Splat operator

Author: BenjaminHorn

lib/handlebars/compiler/compiler.js

@@ -323,18 +323,28 @@ Compiler.prototype = {
 
   Hash: function(hash) {
     let pairs = hash.pairs,
-        i = 0,
+        i = 0, splat = null,
         l = pairs.length;
 
     this.opcode('pushHash');
-
     for (; i < l; i++) {
+
+      if (pairs[i].type === 'Splat') {
+        if (splat !== null) {
+          throw new Exception('Multiple splats are not supported yet');
+        }
+        splat = pairs[i].value;
+        continue;
+      }
       this.pushParam(pairs[i].value);
     }
     while (i--) {
+      if (pairs[i].type === 'Splat') {
+        continue;
+      }
       this.opcode('assignToHash', pairs[i].key);
     }
-    this.opcode('popHash');
+    this.opcode('popHash', splat);
   },
 
   // HELPERS

lib/handlebars/compiler/javascript-compiler.js

@@ -421,7 +421,6 @@ JavaScriptCompiler.prototype = {
   // it onto the stack.
   lookupOnContext: function(parts, falsy, strict, scoped) {
     let i = 0;
-
     if (!scoped && this.options.compat && !this.lastContext) {
       // The depthed query is expected to handle the undefined logic for the root level that
       // is implemented below, so we evaluate that directly in compat mode
@@ -537,7 +536,7 @@ JavaScriptCompiler.prototype = {
     }
     this.hash = {values: [], types: [], contexts: [], ids: []};
   },
-  popHash: function() {
+  popHash: function(splat) {
     let hash = this.hash;
     this.hash = this.hashes.pop();
 
@@ -550,6 +549,10 @@ JavaScriptCompiler.prototype = {
     }
 
     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, ')']);
+    }
   },
 
   // [pushString]
@@ -1008,6 +1011,7 @@ JavaScriptCompiler.prototype = {
     }
 
     options.name = this.quotedString(helper);
+
     options.hash = this.popStack();
 
     if (this.trackIds) {

lib/handlebars/compiler/printer.js

@@ -168,4 +168,8 @@ PrintVisitor.prototype.Hash = function(hash) {
 PrintVisitor.prototype.HashPair = function(pair) {
   return pair.key + '=' + this.accept(pair.value);
 };
+
+PrintVisitor.prototype.Splat = function(splat) {
+  return 'SPLAT{' + this.accept(splat.value) + '}';
+};
 /* eslint-enable new-cap */

lib/handlebars/runtime.js

@@ -88,6 +88,10 @@ export function template(templateSpec, env) {
       return typeof current === 'function' ? current.call(context) : current;
     },
 
+    splat: function(current, context) {
+      return Utils.extend(context, current);
+    },
+
     escapeExpression: Utils.escapeExpression,
     invokePartial: invokePartialWrapper,
 

spec/helpers.js

@@ -737,4 +737,82 @@ describe('helpers', function() {
       shouldCompileTo('{{#if bar}}{{else goodbyes as |value|}}{{value}}{{/if}}{{value}}', [hash, helpers], '1foo');
     });
   });
+
+  describe('splat operators', function() {
+
+    it('basic splat test', function() {
+      var string = '{{hello  **splat }}';
+      var hash = {splat: {firstName: 'Guybrush', lastName: 'Threepwood'}};
+      var helpers = {
+        hello: function(options) {
+          var hash = options.hash;
+          return 'Hi, my name is ' + hash.firstName + ' ' + hash.lastName;
+        }
+      };
+
+      shouldCompileTo(string, [hash, helpers], 'Hi, my name is Guybrush Threepwood');
+    });
+
+    it('fails with multiple splats', function() {
+      var string = '{{foo **bar **baz}}';
+      shouldThrow(function() {
+        CompilerContext.compile(string);
+      }, Error);
+
+    });
+
+    it('splat shadowing', function() {
+      var string = '{{helper **splat occupation="pirate" }}';
+      var hash = {splat: {occupation: 'cannonball'}};
+      var helpers = {
+        helper: function(options) {
+          var hash = options.hash;
+          return 'I want to be a ' + hash.occupation + '!';
+        }
+      };
+
+      shouldCompileTo(string, [hash, helpers], 'I want to be a pirate!');
+    });
+
+    it('splat test', function() {
+      var template = CompilerContext.compile('{{helper **foo.splat character=character }}');
+
+      var helpers = {
+        helper: function(options) {
+          return options.hash.character + ' and the ' + options.hash.numberOfHeads + ' monkey on ' + options.hash.island + ' Island';
+        }
+      };
+
+      var context = {foo: { splat: {numberOfHeads: '3 headed', island: 'Dinky'}}, character: 'Guybrush'};
+
+      var result = template(context, {helpers: helpers});
+      equals(result, 'Guybrush and the 3 headed monkey on Dinky Island', 'Splat test');
+    });
+
+    it('splat with function', function() {
+      var template = CompilerContext.compile('{{helper **foo character=character }}');
+
+      var helpers = {
+        helper: function(options) {
+          var hash = options.hash;
+          return hash.character + ' and the ' + hash.numberOfHeads + ' monkey on ' + hash.format(hash.island) + ' Island';
+        }
+      };
+
+      var context = {
+        foo: {
+          numberOfHeads: '3 headed',
+          island: 'Dinky',
+          format: function(str) {
+            return str.toUpperCase();
+          }
+        },
+        character: 'Guybrush'
+      };
+
+      var result = template(context, {helpers: helpers});
+      equals(result, 'Guybrush and the 3 headed monkey on DINKY Island', 'Splat function test');
+    });
+
+  });
 });

