@bablr/boot 0.1.0

package/lib/languages/spamex.js

@@ -0,0 +1,150 @@
+const Regex = require('./regex.js');
+const StringLanguage = require('./string.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 };
+
+const covers = buildCovers({
+  [sym.node]: ['Attribute', 'TagType', 'Matcher', 'Literal'],
+  Attribute: ['StringAttribute', 'BooleanAttribute'],
+  Matcher: ['NodeMatcher', 'TerminalMatcher', 'TriviaTerminalMatcher', 'StringMatcher'],
+  StringMatcher: ['String:String', 'Regex:Pattern'],
+  TagType: ['Identifier', 'GlobalIdentifier'],
+});
+
+const grammar = class SpamexMiniparserGrammar {
+  // @Cover
+  Matcher(p) {
+    if (p.match('<| |>')) {
+      p.eatProduction('TriviaTerminalMatcher');
+    } else if (p.match(/<(?:\w|$)/y)) {
+      p.eatProduction('NodeMatcher');
+    } else if (p.match('<|')) {
+      p.eatProduction('TerminalMatcher');
+    } else if (p.match(/['"]/y)) {
+      p.eatProduction('String:String');
+    } else if (p.match('/')) {
+      p.eatProduction('Regex:Pattern');
+    } else {
+      throw new Error(`Unexpected character ${p.chr}`);
+    }
+  }
+
+  // @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(_);
+
+    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 });
+  }
+
+  // @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.eatProduction('StringMatcher', { path: 'value' });
+      sp = p.eatMatchTrivia(_);
+    }
+
+    if (sp && p.match(/\w+/y)) {
+      p.eatProduction('Attributes', { path: '[attributes]' });
+      sp = p.eatMatchTrivia(_);
+    }
+
+    p.eatMatchTrivia(_);
+    p.eat('|>', PN, { path: 'close', endSpan: 'Tag', balancer: true });
+  }
+
+  Attributes(p) {
+    let sp = true;
+    while (sp && (p.match(/\w+/y) || p.atExpression)) {
+      p.eatProduction('Attribute');
+      if (p.match(/\s+\w/y)) {
+        sp = p.eatMatchTrivia(_);
+      }
+    }
+  }
+
+  // @Cover
+  Attribute(p) {
+    if (p.match(/\w+\s*=/y)) {
+      p.eatProduction('StringAttribute');
+    } else {
+      p.eatProduction('BooleanAttribute');
+    }
+  }
+
+  // @Node
+  BooleanAttribute(p) {
+    p.eat(/\w+/y, LIT, { path: 'key' });
+  }
+
+  // @Node
+  StringAttribute(p) {
+    p.eat(/\w+/y, LIT, { path: 'key' });
+    p.eatMatchTrivia(_);
+    p.eat('=', PN, { path: 'mapOperator' });
+    p.eatMatchTrivia(_);
+    p.eatProduction('String:String', { path: 'value' });
+  }
+
+  // @Cover
+  TagType(p) {
+    if (p.match(/\w+:/y)) {
+      p.eatProduction('GlobalIdentifier');
+    } else {
+      p.eat(/\w+/y, ID, { path: 'type' });
+    }
+  }
+
+  // @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');
+    } else {
+      p.eatProduction('Regex:Pattern');
+    }
+  }
+
+  // @Node
+  Identifier(p) {
+    p.eatLiteral(/\w+/y);
+  }
+};
+
+module.exports = { name, dependencies, covers, grammar };

package/lib/languages/string.js

