@handlebars/parser 2.0.0 → 2.2.0

package/lib/helpers.js

@@ -1,4 +1,4 @@
-import Exception from './exception';
+import Exception from './exception.js';
 
 function validateClose(open, close) {
   close = close.path ? close.path.original : close;
@@ -17,11 +17,11 @@ export function SourceLocation(source, locInfo) {
   this.source = source;
   this.start = {
     line: locInfo.first_line,
-    column: locInfo.first_column
+    column: locInfo.first_column,
   };
   this.end = {
     line: locInfo.last_line,
-    column: locInfo.last_column
+    column: locInfo.last_column,
   };
 }
 
@@ -36,7 +36,7 @@ export function id(token) {
 export function stripFlags(open, close) {
   return {
     open: open.charAt(2) === '~',
-    close: close.charAt(close.length - 3) === '~'
+    close: close.charAt(close.length - 3) === '~',
   };
 }
 
@@ -44,38 +44,56 @@ export function stripComment(comment) {
   return comment.replace(/^\{\{~?!-?-?/, '').replace(/-?-?~?\}\}$/, '');
 }
 
-export function preparePath(data, parts, loc) {
+export function preparePath(data, sexpr, parts, loc) {
   loc = this.locInfo(loc);
 
-  let original = data ? '@' : '',
-    dig = [],
-    depth = 0;
+  let original;
+
+  if (data) {
+    original = '@';
+  } else if (sexpr) {
+    original = sexpr.original + '.';
+  } else {
+    original = '';
+  }
+
+  let tail = [];
+  let depth = 0;
 
   for (let i = 0, l = parts.length; i < l; i++) {
-    let part = parts[i].part,
-      // If we have [] syntax then we do not treat path references as operators,
-      // i.e. foo.[this] resolves to approximately context.foo['this']
-      isLiteral = parts[i].original !== part;
-    original += (parts[i].separator || '') + part;
+    let part = parts[i].part;
+    // If we have [] syntax then we do not treat path references as operators,
+    // i.e. foo.[this] resolves to approximately context.foo['this']
+    let isLiteral = parts[i].original !== part;
+    let separator = parts[i].separator;
+
+    let partPrefix = separator === '.#' ? '#' : '';
+
+    original += (separator || '') + part;
 
     if (!isLiteral && (part === '..' || part === '.' || part === 'this')) {
-      if (dig.length > 0) {
+      if (tail.length > 0) {
         throw new Exception('Invalid path: ' + original, { loc });
       } else if (part === '..') {
         depth++;
       }
     } else {
-      dig.push(part);
+      tail.push(`${partPrefix}${part}`);
     }
   }
 
+  let head = sexpr || tail.shift();
+
   return {
     type: 'PathExpression',
+    this: original.startsWith('this.'),
     data,
     depth,
-    parts: dig,
+    head,
+    tail,
+    parts: head ? [head, ...tail] : tail,
     original,
-    loc
+    loc,
   };
 }
 
@@ -92,7 +110,7 @@ export function prepareMustache(path, params, hash, open, strip, locInfo) {
     hash,
     escaped,
     strip,
-    loc: this.locInfo(locInfo)
+    loc: this.locInfo(locInfo),
   };
 }
 
@@ -104,7 +122,7 @@ export function prepareRawBlock(openRawBlock, contents, close, locInfo) {
     type: 'Program',
     body: contents,
     strip: {},
-    loc: locInfo
+    loc: locInfo,
   };
 
   return {
@@ -116,7 +134,7 @@ export function prepareRawBlock(openRawBlock, contents, close, locInfo) {
     openStrip: {},
     inverseStrip: {},
     closeStrip: {},
-    loc: locInfo
+    loc: locInfo,
   };
 }
 
@@ -170,7 +188,7 @@ export function prepareBlock(
     openStrip: openBlock.strip,
     inverseStrip,
     closeStrip: close && close.strip,
-    loc: this.locInfo(locInfo)
+    loc: this.locInfo(locInfo),
   };
 }
 
@@ -185,12 +203,12 @@ export function prepareProgram(statements, loc) {
         source: firstLoc.source,
         start: {
           line: firstLoc.start.line,
-          column: firstLoc.start.column
+          column: firstLoc.start.column,
         },
         end: {
           line: lastLoc.end.line,
-          column: lastLoc.end.column
-        }
+          column: lastLoc.end.column,
+        },
       };
     }
   }
@@ -199,7 +217,7 @@ export function prepareProgram(statements, loc) {
     type: 'Program',
     body: statements,
     strip: {},
-    loc: loc
+    loc: loc,
   };
 }
 
@@ -214,6 +232,6 @@ export function preparePartialBlock(open, program, close, locInfo) {
     program,
     openStrip: open.strip,
     closeStrip: close && close.strip,
-    loc: this.locInfo(locInfo)
+    loc: this.locInfo(locInfo),
   };
 }

