@handlebars/parser 2.1.0 → 2.2.1

package/spec/utils.js

@@ -1,3 +1,5 @@
+import { parse, print } from '../dist/esm/index.js';
+
 let AssertError;
 if (Error.captureStackTrace) {
   AssertError = function AssertError(message, caller) {
@@ -15,20 +17,79 @@ if (Error.captureStackTrace) {
 }
 
 /**
- * @deprecated Use chai's expect-style API instead (`expect(actualValue).to.equal(expectedValue)`)
+ * @todo Use chai's expect-style API instead (`expect(actualValue).to.equal(expectedValue)`)
  * @see https://www.chaijs.com/api/bdd/
  */
-export function equals(a, b, msg) {
-  if (a !== b) {
-    throw new AssertError(
-      "'" + a + "' should === '" + b + "'" + (msg ? ': ' + msg : ''),
+export function equals(actual, expected, msg) {
+  if (actual !== expected) {
+    const error = new AssertError(
+      `\n       Actual: ${actual}     Expected: ${expected}` +
+        (msg ? `\n${msg}` : ''),
       equals
     );
+    error.expected = expected;
+    error.actual = actual;
+    throw error;
+  }
+}
+
+export function equalsAst(source, expected, options) {
+  const msg = typeof options === 'string' ? options : options?.msg;
+  const parserOptions =
+    typeof options === 'string' ? undefined : options?.options;
+  const ast = astFor(source, parserOptions);
+  const padding = ` `.repeat(8);
+
+  if (ast !== `${expected}\n`) {
+    let sourceMsg = `${padding}Source: ${source}`;
+    if (parserOptions) {
+      let formattedOptions = printOptions(parserOptions)
+        .split('\n')
+        .join(`\n${padding}`);
+
+      sourceMsg += `\n${padding}Options: ${formattedOptions}`;
+    }
+    const error = new AssertError(
+      `\n${sourceMsg}${msg ? `\n${msg}` : ''}\n`,
+      equalsAst
+    );
+
+    error.expected = expected;
+    error.actual = ast;
+    throw error;
+  }
+}
+
+function printOptions(options) {
+  if (!options) {
+    return '';
   }
-};
+
+  let outOptions = {};
+
+  if (options.srcName) {
+    outOptions.srcName = options.srcName;
+  }
+  if (options.syntax) {
+    outOptions.syntax = {};
+
+    if (options.syntax.hash) {
+      outOptions.syntax.hash = `{function ${
+        options.syntax.hash.name ?? 'anonymous'
+      }}`;
+    }
+    if (options.syntax.square) {
+      outOptions.syntax.square = `{function ${
+        options.syntax.square.name ?? 'anonymous'
+      }}`;
+    }
+  }
+
+  return JSON.stringify(outOptions, null, 2);
+}
 
 /**
- * @deprecated Use chai's expect-style API instead (`expect(actualValue).to.equal(expectedValue)`)
+ * @todo Use chai's expect-style API instead (`expect(actualValue).to.equal(expectedValue)`)
  * @see https://www.chaijs.com/api/bdd/#method_throw
  */
 export function shouldThrow(callback, type, msg) {
@@ -58,4 +119,8 @@ export function shouldThrow(callback, type, msg) {
   if (failed) {
     throw new AssertError('It failed to throw', shouldThrow);
   }
-};
+}
+function astFor(template, options = {}) {
+  let ast = parse(template, options);
+  return print(ast);
+}

package/spec/visitor.js

@@ -1,8 +1,8 @@
-import { Visitor, parse, print, Exception } from '../dist/esm';
-import { equals, shouldThrow } from './utils';
+import { Visitor, parse, print, Exception } from '../dist/esm/index.js';
+import { equals, shouldThrow } from './utils.js';
 
-describe('Visitor', function() {
-  it('should provide coverage', function() {
+describe('Visitor', function () {
+  it('should provide coverage', function () {
     // Simply run the thing and make sure it does not fail and that all of the
     // stub methods are executed
     let visitor = new Visitor();
@@ -16,16 +16,16 @@ describe('Visitor', function() {
     visitor.accept(parse('{{* bar }}'));
   });
 
-  it('should traverse to stubs', function() {
+  it('should traverse to stubs', function () {
     let visitor = new Visitor();
 
-    visitor.StringLiteral = function(string) {
+    visitor.StringLiteral = function (string) {
       equals(string.value, '2');
     };
-    visitor.NumberLiteral = function(number) {
+    visitor.NumberLiteral = function (number) {
       equals(number.value, 1);
     };
-    visitor.BooleanLiteral = function(bool) {
+    visitor.BooleanLiteral = function (bool) {
       equals(bool.value, true);
 
       equals(this.parents.length, 3);
@@ -33,13 +33,13 @@ describe('Visitor', function() {
       equals(this.parents[1].type, 'BlockStatement');
       equals(this.parents[2].type, 'Program');
     };
-    visitor.PathExpression = function(id) {
+    visitor.PathExpression = function (id) {
       equals(/(foo\.)?bar$/.test(id.original), true);
     };
-    visitor.ContentStatement = function(content) {
+    visitor.ContentStatement = function (content) {
       equals(content.value, ' ');
     };
-    visitor.CommentStatement = function(comment) {
+    visitor.CommentStatement = function (comment) {
       equals(comment.value, 'comment');
     };
 
@@ -50,53 +50,47 @@ describe('Visitor', function() {
     );
   });
 
-  describe('mutating', function() {
-    describe('fields', function() {
-      it('should replace value', function() {
+  describe('mutating', function () {
+    describe('fields', function () {
+      it('should replace value', function () {
         let visitor = new Visitor();
 
         visitor.mutating = true;
-        visitor.StringLiteral = function(string) {
+        visitor.StringLiteral = function (string) {
           return { type: 'NumberLiteral', value: 42, loc: string.loc };
         };
 
         let ast = parse('{{foo foo="foo"}}');
         visitor.accept(ast);
-        equals(
-          print(ast),
-          '{{ PATH:foo [] HASH{foo=NUMBER{42}} }}\n'
-        );
+        equals(print(ast), '{{ p%foo HASH{foo=n%42} }}\n');
       });
-      it('should treat undefined resonse as identity', function() {
+      it('should treat undefined resonse as identity', function () {
         let visitor = new Visitor();
         visitor.mutating = true;
 
         let ast = parse('{{foo foo=42}}');
         visitor.accept(ast);
-        equals(
-          print(ast),
-          '{{ PATH:foo [] HASH{foo=NUMBER{42}} }}\n'
-        );
+        equals(print(ast), '{{ p%foo HASH{foo=n%42} }}\n');
       });
-      it('should remove false responses', function() {
+      it('should remove false responses', function () {
         let visitor = new Visitor();
 
         visitor.mutating = true;
-        visitor.Hash = function() {
+        visitor.Hash = function () {
           return false;
         };
 
         let ast = parse('{{foo foo=42}}');
         visitor.accept(ast);
-        equals(print(ast), '{{ PATH:foo [] }}\n');
+        equals(print(ast), '{{ p%foo }}\n');
       });
-      it('should throw when removing required values', function() {
+      it('should throw when removing required values', function () {
         shouldThrow(
-          function() {
+          function () {
             let visitor = new Visitor();
 
             visitor.mutating = true;
-            visitor.PathExpression = function() {
+            visitor.PathExpression = function () {
               return false;
             };
 
@@ -107,13 +101,13 @@ describe('Visitor', function() {
           'MustacheStatement requires path'
         );
       });
-      it('should throw when returning non-node responses', function() {
+      it('should throw when returning non-node responses', function () {
         shouldThrow(
-          function() {
+          function () {
             let visitor = new Visitor();
 
             visitor.mutating = true;
-            visitor.PathExpression = function() {
+            visitor.PathExpression = function () {
               return {};
             };
 
@@ -125,38 +119,38 @@ describe('Visitor', function() {
         );
       });
     });
-    describe('arrays', function() {
-      it('should replace value', function() {
+    describe('arrays', function () {
+      it('should replace value', function () {
         let visitor = new Visitor();
 
         visitor.mutating = true;
-        visitor.StringLiteral = function(string) {
+        visitor.StringLiteral = function (string) {
           return { type: 'NumberLiteral', value: 42, loc: string.locInfo };
         };
 
         let ast = parse('{{foo "foo"}}');
         visitor.accept(ast);
-        equals(print(ast), '{{ PATH:foo [NUMBER{42}] }}\n');
+        equals(print(ast), '{{ p%foo [n%42] }}\n');
       });
-      it('should treat undefined resonse as identity', function() {
+      it('should treat undefined resonse as identity', function () {
         let visitor = new Visitor();
         visitor.mutating = true;
 
         let ast = parse('{{foo 42}}');
         visitor.accept(ast);
-        equals(print(ast), '{{ PATH:foo [NUMBER{42}] }}\n');
+        equals(print(ast), '{{ p%foo [n%42] }}\n');
       });
-      it('should remove false responses', function() {
+      it('should remove false responses', function () {
         let visitor = new Visitor();
 
         visitor.mutating = true;
-        visitor.NumberLiteral = function() {
+        visitor.NumberLiteral = function () {
           return false;
         };
 
         let ast = parse('{{foo 42}}');
         visitor.accept(ast);
-        equals(print(ast), '{{ PATH:foo [] }}\n');
+        equals(print(ast), '{{ p%foo }}\n');
       });
     });
   });

package/src/handlebars.l

@@ -1,5 +1,5 @@
 
-%x mu emu com raw
+%x mu emu com raw escl
 
 %{
 
@@ -12,8 +12,8 @@ function strip(start, end) {
 LEFT_STRIP    "~"
 RIGHT_STRIP   "~"
 
-LOOKAHEAD           [=~}\s\/.)|]
-LITERAL_LOOKAHEAD   [~}\s)]
+LOOKAHEAD           [=~}\s\/.)\]|]
+LITERAL_LOOKAHEAD   [~}\s)\]]
 
 /*
 ID is the inverse of control characters.
@@ -73,6 +73,18 @@ ID    [^\s!"#%-,\.\/;->@\[-\^`\{-~]+/{LOOKAHEAD}
 <mu>"("                          return 'OPEN_SEXPR';
 <mu>")"                          return 'CLOSE_SEXPR';
 
+<mu>"[" {
+  if (yy.syntax.square === 'string') {
+    this.unput(yytext);
+    // escaped literal
+    this.begin('escl');
+  } else {
+    return 'OPEN_ARRAY';
+  }
+}
+<mu>"]"                          return 'CLOSE_ARRAY';
+
+
 <mu>"{{{{"                       { return 'OPEN_RAW_BLOCK'; }
 <mu>"}}}}"                       {
                                   this.popState();
@@ -103,6 +115,7 @@ ID    [^\s!"#%-,\.\/;->@\[-\^`\{-~]+/{LOOKAHEAD}
 <mu>"="                          return 'EQUALS';
 <mu>".."                         return 'ID';
 <mu>"."/{LOOKAHEAD}              return 'ID';
+<mu>".#"                         return 'PRIVATE_SEP';
 <mu>[\/.]                        return 'SEP';
 <mu>\s+                          // ignore whitespace
 <mu>"}"{RIGHT_STRIP}?"}}"        this.popState(); return 'CLOSE_UNESCAPED';
@@ -120,7 +133,12 @@ ID    [^\s!"#%-,\.\/;->@\[-\^`\{-~]+/{LOOKAHEAD}
 
 <mu>{ID}                         return 'ID';
 
-<mu>'['('\\]'|[^\]])*']'         yytext = yytext.replace(/\\([\\\]])/g,'$1'); return 'ID';
+<escl>'['('\\]'|[^\]])*']' {
+  yytext = yytext.replace(/\\([\\\]])/g,'$1');
+  this.popState();
+  return 'ID';
+}
+
 <mu>.                            return 'INVALID';
 
 <INITIAL,mu><<EOF>>              return 'EOF';

package/src/handlebars.yy

@@ -85,7 +85,8 @@ closeBlock
 mustache
   // Parsing out the '&' escape token at AST level saves ~500 bytes after min due to the removal of one parser node.
   // This also allows for handler unification as all mustache node instances can utilize the same handler
-  : OPEN expr expr* hash? CLOSE -> yy.prepareMustache($2, $3, $4, $1, yy.stripFlags($1, $5), @$)
+  : OPEN hash CLOSE -> yy.prepareMustache(yy.syntax.hash($2, yy.locInfo(@$), { yy, syntax: 'expr' }), [], undefined, $1, yy.stripFlags($1, $3), @$)
+  | OPEN expr expr* hash? CLOSE -> yy.prepareMustache($2, $3, $4, $1, yy.stripFlags($1, $5), @$)
   | OPEN_UNESCAPED expr expr* hash? CLOSE_UNESCAPED -> yy.prepareMustache($2, $3, $4, $1, yy.stripFlags($1, $5), @$)
   ;
 
@@ -111,11 +112,18 @@ openPartialBlock
 
 expr
   : helperName -> $1
+  | exprHead -> $1
+  ;
+
+exprHead
+  : arrayLiteral -> $1
   | sexpr -> $1
   ;
 
+
 sexpr
-  : OPEN_SEXPR expr expr* hash? CLOSE_SEXPR {
+  : OPEN_SEXPR hash CLOSE_SEXPR -> yy.syntax.hash($2, yy.locInfo(@$), { yy, syntax: 'expr' })
+  | OPEN_SEXPR expr expr* hash? CLOSE_SEXPR {
     $$ = {
       type: 'SubExpression',
       path: $2,
@@ -133,6 +141,10 @@ hashSegment
   : ID EQUALS expr -> {type: 'HashPair', key: yy.id($1), value: $3, loc: yy.locInfo(@$)}
   ;
 
+arrayLiteral
+  : OPEN_ARRAY expr* CLOSE_ARRAY -> yy.syntax.square($2, yy.locInfo(@$), { yy, syntax: 'expr' })
+  ;
+
 blockParams
   : OPEN_BLOCK_PARAMS ID+ CLOSE_BLOCK_PARAMS -> yy.id($2)
   ;
@@ -151,12 +163,17 @@ dataName
   : DATA pathSegments -> yy.preparePath(true, false, $2, @$)
   ;
 
+sep
+  : SEP -> $1
+  | PRIVATE_SEP -> $1
+  ;
+
 path
-  : sexpr SEP pathSegments -> yy.preparePath(false, $1, $3, @$)
+  : exprHead sep pathSegments -> yy.preparePath(false, $1, $3, @$)
   | pathSegments -> yy.preparePath(false, false, $1, @$)
   ;
 
 pathSegments
-  : pathSegments SEP ID { $1.push({part: yy.id($3), original: $3, separator: $2}); $$ = $1; }
+  : pathSegments sep ID { $1.push({part: yy.id($3), original: $3, separator: $2}); $$ = $1; }
   | ID -> [{part: yy.id($1), original: $1}]
   ;

package/tsconfig.json

@@ -8,18 +8,24 @@
     "baseUrl": "lib",
     "rootDir": "lib",
     "esModuleInterop": true,
-    "moduleResolution": "node",
-
+    "moduleResolution": "bundler",
+    "verbatimModuleSyntax": true,
     // Enhance Strictness
     "strict": true,
     "suppressImplicitAnyIndexErrors": false,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
     "noImplicitReturns": true,
-
     "newLine": "LF",
     "allowJs": true
   },
-  "include": ["lib/**/*.js"],
-  "exclude": ["dist", "node_modules", ".vscode"]
-}
+  "include": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts"
+  ],
+  "exclude": [
+    "dist",
+    "node_modules",
+    ".vscode"
+  ]
+}