import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
/**
 * Constructs a template engine with some additional helpers and lambdas for HTML generation.
 */
public MustacheEngine getEngine() {
    if (engine == null) {
        ClassPathTemplateLocator genericLocator = new ClassPathTemplateLocator(PRIO_CLASS_PATH,
            TEMPLATE_PATH, TEMPLATE_SUFFIX);
        MustacheEngineBuilder builder = MustacheEngineBuilder.newBuilder()
            .setProperty(EngineConfigurationKey.DEFAULT_FILE_ENCODING,
                StandardCharsets.UTF_8.name())
            .addTemplateLocator(genericLocator)
            .registerHelper(ExampleHelper.NAME, new ExampleHelper())
            .registerHelper(TypeLinkHelper.NAME, new TypeLinkHelper())
            .registerHelpers(HelpersBuilder.builtin().addInclude().addInvoke().addSet()
                .addSwitch().addWith().build())
            .addGlobalData(MarkdownLambda.NAME, new MarkdownLambda())
            .addGlobalData(UpperCaseLambda.NAME, new UpperCaseLambda());
        if (templateDir != null) {
            builder.addTemplateLocator(
                new FileSystemTemplateLocator(PRIO_FILE_SYSTEM, templateDir, TEMPLATE_SUFFIX));
        }
        engine = builder.build();
    }
    return engine;
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
/**
 * Constructs a template engine with some additional helpers and lambdas for Typescript
 * generation.
 */
public MustacheEngine getEngine() {
    if (engine == null) {
        ClassPathTemplateLocator genericLocator = new ClassPathTemplateLocator(PRIO_CLASS_PATH,
            TEMPLATE_PATH, TEMPLATE_SUFFIX);
        MustacheEngineBuilder builder = MustacheEngineBuilder.newBuilder()
            .setProperty(EngineConfigurationKey.DEFAULT_FILE_ENCODING,
                StandardCharsets.UTF_8.name())
            .addTemplateLocator(genericLocator);
        if (templateDir != null) {
            builder.addTemplateLocator(
                new FileSystemTemplateLocator(PRIO_FILE_SYSTEM, templateDir, TEMPLATE_SUFFIX));
        }
        engine = builder.build();
    }
    return engine;
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
  super.init(processingEnv);
  types = processingEnv.getTypeUtils();
  elements = processingEnv.getElementUtils();
  filer = processingEnv.getFiler();
  messager = processingEnv.getMessager();

  engine = MustacheEngineBuilder
      .newBuilder()
      .addResolver(new MapResolver())
      .addResolver(new ReflectionResolver())
      .setProperty(EngineConfigurationKey.DEFAULT_FILE_ENCODING, StandardCharsets.UTF_8.name())
      .addTemplateLocator(ClassPathTemplateLocator.builder(1)
                              .setClassLoader(this.getClass().getClassLoader())
                              .setSuffix("mustache").build())
      .build();

  messager.printMessage(NOTE, ApiGeneratorProcessor.class.getSimpleName() + " loaded");
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@Setup
public void setup() {
    template = MustacheEngineBuilder.newBuilder()
            // Disable HTML escaping
            .setProperty(EngineConfigurationKey.SKIP_VALUE_ESCAPING, true)
            // Disable useless resolver
            .setProperty(CombinedIndexResolver.ENABLED_KEY, false)
            .addTemplateLocator(ClassPathTemplateLocator.builder(1).setRootPath("templates").setScanClasspath(false).setSuffix("trimou.html").build())
            .registerHelpers(HelpersBuilder.extra().build())
            // This is a single purpose helper
            // It's a pity we can't use JDK8 extension and SimpleHelpers util class
            .registerHelper("minusClass", new BasicValueHelper() {
                @Override
                public void execute(Options options) {
                    Object value = options.getParameters().get(0);
                    if (value instanceof Double && (Double) value < 0) {
                        options.append(" class=\"minus\"");
                    }
                    // We don't handle any other number types
                }
            }).build().getMustache("stocks");
    this.context = getContext();
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@Test
public void testEncoding() {

    TemplateLocator locator = new ServletContextTemplateLocator(10,
            "/templates", "html");

    MustacheEngine engine = MustacheEngineBuilder.newBuilder()
            .addTemplateLocator(locator)
            .setProperty(EngineConfigurationKey.DEFAULT_FILE_ENCODING,
                    "windows-1250")
            .build();

    Mustache encoding = engine.getMustache("encoding");
    assertNotNull(encoding);
    assertEquals("Hurá ěščřřžžýá!", encoding.render(null));
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@ApplicationScoped
@Produces
public MustacheEngine produceMustacheEngine(
        SimpleStatsCollector simpleStatsCollector) {
    // 1. CDI and servlet resolvers are registered automatically
    // 2. Precompile all available templates
    // 3. Do not escape values
    // 4. PrettyTimeHelper is registered automatically
    // 5. Register extra helpers (set, isOdd, ...)
    // 6. ServletContextTemplateLocator is most suitable for webapps
    // 7. The current locale will be based on the Accept-Language header
    // 8. Minify all the templates
    // 9. Collect some basic rendering statistics
    return MustacheEngineBuilder.newBuilder()
            .setProperty(EngineConfigurationKey.PRECOMPILE_ALL_TEMPLATES,
                    true)
            .setProperty(EngineConfigurationKey.SKIP_VALUE_ESCAPING, true)
            .registerHelpers(HelpersBuilder.extra()
                    .add("format", new DateTimeFormatHelper()).build())
            .addTemplateLocator(ServletContextTemplateLocator.builder()
                    .setRootPath("/WEB-INF/templates").setSuffix("html")
                    .build())
            .setLocaleSupport(new RequestLocaleSupport())
            .addMustacheListener(Minify.htmlListener())
            .addMustacheListener(simpleStatsCollector).build();
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
/**
 * Apply the {@link TrimouProperties} to a {@link MustacheEngineBuilder}.
 *
 * @param engineBuilder the Trimou mustache engine builder to apply the properties to
 */
public void applyToTrimouMustacheEngineBuilder(final MustacheEngineBuilder engineBuilder) {
    engineBuilder
            .setProperty(EngineConfigurationKey.START_DELIMITER, getStartDelimiter())
            .setProperty(EngineConfigurationKey.END_DELIMITER, getEndDelimiter())
            .setProperty(EngineConfigurationKey.PRECOMPILE_ALL_TEMPLATES, isPrecompileTemplates())
            .setProperty(EngineConfigurationKey.REMOVE_STANDALONE_LINES, isRemoveStandaloneLines())
            .setProperty(EngineConfigurationKey.REMOVE_UNNECESSARY_SEGMENTS, isRemoveUnnecessarySegments())
            .setProperty(EngineConfigurationKey.DEBUG_MODE, isDebugMode())
            .setProperty(EngineConfigurationKey.CACHE_SECTION_LITERAL_BLOCK, isCacheSectionLiteralBlock())
            .setProperty(EngineConfigurationKey.TEMPLATE_RECURSIVE_INVOCATION_LIMIT,
                    getTemplateRecursiveInvocationLimit())
            .setProperty(EngineConfigurationKey.SKIP_VALUE_ESCAPING, isSkipValueEscaping())
            .setProperty(EngineConfigurationKey.DEFAULT_FILE_ENCODING, getCharset().name())
            .setProperty(EngineConfigurationKey.TEMPLATE_CACHE_ENABLED, isCache())
            .setProperty(EngineConfigurationKey.TEMPLATE_CACHE_EXPIRATION_TIMEOUT,
                    getTemplateCacheExpirationTimeout())
            .setProperty(EngineConfigurationKey.HANDLEBARS_SUPPORT_ENABLED, isEnableHelper())
            .setProperty(EngineConfigurationKey.REUSE_LINE_SEPARATOR_SEGMENTS, isReuseLineSeparatorSegments())
            .setProperty(EngineConfigurationKey.ITERATION_METADATA_ALIAS, getIterationMetadataAlias())
            .setProperty(EngineConfigurationKey.RESOLVER_HINTS_ENABLED, isEnableResolverHints())
            .setProperty(EngineConfigurationKey.NESTED_TEMPLATE_SUPPORT_ENABLED, isEnableNestedTemplates())
            .setProperty(EngineConfigurationKey.TEMPLATE_CACHE_USED_FOR_SOURCE, isCacheTemplateSources());
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@Test
public void cacheDisabled() throws Exception {
    resolver.setEngine(MustacheEngineBuilder.newBuilder()
            .setProperty(EngineConfigurationKey.TEMPLATE_CACHE_ENABLED, false)
            .setProperty(EngineConfigurationKey.DEBUG_MODE, false)
            .build());
    assertThat(resolver.isCache(), is(false));
    resolver.setEngine(MustacheEngineBuilder.newBuilder()
            .setProperty(EngineConfigurationKey.TEMPLATE_CACHE_ENABLED, true)
            .setProperty(EngineConfigurationKey.DEBUG_MODE, true)
            .build());
    assertThat(resolver.isCache(), is(false));
    resolver.setEngine(MustacheEngineBuilder.newBuilder()
            .setProperty(EngineConfigurationKey.TEMPLATE_CACHE_ENABLED, false)
            .setProperty(EngineConfigurationKey.DEBUG_MODE, true)
            .build());
    assertThat(resolver.isCache(), is(false));
    resolver.setEngine(MustacheEngineBuilder.newBuilder()
            .setProperty(EngineConfigurationKey.TEMPLATE_CACHE_ENABLED, true)
            .setProperty(EngineConfigurationKey.DEBUG_MODE, false)
            .build());
    assertThat(resolver.isCache(), is(true));
    resolver.setCacheLimit(0);
    assertThat(resolver.isCache(), is(false));
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {
    engine = MustacheEngineBuilder.newBuilder()
            .setProperty(EngineConfigurationKey.TEMPLATE_CACHE_ENABLED,
                    isCache())
            .setProperty(
                    EngineConfigurationKey.TEMPLATE_CACHE_EXPIRATION_TIMEOUT,
                    getCacheExpiration())
            .setProperty(EngineConfigurationKey.DEFAULT_FILE_ENCODING,
                    getFileEncoding())
            .setProperty(EngineConfigurationKey.HANDLEBARS_SUPPORT_ENABLED,
                    isHandlebarsSupport())
            .setProperty(EngineConfigurationKey.DEBUG_MODE, isDebug())
            .setProperty(EngineConfigurationKey.PRECOMPILE_ALL_TEMPLATES,
                    isPreCompile())
            .registerHelpers(helpers)
            .addTemplateLocator(ServletContextTemplateLocator.builder()
                    .setPriority(1).setRootPath(getPrefix())
                    .setSuffix(getSuffixWithoutSeparator())
                    .setServletContext(getServletContext()).build())
            .build();
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@Override
public void startTemplate(String name, Delimiters delimiters,
        MustacheEngine engine) {

    this.delimiters = delimiters;
    this.engine = engine;
    this.templateName = name;

    containerStack.addFirst(new RootSegmentBase());

    skipValueEscaping = engine.getConfiguration().getBooleanPropertyValue(
            EngineConfigurationKey.SKIP_VALUE_ESCAPING);
    handlebarsSupportEnabled = engine.getConfiguration()
            .getBooleanPropertyValue(
                    EngineConfigurationKey.HANDLEBARS_SUPPORT_ENABLED);

    start = System.currentTimeMillis();
    LOGGER.debug("Start compilation of {}", new Object[] { name });
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
/**
 * Identify the tag type (variable, comment, etc.).
 *
 * @param buffer
 * @param delimiters
 * @return the tag type
 */
private MustacheTagType identifyTagType(String buffer) {

    if (buffer.length() == 0) {
        return MustacheTagType.VARIABLE;
    }

    // Triple mustache is supported for default delimiters only
    if (delimiters.hasDefaultDelimitersSet()
            && buffer.charAt(0) == ((String) EngineConfigurationKey.START_DELIMITER
                    .getDefaultValue()).charAt(0)
            && buffer.charAt(buffer.length() - 1) == ((String) EngineConfigurationKey.END_DELIMITER
                    .getDefaultValue()).charAt(0)) {
        return MustacheTagType.UNESCAPE_VARIABLE;
    }

    Character command = buffer.charAt(0);

    for (MustacheTagType type : MustacheTagType.values()) {
        if (command.equals(type.getCommand())) {
            return type;
        }
    }
    return MustacheTagType.VARIABLE;
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
/**
 * Extract the tag content.
 *
 * @param buffer
 * @return
 */
private String extractContent(MustacheTagType tagType, String buffer) {

    switch (tagType) {
    case VARIABLE:
        return buffer.trim();
    case UNESCAPE_VARIABLE:
        return (buffer.charAt(0) == ((String) EngineConfigurationKey.START_DELIMITER
                .getDefaultValue()).charAt(0) ? buffer.substring(1,
                buffer.length() - 1).trim() : buffer.substring(1).trim());
    case SECTION:
    case INVERTED_SECTION:
    case PARTIAL:
    case EXTEND:
    case EXTEND_SECTION:
    case SECTION_END:
    case NESTED_TEMPLATE:
    case COMMENT:
        return buffer.substring(1).trim();
    case DELIMITER:
        return buffer.trim();
    default:
        return null;
    }
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
private <K, V> ComputingCache<K, V> buildCache(String name,
        ComputingCache.Function<K, V> loader,
        ComputingCache.Listener<K> listener) {

    Long expirationTimeout = configuration.getLongPropertyValue(
            EngineConfigurationKey.TEMPLATE_CACHE_EXPIRATION_TIMEOUT);

    if (expirationTimeout > 0) {
        LOGGER.info("{} cache expiration timeout set: {} seconds", name, expirationTimeout);
        expirationTimeout = expirationTimeout * 1000L;
    } else {
        expirationTimeout = null;
    }
    return configuration.getComputingCacheFactory().create(
            MustacheEngine.COMPUTING_CACHE_CONSUMER_ID, loader,
            expirationTimeout, null, listener);
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
/**
 *
 * @param text
 * @param origin
 * @param segments
 */
public SectionSegment(String text, Origin origin, List<Segment> segments) {
    super(text, origin, segments);
    this.helperHandler = isHandlebarsSupportEnabled()
            ? HelperExecutionHandler.from(text, getEngine(), this) : null;

    if (helperHandler == null) {
        this.iterationMetaAlias = getEngineConfiguration()
                .getStringPropertyValue(
                        EngineConfigurationKey.ITERATION_METADATA_ALIAS);
        this.provider = new ValueProvider(text, getEngineConfiguration());
    } else {
        this.iterationMetaAlias = null;
        this.provider = null;
    }
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
/**
 *
 * @param text
 * @param configuration
 */
ValueProvider(String text, Configuration configuration) {
    this.key = text;
    ArrayList<String> parts = new ArrayList<>();
    for (Iterator<String> iterator = configuration.getKeySplitter()
            .split(text); iterator.hasNext();) {
        parts.add(iterator.next());
    }
    this.keyParts = parts.toArray(new String[parts.size()]);
    if (configuration.getBooleanPropertyValue(
            EngineConfigurationKey.RESOLVER_HINTS_ENABLED)) {
        this.hint = new AtomicReference<>();
    } else {
        this.hint = null;
    }
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@Test
public void testRecursiveInvocationLimitExceeded() {

    MapTemplateLocator locator = new MapTemplateLocator(ImmutableMap.of(
            "super", "/n{{<super}}{{/super}}"));
    MustacheEngine engine = MustacheEngineBuilder
            .newBuilder()
            .addTemplateLocator(locator)
            .setProperty(
                    EngineConfigurationKey.TEMPLATE_RECURSIVE_INVOCATION_LIMIT,
                    5).build();

    try {
        engine.getMustache("super").render(null);
        fail("Limit exceeded and no exception thrown");
    } catch (MustacheException e) {
        if (!e.getCode()
                .equals(MustacheProblem.RENDER_TEMPLATE_INVOCATION_RECURSIVE_LIMIT_EXCEEDED)) {
            fail("Invalid problem");
        }
        System.out.println(e.getMessage());
        // else {
        // e.printStackTrace();
        // }
    }
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@Before
public void buildEngine() {
    textParam = null;

    MapTemplateLocator locator = new MapTemplateLocator(ImmutableMap.of(
            "partial", "{{! No content}}", "super",
            "{{$extendMe}}Hello{{/extendMe}}"));

    engine = MustacheEngineBuilder
            .newBuilder()
            .addGlobalData("foo", foo)
            .addTemplateLocator(locator)
            .setProperty(
                    EngineConfigurationKey.REMOVE_UNNECESSARY_SEGMENTS,
                    false).build();
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@Test
public void testTemplateInvocationsStack() {
    // See also bug #42
    String partial = "!";
    StringBuilder template = new StringBuilder();
    StringBuilder result = new StringBuilder();
    int loop = 2 * Integer
            .valueOf(EngineConfigurationKey.TEMPLATE_RECURSIVE_INVOCATION_LIMIT
                    .getDefaultValue().toString());
    for (int i = 0; i < loop; i++) {
        template.append("{{> partial}}");
        result.append(partial);
    }
    MustacheEngine engine = MustacheEngineBuilder
            .newBuilder()
            .addTemplateLocator(
                    new MapTemplateLocator(ImmutableMap.of("template",
                            template.toString(), "partial",
                            partial.toString()))).build();
    assertEquals(result.toString(),
            engine.getMustache("template").render(null));
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@SuppressWarnings("deprecation")
// EngineConfigurationKey.NO_VALUE_INDICATES_PROBLEM used intentionally to
// test backwards compatibility
@Test
public void testNoValueProblem() {
    try {
        MustacheEngineBuilder
                .newBuilder()
                .setProperty(
                        EngineConfigurationKey.NO_VALUE_INDICATES_PROBLEM,
                        true).build()
                .compileMustache("value_segment_problem", "{{foo}}")
                .render(null);
    } catch (MustacheException e) {
        if (!e.getCode().equals(MustacheProblem.RENDER_NO_VALUE)) {
            fail("Invalid problem");
        }
        System.out.println(e.getMessage());
    }
}
 

import org.trimou.engine.config.EngineConfigurationKey; //导入依赖的package包/类
@Test
public void testValueEscaping() {
    String shouldBeEscaped = "<&>";
    assertEquals(
            "&lt;&amp;&gt;",
            MustacheEngineBuilder
                    .newBuilder()
                    .build()
                    .compileMustache("value_escaping", "{{foo}}")
                    .render(ImmutableMap.<String, Object> of("foo",
                            shouldBeEscaped)));
    assertEquals(
            shouldBeEscaped,
            MustacheEngineBuilder
                    .newBuilder()
                    .setProperty(
                            EngineConfigurationKey.SKIP_VALUE_ESCAPING,
                            true)
                    .build()
                    .compileMustache("skip_value_escaping", "{{foo}}")
                    .render(ImmutableMap.<String, Object> of("foo",
                            shouldBeEscaped)));
}