com.github.mustachejava.Mustache Java Examples

public Template createTemplate(String template) {
    if (template == null) {
        throw new SawmillException("template cannot be with null value");
    }

    boolean containsMustache = template.contains("{{") && template.contains("}}");
    if (!containsMustache) {
        return new StringTemplate(template);
    }

    Mustache mustache = template.contains(JSON_STRING_SUFFIX) ?
                jsonStringMustacheFactory.compile(new StringReader(template.replaceAll(JSON_STRING_SUFFIX, "")), "") :
                mustacheFactory.compile(new StringReader(template), "");

    return new MustacheTemplate(mustache);
}
 

/**
 * At compile time, this function extracts the name of the variable:
 * {{#toJson}}variable_name{{/toJson}}
 */
protected static String extractVariableName(String fn, Mustache mustache, TemplateContext tc) {
    Code[] codes = mustache.getCodes();
    if (codes == null || codes.length != 1) {
        throw new MustacheException("Mustache function [" + fn + "] must contain one and only one identifier");
    }

    try (StringWriter capture = new StringWriter()) {
        // Variable name is in plain text and has type WriteCode
        if (codes[0] instanceof WriteCode) {
            codes[0].execute(capture, Collections.emptyList());
            return capture.toString();
        } else {
            codes[0].identity(capture);
            return capture.toString();
        }
    } catch (IOException e) {
        throw new MustacheException("Exception while parsing mustache function [" + fn + "] at line " + tc.line(), e);
    }
}
 

public static String execute(Mustache template, Map<String, Object> params) {
    final StringWriter writer = new StringWriter();
    try {
        // crazy reflection here
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(SPECIAL_PERMS);
        }
        AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
            template.execute(writer, params);
            return null;
        });
    } catch (Exception e) {
        logger.error((Supplier<?>) () -> new ParameterizedMessage("Error running {}", template), e);
        throw new IllegalArgumentException("Error running " + template, e);
    }
    return writer.toString();

}
 

@Test
public void givenTodoList_whenGetHtml_thenSuccess() throws IOException {
    Mustache m = MustacheUtil.getMustacheFactory().compile("todos.mustache");

    List<Todo> todos = Arrays.asList(
      new Todo("Todo 1", "Todo description"),
      new Todo("Todo 2", "Todo description another"),
      new Todo("Todo 3", "Todo description another")
    );
    Map<String, Object> context = new HashMap<>();
    context.put("todos", todos);

    assertThat(executeTemplate(m, context))
      .contains("<h2>Todo 1</h2>")
      .contains("<h2>Todo 2</h2>")
      .contains("<h2>Todo 3</h2>");
}
 

@Override
public List<Mustache> getTemplates(final String path) {
    // compile the template from the config value and store it in our map
    if (!templates.containsKey(path)) {
        final List<Mustache> temps = Lists.transform(getRawStrings(path), new Function<String, Mustache>() {

            protected int index;

            @Override
            public Mustache apply(String input) {
                return templating.compile(new StringReader(input), path + ".[" + (index++) + "]");
            }
        });

        templates.putAll(path, temps);
    }

    return templates.get(path);
}
 

@Provides
AsyncServlet mainServlet(ContactDAO contactDAO) {
	Mustache contactListView = new DefaultMustacheFactory().compile("static/contactList.html");
	return RoutingServlet.create()
			.map("/", request ->
					HttpResponse.ok200()
							.withBody(applyTemplate(contactListView, map("contacts", contactDAO.list()))))
			.map(POST, "/add", AsyncServletDecorator.loadBody()
					.serve(request -> {
						//[START REGION_3]
						Either<Contact, DecodeErrors> decodedUser = CONTACT_DECODER.decode(request);
						//[END REGION_3]
						if (decodedUser.isLeft()) {
							contactDAO.add(decodedUser.getLeft());
						}
						Map<String, Object> scopes = map("contacts", contactDAO.list());
						if (decodedUser.isRight()) {
							scopes.put("errors", decodedUser.getRight().toMap(SEPARATOR));
						}
						return HttpResponse.ok200()
								.withBody(applyTemplate(contactListView, scopes));
					}));
}
 