@@ -0,0 +1,92 @@
+const objectEntries = require('iter-tools-es/methods/object-entries');
+const { buildCovers } = require('../utils.js');
+const sym = require('../symbols.js');
+
+const name = 'String';
+
+const dependencies = {};
+
+const covers = buildCovers({
+  [sym.node]: ['String', 'Content'],
+});
+
+const PN = 'Punctuator';
+
+const escapables = new Map(
+  objectEntries({
+    n: '\n'.codePointAt(0),
+    r: '\r'.codePointAt(0),
+    t: '\t'.codePointAt(0),
+    0: '\0'.codePointAt(0),
+  }),
+);
+
+const cookEscape = (escape, span) => {
+  let hexMatch;
+
+  if (!span.type.startsWith('String')) {
+    throw new Error();
+  }
+
+  if (!escape.startsWith('\\')) {
+    throw new Error('string escape must start with \\');
+  }
+
+  if ((hexMatch = /\\x([0-9a-f]{2})/iy.exec(escape))) {
+    //continue
+  } else 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 parseInt(hexMatch[1], 16);
+  }
+
+  const litPattern = span === 'String:Single' ? /\\([\\nrt0'])/y : /\\([\\nrt0"])/y;
+  const litMatch = litPattern.exec(escape);
+
+  if (litMatch) {
+    return escapables.get(litMatch[1]);
+  }
+
+  throw new Error('unable to cook string escape');
+};
+
+const grammar = class StringMiniparserGrammar {
+  // @Node
+  String(p) {
+    const q = p.match(/['"]/y) || '"';
+
+    const span = q === '"' ? 'Double' : 'Single';
+
+    p.eat(q, PN, { path: 'open', startSpan: span, balanced: q });
+    while (p.match(/./sy) || p.atExpression) {
+      p.eatProduction('Content', { path: 'content' });
+    }
+    p.eat(q, PN, { path: 'close', endSpan: span, balancer: true });
+  }
+
+  // @Node
+  Content(p) {
+    let esc, lit;
+    let i = 0;
+    do {
+      esc =
+        p.span.type === 'Single'
+          ? p.eatMatchEscape(/\\(u(\{\d{1,6}\}|\d{4})|x[0-9a-fA-F]{2}|[\\nrt0'])/y)
+          : p.eatMatchEscape(/\\(u(\{\d{1,6}\}|\d{4})|x[0-9a-fA-F]{2}|[\\nrt0"])/y);
+      lit =
+        p.span.type === 'Single'
+          ? p.eatMatchLiteral(/[^\r\n\\']+/y)
+          : p.eatMatchLiteral(/[^\r\n\\"]+/y);
+      i++;
+    } while (esc || lit);
+    if (i === 1 && !esc && !lit) {
+      throw new Error('Invalid string content');
+    }
+  }
+};
+
+module.exports = { name, dependencies, covers, grammar, escapables, cookEscape };

package/lib/match.js

@@ -0,0 +1,84 @@
+const { Path, buildNode } = require('./path.js');
+const { resolveDependentLanguage } = require('./utils.js');
+const sym = require('./symbols.js');
+
+class Match {
+  constructor(parent, resolvedLanguage, id, attributes, path) {
+    this.parent = parent;
+    this.resolvedLanguage = resolvedLanguage;
+    this.id = id;
+    this.attributes = attributes;
+    this.path = path;
+
+    this.grammar =
+      parent?.resolvedLanguage === resolvedLanguage
+        ? parent.grammar
+        : new resolvedLanguage.grammar();
+  }
+
+  get isNode() {
+    const { type, resolvedLanguage } = this;
+    const { covers } = resolvedLanguage;
+
+    return covers.get(sym.node).has(type) && !covers.has(type);
+  }
+
+  get language() {
+    return this.id.language;
+  }
+
+  get type() {
+    return this.id.type;
+  }
+
+  get attrs() {
+    return this.attributes;
+  }
+
+  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 isFragment = covers.get(sym.fragment)?.has(type);
+
+    if (!isNode && !isFragment) {
+      throw new Error(`Top {type: ${type}} must be a node or fragment`);
+    }
+
+    const path = Path.from(id, attrs);
+
+    if (isFragment || (isNode && !isCover)) {
+      path.node = buildNode(id);
+    }
+
+    return new Match(null, resolvedLanguage, id, attrs, path);
+  }
+
+  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 baseAttrs = this.isNode ? {} : this.attrs;
+
+    let { path } = this;
+
+    if (isNode) {
+      if (!path.node) {
+        const relativeType = id.language === this.language ? id.type : `${id.language}:${id.type}`;
+        if (!this.resolvedLanguage.covers.get(path.type).has(relativeType)) throw new Error();
+      } else {
+        path = path.generate(id, attrs);
+      }
+      path.node = buildNode(id);
+    }
+
+    return new Match(this, resolvedLanguage, id, { ...baseAttrs, ...attrs }, path);
+  }
+}
+
+module.exports = { Match };