start pragma support

Sam Pullara · Sam Pullara · commit a78f2081d62a · 2012-05-24T16:47:10.000-07:00
diff --git a/compiler/src/main/java/com/github/mustachejava/DefaultMustacheVisitor.java b/compiler/src/main/java/com/github/mustachejava/DefaultMustacheVisitor.java
@@ -2,22 +2,46 @@
 
 import com.github.mustachejava.codes.*;
 
+import java.io.Writer;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
 
 /**
  * The default implementation that builds up Code lists
  */
 public class DefaultMustacheVisitor implements MustacheVisitor {
+  protected static Logger logger = Logger.getLogger(DefaultMustacheVisitor.class.getSimpleName());
+
   private static final Code EOF = new DefaultCode();
 
   protected final List<Code> list = new LinkedList<Code>();
+  private final Map<String, PragmaHandler> handlers = new HashMap<String, PragmaHandler>() {{
+    put("implicit-iterator", new PragmaHandler() {
+      @Override
+      public Code handle(String pragma, String args) {
+        return new DefaultCode() {
+          @Override
+          public Writer execute(Writer writer, Object[] scopes) {
+            return super.execute(writer, scopes);
+          }
+        };
+      }
+    });
+  }};
+
   protected DefaultMustacheFactory cf;
 
   public DefaultMustacheVisitor(DefaultMustacheFactory cf) {
     this.cf = cf;
   }
 
+  public void addPragmaHandler(String pragma, PragmaHandler handler) {
+    handlers.put(pragma.toLowerCase(), handler);
+  }
+
   @Override
   public Mustache mustache(TemplateContext templateContext) {
     return new DefaultMustache(templateContext, cf, list.toArray(new Code[list.size()]), templateContext.file());
@@ -62,6 +86,20 @@ public void write(TemplateContext templateContext, final String text) {
     }
   }
 
+  @Override
+  public void pragma(TemplateContext templateContext, String pragma, String args) {
+    PragmaHandler pragmaHandler = handlers.get(pragma.toLowerCase());
+    if (pragmaHandler == null) {
+      // By default, warn that no pragmas are understood
+      logger.warning("Unimplemented pragma: " + pragma);
+    } else {
+      Code code = pragmaHandler.handle(pragma, args);
+      if (code != null) {
+        list.add(code);
+      }
+    }
+  }
+
   @Override
   public void eof(TemplateContext templateContext) {
     list.add(EOF);
diff --git a/compiler/src/main/java/com/github/mustachejava/MustacheParser.java b/compiler/src/main/java/com/github/mustachejava/MustacheParser.java
@@ -167,7 +167,20 @@ protected Mustache compile(final Reader reader, String tag, final AtomicInteger
               }
               case '%':
                 // Pragmas
-                out = write(mv, out, file, currentLine.intValue());
+                if (!onlywhitespace) {
+                  out = write(mv, out, file, currentLine.intValue());
+                }
+                int index = variable.indexOf(" ");
+                String pragma;
+                String args;
+                if (index == -1) {
+                  pragma = variable;
+                  args = null;
+                } else {
+                  pragma = variable.substring(0, index);
+                  args = variable.substring(index + 1);
+                }
+                mv.pragma(new TemplateContext(sm, em, file, currentLine.get()), pragma, args);
                 break;
               case '!':
                 // Comment
diff --git a/compiler/src/main/java/com/github/mustachejava/MustacheVisitor.java b/compiler/src/main/java/com/github/mustachejava/MustacheVisitor.java
@@ -13,11 +13,13 @@ public interface MustacheVisitor {
   void partial(TemplateContext templateContext, String variable);
   void value(TemplateContext templateContext, String variable, boolean encoded);
   void write(TemplateContext templateContext, String text);
+  void pragma(TemplateContext templateContext, String pragma, String args);
 
   // Internal
   void eof(TemplateContext templateContext);
 
   // Extension
   void extend(TemplateContext templateContext, String variable, Mustache mustache);
   void name(TemplateContext templateContext, String variable, Mustache mustache);
+
 }
diff --git a/compiler/src/main/java/com/github/mustachejava/PragmaHandler.java b/compiler/src/main/java/com/github/mustachejava/PragmaHandler.java
@@ -0,0 +1,7 @@
+package com.github.mustachejava;
+
+import com.google.common.base.Optional;
+
+public interface PragmaHandler {
+  Code handle(String pragma, String args);
+}
diff --git a/compiler/src/test/java/com/github/mustachejava/InterpreterTest.java b/compiler/src/test/java/com/github/mustachejava/InterpreterTest.java
@@ -54,6 +54,23 @@ int taxed_value() {
     assertEquals(getContents(root, "simple.txt"), sw.toString());
   }
 
+  public void testSimplePragma() throws MustacheException, IOException, ExecutionException, InterruptedException {
+    MustacheFactory c = new DefaultMustacheFactory(root);
+    Mustache m = c.compile("simplepragma.html");
+    StringWriter sw = new StringWriter();
+    m.execute(sw, new Object() {
+      String name = "Chris";
+      int value = 10000;
+
+      int taxed_value() {
+        return (int) (this.value - (this.value * 0.4));
+      }
+
+      boolean in_ca = true;
+    });
+    assertEquals(getContents(root, "simple.txt"), sw.toString());
+  }
+
   public void testMultipleWrappers() throws MustacheException, IOException, ExecutionException, InterruptedException {
     MustacheFactory c = new DefaultMustacheFactory(root);
     Mustache m = c.compile("simple.html");
diff --git a/src/test/resources/simplepragma.html b/src/test/resources/simplepragma.html
@@ -0,0 +1,9 @@
+{{%IMPLICIT-ITERATOR}}Hello {{name}}
+You have just won ${{value}}!
+
+        {{#test}}
+        {{/test}}
+{{#in_ca}}
+Well, ${{ taxed_value }}, after taxes.{{fred}}
+{{/in_ca}}
+{{%UNKNOWN-PRAGMA}}
