@bablr/boot 0.3.0 → 0.5.0

package/lib/languages/cstml.js

@@ -1,7 +1,7 @@
 const objectEntries = require('iter-tools/methods/object-entries');
 
 const { buildCovers } = require('../utils.js');
-const sym = require('../symbols.js');
+const sym = require('@bablr/boot-helpers/symbols');
 
 const _ = /\s+/y;
 const PN = 'Punctuator';
@@ -62,15 +62,15 @@ const covers = buildCovers({
     'DoctypeTag',
     'Attribute',
     'Property',
-    'Reference',
+    'ReferenceTag',
     'TagType',
-    'Null',
-    'Gap',
+    'NullTag',
+    'GapTag',
     'Node',
     'IdentifierPath',
     'OpenNodeTag',
     'CloseNodeTag',
-    'Terminal',
+    'Tag',
     'Number',
     'Digit',
     'String',
@@ -82,9 +82,9 @@ const covers = buildCovers({
   Attribute: ['MappingAttribute', 'BooleanAttribute'],
   AttributeValue: ['String', 'Number'],
   TagType: ['Identifier', 'GlobalIdentifier'],
-  Terminal: ['Literal', 'Trivia'],
-  PropertyValue: ['Gap', 'Node', 'Null'],
-  EmbeddedTerminal: ['Literal'],
+  Tag: ['LiteralTag', 'Trivia'],
+  PropertyValue: ['GapTag', 'Node', 'NullTag'],
+  EmbeddedTag: ['LiteralTag'],
   Number: ['Integer', 'Infinity'],
 });
 
@@ -92,6 +92,7 @@ const grammar = class CSTMLMiniparserGrammar {
   // @Node
   Document(p) {
     p.eatProduction('DoctypeTag', { path: 'doctype' });
+    p.eatMatchTrivia(_);
     p.eatProduction('Node', { path: 'tree' });
   }
 
@@ -113,12 +114,12 @@ const grammar = class CSTMLMiniparserGrammar {
   }
 
   // @Node
-  Null(p) {
+  NullTag(p) {
     p.eat('null', KW, { path: 'sigilToken' });
   }
 
   // @Node
-  Gap(p) {
+  GapTag(p) {
     p.eat('<//>', PN, { path: 'sigilToken' });
   }
 
@@ -131,14 +132,16 @@ const grammar = class CSTMLMiniparserGrammar {
     if (open.properties.flags?.token) {
       p.eatProduction('NodeChild', { path: 'children[]' }, { token: true });
       p.eatMatchTrivia(_);
-    } else {
-      while (!p.match('</')) {
+    } else if (!open.properties.selfClosingTagToken) {
+      while (!(p.match('</') || p.done)) {
         p.eatProduction('NodeChild', { path: 'children[]' });
         p.eatMatchTrivia(_);
       }
     }
 
-    p.eatProduction('CloseNodeTag', { path: 'close' });
+    if (!open.properties.selfClosingTagToken) {
+      p.eatProduction('CloseNodeTag', { path: 'close' });
+    }
   }
 
   NodeChild(p, _, props) {
@@ -148,7 +151,7 @@ const grammar = class CSTMLMiniparserGrammar {
       if (p.match(/<\*?@/y)) {
         p.eatProduction('Node');
       } else {
-        p.eatProduction('Literal');
+        p.eatProduction('LiteralTag');
       }
     } else {
       if (p.match(/<\*?#/y)) {
@@ -156,23 +159,23 @@ const grammar = class CSTMLMiniparserGrammar {
       } else if (p.match(/[a-zA-Z]/y)) {
         p.eatProduction('Property');
       } else if (p.match(/['"]/y)) {
-        p.eatProduction('Literal');
+        p.eatProduction('LiteralTag');
       }
     }
   }
 
   // @Node
   Property(p) {
-    p.eatProduction('Reference', { path: 'reference' });
+    p.eatProduction('ReferenceTag', { path: 'reference' });
     p.eatMatchTrivia(_);
     p.eatProduction('PropertyValue', { path: 'value' });
   }
 
   PropertyValue(p) {
     if (p.match('null')) {
-      p.eatProduction('Null');
+      p.eatProduction('NullTag');
     } else if (p.match('<//>')) {
-      p.eatProduction('Gap');
+      p.eatProduction('GapTag');
     } else {
       p.eatProduction('Node');
     }
@@ -198,13 +201,17 @@ const grammar = class CSTMLMiniparserGrammar {
       flags = p.eatProduction('Flags', { path: 'flags' });
     }
 
+    if (p.done) {
+      p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
+      return;
+    }
+
     p.eatProduction('TagType', { path: 'type' });
 
     let sp = p.eatMatchTrivia(_);
 
-    let iv;
     if (flags.properties.intrinsic && sp && (p.match(/['"/]/y) || p.atExpression)) {
-      iv = p.eatProduction('String', { path: 'intrinsicValue' });
+      p.eatProduction('String', { path: 'intrinsicValue' });
 
       sp = p.eatMatchTrivia(_);
     }
@@ -215,9 +222,7 @@ const grammar = class CSTMLMiniparserGrammar {
     }
 
     p.eatMatchTrivia(_);
-    if (iv) {
-      p.eat('/', PN, { path: 'selfClosingTagToken' });
-    }
+    p.eatMatch('/', PN, { path: 'selfClosingTagToken' });
     p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
@@ -305,20 +310,20 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   Identifier(p) {
-    p.eatLiteral(/[a-zA-Z][[a-zA-Z]-_]*/y);
+    p.eatLiteral(/[a-zA-Z][a-zA-Z-_]*/y);
   }
 
   // @Cover
-  Terminal(p) {
+  Tag(p) {
     if (p.match(/['"]/y)) {
-      p.eatProduction('Literal');
+      p.eatProduction('LiteralTag');
     } else {
       throw new Error();
     }
   }
 
   // @Node
-  Reference(p) {
+  ReferenceTag(p) {
     p.eatProduction('Identifier', { path: 'name' });
     p.eatMatchTrivia(_);
     p.eatMatch('[]', PN, { path: 'arrayToken' });
@@ -327,11 +332,11 @@ const grammar = class CSTMLMiniparserGrammar {
   }
 
   // @Cover
-  EmbeddedTerminal(p) {
+  EmbeddedTag(p) {
     if (p.match(/!['"]/y)) {
       p.eatProduction('Escape');
     } else if (p.match(/['"]/y)) {
-      p.eatProduction('Literal');
+      p.eatProduction('LiteralTag');
     } else {
       throw new Error();
     }

package/lib/languages/instruction.js

@@ -1,7 +1,7 @@
 const Spamex = require('./spamex.js');
 const CSTML = require('./cstml.js');
 const Regex = require('./regex.js');
-const { node } = require('../symbols.js');
+const { node } = require('@bablr/boot-helpers/symbols');
 const { buildCovers } = require('../utils.js');
 
 const _ = /\s+/y;

package/lib/languages/regex.js

@@ -1,7 +1,7 @@
 const when = require('iter-tools/methods/when');
 const { escapables } = require('./cstml.js');
 const { buildCovers } = require('../utils.js');
-const { node } = require('../symbols.js');
+const { node } = require('@bablr/boot-helpers/symbols');
 
 const name = 'Regex';
 
@@ -65,7 +65,7 @@ const unique = (flags) => flags.length === new Set(flags).size;
 const getSpecialPattern = (span) => {
   const { type } = span;
   if (type === 'Bare') {
-    return /[*+{}\[\]()\.^$|\\\n\/]/y;
+    return /[*+{}\[\]()\.^$|\\\n\/><]/y;
   } else if (type === 'CharacterClass') {
     return /[\]\\]/y;
   } else if (type === 'CharacterClass:First') {

package/lib/languages/spamex.js

@@ -1,12 +1,11 @@
 const Regex = require('./regex.js');
 const CSTML = require('./cstml.js');
 const { buildCovers } = require('../utils.js');
-const sym = require('../symbols.js');
+const sym = require('@bablr/boot-helpers/symbols');
 
 const _ = /\s+/y;
 const PN = 'Punctuator';
 const ID = 'Identifier';
-const LIT = 'Literal';
 
 const name = 'Spamex';
 
@@ -15,14 +14,18 @@ const canonicalURL = 'https://bablr.org/languages/core/en/spamex';
 const dependencies = { CSTML, Regex };
 
 const covers = buildCovers({
-  [sym.node]: ['Attribute', 'Identifier', 'Matcher', 'Literal', 'CSTML:Flags'],
+  [sym.node]: ['Attribute', 'Identifier', 'Pattern', 'Matcher', 'Literal', 'CSTML:Flags'],
   Attribute: ['MappingAttribute', 'BooleanAttribute'],
   AttributeValue: ['CSTML:String', 'CSTML:Number'],
-  Matcher: ['NodeMatcher', 'StringMatcher'],
+  Matcher: ['NodeMatcher', 'OpenNodeMatcher', 'CloseNodeMatcher', 'StringMatcher'],
   StringMatcher: ['CSTML:String', 'Regex:Pattern'],
 });
 
 const grammar = class SpamexMiniparserGrammar {
+  Pattern(p) {
+    p.eatProduction('Matcher', { path: 'matcher' });
+  }
+
   // @Cover
   Matcher(p) {
     if (p.match(/<[^!/]/y)) {
@@ -36,8 +39,28 @@ const grammar = class SpamexMiniparserGrammar {
     }
   }
 
-  // @Node
   NodeMatcher(p) {
+    let open = p.eatProduction('OpenNodeMatcher', { path: 'open' });
+
+    if (!open.properties.selfClosingTagToken) {
+      p.eatMatchTrivia(_);
+
+      if (open.properties.flags?.token) {
+        // p.eatProduction('NodeChild', { path: 'children[]' }, { token: true });
+        // p.eatMatchTrivia(_);
+      } else {
+        // while (!(p.match('</') || p.done)) {
+        //   p.eatProduction('NodeChild', { path: 'children[]' });
+        //   p.eatMatchTrivia(_);
+        // }
+      }
+
+      p.eatProduction('CloseNodeMatcher', { path: 'close' });
+    }
+  }
+
+  // @Node
+  OpenNodeMatcher(p) {
     p.eat('<', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
 
     if (!p.atExpression) {
@@ -48,6 +71,10 @@ const grammar = class SpamexMiniparserGrammar {
       p.eat(/[a-zA-Z]+/y, ID, { path: 'language' });
       p.eat(':', PN, { path: 'namespaceSeparatorToken' });
       p.eat(/[a-zA-Z]+/y, ID, { path: 'type' });
+    } else if (p.match('?')) {
+      p.eat('?', PN, { path: 'type' });
+    } else if (p.match(' ')) {
+      p.eatMatchTrivia(_);
     } else {
       if (p.atExpression) {
         p.eatProduction('Identifier', { path: 'type' });
@@ -58,7 +85,7 @@ const grammar = class SpamexMiniparserGrammar {
 
     let sp = p.eatMatchTrivia(_);
 
-    if (sp && (p.match(/['"/]/y) || p.atExpression)) {
+    if (sp && ((p.match(/['"/]/y) && !p.match('/>')) || p.atExpression)) {
       p.eatProduction('StringMatcher', { path: 'intrinsicValue' });
 
       sp = p.eatMatchTrivia(_);
@@ -70,6 +97,12 @@ const grammar = class SpamexMiniparserGrammar {
     }
 
     p.eatMatchTrivia(_);
+    p.eatMatch('/', PN, { path: 'selfClosingTagToken' });
+    p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
+  }
+
+  CloseNodeMatcher(p) {
+    p.eat('</', PN, { path: 'openToken', startSpan: 'Tag', balanced: '>' });
     p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
@@ -94,12 +127,12 @@ const grammar = class SpamexMiniparserGrammar {
 
   // @Node
   BooleanAttribute(p) {
-    p.eat(/[a-zA-Z]+/y, LIT, { path: 'key' });
+    p.eat(/[a-zA-Z]+/y, ID, { path: 'key' });
   }
 
   // @Node
   MappingAttribute(p) {
-    p.eat(/[a-zA-Z]+/y, LIT, { path: 'key' });
+    p.eat(/[a-zA-Z]+/y, ID, { path: 'key' });
     p.eatMatchTrivia(_);
     p.eat('=', PN, { path: 'mapToken' });
     p.eatMatchTrivia(_);

package/lib/match.js

@@ -1,6 +1,6 @@
 const { Path, buildNode } = require('./path.js');
 const { resolveDependentLanguage } = require('./utils.js');
-const sym = require('./symbols.js');
+const sym = require('@bablr/boot-helpers/symbols');
 
 class Match {
   constructor(parent, resolvedLanguage, id, attributes, path) {

package/lib/miniparser.js

@@ -3,10 +3,11 @@ 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('./symbols.js');
+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');
 
 class TemplateParser {
   constructor(rootLanguage, quasis, expressions) {
@@ -210,11 +211,11 @@ class TemplateParser {
     this.m = this.m.parent;
 
     if (this.path?.node) {
-      const isTerminal = (child) => ['Literal', 'Escape'].includes(child.type);
+      const isTag = (child) => [LiteralTag, Escape].includes(child.type);
 
       const { children } = this.path.node;
 
-      if (children.find(isTerminal) && !children.every(isTerminal)) {
+      if (children.find(isTag) && !children.every(isTag)) {
         throw new Error('strings must be wrapped in nodes');
       }
     }
@@ -280,7 +281,7 @@ class TemplateParser {
 
     const lastChild = arrayLast(children);
 
-    if (lastChild.type !== 'Reference') {
+    if (lastChild.type !== ReferenceTag) {
       throw new Error();
     }