Merge branch 'feat/tagged-template-parsing' into master

babel.js

···
-module.exports = require('./dist/reghex-babel.js').default;
+module.exports = require('./dist/reghex-babel.js');

package.json

···
       "require": "./dist/reghex-core.js"
     },
     "./babel": {
-      "import": "./dist/reghex-babel.mjs",
       "require": "./dist/reghex-babel.js"
     },
     "./macro": {
-      "import": "./dist/reghex-macro.mjs",
       "require": "./dist/reghex-macro.js"
     },
     "./package.json": "./package.json"

rollup.config.js

···
   },
   {
     ...base,
+    output: {
+      ...output('cjs', '.js'),
+      exports: 'default',
+    },
     input: {
       babel: './src/babel/plugin.js',
       macro: './src/babel/macro.js',

src/babel/__snapshots__/plugin.test.js.snap

···
 
 var _reghex = require(\\"reghex\\");
 
-var _node_expression = (0, _reghex._pattern)(1),
-    _node_expression2 = (0, _reghex._pattern)(2);
+var _node_expression = _reghex.__private.pattern(1),
+    _node_expression2 = _reghex.__private.pattern(2);
 
 const node = function (state) {
-  var idx1 = state.index;
+  var y1 = state.y,
+      x1 = state.x;
   var node = [];
   var x;
 
-  if (x = (0, _reghex._exec)(state, _node_expression)) {
+  if (x = _reghex.__private.exec(state, _node_expression)) {
     node.push(x);
   } else {
-    state.index = idx1;
+    state.y = y1;
+    state.x = x1;
     return;
   }
 
-  if (x = (0, _reghex._exec)(state, _node_expression2)) {
+  if (x = _reghex.__private.exec(state, _node_expression2)) {
     node.push(x);
   } else {
-    state.index = idx1;
+    state.y = y1;
+    state.x = x1;
     return;
   }
 
···
 `;
 
 exports[`works with local recursion 1`] = `
-"import { match as m, tag, _exec, _pattern } from 'reghex';
+"import { match as m, tag, __private } from 'reghex';
 
-var _inner_expression = _pattern(/inner/);
+var _inner_expression = __private.pattern(/inner/);
 
 const inner = function (state) {
-  var idx1 = state.index;
+  var y1 = state.y,
+      x1 = state.x;
   var node = [];
   var x;
 
-  if (x = _exec(state, _inner_expression)) {
+  if (x = __private.exec(state, _inner_expression)) {
     node.push(x);
   } else {
-    state.index = idx1;
+    state.y = y1;
+    state.x = x1;
     return;
   }
 
···
 };
 
 const node = function (state) {
-  var idx1 = state.index;
+  var y1 = state.y,
+      x1 = state.x;
   var node = [];
   var x;
 
   if (x = inner(state)) {
     node.push(x);
   } else {
-    state.index = idx1;
+    state.y = y1;
+    state.x = x1;
     return;
   }
 
···
 `;
 
 exports[`works with non-capturing groups 1`] = `
-"import { match, _exec, _pattern, tag as _tag } from 'reghex';
+"import { match, __private } from 'reghex';
 
-var _node_expression = _pattern(1),
-    _node_expression2 = _pattern(2),
-    _node_expression3 = _pattern(3);
+var _node_expression = __private.pattern(1),
+    _node_expression2 = __private.pattern(2),
+    _node_expression3 = __private.pattern(3);
 
 const node = function (state) {
-  var idx1 = state.index;
+  var y1 = state.y,
+      x1 = state.x;
   var node = [];
   var x;
 
-  if (x = _exec(state, _node_expression)) {
+  if (x = __private.exec(state, _node_expression)) {
     node.push(x);
   } else {
-    state.index = idx1;
+    state.y = y1;
+    state.x = x1;
     return;
   }
 
···
 
   alt_3: {
     block_3: {
-      var idx3 = state.index;
+      var y3 = state.y,
+          x3 = state.x;
 
-      if (x = _exec(state, _node_expression2)) {
+      if (x = __private.exec(state, _node_expression2)) {
         node.push(x);
       } else {
-        state.index = idx3;
+        state.y = y3;
+        state.x = x3;
         node.length = ln2;
         break block_3;
       }
···
     }
 
     loop_3: for (var j3 = 0; 1; j3++) {
-      var idx3 = state.index;
+      var y3 = state.y,
+          x3 = state.x;
 
-      if (!_exec(state, _node_expression3)) {
+      if (x = __private.exec(state, _node_expression3)) {} else {
         if (j3) {
-          state.index = idx3;
+          state.y = y3;
+          state.x = x3;
           break loop_3;
         } else {}
 
-        state.index = idx1;
+        state.y = y1;
+        state.x = x1;
         node.length = ln2;
         return;
       }
···
 `;
 
 exports[`works with self-referential thunks 1`] = `
-"import { match, tag, _exec, _pattern } from 'reghex';
+"import { match, tag, __private } from 'reghex';
 
 const inner = function (state) {
-  var idx1 = state.index;
+  var y1 = state.y,
+      x1 = state.x;
   var node = [];
   var x;
 
   if (x = node(state)) {
     node.push(x);
   } else {
-    state.index = idx1;
+    state.y = y1;
+    state.x = x1;
     return;
   }
 
···
 };
 
 const node = function (state) {
-  var idx1 = state.index;
+  var y1 = state.y,
+      x1 = state.x;
   var node = [];
   var x;
 
   if (x = inner(state)) {
     node.push(x);
   } else {
-    state.index = idx1;
+    state.y = y1;
+    state.x = x1;
     return;
   }
 
···
 `;
 
 exports[`works with standard features 1`] = `
-"import { match, _exec, _pattern, tag as _tag } from \\"reghex\\";
+"import { match, __private } from \\"reghex\\";
 
-var _node_expression = _pattern(1),
-    _node_expression2 = _pattern(2),
-    _node_expression3 = _pattern(3),
-    _node_expression4 = _pattern(4),
-    _node_expression5 = _pattern(5);
+var _node_expression = __private.pattern(1),
+    _node_expression2 = __private.pattern(2),
+    _node_expression3 = __private.pattern(3),
+    _node_expression4 = __private.pattern(4),
+    _node_expression5 = __private.pattern(5);
 
 const node = function (state) {
-  var idx1 = state.index;
+  var y1 = state.y,
+      x1 = state.x;
   var node = [];
   var x;
 
   alt_2: {
     block_2: {
-      var idx2 = state.index;
+      var y2 = state.y,
+          x2 = state.x;
 
       loop_2: for (var j2 = 0; 1; j2++) {
-        var idx2 = state.index;
+        var y2 = state.y,
+            x2 = state.x;
 
-        if (x = _exec(state, _node_expression)) {
+        if (x = __private.exec(state, _node_expression)) {
           node.push(x);
         } else {
           if (j2) {
-            state.index = idx2;
+            state.y = y2;
+            state.x = x2;
             break loop_2;
           } else {}
 
-          state.index = idx2;
+          state.y = y2;
+          state.x = x2;
           break block_2;
         }
       }
···
     }
 
     loop_2: for (var j2 = 0; 1; j2++) {
-      var idx2 = state.index;
+      var y2 = state.y,
+          x2 = state.x;
 
-      if (x = _exec(state, _node_expression2)) {
+      if (x = __private.exec(state, _node_expression2)) {
         node.push(x);
       } else {
         if (j2) {
-          state.index = idx2;
+          state.y = y2;
+          state.x = x2;
           break loop_2;
         } else {}
 
-        state.index = idx1;
+        state.y = y1;
+        state.x = x1;
         return;
       }
     }
 
     loop_2: for (;;) {
-      var idx2 = state.index;
+      var y2 = state.y,
+          x2 = state.x;
       var ln2 = node.length;
 
-      if (x = _exec(state, _node_expression3)) {
+      if (x = __private.exec(state, _node_expression3)) {
         node.push(x);
       } else {
-        state.index = idx2;
+        state.y = y2;
+        state.x = x2;
         node.length = ln2;
         break loop_2;
       }
 
-      var idx4 = state.index;
+      var y4 = state.y,
+          x4 = state.x;
 
-      if (x = _exec(state, _node_expression4)) {
+      if (x = __private.exec(state, _node_expression4)) {
         node.push(x);
       } else {
-        state.index = idx4;
+        state.y = y4;
+        state.x = x4;
       }
 
-      if (x = _exec(state, _node_expression5)) {
+      if (x = __private.exec(state, _node_expression5)) {
         node.push(x);
       } else {
-        state.index = idx2;
+        state.y = y2;
+        state.x = x2;
         node.length = ln2;
         break loop_2;
       }
···
 `;
 
 exports[`works with transform functions 1`] = `
-"import { match, _exec, _pattern, tag as _tag } from 'reghex';
+"import { match, __private } from 'reghex';
 
 var _inner_transform = x => x;
 
 const first = function (state) {
-  var idx1 = state.index;
+  var y1 = state.y,
+      x1 = state.x;
   var node = [];
   var x;
   node.tag = 'inner';
···
 const transform = x => x;
 
 const second = function (state) {
-  var idx1 = state.index;
+  var y1 = state.y,
+      x1 = state.x;
   var node = [];
   var x;
   node.tag = 'node';

src/babel/sharedIds.js

···
-export class SharedIds {
-  constructor(t) {
-    this.t = t;
-    this.execId = t.identifier('_exec');
-    this.patternId = t.identifier('_pattern');
-    this.tagId = t.identifier('tag');
-  }
-
-  get exec() {
-    return this.t.identifier(this.execId.name);
-  }
-
-  get pattern() {
-    return this.t.identifier(this.patternId.name);
-  }
-
-  get tag() {
-    return this.t.identifier(this.tagId.name);
-  }
-}

src/babel/transform.js

···
+import { astRoot, _private } from '../codegen';
 import { parse } from '../parser';
-import { astRoot } from '../codegen';
-import { SharedIds } from './sharedIds';
 
 export function makeHelpers({ types: t, template }) {
   const regexPatternsRe = /^[()\[\]|.+?*]|[^\\][()\[\]|.+?*$^]|\\[wdsWDS]/;
   const importSourceRe = /reghex$|^reghex\/macro/;
   const importName = 'reghex';
-  const ids = new SharedIds(t);
 
   let _hasUpdatedImport = false;
+  let _matchId = t.identifier('match');
+  let _privateId = t.identifier(_private);
+
+  const privateMethod = (name) =>
+    t.memberExpression(t.identifier(_privateId.name), t.identifier(name));
 
   return {
     /** Adds the reghex import declaration to the Program scope */
···
         path.node.source = t.stringLiteral(importName);
       }
 
-      path.node.specifiers.push(
-        t.importSpecifier(
-          (ids.execId = path.scope.generateUidIdentifier('exec')),
-          t.identifier('_exec')
-        ),
-        t.importSpecifier(
-          (ids.patternId = path.scope.generateUidIdentifier('pattern')),
-          t.identifier('_pattern')
-        )
-      );
+      path.node.specifiers.push(t.importSpecifier(_privateId, _privateId));
 
       const tagImport = path.node.specifiers.find((node) => {
-        return t.isImportSpecifier(node) && node.imported.name === 'tag';
+        return t.isImportSpecifier(node) && node.imported.name === 'match';
       });
 
       if (!tagImport) {
         path.node.specifiers.push(
           t.importSpecifier(
-            (ids.tagId = path.scope.generateUidIdentifier('tag')),
-            t.identifier('tag')
+            (_matchId = path.scope.generateUidIdentifier('match')),
+            t.identifier('match')
           )
         );
       } else {
-        ids.tagId = tagImport.imported;
+        _matchId = tagImport.imported;
       }
     },
 
···
           variableDeclarators.push(
             t.variableDeclarator(
               id,
-              t.callExpression(ids.pattern, [expression])
+              t.callExpression(privateMethod('pattern'), [expression])
             )
           );
 

src/codegen.js

···
-export const _exec = '_exec';
+export const _private = '__private';
+
 const _state = 'state';
 const _node = 'node';
 const _match = 'x';
···
   return next;
 };
 
-const assignIndex = (depth) =>
-  depth ? js`var idx${depth} = ${_state}.index;` : '';
-
-const restoreIndex = (depth) =>
-  depth ? js`${_state}.index = idx${depth};` : '';
+const assignIndex = (depth) => js`
+  var y${depth} = ${_state}.y,
+      x${depth} = ${_state}.x;
+`;
 
-const abortOnCondition = (condition, hooks) => js`
-  if (${condition}) {
-    ${restoreIndex(opts.index)}
-    ${opts.abort}
-  } else {
-    ${opts.onAbort}
-  }
+const restoreIndex = (depth) => js`
+  ${_state}.y = y${depth};
+  ${_state}.x = x${depth};
 `;
 
 const astExpression = (ast, depth, opts) => {
   const restoreLength =
     (opts.length && opts.abort && js`${_node}.length = ln${opts.length};`) ||
     '';
-
-  const abort = js`
-    ${opts.onAbort}
-    ${restoreIndex(opts.index)}
-    ${restoreLength}
-    ${opts.abort}
-  `;
-
   const expression = ast.expression.fn
     ? `${ast.expression.id}(${_state})`
-    : `${_exec}(${_state}, ${ast.expression.id})`;
-
-  if (!opts.capture) {
-    return js`
-      if (!${expression}) {
-        ${abort}
-      }
-    `;
-  }
+    : `${_private}.exec(${_state}, ${ast.expression.id})`;
 
   return js`
     if (${_match} = ${expression}) {
-      ${_node}.push(${_match});
+      ${opts.capture ? js`${_node}.push(${_match})` : ''}
     } else {
-      ${abort}
+      ${opts.onAbort}
+      ${restoreIndex(opts.index)}
+      ${restoreLength}
+      ${opts.abort}
     }
   `;
 };
···
   opts = copy(opts);
   opts.capture = capture;
 
-  let group = '';
   if (!opts.length && capture) {
     opts.length = depth;
     return js`
···
   `;
 };
 
-const astRoot = (ast, name, transform) => js`
-  (function (${_state}) {
-    ${assignIndex(1)}
-    var ${_node} = [];
-    var ${_match};
+const astRoot = (ast, name, transform) => {
+  return js`
+    (function (${_state}) {
+      ${assignIndex(1)}
+      var ${_node} = [];
+      var ${_match};
 
-    ${astSequence(ast, 2, {
-      index: 1,
-      length: 0,
-      onAbort: '',
-      abort: js`return;`,
-      capture: true,
-    })}
+      ${astSequence(ast, 2, {
+        index: 1,
+        length: 0,
+        onAbort: '',
+        abort: js`return;`,
+        capture: true,
+      })}
 
-    ${_node}.tag = ${name};
-    return ${transform ? js`(${transform})(${_node})` : _node};
-  })
-`;
+      ${_node}.tag = ${name};
+      return ${transform ? js`(${transform})(${_node})` : _node};
+    })
+  `;
+};
 
 export { astRoot };

src/core.js

···
-import { astRoot, _exec as execId } from './codegen';
+import { astRoot, _private as privateId } from './codegen';
 import { parse as parseDSL } from './parser';
 
 const isStickySupported = typeof /./g.sticky === 'boolean';
 
-export const _pattern = (input) => {
-  if (typeof input === 'function') return input;
-  const source = typeof input !== 'string' ? input.source : input;
-  return isStickySupported
-    ? new RegExp(source, 'y')
-    : new RegExp(source + '|()', 'g');
+export const __private = {
+  pattern(input) {
+    if (typeof input === 'function') return input;
+    const source = typeof input !== 'string' ? input.source : input;
+    return isStickySupported
+      ? new RegExp(source, 'y')
+      : new RegExp(source + '|()', 'g');
+  },
+
+  exec(state, pattern) {
+    let match;
+
+    if (typeof pattern === 'function') {
+      if (!pattern.length) pattern = pattern();
+      return pattern(state);
+    }
+
+    const input = state.quasis[state.x];
+    if (input && (pattern.lastIndex = state.y) < input.length) {
+      if (isStickySupported) {
+        if (pattern.test(input))
+          match = input.slice(state.y, pattern.lastIndex);
+      } else {
+        match = pattern.exec(input)[0] || match;
+      }
+
+      state.y = pattern.lastIndex;
+    }
+
+    return match;
+  },
 };
 
-export const _exec = (state, pattern) => {
+export const interpolation = (predicate) => (state) => {
   let match;
 
-  if (typeof pattern === 'function') {
-    if (!pattern.length) pattern = pattern();
-    return pattern(state);
-  }
-
-  pattern.lastIndex = state.index;
-
-  if (isStickySupported) {
-    if (pattern.test(state.input))
-      match = state.input.slice(state.index, pattern.lastIndex);
-  } else {
-    match = pattern.exec(state.input)[0] || match;
+  if (
+    state.y >= state.quasis[state.x].length &&
+    state.x < state.expressions.length
+  ) {
+    state.y = 0;
+    match = state.expressions[state.x++];
+    if (predicate && match) match = predicate(match);
   }
 
-  state.index = pattern.lastIndex;
   return match;
 };
 
-export const parse = (pattern) => (input) => {
-  const state = { input, index: 0 };
-  return pattern(state);
+export const parse = (matcher) => (quasis, ...expressions) => {
+  if (typeof quasis === 'string') quasis = [quasis];
+  const state = { quasis, expressions, x: 0, y: 0 };
+  return matcher(state);
 };
 
 export const match = (name, transform) => (quasis, ...expressions) => {
···
   );
 
   const makeMatcher = new Function(
-    execId + ',_n,_t,' + expressions.map((_expression, i) => `_${i}`).join(','),
+    privateId +
+      ',_n,_t,' +
+      expressions.map((_expression, i) => `_${i}`).join(','),
     'return ' + astRoot(ast, '_n', transform ? '_t' : null)
   );
 
-  return makeMatcher(_exec, name, transform, ...expressions.map(_pattern));
+  return makeMatcher(
+    __private,
+    name,
+    transform,
+    ...expressions.map(__private.pattern)
+  );
 };

src/core.test.js

···
-import { match } from './core';
+import { parse, match, interpolation } from './core';
 
 const expectToParse = (node, input, result, lastIndex = 0) => {
-  const state = { input, index: 0 };
+  const state = { quasis: [input], expressions: [], x: 0, y: 0 };
   if (result) result.tag = 'node';
   expect(node(state)).toEqual(result);
 
   // NOTE: After parsing we expect the current index to exactly match the
   // sum amount of matched characters
   if (result === undefined) {
-    expect(state.index).toBe(0);
+    expect(state.y).toBe(0);
   } else {
     const index = lastIndex || result.reduce((acc, x) => acc + x.length, 0);
-    expect(state.index).toBe(index);
+    expect(state.y).toBe(index);
   }
 };
 
···
     }
   );
 });
+
+describe('interpolation parsing', () => {
+  const node = match('node')`
+    ${/1/}
+    ${interpolation((x) => x > 1 && x)}
+    ${/3/}
+  `;
+
+  it('matches interpolations', () => {
+    const expected = ['1', 2, '3'];
+    expected.tag = 'node';
+    expect(parse(node)`1${2}3`).toEqual(expected);
+  });
+
+  it('does not match invalid inputs', () => {
+    expect(parse(node)`13`).toBe(undefined);
+    expect(parse(node)`13${2}`).toBe(undefined);
+    expect(parse(node)`${2}13`).toBe(undefined);
+    expect(parse(node)`1${1}3`).toBe(undefined);
+  });
+});