merge

2013-02-11 23:00:47 -06:00
parent 514c9391e0 7c633b604d
commit 1ca7462497
27 changed files with 3402 additions and 314 deletions
@@ -42,6 +42,26 @@ Handlebars.JavaScriptCompiler = function() {};

      return out.join("\n");
    },
+    equals: function(other) {
+      var len = this.opcodes.length;
+      if (other.opcodes.length !== len) {
+        return false;
+      }
+
+      for (var i = 0; i < len; i++) {
+        var opcode = this.opcodes[i],
+            otherOpcode = other.opcodes[i];
+        if (opcode.opcode !== otherOpcode.opcode || opcode.args.length !== otherOpcode.args.length) {
+          return false;
+        }
+        for (var j = 0; j < opcode.args.length; j++) {
+          if (opcode.args[j] !== otherOpcode.args[j]) {
+            return false;
+          }
+        }
+      }
+      return true;
+    },

    guid: 0,

@@ -133,7 +153,7 @@ Handlebars.JavaScriptCompiler = function() {};
        // evaluate it by executing `blockHelperMissing`
        this.opcode('pushProgram', program);
        this.opcode('pushProgram', inverse);
-        this.opcode('pushLiteral', '{}');
+        this.opcode('emptyHash');
        this.opcode('blockValue');
      } else {
        this.ambiguousMustache(mustache, program, inverse);
@@ -142,7 +162,7 @@ Handlebars.JavaScriptCompiler = function() {};
        // evaluate it by executing `blockHelperMissing`
        this.opcode('pushProgram', program);
        this.opcode('pushProgram', inverse);
-        this.opcode('pushLiteral', '{}');
+        this.opcode('emptyHash');
        this.opcode('ambiguousBlockValue');
      }

@@ -152,19 +172,25 @@ Handlebars.JavaScriptCompiler = function() {};
    hash: function(hash) {
      var pairs = hash.pairs, pair, val;

-      this.opcode('push', '{}');
+      this.opcode('pushHash');

      for(var i=0, l=pairs.length; i<l; i++) {
        pair = pairs[i];
        val  = pair[1];

-        this.accept(val);
+        if (this.options.stringParams) {
+          this.opcode('pushStringParam', val.stringModeValue, val.type);
+        } else {
+          this.accept(val);
+        }
+
        this.opcode('assignToHash', pair[0]);
      }
+      this.opcode('popHash');
    },

    partial: function(partial) {
-      var id = partial.id;
+      var partialName = partial.partialName;
      this.usePartial = true;

      if(partial.context) {
@@ -173,7 +199,7 @@ Handlebars.JavaScriptCompiler = function() {};
        this.opcode('push', 'depth0');
      }

-      this.opcode('invokePartial', id.original);
+      this.opcode('invokePartial', partialName.name);
      this.opcode('append');
    },

@@ -201,17 +227,19 @@ Handlebars.JavaScriptCompiler = function() {};
    },

    ambiguousMustache: function(mustache, program, inverse) {
-      var id = mustache.id, name = id.parts[0];
+      var id = mustache.id,
+          name = id.parts[0],
+          isBlock = program != null || inverse != null;

      this.opcode('getContext', id.depth);

      this.opcode('pushProgram', program);
      this.opcode('pushProgram', inverse);

-      this.opcode('invokeAmbiguous', name);
+      this.opcode('invokeAmbiguous', name, isBlock);
    },

