@bablr/boot 0.6.3 → 0.7.0

package/lib/languages/spamex.js

@@ -1,49 +1,130 @@
-const Regex = require('./regex.js');
-const CSTML = require('./cstml.js');
-const { buildCovers } = require('../utils.js');
-const sym = require('@bablr/boot-helpers/symbols');
+import * as sym from '@bablr/agast-helpers/symbols';
+import * as Regex from './regex.js';
+import * as CSTML from './cstml.js';
+import * as JSON from './json.js';
 
 const _ = /\s+/y;
 const PN = 'Punctuator';
 const ID = 'Identifier';
 
-const name = 'Spamex';
-
-const canonicalURL = 'https://bablr.org/languages/core/en/spamex';
-
-const dependencies = { CSTML, Regex };
-
-const covers = buildCovers({
-  [sym.node]: [
-    'Attribute',
-    'Identifier',
-    'Matcher',
-    'OpenNodeMatcher',
-    'CloseNodeMatcher',
-    'Literal',
-    'CSTML:Flags',
+export const name = 'Spamex';
+
+export const canonicalURL = 'https://bablr.org/languages/core/en/spamex';
+
+export const dependencies = { CSTML, JSON, Regex };
+
+export const covers = new Map([
+  [
+    sym.node,
+    new Set([
+      'Identifier',
+      'PropertyMatcher',
+      'JSON:String',
+      'Regex:Pattern',
+      'BasicNodeMatcher',
+      'GapNodeMatcher',
+      'ArrayNodeMatcher',
+      'NullNodeMatcher',
+      'ReferenceMatcher',
+      'OpenNodeMatcher',
+      'CloseNodeMatcher',
+      'Literal',
+      'CSTML:NodeFlags',
+    ]),
+  ],
+  ['AttributeValue', new Set(['JSON:String', 'CSTML:Number'])],
+  ['Matcher', new Set(['PropertyMatcher', 'JSON:String', 'Regex:Pattern'])],
+  [
+    'NodeMatcher',
+    new Set(['BasicNodeMatcher', 'GapNodeMatcher', 'ArrayNodeMatcher', 'NullNodeMatcher']),
   ],
-  Attribute: ['MappingAttribute', 'BooleanAttribute'],
-  AttributeValue: ['CSTML:String', 'CSTML:Number'],
-  Matcher: ['NodeMatcher', 'StringMatcher'],
-  StringMatcher: ['CSTML:String', 'Regex:Pattern'],
-});
+  ['StringMatcher', new Set(['JSON:String', 'Regex:Pattern'])],
+]);
 
-const grammar = class SpamexMiniparserGrammar {
+export const grammar = class SpamexMiniparserGrammar {
   // @Cover
   Matcher(p) {
-    if (p.match(/<[^!/]/y)) {
-      p.eatProduction('NodeMatcher');
-    } else if (p.match(/['"]/y)) {
-      p.eatProduction('CSTML:String');
-    } else if (p.match('/')) {
-      p.eatProduction('Regex:Pattern');
+    if (p.match(/[a-zA-Z.#@<]/y)) {
+      p.eatProduction('PropertyMatcher');
+    } else if (p.match(/['"/]/y)) {
+      p.eatProduction('StringMatcher');
     } else {
       throw new Error(`Unexpected character ${p.chr}`);
     }
   }
 
+  // @Node
+  // @CoveredBy('NodeMatcher')
+  GapNodeMatcher(p) {
+    p.eat('<//>', PN, { path: 'sigilToken' });
+  }
+
+  // @Node
+  // @CoveredBy('NodeMatcher')
+  ArrayNodeMatcher(p) {
+    p.eat('[]', PN, { path: 'sigilToken' });
+  }
+
+  // @Node
+  // @CoveredBy('NodeMatcher')
+  NullNodeMatcher(p) {
+    p.eat('null', PN, { path: 'sigilToken' });
+  }
+
+  // @Node
+  // @CoveredBy('Matcher')
+  PropertyMatcher(p) {
+    if (p.match(/[a-zA-Z.#@]/y)) {
+      p.eatProduction('ReferenceMatcher', { path: 'refMatcher' });
+    }
+
+    p.eatMatchTrivia(_);
+
+    p.eatProduction('NodeMatcher', { path: 'nodeMatcher' });
+  }
+
+  // @Node
+  ReferenceMatcher(p) {
+    let name;
+    if ((name = p.match(/[.#@]/y))) {
+      name = p.eat(name, PN, { path: 'name' });
+    } else if (p.match(/[A-Za-z]/y)) {
+      name = p.eatProduction('CSTML:Identifier', { path: 'name' });
+    }
+
+    let open =
+      name && p.eatMatch('[', PN, { path: 'openIndexToken', startSpan: 'Index', balanced: ']' });
+
+    if (open) {
+      p.eatMatchTrivia(_);
+      p.eat(']', PN, { path: 'closeIndexToken', endSpan: 'Index', balancer: true });
+    }
+
+    p.eatMatchTrivia(_);
+    if (p.match(/[+$]/y)) {
+      p.eatProduction('CSTML:ReferenceFlags', { path: 'flags' });
+      p.eatMatchTrivia(_);
+    }
+    p.eat(':', PN, { path: 'mapToken' });
+  }
+
   NodeMatcher(p) {
+    if (p.match('<//>')) {
+      p.eatProduction('GapNodeMatcher');
+    } else if (p.match('<')) {
+      p.eatProduction('BasicNodeMatcher');
+    } else if (p.match('[')) {
+      p.eatProduction('ArrayNodeMatcher');
+    } else if (p.match('null')) {
+      p.eatProduction('NullNodeMatcher');
+    } else {
+      p.fail();
+    }
+  }
+
+  // @Node
+  // @CoveredBy('NodeMatcher')
+  BasicNodeMatcher(p) {
     let open = p.eatProduction('OpenNodeMatcher', { path: 'open' });
 
     if (!open.properties.selfClosingTagToken) {
@@ -68,11 +149,11 @@ const grammar = class SpamexMiniparserGrammar {
     p.eat('<', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
 
     if (!p.atExpression) {
-      p.eatProduction('CSTML:Flags', { path: 'flags' });
+      p.eatProduction('CSTML:NodeFlags', { path: 'flags' });
     }
 
-    if (p.match(/['"]|[a-zA-Z]+:/y)) {
-      p.eatProduction('CSTML:TagType', { path: 'type' });
+    if (p.match(/['"]|[a-zA-Z]+:/y) || p.atExpression) {
+      p.eatProduction('CSTML:TagType', { path: 'type', noInterpolate: true });
     } else if (p.match('?')) {
       p.eat('?', PN, { path: 'type' });
     } else if (p.match(' ')) {
@@ -93,9 +174,9 @@ const grammar = class SpamexMiniparserGrammar {
       sp = p.eatMatchTrivia(_);
     }
 
-    if ((sp && p.match(/[a-zA-Z]+/y)) || p.atExpression) {
-      p.eatProduction('Attributes', { path: 'attributes[]' });
-      sp = p.eatMatchTrivia(_);
+    if (p.match('{') || p.atExpression) {
+      p.eatProduction('JSON:Object', { path: 'attributes' });
+      p.eatMatchTrivia(_);
     }
 
     p.eatMatchTrivia(_);
@@ -108,52 +189,10 @@ const grammar = class SpamexMiniparserGrammar {
     p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
-  Attributes(p) {
-    let sp = true;
-    while (sp && (p.match(/[a-zA-Z]+/y) || p.atExpression)) {
-      p.eatProduction('Attribute');
-      if (p.match(/\s+[a-zA-Z]/y)) {
-        sp = p.eatMatchTrivia(_);
-      }
-    }
-  }
-
-  // @Cover
-  Attribute(p) {
-    if (p.match(/[a-zA-Z]+\s*=/y)) {
-      p.eatProduction('MappingAttribute');
-    } else {
-      p.eatProduction('BooleanAttribute');
-    }
-  }
-
-  // @Node
-  BooleanAttribute(p) {
-    p.eat(/[a-zA-Z]+/y, ID, { path: 'key' });
-  }
-
-  // @Node
-  MappingAttribute(p) {
-    p.eat(/[a-zA-Z]+/y, ID, { path: 'key' });
-    p.eatMatchTrivia(_);
-    p.eat('=', PN, { path: 'mapToken' });
-    p.eatMatchTrivia(_);
-    p.eatProduction('AttributeValue', { path: 'value' });
-  }
-
-  // @Cover
-  AttributeValue(p) {
-    if (p.match(/['"]/y)) {
-      p.eatProduction('CSTML:String');
-    } else if (p.match(/-|\d/y)) {
-      p.eatProduction('CSTML:Number');
-    }
-  }
-
   // @Cover
   StringMatcher(p) {
     if (p.match(/['"]/y)) {
-      p.eatProduction('CSTML:String');
+      p.eatProduction('JSON:String');
     } else {
       p.eatProduction('Regex:Pattern');
     }
@@ -164,5 +203,3 @@ const grammar = class SpamexMiniparserGrammar {
     p.eatLiteral(/[a-zA-Z]+/y);
   }
 };
-
-module.exports = { name, canonicalURL, dependencies, covers, grammar };

package/lib/match.js

@@ -1,8 +1,9 @@
-const { Path, buildNode } = require('./path.js');
-const { resolveDependentLanguage } = require('./utils.js');
-const sym = require('@bablr/boot-helpers/symbols');
+import { createNode } from '@bablr/agast-helpers/tree';
+import { Path } from './path.js';
+import { resolveDependentLanguage } from './utils.js';
+import * as sym from '@bablr/agast-helpers/symbols';
 
-class Match {
+export class Match {
   constructor(parent, resolvedLanguage, id, attributes, path) {
     this.parent = parent;
     this.resolvedLanguage = resolvedLanguage;
@@ -41,16 +42,17 @@ class Match {
     const { type } = id;
     const isCover = covers.has(type);
     const isNode = covers.get(sym.node).has(type);
-    const isFragment = covers.get(sym.fragment)?.has(type);
 
-    if (!isNode && !isFragment) {
+    if (!isNode && !isCover) {
       throw new Error(`Top {type: ${type}} must be a node or fragment`);
     }
 
     const path = Path.from(id, attrs);
 
-    if (isFragment || (isNode && !isCover)) {
-      path.node = buildNode(id);
+    if (isNode && !isCover) {
+      path.node = createNode();
+      path.node.type = type;
+      path.node.language = resolvedLanguage.canonicalURL;
     }
 
     return new Match(null, resolvedLanguage, id, attrs, path);
@@ -74,11 +76,11 @@ class Match {
       } else {
         path = path.generate(id, attrs);
       }
-      path.node = buildNode(id);
+      path.node = createNode();
+      path.node.type = Symbol.for(type);
+      path.node.language = resolvedLanguage.canonicalURL;
     }
 
     return new Match(this, resolvedLanguage, id, { ...baseAttrs, ...attrs }, path);
   }
 }
-
-module.exports = { Match };

package/lib/miniparser.js

@@ -1,17 +1,30 @@
-const { ref, lit, trivia, esc } = require('@bablr/boot-helpers/types');
-const escapeRegex = require('escape-string-regexp');
-const arrayLast = require('iter-tools/methods/array-last');
-const isString = require('iter-tools/methods/is-string');
-const isObject = require('iter-tools/methods/is-object');
-const sym = require('@bablr/boot-helpers/symbols');
-const { Match } = require('./match.js');
-const { parsePath } = require('./path.js');
-const { set, isRegex, isArray, getPrototypeOf, buildNode } = require('./utils.js');
-const { ReferenceTag, LiteralTag, Escape } = require('@bablr/boot-helpers/symbols');
-
-const { hasOwn } = Object;
-
-class TemplateParser {
+import escapeRegex from 'escape-string-regexp';
+import arrayLast from 'iter-tools/methods/array-last';
+import isString from 'iter-tools/methods/is-string';
+import isObject from 'iter-tools/methods/is-object';
+import * as sym from '@bablr/agast-helpers/symbols';
+import { Match } from './match.js';
+import { parsePath } from './path.js';
+import { isRegex, isArray, getPrototypeOf } from './utils.js';
+import { ReferenceTag, LiteralTag, ShiftTag } from '@bablr/agast-helpers/symbols';
+import {
+  buildCloseNodeTag,
+  buildLiteralTag,
+  buildOpenNodeTag,
+  buildReferenceTag,
+  nodeFlags,
+} from '@bablr/agast-helpers/builders';
+import { add, buildGapTag, buildShiftTag, buildToken } from '@bablr/agast-helpers/tree';
+import * as btree from '@bablr/agast-helpers/btree';
+import { get } from '@bablr/agast-helpers/path';
+
+const Escape = Symbol.for('Escape');
+
+const getProduction = (grammar, type) => {
+  return getPrototypeOf(grammar)[type];
+};
+
+export class TemplateParser {
   constructor(rootLanguage, quasis, expressions) {
     if (!quasis) throw new Error();
 
@@ -75,7 +88,7 @@ class TemplateParser {
   }
 
   get matchIsFragment() {
-    return this.language.covers.get(sym.fragment)?.has(this.m.type);
+    return false;
   }
 
   get span() {
@@ -123,7 +136,7 @@ class TemplateParser {
     }
   }
 
-  eval(id, attrs = {}, props = {}) {
+  eval(id, attrs = {}, props = {}, shift = null) {
     const parentMatch = this.m;
     const parentPath = this.path?.node ? this.path : this.path?.parent;
     const { type } = id;
@@ -143,13 +156,12 @@ class TemplateParser {
     const { covers } = this.language;
     const isNode = this.matchIsNode;
     const isCover = this.matchIsCover;
-    const isFragment = this.matchIsFragment;
     const isEmbedded = this.language !== this.m.parent?.resolvedLanguage;
     const { path, grammar } = this;
 
     if (!type) throw new Error('eval requires a type');
 
-    if (parentPath?.node && this.atExpression && (isNode || isCover || isFragment)) {
+    if (parentPath?.node && this.atExpression && !attrs.noInterpolate && (isNode || isCover)) {
       const { quasisDone } = this;
 
       if (quasisDone) throw new Error('there must be more quasis than expressions');
@@ -160,38 +172,20 @@ class TemplateParser {
       this.quasiIdx++;
       this.idx = 0;
 
-      if (parentPath?.node && isFragment) {
-        const { properties, children } = parentPath.node;
-
-        if (result) {
-          children.push(...result.children);
-
-          for (const { 0: key, 1: property } of Object.entries(result.properties)) {
-            if (isArray(property)) {
-              for (const value of property) {
-                set(properties, { name: key, isArray: true }, value);
-              }
-            } else {
-              set(properties, { name: key, isArray: false }, property);
-            }
-          }
-        }
-      } else if (parentPath?.node && (isNode || covers.has(type))) {
+      if (parentPath?.node && (isNode || covers.has(type))) {
         const { properties, children } = parentPath.node;
         const path = parsePath(this.m.attrs.path);
 
         if (isArray(result)) {
           for (const value of result) {
-            children.push(ref(path));
-
-            // TODO interpolate separators!
+            children.push(path);
 
-            set(properties, path, value);
+            add(parentPath.node, path, value);
           }
         } else {
-          children.push(ref(path));
+          children.push(path);
 
-          set(properties, path, result);
+          add(parentPath.node, path, result);
         }
       }
     } else {
@@ -199,10 +193,18 @@ class TemplateParser {
         this.spans.push({ type: 'Bare', guard: null });
       }
 
-      if (!hasOwn(getPrototypeOf(grammar), type)) {
+      if (!getProduction(grammar, type)) {
         throw new Error(`Unknown production {type: ${type}}`);
       }
 
+      if (isNode) {
+        let { node } = this.path;
+        node.children = btree.push(
+          node.children,
+          buildOpenNodeTag(nodeFlags, node.language, node.type),
+        );
+      }
+
       const result = getPrototypeOf(grammar)[type].call(grammar, this, props);
 
       if (isEmbedded) {
@@ -213,14 +215,19 @@ class TemplateParser {
         const { node } = this.path;
         if (result?.attrs) {
           node.attributes = result.attrs;
+          node.children = btree.replaceAt(
+            0,
+            node.children,
+            buildOpenNodeTag(nodeFlags, node.language, node.type, result.attrs),
+          );
         }
 
-        if (parentPath?.node && !covers.has(type)) {
-          const path = parsePath(this.m.attrs.path);
+        node.children = btree.push(node.children, buildCloseNodeTag());
 
-          parentPath.node.children.push(ref(path));
+        if (parentPath?.node && !covers.has(type) && shift == null) {
+          const path = parsePath(this.m.attrs.path);
 
-          set(parentPath.node.properties, path, node);
+          add(parentPath.node, path, node, shift);
         }
       }
     }
@@ -284,37 +291,36 @@ class TemplateParser {
 
     const path = parsePath(attrs.path);
 
-    children.push(ref(path));
-    set(properties, path, held);
+    children.push(path);
+    add(this.node, path, held);
 
     return held;
   }
 
   shiftProduction(id, attrs = {}, props = {}) {
-    const { children, properties } = this.node;
+    const { node } = this;
+    const { properties } = node;
     // don't push a new path onto the stack
 
     // get the most recently produced node and detach it from its parent
 
-    const lastChild = arrayLast(children);
+    const ref = btree.getAt(-2, node.children);
+
+    if (!ref.value.flags.expression) throw new Error();
 
-    if (lastChild.type !== ReferenceTag) {
+    if (ref.type !== ReferenceTag) {
       throw new Error();
     }
 
-    const { isArray, name } = lastChild.value;
+    this.held = get(ref, node);
 
-    this.held = isArray ? arrayLast(properties[name]) : properties[name];
+    let id_ = this.buildId(id);
 
-    children.pop();
+    const shifted = this.eval(id_, attrs, props, 1);
 
-    if (isArray) {
-      properties[name].pop();
-    } else {
-      properties[name] = null;
-    }
+    add(node, ref, shifted, 1);
 
-    return this.eval(this.buildId(id), attrs, props);
+    return shifted;
   }
 
   eat(pattern, type, attrs) {
@@ -332,10 +338,9 @@ class TemplateParser {
     this.updateSpans(attrs);
 
     const path_ = parsePath(attrs.path);
+    const language = this.language.canonicalURL;
 
-    set(this.node.properties, path_, buildNode(this.buildId(type), [lit(result)], {}, _attrs));
-
-    this.node.children.push(ref(path_));
+    add(this.node, path_, buildToken(language, type, result, _attrs));
 
     return result;
   }
@@ -349,12 +354,7 @@ class TemplateParser {
     if (!isString(type)) throw new Error('Cannot eatMatch anonymous token');
     if (!isObject(attrs) || !attrs.path) throw new Error('a node must have a path');
 
-    let result;
-    if (this.atExpression) {
-    } else {
-    }
-
-    result = this.matchSticky(pattern, attrs, this);
+    const result = this.matchSticky(pattern, attrs, this);
 
     if (result) {
       this.updateSpans(attrs);
@@ -362,10 +362,9 @@ class TemplateParser {
       this.idx += result.length;
 
       const path = parsePath(attrs.path);
+      const language = this.language.canonicalURL;
 
-      set(this.node.properties, path, buildNode(this.buildId(type), [lit(result)]));
-
-      this.node.children.push(ref(path));
+      add(this.node, path, buildToken(language, type, result));
     }
     return result;
   }
@@ -377,7 +376,11 @@ class TemplateParser {
 
     this.idx += result.length;
 
-    this.node.children.push(trivia(result));
+    add(
+      this.node,
+      buildReferenceTag('#'),
+      buildToken('https://bablr.org/languages/core/en/space-tab-newline', 'Space', result),
+    );
 
     return result;
   }
@@ -388,7 +391,11 @@ class TemplateParser {
     if (result) {
       this.idx += result.length;
 
-      this.node.children.push(trivia(result));
+      add(
+        this.node,
+        buildReferenceTag('#'),
+        buildToken('https://bablr.org/languages/core/en/space-tab-newline', 'Space', result),
+      );
     }
 
     return result;
@@ -401,7 +408,15 @@ class TemplateParser {
 
     this.idx += result.length;
 
-    this.node.children.push(esc(result, this.language.cookEscape(result, this.span)));
+    const raw = result;
+    const cooked = this.language.cookEscape(result, this.span);
+    const attributes = { cooked };
+
+    add(
+      this.node,
+      buildReferenceTag('@'),
+      buildToken(this.language.canonicalURL, 'Escape', raw, attributes),
+    );
 
     return result;
   }
@@ -412,7 +427,15 @@ class TemplateParser {
     if (result) {
       this.idx += result.length;
 
-      this.node.children.push(esc(result, this.language.cookEscape(result, this.span)));
+      const raw = result;
+      const cooked = this.language.cookEscape(result, this.span);
+      const attributes = { cooked };
+
+      add(
+        this.node,
+        buildReferenceTag('@'),
+        buildToken(this.language.canonicalURL, 'Escape', raw, attributes),
+      );
     }
 
     return result;
@@ -425,7 +448,7 @@ class TemplateParser {
 
     this.idx += result.length;
 
-    this.node.children.push(lit(result));
+    this.node.children.push(buildLiteralTag(result));
 
     return result;
   }
@@ -436,7 +459,7 @@ class TemplateParser {
     if (result) {
       this.idx += result.length;
 
-      this.node.children.push(lit(result));
+      this.node.children.push(buildLiteralTag(result));
     }
 
     return result;
@@ -462,5 +485,3 @@ class TemplateParser {
     throw new Error(`miniparser: parsing \`${this.quasis}\` failed`);
   }
 }
-
-module.exports = { TemplateParser };