@bablr/boot 0.1.9 → 0.2.0

package/lib/languages/regex.js

@@ -1,10 +1,12 @@
 const when = require('iter-tools-es/methods/when');
-const { escapables } = require('./string.js');
+const { escapables } = require('./cstml.js');
 const { buildCovers } = require('../utils.js');
 const { node } = require('../symbols.js');
 
 const name = 'Regex';
 
+const canonicalURL = 'https://bablr.org/languages/core/bablr-regex-pattern';
+
 const dependencies = {};
 
 const covers = buildCovers({
@@ -19,14 +21,30 @@ const covers = buildCovers({
     'Character',
     'CharacterClass',
     'CharacterClassRange',
-    'CharacterSet',
+    'AnyCharacterSet',
+    'WordCharacterSet',
+    'SpaceCharacterSet',
+    'DigitCharacterSet',
     'Quantifier',
     'Punctuator',
     'Keyword',
     'Escape',
     'Number',
+    'Gap',
+  ],
+  Assertion: ['StartOfInputAssertion', 'EndOfInputAssertion', 'WordBoundaryAssertion'],
+  Element: [
+    'CharacterClass',
+    'Group',
+    'CapturingGroup',
+    'Assertion',
+    'CharacterSet',
+    'Gap',
+    'Character',
+    'Quantifier',
   ],
-  CharacterClassElement: ['CharacterClassRange', 'Character'],
+  CharacterClassElement: ['CharacterClassRange', 'CharacterSet', 'Character', 'Gap'],
+  CharacterSet: ['AnyCharacterSet', 'WordCharacterSet', 'SpaceCharacterSet', 'DigitCharacterSet'],
 });
 
 const flags = {
@@ -50,9 +68,9 @@ const getSpecialPattern = (span) => {
   if (type === 'Bare') {
     return /[*+{}\[\]()\.^$|\\\n\/]/y;
   } else if (type === 'CharacterClass') {
-    return /[\]\\\.]/y;
+    return /[\]\\]/y;
   } else if (type === 'CharacterClass:First') {
-    return /[\]^\\\.]/y;
+    return /[\]^\\]/y;
   } else if (type === 'Quantifier') {
     return /[{}]/;
   } else {
@@ -150,6 +168,8 @@ const grammar = class RegexMiniparserGrammar {
       p.eatProduction('Assertion');
     } else if (p.match(/\.|\\[dswp]/iy)) {
       p.eatProduction('CharacterSet');
+    } else if (p.match('\\g')) {
+      p.eatProduction('Gap');
     } else {
       p.eatProduction('Character');
     }
@@ -173,20 +193,37 @@ const grammar = class RegexMiniparserGrammar {
     p.eat(')', PN, { path: 'close', balancer: true });
   }
 
-  // @Node
   Assertion(p) {
-    let attrs = {};
-    if (p.eatMatch('^', PN, { path: 'value' })) {
-      attrs = { kind: 'start' };
-    } else if (p.eatMatch('$', KW, { path: 'value' })) {
-      attrs = { kind: 'end' };
+    if (p.match('^')) {
+      p.eatProduction('StartOfInputAssertion');
+    } else if (p.match('$')) {
+      p.eatProduction('EndOfInputAssertion');
+    } else if (p.match(/\\b/iy)) {
+      p.eatProduction('WordBoundaryAssertion');
+    }
+  }
+
+  // @CoveredBy('Assertion')
+  // @Node
+  StartOfInputAssertion(p) {
+    p.eat('^', KW, { path: 'value' });
+  }
+
+  // @CoveredBy('Assertion')
+  // @Node
+  EndOfInputAssertion(p) {
+    p.eat('$', KW, { path: 'value' });
+  }
+
+  // @CoveredBy('Assertion')
+  // @Node
+  WordBoundaryAssertion(p) {
+    let attrs;
+    if (p.eatMatch('\\', ESC, { path: 'escape' })) {
+      const m = p.eat(/b/iy, KW, { path: 'value' });
+      attrs = { negate: m === 'B' };
     } else {
-      if (p.eatMatch('\\', ESC, { path: 'escape' })) {
-        const m = p.eat(/b/iy, KW, { path: 'value' });
-        attrs = { kind: 'word', negate: m === 'B' };
-      } else {
-        throw new Error('invalid boundary');
-      }
+      throw new Error('invalid boundary');
     }
     return { attrs };
   }
@@ -236,13 +273,21 @@ const grammar = class RegexMiniparserGrammar {
   CharacterClassElement(p, { first }) {
     if (p.match(/.-[^\]\n]/y)) {
       p.eatProduction('CharacterClassRange', undefined, { first });
-    } else if (p.match(/\.|\\[dswp]/iy)) {
+    } else if (p.match(/\\[dswp]/iy)) {
       p.eatProduction('CharacterSet');
+    } else if (p.match('\\g')) {
+      p.eatProduction('Gap');
     } else {
       p.eatProduction('Character', when(first, { span: 'CharacterClass:First' }));
     }
   }
 
+  // @Node
+  Gap(p) {
+    p.eat('\\', PN, { path: 'escape' });
+    p.eat('g', KW, { path: 'value' });
+  }
+
   // @Node
   CharacterClassRange(p, { first }) {
     p.eatProduction('Character', {
@@ -253,32 +298,75 @@ const grammar = class RegexMiniparserGrammar {
     p.eatProduction('Character', { path: 'max' });
   }
 
-  // @Node
   CharacterSet(p) {
-    if (p.eatMatch('.', KW, { path: 'value' })) {
-      return { attrs: { kind: 'any' } };
+    let attrs;
+
+    if (p.match('.')) {
+      p.eatProduction('AnyCharacterSet');
+    } else if (p.match(/\\[dD]/y)) {
+      p.eatProduction('DigitCharacterSet');
+    } else if (p.match(/\\[sS]/y)) {
+      p.eatProduction('SpaceCharacterSet');
+    } else if (p.match(/\\[wW]/y)) {
+      p.eatProduction('WordCharacterSet');
+    } else if (p.match(/p/iy)) {
+      throw new Error('unicode property character sets are not supported yet');
+    } else {
+      throw new Error('unknown character set kind');
     }
 
+    return { attrs };
+  }
+
+  // @CoveredBy('CharacterSet')
+  // @Node
+  AnyCharacterSet(p) {
+    p.eat('.', KW, { path: 'value' });
+  }
+
+  // @CoveredBy('CharacterSet')
+  // @Node
+  WordCharacterSet(p) {
+    p.eat('\\', PN, { path: 'escape' });
+
+    let attrs;
+
+    if (p.eatMatch('w', KW, { path: 'value' })) {
+      //continue
+    } else if (p.eatMatch('W', KW, { path: 'value' })) {
+      attrs = { negate: true };
+    }
+
+    return { attrs };
+  }
+
+  // @CoveredBy('CharacterSet')
+  // @Node
+  SpaceCharacterSet(p) {
+    p.eat('\\', PN, { path: 'escape' });
+
+    let attrs;
+
+    if (p.eatMatch('s', KW, { path: 'value' })) {
+      //continue
+    } else if (p.eatMatch('S', KW, { path: 'value' })) {
+      attrs = { negate: true };
+    }
+
+    return { attrs };
+  }
+
+  // @CoveredBy('CharacterSet')
+  // @Node
+  DigitCharacterSet(p) {
     p.eat('\\', PN, { path: 'escape' });
 
     let attrs;
 
     if (p.eatMatch('d', KW, { path: 'value' })) {
-      attrs = { kind: 'digit' };
+      //continue
     } else if (p.eatMatch('D', KW, { path: 'value' })) {
-      attrs = { kind: 'digit', negate: true };
-    } else if (p.eatMatch('s', KW, { path: 'value' })) {
-      attrs = { kind: 'space' };
-    } else if (p.eatMatch('S', KW, { path: 'value' })) {
-      attrs = { kind: 'space', negate: true };
-    } else if (p.eatMatch('w', KW, { path: 'value' })) {
-      attrs = { kind: 'word' };
-    } else if (p.eatMatch('W', KW, { path: 'value' })) {
-      attrs = { kind: 'word', negate: true };
-    } else if (p.match(/p/iy)) {
-      throw new Error('unicode property character sets are not supported yet');
-    } else {
-      throw new Error('unknown character set kind');
+      attrs = { negate: true };
     }
 
     return { attrs };
@@ -319,4 +407,4 @@ const grammar = class RegexMiniparserGrammar {
   }
 };
 
-module.exports = { name, dependencies, covers, grammar, cookEscape };
+module.exports = { name, canonicalURL, dependencies, covers, grammar, cookEscape };

package/lib/languages/spamex.js

@@ -1,39 +1,34 @@
 const Regex = require('./regex.js');
-const StringLanguage = require('./string.js');
-const Number = require('./number.js');
+const CSTML = require('./cstml.js');
 const { buildCovers } = require('../utils.js');
 const sym = require('../symbols.js');
 
 const _ = /\s+/y;
 const PN = 'Punctuator';
-const KW = 'Keyword';
 const ID = 'Identifier';
 const LIT = 'Literal';
 
 const name = 'Spamex';
 
-const dependencies = { Regex, String: StringLanguage, Number };
+const canonicalURL = 'https://bablr.org/languages/core/spamex';
+
+const dependencies = { CSTML, Regex };
 
 const covers = buildCovers({
-  [sym.node]: ['Attribute', 'TagType', 'Matcher', 'Literal'],
+  [sym.node]: ['Attribute', 'Identifier', 'Matcher', 'Literal', 'CSTML:Flags'],
   Attribute: ['MappingAttribute', 'BooleanAttribute'],
-  AttributeValue: ['String:String', 'Number:Number'],
-  Matcher: ['NodeMatcher', 'TerminalMatcher', 'TriviaTerminalMatcher', 'StringMatcher'],
-  StringMatcher: ['String:String', 'Regex:Pattern'],
-  TagType: ['Identifier', 'GlobalIdentifier'],
+  AttributeValue: ['CSTML:String', 'CSTML:Number'],
+  Matcher: ['NodeMatcher', 'StringMatcher'],
+  StringMatcher: ['CSTML:String', 'Regex:Pattern'],
 });
 
 const grammar = class SpamexMiniparserGrammar {
   // @Cover
   Matcher(p) {
-    if (p.match('<| |>')) {
-      p.eatProduction('TriviaTerminalMatcher');
-    } else if (p.match(/<(?:\w|$)/y)) {
+    if (p.match(/<(?:[*#@+]*[ \t]*)?(?:\w|$)/y)) {
       p.eatProduction('NodeMatcher');
-    } else if (p.match('<|')) {
-      p.eatProduction('TerminalMatcher');
     } else if (p.match(/['"]/y)) {
-      p.eatProduction('String:String');
+      p.eatProduction('CSTML:String');
     } else if (p.match('/')) {
       p.eatProduction('Regex:Pattern');
     } else {
@@ -41,48 +36,40 @@ const grammar = class SpamexMiniparserGrammar {
     }
   }
 
-  // @Node
-  TriviaTerminalMatcher(p) {
-    p.eat('<|', PN, { path: 'open', startSpan: 'Tag', balanced: '|>' });
-    p.eat(' ', KW, { path: 'value' });
-    p.eat('|>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
-  }
-
   // @Node
   NodeMatcher(p) {
     p.eat('<', PN, { path: 'open', startSpan: 'Tag', balanced: '>' });
-    p.eatProduction('TagType', { path: 'type' });
 
-    let sp = p.eatMatchTrivia(_);
+    let tr = p.eatMatch('#', PN, { path: 'triviaFlag' });
+    let tok = p.eatMatch('*', PN, { path: 'tokenFlag' });
+    let esc = p.eatMatch('@', PN, { path: 'escapeFlag' });
+    let exp = p.eatMatch('+', PN, { path: 'expressionFlag' });
 
-    if ((sp && p.match(/\w+/y)) || p.atExpression) {
-      p.eatProduction('Attributes', { path: 'attributes[]' });
-      sp = p.eatMatchTrivia(_);
-    }
+    if ((tr && esc) || (exp && (tr || esc))) throw new Error();
 
-    p.eatMatchTrivia(_);
-    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
-  }
+    if (p.match(/\w+:/y)) {
+      p.eat(/\w+/y, ID, { path: 'language' });
+      p.eat(':', PN, { path: 'namespaceOperator' });
+      p.eat(/\w+/y, ID, { path: 'type' });
+    } else {
+      p.eat(/\w+/y, ID, { path: 'type' });
+    }
 
-  // @Node
-  TerminalMatcher(p) {
-    p.eat('<|', PN, { path: 'open', startSpan: 'Tag', balanced: '|>' });
-    p.eatMatchTrivia(_);
-    p.eatProduction('TagType', { path: 'type' });
     let sp = p.eatMatchTrivia(_);
 
-    if (sp && (p.match(/['"/]/y) || p.atExpression)) {
-      p.eatProduction('StringMatcher', { path: 'value' });
+    if (tok && sp && (p.match(/['"/]/y) || p.atExpression)) {
+      p.eatProduction('StringMatcher', { path: 'intrinsicValue' });
+
       sp = p.eatMatchTrivia(_);
     }
 
-    if (sp && (p.match(/\w+/y) || p.atExpression)) {
+    if ((sp && p.match(/\w+/y)) || p.atExpression) {
       p.eatProduction('Attributes', { path: 'attributes[]' });
       sp = p.eatMatchTrivia(_);
     }
 
     p.eatMatchTrivia(_);
-    p.eat('|>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+    p.eat('>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
   }
 
   Attributes(p) {
@@ -121,32 +108,16 @@ const grammar = class SpamexMiniparserGrammar {
   // @Cover
   AttributeValue(p) {
     if (p.match(/['"]/y)) {
-      p.eatProduction('String:String');
+      p.eatProduction('CSTML:String');
     } else if (p.match(/-|\d/y)) {
-      p.eatProduction('Number:Number');
-    }
-  }
-
-  // @Cover
-  TagType(p) {
-    if (p.match(/\w+:/y)) {
-      p.eatProduction('GlobalIdentifier');
-    } else {
-      p.eat(/\w+/y, ID, { path: 'type' });
+      p.eatProduction('CSTML:Number');
     }
   }
 
-  // @Node
-  GlobalIdentifier(p) {
-    p.eat(/\w+/y, ID, { path: 'language' });
-    p.eat(':', PN, { path: 'namespaceOperator' });
-    p.eat(/\w+/y, ID, { path: 'type' });
-  }
-
   // @Cover
   StringMatcher(p) {
     if (p.match(/['"]/y)) {
-      p.eatProduction('String:String');
+      p.eatProduction('CSTML:String');
     } else {
       p.eatProduction('Regex:Pattern');
     }
@@ -158,4 +129,4 @@ const grammar = class SpamexMiniparserGrammar {
   }
 };
 
-module.exports = { name, dependencies, covers, grammar };
+module.exports = { name, canonicalURL, dependencies, covers, grammar };

package/lib/miniparser.js

@@ -164,10 +164,10 @@ class TemplateParser {
           for (const { 0: key, 1: property } of Object.entries(result.properties)) {
             if (isArray(property)) {
               for (const value of property) {
-                set(properties, { pathName: key, pathIsArray: true }, value);
+                set(properties, { name: key, isArray: true }, value);
               }
             } else {
-              set(properties, { pathName: key, pathIsArray: false }, property);
+              set(properties, { name: key, isArray: false }, property);
             }
           }
         }
@@ -282,16 +282,16 @@ class TemplateParser {
       throw new Error();
     }
 
-    const { pathIsArray, pathName } = lastChild.value;
+    const { isArray, name } = lastChild.value;
 
-    this.held = pathIsArray ? arrayLast(properties[pathName]) : properties[pathName];
+    this.held = isArray ? arrayLast(properties[name]) : properties[name];
 
     children.pop();
 
-    if (pathIsArray) {
-      properties[pathName].pop();
+    if (isArray) {
+      properties[name].pop();
     } else {
-      properties[pathName] = null;
+      properties[name] = null;
     }
 
     return this.eval(this.buildId(id), attrs, props);
@@ -301,6 +301,8 @@ class TemplateParser {
     if (!isString(type)) throw new Error('Cannot eat anonymous token');
     if (!isObject(attrs) || !attrs.path) throw new Error('a node must have a path');
 
+    const { path, ..._attrs } = attrs;
+
     const result = this.matchSticky(pattern, attrs, this);
 
     if (!result) throw new Error('miniparser: parsing failed');
@@ -309,11 +311,11 @@ class TemplateParser {
 
     this.updateSpans(attrs);
 
-    const path = parsePath(attrs.path);
+    const path_ = parsePath(attrs.path);
 
-    set(this.node.properties, path, buildNode(this.buildId(type), [lit(result)]));
+    set(this.node.properties, path_, buildNode(this.buildId(type), [lit(result)], {}, _attrs));
 
-    this.node.children.push(ref(path));
+    this.node.children.push(ref(path_));
 
     return result;
   }

package/lib/path.js

@@ -13,11 +13,11 @@ const buildNode = (id) => {
 const stripPathBraces = (str) => (str.endsWith('[]') ? str.slice(0, -2) : str);
 
 const parsePath = (str) => {
-  const pathName = stripPathBraces(str);
+  const name = stripPathBraces(str);
 
-  if (!/^\w+$/.test(pathName)) throw new Error();
+  if (!/^\w+$/.test(name)) throw new Error();
 
-  return { pathIsArray: pathName !== str, pathName };
+  return { isArray: name !== str, name };
 };
 
 class Path {