-    simpleMustache: function(mustache, program, inverse) {
+    simpleMustache: function(mustache) {
      var id = mustache.id;

      if (id.type === 'DATA') {
@@ -328,7 +356,7 @@ Handlebars.JavaScriptCompiler = function() {};
          }

          this.opcode('getContext', param.depth || 0);
-          this.opcode('pushStringParam', param.string);
+          this.opcode('pushStringParam', param.stringModeValue, param.type);
        } else {
          this[param.type](param);
        }
@@ -342,7 +370,7 @@ Handlebars.JavaScriptCompiler = function() {};
      if(mustache.hash) {
        this.hash(mustache.hash);
      } else {
-        this.opcode('pushLiteral', '{}');
+        this.opcode('emptyHash');
      }

      return params;
@@ -359,7 +387,7 @@ Handlebars.JavaScriptCompiler = function() {};
      if(mustache.hash) {
        this.hash(mustache.hash);
      } else {
-        this.opcode('pushLiteral', '{}');
+        this.opcode('emptyHash');
      }

      return params;
@@ -373,7 +401,7 @@ Handlebars.JavaScriptCompiler = function() {};
  JavaScriptCompiler.prototype = {
    // PUBLIC API: You can override these methods in a subclass to provide
    // alternative compiled forms for name lookup and buffering semantics
-    nameLookup: function(parent, name, type) {
+    nameLookup: function(parent, name /* , type*/) {
      if (/^[0-9]+$/.test(name)) {
        return parent + "[" + name + "]";
      } else if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
@@ -388,7 +416,11 @@ Handlebars.JavaScriptCompiler = function() {};
      if (this.environment.isSimple) {
        return "return " + string + ";";
      } else {
-        return "buffer += " + string + ";";
+        return {
+          appendToBuffer: true,
+          content: string,
+          toString: function() { return "buffer += " + string + ";"; }
+        };
      }
    },

@@ -409,6 +441,7 @@ Handlebars.JavaScriptCompiler = function() {};
      this.isChild = !!context;
      this.context = context || {
        programs: [],
+        environments: [],
        aliases: { }
      };

@@ -418,6 +451,7 @@ Handlebars.JavaScriptCompiler = function() {};
      this.stackVars = [];
      this.registers = { list: [] };
      this.compileStack = [];
+      this.inlineStack = [];

      this.compileChildren(environment, options);

@@ -439,11 +473,11 @@ Handlebars.JavaScriptCompiler = function() {};
    },

    nextOpcode: function() {
-      var opcodes = this.environment.opcodes, opcode = opcodes[this.i + 1];
+      var opcodes = this.environment.opcodes;
      return opcodes[this.i + 1];
    },

-    eat: function(opcode) {
+    eat: function() {
      this.i = this.i + 1;
    },

@@ -481,7 +515,6 @@ Handlebars.JavaScriptCompiler = function() {};

      // Generate minimizer alias mappings
      if (!this.isChild) {
-        var aliases = [];
        for (var alias in this.context.aliases) {
          this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias];
        }
@@ -506,16 +539,48 @@ Handlebars.JavaScriptCompiler = function() {};
        params.push("depth" + this.environment.depths.list[i]);
      }

+      // Perform a second pass over the output to merge content when possible
+      var source = this.mergeSource();
+
+      if (!this.isChild) {
+        var revision = Handlebars.COMPILER_REVISION,
+            versions = Handlebars.REVISION_CHANGES[revision];
+        source = "this.compilerInfo = ["+revision+",'"+versions+"'];\n"+source;
+      }
+
      if (asObject) {
-        params.push(this.source.join("\n  "));
+        params.push(source);

        return Function.apply(this, params);
      } else {
-        var functionSource = 'function ' + (this.name || '') + '(' + params.join(',') + ') {\n  ' + this.source.join("\n  ") + '}';
+        var functionSource = 'function ' + (this.name || '') + '(' + params.join(',') + ') {\n  ' + source + '}';
        Handlebars.log(Handlebars.logger.DEBUG, functionSource + "\n\n");
        return functionSource;
      }
    },
+    mergeSource: function() {
+      // WARN: We are not handling the case where buffer is still populated as the source should
+      // not have buffer append operations as their final action.
+      var source = '',
+          buffer;
+      for (var i = 0, len = this.source.length; i < len; i++) {
+        var line = this.source[i];
+        if (line.appendToBuffer) {
+          if (buffer) {
+            buffer = buffer + '\n    + ' + line.content;
+          } else {
+            buffer = line.content;
+          }
+        } else {
+          if (buffer) {
+            source += 'buffer += ' + buffer + ';\n  ';
+            buffer = undefined;
+          }
+          source += line + '\n  ';
+        }
+      }
+      return source;
+    },

    // [blockValue]
    //
@@ -534,7 +599,7 @@ Handlebars.JavaScriptCompiler = function() {};

      this.replaceStack(function(current) {
        params.splice(1, 0, current);
-        return current + " = blockHelperMissing.call(" + params.join(", ") + ")";
+        return "blockHelperMissing.call(" + params.join(", ") + ")";
      });
    },

