@bablr/boot 0.1.0

package/lib/miniparser.js

@@ -0,0 +1,434 @@
+const { ref, lit, trivia, esc } = require('@bablr/boot-helpers/types');
+const escapeRegex = require('escape-string-regexp');
+const arrayLast = require('iter-tools-es/methods/array-last');
+const isString = require('iter-tools-es/methods/is-string');
+const isObject = require('iter-tools-es/methods/is-object');
+const sym = require('./symbols.js');
+const { Match } = require('./match.js');
+const { set, isRegex, isArray, parsePath, getPrototypeOf, buildNode } = require('./utils.js');
+
+class TemplateParser {
+  constructor(rootLanguage, quasis, expressions) {
+    this.rootLanguage = rootLanguage;
+    this.spans = [];
+    this.quasis = quasis;
+    this.expressions = expressions;
+    this.quasiIdx = 0;
+    this.expressionIdx = 0;
+    this.idx = 0;
+    this.type = null;
+    this.m = null;
+  }
+
+  get quasi() {
+    return this.quasis[this.quasiIdx];
+  }
+
+  get expression() {
+    return this.expressions[this.expressionIdx];
+  }
+
+  get expressionsDone() {
+    return this.expressionIdx >= this.expressions.length;
+  }
+
+  get atExpression() {
+    return !this.slicedQuasi.length && !this.expressionsDone;
+  }
+
+  get done() {
+    return !this.guardedSlicedQuasi.length && !this.atExpression;
+  }
+
+  get quasisDone() {
+    return this.quasiIdx >= this.quasis.length;
+  }
+
+  get path() {
+    return this.m?.path;
+  }
+
+  get node() {
+    return this.path.node;
+  }
+
+  get language() {
+    return this.m.resolvedLanguage;
+  }
+
+  get grammar() {
+    return this.m.grammar;
+  }
+
+  get matchIsNode() {
+    return this.language.covers.get(sym.node).has(this.m.type) && !this.matchIsCover;
+  }
+
+  get matchIsCover() {
+    return this.language.covers.has(this.m.type);
+  }
+
+  get matchIsFragment() {
+    return this.language.covers.get(sym.fragment)?.has(this.m.type);
+  }
+
+  get span() {
+    return arrayLast(this.spans);
+  }
+
+  get chr() {
+    return this.quasi[this.idx];
+  }
+
+  get slicedQuasi() {
+    const { idx, quasi } = this;
+    return quasi.slice(idx);
+  }
+
+  get guardedSlicedQuasi() {
+    const { span, slicedQuasi } = this;
+    const { guard } = span;
+
+    if (!guard) return slicedQuasi;
+
+    const pat = new RegExp(escapeRegex(guard), 'y');
+    const res = pat.exec(slicedQuasi);
+
+    return res ? slicedQuasi.slice(0, pat.lastIndex - res[0].length) : slicedQuasi;
+  }
+
+  matchSticky(pattern, attrs) {
+    const { slicedQuasi, guardedSlicedQuasi } = this;
+    const { balancer } = attrs;
+
+    const source = balancer ? slicedQuasi : guardedSlicedQuasi;
+
+    if (isString(pattern)) {
+      return source.startsWith(pattern) ? pattern : null;
+    } else if (isRegex(pattern)) {
+      if (!pattern.sticky) throw new Error('be sticky!');
+      pattern.lastIndex = 0;
+
+      const result = pattern.exec(source);
+
+      return result ? result[0] : null;
+    } else {
+      throw new Error(`Unknown pattern type`);
+    }
+  }
+
+  eval(id, attrs = {}, props = {}) {
+    const parentMatch = this.m;
+    const parentPath = this.path?.node ? this.path : this.path?.parent;
+    const { type } = id;
+
+    if (parentMatch && this.matchIsNode) {
+      if (this.matchIsCover && Object.keys(attrs).length) {
+        throw new Error('Attrs cannot be passed from inside covers');
+      }
+    }
+
+    if (parentMatch) {
+      this.m = parentMatch.generate(id, attrs);
+    } else {
+      this.m = Match.from(this.rootLanguage, id, attrs);
+    }
+
+    const { covers } = this.language;
+    const isNode = this.matchIsNode;
+    const isCover = this.matchIsCover;
+    const isFragment = this.matchIsFragment;
+    const isEmbedded = this.language !== this.m.parent?.resolvedLanguage;
+    const { path, grammar } = this;
+
+    if (!type) throw new Error('eval requires a type');
+
+    if (parentPath?.node && this.atExpression && (isNode || isCover || isFragment)) {
+      const { quasisDone } = this;
+
+      if (quasisDone) throw new Error('there must be more quasis than expressions');
+
+      const result = this.expression;
+
+      this.expressionIdx++;
+      this.quasiIdx++;
+      this.idx = 0;
+
+      if (parentPath?.node && isFragment) {
+        const { properties, children } = parentPath.node;
+
+        if (result) {
+          children.push(...result.children);
+
+          for (const { 0: key, 1: property } of Object.entries(result.properties)) {
+            if (isArray(property)) {
+              for (const value of property) {
+                set(properties, `[${key}]`, value);
+              }
+            } else {
+              set(properties, key, property);
+            }
+          }
+        }
+      } else if (parentPath?.node && (isNode || covers.has(type))) {
+        const { properties, children } = parentPath.node;
+        const { pathName } = parsePath(this.m.attrs.path);
+
+        children.push({ ...ref(pathName), id });
+
+        set(properties, this.m.attrs.path, result);
+      }
+    } else {
+      if (isEmbedded) {
+        this.spans.push({ type: 'Bare', guard: null });
+      }
+
+      const result = getPrototypeOf(grammar)[type].call(grammar, this, props);
+
+      if (isEmbedded) {
+        this.spans.pop();
+      }
+
+      if (isNode) {
+        const { node } = this.path;
+        if (result?.attrs) {
+          node.attributes = result.attrs;
+        }
+        if (parentPath?.node && !covers.has(type)) {
+          const { pathName } = parsePath(this.m.attrs.path);
+
+          parentPath.node.children.push(ref(pathName));
+
+          set(parentPath.node.properties, this.m.attrs.path, node);
+        }
+      }
+    }
+
+    this.m = this.m.parent;
+
+    if (this.path?.node) {
+      const isTerminal = (child) => ['Literal', 'Escape'].includes(child.type);
+
+      const { children } = this.path.node;
+
+      if (children.find(isTerminal) && !children.every(isTerminal)) {
+        throw new Error('strings must be wrapped in nodes');
+      }
+    }
+
+    return path.node;
+  }
+
+  updateSpans(attrs) {
+    const { startSpan, endSpan, balanced, balancer } = attrs;
+    if (endSpan || balancer) {
+      if (!this.span.guard) {
+        throw new Error('Only balanced spans can be closed with endSpan');
+      }
+      this.popSpan();
+    }
+    if (startSpan || balanced) {
+      const type = startSpan || this.span.type;
+      this.pushSpan({ type, guard: balanced });
+    }
+  }
+
+  buildId(id) {
+    let type;
+    let language = this.language.name;
+
+    if (id.includes(':')) {
+      ({ 0: language, 1: type } = id.split(':'));
+    } else {
+      type = id;
+    }
+
+    return { type, language };
+  }
+
+  eatProduction(id, attrs = {}, props = {}) {
+    return this.eval(this.buildId(id), attrs, props);
+  }
+
+  eatHeldProduction(type, attrs) {
+    const { children, properties } = this.node;
+
+    if (!this.held) {
+      throw new Error();
+    }
+
+    const { held } = this;
+
+    this.held = null;
+
+    children.push(ref(attrs.path));
+    set(properties, attrs.path, held);
+
+    return held;
+  }
+
+  shiftProduction(id, attrs = {}, props = {}) {
+    const { children, properties } = this.node;
+    // don't push a new path onto the stack
+
+    // get the most recently produced node and detach it from its parent
+
+    const lastChild = arrayLast(children);
+
+    if (lastChild.type !== 'Reference') {
+      throw new Error();
+    }
+
+    const path = lastChild.value;
+    const pathIsArray = isArray(properties[path]);
+
+    this.held = pathIsArray ? arrayLast(properties[path]) : properties[path];
+
+    children.pop();
+
+    if (pathIsArray) {
+      properties[path].pop();
+    } else {
+      properties[path] = null;
+    }
+
+    return this.eval(this.buildId(id), attrs, props);
+  }
+
+  eat(pattern, type, attrs) {
+    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 result = this.matchSticky(pattern, attrs, this);
+
+    if (!result) throw new Error('miniparser: parsing failed');
+
+    this.idx += result.length;
+
+    this.updateSpans(attrs);
+
+    set(this.node.properties, attrs.path, buildNode(this.buildId(type), [lit(result)]));
+
+    this.node.children.push(ref(parsePath(attrs.path).pathName));
+
+    return result;
+  }
+
+  // matchLiteral would be a better name
+  match(pattern, attrs = {}) {
+    return this.matchSticky(pattern, attrs, this);
+  }
+
+  eatMatch(pattern, type, attrs) {
+    if (!isString(type)) throw new Error('Cannot eatMatch anonymous token');
+    if (!isObject(attrs) || !attrs.path) throw new Error('a node must have a path');
+
+    let result;
+    if (this.atExpression) {
+    } else {
+    }
+
+    result = this.matchSticky(pattern, attrs, this);
+
+    if (result) {
+      this.updateSpans(attrs);
+
+      this.idx += result.length;
+
+      set(this.node.properties, attrs.path, buildNode(this.buildId(type), [lit(result)]));
+
+      this.node.children.push(ref(parsePath(attrs.path).pathName));
+    }
+    return result;
+  }
+
+  eatTrivia(pattern) {
+    const result = this.matchSticky(pattern, {}, this);
+
+    if (!result) throw new Error('miniparser: parsing failed');
+
+    this.idx += result.length;
+
+    this.node.children.push(trivia(result));
+
+    return result;
+  }
+
+  eatMatchTrivia(pattern) {
+    const result = this.matchSticky(pattern, {}, this);
+
+    if (result) {
+      this.idx += result.length;
+
+      this.node.children.push(trivia(result));
+    }
+
+    return result;
+  }
+
+  eatEscape(pattern) {
+    const result = this.matchSticky(pattern, {}, this);
+
+    if (!result) throw new Error('miniparser: parsing failed');
+
+    this.idx += result.length;
+
+    this.node.children.push(esc(result, this.language.cookEscape(result, this.span)));
+
+    return result;
+  }
+
+  eatMatchEscape(pattern) {
+    const result = this.matchSticky(pattern, {}, this);
+
+    if (result) {
+      this.idx += result.length;
+
+      this.node.children.push(esc(result, this.language.cookEscape(result, this.span)));
+    }
+
+    return result;
+  }
+
+  eatLiteral(pattern) {
+    const result = this.matchSticky(pattern, {}, this);
+
+    if (!result) throw new Error('miniparser: parsing failed');
+
+    this.idx += result.length;
+
+    this.node.children.push(lit(result));
+
+    return result;
+  }
+
+  eatMatchLiteral(pattern) {
+    const result = this.matchSticky(pattern, {}, this);
+
+    if (result) {
+      this.idx += result.length;
+
+      this.node.children.push(lit(result));
+    }
+
+    return result;
+  }
+
+  pushSpan(span) {
+    this.spans.push(span);
+  }
+
+  popSpan() {
+    if (!this.spans.length) {
+      throw new Error('no span to pop');
+    }
+    this.spans.pop();
+  }
+
+  replaceSpan(span) {
+    this.spans.pop();
+    this.spans.push(span);
+  }
+}
+
+module.exports = { TemplateParser };