/**
 * Get the changelog.
 *
 * @throws GitChangelogRepositoryException
 */
public void render(final Writer writer) throws GitChangelogRepositoryException {
  final MustacheFactory mf = new DefaultMustacheFactory();
  final String templateContent = checkNotNull(getTemplateContent(), "No template!");
  final StringReader reader = new StringReader(templateContent);
  final Mustache mustache = mf.compile(reader, this.settings.getTemplatePath());
  try {
    final boolean useIntegrationIfConfigured = shouldUseIntegrationIfConfigured(templateContent);
    final Changelog changelog = this.getChangelog(useIntegrationIfConfigured);
    mustache
        .execute(
            writer, //
            new Object[] {changelog, this.settings.getExtendedVariables()} //
            )
        .flush();
  } catch (final IOException e) {
    // Should be impossible!
    throw new GitChangelogRepositoryException("", e);
  }
}
 

public static Mustache compile(MustacheFactory mustacheFactory, ProjectGeneratorConfiguration generatorProperties, String template, String name) throws IOException {
    String overridePath = generatorProperties.getTemplates().getOverridePath();
    URL resource = null;

    if (!StringUtils.isEmpty(overridePath)) {
        resource = ProjectGeneratorHelper.class.getResource("templates/" + overridePath + "/" + template);
    }
    if (resource == null) {
        resource = ProjectGeneratorHelper.class.getResource("templates/" + template);
    }
    if (resource == null) {
        throw new IllegalArgumentException(
            String.format("Unable to find te required template (overridePath=%s, template=%s)"
                , overridePath
                , template
            )
        );
    }

    try (InputStream stream = resource.openStream()) {
        return mustacheFactory.compile(new InputStreamReader(stream, StandardCharsets.UTF_8), name);
    }
}
 

@Override
public String serializeAsXml() throws IOException {
    HashMap<String, Object> scopes = new HashMap<>();
    scopes.put("hasAuthorizedAddresses", authorizedAddresses.isPresent());
    authorizedAddresses.ifPresent(value -> scopes.put("authorizedAddresses", value));
    scopes.put("authRequired", authRequired);
    scopes.put("verifyIdentity", verifyIndentity);
    scopes.put("maxmessagesize", maxMessageSizeInKb);
    scopes.put("bracketEnforcement", bracketEnforcement);
    scopes.put("hooks", addittionalHooks);

    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    Writer writer = new OutputStreamWriter(byteArrayOutputStream);
    MustacheFactory mf = new DefaultMustacheFactory();
    Mustache mustache = mf.compile(getPatternReader(), "example");
    mustache.execute(writer, scopes);
    writer.flush();
    return new String(byteArrayOutputStream.toByteArray(), StandardCharsets.UTF_8);
}
 

@Override
public void handleRequest(HttpServerExchange exchange) throws Exception {
    List<Fortune> fortunes = new ArrayList<>();
    try (Connection connection = ds.getConnection();
         PreparedStatement statement = connection.prepareStatement(
                 "SELECT * FROM Fortune",
                 ResultSet.TYPE_FORWARD_ONLY,
                 ResultSet.CONCUR_READ_ONLY);
         ResultSet resultSet = statement.executeQuery()) {
        while (resultSet.next()) {
            fortunes.add(new Fortune(
                    resultSet.getInt("id"),
                    resultSet.getString("message")));
        }
    }
    fortunes.add(new Fortune(0, "Additional fortune added at request time."));
    Collections.sort(fortunes);
    Mustache mustache = mustacheFactory.compile("fortunes.mustache");
    StringWriter writer = new StringWriter();
    mustache.execute(writer, fortunes);
    exchange.getResponseHeaders().put(
            Headers.CONTENT_TYPE, "text/html;charset=utf-8");
    exchange.getResponseSender().send(writer.toString());
}
 

