@bablr/boot 0.9.0 → 0.11.0

package/lib/languages/spamex.js

@@ -1,11 +1,10 @@
-import * as sym from '@bablr/agast-vm-helpers/symbols';
-import * as Regex from './regex.js';
-import * as CSTML from './cstml.js';
-import * as JSON from './json.js';
+import Regex from './regex.js';
+import CSTML from './cstml.js';
+import JSON from './json.js';
+import { get } from '@bablr/agast-helpers/path';
 
 const _ = /\s+/y;
-const PN = 'Punctuator';
-const ID = 'Identifier';
+const PN = null;
 
 export const name = 'Spamex';
 
@@ -15,138 +14,126 @@ export const dependencies = { CSTML, JSON, Regex };
 
 export const covers = new Map([
   [
-    sym.node,
+    Symbol.for('@bablr/node'),
     new Set([
       'CSTML:Identifier',
       'PropertyMatcher',
       'JSON:String',
       'Regex:Pattern',
-      'BasicNodeMatcher',
+      'TreeNodeMatcher',
       'GapNodeMatcher',
-      'ArrayNodeMatcher',
       'NullNodeMatcher',
       'ReferenceMatcher',
+      'BoundNodeMatcher',
       'BindingMatcher',
-      'OpenNodeMatcher',
-      'CloseNodeMatcher',
+      'TreeNodeMatcherOpen',
+      'TreeNodeMatcherClose',
       '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']),
-  ],
+  ['Matcher', new Set(['BoundNodeMatcher'])],
+  ['NodeMatcher', new Set(['TreeNodeMatcher', 'GapNodeMatcher', 'NullNodeMatcher'])],
   ['StringMatcher', new Set(['JSON:String', 'Regex:Pattern'])],
 ]);
 
 export const grammar = class SpamexMiniparserGrammar {
-  // @Cover
   Matcher(p) {
-    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}`);
-    }
+    p.eatProduction('BoundNodeMatcher');
   }
 
-  // @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)) {
+    if (p.match(/[a-zA-Z.#@_]/y) || p.atExpression || null) {
       p.eatProduction('ReferenceMatcher', { path: 'refMatcher' });
     }
 
     p.eatMatchTrivia(_);
 
-    if (p.match(':')) {
-      p.eatProduction('BindingMatcher', { path: 'bindingMatcher' });
-    }
-
-    p.eatMatchTrivia(_);
-
-    p.eatProduction('NodeMatcher', { path: 'nodeMatcher' });
+    p.eatProduction('BoundNodeMatcher', { path: 'valueMatcher' });
   }
 
-  // @Node
   ReferenceMatcher(p) {
-    let name;
-    if ((name = p.match(/[.#@]/y))) {
-      name = p.eat(name, PN, { path: 'type' });
-    } else if (p.match(/[A-Za-z]/y)) {
-      name = p.eatProduction('CSTML:Identifier', { path: 'name' });
+    let name, type;
+    if ((type = p.match(/\.\.|[.#@_]/y))) {
+      p.eat(type, PN, { path: 'type' });
     }
 
-    let open =
-      name && p.eatMatch('[', PN, { path: 'openIndexToken', startSpan: 'Index', balanced: ']' });
-
-    if (open) {
-      p.eatMatchTrivia(_);
-      p.eat(']', PN, { path: 'closeIndexToken', endSpan: 'Index', balancer: true });
+    if ((!type || type === '#') && p.match(/[A-Za-z]/y)) {
+      name = p.eatProduction('CSTML:Identifier', { path: 'name' });
     }
 
     p.eatMatchTrivia(_);
-    if (p.match(/[+$]/y)) {
+    if (!['#', '@'].includes(type)) {
       p.eatProduction('CSTML:ReferenceFlags', { path: 'flags' });
       p.eatMatchTrivia(_);
     }
     p.eat(':', PN, { path: 'mapToken' });
   }
 
-  // @Node
+  BoundNodeMatcher(p) {
+    while (p.match(':')) {
+      p.eatProduction('BindingMatcher', { path: 'bindingMatchers[]' });
+      p.eatMatchTrivia(_);
+    }
+
+    p.eatProduction('NodeMatcher', { path: 'nodeMatcher', noInterpolate: true });
+  }
+
   BindingMatcher(p) {
     p.eat(':', PN, { path: 'openToken' });
+
     p.eatMatchTrivia(_);
-    p.eatProduction('CSTML:IdentifierPath', { path: 'languagePath' });
-    p.eatMatchTrivia(_);
+    let first = true;
+    while (!p.match(':') && (first || p.match('/'))) {
+      if (!first) {
+        p.eat('/', PN, { path: '#separatorTokens' });
+      }
+      p.eatProduction('CSTML:BindingSegment', { path: 'segments[]' });
+      p.eatMatchTrivia(_);
+      first = false;
+    }
     p.eat(':', PN, { path: 'closeToken' });
   }
 
   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();
+    let chrs = p.match(/<\/\/?>|<|null/y);
+    switch (chrs) {
+      case '<//>':
+        p.eatProduction('GapNodeMatcher');
+        break;
+      case '</>':
+        p.fail();
+        break;
+      case 'null':
+        p.eatProduction('NullNodeMatcher');
+        break;
+      default:
+        p.eatProduction('TreeNodeMatcher', { noInterpolate: true });
+        break;
     }
   }
 
-  // @Node
-  // @CoveredBy('NodeMatcher')
-  BasicNodeMatcher(p) {
-    let open = p.eatProduction('OpenNodeMatcher', { path: 'open' });
+  TreeNodeMatcher(p) {
+    if (p.match(/[a-zA-Z.#@]/y) || p.atExpression) {
+      p.eatProduction('PropertyMatcher', { path: 'children[]', noInterpolate: true });
+      return;
+    }
 
-    if (!open.properties.selfClosingTagToken) {
+    let open = p.eatProduction('TreeNodeMatcherOpen', { path: 'open' });
+
+    if (!get('selfClosingToken', open)) {
       p.eatMatchTrivia(_);
 
-      if (open.properties.flags?.token) {
+      if (get('flags', open)?.token) {
         // p.eatProduction('NodeChild', { path: 'children[]' }, { token: true });
         // p.eatMatchTrivia(_);
       } else {
@@ -156,30 +143,37 @@ export const grammar = class SpamexMiniparserGrammar {
         // }
       }
 
-      p.eatProduction('CloseNodeMatcher', { path: 'close' });
+      p.eatProduction('TreeNodeMatcherClose', { path: 'close' });
     }
   }
 
-  // @Node
-  OpenNodeMatcher(p) {
-    p.eat('<', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
+  TreeNodeMatcherOpen(p) {
+    if (p.match(/['"/]/y)) {
+      p.eatProduction('CSTML:NodeFlags', { path: 'flags', token: true });
+      p.eatProduction('StringMatcher', { path: 'literalValue' });
+
+      return { attrs: { selfClosing: true } };
+    }
+
+    p.eat('<', PN, { path: 'openToken' });
 
     if (!p.atExpression) {
       p.eatProduction('CSTML:NodeFlags', { path: 'flags' });
     }
 
+    let type;
+    if ((type = p.match(/[?]|__?/y))) {
+      p.eat(type, PN, { path: 'type' });
+    }
+
     if (p.match(/[a-zA-Z]/y) || p.atExpression) {
-      p.eatProduction('CSTML:Identifier', { path: 'type' });
-    } else if (p.match('?')) {
-      p.eat('?', PN, { path: 'type' });
-    } else if (p.match('_')) {
-      p.eat('_', PN, { path: 'type' });
+      p.eatProduction('CSTML:Identifier', { path: 'name' });
     }
 
     let sp = p.eatMatchTrivia(_);
 
     if (sp && ((p.match(/['"/]/y) && !p.match('/>')) || p.atExpression)) {
-      p.eatProduction('StringMatcher', { path: 'intrinsicValue' });
+      p.eatProduction('StringMatcher', { path: 'literalValue' });
 
       sp = p.eatMatchTrivia(_);
     }
@@ -190,16 +184,17 @@ export const grammar = class SpamexMiniparserGrammar {
     }
 
     p.eatMatchTrivia(_);
-    p.eatMatch('/', PN, { path: 'selfClosingTagToken' });
-    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
+    let sc = p.eatMatch('/', PN, { path: 'selfClosingToken' });
+    p.eat('>', PN, { path: 'closeToken' });
+
+    return { attrs: { selfClosing: !!sc } };
   }
 
-  CloseNodeMatcher(p) {
-    p.eat('</', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
-    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
+  TreeNodeMatcherClose(p) {
+    p.eat('</', PN, { path: 'openToken' });
+    p.eat('>', PN, { path: 'closeToken' });
   }
 
-  // @Cover
   StringMatcher(p) {
     if (p.match(/['"]/y)) {
       p.eatProduction('JSON:String');
@@ -208,3 +203,5 @@ export const grammar = class SpamexMiniparserGrammar {
     }
   }
 };
+
+export default { name, canonicalURL, dependencies, covers, grammar };

package/lib/match.js

@@ -1,7 +1,8 @@
-import { createNode } from '@bablr/agast-helpers/tree';
 import { Path } from './path.js';
 import { resolveDependentLanguage } from './utils.js';
 import * as sym from '@bablr/agast-vm-helpers/symbols';
+import { buildOpenCoverTag, buildOpenNodeTag, nodeFlags } from '@bablr/agast-helpers/builders';
+import { buildNode } from '@bablr/agast-helpers/path';
 
 export class Match {
   constructor(parent, resolvedLanguage, id, attributes, path) {
@@ -18,10 +19,10 @@ export class Match {
   }
 
   get isNode() {
-    const { type, resolvedLanguage } = this;
+    const { name, resolvedLanguage } = this;
     const { covers } = resolvedLanguage;
 
-    return covers.get(sym.node).has(type) && !covers.has(type);
+    return covers.get(Symbol.for('@bablr/node')).has(name) && !covers.has(name);
   }
 
   get language() {
@@ -32,6 +33,10 @@ export class Match {
     return this.id.type;
   }
 
+  get name() {
+    return this.id.name;
+  }
+
   get attrs() {
     return this.attributes;
   }
@@ -39,21 +44,19 @@ export class Match {
   static from(language, id, attrs = {}) {
     const resolvedLanguage = resolveDependentLanguage(language, id.language);
     const { covers } = resolvedLanguage;
-    const { type } = id;
-    const isCover = covers.has(type);
-    const isNode = covers.get(sym.node).has(type);
+    const { name } = id;
+    const isCover = covers.has(name);
+    const isNode = covers.get(Symbol.for('@bablr/node')).has(name);
 
     if (!isNode && !isCover) {
-      throw new Error(`Top {type: ${type}} must be a node or fragment`);
+      throw new Error(`Top {type: ${name}} must be a node or fragment`);
     }
 
     const path = Path.from(id, attrs);
 
-    if (isNode && !isCover) {
-      path.node = createNode();
-      path.node.type = type;
-      path.node.language = resolvedLanguage.canonicalURL;
-    }
+    path.node = buildNode(
+      isCover ? buildOpenCoverTag(nodeFlags, name) : buildOpenNodeTag(nodeFlags, name),
+    );
 
     return new Match(null, resolvedLanguage, id, attrs, path);
   }
@@ -61,9 +64,9 @@ export class Match {
   generate(id, attrs) {
     const resolvedLanguage = resolveDependentLanguage(this.resolvedLanguage, id.language);
     const { covers } = resolvedLanguage;
-    const { type } = id;
-    const isCover = covers.has(type);
-    const isNode = covers.get(sym.node).has(type) && !isCover;
+    const { name } = id;
+    const isCover = covers.has(name);
+    const isNode = covers.get(Symbol.for('@bablr/node')).has(name) && !isCover;
 
     const baseAttrs = this.isNode ? {} : this.attrs;
 
@@ -76,9 +79,7 @@ export class Match {
       } else {
         path = path.generate(id, attrs);
       }
-      path.node = createNode();
-      path.node.type = Symbol.for(type);
-      path.node.language = resolvedLanguage.canonicalURL;
+      path.node = buildNode(buildOpenNodeTag(nodeFlags, name));
     }
 
     return new Match(this, resolvedLanguage, id, { ...baseAttrs, ...attrs }, path);