@@ -553,6 +618,9 @@ Handlebars.JavaScriptCompiler = function() {};
      var current = this.topStack();
      params.splice(1, 0, current);

+      // Use the options value generated from the invocation
+      params[params.length-1] = 'options';
+
      this.source.push("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }");
    },

@@ -576,6 +644,9 @@ Handlebars.JavaScriptCompiler = function() {};
    // If `value` is truthy, or 0, it is coerced into a string and appended
    // Otherwise, the empty string is appended
    append: function() {
+      // Force anything that is inlined onto the stack so we don't have duplication
+      // when we examine local
+      this.flushInline();
      var local = this.popStack();
      this.source.push("if(" + local + " || " + local + " === 0) { " + this.appendToBuffer(local) + " }");
      if (this.environment.isSimple) {
@@ -590,15 +661,9 @@ Handlebars.JavaScriptCompiler = function() {};
    //
    // Escape `value` and append it to the buffer
    appendEscaped: function() {
-      var opcode = this.nextOpcode(), extra = "";
      this.context.aliases.escapeExpression = 'this.escapeExpression';

-      if(opcode && opcode.opcode === 'appendContent') {
-        extra = " + " + this.quotedString(opcode.args[0]);
-        this.eat(opcode);
-      }
-
-      this.source.push(this.appendToBuffer("escapeExpression(" + this.popStack() + ")" + extra));
+      this.source.push(this.appendToBuffer("escapeExpression(" + this.popStack() + ")"));
    },

    // [getContext]
@@ -622,7 +687,7 @@ Handlebars.JavaScriptCompiler = function() {};
    // Looks up the value of `name` on the current context and pushes
    // it onto the stack.
    lookupOnContext: function(name) {
-      this.pushStack(this.nameLookup('depth' + this.lastContext, name, 'context'));
+      this.push(this.nameLookup('depth' + this.lastContext, name, 'context'));
    },

    // [pushContext]
@@ -670,7 +735,7 @@ Handlebars.JavaScriptCompiler = function() {};
    //
    // Push the result of looking up `id` on the current data
    lookupData: function(id) {
-      this.pushStack(this.nameLookup('data', id, 'data'));
+      this.push(this.nameLookup('data', id, 'data'));
    },

    // [pushStringParam]
@@ -681,9 +746,36 @@ Handlebars.JavaScriptCompiler = function() {};
    // This opcode is designed for use in string mode, which
    // provides the string value of a parameter along with its
    // depth rather than resolving it immediately.
-    pushStringParam: function(string) {
+    pushStringParam: function(string, type) {
      this.pushStackLiteral('depth' + this.lastContext);
-      this.pushString(string);
+
+      this.pushString(type);
+
+      if (typeof string === 'string') {
+        this.pushString(string);
+      } else {
+        this.pushStackLiteral(string);
+      }
+    },
+
+    emptyHash: function() {
+      this.pushStackLiteral('{}');
+
+      if (this.options.stringParams) {
+        this.register('hashTypes', '{}');
+      }
+    },
+    pushHash: function() {
+      this.hash = {values: [], types: []};
+    },
+    popHash: function() {
+      var hash = this.hash;
+      this.hash = undefined;
+
+      if (this.options.stringParams) {
+        this.register('hashTypes', '{' + hash.types.join(',') + '}');
+      }
+      this.push('{\n    ' + hash.values.join(',\n    ') + '\n  }');
    },

    // [pushString]
@@ -703,7 +795,8 @@ Handlebars.JavaScriptCompiler = function() {};
    //
    // Push an expression onto the stack
    push: function(expr) {
-      this.pushStack(expr);
+      this.inlineStack.push(expr);
+      return expr;
    },

    // [pushLiteral]
@@ -746,12 +839,14 @@ Handlebars.JavaScriptCompiler = function() {};
    invokeHelper: function(paramSize, name) {
      this.context.aliases.helperMissing = 'helpers.helperMissing';

-      var helper = this.lastHelper = this.setupHelper(paramSize, name);
-      this.register('foundHelper', helper.name);
+      var helper = this.lastHelper = this.setupHelper(paramSize, name, true);

-      this.pushStack("foundHelper ? foundHelper.call(" +
-        helper.callParams + ") " + ": helperMissing.call(" +
-        helper.helperMissingParams + ")");
+      this.push(helper.name);
+      this.replaceStack(function(name) {
+        return name + ' ? ' + name + '.call(' +
+            helper.callParams + ") " + ": helperMissing.call(" +
+            helper.helperMissingParams + ")";
+      });
    },

    // [invokeKnownHelper]
@@ -763,7 +858,7 @@ Handlebars.JavaScriptCompiler = function() {};
    // so a `helperMissing` fallback is not required.
    invokeKnownHelper: function(paramSize, name) {
      var helper = this.setupHelper(paramSize, name);
-      this.pushStack(helper.name + ".call(" + helper.callParams + ")");
+      this.push(helper.name + ".call(" + helper.callParams + ")");
    },

    // [invokeAmbiguous]
@@ -778,19 +873,18 @@ Handlebars.JavaScriptCompiler = function() {};
    // This operation emits more code than the other options,
    // and can be avoided by passing the `knownHelpers` and
    // `knownHelpersOnly` flags at compile-time.
-    invokeAmbiguous: function(name) {
+    invokeAmbiguous: function(name, helperCall) {
      this.context.aliases.functionType = '"function"';

-      this.pushStackLiteral('{}');
-      var helper = this.setupHelper(0, name);
+      this.pushStackLiteral('{}');    // Hash value
+      var helper = this.setupHelper(0, name, helperCall);

      var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');
-      this.register('foundHelper', helperName);

      var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context');
      var nextStack = this.nextStack();

-      this.source.push('if (foundHelper) { ' + nextStack + ' = foundHelper.call(' + helper.callParams + '); }');
+      this.source.push('if (' + nextStack + ' = ' + helperName + ') { ' + nextStack + ' = ' + nextStack + '.call(' + helper.callParams + '); }');
      this.source.push('else { ' + nextStack + ' = ' + nonHelper + '; ' + nextStack + ' = typeof ' + nextStack + ' === functionType ? ' + nextStack + '.apply(depth0) : ' + nextStack + '; }');
    },

@@ -809,7 +903,7 @@ Handlebars.JavaScriptCompiler = function() {};
      }

      this.context.aliases.self = "this";
-      this.pushStack("self.invokePartial(" + params.join(", ") + ");");
+      this.push("self.invokePartial(" + params.join(", ") + ")");
    },

    // [assignToHash]
@@ -820,10 +914,19 @@ Handlebars.JavaScriptCompiler = function() {};
    // Pops a value and hash off the stack, assigns `hash[key] = value`
    // and pushes the hash back onto the stack.
    assignToHash: function(key) {
-      var value = this.popStack();
-      var hash = this.topStack();
+      var value = this.popStack(),
+          type;

-      this.source.push(hash + "['" + key + "'] = " + value + ";");
+      if (this.options.stringParams) {
+        type = this.popStack();
+        this.popStack();
+      }
+
+      var hash = this.hash;
+      if (type) {
+        hash.types.push("'" + key + "': " + type);
+      }
+      hash.values.push("'" + key + "': (" + value + ")");
    },

    // HELPERS
@@ -837,11 +940,27 @@ Handlebars.JavaScriptCompiler = function() {};
        child = children[i];
        compiler = new this.compiler();

-        this.context.programs.push('');     // Placeholder to prevent name conflicts for nested children
-        var index = this.context.programs.length;
-        child.index = index;
-        child.name = 'program' + index;
-        this.context.programs[index] = compiler.compile(child, options, this.context);
+        var index = this.matchExistingProgram(child);
+
+        if (index == null) {
+          this.context.programs.push('');     // Placeholder to prevent name conflicts for nested children
+          index = this.context.programs.length;
+          child.index = index;
+          child.name = 'program' + index;
+          this.context.programs[index] = compiler.compile(child, options, this.context);
+          this.context.environments[index] = child;
+        } else {
+          child.index = index;
+          child.name = 'program' + index;
+        }
+      }
+    },
+    matchExistingProgram: function(child) {
+      for (var i = 0, len = this.context.environments.length; i < len; i++) {
+        var environment = this.context.environments[i];
+        if (environment && environment.equals(child)) {
+          return i;
+        }
      }
    },

