@bablr/boot 0.3.0 → 0.5.0

package/lib/builders.js

@@ -1,5 +1,13 @@
+const sym = require('@bablr/boot-helpers/symbols');
 const { freeze, getPrototypeOf } = Object;
 const { isArray } = Array;
+const {
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  GapTag,
+  LiteralTag,
+} = require('@bablr/boot-helpers/symbols');
 
 const spreads = new WeakMap();
 
@@ -31,16 +39,16 @@ const interpolateArray = (values, buildSeparator) => {
   return children;
 };
 
-const buildTerminal = (term) => {
+const buildTag = (term) => {
   switch (term?.type) {
-    case 'Literal':
+    case LiteralTag:
       return term;
 
     // case 'Escape':
     //   return buildEscapeNode;
 
     default:
-      throw new Error('Invalid terminal of type ' + term.type);
+      throw new Error('Invalid tag of type ' + term.type);
   }
 };
 
@@ -48,34 +56,34 @@ const interpolateString = (value) => {
   const children = [];
   if (isArray(value)) {
     for (const element of value) {
-      children.push(buildTerminal(element));
+      children.push(buildTag(element));
     }
   } else {
     // we can't safely interpolate strings here, though I wish we could
-    children.push(buildTerminal(value));
+    children.push(buildTag(value));
   }
 
   return buildNode('String', 'Content', children);
 };
 
-const buildReference = (name, isArray) => {
-  return freeze({ type: 'Reference', value: freeze({ name, isArray }) });
+const buildReferenceTag = (name, isArray) => {
+  return freeze({ type: ReferenceTag, value: freeze({ name, isArray }) });
 };
 
-const buildGap = () => {
-  return freeze({ type: 'Gap', value: undefined });
+const buildGapTag = () => {
+  return freeze({ type: GapTag, value: undefined });
 };
 
-const buildNodeOpenTag = (flags, type, attributes = {}) => {
-  return freeze({ type: 'OpenNodeTag', value: freeze({ flags, type, attributes }) });
+const buildNodeOpenTag = (flags, language, type, attributes = {}) => {
+  return freeze({ type: OpenNodeTag, value: freeze({ flags, language, type, attributes }) });
 };
 
 const buildNodeCloseTag = (type) => {
-  return freeze({ type: 'CloseNodeTag', value: freeze({ type }) });
+  return freeze({ type: CloseNodeTag, value: freeze({ type }) });
 };
 
-const buildLiteral = (value) => {
-  return freeze({ type: 'Literal', value });
+const buildLiteralTag = (value) => {
+  return freeze({ type: LiteralTag, value });
 };
 
 const buildProperty = (key, value) => {
@@ -87,43 +95,43 @@ const buildProperty = (key, value) => {
 };
 
 const buildString = (value) => {
-  const terminals = [];
+  const Tags = [];
   let literal = '';
   for (const chr of value) {
     if (chr === "'") {
       if (literal)
-        terminals.push(
+        Tags.push(
           freeze({
-            type: 'Literal',
+            type: LiteralTag,
             value: literal,
           }),
         );
-      terminals.push(
+      Tags.push(
         e_node(
           'String',
           'Escape',
           [ref`escape`, ref`escapee`],
           {
             escape: s_node('String', 'Punctuator', '\\'),
-            escapee: s_node('String', 'Literal', "'"),
+            escapee: s_node('String', LiteralTag, "'"),
           },
           { cooked: chr },
         ),
       );
     } else if (chr === '\\') {
       if (literal)
-        terminals.push({
-          type: 'Literal',
+        Tags.push({
+          type: LiteralTag,
           value: literal,
         });
-      terminals.push(
+      Tags.push(
         e_node(
           'String',
           'Escape',
           [ref`escape`, ref`escapee`],
           {
             escape: s_node('String', 'Punctuator', '\\'),
-            escapee: s_node('String', 'Literal', '\\'),
+            escapee: s_node('String', LiteralTag, '\\'),
           },
           { cooked: chr },
         ),
@@ -133,9 +141,9 @@ const buildString = (value) => {
     }
   }
   if (literal)
-    terminals.push(
+    Tags.push(
       freeze({
-        type: 'Literal',
+        type: LiteralTag,
         value: literal,
       }),
     );
@@ -145,7 +153,7 @@ const buildString = (value) => {
     [ref`open`, ref`content`, ref`close`],
     {
       open: s_node('String', 'Punctuator', "'"),
-      content: interpolateString(terminals),
+      content: interpolateString(Tags),
       close: s_node('String', 'Punctuator', "'"),
     },
     {},
@@ -174,7 +182,7 @@ const buildBoolean = (value) => {
       );
 };
 
-const buildNull = () => {
+const buildNullTag = () => {
   return node(
     'Instruction',
     'Null',
@@ -186,7 +194,7 @@ const buildNull = () => {
   );
 };
 
-const buildArray = (elements) => {
+const buildArrayTag = (elements) => {
   return node(
     'Instruction',
     'Array',
@@ -237,7 +245,7 @@ const buildSpace = () => {
 };
 
 const buildIdentifier = (name) => {
-  return node('Instruction', 'Identifier', [buildLiteral(name)]);
+  return node('Instruction', 'Identifier', [buildLiteralTag(name)]);
 };
 
 const buildAttribute = (key, value) => {
@@ -249,7 +257,7 @@ const buildAttribute = (key, value) => {
 };
 
 const buildExpression = (expr) => {
-  if (expr == null) return buildNull();
+  if (expr == null) return buildNullTag();
 
   switch (typeof expr) {
     case 'boolean':
@@ -259,7 +267,7 @@ const buildExpression = (expr) => {
     case 'object': {
       switch (getPrototypeOf(expr)) {
         case Array.prototype:
-          return buildArray(expr);
+          return buildArrayTag(expr);
         case Object.prototype:
           if (expr.type && expr.language && expr.children && expr.properties) {
             return expr;
@@ -276,39 +284,48 @@ const buildExpression = (expr) => {
 
 const nodeFlags = freeze({ syntactic: false, escape: false, trivia: false });
 
-const buildNode = (language, type, children = [], properties = {}, attributes = {}) =>
-  freeze({
+const buildNode = (language, type, children = [], properties = {}, attributes = {}) => {
+  const openTag = buildNodeOpenTag(nodeFlags, language, type, attributes);
+  const closeTag = buildNodeCloseTag(type);
+  return freeze({
     flags: nodeFlags,
     language,
     type,
-    children: freeze(children),
+    children: freeze([openTag, ...children, closeTag]),
     properties: freeze(properties),
     attributes: freeze(attributes),
   });
+};
 
 const syntacticFlags = freeze({ syntactic: true, escape: false, trivia: false });
 
-const buildSyntacticNode = (language, type, value, attributes = {}) =>
-  freeze({
+const buildSyntacticNode = (language, type, value, attributes = {}) => {
+  const openTag = buildNodeOpenTag(syntacticFlags, language, type, attributes);
+  const closeTag = buildNodeCloseTag(type);
+  return freeze({
     flags: syntacticFlags,
     language,
     type,
-    children: [buildLiteral(value)],
+    children: [openTag, buildLiteralTag(value), closeTag],
     properties: freeze({}),
     attributes: freeze(attributes),
   });
+};
 
 const escapeFlags = freeze({ syntactic: false, escape: true, trivia: false });
 
-const buildEscapeNode = (language, type, children = [], properties = {}, attributes = {}) =>
-  freeze({
+const buildEscapeNode = (language, type, children = [], properties = {}, attributes = {}) => {
+  const openTag = buildNodeOpenTag(escapeFlags, language, type, attributes);
+  const closeTag = buildNodeCloseTag(type);
+  return freeze({
     flags: escapeFlags,
     language,
     type,
-    children: freeze(children),
+    children: freeze([openTag, ...children, closeTag]),
     properties: freeze(properties),
     attributes: freeze(attributes),
   });
+};
 
 const syntacticEscapeFlags = freeze({ syntactic: true, escape: true, trivia: false });
 
@@ -318,27 +335,44 @@ const buildSyntacticEscapeNode = (
   children = [],
   properties = {},
   attributes = {},
-) =>
-  freeze({
+) => {
+  const openTag = buildNodeOpenTag(syntacticEscapeFlags, language, type, attributes);
+  const closeTag = buildNodeCloseTag(type);
+  return freeze({
     flags: syntacticEscapeFlags,
     language,
     type,
-    children: freeze(children),
+    children: freeze([openTag, ...children, closeTag]),
     properties: freeze(properties),
     attributes: freeze(attributes),
   });
+};
 
 const triviaFlags = freeze({ syntactic: false, escape: false, trivia: true });
 
-const buildTriviaNode = (language, type, children = [], properties = {}, attributes = {}) =>
-  freeze({
+const buildTriviaNode = (language, type, children = [], properties = {}, attributes = {}) => {
+  const openTag = buildNodeOpenTag(triviaFlags, language, type, attributes);
+  const closeTag = buildNodeCloseTag(type);
+  return freeze({
     flags: triviaFlags,
     language,
     type,
-    children: freeze(children),
+    children: freeze([openTag, ...children, closeTag]),
     properties: freeze(properties),
     attributes: freeze(attributes),
   });
+};
+
+const buildGapNode = (attributes = []) => {
+  return freeze({
+    flags: nodeFlags,
+    language: null,
+    type: sym.gap,
+    children: freeze([buildGapTag()]),
+    properties: freeze({}),
+    attributes: freeze(attributes),
+  });
+};
 
 const stripArray = (val) => {
   if (isArray(val)) {
@@ -355,19 +389,21 @@ const ref = (path) => {
   if (isArray(path)) {
     const pathIsArray = path[0].endsWith('[]');
     const name = pathIsArray ? path[0].slice(0, -2) : path[0];
-    return buildReference(name, pathIsArray);
+    return buildReferenceTag(name, pathIsArray);
   } else {
     const { name, pathIsArray } = path;
-    return buildReference(name, pathIsArray);
+    return buildReferenceTag(name, pathIsArray);
   }
 };
 
-const lit = (str) => buildLiteral(stripArray(str));
+const lit = (str) => buildLiteralTag(stripArray(str));
 
-const gap = buildGap;
+const gap = buildGapTag;
+const arr = buildArrayTag;
 const nodeOpen = buildNodeOpenTag;
 const nodeClose = buildNodeCloseTag;
 const node = buildNode;
+const g_node = buildGapNode;
 const s_node = buildSyntacticNode;
 const e_node = buildEscapeNode;
 const s_e_node = buildSyntacticEscapeNode;
@@ -377,30 +413,33 @@ module.exports = {
   buildProperty,
   buildString,
   buildBoolean,
-  buildNull,
-  buildArray,
+  buildNullTag,
+  buildArrayTag,
   buildTuple,
   buildObject,
   buildExpression,
   buildSpace,
   buildIdentifier,
   buildAttribute,
-  buildReference,
-  buildGap,
+  buildReferenceTag,
+  buildGapTag,
   buildNodeOpenTag,
   buildNodeCloseTag,
-  buildLiteral,
+  buildLiteralTag,
   buildNode,
   buildSyntacticNode,
   buildEscapeNode,
   buildSyntacticEscapeNode,
   buildTriviaNode,
+  buildGapNode,
   ref,
   lit,
   gap,
+  arr,
   nodeOpen,
   nodeClose,
   node,
+  g_node,
   s_node,
   e_node,
   s_e_node,

package/lib/index.js

@@ -1,14 +1,48 @@
 const { PathResolver } = require('@bablr/boot-helpers/path');
 const cstml = require('./languages/cstml.js');
+const spamex = require('./languages/spamex.js');
 const regex = require('./languages/regex.js');
 const instruction = require('./languages/instruction.js');
-const { buildLiteral } = require('./builders.js');
+const {
+  buildLiteralTag,
+  buildNodeOpenTag,
+  buildNodeCloseTag,
+  buildTriviaNode,
+  buildGapNode,
+  buildSyntacticEscapeNode,
+} = require('./builders.js');
 const { TemplateParser } = require('./miniparser.js');
+const { Resolver } = require('./print.js');
+const {
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  ArrayTag,
+  EmbeddedNode,
+  Trivia,
+  Escape,
+} = require('@bablr/boot-helpers/symbols');
+const btree = require('@bablr/boot-helpers/btree');
 
 const { isArray } = Array;
 const { hasOwn } = Object;
 
-const set = (obj, path, value) => {
+const get = (node, path) => {
+  const { type, properties } = node;
+  const { 1: name, 2: index } = /^([^\.]+)(?:\.(\d+))?/.exec(path) || [];
+
+  if (!hasOwn(properties, name)) {
+    throw new Error(`Cannot find {name: ${name}} on node of {type: ${type}}`);
+  }
+
+  if (index != null) {
+    return properties[name]?.[parseInt(index, 10)];
+  } else {
+    return properties[name];
+  }
+};
+
+const add = (obj, path, value) => {
   const { name, isArray: pathIsArray } = path;
   if (pathIsArray) {
     if (!obj[name]) {
@@ -17,7 +51,7 @@ const set = (obj, path, value) => {
 
     if (!isArray(obj[name])) throw new Error('bad array value');
 
-    obj[name].push(value);
+    obj[name] = btree.push(obj[name], value);
   } else {
     if (hasOwn(obj, name)) {
       throw new Error('duplicate child name');
@@ -71,9 +105,14 @@ const getAgASTValue = (language, miniNode) => {
   }
 
   const { language: languageName, type, attributes } = miniNode;
-  const flags = { escape: false, trivia: false, token: false, intrinsic: false };
+  const flags = {
+    escape: !!miniNode.flags?.escape,
+    trivia: !!miniNode.flags?.trivia,
+    token: false,
+    intrinsic: false,
+  };
   const properties = {};
-  const children = [];
+  let children = [];
   const resolver = new PathResolver(miniNode);
   const resolvedLanguage =
     languageName !== language.name ? language.dependencies[languageName] : language;
@@ -90,7 +129,9 @@ const getAgASTValue = (language, miniNode) => {
     type === 'Punctuator' ||
     type === 'Keyword' ||
     type === 'Identifier' ||
-    type === 'StringContent'
+    type === 'StringContent' ||
+    type === 'Escape' ||
+    miniNode.flags?.syntactic
   ) {
     flags.token = true;
   }
@@ -99,51 +140,84 @@ const getAgASTValue = (language, miniNode) => {
     flags.intrinsic = true;
   }
 
+  children = btree.push(
+    children,
+    buildNodeOpenTag(flags, resolvedLanguage.canonicalURL, type, attributes),
+  );
+
   for (const child of miniNode.children) {
-    if (child.type === 'Reference') {
+    if (child.type === OpenNodeTag || child.type === CloseNodeTag) {
+      continue;
+    } else if (child.type === ReferenceTag) {
       const path = child.value;
-      const node = resolver.get(path);
-      set(properties, path, getAgASTValue(resolvedLanguage, node));
-      children.push(child);
-    } else if (child.type === 'Trivia') {
-      children.push({
-        type: 'Embedded',
-        value: {
-          flags: { escape: false, token: true, trivia: true, intrinsic: false },
-          language: 'https://bablr.org/languages/core/en/space-tab-newline',
-          type: 'Space',
-          children: [buildLiteral(child.value)],
-          properties: {},
-          attributes: {},
-        },
+      const { name, isArray } = path;
+      let node = resolver.get(child.value);
+
+      if (node === undefined) throw new Error();
+
+      const agASTNode = node === null ? buildGapNode() : getAgASTValue(resolvedLanguage, node);
+
+      if (isArray && !hasOwn(properties, name)) {
+        const newRef = { type: ReferenceTag, value: { name, isArray } };
+        const arrayTag = { type: ArrayTag, value: undefined };
+
+        children = btree.push(children, newRef);
+        children = btree.push(children, arrayTag);
+
+        add(properties, { name }, []);
+      }
+
+      add(properties, path, agASTNode);
+      children = btree.push(children, { type: ReferenceTag, value: { name, isArray } });
+    } else if (child.type === Trivia) {
+      children = btree.push(children, {
+        type: EmbeddedNode,
+        value: getAgASTValue(
+          resolvedLanguage,
+          buildTriviaNode(languageName, 'Space', [buildLiteralTag(child.value)]),
+        ),
       });
-    } else if (child.type === 'Escape') {
+    } else if (child.type === Escape) {
       const { cooked, raw } = child.value;
       const attributes = { cooked };
 
-      children.push({
-        type: 'Embedded',
-        value: {
-          flags: { escape: true, token: true, trivia: false, intrinsic: false },
-          language: cstml.canonicalURL,
-          type: 'Escape',
-          children: [buildLiteral(raw)],
-          properties: {},
-          attributes,
-        },
+      children = btree.push(children, {
+        type: EmbeddedNode,
+        value: getAgASTValue(
+          resolvedLanguage,
+          buildSyntacticEscapeNode(languageName, 'Escape', [buildLiteralTag(raw)], {}, attributes),
+        ),
       });
     } else {
-      children.push(child);
+      if (child.type === ArrayTag) throw new Error('badbad');
+      children = btree.push(children, child);
     }
   }
 
+  children = btree.push(children, buildNodeCloseTag());
+
   return { flags, language: resolvedLanguage.canonicalURL, type, children, properties, attributes };
 };
 
 const str = buildTag(cstml, 'String');
 const num = buildTag(cstml, 'Integer');
 const cst = buildTag(cstml, 'Node');
+const spam = buildTag(spamex, 'Pattern');
 const re = buildTag(regex, 'Pattern');
 const i = buildTag(instruction, 'Call');
 
-module.exports = { str, num, cst, re, i, buildTag, set, getAgASTValue, TemplateParser, parse };
+module.exports = {
+  str,
+  num,
+  cst,
+  spam,
+  re,
+  i,
+  buildTag,
+  get,
+  add,
+  getAgASTValue,
+  TemplateParser,
+  Resolver,
+  parse,
+};

package/lib/index.mjs

@@ -1,3 +1,17 @@
 import index from './index.js';
 
-export const { str, num, cst, re, i, buildTag, set, getAgASTValue, TemplateParser, parse } = index;
+export const {
+  str,
+  num,
+  cst,
+  cst: cstml,
+  spam,
+  spam: spamex,
+  re,
+  i,
+  buildTag,
+  set,
+  getAgASTValue,
+  TemplateParser,
+  parse,
+} = index;