com.github.mustachejava.MustacheException Java Examples

@Setup
public void setup() {
    MustacheFactory mustacheFactory = new DefaultMustacheFactory() {

        @Override
        public void encode(String value, Writer writer) {
            // Disable HTML escaping
            try {
                writer.write(value);
            } catch (IOException e) {
                throw new MustacheException(e);
            }
        }
    };
    template = mustacheFactory.compile("templates/stocks.mustache.html");
}
 

/**
 * 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);
    }
}
 

@Test
public void testApplyMissingExceptionValueThrows() throws IOException {
    Map<String, String> env = new TreeMap<>();
    env.put("foo", "bar");
    env.put("bar", "baz");
    env.put("baz", "foo");
    try {
        TemplateUtils.renderMustacheThrowIfMissing(
                "testTemplate",
                "hello this is {{a_missing_parameter}},\nand {{another_missing_parameter}}. thanks for reading bye",
                env);
        Assert.fail("expected exception");
    } catch (MustacheException e) {
        Assert.assertEquals(String.format(
                "Missing 2 values when rendering testTemplate:%n" +
                "- Missing values: [a_missing_parameter@L1, another_missing_parameter@L2]%n" +
                "- Provided values: %s", env), e.getMessage());
    }
}
 

/**
 * Throws a descriptive exception if {@code missingValues} is non-empty. Exposed as a utility function to allow
 * custom filtering of missing values before the validation occurs.
 */
public static void validateMissingValues(
    String templateName, Map<String, String> values, Collection<MissingValue> missingValues)
    throws MustacheException
{
  if (!missingValues.isEmpty()) {
    Map<String, String> orderedValues = new TreeMap<>();
    orderedValues.putAll(values);
    throw new MustacheException(String.format(
        "Missing %d value%s when rendering %s:%n- Missing values: %s%n- Provided values: %s",
        missingValues.size(),
        missingValues.size() == 1 ? "" : "s",
        templateName,
        missingValues,
        orderedValues));
  }
}
 

@Override
public Writer run(Writer writer, List<Object> scopes) {
    if (getCodes() != null) {
        for (Code code : getCodes()) {
            try (StringWriter capture = new StringWriter()) {
                code.execute(capture, scopes);

                String s = capture.toString();
                if (s != null) {
                    encoder.encode(s, writer);
                }
            } catch (IOException e) {
                throw new MustacheException("Exception while parsing mustache function at line " + tc.line(), e);
            }
        }
    }
    return writer;
}
 

@Override
public MustacheVisitor createMustacheVisitor() {
    return new DefaultMustacheVisitor(this) {
        @Override
        public void value(TemplateContext tc, String variable, boolean encoded) {
            list.add(new ValueCode(tc, df, variable, encoded) {
                @Override
                public Writer execute(Writer writer, List<Object> scopes) {
                    try {
                        final Object object = get(scopes);
                        if (object instanceof NotEncoded) {
                            writer.write(oh.stringify(object));
                            return appendText(run(writer, scopes));
                        } else {
                            return super.execute(writer, scopes);
                        }
                    } catch (Exception e) {
                        throw new MustacheException("Failed to get value for " + name, e, tc);
                    }
                }
            });
        }
    };
}
 

@Override
public void encode(String value, Writer writer) {
    try {
        writer.write(value);
    } catch (IOException e) {
        throw new MustacheException("Failed to encode value: " + value);
    }
}
 

@Override
public void encode(String value, Writer writer) {
  //
  // TODO: encoding rules
  //
  try {
    writer.write(value);
  } catch (IOException e) {
    throw new MustacheException(e);
  }
}
 

@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 testMustache() throws MustacheException, IOException {
	File root = new File("TestFiles");
	DefaultMustacheFactory builder = new DefaultMustacheFactory(root);
	Map<String, Object> context = Maps.newHashMap();
	context.put(TEST_FIELD1, TEST_RESULT1);
	Mustache m = builder.compile("testSimpleTemplate.txt");
	StringWriter writer = new StringWriter();
	m.execute(writer, context);
	assertEquals(TEST_RESULT1, writer.toString());
}
 

private List<AbstractProperty> extractPropertiesFromStringContent(String fileName, String fieldName, String string) {
    try {
        return AbstractProperty.extractPropertiesFromStringContent(string);
    } catch (IllegalArgumentException | MustacheException illegalArgException) {
        throw new InvalidTemplateException(templateContainerKey.toString(), fileName, fieldName, illegalArgException);
    }
}
 