package/lib/path.js

@@ -0,0 +1,47 @@
+const buildNode = (id) => {
+  const { language, type } = id;
+
+  return {
+    language,
+    type,
+    attributes: {},
+    children: [],
+    properties: {},
+  };
+};
+
+class Path {
+  constructor(id, attributes, parent = null) {
+    this.id = id;
+    this.attributes = attributes;
+    this.parent = parent;
+
+    this.node = null;
+  }
+
+  get parentProperty() {
+    return this.attributes.path;
+  }
+
+  get attrs() {
+    return this.attributes;
+  }
+
+  get language() {
+    return this.id.language;
+  }
+
+  get type() {
+    return this.id.type;
+  }
+
+  generate(id, attrs) {
+    return new Path(id, attrs, this);
+  }
+
+  static from(id, attrs = {}) {
+    return new Path(id, attrs);
+  }
+}
+
+module.exports = { Path, buildNode };

package/lib/symbols.js

@@ -0,0 +1,4 @@
+const node = Symbol.for('@bablr/node');
+const fragment = Symbol.for('@bablr/fragment');
+
+module.exports = { node, fragment };

package/lib/utils.js

@@ -0,0 +1,119 @@
+const every = require('iter-tools-es/methods/every');
+const isArray = require('iter-tools-es/methods/is-array');
+const isString = require('iter-tools-es/methods/is-string');
+const { parsePath, stripPathBraces } = require('@bablr/boot-helpers/path');
+
+const { hasOwn, getPrototypeOf, getOwnPropertySymbols } = Object;
+const isSymbol = (value) => typeof value === 'symbol';
+const isType = (value) => isString(value) || isSymbol(value);
+const isRegex = (val) => val instanceof RegExp;
+
+const objectEntries = (obj) => {
+  return {
+    *[Symbol.iterator]() {
+      for (let key in obj) if (hasOwn(obj, key)) yield [key, obj[key]];
+      const symTypes = getOwnPropertySymbols(obj);
+      for (const type of symTypes) {
+        yield [type, obj[type]];
+      }
+    },
+  };
+};
+
+const explodeSubtypes = (aliases, exploded, types) => {
+  for (const type of types) {
+    const explodedTypes = aliases.get(type);
+    if (explodedTypes) {
+      for (const explodedType of explodedTypes) {
+        exploded.add(explodedType);
+        const subtypes = aliases.get(explodedType);
+        if (subtypes) {
+          explodeSubtypes(aliases, exploded, subtypes);
+        }
+      }
+    }
+  }
+};
+
+const buildCovers = (rawAliases) => {
+  const aliases = new Map();
+
+  for (const alias of objectEntries(rawAliases)) {
+    if (!isType(alias[0])) throw new Error('alias[0] key must be a string or symbol');
+    if (!isArray(alias[1])) throw new Error('alias[1] must be an array');
+    if (!every(isType, alias[1])) throw new Error('alias[1] values must be strings or symbols');
+
+    aliases.set(alias[0], new Set(alias[1]));
+  }
+
+  for (const [type, types] of aliases.entries()) {
+    explodeSubtypes(aliases, aliases.get(type), types);
+  }
+
+  return new Map(aliases);
+};
+
+const set = (obj, path, value) => {
+  const { pathIsArray, pathName } = parsePath(path);
+
+  if (pathIsArray) {
+    if (!obj[pathName]) {
+      obj[pathName] = [];
+    }
+
+    if (!isArray(obj[pathName])) throw new Error('bad array value');
+
+    obj[pathName].push(value);
+  } else {
+    if (hasOwn(obj, pathName)) {
+      throw new Error('duplicate child name');
+    }
+    obj[pathName] = value;
+  }
+};
+
+const resolveDependentLanguage = (language, name) => {
+  if (name === undefined) {
+    return language;
+  }
+
+  const resolved = name === language.name ? language : language.dependencies[name];
+
+  if (!resolved) {
+    throw new Error(`Cannot resolve {name: ${name}} from {name: ${language.name}}`);
+  }
+
+  return resolved;
+};
+
+const buildNode = (id, children, properties = {}, attributes = {}) => {
+  const { language, type } = id;
+  return { language, type, children, properties, attributes, gap: undefined };
+};
+
+const buildId = (value) => {
+  if (isString(value)) {
+    const { 0: language, 1: type } = value.split(':');
+    return type ? { language, type } : { language: undefined, type: language };
+  } else {
+    return value;
+  }
+};
+
+const id = (...args) => {
+  return buildId(String.raw(...args));
+};
+
+module.exports = {
+  parsePath,
+  stripPathBraces,
+  buildCovers,
+  set,
+  resolveDependentLanguage,
+  isArray,
+  isRegex,
+  getPrototypeOf,
+  buildNode,
+  buildId,
+  id,
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@bablr/boot",
+  "version": "0.1.0",
+  "description": "Compile-time tools for bootstrapping BABLR VM",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "exports": {
+    ".": "./lib/index.js",
+    "./shorthand.macro": "./shorthand.macro.js"
+  },
+  "files": [
+    "lib/**/*.js"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@babel/helper-module-imports": "^7.22.15",
+    "@babel/template": "^7.22.15",
+    "@babel/types": "7.23.0",
+    "@bablr/boot-helpers": "github:bablr-lang/boot-helpers#1551598bc7257481089d06839eeec2e26885bbb2",
+    "escape-string-regexp": "4.0.0",
+    "iter-tools-es": "^7.5.3"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.23.0",
+    "@babel/core": "^7.23.0",
+    "@babel/plugin-proposal-decorators": "^7.23.2",
+    "@babel/plugin-transform-runtime": "^7.23.2",
+    "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#a49dbe6861a82d96864ee89fbf0ec1844a8a5e8e",
+    "@bablr/helpers": "github:bablr-lang/helpers#8ef702024395635c9a05fe4c9f803a48f87d902c",
+    "babel-plugin-macros": "^3.1.0",
+    "enhanced-resolve": "^5.12.0",
+    "eslint": "^8.47.0",
+    "eslint-import-resolver-enhanced-resolve": "^1.0.5",
+    "eslint-plugin-import": "^2.27.5",
+    "expect": "^29.6.2",
+    "prettier": "^2.0.5"
+  },
+  "repository": "git@github.com:bablr-lang/boot.git",
+  "homepage": "https://github.com/bablr-lang/boot",
+  "author": "Conrad Buck <conartist6@gmail.com>",
+  "license": "MIT"
+}