@bablr/bablr-vm 0.20.1 → 0.22.0

package/lib/utils/pattern.js

@@ -1,9 +1,13 @@
 import isString from 'iter-tools-es/methods/is-string';
 import isEmpty from 'iter-tools-es/methods/is-empty';
 import { generateMatches } from '@bablr/regex-vm';
-import { getStreamIterator, maybeWait, printType } from '@bablr/agast-helpers/stream';
-import * as sumtree from '@bablr/agast-helpers/sumtree';
-import * as l from '@bablr/agast-vm-helpers/languages';
+import {
+  getStreamIterator,
+  maybeWait,
+  printType,
+  StreamIterable,
+} from '@bablr/agast-helpers/stream';
+import * as Tags from '@bablr/agast-helpers/tags';
 import {
   buildAlternative,
   buildAlternatives,
@@ -14,10 +18,41 @@ import {
 } from '@bablr/helpers/builders';
 import { buildEmbeddedRegex } from '@bablr/agast-vm-helpers/builders';
 import { GapTag, LiteralTag } from '@bablr/agast-helpers/symbols';
+import {
+  buildCloseNodeTag,
+  buildLiteralTag,
+  buildOpenNodeTag,
+  tokenFlags,
+} from '@bablr/agast-helpers/builders';
+import { streamIteratorSymbol } from '@bablr/stream-iterator';
+
+function* __wrapSource(source) {
+  let source_ = source.source || source;
+  if ('\r\n'.includes(source_.prevValue)) {
+    yield '\n';
+  } else if (source_.index === 0) {
+    yield Symbol.for('BOS');
+  } else {
+    yield '';
+  }
+  let iter = getStreamIterator(source);
 
-export const assertValidRegex = (expr) => {
-  const { flags } = expr;
+  let step = iter.next();
+  while (!step.done) {
+    yield step.value;
+    step = iter.next();
+  }
+
+  iter.return();
+
+  yield Symbol.for('EOS');
+}
 
+export const wrapSource = (source) => {
+  return new StreamIterable(__wrapSource(source));
+};
+
+export const assertValidRegex = (expr) => {
   if (!expr.language === 'Spamex' && expr.type === 'Regex') {
     throw new Error();
   }
@@ -28,7 +63,7 @@ export const assertValidRegex = (expr) => {
 const buildStringRegex = (str) => {
   return buildPattern(
     buildAlternatives([
-      buildAlternative(buildElements([...str].map((chr) => buildToken(l.Regex, 'Character', chr)))),
+      buildAlternative(buildElements([...str].map((chr) => buildToken('Character', chr)))),
     ]),
   );
 };
@@ -38,10 +73,10 @@ const buildFragmentRegex = (frag) => {
     buildAlternatives([
       buildAlternative(
         buildElements(
-          [...sumtree.traverse(frag.children)].flatMap((tag) => {
+          [...Tags.traverse(frag.tags)].flatMap((tag) => {
             if (tag.type === LiteralTag) {
               let str = tag.value;
-              return [...str].map((chr) => buildToken(l.Regex, 'Character', chr));
+              return [...str].map((chr) => buildToken('Character', chr));
             } else if (tag.type === GapTag) {
               return [buildRegexGap()];
             } else {
@@ -54,7 +89,64 @@ const buildFragmentRegex = (frag) => {
   );
 };
 
+const promiseCo = (gen) => {
+  return (...args) => {
+    let generator = gen(...args);
+
+    const fn = (step) => {
+      if (step.done) {
+        return step.value;
+      } else if (step.value instanceof Promise) {
+        return step.value.then((value) => {
+          return fn(generator.next(value));
+        });
+      }
+    };
+
+    return fn(generator.next());
+  };
+};
+
+function* __stringEqual(str, iterable) {
+  let strIter = str[Symbol.iterator]();
+  let iter = getStreamIterator(iterable);
+
+  let strStep = strIter.next();
+  let step = iter.next();
+
+  while (!strStep.done) {
+    if (step instanceof Promise) {
+      step = yield step;
+    }
+
+    if (step.value !== strStep.value) {
+      iter.return();
+      return false;
+    }
+
+    strStep = strIter.next();
+    step = iter.next();
+  }
+
+  iter.return();
+  return true;
+}
+
+const stringEqual = (str, iterable) => {
+  return promiseCo(__stringEqual)(str, iterable);
+};
+
 export const match = (pattern, source) => {
+  if (typeof pattern === 'string' && pattern.length === 1) {
+    return pattern === source.value
+      ? [buildOpenNodeTag(tokenFlags), buildLiteralTag(pattern), buildCloseNodeTag()]
+      : null;
+  } else if (typeof pattern === 'string') {
+    return stringEqual(pattern, source)
+      ? [buildOpenNodeTag(tokenFlags), buildLiteralTag(pattern), buildCloseNodeTag()]
+      : null;
+  }
+
   const pattern_ =
     pattern.type === null && pattern.flags.token
       ? buildFragmentRegex(pattern)
@@ -66,12 +158,13 @@ export const match = (pattern, source) => {
 
   assertValidRegex(pattern_);
 
-  const iter = getStreamIterator(generateMatches(buildEmbeddedRegex(pattern_), source));
+  const iter = getStreamIterator(generateMatches(buildEmbeddedRegex(pattern_), wrapSource(source)));
 
   const step = iter.next();
 
   return maybeWait(step, (step) => {
     const result = step.done ? null : step.value[0];
+    iter.return();
     return isEmpty(result) ? null : result;
   });
 };
@@ -79,35 +172,40 @@ export const match = (pattern, source) => {
 class GuardedIterator {
   constructor(pattern, source) {
     this.pattern = pattern;
-    this.fork = source.fork.clone();
+    this.source = source.branch();
     this.done = false;
   }
 
+  get value() {
+    return this.source.value;
+  }
+
   next() {
-    const { pattern, fork } = this;
+    const { pattern, source } = this;
 
-    const guardMatch = match(pattern, fork.clone());
+    const guardMatch = match(pattern, source);
 
     return maybeWait(guardMatch, (guardMatch) => {
-      if (guardMatch || fork.done) {
+      if (guardMatch || source.done) {
         this.done = true;
+        source.release();
         return { value: undefined, done: true };
       } else {
-        const { value } = fork;
-        return maybeWait(fork.advance(), (_) => ({ value, done: false }));
+        const { value } = source;
+        return maybeWait(source.advance(), (_) => ({ value, done: false }));
       }
     });
   }
 
   return() {
-    this.fork.return();
+    this.source.release();
   }
 
-  [Symbol.for('@@streamIterator')]() {
+  [streamIteratorSymbol]() {
     return this;
   }
 }
 
 export const guardWithPattern = (pattern, source) => {
-  return new GuardedIterator(pattern, source.branch());
+  return new GuardedIterator(pattern, source);
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/bablr-vm",
   "description": "A VM for parsing using BABLR languages",
-  "version": "0.20.1",
+  "version": "0.22.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,14 +12,14 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.7.1",
-    "@bablr/agast-vm": "0.8.1",
-    "@bablr/agast-vm-helpers": "0.7.1",
+    "@bablr/agast-helpers": "0.9.0",
+    "@bablr/agast-vm": "0.10.0",
+    "@bablr/agast-vm-helpers": "0.9.0",
     "@bablr/coroutine": "0.1.0",
-    "@bablr/helpers": "0.22.1",
-    "@bablr/regex-vm": "0.11.1",
-    "@bablr/weak-stack": "1.0.0",
-    "@iter-tools/imm-stack": "1.1.0",
+    "@bablr/helpers": "0.24.0",
+    "@bablr/regex-vm": "0.13.0",
+    "@bablr/weak-stack": "1.0.1",
+    "@iter-tools/imm-stack": "1.2.0",
     "iter-tools-es": "7.5.3"
   },
   "devDependencies": {

package/lib/utils/array.js

@@ -1,13 +0,0 @@
-export const isArray = Array;
-
-export const notEmpty = (arr) => arr != null && arr.length > 0;
-
-export const nullOr = (arr) => (arr.length === 0 ? null : arr);
-
-export function* arraySlice(arr, start, end) {
-  const increment = end > start ? 1 : -1;
-
-  for (let i = start; i < end; i += increment) {
-    yield arr[i];
-  }
-}

package/lib/utils/format.js

@@ -1,9 +0,0 @@
-export const formatType = (type) => {
-  return typeof type === 'symbol' ? `${type.description.replace(/^@bablr\//y, '')}` : `'${type}'`;
-};
-
-export const formatGraveString = (str) => {
-  return `\`${str
-    .replace(/`/g, '\\`')
-    .replace(/[\r\n\u{00}\u{08}\u{0B}\u{0C}\u{0E}-\u{1F}]/gu, '')}\``;
-};

package/lib/utils/object.js

@@ -1,97 +0,0 @@
-export const { hasOwn, freeze, isFrozen, seal, isSealed, getOwnPropertySymbols } = Object;
-export const { isArray } = Array;
-
-const intFrom = (str) => {
-  const value = parseInt(str, 10);
-  return isNaN(value) ? null : value;
-};
-
-export const has = (obj, property) => {
-  let value = obj;
-  for (const part of property.split('.')) {
-    if (!hasOwn(value, part)) return false;
-    value = value[part];
-  }
-  return true;
-};
-
-export const get = (obj, property) => {
-  let value = obj;
-  for (const part of property.split('.')) {
-    value = value[part];
-  }
-  return value;
-};
-
-export const set = (obj, property, value) => {
-  const parts = property.split('.');
-  let obj_ = obj;
-
-  let lastKey;
-  for (let i = 0; i < parts.length; i++) {
-    const intKey = intFrom(parts[i]);
-    const key = intKey !== null ? intKey : parts[i];
-    let value = obj_[key];
-
-    if (parts.length - 1 === i) {
-      lastKey = key;
-    } else if (value !== undefined) {
-      obj_ = value;
-    } else if (intFrom(parts[i + 1]) !== null) {
-      obj_ = value = obj_[key] = [];
-    } else {
-      throw new Error(`Unable to set {property: '${property}'} in obj`);
-    }
-  }
-
-  obj_[lastKey] = value;
-};
-
-export function objectKeys(obj) {
-  return {
-    *[Symbol.iterator]() {
-      for (let key in obj) if (hasOwn(obj, key)) yield key;
-      yield* getOwnPropertySymbols(obj);
-    },
-  };
-}
-
-export function objectValues(obj) {
-  return {
-    *[Symbol.iterator]() {
-      for (let key in obj) if (hasOwn(obj, key)) yield obj[key];
-      yield* getOwnPropertySymbols(obj).map((sym) => obj[sym]);
-    },
-  };
-}
-
-export function objectEntries(obj) {
-  return {
-    *[Symbol.iterator]() {
-      for (let key in obj) if (hasOwn(obj, key)) yield [key, obj[key]];
-      yield* getOwnPropertySymbols(obj).map((sym) => [sym, obj[sym]]);
-    },
-  };
-}
-
-export const isObject = (obj) => obj !== null && typeof obj === 'object';
-export const isFunction = (obj) => typeof obj === 'function';
-export const isSymbol = (obj) => typeof obj === 'symbol';
-export const isString = (obj) => typeof obj === 'string';
-export const isType = (obj) => isSymbol(obj) || isString(obj);
-export const isRegex = (obj) => obj instanceof RegExp;
-export const isPattern = (obj) => isString(obj) || isRegex(obj);
-
-export const memoize = (fn) => {
-  const cache = new WeakMap();
-  return (obj) => {
-    let result;
-    if (cache.has(obj)) {
-      result = cache.get(obj);
-    } else {
-      result = fn(obj);
-      cache.set(obj, result);
-    }
-    return result;
-  };
-};

package/lib/utils/pump.js

@@ -1,20 +0,0 @@
-export class Pump {
-  constructor() {
-    this.held = [];
-  }
-
-  queue(value) {
-    this.held.push(value);
-  }
-
-  next() {
-    const held = this.held[0];
-    if (!held) throw new Error();
-    this.held.shift();
-    return { done: false, value: held };
-  }
-
-  [Symbol.iterator]() {
-    return this;
-  }
-}

package/lib/utils/token.js

@@ -1,30 +0,0 @@
-import { buildLiteralTag, buildGapTag } from '@bablr/agast-helpers/builders';
-
-export const isNewlineToken = (token) => /^\r|\r\n|\n$/.test(token.value);
-
-export function* ownChildrenFor(range) {
-  throw new Error('unimplemented');
-}
-
-export function* allChildrenFor(range) {
-  throw new Error('unimplemented');
-}
-
-export function* buildTokens(chrs) {
-  let str = '';
-  for (const chr of chrs) {
-    if (chr == null) {
-      if (str) {
-        yield buildLiteralTag(str);
-        str = '';
-      }
-      yield buildGapTag();
-    } else {
-      str += chr;
-    }
-  }
-
-  if (str) {
-    yield buildLiteralTag(str);
-  }
-}