@bablr/boot 0.4.0 → 0.6.0

package/lib/print.js

@@ -1,169 +1,228 @@
 const emptyStack = require('@iter-tools/imm-stack');
+const sym = require('@bablr/boot-helpers/symbols');
+const {
+  DoctypeTag,
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  GapTag,
+  NullTag,
+  ArrayTag,
+  LiteralTag,
+  EmbeddedNode,
+} = require('@bablr/boot-helpers/symbols');
+const btree = require('@bablr/boot-helpers/btree');
 
 const { isInteger, isFinite } = Number;
 const { isArray } = Array;
 const isString = (val) => typeof val === 'string';
 const isNumber = (val) => typeof val === 'number';
 
-const { freeze } = Object;
+const { freeze, hasOwn } = Object;
 
 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 node.properties[name]?.[parseInt(index, 10)];
+    return btree.getAt(parseInt(index, 10), properties[name]);
   } else {
-    return node.properties[name];
+    return properties[name];
   }
 };
 
 class Resolver {
-  constructor(node, counters = new Map()) {
-    this.node = node;
-    this.counters = counters;
+  constructor(
+    states = emptyStack.push({ properties: new Map(), idx: 0 }),
+    reference = null,
+    popped = false,
+  ) {
+    this.states = states;
+    this.reference = reference;
+    this.popped = popped;
   }
 
-  consume(reference) {
-    const { name, isArray } = reference.value;
-    const { counters } = this;
+  get idx() {
+    return this.states.value.idx;
+  }
 
-    if (isArray) {
-      const count = counters.get(name) + 1 || 0;
+  get properties() {
+    return this.states.value.properties;
+  }
 
-      counters.set(name, count);
-    } else {
-      if (counters.has(name)) throw new Error('attempted to consume property twice');
+  advance(tag) {
+    const { states } = this;
 
-      counters.set(name, 1);
-    }
+    ++states.value.idx;
 
-    return this;
-  }
+    this.popped = false;
 
-  resolve(reference) {
-    let { name, isArray } = reference.value;
-    const { counters } = this;
-    let path = name;
+    switch (tag.type) {
+      case ReferenceTag: {
+        const { name, isArray } = tag.value;
+        const { properties } = states.value;
 
-    if (isArray) {
-      const count = counters.get(name) || 0;
+        this.reference = tag;
 
-      path += '.' + count;
-    }
+        let state = properties.get(name);
 
-    return path;
-  }
+        if (isArray) {
+          if (state && !state.isArray) throw new Error();
 
-  get(reference) {
-    if (!this.node) throw new Error('Cannot get from a resolver with no node');
+          const { count = -1 } = state || {};
 
-    return get(this.node, this.resolve(reference));
-  }
+          state = { count: count + 1, isArray };
+        } else if (state) {
+          throw new Error(`attempted to consume property {name: ${name}} twice`);
+        } else {
+          state = { count: 1, isArray: false };
+        }
 
-  branch() {
-    return new Resolver(this.node, new Map(this.counters));
-  }
+        properties.set(name, state);
+
+        if (!isArray || state.count > 0) {
+          this.states = states.push({ properties: new Map(), idx: 0 });
+        }
 
-  accept(resolver) {
-    this.counters = resolver.counters;
+        break;
+      }
 
-    return this;
-  }
-}
+      case EmbeddedNode: {
+        this.reference = tag;
 
-const buildFrame = (node) => {
-  if (!node) throw new Error();
-  return { node, childrenIdx: -1, resolver: new Resolver(node) };
-};
+        this.states = states.push({ properties: new Map(), idx: 0 });
+        break;
+      }
 
-const buildNull = () => {
-  return freeze({ type: 'Null', value: undefined });
-};
+      case OpenNodeTag: {
+        const { flags } = tag.value;
+        const isRootNode = states.size === 1;
 
-const buildDoctypeTag = () => {
-  return freeze({ type: 'DoctypeTag', value: { doctype: 'cstml', version: 0 } });
-};
+        if (!isRootNode && !this.reference && !(flags.trivia || flags.escape)) {
+          throw new Error();
+        }
 
-const buildNodeOpenTag = (flags = {}, language = null, type = null, attributes = {}) => {
-  let { token, trivia, escape } = flags;
+        if (this.reference?.type !== EmbeddedNode && (flags.trivia || flags.escape)) {
+          this.states = states.push({ properties: new Map(), idx: 0 });
+        }
 
-  token = !!token;
-  trivia = !!trivia;
-  escape = !!escape;
+        this.reference = null;
+        break;
+      }
 
-  return freeze({
-    type: 'OpenNodeTag',
-    value: freeze({ flags: freeze({ token, trivia, escape }), language, type, attributes }),
-  });
-};
+      case ArrayTag: {
+        if (!this.reference) throw new Error();
 
-const buildNodeCloseTag = (type = null, language = null) => {
-  return freeze({ type: 'CloseNodeTag', value: freeze({ language, type }) });
-};
+        const { name } = this.reference.value;
+        const { properties } = states.value;
+        const state = properties.get(name);
+
+        if (!state || !state.isArray || state.count !== 0) throw new Error();
+
+        properties.set(name, { count: 0, isArray: true });
+
+        this.reference = null;
+        break;
+      }
+
+      case NullTag:
+      case GapTag: {
+        this.states = states.pop();
+        this.popped = true;
+        this.reference = null;
+        break;
+      }
+
+      case CloseNodeTag: {
+        this.states = states.pop();
+        this.popped = true;
+      }
+    }
+
+    return this;
+  }
+
+  resolve(reference) {
+    let { name, isArray } = reference.value;
+    const { states } = this;
+    const state = states.value.properties.get(name);
+    let path = name;
+
+    if (isArray) {
+      const count = state?.count || 0;
+      path += '.' + count;
+    }
+
+    return path;
+  }
+}
 
 function* streamFromTree(rootNode) {
-  if (!rootNode || rootNode.type === 'Gap') {
+  if (!rootNode || rootNode.type === GapTag) {
     return rootNode;
   }
 
-  yield buildDoctypeTag();
-  yield buildNodeOpenTag(undefined, rootNode.language[0]);
-
-  let stack = emptyStack.push(buildFrame(rootNode));
+  let stack = emptyStack.push(rootNode);
+  const resolver = new Resolver();
 
   stack: while (stack.size) {
-    const frame = stack.value;
-    const { node, resolver } = frame;
-    const { language, type, attributes, flags } = node;
+    const node = stack.value;
+    const { children } = node;
 
-    if (frame.childrenIdx === -1 && stack.size > 1) {
-      yield buildNodeOpenTag(flags, language, type, attributes);
-    }
+    while (true) {
+      const tag = btree.getAt(resolver.idx, children);
 
-    while (++frame.childrenIdx < node.children.length) {
-      const terminal = node.children[frame.childrenIdx];
+      switch (tag.type) {
+        case EmbeddedNode: {
+          stack = stack.push(tag.value);
 
-      switch (terminal.type) {
-        case 'Literal':
-        case 'Gap':
-        case 'Null': {
-          yield terminal;
-          break;
-        }
+          resolver.advance(tag);
 
-        case 'EmbeddedNode': {
-          stack = stack.push(buildFrame(terminal.value));
           continue stack;
         }
 
-        case 'Reference': {
-          if (stack.size > 1) {
-            yield terminal;
-          }
+        case ReferenceTag: {
+          const resolvedPath = resolver.resolve(tag);
+          const resolved = get(stack.value, resolvedPath);
+          const { name, isArray: refIsArray } = tag.value;
+
+          if (!resolved) throw new Error();
+
+          yield tag;
+
+          resolver.advance(tag);
 
-          const resolved = resolver.consume(terminal).get(terminal);
-          if (resolved) {
-            stack = stack.push(buildFrame(resolved));
-            continue stack;
-          } else {
-            yield buildNull();
-            break;
+          const resolverState = resolver.properties.get(name);
+
+          const isEmptyArray = resolverState?.count === 0;
+
+          if (!refIsArray || !isEmptyArray) {
+            if (isArray(resolved)) throw new Error();
+            stack = stack.push(resolved);
           }
+          continue stack;
         }
 
-        default: {
-          throw new Error();
+        case GapTag:
+        case NullTag:
+        case CloseNodeTag: {
+          stack = stack.pop();
+          resolver.advance(tag);
+          yield tag;
+          continue stack;
         }
-      }
-    }
 
-    if (stack.size > 1) {
-      yield buildNodeCloseTag(node.type, node.language);
+        default:
+          resolver.advance(tag);
+          yield tag;
+          break;
+      }
     }
-
-    stack = stack.pop();
   }
-  yield buildNodeCloseTag();
 }
 
 const printExpression = (expr) => {
@@ -213,58 +272,66 @@ const printFlags = (flags) => {
   return `${hash}${star}${at}`;
 };
 
-const printTerminal = (terminal) => {
-  switch (terminal?.type || 'Null') {
-    case 'Null': {
+const printTag = (tag) => {
+  switch (tag?.type || NullTag) {
+    case NullTag: {
       return 'null';
     }
 
-    case 'Gap': {
+    case GapTag: {
       return `<//>`;
     }
 
-    case 'Literal': {
-      return printString(terminal.value);
+    case ArrayTag: {
+      return `[]`;
     }
 
-    case 'DoctypeTag': {
-      let { doctype, attributes } = terminal.value;
+    case LiteralTag: {
+      return printString(tag.value);
+    }
+
+    case DoctypeTag: {
+      let { doctype, attributes } = tag.value;
 
       attributes = attributes ? ` ${printAttributes(attributes)}` : '';
 
       return `<!${doctype}${attributes}>`;
     }
 
-    case 'Reference': {
-      const { name, isArray } = terminal.value;
+    case ReferenceTag: {
+      const { name, isArray } = tag.value;
       const pathBraces = isArray ? '[]' : '';
 
       return `${name}${pathBraces}:`;
     }
 
-    case 'OpenNodeTag': {
-      const { flags, language: tagLanguage, type, attributes } = terminal.value;
+    case OpenNodeTag: {
+      const { flags, language: tagLanguage, type, attributes } = tag.value;
       const printedAttributes = attributes && printAttributes(attributes);
       const attributesFrag = printedAttributes ? ` ${printedAttributes}` : '';
 
+      if (type === sym.gap) {
+        return '';
+      }
+
       if (flags.escape && flags.trivia) throw new Error('Node cannot be escape and trivia');
 
       return `<${printFlags(flags)}${printTagPath(tagLanguage, type)}${attributesFrag}>`;
     }
 
-    case 'CloseNodeTag': {
+    case CloseNodeTag: {
       return `</>`;
     }
 
     default:
-      throw new Error();
+      throw new Error(`Unexpected tag {type: ${tag?.type}}`);
   }
 };
 
 const printPrettyCSTML = (tree, indent = '  ') => {
-  const terminals = streamFromTree(tree);
+  const tags = streamFromTree(tree);
 
-  if (!terminals) {
+  if (!tags) {
     return '<//>';
   }
 
@@ -272,23 +339,23 @@ const printPrettyCSTML = (tree, indent = '  ') => {
   let indentLevel = 0;
   let first = true;
 
-  for (const terminal of terminals) {
-    if (!first && terminal.type !== 'Null') {
+  for (const tag of tags) {
+    if (!first && tag.type !== NullTag) {
       printed += '\n';
     }
 
-    if (terminal.type === 'CloseNodeTag') {
+    if (tag.type === CloseNodeTag) {
       indentLevel--;
     }
 
-    if (terminal.type !== 'Null') {
+    if (tag.type !== NullTag) {
       printed += indent.repeat(indentLevel);
     } else {
       printed += ' ';
     }
-    printed += printTerminal(terminal);
+    printed += printTag(tag);
 
-    if (terminal.type === 'OpenNodeTag') {
+    if (tag.type === OpenNodeTag) {
       indentLevel++;
     }
 
@@ -323,9 +390,10 @@ const printString = (str) => {
 };
 
 module.exports = {
+  Resolver,
   printExpression,
   printAttributes,
-  printTerminal,
+  printTag,
   printPrettyCSTML,
   printSingleString,
   printDoubleString,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/boot",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Compile-time tools for bootstrapping BABLR VM",
   "engines": {
     "node": ">=12.0.0"
@@ -22,7 +22,8 @@
     "@babel/helper-module-imports": "^7.22.15",
     "@babel/template": "^7.22.15",
     "@babel/types": "7.23.0",
-    "@bablr/boot-helpers": "0.2.0",
+    "@bablr/boot-helpers": "0.3.1",
+    "@iter-tools/imm-stack": "1.1.0",
     "escape-string-regexp": "4.0.0",
     "iter-tools": "^7.5.3",
     "jest-diff": "29.7.0"