@bablr/boot 0.6.3 → 0.7.0

package/lib/languages/instruction.js

@@ -1,133 +1,68 @@
-const Spamex = require('./spamex.js');
-const CSTML = require('./cstml.js');
-const Regex = require('./regex.js');
-const { node } = require('@bablr/boot-helpers/symbols');
-const { buildCovers } = require('../utils.js');
+import * as sym from '@bablr/agast-helpers/symbols';
+import * as Spamex from './spamex.js';
+import * as CSTML from './cstml.js';
+import * as Regex from './regex.js';
+import * as BaseJSON from './json.js';
 
 const _ = /\s+/y;
 const PN = 'Punctuator';
 const ID = 'Identifier';
 const KW = 'Keyword';
-const LIT = 'Literal';
-
-const name = 'Instruction';
-
-const canonicalURL = 'https://bablr.org/languages/core/en/bablr-vm-instruction';
-
-const dependencies = { Spamex, CSTML, Regex };
-
-const covers = buildCovers({
-  [node]: ['Call', 'Punctuator', 'Property', 'Expression'],
-  Expression: [
-    'Object',
-    'Array',
-    'Tuple',
-    'Identifier',
-    'CSTML:String',
-    'CSTML:Gap',
-    'Regex:Pattern',
-    'Boolean',
-    'Null',
-    'Spamex:Matcher',
-    'Separator',
-  ],
-});
 