@@ -885,50 +1004,111 @@ Handlebars.JavaScriptCompiler = function() {};
    },

    pushStackLiteral: function(item) {
-      this.compileStack.push(new Literal(item));
-      return item;
+      return this.push(new Literal(item));
    },

    pushStack: function(item) {
-      this.source.push(this.incrStack() + " = " + item + ";");
-      this.compileStack.push("stack" + this.stackSlot);
-      return "stack" + this.stackSlot;
+      this.flushInline();
+
+      var stack = this.incrStack();
+      if (item) {
+        this.source.push(stack + " = " + item + ";");
+      }
+      this.compileStack.push(stack);
+      return stack;
    },

    replaceStack: function(callback) {
-      var item = callback.call(this, this.topStack());
+      var prefix = '',
+          inline = this.isInline(),
+          stack;

-      this.source.push(this.topStack() + " = " + item + ";");
-      return "stack" + this.stackSlot;
+      // If we are currently inline then we want to merge the inline statement into the
+      // replacement statement via ','
+      if (inline) {
+        var top = this.popStack(true);
+
+        if (top instanceof Literal) {
+          // Literals do not need to be inlined
+          stack = top.value;
+        } else {
+          // Get or create the current stack name for use by the inline
+          var name = this.stackSlot ? this.topStackName() : this.incrStack();
+
+          prefix = '(' + this.push(name) + ' = ' + top + '),';
+          stack = this.topStack();
+        }
+      } else {
+        stack = this.topStack();
+      }
+
+      var item = callback.call(this, stack);
+
+      if (inline) {
+        if (this.inlineStack.length || this.compileStack.length) {
+          this.popStack();
+        }
+        this.push('(' + prefix + item + ')');
+      } else {
+        // Prevent modification of the context depth variable. Through replaceStack
+        if (!/^stack/.test(stack)) {
+          stack = this.nextStack();
+        }
+
+        this.source.push(stack + " = (" + prefix + item + ");");
+      }
+      return stack;
    },

