@bablr/boot 0.4.0 → 0.6.0

package/lib/languages/cstml.js

@@ -1,13 +1,12 @@
 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';
 const ID = 'Identifier';
 const KW = 'Keyword';
-const LIT = 'Literal';
 
 const name = 'CSTML';
 
@@ -62,15 +61,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 +81,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 +91,7 @@ const grammar = class CSTMLMiniparserGrammar {
   // @Node
   Document(p) {
     p.eatProduction('DoctypeTag', { path: 'doctype' });
+    p.eatMatchTrivia(_);
     p.eatProduction('Node', { path: 'tree' });
   }
 
@@ -104,7 +104,7 @@ const grammar = class CSTMLMiniparserGrammar {
 
     let sp = p.eatMatchTrivia(_);
 
-    if ((sp && p.match(/[a-zA-Z]+/y)) || p.atExpression) {
+    if ((sp && p.match(/!?[a-zA-Z]/y)) || p.atExpression) {
       p.eatProduction('Attributes');
       sp = p.eatMatchTrivia(_);
     }
@@ -113,12 +113,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 +131,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,31 +150,31 @@ const grammar = class CSTMLMiniparserGrammar {
       if (p.match(/<\*?@/y)) {
         p.eatProduction('Node');
       } else {
-        p.eatProduction('Literal');
+        p.eatProduction('LiteralTag');
       }
     } else {
       if (p.match(/<\*?#/y)) {
         p.eatProduction('Node');
-      } else if (p.match(/[a-zA-Z]/y)) {
+      } 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');
     }
@@ -181,10 +183,10 @@ const grammar = class CSTMLMiniparserGrammar {
   // @Node
   Flags(p) {
     let tr = p.eatMatch('#', PN, { path: 'triviaToken' });
-    p.eatMatch('~', PN, { path: 'intrinsicToken' });
     p.eatMatch('*', PN, { path: 'tokenToken' });
     let esc = p.eatMatch('@', PN, { path: 'escapeToken' });
     let exp = p.eatMatch('+', PN, { path: 'expressionToken' });
+    p.eatMatch('$', PN, { path: 'hasGapToken' });
 
     if ((tr && esc) || (exp && (tr || esc))) throw new Error();
   }
@@ -198,26 +200,34 @@ 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)) {
+
+    if (sp && (p.match(/['"]/y) || p.atExpression)) {
       iv = p.eatProduction('String', { path: 'intrinsicValue' });
 
       sp = p.eatMatchTrivia(_);
     }
 
+    if (!flags.properties.tokenToken && iv) {
+      throw new Error();
+    }
+
     if ((sp && p.match(/[a-zA-Z]+/y)) || p.atExpression) {
       p.eatProduction('Attributes');
       sp = p.eatMatchTrivia(_);
     }
 
     p.eatMatchTrivia(_);
-    if (iv) {
-      p.eat('/', PN, { path: 'selfClosingTagToken' });
-    }
+    p.eatMatch('/', PN, { path: 'selfClosingTagToken' });
     p.eat('>', PN, { path: 'closeToken', endSpan: 'Tag', balancer: true });
   }
 
@@ -230,13 +240,13 @@ const grammar = class CSTMLMiniparserGrammar {
   // @Fragment
   Attributes(p) {
     let sp = true;
-    while (sp && (p.match(/[a-zA-Z]+/y) || p.atExpression)) {
+    while (sp && (p.match(/!?[a-zA-Z]/y) || p.atExpression)) {
       if (p.atExpression) {
         p.eatProduction('Attributes'); // ??
       } else {
         p.eatProduction('Attribute', { path: 'attributes[]' });
       }
-      if (p.match(/\s+[a-zA-Z]/y) || (p.match(/\s+$/y) && !p.quasisDone)) {
+      if (p.match(/\s+!?[a-zA-Z]/y) || (p.match(/\s+$/y) && !p.quasisDone)) {
         sp = p.eatMatchTrivia(_);
       } else {
         sp = false;
@@ -246,7 +256,7 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Cover
   Attribute(p) {
-    if (p.match(/[a-zA-Z][[a-zA-Z]-_]*\s*=/y)) {
+    if (p.match(/[a-zA-Z][a-zA-Z-_]*\s*=/y)) {
       p.eatProduction('MappingAttribute');
     } else {
       p.eatProduction('BooleanAttribute');
@@ -255,13 +265,13 @@ const grammar = class CSTMLMiniparserGrammar {
 
   // @Node
   BooleanAttribute(p) {
-    p.eat('!', KW, { path: 'negateToken' });
-    p.eat(/[a-zA-Z]+/y, ID, { path: 'key' });
+    p.eatMatch('!', KW, { path: 'negateToken' });
+    p.eat(/[a-zA-Z][a-zA-Z-_]*/y, ID, { path: 'key' });
   }
 
   // @Node
   MappingAttribute(p) {
-    p.eat(/[a-zA-Z]+/y, LIT, { path: 'key' });
+    p.eat(/[a-zA-Z][a-zA-Z-_]*/y, ID, { path: 'key' });
     p.eatMatchTrivia(_);
     p.eat('=', PN, { path: 'mapToken' });
     p.eatMatchTrivia(_);
@@ -278,7 +288,7 @@ const grammar = class CSTMLMiniparserGrammar {
   }
 
   TagType(p) {
-    if (p.match(/[[a-zA-Z].]+:/y)) {
+    if (p.match(/[a-zA-Z\.]+:/y)) {
       p.eatProduction('LanguageReference', { path: 'language' });
       p.eat(':', PN, { path: 'namespaceSeparatorToken' });
       p.eatProduction('Identifier', { path: 'type' });
@@ -305,21 +315,25 @@ 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) {
-    p.eatProduction('Identifier', { path: 'name' });
+  ReferenceTag(p) {
+    if (p.match('.')) {
+      p.eat('.', PN, { path: 'name' });
+    } else {
+      p.eatProduction('Identifier', { path: 'name' });
+    }
     p.eatMatchTrivia(_);
     p.eatMatch('[]', PN, { path: 'arrayToken' });
     p.eatMatchTrivia(_);
@@ -327,11 +341,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') {
@@ -154,7 +154,7 @@ const grammar = class RegexMiniparserGrammar {
   }
 
   Elements(p) {
-    while (p.match(/[^|]/y || p.atExpression)) {
+    while (p.match(/[^|]/y) || p.atExpression) {
       p.eatProduction('Element');
     }
   }

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) {
@@ -177,9 +178,19 @@ class TemplateParser {
         const { properties, children } = parentPath.node;
         const path = parsePath(this.m.attrs.path);
 
-        children.push({ ...ref(path), id });
+        if (isArray(result)) {
+          for (const value of result) {
+            children.push(ref(path));
 
-        set(properties, path, result);
+            // TODO interpolate separators!
+
+            set(properties, path, value);
+          }
+        } else {
+          children.push(ref(path));
+
+          set(properties, path, result);
+        }
       }
     } else {
       if (isEmbedded) {
@@ -197,6 +208,7 @@ class TemplateParser {
         if (result?.attrs) {
           node.attributes = result.attrs;
         }
+
         if (parentPath?.node && !covers.has(type)) {
           const path = parsePath(this.m.attrs.path);
 
@@ -210,11 +222,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 +292,7 @@ class TemplateParser {
 
     const lastChild = arrayLast(children);
 
-    if (lastChild.type !== 'Reference') {
+    if (lastChild.type !== ReferenceTag) {
       throw new Error();
     }