package/lib/index.js

@@ -1,6 +1,6 @@
-export { default as Visitor } from './visitor';
-export { default as WhitespaceControl } from './whitespace-control';
-export { default as parser } from './parser';
-export { default as Exception } from './exception';
-export { print, PrintVisitor } from './printer';
-export { parse, parseWithoutProcessing } from './parse';
+export { default as Visitor } from './visitor.js';
+export { default as WhitespaceControl } from './whitespace-control.js';
+export { default as parser } from './parser.js';
+export { default as Exception } from './exception.js';
+export { print, PrintVisitor } from './printer.js';
+export { parse, parseWithoutProcessing } from './parse.js';

package/lib/parse.js

@@ -1,6 +1,6 @@
-import parser from './parser';
-import WhitespaceControl from './whitespace-control';
-import * as Helpers from './helpers';
+import parser from './parser.js';
+import WhitespaceControl from './whitespace-control.js';
+import * as Helpers from './helpers.js';
 
 let baseHelpers = {};
 
@@ -19,13 +19,50 @@ export function parseWithoutProcessing(input, options) {
   parser.yy = baseHelpers;
 
   // Altering the shared object here, but this is ok as parser is a sync operation
-  parser.yy.locInfo = function(locInfo) {
+  parser.yy.locInfo = function (locInfo) {
     return new Helpers.SourceLocation(options && options.srcName, locInfo);
   };
 
-  let ast = parser.parse(input);
+  let squareSyntax;
 
-  return ast;
+  if (typeof options?.syntax?.square === 'function') {
+    squareSyntax = options.syntax.square;
+  } else if (options?.syntax?.square === 'node') {
+    squareSyntax = arrayLiteralNode;
+  } else {
+    squareSyntax = 'string';
+  }
+
+  let hashSyntax;
+
+  if (typeof options?.syntax?.hash === 'function') {
+    hashSyntax = options.syntax.hash;
+  } else {
+    hashSyntax = hashLiteralNode;
+  }
+
+  parser.yy.syntax = {
+    square: squareSyntax,
+    hash: hashSyntax,
+  };
+
+  return parser.parse(input);
+}
+
+function arrayLiteralNode(array, loc) {
+  return {
+    type: 'ArrayLiteral',
+    items: array,
+    loc,
+  };
+}
+
+function hashLiteralNode(hash, loc) {
+  return {
+    type: 'HashLiteral',
+    pairs: hash.pairs,
+    loc,
+  };
 }
 
 export function parse(input, options) {

package/lib/printer.js

@@ -1,5 +1,5 @@
 /* eslint-disable new-cap */
-import Visitor from './visitor';
+import Visitor from './visitor.js';
 
 export function print(ast) {
   return new PrintVisitor().accept(ast);
@@ -11,7 +11,7 @@ export function PrintVisitor() {
 
 PrintVisitor.prototype = new Visitor();
 
-PrintVisitor.prototype.pad = function(string) {
+PrintVisitor.prototype.pad = function (string) {
   let out = '';
 
   for (let i = 0, l = this.padding; i < l; i++) {
@@ -22,7 +22,7 @@ PrintVisitor.prototype.pad = function(string) {
   return out;
 };
 
-PrintVisitor.prototype.Program = function(program) {
+PrintVisitor.prototype.Program = function (program) {
   let out = '',
     body = program.body,
     i,
@@ -46,47 +46,50 @@ PrintVisitor.prototype.Program = function(program) {
   return out;
 };
 
-PrintVisitor.prototype.MustacheStatement = function(mustache) {
-  return this.pad('{{ ' + this.SubExpression(mustache) + ' }}');
+PrintVisitor.prototype.MustacheStatement = function (mustache) {
+  if (mustache.params.length > 0 || mustache.hash) {
+    return this.pad('{{ ' + this.callBody(mustache) + ' }}');
+  } else {
+    return this.pad('{{ ' + this.accept(mustache.path) + ' }}');
+  }
 };
-PrintVisitor.prototype.Decorator = function(mustache) {
-  return this.pad('{{ DIRECTIVE ' + this.SubExpression(mustache) + ' }}');
+PrintVisitor.prototype.Decorator = function (mustache) {
+  return this.pad('{{ DIRECTIVE ' + this.callBody(mustache) + ' }}');
 };
 
-PrintVisitor.prototype.BlockStatement = PrintVisitor.prototype.DecoratorBlock = function(
-  block
-) {
-  let out = '';
+PrintVisitor.prototype.BlockStatement = PrintVisitor.prototype.DecoratorBlock =
+  function (block) {
+    let out = '';
 
-  out += this.pad(
-    (block.type === 'DecoratorBlock' ? 'DIRECTIVE ' : '') + 'BLOCK:'
-  );
-  this.padding++;
-  out += this.pad(this.SubExpression(block));
-  if (block.program) {
-    out += this.pad('PROGRAM:');
+    out += this.pad(
+      (block.type === 'DecoratorBlock' ? 'DIRECTIVE ' : '') + 'BLOCK:'
+    );
     this.padding++;
-    out += this.accept(block.program);
-    this.padding--;
-  }
-  if (block.inverse) {
+    out += this.pad(this.callBody(block));
     if (block.program) {
+      out += this.pad('PROGRAM:');
       this.padding++;
+      out += this.accept(block.program);
+      this.padding--;
     }
-    out += this.pad('{{^}}');
-    this.padding++;
-    out += this.accept(block.inverse);
-    this.padding--;
-    if (block.program) {
+    if (block.inverse) {
+      if (block.program) {
+        this.padding++;
+      }
+      out += this.pad('{{^}}');
+      this.padding++;
+      out += this.accept(block.inverse);
       this.padding--;
+      if (block.program) {
+        this.padding--;
+      }
     }
-  }
-  this.padding--;
+    this.padding--;
 
-  return out;
-};
+    return out;
+  };
 
-PrintVisitor.prototype.PartialStatement = function(partial) {
+PrintVisitor.prototype.PartialStatement = function (partial) {
   let content = 'PARTIAL:' + partial.name.original;
   if (partial.params[0]) {
     content += ' ' + this.accept(partial.params[0]);
@@ -96,7 +99,7 @@ PrintVisitor.prototype.PartialStatement = function(partial) {
   }
   return this.pad('{{> ' + content + ' }}');
 };
-PrintVisitor.prototype.PartialBlockStatement = function(partial) {
+PrintVisitor.prototype.PartialBlockStatement = function (partial) {
   let content = 'PARTIAL BLOCK:' + partial.name.original;
   if (partial.params[0]) {
     content += ' ' + this.accept(partial.params[0]);
@@ -113,16 +116,20 @@ PrintVisitor.prototype.PartialBlockStatement = function(partial) {
   return this.pad('{{> ' + content + ' }}');
 };
 
-PrintVisitor.prototype.ContentStatement = function(content) {
+PrintVisitor.prototype.ContentStatement = function (content) {
   return this.pad("CONTENT[ '" + content.value + "' ]");
 };
 
-PrintVisitor.prototype.CommentStatement = function(comment) {
+PrintVisitor.prototype.CommentStatement = function (comment) {
   return this.pad("{{! '" + comment.value + "' }}");
 };
 
-PrintVisitor.prototype.SubExpression = function(sexpr) {
-  let params = sexpr.params,
+PrintVisitor.prototype.SubExpression = function (sexpr) {
+  return `(${this.callBody(sexpr)})`;
+};
+
+PrintVisitor.prototype.callBody = function (callExpr) {
+  let params = callExpr.params,
     paramStrings = [],
     hash;
 
@@ -130,49 +137,75 @@ PrintVisitor.prototype.SubExpression = function(sexpr) {
     paramStrings.push(this.accept(params[i]));
   }
 
-  params = '[' + paramStrings.join(', ') + ']';
+  params =
+    paramStrings.length === 0 ? '' : ' [' + paramStrings.join(', ') + ']';
 
-  hash = sexpr.hash ? ' ' + this.accept(sexpr.hash) : '';
+  hash = callExpr.hash ? ' ' + this.accept(callExpr.hash) : '';
 
-  return this.accept(sexpr.path) + ' ' + params + hash;
+  return this.accept(callExpr.path) + params + hash;
 };
 
-PrintVisitor.prototype.PathExpression = function(id) {
-  let path = id.parts.join('/');
-  return (id.data ? '@' : '') + 'PATH:' + path;
+PrintVisitor.prototype.PathExpression = function (id) {
+  let head =
+    typeof id.head === 'string' ? id.head : `[${this.accept(id.head)}]`;
+  let path = [head, ...id.tail].join('/');
+  return 'p%' + prefix(id) + path;
 };
 
-PrintVisitor.prototype.StringLiteral = function(string) {
+function prefix(path) {
+  if (path.data) {
+    return '@';
+  } else if (path.this) {
+    return 'this.';
+  } else {
+    return '';
+  }
+}
+
+PrintVisitor.prototype.StringLiteral = function (string) {
   return '"' + string.value + '"';
 };
 
-PrintVisitor.prototype.NumberLiteral = function(number) {
-  return 'NUMBER{' + number.value + '}';
+PrintVisitor.prototype.NumberLiteral = function (number) {
+  return 'n%' + number.value;
 };
 
-PrintVisitor.prototype.BooleanLiteral = function(bool) {
-  return 'BOOLEAN{' + bool.value + '}';
+PrintVisitor.prototype.BooleanLiteral = function (bool) {
+  return 'b%' + bool.value;
 };
 
-PrintVisitor.prototype.UndefinedLiteral = function() {
+PrintVisitor.prototype.UndefinedLiteral = function () {
   return 'UNDEFINED';
 };
 
-PrintVisitor.prototype.NullLiteral = function() {
+PrintVisitor.prototype.NullLiteral = function () {
   return 'NULL';
 };
 
-PrintVisitor.prototype.Hash = function(hash) {
+PrintVisitor.prototype.ArrayLiteral = function (array) {
+  return `Array[${array.items.map((item) => this.accept(item)).join(', ')}]`;
+};
+
+PrintVisitor.prototype.HashLiteral = function (hash) {
+  return `Hash{${this.hashPairs(hash)}}`;
+};
+
+PrintVisitor.prototype.Hash = function (hash) {
+  return `HASH{${this.hashPairs(hash)}}`;
+};
+
+PrintVisitor.prototype.hashPairs = function (hash) {
   let pairs = hash.pairs,
     joinedPairs = [];
 
   for (let i = 0, l = pairs.length; i < l; i++) {
-    joinedPairs.push(this.accept(pairs[i]));
+    joinedPairs.push(this.HashPair(pairs[i]));
   }
 
-  return 'HASH{' + joinedPairs.join(', ') + '}';
+  return joinedPairs.join(' ');
 };
-PrintVisitor.prototype.HashPair = function(pair) {
+
+PrintVisitor.prototype.HashPair = function (pair) {
   return pair.key + '=' + this.accept(pair.value);
 };
 /* eslint-enable new-cap */

package/lib/visitor.js

@@ -1,4 +1,4 @@
-import Exception from './exception';
+import Exception from './exception.js';
 
 function Visitor() {
   this.parents = [];
@@ -9,7 +9,7 @@ Visitor.prototype = {
   mutating: false,
 
   // Visits a given value. If mutating, will replace the value if necessary.
-  acceptKey: function(node, name) {
+  acceptKey: function (node, name) {
     let value = this.accept(node[name]);
     if (this.mutating) {
       // Hacky sanity check: This may have a few false positives for type for the helper
@@ -30,7 +30,7 @@ Visitor.prototype = {
 
   // Performs an accept operation with added sanity check to ensure
   // required keys are not removed.
-  acceptRequired: function(node, name) {
+  acceptRequired: function (node, name) {
     this.acceptKey(node, name);
 
     if (!node[name]) {
@@ -38,9 +38,9 @@ Visitor.prototype = {
     }
   },
 
-  // Traverses a given array. If mutating, empty respnses will be removed
+  // Traverses a given array. If mutating, empty responses will be removed
   // for child elements.
-  acceptArray: function(array) {
+  acceptArray: function (array) {
     for (let i = 0, l = array.length; i < l; i++) {
       this.acceptKey(array, i);
 
@@ -52,7 +52,7 @@ Visitor.prototype = {
     }
   },
 
-  accept: function(object) {
+  accept: function (object) {
     if (!object) {
       return;
     }
@@ -78,7 +78,7 @@ Visitor.prototype = {
     }
   },
 
-  Program: function(program) {
+  Program: function (program) {
     this.acceptArray(program.body);
   },
 
@@ -89,31 +89,31 @@ Visitor.prototype = {
   DecoratorBlock: visitBlock,
 
   PartialStatement: visitPartial,
-  PartialBlockStatement: function(partial) {
+  PartialBlockStatement: function (partial) {
     visitPartial.call(this, partial);
 
     this.acceptKey(partial, 'program');
   },
 
-  ContentStatement: function(/* content */) {},
-  CommentStatement: function(/* comment */) {},
+  ContentStatement: function (/* content */) {},
+  CommentStatement: function (/* comment */) {},
 
   SubExpression: visitSubExpression,
 
-  PathExpression: function(/* path */) {},
+  PathExpression: function (/* path */) {},
 
-  StringLiteral: function(/* string */) {},
-  NumberLiteral: function(/* number */) {},
-  BooleanLiteral: function(/* bool */) {},
-  UndefinedLiteral: function(/* literal */) {},
-  NullLiteral: function(/* literal */) {},
+  StringLiteral: function (/* string */) {},
+  NumberLiteral: function (/* number */) {},
+  BooleanLiteral: function (/* bool */) {},
+  UndefinedLiteral: function (/* literal */) {},
+  NullLiteral: function (/* literal */) {},
 
-  Hash: function(hash) {
+  Hash: function (hash) {
     this.acceptArray(hash.pairs);
   },
-  HashPair: function(pair) {
+  HashPair: function (pair) {
     this.acceptRequired(pair, 'value');
-  }
+  },
 };
 
 function visitSubExpression(mustache) {