@Test
public void testImportTemplate() throws Exception {

	Map<String, String> vars = new HashMap<>();
	vars.put("name1", "val1");
	vars.put("name2", "val2");
	vars.put("name3", "val3");
	Import impt = new Import( "/", "component1", vars );

	MustacheFactory mf = new DefaultMustacheFactory();
	File templateFile = TestUtils.findTestFile( "/importTemplate.mustache" );
	Mustache mustache = mf.compile( templateFile.getAbsolutePath());
	StringWriter writer = new StringWriter();
	mustache.execute(writer, new ImportBean(impt)).flush();

	String writtenString = writer.toString();
	for( Map.Entry<String,String> entry : vars.entrySet()) {
		Assert.assertTrue("Var was not displayed correctly", writtenString.contains( entry.getKey() + " : " + entry.getValue()));
	}
}
 

@Autowired
StackCommandBuilder(Settings settings, Mustache terraformMustache, List<RegistryOAuth2Provider> registryOAuth2Providers, StateApiSecurityConfig.StateApiSecurityProperties stateApiSecurityProperties) {
    this.settings = settings;
    this.terraformMustache = terraformMustache;
    this.registryOAuth2Providers = registryOAuth2Providers;
    this.stateApiSecurityProperties = stateApiSecurityProperties;
}
 

@Override
public String render(ModelAndView modelAndView) {
    String viewName = modelAndView.getViewName();
    Mustache mustache = mustacheFactory.compile(viewName);
    StringWriter stringWriter = new StringWriter();
    try {
        mustache.execute(stringWriter, modelAndView.getModel()).close();
    } catch (IOException e) {
        throw new RuntimeIOException(e);
    }
    return stringWriter.toString();
}
 

protected String MustacheView (String templateName, Map scopes)
{
    ServletContext context = getServletContext();
    String fullTemplatePath = context.getRealPath("/WEB-INF/"+templateName);

    StringWriter writer = new StringWriter();
    MustacheFactory mf = new DefaultMustacheFactory();
    Mustache mustache = mf.compile(fullTemplatePath);
    mustache.execute(writer, scopes);
    writer.flush();

    return writer.toString();
}
 

protected String Mustache (String template, Map scopes)
{
    StringWriter writer = new StringWriter();
    MustacheFactory mf = new DefaultMustacheFactory();
    Mustache mustache = mf.compile(new StringReader(template), template);
    mustache.execute(writer, scopes);
    writer.flush();

    return writer.toString();
}
 

@Override
public void execute(final Reader input, final Writer output, final String name, final Object parameters) {
    try {
        final Mustache template = MUSTACHE.compile(input, name);
        template.execute(output, parameters);
    }
    catch (MustacheException e) {
        final Throwable cause = Throwables.getRootCause(e);
        Throwables.propagateIfInstanceOf(cause, MissingParameterException.class);
        throw e;
    }
}
 

@Test
public void givenEmptyList_whenGetHtml_thenEmptyHtml() throws IOException {
    Mustache m = MustacheUtil.getMustacheFactory().compile("todos.mustache");

    Map<String, Object> context = new HashMap<>();
    assertThat(executeTemplate(m, context)).isEmpty();
    ;
}
 

@Test
public void givenTodoList_whenGetHtmlUsingLamdba_thenHtml() throws IOException {
    Mustache m = MustacheUtil.getMustacheFactory().compile("todos-lambda.mustache");
    List<Todo> todos = Arrays.asList(
      new Todo("Todo 1", "Todo description"),
      new Todo("Todo 2", "Todo description another"),
      new Todo("Todo 3", "Todo description another")
    );
    todos.get(2).setDone(true);
    todos.get(2).setCompletedOn(Date.from(Instant.now().plusSeconds(300)));

    Map<String, Object> context = new HashMap<>();
    context.put("todos", todos);
    assertThat(executeTemplate(m, context).trim()).contains("Done 5 minutes ago");
}
 

/**
 * Renders template with scope to a file located at outDir + suffix.
 *
 * @param outDir must not end with /
 * @param suffix must start with /
 * @param template
 * @param scope
 */
private static void renderIfOutputEnabled(
    String outDir, String suffix, Mustache template, Object scope) throws IOException {
  assert suffix.charAt(0) == '/';
  if (outDir != null) {
    assert !outDir.endsWith("/");
    String path = outDir + suffix;
    try (BufferedWriter writer = Files.newWriter(new File(path), Charsets.UTF_8)) {
      template.execute(writer, scope);
    }
  }
}
 