-    nextStack: function(skipCompileStack) {
-      var name = this.incrStack();
-      this.compileStack.push("stack" + this.stackSlot);
-      return name;
+    nextStack: function() {
+      return this.pushStack();
    },

    incrStack: function() {
      this.stackSlot++;
      if(this.stackSlot > this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); }
+      return this.topStackName();
+    },
+    topStackName: function() {
      return "stack" + this.stackSlot;
    },
+    flushInline: function() {
+      var inlineStack = this.inlineStack;
+      if (inlineStack.length) {
+        this.inlineStack = [];
+        for (var i = 0, len = inlineStack.length; i < len; i++) {
+          var entry = inlineStack[i];
+          if (entry instanceof Literal) {
+            this.compileStack.push(entry);
+          } else {
+            this.pushStack(entry);
+          }
+        }
+      }
+    },
+    isInline: function() {
+      return this.inlineStack.length;
+    },

-    popStack: function() {
-      var item = this.compileStack.pop();
+    popStack: function(wrapped) {
+      var inline = this.isInline(),
+          item = (inline ? this.inlineStack : this.compileStack).pop();

-      if (item instanceof Literal) {
+      if (!wrapped && (item instanceof Literal)) {
        return item.value;
      } else {
-        this.stackSlot--;
+        if (!inline) {
+          this.stackSlot--;
+        }
        return item;
      }
    },

-    topStack: function() {
-      var item = this.compileStack[this.compileStack.length - 1];
+    topStack: function(wrapped) {
+      var stack = (this.isInline() ? this.inlineStack : this.compileStack),
+          item = stack[stack.length - 1];

-      if (item instanceof Literal) {
+      if (!wrapped && (item instanceof Literal)) {
        return item.value;
      } else {
        return item;
@@ -943,23 +1123,23 @@ Handlebars.JavaScriptCompiler = function() {};
        .replace(/\r/g, '\\r') + '"';
    },

-    setupHelper: function(paramSize, name) {
+    setupHelper: function(paramSize, name, missingParams) {
      var params = [];
-      this.setupParams(paramSize, params);
+      this.setupParams(paramSize, params, missingParams);
      var foundHelper = this.nameLookup('helpers', name, 'helper');

      return {
        params: params,
        name: foundHelper,
        callParams: ["depth0"].concat(params).join(", "),
-        helperMissingParams: ["depth0", this.quotedString(name)].concat(params).join(", ")
+        helperMissingParams: missingParams && ["depth0", this.quotedString(name)].concat(params).join(", ")
      };
    },

    // the params and contexts arguments are passed in arrays
    // to fill in
-    setupParams: function(paramSize, params) {
-      var options = [], contexts = [], param, inverse, program;
+    setupParams: function(paramSize, params, useRegister) {
+      var options = [], contexts = [], types = [], param, inverse, program;

      options.push("hash:" + this.popStack());

@@ -988,19 +1168,28 @@ Handlebars.JavaScriptCompiler = function() {};
        params.push(param);

        if(this.options.stringParams) {
+          types.push(this.popStack());
          contexts.push(this.popStack());
        }
      }

      if (this.options.stringParams) {
        options.push("contexts:[" + contexts.join(",") + "]");
+        options.push("types:[" + types.join(",") + "]");
+        options.push("hashTypes:hashTypes");
      }

      if(this.options.data) {
        options.push("data:data");
      }

-      params.push("{" + options.join(",") + "}");
+      options = "{" + options.join(",") + "}";
+      if (useRegister) {
+        this.register('options', options);
+        params.push('options');
+      } else {
+        params.push(options);
+      }
      return params.join(", ");
    }
  };
@@ -1038,20 +1227,32 @@ Handlebars.JavaScriptCompiler = function() {};

 })(Handlebars.Compiler, Handlebars.JavaScriptCompiler);

-Handlebars.precompile = function(string, options) {
-  options = options || {};
+Handlebars.precompile = function(input, options) {
+  if (!input || (typeof input !== 'string' && input.constructor !== Handlebars.AST.ProgramNode)) {
+    throw new Handlebars.Exception("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input);
+  }

-  var ast = Handlebars.parse(string);
+  options = options || {};
+  if (!('data' in options)) {
+    options.data = true;
+  }
+  var ast = Handlebars.parse(input);
  var environment = new Handlebars.Compiler().compile(ast, options);
  return new Handlebars.JavaScriptCompiler().compile(environment, options);
 };

-Handlebars.compile = function(string, options) {
-  options = options || {};
+Handlebars.compile = function(input, options) {
+  if (!input || (typeof input !== 'string' && input.constructor !== Handlebars.AST.ProgramNode)) {
+    throw new Handlebars.Exception("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input);
+  }

+  options = options || {};
+  if (!('data' in options)) {
+    options.data = true;
+  }
  var compiled;
  function compile() {
-    var ast = Handlebars.parse(string);
+    var ast = Handlebars.parse(input);
    var environment = new Handlebars.Compiler().compile(ast, options);
    var templateSpec = new Handlebars.JavaScriptCompiler().compile(environment, options, undefined, true);
    return Handlebars.template(templateSpec);