spec/parser.js

@@ -93,6 +93,12 @@ describe('parser', function() {
     equals(astFor('{{foo omg bar=baz bat=\"bam\" baz=false}}'), '{{ PATH:foo [PATH:omg] HASH{bar=PATH:baz, bat="bam", baz=BOOLEAN{false}} }}\n');
   });
 
+  it('parses splat', function() {
+    equals(astFor('{{foo **bar}}'), '{{ PATH:foo [] HASH{SPLAT{PATH:bar}} }}\n');
+    equals(astFor('{{foo ** bar}}'), '{{ PATH:foo [] HASH{SPLAT{PATH:bar}} }}\n');
+    equals(astFor('{{foo **bar baz=bat}}'), '{{ PATH:foo [] HASH{SPLAT{PATH:bar}, baz=PATH:bat} }}\n');
+  });
+
   it('parses contents followed by a mustache', function() {
     equals(astFor('foo bar {{baz}}'), 'CONTENT[ \'foo bar \' ]\n{{ PATH:baz [] }}\n');
   });
@@ -215,6 +221,10 @@ describe('parser', function() {
     shouldThrow(function() {
       astFor('{{{{goodbyes}}}} {{{{/hellos}}}}');
     }, Error, /goodbyes doesn't match hellos/);
+
+    shouldThrow(function() {
+      astFor('{{foo **}}');
+    }, Error, /Parse error on line 1/);
   });
 
   it('should handle invalid paths', function() {

spec/tokenizer.js

@@ -376,6 +376,14 @@ describe('Tokenizer', function() {
     shouldBeToken(result[2], 'ID', 'omg');
   });
 
+  it('tokenizes splat', function() {
+    var result = tokenize('{{foo **bar}}');
+    shouldMatchTokens(result, ['OPEN', 'ID', 'SPLAT', 'ID', 'CLOSE']);
+
+    result = tokenize('{{foo ** bar}}');
+    shouldMatchTokens(result, ['OPEN', 'ID', 'SPLAT', 'ID', 'CLOSE']);
+  });
+
   it('tokenizes special @ identifiers', function() {
     var result = tokenize('{{ @foo }}');
     shouldMatchTokens(result, ['OPEN', 'DATA', 'ID', 'CLOSE']);

src/handlebars.l

@@ -12,7 +12,7 @@ function strip(start, end) {
 LEFT_STRIP    "~"
 RIGHT_STRIP   "~"
 
-LOOKAHEAD           [=~}\s\/.)|]
+LOOKAHEAD           [=~}\s\/.)|*]
 LITERAL_LOOKAHEAD   [~}\s)]
 
 /*
@@ -119,7 +119,7 @@ ID    [^\s!"#%-,\.\/;->@\[-\^`\{-~]+/{LOOKAHEAD}
 <mu>"|"                          return 'CLOSE_BLOCK_PARAMS';
 
 <mu>{ID}                         return 'ID';
-
+<mu>"**"                         return 'SPLAT'
 <mu>'['('\\]'|[^\]])*']'         yytext = yytext.replace(/\\([\\\]])/g,'$1'); return 'ID';
 <mu>.                            return 'INVALID';
 

src/handlebars.yy

@@ -89,6 +89,7 @@ mustache
   | OPEN_UNESCAPED helperName param* hash? CLOSE_UNESCAPED -> yy.prepareMustache($2, $3, $4, $1, yy.stripFlags($1, $5), @$)
   ;
 
+
 partial
   : OPEN_PARTIAL partialName param* hash? CLOSE {
     $$ = {
@@ -131,6 +132,7 @@ hash
 
 hashSegment
   : ID EQUALS param -> {type: 'HashPair', key: yy.id($1), value: $3, loc: yy.locInfo(@$)}
+  | SPLAT param -> {type: 'Splat', value: $2, loc: yy.locInfo(@$)}  
   ;
 
 blockParams