Java MustacheEngine.compileMustache方法代码示例

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testOutOfBoundIndexException()
        throws JsonIOException, JsonSyntaxException, FileNotFoundException {
    // https://github.com/trimou/trimou/issues/73
    String json = "{\"numbers\": [1,2]}";
    String template = "One of users is {{numbers.2}}.";
    final JsonElement jsonElement = new JsonParser().parse(json);
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .setMissingValueHandler(
                    new ThrowingExceptionMissingValueHandler())
            .omitServiceLoaderConfigurationExtensions()
            .setProperty(JsonElementResolver.UNWRAP_JSON_PRIMITIVE_KEY,
                    true)
            .setProperty(GsonValueConverter.ENABLED_KEY, false)
            .addResolver(new ThisResolver()).addResolver(new MapResolver())
            .addResolver(new JsonElementResolver()).build();
    final Mustache mustache = engine.compileMustache("unwrap_array_index",
            template);
    MustacheExceptionAssert.expect(MustacheProblem.RENDER_NO_VALUE)
            .check(() -> mustache.render(jsonElement));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testOutOfBoundIndexException() throws FileNotFoundException {
    // https://github.com/trimou/trimou/issues/73
    String json = "{\"numbers\": [1,2]}";
    String template = "One of users is {{numbers.2}}.";
    JsonStructure jsonStructure = Json.createReader(new StringReader(json))
            .read();
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .setMissingValueHandler(
                    new ThrowingExceptionMissingValueHandler())
            .omitServiceLoaderConfigurationExtensions()
            .setProperty(JsonValueResolver.ENABLED_KEY, true)
            .setProperty(JsonProcessingValueConverter.ENABLED_KEY, false)
            .addResolver(new ThisResolver()).addResolver(new MapResolver())
            .addResolver(new JsonValueResolver()).build();
    final Mustache mustache = engine.compileMustache("unwrap_array_index",
            template);
    MustacheExceptionAssert.expect(MustacheProblem.RENDER_NO_VALUE)
            .check(() -> mustache.render(jsonStructure));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testHelperConfiguration() throws InterruptedException {
    final MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .setProperty(CacheHelper.FRAGMENT_CACHE_MAX_SIZE_KEY, 0)
            .registerHelpers(HelpersBuilder.empty().addCache().build())
            .build();
    Hammer hammer1 = new Hammer(1);
    Hammer hammer2 = new Hammer(2);
    Hammer hammer3 = new Hammer(3);
    Mustache mustache = engine.compileMustache("cache_config_01",
            "{{#cache key=this.id}}{{this.age}}{{/cache}}");
    assertEquals("1", mustache.render(hammer1));
    assertEquals("2", mustache.render(hammer2));
    assertEquals("3", mustache.render(hammer3));
    hammer1.setAge(11);
    hammer2.setAge(22);
    hammer3.setAge(33);
    assertEquals("11", mustache.render(hammer1));
    assertEquals("22", mustache.render(hammer2));
    assertEquals("33", mustache.render(hammer3));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testConverter() {
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addValueConverter(new GsonValueConverter())
            .setProperty(EngineConfigurationKey.SKIP_VALUE_ESCAPING, true)
            .setProperty(JsonElementResolver.UNWRAP_JSON_PRIMITIVE_KEY,
                    true)
            .setProperty(GsonValueConverter.ENABLED_KEY, true).build();
    Mustache mustache = engine.compileMustache("converter_test",
            "{{#this}}{{.}}{{/this}}");
    assertEquals("1true",
            mustache.render(new JsonParser().parse("[\"1\",true,null]")));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testUnwrapJsonPrimitiveSetToFalse() {
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addValueConverter(new GsonValueConverter())
            .setProperty(EngineConfigurationKey.SKIP_VALUE_ESCAPING, true)
            .setProperty(JsonElementResolver.UNWRAP_JSON_PRIMITIVE_KEY,
                    false)
            .setProperty(GsonValueConverter.ENABLED_KEY, false).build();
    Mustache mustache = engine.compileMustache(
            "converter_unwrap_primitive_disabled_test",
            "{{#this}}{{.}}{{/this}}");
    assertEquals("\"1\"truenull",
            mustache.render(new JsonParser().parse("[\"1\",true,null]")));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testUnwrapJsonPrimitiveSetToFalse()
        throws JsonIOException, JsonSyntaxException, FileNotFoundException {

    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .omitServiceLoaderConfigurationExtensions()
            .addResolver(new JsonElementResolver())
            .addResolver(new ReflectionResolver())
            .setProperty(JsonElementResolver.UNWRAP_JSON_PRIMITIVE_KEY,
                    false)
            .setProperty(GsonValueConverter.ENABLED_KEY, false)
            .build();
    Mustache mustache = engine.compileMustache(
            "json_element_unwrap_primitive_disabled_test",
            "{{firstName.asString.length}}|{{phoneNumbers.1.type.asString.toUpperCase}}");
    assertEquals("3|MOBILE", mustache.render(loadJsonData()));

    // Test together with converter
    engine = MustacheEngineBuilder.newBuilder()
            .omitServiceLoaderConfigurationExtensions()
            .addResolver(new ReflectionResolver())
            .addResolver(new JsonElementResolver())
            .addValueConverter(new GsonValueConverter())
            .setProperty(JsonElementResolver.UNWRAP_JSON_PRIMITIVE_KEY,
                    false)
            .setProperty(GsonValueConverter.ENABLED_KEY, true).build();
    mustache = engine.compileMustache(
            "json_element_unwrap_primitive_disabled_test2",
            "{{firstName}}|{{phoneNumbers.1.type}}|{{phoneNumbers.1.type.getAsString.toUpperCase}}");
    assertEquals("Jan|mobile|MOBILE", mustache.render(loadJsonData()));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testUnwrapJsonArrayElementAtIndex()
        throws JsonIOException, JsonSyntaxException, FileNotFoundException {
    // https://github.com/trimou/trimou/issues/26
    String json = "{\"users\": [\"izeye\", \"always19\"]}";
    String template = "One of users is {{users.0}}.";
    JsonElement jsonElement = new JsonParser().parse(json);
    MustacheEngine engine = getEngine();
    Mustache mustache = engine.compileMustache("unwrap_array_index",
            template);
    assertEquals("One of users is izeye.", mustache.render(jsonElement));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void viewResolves() throws Exception {
    final MustacheEngine engine = MustacheEngineBuilder.newBuilder().build();
    final TrimouView view = new TrimouView(engine.compileMustache("hello", "Hello {{msg}}"));
    view.setApplicationContext(context);
    view.render(Collections.singletonMap("msg", "world!"), request, response);
    assertThat(response.getContentAsString(), is("Hello world!"));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testConverter() {
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addValueConverter(new JsonProcessingValueConverter())
            .setProperty(EngineConfigurationKey.SKIP_VALUE_ESCAPING, true)
            .setProperty(JsonValueResolver.ENABLED_KEY, false)
            .setProperty(JsonProcessingValueConverter.ENABLED_KEY, true)
            .build();
    Mustache mustache = engine.compileMustache("converter_test",
            "{{#this}}{{.}}{{/this}}");
    assertEquals("1true", mustache.render(Json
            .createReader(new StringReader("[\"1\",true,null]")).read()));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testUnwrapJsonPrimitiveSetToFalse() {
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addValueConverter(new JsonProcessingValueConverter())
            .setProperty(EngineConfigurationKey.SKIP_VALUE_ESCAPING, true)
            .setProperty(JsonValueResolver.ENABLED_KEY, false)
            .setProperty(JsonProcessingValueConverter.ENABLED_KEY, false)
            .build();
    Mustache mustache = engine.compileMustache(
            "converter_unwrap_primitive_disabled_test",
            "{{#this}}{{.}}{{/this}}");
    assertEquals("\"1\"truenull", mustache.render(Json
            .createReader(new StringReader("[\"1\",true,null]")).read()));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testUnwrapJsonArrayElementAtIndex()
        throws FileNotFoundException {
    // https://github.com/trimou/trimou/issues/26
    String json = "{\"users\": [\"izeye\", \"always19\"]}";
    String template = "One of users is {{users.0}}.";
    JsonStructure jsonStructure = Json.createReader(new StringReader(json))
            .read();
    MustacheEngine engine = getEngine();
    Mustache mustache = engine.compileMustache("unwrap_array_index",
            template);
    assertEquals("One of users is izeye.", mustache.render(jsonStructure));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testPreservePattern() {

    String template = "<html><body>{{ <!--foo--> }}</body>     </html>";

    MustacheEngine engine = MustacheEngineBuilder
            .newBuilder()
            .addMustacheListener(Minify.htmlListener())
            .setProperty(EngineConfigurationKey.HANDLEBARS_SUPPORT_ENABLED,
                    false).build();
    assertEquals(
            "<html><body>FOO</body> </html>",
            engine.compileMustache("minify_html_preserve_pattern", template)
                    .render(ImmutableMap.<String, Object> of("<!--foo-->",
                            "FOO")));

    engine = MustacheEngineBuilder
            .newBuilder()
            .addMustacheListener(
                    Minify.customListener(new HtmlCompressorMinifier() {

                        @Override
                        public void init(Configuration configuration) {
                            // No custom preserve pattern
                        }
                    })).build();
    try {
        engine.compileMustache("minify_html_preserve_pattern", template);
        fail("Compilation should fail!");
    } catch (MustacheException e) {
        if (!MustacheProblem.COMPILE_INVALID_TAG.equals(e.getCode())) {
            fail("Unexpected problem code: " + e.getCode());
        }
    }
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testLifecycle() {
    MustacheEngine engine = MustacheEngineBuilder.newBuilder().build();
    Mustache mustache = engine.compileMustache("cdi_rendering_context_weld_se", "{{renderingScopedBean.id}}");
    String id1 = mustache.render(null);
    assertTrue(RenderingScopedBean.DESTROYED.get());
    assertNotEquals(id1, mustache.render(null));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testCustomELProcessorFactoryClazz() {
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .setProperty(ELProcessorFactory.EL_PROCESSOR_FACTORY_KEY, CustomELProcessorFactory.class.getName())
            .build();
    CustomELProcessorFactory.value = 10;
    Mustache mustache = engine.compileMustache("elpfcustom_02", "{{el 'foo'}}");
    assertEquals("10", mustache.render(null));
    assertEquals("10", mustache.render(null));
}
 

import org.trimou.engine.MustacheEngine; //导入方法依赖的package包/类
@Test
public void testStreamIteration() {
    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .registerHelpers(HelpersBuilder.empty().addRepeat().build()).build();
    List<String> data = ImmutableList.of("foo", "baz", "foos");
    Mustache mustache = engine.compileMustache("stream",
            "{{#with this.sequential.iterator}}{{#repeat while=hasNext}}{{next}}/{{/repeat}}{{/with}}");
    assertEquals("foo/baz/", mustache.render(data.stream().filter((e) -> e.toString().length() == 3)));
}