Java Code Examples for com.samskivert.mustache.Mustache#Compiler

@Override
public Mustache.Compiler processCompiler(Mustache.Compiler compiler) {
    Mustache.Escaper SCALA = new Mustache.Escaper() {
        @Override public String escape (String text) {
            // Fix included as suggested by akkie in #6393
            // The given text is a reserved word which is escaped by enclosing it with grave accents. If we would
            // escape that with the default Mustache `HTML` escaper, then the escaper would also escape our grave
            // accents. So we remove the grave accents before the escaping and add it back after the escaping.
            if (text.startsWith("`") && text.endsWith("`")) {
                String unescaped =  text.substring(1, text.length() - 1);
                return "`" + Escapers.HTML.escape(unescaped) + "`";
            }

            // All none reserved words will be escaped with the default Mustache `HTML` escaper
            return Escapers.HTML.escape(text);
        }
    };

    return compiler.withEscaper(SCALA);
}
 

private File processTemplateToFile(Map<String, Object> templateData, String templateName, String outputFilename) throws IOException {
    String adjustedOutputFilename = outputFilename.replaceAll("//", "/").replace('/', File.separatorChar);
    if (ignoreProcessor.allowsFile(new File(adjustedOutputFilename))) {
        String templateFile = getFullTemplateFile(config, templateName);
        String template = readTemplate(templateFile);
        Mustache.Compiler compiler = Mustache.compiler();
        compiler = config.processCompiler(compiler);
        Template tmpl = compiler
                .withLoader(new Mustache.TemplateLoader() {
                    @Override
                    public Reader getTemplate(String name) {
                        return getTemplateReader(getFullTemplateFile(config, name + ".mustache"));
                    }
                })
                .defaultValue("")
                .compile(template);

        writeToFile(adjustedOutputFilename, tmpl.execute(templateData));
        return new File(adjustedOutputFilename);
    }

    LOGGER.info("Skipped generation of " + adjustedOutputFilename + " due to rule in .swagger-codegen-ignore");
    return null;
}
 

@Override
public Mustache.Compiler processCompiler(Mustache.Compiler compiler) {
    Mustache.Escaper SCALA = new Mustache.Escaper() {
        @Override
        public String escape(String text) {
            // Fix included as suggested by akkie in #6393
            // The given text is a reserved word which is escaped by enclosing it with grave accents. If we would
            // escape that with the default Mustache `HTML` escaper, then the escaper would also escape our grave
            // accents. So we remove the grave accents before the escaping and add it back after the escaping.
            if (text.startsWith("`") && text.endsWith("`")) {
                String unescaped = text.substring(1, text.length() - 1);
                return "`" + Escapers.HTML.escape(unescaped) + "`";
            }

            // All none reserved words will be escaped with the default Mustache `HTML` escaper
            return Escapers.HTML.escape(text);
        }
    };

    return compiler.withEscaper(SCALA);
}
 

@Bean
public Mustache.Compiler mustacheCompiler(Mustache.TemplateLoader templateLoader, Environment environment) {

    MustacheEnvironmentCollector collector = new MustacheEnvironmentCollector();
    collector.setEnvironment(environment);

    return Mustache.compiler()
      .defaultValue("Some Default Value")
      .withLoader(templateLoader)
      .withCollector(collector);

}
 

private static Mustache.Compiler getCompiler() {
    Mustache.Compiler compiler = Mustache.compiler();
    compiler.escapeHTML(false);
    compiler.withDelims("{{ }}");
    return compiler;
}
 

private String renderTemplate(Map<String, Object> templateData, String templateLocation) throws IOException {
  String templateString = readResourceInClasspath(templateLocation);
  Mustache.Compiler compiler = Mustache.compiler();
  Template tmpl = compiler.compile(templateString);
  return tmpl.execute(templateData);
}
 

private static Mustache.Compiler mustacheCompiler() {
    return Mustache.compiler().withLoader(mustacheTemplateLoader());
}
 

public TemplateRenderer(Mustache.Compiler mustache) {
    this.mustache = mustache;
}
 

protected void test(Mustache.Compiler compiler, String expected,String template, Map<String, Object> ctx) {
    assertEquals(execute(compiler, template, ctx), expected);
}
 

protected String execute(Mustache.Compiler compiler, String template, Object ctx) {
    return compiler.compile(template).execute(ctx);
}
 

@Override
public View getView(String viewName, final ResourceLoader resourceLoader) throws Exception {
	String filename = filename(viewName);

	byte[] bytes = resourceLoader.load(filename);
	if (bytes == null) return null;

	Mustache.TemplateLoader loader = loader(resourceLoader);

	String template = new String(bytes);

	Mustache.Compiler compiler = getViewFactory(resourceLoader);

	Template mustache = compiler.withLoader(loader).compile(template);

	return view(mustache);
}
 

public Mustache.Compiler getCompiler() {
    return compiler;
}
 

@Override
protected Mustache.Compiler createViewFactory(ResourceLoader templateLoader) {
	return Mustache.compiler().withLoader(loader(templateLoader));
}
 

@Bean
public Mustache.Compiler mustacheCompiler() {
	return Mustache.compiler();
}
 

@Override
public Mustache.Compiler processCompiler(Mustache.Compiler compiler) {
    // To avoid unexpected behaviors when options are passed programmatically such as { "supportsAsync": "" }
    return super.processCompiler(compiler).emptyStringIsFalse(true);
}
 

@Override
public Mustache.Compiler processCompiler(Mustache.Compiler compiler) {
    // To avoid unexpected behaviors when options are passed programmatically such as { "useCollection": "" }
    return super.processCompiler(compiler).emptyStringIsFalse(true);
}
 

@Override
public Mustache.Compiler processCompiler(Mustache.Compiler compiler) {
    // To avoid unexpected behaviors when options are passed programmatically such as { "supportsAsync": "" }
    return super.processCompiler(compiler).emptyStringIsFalse(true);
}
 

/**
 * Override the Mustache compiler configuration.
 * <p>
 * We don't want to have special characters escaped
 *
 * @param compiler the compiler.
 * @return the compiler to use.
 */
@Override
public Mustache.Compiler processCompiler(Mustache.Compiler compiler) {
    compiler = super.processCompiler(compiler).emptyStringIsFalse(true);

    return compiler.withEscaper(Escapers.NONE);
}
 

/**
 * Override the Mustache compiler configuration.
 *
 * We don't want to have special characters escaped
 *
 * @param compiler the compiler.
 * @return the compiler to use.
 */
@Override
public Mustache.Compiler processCompiler(Mustache.Compiler compiler) {
    compiler = super.processCompiler(compiler).emptyStringIsFalse(true);

    return compiler.withEscaper(Escapers.NONE);
}
 

/**
 * Configure Mustache compiler to return empty string for null values.
 *
 * @return customized Mustache compiler
 */
@Bean
Mustache.Compiler getMustache() {
    return Mustache.compiler().nullValue("");
}