@bablr/boot 0.4.0 → 0.6.0

package/shorthand.macro.js

@@ -8,21 +8,45 @@ const isNull = require('iter-tools/methods/is-null');
 const isString = require('iter-tools/methods/is-string');
 const concat = require('iter-tools/methods/concat');
 const { createMacro } = require('babel-plugin-macros');
-const { TemplateParser, set, getAgASTValue } = require('./lib/index.js');
+const { TemplateParser, add, getAgASTValue } = require('./lib/index.js');
 const i = require('./lib/languages/instruction.js');
 const re = require('./lib/languages/regex.js');
 const spam = require('./lib/languages/spamex.js');
 const cstml = require('./lib/languages/cstml.js');
 const { addNamespace, addNamed } = require('@babel/helper-module-imports');
-const { PathResolver } = require('@bablr/boot-helpers/path');
 const { printPrettyCSTML } = require('./lib/print.js');
+const sym = require('@bablr/boot-helpers/symbols');
+const {
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  GapTag,
+  ArrayTag,
+  LiteralTag,
+  EmbeddedNode,
+} = require('@bablr/boot-helpers/symbols');
+const btree = require('@bablr/boot-helpers/btree');
 
 const { isArray } = Array;
+const { hasOwn } = Object;
 const isNumber = (v) => typeof v === 'number';
 const isBoolean = (v) => typeof v === 'boolean';
 const isPlainObject = (v) => isObject(v) && !isArray(v);
 const printRef = (ref) => (ref.isArray ? `${ref.name}[]` : ref.name);
 
