@Override protected DefaultMustacheFactory createMustacheFactory() { DefaultMustacheFactory mf = new DefaultMustacheFactory(); mf.setObjectHandler(new SimpleObjectHandler()); return mf; } }
@Override protected DefaultMustacheFactory createMustacheFactory(JsonNode test) { DefaultMustacheFactory mf = super.createMustacheFactory(test); mf.setObjectHandler(new SimpleObjectHandler()); return mf; } }
@Override protected DefaultMustacheFactory createMustacheFactory() { DefaultMustacheFactory mf = super.createMustacheFactory(); mf.setObjectHandler(new SimpleObjectHandler()); return mf; } }
private String getOutput(final boolean setObjectHandler) { final DefaultMustacheFactory mustacheFactory = new DefaultMustacheFactory(); if (setObjectHandler) { mustacheFactory.setObjectHandler(new SimpleObjectHandler()); } final Mustache defaultMustache = mustacheFactory.compile(new StringReader("{{#okGenerator.isItOk}}{{okGenerator.isItOk}}{{/okGenerator.isItOk}}"), "Test template"); final Map<String, Object> params = new HashMap<>(); params.put("okGenerator", new OkGenerator()); final Writer writer = new StringWriter(); defaultMustache.execute(writer, params); return writer.toString(); }
@Test public void testMethodAccessAllowed() { Map<String, Object> model = new HashMap<>(); factory.setObjectHandler(new MapMethodReflectionHandler()); Reader reader = new StringReader(TEMPLATE); Mustache mustache = factory.compile(reader, "template"); verifyOutput("true", model, mustache); }
@Test public void testSimpleHandlerMethodAccessDisallowed() { Map<String, Object> model = new HashMap<>(); factory.setObjectHandler(new SimpleObjectHandler()); Reader reader = new StringReader(TEMPLATE); Mustache mustache = factory.compile(reader, "template"); verifyOutput("", model, mustache); }
@Test public void testSimpleHandlerMethodAccessAllowed() { Map<String, Object> model = new HashMap<>(); factory.setObjectHandler(new SimpleMapMethodHandler()); Reader reader = new StringReader(TEMPLATE); Mustache mustache = factory.compile(reader, "template"); verifyOutput("true", model, mustache); }
@Test public void testConvert() throws IOException { DefaultMustacheFactory dmf = new DefaultMustacheFactory(); dmf.setObjectHandler(roh); Mustache uppertest = dmf.compile(new StringReader("{{#upper}}{{test}}{{/upper}}"), "uppertest"); StringWriter sw = new StringWriter(); uppertest.execute(sw, new Object() { String test = "test"; String upper(String s) { return s.toUpperCase(); } }).close(); assertEquals("TEST", sw.toString()); sw = new StringWriter(); uppertest.execute(sw, new Object() { String test2 = "test"; @TemplateMethod String upper(String s) { return "{{test2}}"; } }).close(); assertEquals("test", sw.toString()); }
@Test public void testWrapperCaching() { factory.setObjectHandler(new MapMethodReflectionHandler()); Reader reader = new StringReader(TEMPLATE); Mustache mustache = factory.compile(reader, "template"); Map<String, String> model = new HashMap<>(); verifyOutput("true", model, mustache); model.put("empty", "data"); verifyOutput("data", model, mustache); }
@Test public void testObjectHandler() throws IOException { DefaultMustacheFactory mf = new DefaultMustacheFactory(); mf.setObjectHandler(new ReflectionObjectHandler() { @Override public Object coerce(Object object) { if (object instanceof Collection) { return new DecoratedCollection((Collection) object); } return super.coerce(object); } }); Mustache test = mf.compile(new StringReader( "{{#test}}{{index}}: {{#first}}first: {{/first}}{{#last}}last: {{/last}}{{value}}\n{{/test}}"), "test"); StringWriter sw = new StringWriter(); test.execute(sw, new Object() { Collection test = Arrays.asList("First", "Second", "Third", "Last"); }).flush(); assertEquals("0: first: First\n1: Second\n2: Third\n3: last: Last\n", sw.toString()); }
public void testNumber0IsFalse() throws IOException { DefaultMustacheFactory c = createMustacheFactory(); c.setObjectHandler(new ReflectionObjectHandler() { @Override public Writer falsey(Iteration iteration, Writer writer, Object object, List<Object> scopes) { if (object instanceof Number) { if (((Number) object).intValue() == 0) { return iteration.next(writer, object, scopes); } } return super.falsey(iteration, writer, object, scopes); } @Override public Writer iterate(Iteration iteration, Writer writer, Object object, List<Object> scopes) { if (object instanceof Number) { if (((Number) object).intValue() == 0) { return writer; } } return super.iterate(iteration, writer, object, scopes); } }); StringWriter sw = new StringWriter(); Mustache m = c.compile(new StringReader("{{#zero}}zero{{/zero}}{{#one}}one{{/one}}{{^zero}}zero{{/zero}}{{^one}}one{{/one}}"), "zeroone"); m.execute(sw, new Object() { int zero = 0; int one = 1; }).close(); assertEquals("onezero", sw.toString()); }
public void testDefaultValue() throws IOException { DefaultMustacheFactory mf = new DefaultMustacheFactory(root); mf.setObjectHandler(new ReflectionObjectHandler() { @Override public Wrapper find(String name, List<Object> scopes) { int i; if ((i = name.indexOf("|")) != -1) { String newName = name.substring(0, i); String defaultValue = name.substring(i + 1); Wrapper wrapper = super.find(newName, scopes); if (wrapper instanceof MissingWrapper) { return scopes1 -> { // Test the guards returned in the missing wrapper wrapper.call(scopes1); return defaultValue; }; } return wrapper; } return super.find(name, scopes); } }); Mustache m = mf.compile(new StringReader("{{test}} {{test2|bar}} {{test3|baz}}"), "testDefaultValue"); StringWriter sw = new StringWriter(); m.execute(sw, new Object() { String test = "foo"; String test2 = "BAR"; }); assertEquals("foo BAR baz", sw.toString()); }
@Test public void testExpressionsInNames() throws IOException { DefaultMustacheFactory mf = new DefaultMustacheFactory(); mf.setObjectHandler(new ReflectionObjectHandler() { @Override public Wrapper find(String name, List<Object> scopes) {
mf.setObjectHandler(oh); Mustache m = mf.compile(new StringReader(template), "template"); StringWriter writer = new StringWriter();
public void testTypedSimple() throws MustacheException, IOException, ExecutionException, InterruptedException { final Object scope = new Object() { String name = "Chris"; int value = 10000; class MyObject { int taxed_value() { return (int) (value - (value * 0.4)); } String fred = ""; } MyObject in_ca = new MyObject(); boolean test = false; }; DefaultMustacheFactory c = new DefaultMustacheFactory(root); c.setObjectHandler(new TypeCheckingHandler()); Mustache m = c.compile("simple.html"); StringWriter sw = new StringWriter(); m.execute(sw, scope.getClass()).flush(); assertEquals(getContents(root, "simpletyped.txt"), sw.toString()); }
dmf.setObjectHandler(roh); try { Mustache test = dmf.compile(new StringReader("{{test}}"), "test");
@Test public void testKeyValues() { Map<String, String> model = new TreeMap<String, String>() {{ put("test", "testvalue"); put("key", "keyvalue"); }}; Reader reader = new StringReader(TEMPLATE2); factory.setObjectHandler(new MapMethodReflectionHandler()); Mustache mustache = factory.compile(reader, "template"); verifyOutput("key=keyvalue\ntest=testvalue\n", model, mustache); }
mf.setObjectHandler(new ReflectionObjectHandler() { @Override protected MissingWrapper createMissingWrapper(String name, List<Guard> guards) {
@Test public void testThrowMustacheExceptionInCaseOfNullHandler() throws Exception { try { String template = "<ol>\n" + " <li>{{test.1}}</li>\n" + " <li>{{test.0}}</li>\n" + " <li>{{test.3}}</li>\n" + "</ol>\n" + "<ol>\n" + "{{#test}}\n" + " <li>{{.}}</li>\n" + "{{/test}}\n" + "</ol>"; Object scope = new Object() { String[] test = new String[]{ "a", "b", "c", "d" }; }; DefaultMustacheFactory mf = new DefaultMustacheFactory(); mf.setObjectHandler(null); Mustache m = mf.compile(new StringReader(template), "template"); m.execute(new StringWriter(), scope).flush(); fail("should have thrown MustacheException"); } catch (MustacheException expected) { assertEquals("Failed to get value for test.1 @[template:2]", expected.getMessage()); } }
mustacheFactory.setObjectHandler(new ReflectionObjectHandler() { @Override public Binding createBinding(String name, final TemplateContext tc, Code code) {