/**
 * Renders a given Mustache template using the provided value map, throwing an exception if any template parameters
 * weren't found in the map.
 *
 * @param templateContent String representation of template
 * @param values          Map of values to be inserted into the template
 * @return Rendered Mustache template String
 * @throws MustacheException if parameters in the {@code templateContent} weren't provided in the {@code values}
 */
public static String renderMustacheThrowIfMissing(
    String templateName,
    String templateContent,
    Map<String, String> values)
    throws MustacheException
{
  List<MissingValue> missingValues = new ArrayList<>();
  String rendered = renderMustache(templateName, templateContent, values, missingValues);
  validateMissingValues(templateName, values, missingValues);
  return rendered;
}
 

@Override
public void encode(String value, Writer writer) {
    try {
        writer.write(value);
    } catch (IOException e) {
        throw new MustacheException("Failed to encode value: " + value);
    }
}
 

private static String extractDelimiter(String variable) {
    Matcher matcher = PATTERN.matcher(variable);
    if (matcher.find()) {
        return matcher.group(1);
    }
    throw new MustacheException("Failed to extract delimiter for join function");
}
 

@Override
@SuppressWarnings("unchecked")
protected Function<String, String> createFunction(Object resolved) {
    return s -> {
        if (resolved == null) {
            return null;
        }
        try (XContentBuilder builder = XContentBuilder.builder(XContentType.JSON.xContent())) {
            if (resolved == null) {
                builder.nullValue();
            } else if (resolved instanceof Iterable) {
                builder.startArray();
                for (Object o : (Iterable) resolved) {
                    builder.value(o);
                }
                builder.endArray();
            } else if (resolved instanceof Map) {
                builder.map((Map<String, ?>) resolved);
            } else {
                // Do not handle as JSON
                return oh.stringify(resolved);
            }
            return Strings.toString(builder);
        } catch (IOException e) {
            throw new MustacheException("Failed to convert object to JSON", e);
        }
    };
}
 

@Override
public void encode(String value, Writer writer) {
    try {
        encoder.encode(value, writer);
    } catch (IOException e) {
        throw new MustacheException("Unable to encode value", e);
    }
}
 

public static Mustache compile(String name, String template) {
    // Don't use compile(String name) to avoid caching in the factory
    try {
        return FACTORY.compile(new StringReader(template), name);
    } catch (MustacheException me) {
        throw new IllegalArgumentException(me.getMessage(), me);
    }
}
 

@Override
public void encode(String value, Writer writer) {
    int position = 0;
    int length = value.length();
    try {
        writer.append(value, position, length);
    } catch (IOException e) {
        throw new MustacheException("Failed to encode value: " + value);
    }
}
 

@Override
public void encode(String value, Writer writer) {
    try {
        writer.write(value);
    } catch (IOException e) {
        throw new MustacheException("Failed to encode value: " + value);
    }
}
 

@Override
public void encode(String value, Writer writer) {
    try {
        writer.write(JsonStringEncoder.getInstance().quoteAsString(value));
    } catch (IOException e) {
        throw new MustacheException("Failed to encode value: " + value);
    }
}
 

ToJsonCode(TemplateContext tc, DefaultMustacheFactory df, Mustache mustache, String variable) {
    super(tc, df, mustache, CODE);
    if (!CODE.equalsIgnoreCase(variable)) {
        throw new MustacheException("Mismatch function code [" + CODE + "] cannot be applied to [" + variable + "]");
    }
}
 

public static void rdfToHtml(SpdxDocument doc, File docHtmlFile, File licenseHtmlFile, File snippetHtmlFile,
		File docFilesHtmlFile) throws MustacheException, IOException, InvalidSPDXAnalysisException {
	rdfToHtml(doc, templateRootPath.toFile(), docHtmlFile, licenseHtmlFile, snippetHtmlFile, docFilesHtmlFile);
}
 

@Test(expected=MustacheException.class)
public void compileMissing() {
  Templates.compile("missing.mustache");
}
 

@Test(expected=MustacheException.class)
public void compileMissingPartial() {
  Templates.compile("missing_partial.mustache");
}
 

@Test(expected = MustacheException.class)
public void testInvalidTemplate() throws IOException {
    final String template = getTemplate("invalid.mustache");
    templater.execute(template, "test", Collections.emptySet());
}