From 15ff48eabb359d08ba9b1f11caef407aeba3ddc5 Mon Sep 17 00:00:00 2001 From: Michael Bayne Date: Fri, 15 Apr 2011 12:35:33 -0700 Subject: [PATCH] Some tidying up, name changes and clarifications. I went with "defaultValue" rather than "missingVariableValue" because the value is used any time a variable resolves to null, not necessarily just when it is missing. If you have a context like: new Object() { String foo = null; } and reference {{foo}} in your template, foo is not missing, per se, but the default value will still be used for it. --- .../com/samskivert/mustache/Mustache.java | 27 ++++++++++--------- .../com/samskivert/mustache/Template.java | 8 ++++-- .../com/samskivert/mustache/MustacheTest.java | 24 +++++++---------- 3 files changed, 29 insertions(+), 30 deletions(-) diff --git a/src/main/java/com/samskivert/mustache/Mustache.java b/src/main/java/com/samskivert/mustache/Mustache.java index aca61cf..cae4229 100644 --- a/src/main/java/com/samskivert/mustache/Mustache.java +++ b/src/main/java/com/samskivert/mustache/Mustache.java @@ -38,8 +38,9 @@ public class Mustache /** Whether or not standards mode is enabled. */ public final boolean standardsMode; - /** Replace missnig values with this value - if null will throw an exception on missing values. */ - public final String missingVariableValue; + /** A value to use when a variable cannot be resolved, or resolves to null. If the default + * value is null (which is the default default value), an exception will be thrown. */ + public final String defaultValue; /** The template loader in use during this compilation. */ public final TemplateLoader loader; @@ -56,32 +57,32 @@ public class Mustache /** Returns a compiler that either does or does not escape HTML by default. */ public Compiler escapeHTML (boolean escapeHTML) { - return new Compiler(escapeHTML, this.standardsMode, this.missingVariableValue, this.loader); + return new Compiler(escapeHTML, this.standardsMode, this.defaultValue, this.loader); } /** Returns a compiler that either does or does not use standards mode. Standards mode * disables the non-standard JMustache extensions like looking up missing names in a parent * context. */ public Compiler standardsMode (boolean standardsMode) { - return new Compiler(this.escapeHTML, standardsMode, this.missingVariableValue, this.loader); + return new Compiler(this.escapeHTML, standardsMode, this.defaultValue, this.loader); } - /** - * Returns a compiler that will replace missing variables with the given value - **/ - public Compiler missingVariableValue (String missingVariableValue) { - return new Compiler(this.escapeHTML, this.standardsMode, missingVariableValue, this.loader); + /** Returns a compiler that will use the given value for any variable that is missing, or + * otherwise resolves to null. */ + public Compiler defaultValue (String defaultValue) { + return new Compiler(this.escapeHTML, this.standardsMode, defaultValue, this.loader); } /** Returns a compiler configured to use the supplied template loader to handle partials. */ public Compiler withLoader (TemplateLoader loader) { - return new Compiler(this.escapeHTML, this.standardsMode, this.missingVariableValue, loader); + return new Compiler(this.escapeHTML, this.standardsMode, this.defaultValue, loader); } - protected Compiler (boolean escapeHTML, boolean standardsMode, String missingVariableValue, TemplateLoader loader) { + protected Compiler (boolean escapeHTML, boolean standardsMode, String defaultValue, + TemplateLoader loader) { this.escapeHTML = escapeHTML; this.standardsMode = standardsMode; - this.missingVariableValue = missingVariableValue; + this.defaultValue = defaultValue; this.loader = loader; } } @@ -479,7 +480,7 @@ public class Mustache _escapeHTML = escapeHTML; } @Override public void execute (Template tmpl, Template.Context ctx, Writer out) { - Object value = tmpl.getValueWithDefault(ctx, _name, _line); + Object value = tmpl.getValueOrDefault(ctx, _name, _line); if (value == null) { throw new MustacheException( "No key, method or field with name '" + _name + "' on line " + _line); diff --git a/src/main/java/com/samskivert/mustache/Template.java b/src/main/java/com/samskivert/mustache/Template.java index 5ef2950..ff1c1e4 100644 --- a/src/main/java/com/samskivert/mustache/Template.java +++ b/src/main/java/com/samskivert/mustache/Template.java @@ -126,10 +126,14 @@ public class Template return null; } - protected Object getValueWithDefault (Context ctx, String name, int line) + /** + * Returns the value for the specified variable, or the configured default value if the + * variable resolves to null. See {@link #getValue}. + */ + protected Object getValueOrDefault (Context ctx, String name, int line) { Object value = getValue(ctx, name, line); - return value != null? value : _compiler.missingVariableValue; + return (value == null) ? _compiler.defaultValue : value; } protected Object getValueIn (Object data, String name, int line) diff --git a/src/test/java/com/samskivert/mustache/MustacheTest.java b/src/test/java/com/samskivert/mustache/MustacheTest.java index f215023..24b2fc4 100644 --- a/src/test/java/com/samskivert/mustache/MustacheTest.java +++ b/src/test/java/com/samskivert/mustache/MustacheTest.java @@ -153,12 +153,12 @@ public class MustacheTest execute(context("a", ""))); } - @Test(expected = MustacheParseException.class) + @Test(expected=MustacheParseException.class) public void testDanglingTag () { Mustache.compiler().escapeHTML(true).compile("{{a").execute(context("a", "")); } - @Test(expected = MustacheParseException.class) + @Test(expected=MustacheParseException.class) public void testInvalidUnescapeHTML () { Mustache.compiler().escapeHTML(true).compile("{{{a}}").execute(context("a", "")); } @@ -276,7 +276,7 @@ public class MustacheTest assertEquals(":bar:", result); } - @Test(expected = MustacheException.class) + @Test(expected=MustacheException.class) public void testStandardsModeWithNoParentContextSearching () { String tmpl = "{{#parent}}foo{{parentProperty}}bar{{/parent}}"; String result = Mustache.compiler().standardsMode(true).compile(tmpl). @@ -284,25 +284,19 @@ public class MustacheTest "parentProperty", "bar")); } - @Test(expected = MustacheException.class) + @Test(expected=MustacheException.class) public void testMissingValue () { - String tmpl = "{{ missing }} {{ notmissing }}"; - Mustache.compiler().compile(tmpl). - execute(Collections.singletonMap("notmissing", "bar")); + test("n/a", "{{missing}} {{notmissing}}", context("notmissing", "bar")); } @Test public void testMissingValueWithDefault () { - String tmpl = "{{ missing }}{{ notmissing }}"; - String result = Mustache.compiler().missingVariableValue("").compile(tmpl). - execute(Collections.singletonMap("notmissing", "bar")); - assertEquals("bar", result); + test(Mustache.compiler().defaultValue(""), + "bar", "{{missing}}{{notmissing}}", context("notmissing", "bar")); } @Test public void testMissingValueWithDefaultNonEmptyString () { - String tmpl = "{{ missing }}{{ notmissing }}"; - String result = Mustache.compiler().missingVariableValue("foo").compile(tmpl). - execute(Collections.singletonMap("notmissing", "bar")); - assertEquals("foobar", result); + test(Mustache.compiler().defaultValue("foo"), + "foobar", "{{missing}}{{notmissing}}", context("notmissing", "bar")); } protected void test (Mustache.Compiler compiler, String expected, String template, Object ctx)