@Test
public void compileSuccess() {
  Mustache mustache = Templates.compile("correct.mustache");

  HashMap<String, String> variables = new HashMap<>();
  variables.put("outer_variable", "1");
  variables.put("partial_variable", "2");
  StringWriter writer = new StringWriter();
  mustache.execute(writer, variables);
  assertEquals("outer: 1\npartial: 2\n\n", writer.getBuffer().toString());
}
 

@Override
public List<String> evalTemplates(String path, final Object... context) {
    final List<Mustache> temps = getTemplates(path);

    return Lists.transform(temps, new Function<Mustache, String>() {
        @Override
        public String apply(Mustache input) {
            final StringWriter writer = new StringWriter();
            input.execute(writer, context);

            return writer.getBuffer().toString();
        }
    });
}
 

@Override
public String evalTemplate(String key, Object... context) {
    final Mustache template = getTemplate(key);

    final StringWriter writer = new StringWriter();
    template.execute(writer, context);

    return writer.getBuffer().toString();
}
 

protected View view(final Mustache mustache) {
	return (model, out) -> {
		PrintWriter writer = new PrintWriter(out);
		mustache.execute(writer, model);
		writer.flush();
	};
}
 

@Override
public Mustache getTemplate(String key) {
    // compile the tempalte from the config value and store it in our map
    if (!templates.containsKey(key)) {
        templates.put(key, templating.compile(new StringReader(getRaw(key)), key));
    }

    return Iterables.getFirst(templates.get(key), null);
}
 

private byte[] buildMustacheTemplate(List<Fortune> fortunes) {
  Mustache mustache = mustacheFactory.compile("fortunes.mustache");
  ByteArrayOutputStream bytes = new ByteArrayOutputStream();

  try (Writer writer = new OutputStreamWriter(bytes, StandardCharsets.UTF_8)) {
    mustache.execute(writer, fortunes);
  } catch (IOException e) {
    throw new UncheckedIOException(e);
  }

  return bytes.toByteArray();
}
 

@Test
public void givenEmptyList_whenGetHtmlUsingInvertedSection_thenHtml() throws IOException {
    Mustache m = MustacheUtil.getMustacheFactory().compile("todos-inverted-section.mustache");

    Map<String, Object> context = new HashMap<>();
    assertThat(executeTemplate(m, context).trim()).isEqualTo("<p>No todos!</p>");
}
 

/**
 * Remplace les propriétés entre moustaches par leur valorisation
 * à l'aide du framework Mustache.
 */
public static String replaceMustachePropertiesWithValues(String input, Map<String, Object> scopes) {
    Mustache mustache = AbstractProperty.getMustacheInstanceFromStringContent(input);
    StringWriter stringWriter = new StringWriter();
    mustache.execute(stringWriter, scopes);
    stringWriter.flush();
    return stringWriter.toString();
}
 

@Override
public void generateReport(final List<XmlSuite> xmlSuites, final List<ISuite> suites, final String outputDirectory) {
    try {
        final Mustache mustache = new DefaultMustacheFactory().compile(REPORT_TEMPLATE);
        final File reportsFolder = new File(outputDirectory + "/html");

        reportsFolder.mkdir();

        if (reportsFolder.exists()) {
            mustache.execute(new FileWriter(outputDirectory + "/" + REPORT_OUTPUT), getScope(suites)).flush();
        }
    } catch (Exception e) {
        LOGGER.severe("Can't create template: " + e.getMessage());
    }
}
 

public String html() throws IOException {
    MustacheFactory mf = new DefaultMustacheFactory();
    Mustache mustache = mf.compile(templateFile);
    try (Writer output = new StringWriter()) {
        mustache.execute(output, staxTransformer.getMap());
        output.flush();
        return output.toString();
    }
}
 

/**
 * Render a given model from a given template.
 *
 * @param view  name of the template file in resources/templates directory
 * @param model model to be rendered from the template
 * @return rendered template
 */
@Override
public String render(String view, Object model) {
    Mustache mustache = mustacheFactory.compile(view);
    StringWriter stringWriter = new StringWriter();
    try {
        mustache.execute(stringWriter, model).close();
    } catch (IOException e) {
        throw new RuntimeTemplateException(e);
    }
    return stringWriter.toString();
}