add deferring mustache factory to the main

Sam Pullara · Sam Pullara · commit d1d398bf4443 · 2012-04-16T15:24:53.000-07:00
diff --git a/compiler/src/main/java/com/github/mustachejava/DeferringMustacheFactory.java b/compiler/src/main/java/com/github/mustachejava/DeferringMustacheFactory.java
@@ -0,0 +1,137 @@
+package com.github.mustachejava;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicLong;
+
+import com.github.mustachejava.codes.PartialCode;
+import com.github.mustachejava.util.GuardException;
+import com.github.mustachejava.util.Wrapper;
+
+/**
+ * This allows you to automatically defer evaluation of partials. By default
+ * it generates HTML but you can override that behavior.
+ */
+public class DeferringMustacheFactory extends DefaultMustacheFactory {
+
+  public static final Object DEFERRED = new Object();
+
+  public DeferringMustacheFactory() {
+  }
+
+  public DeferringMustacheFactory(String resourceRoot) {
+    super(resourceRoot);
+  }
+
+  public DeferringMustacheFactory(File fileRoot) {
+    super(fileRoot);
+  }
+
+  private static class Deferral {
+    final long id;
+    final Future<Object> future;
+
+    Deferral(long id, Future<Object> future) {
+      this.id = id;
+      this.future = future;
+    }
+  }
+
+  public static class DeferredCallable implements Callable<String> {
+
+    private List<Deferral> deferrals = new ArrayList<Deferral>();
+
+    public void add(Deferral deferral) {
+      deferrals.add(deferral);
+    }
+
+    @Override
+    public String call() throws Exception {
+      StringBuilder sb = new StringBuilder();
+      for (Deferral deferral : deferrals) {
+        Object o = deferral.future.get();
+        if (o != null) {
+          writeDeferral(sb, deferral, o);
+        }
+      }
+      return sb.toString();
+    }
+  }
+
+  @Override
+  public MustacheVisitor createMustacheVisitor() {
+    final AtomicLong id = new AtomicLong(0);
+    return new DefaultMustacheVisitor(this) {
+      @Override
+      public void partial(TemplateContext templateContext, final String variable) {
+        TemplateContext partialTC = new TemplateContext("{{", "}}", templateContext.file(),
+                templateContext.line());
+        final Long divid = id.incrementAndGet();
+        list.add(new PartialCode(partialTC, cf, variable) {
+          Wrapper deferredWrapper;
+
+          @Override
+          protected Writer partialExecute(Writer writer, final Object[] scopes) {
+            final Object object = get(variable, scopes);
+            final DeferredCallable deferredCallable = getDeferred(scopes);
+            if (object == DEFERRED && deferredCallable != null) {
+              try {
+                writeTarget(writer, divid);
+              } catch (IOException e) {
+                throw new MustacheException("Failed to write", e);
+              }
+              deferredCallable.add(
+                      new Deferral(divid, getExecutorService().submit(new Callable<Object>() {
+                        @Override
+                        public Object call() {
+                          try {
+                            StringWriter writer = new StringWriter();
+                            execute(writer, object, scopes).close();
+                            return writer.toString();
+                          } catch (IOException e) {
+                            throw new MustacheException("Failed to writer", e);
+                          }
+                        }
+                      })));
+              return writer;
+            } else {
+              return super.partialExecute(writer, scopes);
+            }
+          }
+
+          private DeferredCallable getDeferred(Object[] scopes) {
+            try {
+              if (deferredWrapper == null) {
+                deferredWrapper = getObjectHandler().find("deferred", scopes);
+              }
+              return (DeferredCallable) deferredWrapper.call(scopes);
+            } catch (GuardException e) {
+              deferredWrapper = null;
+              return getDeferred(scopes);
+            }
+          }
+        });
+      }
+    };
+  }
+
+  protected void writeTarget(Writer writer, Long divid) throws IOException {
+    writer.append("<div id=\"");
+    writer.append(divid.toString());
+    writer.append("\"></div>\n");
+  }
+
+  protected static void writeDeferral(StringBuilder sb, Deferral deferral, Object o) {
+    sb.append("<script>document.getElementById(\"");
+    sb.append(deferral.id);
+    sb.append("\").innerHTML=\"");
+    sb.append(o.toString().replace("<", "&lt;").replace("\"", "\\\"").replace("\n", "\\n"));
+    sb.append("\";</script>");
+  }
+}
diff --git a/compiler/src/main/java/com/github/mustachejava/codes/DefaultCode.java b/compiler/src/main/java/com/github/mustachejava/codes/DefaultCode.java
@@ -97,18 +97,7 @@ public Object get(String name, Object[] scopes) {
 
   private Object get_recurse(String name, Object[] scopes, int depth) {
     if (depth > 10) {
-      StringBuilder sb = new StringBuilder();
-      sb.append(name);
-      for (Object scope : scopes) {
-        sb.append(":");
-        sb.append(scope);
-        if (scope != null) {
-          sb.append("<");
-          sb.append(scope.getClass());
-          sb.append(">");
-        }
-      }
-      throw new AssertionError("Guard recursion: " + sb);
+      return recursionError(name, scopes);
     }
     if (returnThis) {
       return scopes[scopes.length - 1];
@@ -126,6 +115,21 @@ private Object get_recurse(String name, Object[] scopes, int depth) {
     }
   }
 
+  private Object recursionError(String name, Object[] scopes) {
+    StringBuilder sb = new StringBuilder();
+    sb.append(name);
+    for (Object scope : scopes) {
+      sb.append(":");
+      sb.append(scope);
+      if (scope != null) {
+        sb.append("<");
+        sb.append(scope.getClass());
+        sb.append(">");
+      }
+    }
+    throw new AssertionError("Guard recursion: " + sb);
+  }
+
   private boolean getWrapper(String name, Object[] scopes) {
     boolean notfound = false;
     wrapper = oh.find(name, scopes);
diff --git a/compiler/src/test/java/com/github/mustachejava/InterpreterTest.java b/compiler/src/test/java/com/github/mustachejava/InterpreterTest.java
@@ -355,6 +355,20 @@ public String call() throws Exception {
     }
   }
 
+  public void testDeferred() throws IOException {
+    DefaultMustacheFactory mf = new DeferringMustacheFactory(root);
+    mf.setExecutorService(Executors.newCachedThreadPool());
+    Object context = new Object() {
+      String title = "Deferred";
+      Object deferred = new DeferringMustacheFactory.DeferredCallable();
+      Object deferredpartial = DeferringMustacheFactory.DEFERRED;
+    };
+    Mustache m = mf.compile("deferred.html");
+    StringWriter sw = new StringWriter();
+    m.execute(sw, context).close();
+    assertEquals(getContents(root, "deferred.txt"), sw.toString());
+  }
+
   private MustacheFactory init() {
     DefaultMustacheFactory cf = new DefaultMustacheFactory(root);
     return cf;
diff --git a/src/test/resources/deferred.html b/src/test/resources/deferred.html
@@ -0,0 +1,7 @@
+<html>
+<head><title>{{title}}</title></head>
+<body>
+{{>deferredpartial}}
+{{{deferred}}}
+</body>
+</html>
diff --git a/src/test/resources/deferred.txt b/src/test/resources/deferred.txt
@@ -0,0 +1,7 @@
+<html>
+<head><title>Deferred</title></head>
+<body>
+<div id="1"></div>
+<script>document.getElementById("1").innerHTML="I am calculated\n\"later\" and divs\nare written out &lt;\nnow\n";</script>
+</body>
+</html>
diff --git a/src/test/resources/deferredpartial.html b/src/test/resources/deferredpartial.html
@@ -0,0 +1,4 @@
+I am calculated
+"later" and divs
+are written out <
+now
