@bablr/agast-helpers 0.5.2 → 0.6.0

package/lib/stream.js

@@ -1,7 +1,7 @@
 import { Coroutine } from '@bablr/coroutine';
 import emptyStack from '@iter-tools/imm-stack';
 import { printSelfClosingNodeTag, printTag } from './print.js';
-import { buildWriteEffect, buildTokenGroup } from './builders.js';
+import { buildTokenGroup, buildWriteEffect } from './builders.js';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -10,18 +10,16 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayTag,
+  ArrayInitializerTag,
   LiteralTag,
-  EmbeddedExpression,
+  EmbeddedObject,
   TokenGroup,
-  OpenFragmentTag,
-  CloseFragmentTag,
 } from './symbols.js';
 
 export * from './print.js';
 
-const getEmbeddedExpression = (obj) => {
-  if (obj.type !== EmbeddedExpression) throw new Error();
+const getEmbeddedObject = (obj) => {
+  if (obj.type !== EmbeddedObject) throw new Error();
   return obj.value;
 };
 
@@ -171,23 +169,24 @@ function* __isEmpty(tags) {
     if (co.done) break;
 
     let depth = 0;
+    let ref = null;
 
     const tag = co.value;
 
     switch (tag.type) {
-      case OpenFragmentTag:
+      case ReferenceTag:
+        ref = tag;
+        break;
+
       case OpenNodeTag:
-        if (tag.value.flags.trivia) {
-          ++depth;
-        }
+        ++depth;
 
-        if (depth === 0 && tag.value.flags.escape) {
+        if (depth === 0 && ref.value.name === '@') {
           return false;
         }
 
         break;
 
-      case CloseFragmentTag:
       case CloseNodeTag:
         --depth;
         break;
@@ -220,7 +219,7 @@ function* __generateStandardOutput(tags) {
     if (tag.type === 'Effect') {
       const effect = tag.value;
       if (effect.verb === 'write') {
-        const writeEffect = getEmbeddedExpression(effect.value);
+        const writeEffect = getEmbeddedObject(effect.value);
         if (writeEffect.stream == null || writeEffect.stream === 1) {
           yield* writeEffect.text;
         }
@@ -249,10 +248,14 @@ function* __generateAllOutput(tags) {
     if (tag.type === 'Effect') {
       const effect = tag.value;
       if (effect.verb === 'write') {
-        const writeEffect = getEmbeddedExpression(effect.value);
+        const writeEffect = getEmbeddedObject(effect.value);
         const prevStream = currentStream;
-        currentStream = getEmbeddedExpression(writeEffect.options).stream || 1;
-        if (prevStream && prevStream !== currentStream && !writeEffect.text.startsWith('\n')) {
+        currentStream = getEmbeddedObject(writeEffect.options).stream || 1;
+        if (
+          prevStream &&
+          (prevStream !== currentStream || currentStream === 2) &&
+          !writeEffect.text.startsWith('\n')
+        ) {
           yield* '\n';
         }
         yield* writeEffect.text;
@@ -264,7 +267,7 @@ function* __generateAllOutput(tags) {
 export const generateAllOutput = (tags) => new StreamIterable(__generateAllOutput(tags));
 
 export const printCSTML = (tags) => {
-  return stringFromStream(generateStandardOutput(generateCSTMLStrategy(tags)));
+  return stringFromStream(generateStandardOutput(generateCSTML(tags)));
 };
 
 function* __emptyStreamIterator() {}
@@ -309,17 +312,15 @@ export const stringFromStream = (stream) => {
   return str;
 };
 
-function* __generateCSTMLStrategy(tags, options) {
-  let { emitEffects = false, inline: inlineOption = true } = options;
-
+function* __generateCSTML(tags, options) {
   if (!tags) {
-    yield buildWriteEffect('<//>');
+    yield* '<//>';
     return;
   }
 
   let prevTag = null;
 
-  const co = new Coroutine(getStreamIterator(prettyGroupTokens(tags)));
+  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
 
   for (;;) {
     co.advance();
@@ -332,45 +333,43 @@ function* __generateCSTMLStrategy(tags, options) {
     const tag = co.value;
 
     if (tag.type === ReferenceTag && prevTag.type === NullTag) {
-      yield buildWriteEffect(' ');
+      yield* ' ';
     }
 
     if (tag.type === 'Effect') {
-      const effect = tag.value;
-      if (emitEffects && effect.verb === 'write') {
-        yield buildWriteEffect(effect.value.text, effect.value.options);
-      }
       continue;
     }
 
     if (tag.type === TokenGroup) {
       const intrinsicValue = getCooked(tag.value);
-      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
+      yield* printSelfClosingNodeTag(tag.value[0], intrinsicValue);
     } else {
-      yield buildWriteEffect(printTag(tag));
+      yield* printTag(tag);
     }
 
     prevTag = tag;
   }
 
-  yield buildWriteEffect('\n');
+  yield* '\n';
 }
 
-export const generateCSTMLStrategy = (tags, options = {}) =>
-  new StreamIterable(__generateCSTMLStrategy(tags, options));
+export const generateCSTML = (tags, options = {}) =>
+  new StreamIterable(__generateCSTML(tags, options));
 
 const isToken = (tag) => {
   return tag.value.flags.token;
 };
 
-export const prettyGroupTokens = (tags) => new StreamIterable(__prettyGroupTokens(tags));
+export const prettyGroupTags = (tags) => new StreamIterable(__prettyGroupTags(tags));
 
-function* __prettyGroupTokens(tags) {
+function* __prettyGroupTags(tags) {
   let states = emptyStack.push({ holding: [], broken: false, open: null });
   let state = states.value;
 
   const co = new Coroutine(getStreamIterator(tags));
 
+  let ref = null;
+
   for (;;) {
     co.advance();
 
@@ -381,18 +380,18 @@ function* __prettyGroupTokens(tags) {
     }
 
     const tag = co.value;
-    const isOpenClose =
-      tag.type === CloseNodeTag ||
-      tag.type === OpenNodeTag ||
-      tag.type === CloseFragmentTag ||
-      tag.type === OpenFragmentTag;
+    const isOpenClose = tag.type === CloseNodeTag || tag.type === OpenNodeTag;
+
+    if (tag.type === ReferenceTag) {
+      ref = tag;
+    }
 
     if (
       (tag.type === 'Effect' && tag.value.verb === 'write') ||
-      [ReferenceTag, DoctypeTag, GapTag, NullTag, ArrayTag, ShiftTag, OpenFragmentTag].includes(
+      [ReferenceTag, DoctypeTag, GapTag, NullTag, ArrayInitializerTag, ShiftTag].includes(
         tag.type,
       ) ||
-      (tag.type === OpenNodeTag && tag.value.flags.escape)
+      (tag.type === OpenNodeTag && (!tag.value.type || ref?.value.name === '@'))
     ) {
       state.broken = true;
 
@@ -408,7 +407,7 @@ function* __prettyGroupTokens(tags) {
       yield tag;
     }
 
-    if (tag.type === CloseNodeTag || tag.type === CloseFragmentTag) {
+    if (tag.type === CloseNodeTag) {
       if (!state.broken && (isToken(state.open) || state.holding.length === 1)) {
         state.holding.push(tag);
         yield buildTokenGroup(state.holding);
@@ -423,8 +422,8 @@ function* __prettyGroupTokens(tags) {
       state = states.value;
     }
 
-    if (tag.type === OpenNodeTag || tag.type === OpenFragmentTag) {
-      if (tag.type === OpenFragmentTag) {
+    if (tag.type === OpenNodeTag) {
+      if (!tag.value.type) {
         states = states.push({ holding: [], broken: false, open: tag });
         yield tag;
       } else {
@@ -436,7 +435,138 @@ function* __prettyGroupTokens(tags) {
   }
 }
 
-function* __generatePrettyCSTMLStrategy(tags, options) {
+function* __generatePrettyCSTML(tags, options) {
+  let { indent = '  ', inline: inlineOption = true } = options;
+
+  if (!tags) {
+    yield* '<//>';
+    return;
+  }
+
+  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
+  let indentLevel = 0;
+  let first = true;
+  let inline = false;
+  let ref = null;
+
+  for (;;) {
+    co.advance();
+
+    if (co.done) break;
+
+    if (co.current instanceof Promise) {
+      co.current = yield co.current;
+    }
+
+    const tag = co.value;
+
+    if (tag.type === 'Effect') {
+      continue;
+    }
+
+    inline =
+      inlineOption &&
+      inline &&
+      ref &&
+      (tag.type === NullTag ||
+        tag.type === GapTag ||
+        tag.type === ArrayInitializerTag ||
+        tag.type === TokenGroup);
+
+    if (!first && !inline) {
+      yield* '\n';
+    }
+
+    if (tag.type === CloseNodeTag) {
+      ref = null;
+
+      indentLevel--;
+    }
+
+    if (!inline) {
+      yield* indent.repeat(indentLevel);
+    } else {
+      yield* ' ';
+    }
+
+    if (tag.type === TokenGroup) {
+      ref = null;
+      const intrinsicValue = tag.value[0].value.flags.token ? getCooked(tag.value) : null;
+      yield* printSelfClosingNodeTag(tag.value[0], intrinsicValue);
+    } else {
+      yield* printTag(tag);
+    }
+
+    if (tag.type === ReferenceTag) {
+      inline = true;
+      ref = tag;
+    }
+
+    if (tag.type === OpenNodeTag) {
+      indentLevel++;
+    }
+
+    first = false;
+  }
+
+  if (indentLevel !== 0) {
+    throw new Error('imbalanced tags');
+  }
+
+  yield* '\n';
+}
+
+export const generatePrettyCSTML = (tags, options = {}) => {
+  return new StreamIterable(__generatePrettyCSTML(tags, options));
+};
+
+function* __writeCSTMLStrategy(tags) {
+  if (!tags) {
+    yield buildWriteEffect('<//>');
+    return;
+  }
+
+  let prevTag = null;
+
+  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
+
+  for (;;) {
+    co.advance();
+
+    if (co.current instanceof Promise) {
+      co.current = yield co.current;
+    }
+    if (co.done) break;
+
+    const tag = co.value;
+
+    if (tag.type === ReferenceTag && prevTag.type === NullTag) {
+      yield buildWriteEffect(' ');
+    }
+
+    if (tag.type === 'Effect') {
+      yield tag;
+
+      continue;
+    }
+
+    if (tag.type === TokenGroup) {
+      const intrinsicValue = getCooked(tag.value);
+      yield buildWriteEffect(printSelfClosingNodeTag(tag.value[0], intrinsicValue));
+    } else {
+      yield buildWriteEffect(printTag(tag));
+    }
+
+    prevTag = tag;
+  }
+
+  yield buildWriteEffect('\n');
+}
+
+export const writeCSTMLStrategy = (tags, options = {}) =>
+  new StreamIterable(__writeCSTMLStrategy(tags, options));
+
+function* __writePrettyCSTMLStrategy(tags, options) {
   let { indent = '  ', emitEffects = false, inline: inlineOption = true } = options;
 
   if (!tags) {
@@ -444,7 +574,7 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
     return;
   }
 
-  const co = new Coroutine(getStreamIterator(prettyGroupTokens(tags)));
+  const co = new Coroutine(getStreamIterator(prettyGroupTags(tags)));
   let indentLevel = 0;
   let first = true;
   let inline = false;
@@ -464,14 +594,16 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
     if (tag.type === 'Effect') {
       const effect = tag.value;
       if (emitEffects && effect.verb === 'write') {
-        const writeEffect = getEmbeddedExpression(effect.value);
+        const writeEffect = getEmbeddedObject(effect.value);
         yield buildWriteEffect(
           (first ? '' : '\n') + writeEffect.text,
-          getEmbeddedExpression(writeEffect.options),
+          getEmbeddedObject(writeEffect.options),
         );
 
         inline = false;
         first = false;
+      } else {
+        yield tag;
       }
       continue;
     }
@@ -482,14 +614,14 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
       ref &&
       (tag.type === NullTag ||
         tag.type === GapTag ||
-        tag.type === ArrayTag ||
+        tag.type === ArrayInitializerTag ||
         tag.type === TokenGroup);
 
     if (!first && !inline) {
       yield buildWriteEffect('\n');
     }
 
-    if (tag.type === CloseNodeTag || tag.type === CloseFragmentTag) {
+    if (tag.type === CloseNodeTag) {
       ref = null;
       if (indentLevel === 0) {
         throw new Error('imbalanced tag stack');
@@ -517,7 +649,7 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
       ref = tag;
     }
 
-    if (tag.type === OpenNodeTag || tag.type === OpenFragmentTag) {
+    if (tag.type === OpenNodeTag) {
       indentLevel++;
     }
 
@@ -527,12 +659,12 @@ function* __generatePrettyCSTMLStrategy(tags, options) {
   yield buildWriteEffect('\n');
 }
 
-export const generatePrettyCSTMLStrategy = (tags, options = {}) => {
-  return new StreamIterable(__generatePrettyCSTMLStrategy(tags, options));
+export const writePrettyCSTMLStrategy = (tags, options = {}) => {
+  return new StreamIterable(__writePrettyCSTMLStrategy(tags, options));
 };
 
 export const printPrettyCSTML = (tags, options = {}) => {
-  return stringFromStream(generateStandardOutput(generatePrettyCSTMLStrategy(tags, options)));
+  return stringFromStream(generateStandardOutput(generatePrettyCSTML(tags, options)));
 };
 
 export const getCooked = (tags) => {
@@ -541,19 +673,20 @@ export const getCooked = (tags) => {
   let first = true;
   let foundLast = false;
   let depth = 0;
+  let ref = null;
 
   for (const tag of tags) {
     if (foundLast) throw new Error();
 
     switch (tag.type) {
       case ReferenceTag: {
+        ref = tag;
         if (depth === 1) {
           throw new Error('cookable nodes must not contain other nodes');
         }
         break;
       }
 
-      case OpenFragmentTag:
       case OpenNodeTag: {
         const { flags, attributes } = tag.value;
 
@@ -567,11 +700,11 @@ export const getCooked = (tags) => {
           }
         }
 
-        if (!(flags.trivia || (flags.escape && attributes.cooked))) {
+        if (!(ref.value.name === '#' || (ref.value.name === '@' && attributes.cooked))) {
           throw new Error('cookable nodes must not contain other nodes');
         }
 
-        if (flags.escape) {
+        if (ref.value.name === '@') {
           const { cooked: cookedValue } = tag.value.attributes;
 
           if (!cookedValue) throw new Error('cannot cook string: it contains uncooked escapes');
@@ -582,7 +715,6 @@ export const getCooked = (tags) => {
         break;
       }
 
-      case CloseFragmentTag:
       case CloseNodeTag: {
         if (depth === 1) {
           foundLast = true;
@@ -617,6 +749,8 @@ export const printSource = (tags) => {
   for (const tag of tags) {
     if (tag.type === LiteralTag) {
       printed += tag.value;
+    } else if (tag.type === GapTag) {
+      throw new Error('use generateSourceTextFor');
     }
   }
 
@@ -627,6 +761,8 @@ export function* generateSourceTextFor(tags) {
   for (const tag of tags) {
     if (tag.type === LiteralTag) {
       yield* tag.value;
+    } else if (tag.type === GapTag) {
+      yield null;
     }
   }
 }

package/lib/symbols.js

@@ -1,27 +1,20 @@
 export const node = Symbol.for('@bablr/node');
-
-export const gap = Symbol.for('@bablr/gap');
-
 export const fragment = Symbol.for('@bablr/fragment');
 
-export const null_ = Symbol.for('@bablr/null');
-
 export const DoctypeTag = Symbol.for('DoctypeTag');
 export const OpenNodeTag = Symbol.for('OpenNodeTag');
 export const CloseNodeTag = Symbol.for('CloseNodeTag');
-export const OpenFragmentTag = Symbol.for('OpenFragmentTag');
-export const CloseFragmentTag = Symbol.for('CloseFragmentTag');
 export const ReferenceTag = Symbol.for('ReferenceTag');
 export const ShiftTag = Symbol.for('ShiftTag');
 export const GapTag = Symbol.for('GapTag');
 export const NullTag = Symbol.for('NullTag');
-export const ArrayTag = Symbol.for('ArrayTag');
+export const ArrayInitializerTag = Symbol.for('ArrayInitializerTag');
 export const LiteralTag = Symbol.for('LiteralTag');
 
 export const EmbeddedNode = Symbol.for('EmbeddedNode');
+export const EmbeddedMatcher = Symbol.for('EmbeddedMatcher');
+export const EmbeddedRegex = Symbol.for('EmbeddedRegex');
 export const EmbeddedTag = Symbol.for('EmbeddedTag');
-export const EmbeddedExpression = Symbol.for('EmbeddedExpression');
+export const EmbeddedObject = Symbol.for('EmbeddedObject');
 
 export const TokenGroup = Symbol.for('TokenGroup');
-
-export { null_ as null };

package/lib/template.js

@@ -1,93 +1,107 @@
 import * as t from './builders.js';
 import {
-  LiteralTag,
-  EmbeddedNode,
   ReferenceTag,
-  ArrayTag,
-  OpenFragmentTag,
+  ArrayInitializerTag,
   OpenNodeTag,
+  CloseNodeTag,
   DoctypeTag,
-  CloseFragmentTag,
+  EmbeddedNode,
+  GapTag,
 } from './symbols.js';
 import * as btree from './btree.js';
-import { getOpenTag, getRoot } from './tree.js';
+import { getOpenTag, get, isFragmentNode } from './tree.js';
 
-const { isArray } = Array;
 const { freeze } = Object;
-const { isFinite } = Number;
-
-export const interpolateArray = (fragment) => {
-  const value = getRoot(fragment);
 
-  if (isArray(value)) {
-    if (isFinite(value[0])) {
-      return [...btree.traverse(value)];
-    } else {
-      return value;
-    }
-  } else {
-    return [value];
-  }
+export const buildFilledGapFunction = (expressions) => (value) => {
+  expressions.push(value);
+  return t.buildGapTag();
 };
 
-export function* interpolateFragmentChildren(value, ref) {
-  const open = getOpenTag(value);
+export function* interpolateFragment(node, ref, expressions) {
+  const open = getOpenTag(node);
+
+  if (node.type !== null) throw new Error();
+
+  const gap = buildFilledGapFunction(expressions);
 
-  if (open.type === OpenFragmentTag) {
+  const counters = new Map();
+
+  if (!open.value.type) {
     let currentRef = null;
-    for (let child of btree.traverse(value.children)) {
-      if (
-        child.type === DoctypeTag ||
-        child.type === OpenFragmentTag ||
-        child.type === CloseFragmentTag
-      ) {
-        continue;
-      }
+    let isFragment = isFragmentNode(node);
+    for (let tag of btree.traverse(node.children)) {
+      switch (tag.type) {
+        case DoctypeTag: {
+          break;
+        }
+        case OpenNodeTag:
+        case CloseNodeTag: {
+          if (!isFragment) {
+            yield tag;
+          }
+          break;
+        }
+
+        case ReferenceTag: {
+          currentRef = tag;
+          break;
+        }
+
+        case ArrayInitializerTag: {
+          const { name } = currentRef.value;
+          counters.set(name, -1);
+          if (name === '.') {
+            yield freeze({ ...ref });
+          } else {
+            yield currentRef;
+          }
+          yield tag;
+          break;
+        }
+
+        case GapTag: {
+          const { name, isArray, flags } = currentRef.value;
+
+          if (name === '.') {
+            // TODO check/combine flags
+            yield freeze({ ...ref });
+          } else {
+            yield currentRef;
+          }
+
+          const count = counters.get(name) + 1;
 
-      if (child.type === ArrayTag) {
-        // if (notAlreadyInitialized) {
-        yield child;
-        // }
-      } else if (child.type === ReferenceTag) {
-        currentRef = child;
-        if (child.value.name === '.') {
-          yield freeze({ ...ref });
-        } else {
-          yield child;
+          counters.set(name, count);
+
+          const resolvedRef = t.buildReferenceTag(name, isArray, flags, count);
+
+          yield gap(get(resolvedRef, node));
+
+          break;
+        }
+
+        case EmbeddedNode: {
+          const { name } = currentRef.value;
+          if (name === '.') {
+            yield freeze({ ...ref });
+          } else {
+            yield currentRef;
+          }
+          yield gap(tag.value);
+          break;
+        }
+
+        default: {
+          yield tag;
+          break;
         }
-      } else {
-        yield child;
       }
     }
   } else if (open.type === OpenNodeTag) {
     yield freeze({ ...ref });
+    yield gap(get(ref, node));
   } else {
     throw new Error();
   }
 }
-
-const validateTag = (tag) => {
-  if (!tag || (tag.type !== LiteralTag && tag.type !== EmbeddedNode)) {
-    throw new Error('Invalid tag');
-  }
-  if (tag.type === EmbeddedNode && !tag.value.flags.escape) {
-    throw new Error();
-  }
-};
-
-export const interpolateString = (value) => {
-  const tags = [];
-  if (isArray(value)) {
-    for (const element of value) {
-      validateTag(element);
-
-      tags.push(element);
-    }
-  } else {
-    // we can't safely interpolate strings here, though I wish we could
-    validateTag(value);
-    tags.push(value);
-  }
-
-  return t.buildNode('String', 'Content', tags);
-};