-const grammar = class InstructionMiniparserGrammar {
-  // @Node
-  Call(p) {
-    p.eat(/[a-zA-Z]+/y, ID, { path: 'verb' });
-    p.eatMatchTrivia(_);
-    p.eatProduction('Tuple', { path: 'arguments' });
-  }
+export const name = 'Instruction';
 
-  // @Cover
+export const canonicalURL = 'https://bablr.org/languages/core/en/bablr-vm-instruction';
+
+class JSONGrammar extends BaseJSON.grammar {
   Expression(p) {
-    if (p.match('[')) {
-      p.eatProduction('Array');
-    } else if (p.match('{')) {
-      p.eatProduction('Object');
-    } else if (p.match('(')) {
-      p.eatProduction('Tuple');
-    } else if (p.match(/['"]/y)) {
-      p.eatProduction('CSTML:String');
-    } else if (p.match('<//>')) {
-      p.eatProduction('CSTML:Gap');
-    } else if (p.match('/')) {
-      p.eatProduction('Regex:Pattern');
-    } else if (p.match(/true|false/y)) {
-      p.eatProduction('Boolean');
-    } else if (p.match('null')) {
-      p.eatProduction('Null');
-    } else if (p.match(/[a-zA-Z]/y)) {
-      p.eat(/[a-zA-Z]+/y, ID, p.m.attributes);
-    } else if (p.match('<')) {
-      p.eatProduction('Spamex:Matcher');
+    if (p.match(/(m|re|t)['"`]/y)) {
+      grammar.prototype.Expression.call(this, p);
+    } else {
+      super.Expression(p);
     }
   }
+}
 
-  // @Node
-  Object(p) {
-    p.eat('{', PN, { path: 'openToken', balanced: '}' });
-
-    p.eatMatchTrivia(_);
-
-    let first = true;
-    let sep;
-    while (first || (sep && (p.match(/./y) || p.atExpression))) {
-      p.eatProduction('Property', { path: 'properties[]' });
-      if (p.match(/\s*,?/y)) {
-        sep = p.eatProduction('Separator', { path: 'separators[]' });
-      }
-      first = false;
-    }
-
-    p.eatMatchTrivia(_);
-
-    p.eat('}', PN, { path: 'closeToken', balancer: true });
-  }
+const JSON = {
+  ...BaseJSON,
+  grammar: JSONGrammar,
+};
 
-  // @Node
-  Property(p) {
-    p.eat(/[a-zA-Z]+/y, LIT, { path: 'key' });
-    p.eatMatchTrivia(_);
-    p.eat(':', PN, { path: 'mapToken' });
-    p.eatMatchTrivia(_);
-    p.eatProduction('Expression', { path: 'value' });
-  }
+export const dependencies = { Spamex, CSTML, Regex, JSON };
+
+export const covers = new Map([
+  [sym.node, new Set(['Call', 'Punctuator'])],
+  [
+    'Expression',
+    new Set([
+      'Object',
+      'Array',
+      'Number',
+      'JSON:String',
+      'CSTML:GapTag',
+      'RegexString',
+      'SpamexString',
+      'CSTMLString',
+      'Boolean',
+      'Null',
+    ]),
+  ],
+]);
 
+export const grammar = class InstructionMiniparserGrammar {
   // @Node
-  Array(p) {
-    p.eat('[', PN, { path: 'openToken', balanced: ']' });
-
+  Call(p) {
+    p.eat(/[a-zA-Z]+/y, ID, { path: 'verb' });
     p.eatMatchTrivia(_);
 
-    let first = true;
-    let sep;
-    while (first || (sep && (p.match(/./y) || p.atExpression))) {
-      p.eatProduction('Expression', { path: 'elements[]' });
-      if (p.match(/\s*,?/y)) {
-        sep = p.eatProduction('Separator', { path: 'separators[]' });
-      }
-
-      first = false;
-    }
-
-    p.eat(']', PN, { path: 'closeToken', balancer: true });
-  }
-
-  // @Node
-  Tuple(p) {
     p.eat('(', PN, { path: 'openToken', balanced: ')' });
 
-    let sep;
+    let sep = p.eatMatchTrivia(_);
 
     let i = 0;
     while (i === 0 || (sep && (p.match(/./y) || p.atExpression))) {
       p.eatProduction('Expression', { path: 'values[]' });
-      if (p.match(/\s*,?/y)) {
-        sep = p.eatProduction('Separator', { path: 'separators[]' });
-      }
+      sep = p.eatMatchTrivia(_);
       i++;
     }
 
@@ -135,21 +70,51 @@ const grammar = class InstructionMiniparserGrammar {
   }
 
   // @Node
-  Boolean(p) {
-    p.eat(/true|false/y, KW, { path: 'sigilToken' });
+  SpamexString(p) {
+    p.eat('m', KW, { path: 'sigilToken' });
+    let quot = p.match(/['"`]/);
+    p.eat(quot, PN, { path: 'openToken', balanced: quot });
+    p.eatProduction('Spamex:Matcher', { path: 'content' });
+
+    p.eat(quot, PN, { path: 'closeToken', balancer: true });
   }
 
-  //@Node
-  Separator(p) {
-    p.eatMatchTrivia(_);
-    p.eatMatch(/,/y, PN, { path: 'separators[]' });
-    p.eatMatchTrivia(_);
+  // @Node
+  CSTMLString(p) {
+    p.eat('t', KW, { path: 'sigilToken' });
+    let quot = p.match(/['"`]/);
+    p.eat(quot, PN, { path: 'openToken', balanced: quot });
+    p.eatProduction('CSTML:Tag', { path: 'content' });
+
+    p.eat(quot, PN, { path: 'closeToken', balancer: true });
   }
 
   // @Node
-  Null(p) {
-    p.eat('null', KW, { path: 'sigilToken' });
+  RegexString(p) {
+    p.eat('re', KW, { path: 'sigilToken' });
+    let quot = p.match(/['"`]/);
+    p.eat(quot, PN, { path: 'openToken', balanced: quot });
+    p.eatProduction('Regex:Pattern', { path: 'content' });
+
+    p.eat(quot, PN, { path: 'closeToken', balancer: true });
   }
-};
 
-module.exports = { name, canonicalURL, dependencies, covers, grammar };
+  // @Cover
+  Expression(p) {
+    if (p.match('[')) {
+      p.eatProduction('JSON:Array');
+    } else if (p.match('{')) {
+      p.eatProduction('JSON:Object');
+    } else if (p.match(/['"]/y)) {
+      p.eatProduction('JSON:String');
+    } else if (p.match(/re['"`]/y)) {
+      p.eatProduction('RegexString');
+    } else if (p.match(/m['"`]/y)) {
+      p.eatProduction('SpamexString');
+    } else if (p.match(/true|false/y)) {
+      p.eatProduction('JSON:Boolean');
+    } else if (p.match('null')) {
+      p.eatProduction('JSON:Null');
+    }
+  }
+};

package/lib/languages/json.js

@@ -0,0 +1,241 @@
+import objectEntries from 'iter-tools/methods/object-entries';
+import * as sym from '@bablr/agast-helpers/symbols';
+import * as Spamex from './spamex.js';
+import * as CSTML from './cstml.js';
+import * as Regex from './regex.js';
+
+const _ = /\s+/y;
+const PN = 'Punctuator';
+const KW = 'Keyword';
+const ID = 'Identifier';
+
+export const name = 'JSON';
+
+export const canonicalURL = 'https://bablr.org/languages/core/en/cstml-json';
+
+export const dependencies = { Spamex, CSTML, Regex };
+
+export const covers = new Map([
+  [
+    sym.node,
+    new Set([
+      'Punctuator',
+      'Property',
+      'Object',
+      'Array',
+      'Boolean',
+      'Null',
+      'Number',
+      'UnsignedInteger',
+      'Infinity',
+      'NaN',
+      'Digit',
+      'Integer',
+      'String',
+      'StringContent',
+    ]),
+  ],
+  ['Expression', new Set(['Object', 'Array', 'Boolean', 'Null', 'Number', 'String'])],
+  ['Number', new Set(['Integer', 'Infinity', 'NaN'])],
+]);
+
+export const escapables = new Map(
+  objectEntries({
+    n: '\n',
+    r: '\r',
+    t: '\t',
+    0: '\0',
+  }),
+);
+
+export const cookEscape = (escape, span) => {
+  let hexMatch;
+
+  if (!escape.startsWith('\\')) {
+    throw new Error('string escape must start with \\');
+  }
+
+  if ((hexMatch = /\\u([0-9a-f]{4})/iy.exec(escape))) {
+    //continue
+  } else if ((hexMatch = /\\u{([0-9a-f]+)}/iy.exec(escape))) {
+    //continue
+  }
+
+  if (hexMatch) {
+    return String.fromCodePoint(parseInt(hexMatch[1], 16));
+  }
+
+  const litPattern = span === 'Single' ? /\\([\\gnrt0'])/y : /\\([\\gnrt0"])/y;
+  const litMatch = litPattern.exec(escape);
+
+  if (litMatch) {
+    if (litMatch[1] === 'g') {
+      return null;
+    } else {
+      return escapables.get(litMatch[1]) || litMatch[1];
+    }
+  }
+
+  throw new Error('unable to cook string escape');
+};
+
+export const grammar = class JSONMiniparserGrammar {
+  // @Cover
+  Expression(p) {
+    if (p.match('[')) {
+      p.eatProduction('Array');
+    } else if (p.match('{')) {
+      p.eatProduction('Object');
+    } else if (p.match(/true|false/y)) {
+      p.eatProduction('Boolean');
+    } else if (p.match('null')) {
+      p.eatProduction('Null');
+    } else if (p.match(/[+-]?(?:\d|Infinity)|NaN/y)) {
+      p.eatProduction('Number');
+    } else if (p.match(/['"]/y)) {
+      p.eatProduction('String');
+    }
+  }
+
+  // @Node
+  Object(p) {
+    p.eat('{', PN, { path: 'openToken', balanced: '}' });
+
+    p.eatMatchTrivia(_);
+
+    let first = true;
+    let sep;
+    while (first || (sep && (p.match(/./y) || p.atExpression))) {
+      p.eatProduction('Property', { path: 'properties[]' });
+      if (p.match(/\s*,?/y)) {
+        sep = p.eatProduction('ListSeparator', { path: 'separators[]' });
+      }
+      first = false;
+    }
+
+    p.eatMatchTrivia(_);
+
+    p.eat('}', PN, { path: 'closeToken', balancer: true });
+  }
+
+  // @Node
+  Property(p) {
+    p.eat(/[a-zA-Z]+/y, ID, { path: 'key' });
+    p.eatMatchTrivia(_);
+    p.eat(':', PN, { path: 'mapToken' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('Expression', { path: 'value' });
+  }
+
+  // @Node
+  Array(p) {
+    p.eat('[', PN, { path: 'openToken', balanced: ']' });
+
+    p.eatMatchTrivia(_);
+
+    let first = true;
+    let sep;
+    while (first || (sep && (p.match(/./y) || p.atExpression))) {
+      p.eatProduction('Expression', { path: 'elements[]' });
+      if (p.match(/\s*,?/y)) {
+        sep = p.eatProduction('ListSeparator', { path: 'separators[]' });
+      }
+
+      first = false;
+    }
+
+    p.eat(']', PN, { path: 'closeToken', balancer: true });
+  }
+
+  // @Node
+  Boolean(p) {
+    p.eat(/true|false/y, KW, { path: 'sigilToken' });
+  }
+
+  // @Node
+  Null(p) {
+    p.eat('null', KW, { path: 'sigilToken' });
+  }
+
+  ListSeparator(p) {
+    p.eatMatchTrivia(_);
+    p.eatMatch(/,/y, PN, { path: 'separators[]' });
+    p.eatMatchTrivia(_);
+  }
+
+  Number(p) {
+    if (p.match(/-?\d/y)) {
+      p.eatProduction('Integer');
+    } else if (p.match('NaN')) {
+      p.eatProduction('NaN');
+    } else {
+      p.eatProduction('Infinity');
+    }
+  }
+
+  // @Node
+  Integer(p) {
+    p.eatMatch('-', 'Punctuator', { path: 'negative' });
+    p.eatProduction('Digits', { path: 'digits[]' });
+  }
+
+  // @Node
+  UnsignedInteger(p) {
+    p.eatProduction('Digits', { path: 'digits[]' });
+  }
+
+  // @Node
+  Infinity(p) {
+    p.eatMatch(/[+-]/, 'Punctuator', { path: 'sign' });
+    p.eat('Infinity', 'Keyword', { path: 'sigilToken' });
+  }
+
+  // @Node
+  NaN(p) {
+    p.eat('NaN', 'Keyword', { path: 'sigilToken' });
+  }
+
+  Digits(p) {
+    while (p.match(/\d/y)) {
+      p.eatProduction('Digit');
+    }
+  }
+
+  // @Node
+  Digit(p) {
+    p.eatLiteral(/\d/y);
+  }
+
+  // @Node
+  String(p) {
+    const q = p.match(/['"]/y) || '"';
+
+    const span = q === '"' ? 'Double' : 'Single';
+
+    p.eat(q, PN, { path: 'openToken', startSpan: span, balanced: q });
+    while (p.match(/./sy) || p.atExpression) {
+      p.eatProduction('StringContent', { path: 'content' });
+    }
+    p.eat(q, PN, { path: 'closeToken', endSpan: span, balancer: true });
+  }
+
+  // @Node
+  StringContent(p) {
+    let esc, lit;
+    let i = 0;
+    do {
+      esc =
+        p.span.type === 'Single'
+          ? p.eatMatchEscape(/\\(u(\{\d{1,6}\}|\d{4})|[\\gnrt0'])/y)
+          : p.eatMatchEscape(/\\(u(\{\d{1,6}\}|\d{4})|[\\gnrt0"])/y);
+      lit =
+        p.span.type === 'Single'
+          ? p.eatMatchLiteral(/[^\r\n\0\\']+/y)
+          : p.eatMatchLiteral(/[^\r\n\0\\"]+/y);
+      i++;
+    } while (esc || lit);
+    if (i === 1 && !esc && !lit) {
+      throw new Error('Invalid string content');
+    }
+  }
+};

package/lib/languages/regex.js

@@ -1,51 +1,77 @@
-const when = require('iter-tools/methods/when');
-const { escapables } = require('./cstml.js');
-const { buildCovers } = require('../utils.js');
-const { node } = require('@bablr/boot-helpers/symbols');
-
-const name = 'Regex';
-
-const canonicalURL = 'https://bablr.org/languages/core/en/bablr-regex-pattern';
-
-const dependencies = {};
-
-const covers = buildCovers({
-  [node]: [
-    'RegExpLiteral',
-    'Flags',
-    'Pattern',
-    'Alternative',
-    'Group',
-    'CapturingGroup',
-    'Assertion',
-    'Character',
-    'CharacterClass',
-    'CharacterClassRange',
-    'AnyCharacterSet',
-    'WordCharacterSet',
-    'SpaceCharacterSet',
-    'DigitCharacterSet',
-    'Quantifier',
-    'Punctuator',
-    'Keyword',
-    'Escape',
-    'Number',
-    'Gap',
+import * as sym from '@bablr/agast-helpers/symbols';
+import when from 'iter-tools/methods/when';
+import { escapables } from './json.js';
+
+export const name = 'Regex';
+
+export const canonicalURL = 'https://bablr.org/languages/core/en/bablr-regex-pattern';
+
+export const dependencies = {};
+
+export const covers = new Map([
+  [
+    sym.node,
+    new Set([
+      'RegExpLiteral',
+      'Flags',
+      'Pattern',
+      'Alternative',
+      'Group',
+      'CapturingGroup',
+      'StartOfInputAssertion',
+      'EndOfInputAssertion',
+      'WordBoundaryAssertion',
+      'Character',
+      'CharacterClass',
+      'CharacterClassRange',
+      'AnyCharacterSet',
+      'WordCharacterSet',
+      'SpaceCharacterSet',
+      'DigitCharacterSet',
+      'Quantifier',
+      'Punctuator',
+      'Keyword',
+      'Escape',
+      'Number',
+      'Gap',
+    ]),
   ],
-  Assertion: ['StartOfInputAssertion', 'EndOfInputAssertion', 'WordBoundaryAssertion'],
-  Element: [
-    'CharacterClass',
-    'Group',
-    'CapturingGroup',
-    'Assertion',
+  ['Assertion', new Set(['StartOfInputAssertion', 'EndOfInputAssertion', 'WordBoundaryAssertion'])],
+  [
+    'Element',
+    new Set([
+      'CharacterClass',
+      'Group',
+      'CapturingGroup',
+      'StartOfInputAssertion',
+      'EndOfInputAssertion',
+      'WordBoundaryAssertion',
+      'AnyCharacterSet',
+      'WordCharacterSet',
+      'SpaceCharacterSet',
+      'DigitCharacterSet',
+      'Gap',
+      'Character',
+      'Quantifier',
+    ]),
+  ],
+  [
+    'CharacterClassElement',
+    new Set([
+      'CharacterClassRange',
+      'AnyCharacterSet',
+      'WordCharacterSet',
+      'SpaceCharacterSet',
+      'DigitCharacterSet',
+      'Character',
+      'Gap',
+    ]),
+  ],
+  [
     'CharacterSet',
-    'Gap',
-    'Character',
-    'Quantifier',
+    new Set(['AnyCharacterSet', 'WordCharacterSet', 'SpaceCharacterSet', 'DigitCharacterSet']),
   ],
-  CharacterClassElement: ['CharacterClassRange', 'CharacterSet', 'Character', 'Gap'],
-  CharacterSet: ['AnyCharacterSet', 'WordCharacterSet', 'SpaceCharacterSet', 'DigitCharacterSet'],
-});
+]);
 
 const flags = {
   global: 'g',
@@ -77,7 +103,7 @@ const getSpecialPattern = (span) => {
   }
 };
 
-const cookEscape = (escape, span) => {
+export const cookEscape = (escape, span) => {
   let hexMatch;
 
   if (!escape.startsWith('\\')) {
@@ -111,7 +137,7 @@ const cookEscape = (escape, span) => {
   throw new Error('unable to cook regex escape');
 };
 
-const grammar = class RegexMiniparserGrammar {
+export const grammar = class RegexMiniparserGrammar {
   // @Node
   Pattern(p) {
     p.eat('/', PN, { path: 'openToken', balanced: '/' });
@@ -145,12 +171,12 @@ const grammar = class RegexMiniparserGrammar {
   Alternatives(p) {
     do {
       p.eatProduction('Alternative');
-    } while (p.eatMatch('|', PN, { path: 'separators[]' }));
+    } while (p.eatMatch('|', PN, { path: 'separatorTokens[]' }));
   }
 
   // @Node
   Alternative(p) {
-    p.eatProduction('Elements', { path: 'elements[]' });
+    p.eatProduction('Elements', { path: 'elements[]+' });
   }
 
   Elements(p) {
@@ -383,7 +409,7 @@ const grammar = class RegexMiniparserGrammar {
 
   // @Node
   Quantifier(p) {
-    p.eatHeldProduction('Element', { path: 'element' });
+    p.eatHeldProduction('Element', { path: 'element+' });
 
     let attrs;
 
@@ -415,5 +441,3 @@ const grammar = class RegexMiniparserGrammar {
     return { attrs };
   }
 };
-
-module.exports = { name, canonicalURL, dependencies, covers, grammar, cookEscape };