+const getBtreeASTValue = (tree, exprs, bindings) => {
+  if (!isArray(tree)) return tree;
+
+  if (btree.isLeafNode(tree)) {
+    return t.arrayExpression(tree);
+  } else {
+    return t.arrayExpression([
+      t.numericLiteral(tree[0]),
+      t.arrayExpression(tree[1].map((v) => getBtreeASTValue(v, exprs, bindings))),
+    ]);
+  }
+};
+
 const getBabelASTValue = (v, exprs, bindings) => {
   return isNull(v)
     ? t.nullLiteral()
@@ -46,30 +70,38 @@ const getBabelASTValue = (v, exprs, bindings) => {
 };
 
 const generateBabelNodeChild = (child, exprs, bindings) => {
-  if (child.type === 'Reference') {
+  if (child.type === ReferenceTag) {
     return expression(`%%t%%.ref\`${printRef(child.value)}\``)({ t: bindings.t });
-  } else if (child.type === 'Literal') {
+  } else if (child.type === LiteralTag) {
     return expression(`%%t%%.lit(%%value%%)`)({
       t: bindings.t,
       value: getBabelASTValue(child.value, exprs, bindings),
     });
-  } else if (child.type === 'EmbeddedNode') {
+  } else if (child.type === EmbeddedNode) {
     return expression(`%%t%%.embedded(%%value%%)`)({
       t: bindings.t,
       value: generateBabelNode(child.value, exprs, bindings),
     });
+  } else if (child.type === ArrayTag) {
+    return expression(`%%t%%.arr()`)({
+      t: bindings.t,
+    });
+  } else if (child.type === GapTag) {
+    return expression(`%%t%%.gap()`)({
+      t: bindings.t,
+    });
   } else {
     throw new Error(`Unknown child type ${child.type}`);
   }
 };
 
 const getAgastNodeType = (flags) => {
-  if (flags.intrinsic && flags.token) {
-    return 's_i_node';
-  } else if (flags.token && flags.trivia) {
+  if (flags.token && flags.trivia) {
     return 's_t_node';
   } else if (flags.token && flags.escape) {
     return 's_e_node';
+  } else if (flags.escape) {
+    return 'e_node';
   } else if (flags.token) {
     return 's_node';
   } else {
@@ -78,75 +110,81 @@ const getAgastNodeType = (flags) => {
 };
 
 const generateBabelNode = (node, exprs, bindings) => {
-  const resolver = new PathResolver(node);
   const { flags = {}, children, type, language, attributes } = node;
 
   const properties_ = {};
-  const children_ = [];
+  let children_ = [];
 
   if (!children) {
     throw new Error();
   }
 
-  for (const child of children) {
-    if (child.type === 'Reference') {
-      const path = child.value;
-      const { isArray: pathIsArray } = path;
-      const resolved = resolver.get(path);
+  // resolver.advance({ type: DoctypeTag, value: {} });
 
-      if (resolved) {
-        set(properties_, path, generateBabelNode(resolved, exprs, bindings));
-        children_.push(generateBabelNodeChild(child, exprs, bindings));
-      } else {
-        // gap
-        const expr = exprs.pop();
-        const { interpolateArray, interpolateArrayChildren, interpolateString } = bindings;
+  for (const child of btree.traverse(children)) {
+    if (child.type === ReferenceTag) {
+      const path = child.value;
+      const { isArray: pathIsArray, name } = path;
+      if (!pathIsArray || hasOwn(properties_, name)) {
+        let resolved = node.properties[name];
 
         if (pathIsArray) {
-          set(
-            properties_,
-            path,
-            expression('[...%%interpolateArray%%(%%expr%%)]')({
-              interpolateArray,
-              expr,
-            }).elements[0],
-          );
-
-          children_.push(
-            t.spreadElement(
-              expression('%%interpolateArrayChildren%%(%%expr%%, %%ref%%, %%sep%%)')({
-                interpolateArrayChildren,
+          resolved = btree.getAt(btree.getSum(properties_[name]), resolved);
+        }
+
+        if (resolved.type !== sym.gap) {
+          add(properties_, path, generateBabelNode(resolved, exprs, bindings));
+          children_ = btree.push(children_, generateBabelNodeChild(child, exprs, bindings));
+        } else {
+          // gap
+          const expr = exprs.pop();
+          const { interpolateArray, interpolateFragmentChildren, interpolateString } = bindings;
+
+          if (pathIsArray) {
+            add(
+              properties_,
+              path,
+              expression('[...%%interpolateArray%%(%%expr%%)]')({
+                interpolateArray,
+                expr,
+              }).elements[0],
+            );
+
+            children_ = btree.push(
+              children_,
+              t.spreadElement(
+                expression('%%interpolateFragmentChildren%%(%%expr%%, %%ref%%)')({
+                  interpolateFragmentChildren,
+                  expr,
+                  ref: expression(`%%t%%.ref\`${printRef(child.value)}\``)({ t: bindings.t }),
+                }),
+              ),
+            );
+          } else if (language === cstml.canonicalURL && type === 'String') {
+            add(
+              properties_,
+              path,
+              expression('%%interpolateString%%(%%expr%%)')({
+                interpolateString,
                 expr,
-                ref: expression(`%%t%%.ref\`${printRef(child.value)}\``)({ t: bindings.t }),
-
-                // Really really awful unsafe-as-heck hack, to be removed ASAP
-                // Fixing this requires having interpolation happen during parsing
-                // That way the grammar can deal with the separators!
-                sep: expression(
-                  "%%t%%.embedded(%%t%%.t_node(%%l%%.Comment, null, [%%t%%.embedded(%%t%%.t_node('Space', 'Space', [%%t%%.lit(' ')]))]))",
-                )({ t: bindings.t, l: bindings.l }),
               }),
-            ),
-          );
-        } else if (language === cstml.canonicalURL && type === 'String') {
-          set(
-            properties_,
-            path,
-            expression('%%interpolateString%%(%%expr%%)')({
-              interpolateString,
-              expr,
-            }),
-          );
-
-          children_.push(generateBabelNodeChild(child, exprs, bindings));
-        } else {
-          set(properties_, path, expr);
+            );
 
-          children_.push(generateBabelNodeChild(child, exprs, bindings));
+            children_ = btree.push(children_, generateBabelNodeChild(child, exprs, bindings));
+          } else {
+            add(properties_, path, expr);
+
+            children_ = btree.push(children_, generateBabelNodeChild(child, exprs, bindings));
+          }
         }
+      } else if (pathIsArray) {
+        children_ = btree.push(children_, generateBabelNodeChild(child, exprs, bindings));
+        properties_[name] = [];
       }
     } else {
-      children_.push(generateBabelNodeChild(child, exprs, bindings));
+      if (child.type !== OpenNodeTag && child.type !== CloseNodeTag) {
+        children_ = btree.push(children_, generateBabelNodeChild(child, exprs, bindings));
+      }
     }
   }
 
@@ -160,10 +198,7 @@ const generateBabelNode = (node, exprs, bindings) => {
       : {
           properties: t.objectExpression(
             Object.entries(properties_).map(([key, value]) =>
-              t.objectProperty(
-                t.identifier(key),
-                isArray(value) ? t.arrayExpression(value) : value,
-              ),
+              t.objectProperty(t.identifier(key), isArray(value) ? getBtreeASTValue(value) : value),
             ),
           ),
           attributes: t.objectExpression(
@@ -173,6 +208,10 @@ const generateBabelNode = (node, exprs, bindings) => {
           ),
         };
 
+  if (type === sym.gap) {
+    return expression(`%%t%%.g_node()`)({ t: bindings.t });
+  }
+
   return expression(`%%t%%.%%nodeType%%(%%l%%.%%language%%, %%type%%, %%children%%${propsAtts})`)({
     t: bindings.t,
     l: bindings.l,
@@ -181,8 +220,8 @@ const generateBabelNode = (node, exprs, bindings) => {
     type: t.stringLiteral(type),
     children:
       nodeType === 's_node' || nodeType === 's_i_node'
-        ? t.stringLiteral(children[0].value)
-        : t.arrayExpression(children_),
+        ? t.stringLiteral(btree.getAt(1, children).value)
+        : getBtreeASTValue(children_),
     ...propsAttsValue,
   });
 };
@@ -258,10 +297,10 @@ const shorthandMacro = ({ references }) => {
       );
     }
 
-    if (!bindings.interpolateArrayChildren) {
-      bindings.interpolateArrayChildren = addNamed(
+    if (!bindings.interpolateFragmentChildren) {
+      bindings.interpolateFragmentChildren = addNamed(
         getTopScope(ref.scope).path,
-        'interpolateArrayChildren',
+        'interpolateFragmentChildren',
         '@bablr/agast-helpers/template',
       );
     }

package/lib/symbols.js

@@ -1,4 +0,0 @@
-const node = Symbol.for('@bablr/node');
-const fragment = Symbol.for('@bablr/fragment');
-
-module.exports = { node, fragment };