Modified compound variables to honor null/default configuration. Closes #10.

Kali/Bertrand convinced me that being consistent with other Mustache
implementations is more important than whatever wacky reasons I was harboring
for keeping compound variables different than singleton sections.

src/main/java/com/samskivert/mustache/Mustache.java

@@ -85,9 +85,7 @@ public class Mustache
 
         /** Returns a compiler that will use the given value for any variable that is missing, or
          * otherwise resolves to null. This is like {@link #nullValue} except that it returns the
-         * supplied default for missing keys and existing keys that return null values. Note that
-         * regardless of whether a null or default value is configured, if the resolution of part
-         * of a compound key results in a missing or null value, an exception will be raised. */
+         * supplied default for missing keys and existing keys that return null values. */
         public Compiler defaultValue (String defaultValue) {
             return new Compiler(this.escapeHTML, this.standardsMode, defaultValue, true,
                                 this.loader, this.collector);
@@ -103,10 +101,7 @@ public class Mustache
          * <li>In the case of a {@link Map} being used as a context, all possible accessors are
          * assumed to exist (but potentially return null), and no exception will ever be
          * raised.</li>
-         * </ul>
-         * Note that regardless of whether a null or default value is configured, if the resolution
-         * of part of a compound key results in a missing or null value, an exception will be
-         * raised. */
+         * </ul> */
         public Compiler nullValue (String nullValue) {
             return new Compiler(this.escapeHTML, this.standardsMode, nullValue, false,
                                 this.loader, this.collector);

src/main/java/com/samskivert/mustache/Template.java

@@ -93,13 +93,12 @@ public class Template
                 Object data = getValue(ctx, comps[0].intern(), line, missingIsNull);
                 for (int ii = 1; ii < comps.length; ii++) {
                     if (data == NO_FETCHER_FOUND) {
-                        throw new NullPointerException(
+                        if (!missingIsNull) throw new MustacheException(
                             "Missing context for compound variable '" + name + "' on line " + line +
                             ". '" + comps[ii - 1] + "' was not found.");
+                        return null;
                     } else if (data == null) {
-                        throw new NullPointerException(
-                            "Null context for compound variable '" + name + "' on line " + line +
-                            ". '" + comps[ii - 1] + "' resolved to null.");
+                        return null;
                     }
                     // once we step into a composite key, we drop the ability to query our parent
                     // contexts; that would be weird and confusing
@@ -214,12 +213,9 @@ public class Template
     protected Object checkForMissing (String name, int line, boolean missingIsNull, Object value)
     {
         if (value == NO_FETCHER_FOUND) {
-            if (missingIsNull) {
-                return null;
-            } else {
-                throw new MustacheException(
-                    "No method or field with name '" + name + "' on line " + line);
-            }
+            if (missingIsNull) return null;
+            throw new MustacheException(
+                "No method or field with name '" + name + "' on line " + line);
         } else {
             return value;
         }