hogan_assets 1.1.0 → 1.2.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hogan_assets (1.1.0)
+    hogan_assets (1.2.0)
       execjs (>= 1.2.9)
       sprockets (>= 2.0.3)
       tilt (>= 1.3.3)

data/README.md

@@ -4,7 +4,7 @@
 
 **hogan.js** is a templating engine developed at [Twitter](http://twitter.com) that follows the **mustache** spec and compiles the templates to JavaScript. The first bit is *cool*, since **mustache** is *cool*. The second bit is **awesome and full of win** because we can now compile our **mustache** templates on the server using the asset pipeline/sprockets.
 
-This gem contains **hogan.js v1.0.5**
+This gem contains **hogan.js v3.0.0**
 
 ## Installation
 
@@ -47,12 +47,12 @@ Require `hogan.js` somewhere in your JavaScript.
 
 ## Hamstache!
 
-_hamstache_ is the quite popular combination of `haml` and `mustache`, a more robust solution exists using [haml_assets](https://github.com/infbio/haml_assets), but if all you want is nicer markup, you need to take these two steps:
+_hamstache_ is the quite popular combination of `haml` and `mustache`, a more robust solution exists using [haml_assets](https://github.com/infbio/haml_assets), but if all you want is nicer markup, you need to take these two additional steps:
 
 Add this line to your `Gemfile`:
 
     group :assets do
-      gem 'hogan_assets'
+      gem 'haml'
     end
 
 And then execute:
@@ -63,7 +63,7 @@ And then execute:
 
 Templates are compiled to a global JavaScript object named `HoganTemplates`. To render `pages/person`:
 
-    HoganTemplates['pages/person'].render(context, partials);
+    HoganTemplates['templates/pages/person'].render(context, partials);
 
 # Author
 

data/lib/hogan_assets/config.rb

@@ -16,8 +16,6 @@ module HoganAssets
       yield self
     end
 
-    attr_accessor :allow_hamstache
-
     attr_writer :template_extensions
 
     def template_extensions

data/lib/hogan_assets/version.rb

@@ -1,3 +1,3 @@
 module HoganAssets
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/test/hogan_assets/tilt_test.rb

@@ -16,7 +16,7 @@ module HoganAssets
       template = HoganAssets::Tilt.new('/myapp/app/assets/templates/path/to/template.mustache') { "This is {{mustache}}" }
       assert_equal <<-END_EXPECTED, template.render(scope, {})
         this.HoganTemplates || (this.HoganTemplates = {});
-        this.HoganTemplates[\"path/to/template\"] = new Hogan.Template(function(c,p,i){var _=this;_.b(i=i||\"\");_.b(\"This is \");_.b(_.v(_.f(\"mustache\",c,p,0)));return _.fl();;});
+        this.HoganTemplates[\"path/to/template\"] = new Hogan.Template({code: function (c,p,i) { var t=this;t.b(i=i||\"\");t.b(\"This is \");t.b(t.v(t.f(\"mustache\",c,p,0)));return t.fl(); },partials: {}, subs: {  }});
       END_EXPECTED
     end
   end

data/vendor/assets/javascripts/hogan.js

@@ -18,12 +18,15 @@
 var Hogan = {};
 
 (function (Hogan, useArrayBuffer) {
-  Hogan.Template = function (renderFunc, text, compiler, options) {
-    this.r = renderFunc || this.r;
+  Hogan.Template = function (codeObj, text, compiler, options) {
+    codeObj = codeObj || {};
+    this.r = codeObj.code || this.r;
     this.c = compiler;
     this.options = options;
     this.text = text || '';
-    this.buf = (useArrayBuffer) ? [] : '';
+    this.partials = codeObj.partials || {};
+    this.subs = codeObj.subs || {};
+    this.ib();
   }
 
   Hogan.Template.prototype = {
@@ -45,16 +48,43 @@ var Hogan = {};
       return this.r(context, partials, indent);
     },
 
-    // tries to find a partial in the curent scope and render it
-    rp: function(name, context, partials, indent) {
-      var partial = partials[name];
+    // ensurePartial
+    ep: function(symbol, partials) {
+      var partial = this.partials[symbol];
 
-      if (!partial) {
-        return '';
+      // check to see that if we've instantiated this partial before
+      var template = partials[partial.name];
+      if (partial.instance && partial.base == template) {
+        return partial.instance;
+      }
+
+      if (typeof template == 'string') {
+        if (!this.c) {
+          throw new Error("No compiler available.");
+        }
+        template = this.c.compile(template, this.options);
       }
 
-      if (this.c && typeof partial == 'string') {
-        partial = this.c.compile(partial, this.options);
+      if (!template) {
+        return null;
+      }
+
+      // We use this to check whether the partials dictionary has changed
+      this.partials[symbol].base = template;
+
+      if (partial.subs) {
+        template = createSpecializedPartial(template, partial.subs, partial.partials);
+      }
+
+      this.partials[symbol].instance = template;
+      return template;
+    },
+
+    // tries to find a partial in the curent scope and render it
+    rp: function(symbol, context, partials, indent) {
+      var partial = this.ep(symbol, partials);
+      if (!partial) {
+        return '';
       }
 
       return partial.ri(context, partials, indent);
@@ -85,7 +115,7 @@ var Hogan = {};
       }
 
       if (typeof val == 'function') {
-        val = this.ls(val, ctx, partials, inverted, start, end, tags);
+        val = this.ms(val, ctx, partials, inverted, start, end, tags);
       }
 
       pass = (val === '') || !!val;
@@ -108,7 +138,7 @@ var Hogan = {};
       }
 
       for (var i = 1; i < names.length; i++) {
-        if (val && typeof val == 'object' && names[i] in val) {
+        if (val && typeof val == 'object' && val[names[i]] != null) {
           cx = val;
           val = val[names[i]];
         } else {
@@ -122,7 +152,7 @@ var Hogan = {};
 
       if (!returnFound && typeof val == 'function') {
         ctx.push(cx);
-        val = this.lv(val, ctx, partials);
+        val = this.mv(val, ctx, partials);
         ctx.pop();
       }
 
@@ -137,7 +167,7 @@ var Hogan = {};
 
       for (var i = ctx.length - 1; i >= 0; i--) {
         v = ctx[i];
-        if (v && typeof v == 'object' && key in v) {
+        if (v && typeof v == 'object' && v[key] != null) {
           val = v[key];
           found = true;
           break;
@@ -149,70 +179,100 @@ var Hogan = {};
       }
 
       if (!returnFound && typeof val == 'function') {
-        val = this.lv(val, ctx, partials);
+        val = this.mv(val, ctx, partials);
       }
 
       return val;
     },
 
     // higher order templates
-    ho: function(val, cx, partials, text, tags) {
-      var compiler = this.c;
-      var options = this.options;
-      options.delimiters = tags;
-      var t = val.call(cx, text, function(t) {
-        return compiler.compile(t, options).render(cx, partials);
-      });
-      this.b(compiler.compile(t.toString(), options).render(cx, partials));
+    ls: function(func, cx, partials, text, tags) {
+      var oldTags = this.options.delimiters;
+
+      this.options.delimiters = tags;
+      this.b(this.ct(coerceToString(func.call(cx, text)), cx, partials));
+      this.options.delimiters = oldTags;
+
       return false;
     },
 
+    // compile text
+    ct: function(text, cx, partials) {
+      if (this.options.disableLambda) {
+        throw new Error('Lambda features disabled.');
+      }
+      return this.c.compile(text, this.options).render(cx, partials);
+    },
+
     // template result buffering
     b: (useArrayBuffer) ? function(s) { this.buf.push(s); } :
                           function(s) { this.buf += s; },
+
     fl: (useArrayBuffer) ? function() { var r = this.buf.join(''); this.buf = []; return r; } :
                            function() { var r = this.buf; this.buf = ''; return r; },
+    // init the buffer
+    ib: function () {
+      this.buf = (useArrayBuffer) ? [] : '';
+    },
 
-    // lambda replace section
-    ls: function(val, ctx, partials, inverted, start, end, tags) {
+    // method replace section
+    ms: function(func, ctx, partials, inverted, start, end, tags) {
       var cx = ctx[ctx.length - 1],
-          t = null;
+          result = func.call(cx);
 
-      if (!inverted && this.c && val.length > 0) {
-        return this.ho(val, cx, partials, this.text.substring(start, end), tags);
-      }
-
-      t = val.call(cx);
-
-      if (typeof t == 'function') {
+      if (typeof result == 'function') {
         if (inverted) {
           return true;
-        } else if (this.c) {
-          return this.ho(t, cx, partials, this.text.substring(start, end), tags);
+        } else {
+          return this.ls(result, cx, partials, this.text.substring(start, end), tags);
         }
       }
 
-      return t;
+      return result;
     },
 
-    // lambda replace variable
-    lv: function(val, ctx, partials) {
+    // method replace variable
+    mv: function(func, ctx, partials) {
       var cx = ctx[ctx.length - 1];
-      var result = val.call(cx);
-      if (typeof result == 'function') {
-        result = result.call(cx);
-      }
-      result = coerceToString(result);
+      var result = func.call(cx);
 
-      if (this.c && ~result.indexOf("{\u007B")) {
-        return this.c.compile(result, this.options).render(cx, partials);
+      if (typeof result == 'function') {
+        return this.ct(coerceToString(result.call(cx)), cx, partials);
       }
 
       return result;
+    },
+
+    sub: function(name, context, partials, indent) {
+      var f = this.subs[name];
+      if (f) {
+        f(context, partials, this, indent);
+      }
     }
 
   };
 
+  function createSpecializedPartial(instance, subs, partials) {
+    function PartialTemplate() {};
+    PartialTemplate.prototype = instance;
+    function Substitutions() {};
+    Substitutions.prototype = instance.subs;
+    var key;
+    var partial = new PartialTemplate();
+    partial.subs = new Substitutions();
+    partial.ib();
+
+    for (key in subs) {
+      partial.subs[key] = subs[key];
+    }
+
+    for (key in partials) {
+      partial.partials[key] = partials[key];
+    }
+
+    return partial;
+  }
+
   var rAmp = /&/g,
       rLt = /</g,
       rGt = />/g,
@@ -220,7 +280,6 @@ var Hogan = {};
       rQuot = /\"/g,
       hChars =/[&<>\"\']/;
 
-
   function coerceToString(val) {
     return String((val === null || val === undefined) ? '' : val);
   }
@@ -245,7 +304,6 @@ var Hogan = {};
 
 
 
-
 (function (Hogan) {
   // Setup regex  assignments
   // remove whitespace according to Mustache spec
@@ -253,11 +311,13 @@ var Hogan = {};
       rQuot = /\"/g,
       rNewline =  /\n/g,
       rCr = /\r/g,
-      rSlash = /\\/g,
-      tagTypes = {
-        '#': 1, '^': 2, '/': 3,  '!': 4, '>': 5,
-        '<': 6, '=': 7, '_v': 8, '{': 9, '&': 10
-      };
+      rSlash = /\\/g;
+
+  Hogan.tags = {
+    '#': 1, '^': 2, '<': 3, '$': 4,
+    '/': 5, '!': 6, '>': 7, '=': 8, '_v': 9,
+    '{': 10, '&': 11, '_t': 12
+  };
 
   Hogan.scan = function scan(text, delimiters) {
     var len = text.length,
@@ -277,7 +337,7 @@ var Hogan = {};
 
     function addBuf() {
       if (buf.length > 0) {
-        tokens.push(new String(buf));
+        tokens.push({tag: '_t', text: new String(buf)});
         buf = '';
       }
     }
@@ -286,8 +346,8 @@ var Hogan = {};
       var isAllWhitespace = true;
       for (var j = lineStart; j < tokens.length; j++) {
         isAllWhitespace =
-          (tokens[j].tag && tagTypes[tokens[j].tag] < tagTypes['_v']) ||
-          (!tokens[j].tag && tokens[j].match(rIsWhitespace) === null);
+          (Hogan.tags[tokens[j].tag] < Hogan.tags['_v']) ||
+          (tokens[j].tag == '_t' && tokens[j].text.match(rIsWhitespace) === null);
         if (!isAllWhitespace) {
           return false;
         }
@@ -301,10 +361,10 @@ var Hogan = {};
 
       if (haveSeenTag && lineIsWhitespace()) {
         for (var j = lineStart, next; j < tokens.length; j++) {
-          if (!tokens[j].tag) {
+          if (tokens[j].text) {
             if ((next = tokens[j+1]) && next.tag == '>') {
               // set indent to token value
-              next.indent = tokens[j].toString()
+              next.indent = tokens[j].text.toString()
             }
             tokens.splice(j, 1);
           }
@@ -351,7 +411,7 @@ var Hogan = {};
         }
       } else if (state == IN_TAG_TYPE) {
         i += otag.length - 1;
-        tag = tagTypes[text.charAt(i + 1)];
+        tag = Hogan.tags[text.charAt(i + 1)];
         tagType = tag ? text.charAt(i + 1) : '_v';
         if (tagType == '=') {
           i = changeDelimiters(text, i);
@@ -366,7 +426,7 @@ var Hogan = {};
       } else {
         if (tagChange(ctag, text, i)) {
           tokens.push({tag: tagType, n: trim(buf), otag: otag, ctag: ctag,
-                       i: (tagType == '/') ? seenTag - ctag.length : i + otag.length});
+                       i: (tagType == '/') ? seenTag - otag.length : i + ctag.length});
           buf = '';
           i += ctag.length - 1;
           state = IN_TEXT;
@@ -416,17 +476,27 @@ var Hogan = {};
     return true;
   }
 
+  // the tags allowed inside super templates
+  var allowedInSuper = {'_t': true, '\n': true, '$': true, '/': true};
+
   function buildTree(tokens, kind, stack, customTags) {
     var instructions = [],
         opener = null,
+        tail = null,
         token = null;
 
+    tail = stack[stack.length - 1];
+
     while (tokens.length > 0) {
       token = tokens.shift();
-      if (token.tag == '#' || token.tag == '^' || isOpener(token, customTags)) {
+
+      if (tail && tail.tag == '<' && !(token.tag in allowedInSuper)) {
+        throw new Error('Illegal content in < super tag.');
+      }
+
+      if (Hogan.tags[token.tag] <= Hogan.tags['$'] || isOpener(token, customTags)) {
         stack.push(token);
         token.nodes = buildTree(tokens, token.tag, stack, customTags);
-        instructions.push(token);
       } else if (token.tag == '/') {
         if (stack.length === 0) {
           throw new Error('Closing tag without opener: /' + token.n);
@@ -437,9 +507,11 @@ var Hogan = {};
         }
         opener.end = token.i;
         return instructions;
-      } else {
-        instructions.push(token);
+      } else if (token.tag == '\n') {
+        token.last = (tokens.length == 0) || (tokens[0].tag == '\n');
       }
+
+      instructions.push(token);
     }
 
     if (stack.length > 0) {
@@ -466,16 +538,60 @@ var Hogan = {};
     }
   }
 
-  function writeCode(tree) {
-    return 'var _=this;_.b(i=i||"");' + walk(tree) + 'return _.fl();';
+  function stringifySubstitutions(obj) {
+    var items = [];
+    for (var key in obj) {
+      items.push('"' + esc(key) + '": function(c,p,t,i) {' + obj[key] + '}');
+    }
+    return "{ " + items.join(",") + " }";
+  }
+
+  function stringifyPartials(codeObj) {
+    var partials = [];
+    for (var key in codeObj.partials) {
+      partials.push('"' + esc(key) + '":{name:"' + esc(codeObj.partials[key].name) + '", ' + stringifyPartials(codeObj.partials[key]) + "}");
+    }
+    return "partials: {" + partials.join(",") + "}, subs: " + stringifySubstitutions(codeObj.subs);
+  }
+
+  Hogan.stringify = function(codeObj, text, options) {
+    return "{code: function (c,p,i) { " + Hogan.wrapMain(codeObj.code) + " }," + stringifyPartials(codeObj) +  "}";
   }
 
-  Hogan.generate = function (code, text, options) {
+  var serialNo = 0;
+  Hogan.generate = function(tree, text, options) {
+    serialNo = 0;
+    var context = { code: '', subs: {}, partials: {} };
+    Hogan.walk(tree, context);
+
     if (options.asString) {
-      return 'function(c,p,i){' + code + ';}';
+      return this.stringify(context, text, options);
     }
 
-    return new Hogan.Template(new Function('c', 'p', 'i', code), text, Hogan, options);
+    return this.makeTemplate(context, text, options);
+  }
+
+  Hogan.wrapMain = function(code) {
+    return 'var t=this;t.b(i=i||"");' + code + 'return t.fl();';
+  }
+
+  Hogan.template = Hogan.Template;
+
+  Hogan.makeTemplate = function(codeObj, text, options) {
+    var template = this.makePartials(codeObj);
+    template.code = new Function('c', 'p', 'i', this.wrapMain(codeObj.code));
+    return new this.template(template, text, this, options);
+  }
+
+  Hogan.makePartials = function(codeObj) {
+    var key, template = {subs: {}, partials: codeObj.partials, name: codeObj.name};
+    for (key in template.partials) {
+      template.partials[key] = this.makePartials(template.partials[key]);
+    }
+    for (key in codeObj.subs) {
+      template.subs[key] = new Function('c', 'p', 't', 'i', codeObj.subs[key]);
+    }
+    return template;
   }
 
   function esc(s) {
@@ -489,60 +605,79 @@ var Hogan = {};
     return (~s.indexOf('.')) ? 'd' : 'f';
   }
 
-  function walk(tree) {
-    var code = '';
-    for (var i = 0, l = tree.length; i < l; i++) {
-      var tag = tree[i].tag;
-      if (tag == '#') {
-        code += section(tree[i].nodes, tree[i].n, chooseMethod(tree[i].n),
-                        tree[i].i, tree[i].end, tree[i].otag + " " + tree[i].ctag);
-      } else if (tag == '^') {
-        code += invertedSection(tree[i].nodes, tree[i].n,
-                                chooseMethod(tree[i].n));
-      } else if (tag == '<' || tag == '>') {
-        code += partial(tree[i]);
-      } else if (tag == '{' || tag == '&') {
-        code += tripleStache(tree[i].n, chooseMethod(tree[i].n));
-      } else if (tag == '\n') {
-        code += text('"\\n"' + (tree.length-1 == i ? '' : ' + i'));
-      } else if (tag == '_v') {
-        code += variable(tree[i].n, chooseMethod(tree[i].n));
-      } else if (tag === undefined) {
-        code += text('"' + esc(tree[i]) + '"');
-      }
-    }
-    return code;
+  function createPartial(node, context) {
+    var prefix = "<" + (context.prefix || "");
+    var sym = prefix + node.n + serialNo++;
+    context.partials[sym] = {name: node.n, partials: {}};
+    context.code += 't.b(t.rp("' +  esc(sym) + '",c,p,"' + (node.indent || '') + '"));';
+    return sym;
   }
 
-  function section(nodes, id, method, start, end, tags) {
-    return 'if(_.s(_.' + method + '("' + esc(id) + '",c,p,1),' +
-           'c,p,0,' + start + ',' + end + ',"' + tags + '")){' +
-           '_.rs(c,p,' +
-           'function(c,p,_){' +
-           walk(nodes) +
-           '});c.pop();}';
-  }
+  Hogan.codegen = {
+    '#': function(node, context) {
+      context.code += 'if(t.s(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,1),' +
+                      'c,p,0,' + node.i + ',' + node.end + ',"' + node.otag + " " + node.ctag + '")){' +
+                      't.rs(c,p,' + 'function(c,p,t){';
+      Hogan.walk(node.nodes, context);
+      context.code += '});c.pop();}';
+    },
 
-  function invertedSection(nodes, id, method) {
-    return 'if(!_.s(_.' + method + '("' + esc(id) + '",c,p,1),c,p,1,0,0,"")){' +
-           walk(nodes) +
-           '};';
-  }
+    '^': function(node, context) {
+      context.code += 'if(!t.s(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,1),c,p,1,0,0,"")){';
+      Hogan.walk(node.nodes, context);
+      context.code += '};';
+    },
+
+    '>': createPartial,
+    '<': function(node, context) {
+      var ctx = {partials: {}, code: '', subs: {}, inPartial: true};
+      Hogan.walk(node.nodes, ctx);
+      var template = context.partials[createPartial(node, context)];
+      template.subs = ctx.subs;
+      template.partials = ctx.partials;
+    },
+
+    '$': function(node, context) {
+      var ctx = {subs: {}, code: '', partials: context.partials, prefix: node.n};
+      Hogan.walk(node.nodes, ctx);
+      context.subs[node.n] = ctx.code;
+      if (!context.inPartial) {
+        context.code += 't.sub("' + esc(node.n) + '",c,p,i);';
+      }
+    },
+
+    '\n': function(node, context) {
+      context.code += write('"\\n"' + (node.last ? '' : ' + i'));
+    },
+
+    '_v': function(node, context) {
+      context.code += 't.b(t.v(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,0)));';
+    },
+
+    '_t': function(node, context) {
+      context.code += write('"' + esc(node.text) + '"');
+    },
+
+    '{': tripleStache,
 
-  function partial(tok) {
-    return '_.b(_.rp("' +  esc(tok.n) + '",c,p,"' + (tok.indent || '') + '"));';
+    '&': tripleStache
   }
 
-  function tripleStache(id, method) {
-    return '_.b(_.t(_.' + method + '("' + esc(id) + '",c,p,0)));';
+  function tripleStache(node, context) {
+    context.code += 't.b(t.t(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,0)));';
   }
 
-  function variable(id, method) {
-    return '_.b(_.v(_.' + method + '("' + esc(id) + '",c,p,0)));';
+  function write(s) {
+    return 't.b(' + s + ');';
   }
 
-  function text(id) {
-    return '_.b(' + id + ');';
+  Hogan.walk = function (nodelist, context) {
+    var func;
+    for (var i = 0, l = nodelist.length; i < l; i++) {
+      func = Hogan.codegen[nodelist[i].tag];
+      func && func(nodelist[i], context);
+    }
+    return context;
   }
 
   Hogan.parse = function(tokens, text, options) {
@@ -552,30 +687,21 @@ var Hogan = {};
 
   Hogan.cache = {};
 
+  Hogan.cacheKey = function(text, options) {
+    return [text, !!options.asString, !!options.disableLambda].join('||');
+  },
+
   Hogan.compile = function(text, options) {
-    // options
-    //
-    // asString: false (default)
-    //
-    // sectionTags: [{o: '_foo', c: 'foo'}]
-    // An array of object with o and c fields that indicate names for custom
-    // section tags. The example above allows parsing of {{_foo}}{{/foo}}.
-    //
-    // delimiters: A string that overrides the default delimiters.
-    // Example: "<% %>"
-    //
     options = options || {};
+    var key = Hogan.cacheKey(text, options);
+    var template = this.cache[key];
 
-    var key = text + '||' + !!options.asString;
-
-    var t = this.cache[key];
-
-    if (t) {
-      return t;
+    if (template) {
+      return template;
     }
 
-    t = this.generate(writeCode(this.parse(this.scan(text, options.delimiters), text, options)), text, options);
-    return this.cache[key] = t;
+    template = this.generate(this.parse(this.scan(text, options.delimiters), text, options), text, options);
+    return this.cache[key] = template;
   };
 })(typeof exports !== 'undefined' ? exports : Hogan);
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hogan_assets
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-28 00:00:00.000000000 Z
+date: 2012-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: execjs