Finish ES6-style param and hash splatting

Author: machty

lib/handlebars/compiler/code-gen.js

@@ -6,7 +6,7 @@ let SourceNode;
 try {
   /* istanbul ignore next */
   if (typeof define !== 'function' || !define.amd) {
-    // We don't support this in AMD environments. For these environments, we asusme that
+    // We don't support this in AMD environments. For these environments, we assume that
     // they are running on the browser and thus have no need for the source-map library.
     let SourceMap = require('source-map');
     SourceNode = SourceMap.SourceNode;
@@ -107,8 +107,8 @@ CodeGen.prototype = {
     return new SourceNode(loc.start.line, loc.start.column, this.srcFile, chunk);
   },
 
-  functionCall: function(fn, type, params) {
-    params = this.generateList(params);
+  functionCall: function(fn, type, rawParams) {
+    let params = this.generateList(rawParams);
     return this.wrap([fn, type ? '.' + type + '(' : '(', params, ')']);
   },
 

lib/handlebars/compiler/compiler.js

@@ -156,11 +156,13 @@ Compiler.prototype = {
 
   DecoratorBlock(decorator) {
     let program = decorator.program && this.compileProgram(decorator.program);
-    let params = this.setupFullMustacheParams(decorator, program, undefined),
+    let setup = this.setupFullMustacheParams(decorator, program, undefined),
+        params = setup.params,
+        splatMap = setup.splatMap,
         path = decorator.path;
 
     this.useDecorators = true;
-    this.opcode('registerDecorator', params.length, path.original);
+    this.opcode('registerDecorator', params.length, path.original, splatMap);
   },
 
   PartialStatement: function(partial) {
@@ -199,6 +201,7 @@ Compiler.prototype = {
     this.opcode('invokePartial', isDynamic, partialName, indent);
     this.opcode('append');
   },
+
   PartialBlockStatement: function(partialBlock) {
     this.PartialStatement(partialBlock);
   },
@@ -212,11 +215,11 @@ Compiler.prototype = {
       this.opcode('append');
     }
   },
+
   Decorator(decorator) {
     this.DecoratorBlock(decorator);
   },
 
-
   ContentStatement: function(content) {
     if (content.value) {
       this.opcode('appendContent', content.value);
@@ -261,20 +264,22 @@ Compiler.prototype = {
   },
 
   helperSexpr: function(sexpr, program, inverse) {
-    let params = this.setupFullMustacheParams(sexpr, program, inverse),
+    let setup = this.setupFullMustacheParams(sexpr, program, inverse),
+        params = setup.params,
+        splatMap = setup.splatMap,
         path = sexpr.path,
         name = path.parts[0];
 
     if (this.options.knownHelpers[name]) {
-      this.opcode('invokeKnownHelper', params.length, name);
+      this.opcode('invokeKnownHelper', params.length, name, splatMap);
     } else if (this.options.knownHelpersOnly) {
       throw new Exception('You specified knownHelpersOnly, but used the unknown helper ' + name, sexpr);
     } else {
       path.strict = true;
       path.falsy = true;
 
       this.accept(path);
-      this.opcode('invokeHelper', params.length, path.original, AST.helpers.simpleId(path));
+      this.opcode('invokeHelper', params.length, path.original, AST.helpers.simpleId(path), splatMap);
     }
   },
 
@@ -321,28 +326,35 @@ Compiler.prototype = {
 
   Hash: function(hash) {
     let pairs = hash.pairs,
-        i = 0, splat = null,
+        i = 0,
         l = pairs.length;
 
     this.opcode('pushHash');
-    for (; i < l; i++) {
 
+    while (i < l) {
       if (pairs[i].type === 'Splat') {
-        if (splat !== null) {
-          throw new Exception('Multiple splats are not supported yet');
+        this.pushParam(pairs[i].value);
+        this.opcode('pushSplatHashPiece');
+        ++i;
+      } else {
+        let start = i;
+        let end = i;
+        while (end < l && pairs[end].type == 'HashPair') {
+          ++end;
         }
-        splat = pairs[i].value;
-        continue;
-      }
-      this.pushParam(pairs[i].value);
-    }
-    while (i--) {
-      if (pairs[i].type === 'Splat') {
-        continue;
+
+        this.opcode('pushHashPiece');
+        for (let g = start; g < end; ++g) {
+          let pair = pairs[g];
+          this.pushParam(pair.value);
+          this.opcode('assignToHash', pair.key);
+        }
+
+        i = end;
       }
-      this.opcode('assignToHash', pairs[i].key);
     }
-    this.opcode('popHash', splat);
+
+    this.opcode('popHash');
   },
 
   // HELPERS
@@ -394,19 +406,25 @@ Compiler.prototype = {
     }
   },
 
-  pushParams: function(params) {
-    for (let i = 0, l = params.length; i < l; i++) {
-      this.pushParam(params[i]);
-    }
-  },
-
   pushParam: function(val) {
     this.accept(val);
   },
 
   setupFullMustacheParams: function(sexpr, program, inverse, omitEmpty) {
     let params = sexpr.params;
-    this.pushParams(params);
+
+    let splatMap = [];
+    for (let i = 0, l = params.length; i < l; i++) {
+      let p = params[i];
+      this.pushParam(p);
+      if (p.splat) {
+        splatMap.push(i);
+      }
+    }
+
+    if (splatMap.length === 0) {
+      splatMap = null;
+    }
 
     this.opcode('pushProgram', program);
     this.opcode('pushProgram', inverse);
@@ -417,7 +435,7 @@ Compiler.prototype = {
       this.opcode('emptyHash', omitEmpty);
     }
 
-    return params;
+    return { params, splatMap };
   },
 
   blockParamIndex: function(name) {

lib/handlebars/compiler/javascript-compiler.js

@@ -499,20 +499,53 @@ JavaScriptCompiler.prototype = {
     this.pushStackLiteral(omitEmpty ? 'undefined' : '{}');
   },
   pushHash: function() {
-    if (this.hash) {
-      this.hashes.push(this.hash);
+    if (this.hashPieces) {
+      this.hashes.push(this.hashPieces);
     }
-    this.hash = {values: [], types: [], contexts: [], ids: []};
+    this.hashPieces = [];
   },
-  popHash: function(splat) {
-    let hash = this.hash;
-    this.hash = this.hashes.pop();
-
-    this.push(this.objectLiteral(hash.values));
-    if (splat) {
-      let splatIdentifier = 'depth' + splat.depth + '.' + splat.original; // or parts[0] ? what's the different
-      this.push([this.aliasable('container.splat'), '(', this.popStack(), ', ', splatIdentifier, ')']);
+  popHash: function() {
+    let hashPieces = this.hashPieces;
+    this.hashPieces = this.hashes.pop();
+    this.hashPiece = this.hashPieces && this.hashPieces[this.hashPieces.length - 1];
+
+    let splatParams = [];
+    for (let i = 0, l = hashPieces.length; i < l; ++i) {
+      let piece = hashPieces[i];
+      if (piece.type === 'pairs') {
+        splatParams.push(this.objectLiteral(piece.values));
+      } else {
+        splatParams.push(piece.value);
+      }
     }
+
+    if (hashPieces.length === 1) {
+      // don't splat(); just use single piece as hash
+      this.push(splatParams[0]);
+    } else {
+      if (hashPieces[0].type === 'splat') {
+        // we merge into an empty POJO so that we don't mutate first splat param
+        splatParams.unshift('{}');
+      }
+
+      this.push([this.aliasable('container.splat'), '('].concat(splatParams.join(','), ')'));
+    }
+  },
+
+  pushHashPiece: function() {
+    this.hashPiece = {type: 'pairs', values: {}};
+    this.hashPieces.push(this.hashPiece);
+  },
+
+  // [pushSplatHashPiece]
+  //
+  // On stack, before: value, ..., hash, ...
+  // On stack, after: ..., hash, ...
+  //
+  // Pops a splat value off the stack and pushes it to hashPieces
+  pushSplatHashPiece: function() {
+    this.hashPiece = null;
+    this.hashPieces.push({ type: 'splat', value: this.popStack() });
   },
 
   // [pushString]
@@ -580,7 +613,7 @@ JavaScriptCompiler.prototype = {
   // and pushes the helper's return value onto the stack.
   //
   // If the helper is not found, `helperMissing` is called.
-  invokeHelper: function(paramSize, name, isSimple) {
+  invokeHelper: function(paramSize, name, isSimple, splatMap) {
     let nonHelper = this.popStack(),
         helper = this.setupHelper(paramSize, name),
         simple = isSimple ? [helper.name, ' || '] : '';
@@ -591,7 +624,7 @@ JavaScriptCompiler.prototype = {
     }
     lookup.push(')');
 
-    this.push(this.source.functionCall(lookup, 'call', helper.callParams));
+    this.push(this.helperFunctionCall(lookup, helper, splatMap));
   },
 
   // [invokeKnownHelper]
@@ -601,9 +634,9 @@ JavaScriptCompiler.prototype = {
   //
   // This operation is used when the helper is known to exist,
   // so a `helperMissing` fallback is not required.
-  invokeKnownHelper: function(paramSize, name) {
+  invokeKnownHelper: function(paramSize, name, splatMap) {
     let helper = this.setupHelper(paramSize, name);
-    this.push(this.source.functionCall(helper.name, 'call', helper.callParams));
+    this.push(this.helperFunctionCall(helper.name, helper, splatMap));
   },
 
   // [invokeAmbiguous]
@@ -641,10 +674,27 @@ JavaScriptCompiler.prototype = {
         '(', lookup,
         (helper.paramsInit ? ['),(', helper.paramsInit] : []), '),',
         '(typeof helper === ', this.aliasable('"function"'), ' ? ',
-        this.source.functionCall('helper', 'call', helper.callParams), ' : helper))'
+        this.helperFunctionCall('helper', helper, null), ' : helper))'
     ]);
   },
 
+  helperFunctionCall: function(helperName, helperOptions, splatMap) {
+    if (splatMap) {
+      let splatMapObj = {};
+      for (let i = 0, l = splatMap.length; i < l; ++i) {
+        splatMapObj[splatMap[i]] = 1;
+      }
+
+      let argsWithSplatMap = helperOptions.params.slice();
+      argsWithSplatMap.push(this.objectLiteral(splatMapObj));
+      let splattedArgs = this.source.functionCall(this.aliasable('container.splatArgs'), null, argsWithSplatMap);
+      return this.source.functionCall(helperName, 'apply', [helperOptions.callContext, splattedArgs]);
+    } else {
+      let args = [helperOptions.callContext].concat(helperOptions.params);
+      return this.source.functionCall(helperName, 'call', args);
+    }
+  },
+
   // [invokePartial]
   //
   // On stack, before: context, ...
@@ -688,9 +738,9 @@ JavaScriptCompiler.prototype = {
   // On stack, before: value, ..., hash, ...
   // On stack, after: ..., hash, ...
   //
-  // Pops a value off the stack and assigns it to the current hash
+  // Pops a value off the stack and assigns it to the current hash piece
   assignToHash: function(key) {
-    this.hash.values[key] = this.popStack();
+    this.hashPiece.values[key] = this.popStack();
   },
 
   // HELPERS
@@ -911,13 +961,14 @@ JavaScriptCompiler.prototype = {
     let params = [],
         paramsInit = this.setupHelperArgs(name, paramSize, params, blockHelper);
     let foundHelper = this.nameLookup('helpers', name, 'helper'),
-        callContext = this.aliasable(`${this.contextName(0)} != null ? ${this.contextName(0)} : {}`);
+        contextName = this.contextName(0),
+        callContext = this.aliasable(`${contextName} != null ? ${contextName} : {}`);
 
     return {
-      params: params,
-      paramsInit: paramsInit,
+      params,
+      paramsInit,
       name: foundHelper,
-      callParams: [callContext].concat(params)
+      callContext
     };
   },
 

lib/handlebars/compiler/printer.js

@@ -131,7 +131,9 @@ PrintVisitor.prototype.SubExpression = function(sexpr) {
 
 PrintVisitor.prototype.PathExpression = function(id) {
   let path = id.parts.join('/');
-  return (id.data ? '@' : '') + 'PATH:' + path;
+  let pathFormatted = id.splat ? `SPLAT{PATH:${path}}` : `PATH:${path}`;
+
+  return `${id.data ? '@' : ''}${pathFormatted}`;
 };
 
 

lib/handlebars/runtime.js

@@ -85,8 +85,21 @@ export function template(templateSpec, env) {
       return typeof current === 'function' ? current.call(context) : current;
     },
 
-    splat: function(current, context) {
-      return Utils.extend(context, current);
+    splat: function() {
+      return Utils.extend.apply(null, arguments);
+    },
+
+    splatArgs: function() {
+      let splatMap = arguments[arguments.length - 1];
+      let args = [];
+      for (let i = 0, l = arguments.length - 1; i < l; ++i) {
+        if (splatMap[i]) {
+          args.push.apply(args, arguments[i]);
+        } else {
+          args.push(arguments[i]);
+        }
+      }
+      return args;
     },
 
     escapeExpression: Utils.escapeExpression,