@bablr/boot 0.1.1 → 0.1.3

package/lib/languages/cstml.js

@@ -22,7 +22,7 @@ const grammar = class CSTMLMiniparserGrammar {
   Fragment(p) {
     p.eatMatchTrivia(_);
     while (p.match(/<[^/]/y) || p.atExpression) {
-      p.eatProduction('Property', { path: 'properties' });
+      p.eatProduction('Property', { path: 'properties[]' });
       p.eatMatchTrivia(_);
     }
   }
@@ -73,7 +73,7 @@ const grammar = class CSTMLMiniparserGrammar {
       if (p.atExpression) {
         p.eatProduction('Attributes'); // ??
       } else {
-        p.eatProduction('Attribute', { path: '[attributes]' });
+        p.eatProduction('Attribute', { path: 'attributes[]' });
       }
       if (p.match(/\s+\w/y) || (p.match(/\s+$/y) && !p.quasisDone)) {
         sp = p.eatMatchTrivia(_);

package/lib/languages/instruction.js

@@ -69,7 +69,7 @@ const grammar = class InstructionMiniparserGrammar {
     let first = true;
     let sep;
     while (first || (sep && (p.match(/./y) || p.atExpression))) {
-      p.eatProduction('Property', { path: '[properties]' });
+      p.eatProduction('Property', { path: 'properties[]' });
       sep = p.eatMatchTrivia(_);
       first = false;
     }
@@ -97,7 +97,7 @@ const grammar = class InstructionMiniparserGrammar {
     let first = true;
     let sep;
     while (first || (sep && (p.match(/./y) || p.atExpression))) {
-      p.eatProduction('Expression', { path: '[elements]' });
+      p.eatProduction('Expression', { path: 'elements[]' });
       sep = p.eatMatchTrivia(_);
       first = false;
     }
@@ -113,7 +113,7 @@ const grammar = class InstructionMiniparserGrammar {
 
     let i = 0;
     while (i === 0 || (sep && (p.match(/./y) || p.atExpression))) {
-      p.eatProduction('Expression', { path: '[values]' });
+      p.eatProduction('Expression', { path: 'values[]' });
       sep = p.eatMatchTrivia(_);
       i++;
     }
@@ -128,7 +128,7 @@ const grammar = class InstructionMiniparserGrammar {
 
   // @Node
   Null(p) {
-    p.eat(/null/y, KW, { path: 'value' });
+    p.eat('null', KW, { path: 'value' });
   }
 };
 

package/lib/languages/regex.js

@@ -98,9 +98,9 @@ const grammar = class RegexMiniparserGrammar {
   // @Node
   Pattern(p) {
     p.eat('/', PN, { path: 'open', balanced: '/' });
-    p.eatProduction('Alternatives', { path: '[alternatives]' });
+    p.eatProduction('Alternatives', { path: 'alternatives[]' });
     p.eat('/', PN, { path: 'close', balancer: true });
-    p.eatProduction('Flags', { path: '[flags]' });
+    p.eatProduction('Flags', { path: 'flags[]' });
   }
 
   Flags(p) {
@@ -116,19 +116,18 @@ const grammar = class RegexMiniparserGrammar {
   // @Node
   Flag(p) {
     const flag = p.eatMatch(/[gimsuy]/y, KW, { path: 'value' });
-
     return { attrs: { kind: flagsReverse[flag] } };
   }
 
   Alternatives(p) {
     do {
       p.eatProduction('Alternative');
-    } while (p.eatMatch('|', PN, { path: '[separators]' }));
+    } while (p.eatMatch('|', PN, { path: 'separators[]' }));
   }
 
   // @Node
   Alternative(p) {
-    p.eatProduction('Elements', { path: '[elements]' });
+    p.eatProduction('Elements', { path: 'elements[]' });
   }
 
   Elements(p) {
@@ -163,14 +162,14 @@ const grammar = class RegexMiniparserGrammar {
   // @Node
   Group(p) {
     p.eat('(?:', PN, { path: 'open', balanced: ')' });
-    p.eatProduction('Alternatives', { path: '[alternatives]' });
+    p.eatProduction('Alternatives', { path: 'alternatives[]' });
     p.eat(')', PN, { path: 'close', balancer: true });
   }
 
   // @Node
   CapturingGroup(p) {
     p.eat('(', PN, { path: 'open', balanced: ')' });
-    p.eatProduction('Alternatives', { path: '[alternatives]' });
+    p.eatProduction('Alternatives', { path: 'alternatives[]' });
     p.eat(')', PN, { path: 'close', balancer: true });
   }
 
@@ -226,7 +225,7 @@ const grammar = class RegexMiniparserGrammar {
 
     let first = !negate;
     while (p.match(/./sy)) {
-      p.eatProduction('CharacterClassElement', { path: '[elements]' }, { first });
+      p.eatProduction('CharacterClassElement', { path: 'elements[]' }, { first });
       first = false;
     }
 

package/lib/languages/spamex.js

@@ -54,7 +54,7 @@ const grammar = class SpamexMiniparserGrammar {
     let sp = p.eatMatchTrivia(_);
 
     if ((sp && p.match(/\w+/y)) || p.atExpression) {
-      p.eatProduction('Attributes', { path: '[attributes]' });
+      p.eatProduction('Attributes', { path: 'attributes[]' });
       sp = p.eatMatchTrivia(_);
     }
 
@@ -75,7 +75,7 @@ const grammar = class SpamexMiniparserGrammar {
     }
 
     if (sp && p.match(/\w+/y)) {
-      p.eatProduction('Attributes', { path: '[attributes]' });
+      p.eatProduction('Attributes', { path: 'attributes[]' });
       sp = p.eatMatchTrivia(_);
     }
 

package/lib/miniparser.js

@@ -5,7 +5,7 @@ const isString = require('iter-tools-es/methods/is-string');
 const isObject = require('iter-tools-es/methods/is-object');
 const sym = require('./symbols.js');
 const { Match } = require('./match.js');
-const { set, isRegex, isArray, parsePath, getPrototypeOf, buildNode } = require('./utils.js');
+const { set, isRegex, isArray, getPrototypeOf, buildNode, parsePath } = require('./utils.js');
 
 class TemplateParser {
   constructor(rootLanguage, quasis, expressions) {
@@ -172,9 +172,8 @@ class TemplateParser {
         }
       } else if (parentPath?.node && (isNode || covers.has(type))) {
         const { properties, children } = parentPath.node;
-        const { pathName } = parsePath(this.m.attrs.path);
 
-        children.push({ ...ref(pathName), id });
+        children.push({ ...ref(this.m.attrs.path), id });
 
         set(properties, this.m.attrs.path, result);
       }
@@ -195,9 +194,7 @@ class TemplateParser {
           node.attributes = result.attrs;
         }
         if (parentPath?.node && !covers.has(type)) {
-          const { pathName } = parsePath(this.m.attrs.path);
-
-          parentPath.node.children.push(ref(pathName));
+          parentPath.node.children.push(ref(this.m.attrs.path));
 
           set(parentPath.node.properties, this.m.attrs.path, node);
         }
@@ -280,16 +277,16 @@ class TemplateParser {
     }
 
     const path = lastChild.value;
-    const pathIsArray = isArray(properties[path]);
+    const { pathIsArray, pathName } = parsePath(path);
 
-    this.held = pathIsArray ? arrayLast(properties[path]) : properties[path];
+    this.held = pathIsArray ? arrayLast(properties[pathName]) : properties[pathName];
 
     children.pop();
 
     if (pathIsArray) {
-      properties[path].pop();
+      properties[pathName].pop();
     } else {
-      properties[path] = null;
+      properties[pathName] = null;
     }
 
     return this.eval(this.buildId(id), attrs, props);
@@ -309,7 +306,7 @@ class TemplateParser {
 
     set(this.node.properties, attrs.path, buildNode(this.buildId(type), [lit(result)]));
 
-    this.node.children.push(ref(parsePath(attrs.path).pathName));
+    this.node.children.push(ref(attrs.path));
 
     return result;
   }
@@ -337,7 +334,7 @@ class TemplateParser {
 
       set(this.node.properties, attrs.path, buildNode(this.buildId(type), [lit(result)]));
 
-      this.node.children.push(ref(parsePath(attrs.path).pathName));
+      this.node.children.push(ref(attrs.path));
     }
     return result;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/boot",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Compile-time tools for bootstrapping BABLR VM",
   "engines": {
     "node": ">=12.0.0"
@@ -10,14 +10,15 @@
     "./shorthand.macro": "./shorthand.macro.js"
   },
   "files": [
-    "lib/**/*.js"
+    "lib/**/*.js",
+    "shorthand.macro.js"
   ],
   "sideEffects": false,
   "dependencies": {
     "@babel/helper-module-imports": "^7.22.15",
     "@babel/template": "^7.22.15",
     "@babel/types": "7.23.0",
-    "@bablr/boot-helpers": "0.1.0",
+    "@bablr/boot-helpers": "0.1.1",
     "escape-string-regexp": "4.0.0",
     "iter-tools-es": "^7.5.3"
   },

package/shorthand.macro.js

@@ -0,0 +1,224 @@
+const t = require('@babel/types');
+const { expression } = require('@babel/template');
+const isObject = require('iter-tools-es/methods/is-object');
+const isUndefined = require('iter-tools-es/methods/is-undefined');
+const isNull = require('iter-tools-es/methods/is-null');
+const isString = require('iter-tools-es/methods/is-string');
+const concat = require('iter-tools-es/methods/concat');
+const { createMacro } = require('babel-plugin-macros');
+const { TemplateParser } = require('./lib/miniparser.js');
+const i = require('./lib/languages/instruction.js');
+const re = require('./lib/languages/regex.js');
+const spam = require('./lib/languages/spamex.js');
+const str = require('./lib/languages/string.js');
+const cstml = require('./lib/languages/cstml.js');
+const { addNamespace, addNamed } = require('@babel/helper-module-imports');
+const { PathResolver } = require('@bablr/boot-helpers/path');
+
+const { hasOwn } = Object;
+const { isArray } = Array;
+const isNumber = (v) => typeof v === 'number';
+const isBoolean = (v) => typeof v === 'boolean';
+
+const isPlainObject = (v) => isObject(v) && !isArray(v);
+
+const set = (obj, path, value, pathIsArray) => {
+  if (pathIsArray) {
+    if (!obj[path]) {
+      obj[path] = [];
+    }
+
+    if (!isArray(obj[path])) throw new Error('bad array value');
+
+    obj[path].push(value);
+  } else {
+    if (hasOwn(obj, path)) {
+      throw new Error('duplicate child name');
+    }
+    obj[path] = value;
+  }
+};
+
+const getASTValue = (v, exprs, bindings) => {
+  return isNull(v)
+    ? t.nullLiteral()
+    : isUndefined(v)
+    ? t.identifier('undefined')
+    : isString(v)
+    ? t.stringLiteral(v)
+    : isNumber(v)
+    ? t.numericLiteral(v)
+    : isBoolean(v)
+    ? t.booleanLiteral(v)
+    : isArray(v)
+    ? t.arrayExpression(v.map((v) => getASTValue(v, exprs, bindings)))
+    : isPlainObject(v) && !v.language
+    ? t.objectExpression(
+        Object.entries(v).map(([k, v]) =>
+          t.objectProperty(t.identifier(k), getASTValue(v, exprs, bindings)),
+        ),
+      )
+    : generateNode(v, exprs, bindings);
+};
+
+const generateNodeChild = (child, bindings) => {
+  if (child.type === 'Reference') {
+    return expression(`%%t%%.ref\`${child.value}\``)({ t: bindings.t });
+  } else if (child.type === 'Literal') {
+    return expression(`%%t%%.lit\`${child.value.replace(/\\/g, '\\\\')}\``)({ t: bindings.t });
+  } else if (child.type === 'Trivia') {
+    return expression(`%%t%%.trivia\` \``)({ t: bindings.t });
+  } else if (child.type === 'Escape') {
+    return expression(`%%t%%.esc(%%cooked%%, %%raw%%)`)({
+      t: bindings.t,
+      cooked: child.cooked,
+      raw: child.raw,
+    });
+  } else {
+    throw new Error(`Unknown child type ${child.type}`);
+  }
+};
+
+const generateNode = (node, exprs, bindings) => {
+  const resolver = new PathResolver(node);
+  const { children, type, language, attributes, properties } = node;
+  const properties_ = {};
+  const children_ = [];
+
+  if (!children) {
+    throw new Error();
+  }
+
+  for (const child of children) {
+    children_.push(generateNodeChild(child, bindings));
+
+    if (child.type === 'Reference') {
+      const path = child.value;
+      const resolved = resolver.get(path);
+      const pathIsArray = isArray(properties[path]);
+
+      let embedded = resolved;
+      if (resolved) {
+        embedded = generateNode(resolved, exprs, bindings);
+      } else {
+        embedded = exprs.pop();
+        const { interpolateArray, interpolateString } = bindings;
+
+        if (pathIsArray) {
+          embedded = expression('[...%%interpolateArray%%(%%embedded%%)]')({
+            interpolateArray,
+            embedded,
+          }).elements[0];
+        } else if (language === 'String' && type === 'String') {
+          embedded = expression('%%interpolateString%%(%%embedded%%)')({
+            interpolateString,
+            embedded,
+          });
+        }
+      }
+
+      set(properties_, path, embedded, pathIsArray);
+    }
+  }
+
+  return expression(
+    `%%t%%.node(%%language%%, %%type%%, %%children%%, %%properties%%, %%attributes%%)`,
+  )({
+    t: bindings.t,
+    language: t.stringLiteral(language),
+    type: t.stringLiteral(type),
+    children: t.arrayExpression(children_),
+    properties: t.objectExpression(
+      Object.entries(properties_).map(([key, value]) =>
+        t.objectProperty(t.identifier(key), isArray(value) ? t.arrayExpression(value) : value),
+      ),
+    ),
+    attributes: t.objectExpression(
+      Object.entries(attributes).map(([key, value]) =>
+        t.objectProperty(t.identifier(key), getASTValue(value, exprs, bindings)),
+      ),
+    ),
+  });
+};
+
+const languages = {
+  i,
+  re,
+  spam,
+  str,
+  cst: cstml,
+};
+
+const topTypes = {
+  i: 'Call',
+  re: 'Pattern',
+  spam: 'Matcher',
+  str: 'String',
+  cst: 'Node',
+};
+
+const getTopScope = (scope) => {
+  let top = scope;
+  while (top.parent) top = top.parent;
+  return top;
+};
+
+const shorthandMacro = ({ references }) => {
+  const bindings = {};
+
+  // decorator references
+
+  for (const ref of concat(
+    references.i,
+    references.spam,
+    references.re,
+    references.str,
+    references.cst,
+  )) {
+    if (!bindings.t) {
+      bindings.t = addNamespace(getTopScope(ref.scope).path, '@bablr/boot-helpers/types', {
+        nameHint: 't',
+      });
+    }
+
+    if (!bindings.interpolateArray) {
+      bindings.interpolateArray = addNamed(
+        getTopScope(ref.scope).path,
+        'interpolateArray',
+        '@bablr/boot-helpers/template',
+      );
+    }
+
+    if (!bindings.interpolateString) {
+      bindings.interpolateString = addNamed(
+        getTopScope(ref.scope).path,
+        'interpolateString',
+        '@bablr/boot-helpers/template',
+      );
+    }
+
+    const taggedTemplate =
+      ref.parentPath.type === 'MemberExpression' ? ref.parentPath.parentPath : ref.parentPath;
+
+    const { quasis, expressions } = taggedTemplate.node.quasi;
+
+    const tagName = ref.node.name;
+    const language = languages[tagName];
+    const type =
+      ref.parentPath.type === 'MemberExpression'
+        ? ref.parentPath.node.property.name
+        : topTypes[tagName];
+
+    if (!language) throw new Error();
+
+    const ast = new TemplateParser(
+      language,
+      quasis.map((q) => q.value.raw),
+      expressions.map(() => null),
+    ).eval({ language: language.name, type });
+
+    taggedTemplate.replaceWith(generateNode(ast, expressions.reverse(), bindings));
+  }
+};
+
+module.exports = createMacro(shorthandMacro);