@bablr/agast-vm 0.8.0 → 0.9.0

package/lib/state.js

@@ -1,20 +1,25 @@
-import isArray from 'iter-tools-es/methods/is-array';
-import { WeakStackFrame } from '@bablr/weak-stack';
 import {
-  add,
+  addProperty,
   finalizeNode,
-  getRoot,
   buildStubNode,
   getRange,
-  buildNullTag,
-  treeFromStream,
   createNode,
-  buildReferenceTag,
+  buildNullNode,
+  buildOpenNodeTag,
+  shiftProperty,
+  buildProperty,
+  add,
+  buildBindingTag,
+  buildAttributeDefinition,
 } from '@bablr/agast-helpers/tree';
-import * as sumtree from '@bablr/agast-helpers/sumtree';
+import * as sumtree from '@bablr/agast-helpers/children';
+import * as btree from '@bablr/agast-helpers/btree';
 import {
   getInitializerChildrenIndex,
-  getPropertyChildrenIndex,
+  getOpenTag,
+  getOriginalFirstNode,
+  isGapNode,
+  isStubNode,
   referencesAreEqual,
   TagPath,
 } from '@bablr/agast-helpers/path';
@@ -28,52 +33,85 @@ import {
   NullTag,
   InitializerTag,
   LiteralTag,
+  AttributeDefinition,
+  BindingTag,
+  Property,
 } from '@bablr/agast-helpers/symbols';
 import { facades, actuals } from './facades.js';
-import { Path } from './path.js';
-import { Coroutine } from '@bablr/coroutine';
+import { Path, PathFacade, TagPathFacade } from './path.js';
+import { get, has, immSet, isObject } from '@bablr/agast-helpers/object';
+import { NodeFacade } from './node.js';
 
+const { isArray } = Array;
 const { hasOwn } = Object;
 
+const defineAttribute = (node, tag) => {
+  if (tag.type !== AttributeDefinition) throw new Error();
+
+  let { path, value } = tag.value;
+  let openTag = getOpenTag(node);
+  let { attributes } = node;
+
+  if (!has(attributes, path) && get(attributes, path) !== undefined)
+    throw new Error('Can only define undefined attributes');
+
+  if (value === undefined) throw new Error('cannot define attribute to undefined');
+
+  let { flags, type } = openTag.value;
+  attributes = immSet(attributes, path, value);
+  let newOpenTag = buildOpenNodeTag(flags, type, attributes);
+
+  node.attributes = attributes;
+
+  node.children = sumtree.replaceAt(0, node.children, newOpenTag);
+  node.children = sumtree.push(node.children, tag);
+};
+
 export const StateFacade = class AgastStateFacade {
   constructor(state) {
     facades.set(state, this);
   }
 
-  static from(context) {
-    return State.from(actuals.get(context));
+  static create() {
+    return State.create();
   }
 
   get resultPath() {
-    return actuals.get(this).resultPath;
+    let { resultPath } = actuals.get(this);
+    return resultPath && new TagPathFacade(resultPath);
   }
 
-  get reference() {
-    return actuals.get(this).reference;
+  get referenceTag() {
+    return actuals.get(this).referenceTag;
   }
 
-  get referencePath() {
-    return actuals.get(this).referencePath;
+  get referenceTagPath() {
+    let { referenceTagPath } = actuals.get(this);
+    return referenceTagPath && new TagPathFacade(referenceTagPath);
   }
 
-  get unshiftedReferencePath() {
-    return actuals.get(this).unshiftedReferencePath;
+  get path() {
+    let { path } = actuals.get(this);
+    return path && new PathFacade(path);
   }
 
-  get context() {
-    return facades.get(actuals.get(this).context);
+  get node() {
+    let { node } = actuals.get(this);
+    return node && new NodeFacade(node);
   }
 
-  get path() {
-    return actuals.get(this).path;
+  get done() {
+    return actuals.get(this).done;
   }
 
-  get node() {
-    return actuals.get(this).node;
+  get parentNode() {
+    let { parentNode } = actuals.get(this);
+    return parentNode && new NodeFacade(parentNode);
   }
 
-  get parentNode() {
-    return actuals.get(this).parentNode;
+  get held() {
+    let { held } = actuals.get(this);
+    return held && new NodeFacade(held.node);
   }
 
   get holding() {
@@ -84,10 +122,6 @@ export const StateFacade = class AgastStateFacade {
     return actuals.get(this).depth;
   }
 
-  get ctx() {
-    return this.context;
-  }
-
   get parent() {
     return facades.get(actuals.get(this).parent);
   }
@@ -95,33 +129,24 @@ export const StateFacade = class AgastStateFacade {
 
 export const nodeStates = new WeakMap();
 
-export const State = class AgastState extends WeakStackFrame {
-  constructor(
-    parent,
-    context,
-    expressions = [],
-    path = Path.from(createNode()),
-    held = null,
-    resultPath = null,
-  ) {
-    super(parent);
-
-    if (!context || !path || !expressions) throw new Error('invalid args to tagState');
-
-    this.context = context;
-    this.expressions = new Coroutine(expressions[Symbol.iterator]());
-    this.path = path;
+export const State = class AgastState {
+  static create() {
+    return new State();
+  }
+
+  constructor(held = null, path = null, resultPath = null) {
     this.held = held;
+    this.path = path;
     this.resultPath = resultPath;
-    this.referencePath = null;
-
-    if (!this.node) throw new Error();
+    this.done = false;
+    this.referenceTagPath = null;
+    this.doctype = null;
 
     new StateFacade(this);
   }
 
-  static from(context, expressions = []) {
-    return State.create(context, expressions);
+  static from(held) {
+    return new State(held);
   }
 
   get holding() {
@@ -129,33 +154,48 @@ export const State = class AgastState extends WeakStackFrame {
   }
 
   get atReference() {
-    return !![ReferenceTag, ShiftTag].includes(this.resultPath?.tag.type);
+    return [ReferenceTag, ShiftTag].includes(this.resultPath?.tag.type);
+  }
+
+  get atBinding() {
+    return this.resultPath?.tag.type === BindingTag;
   }
 
   advance(tag) {
     if (!tag) throw new Error();
 
+    if (this.done) throw new Error();
+
     let targetPath = this.path;
 
     switch (tag.type) {
       case DoctypeTag: {
-        let { path, node } = this;
+        let { path } = this;
 
-        if (this.resultPath) throw new Error('invalid location for doctype');
+        if (this.resultPath || this.docType) throw new Error('invalid location for doctype');
 
-        node.children = sumtree.push(node.children, tag);
-        node.attributes = tag.value.attributes;
+        this.doctype = tag;
 
         targetPath = path;
         break;
       }
 
       case ReferenceTag: {
-        let { name, isArray, flags } = tag.value;
+        let { type, isArray, name, flags } = tag.value;
 
         if (this.atReference) throw new Error('invalid location for reference');
-        if (!name) throw new Error('missing reference name');
-        if (!/#|@|[.]|[a-zA-Z]+/.test(name)) throw new Error('invalid reference name');
+        if (!name && !type) throw new Error();
+        if (type && !['.', '#', '@'].includes(type)) throw new Error();
+        if (['#', '@'].includes(type) && isArray) throw new Error();
+
+        if (this.held && sumtree.getAt(2, this.node.children)?.type === InitializerTag) {
+          if (
+            !referencesAreEqual(sumtree.getAt(1, this.node.children), tag) ||
+            sumtree.getSize(this.node.children) > 3
+          ) {
+            throw new Error();
+          }
+        }
 
         if (this.node.properties[name] && this.node.properties[name]?.node === undefined) {
           let existingReferenceIndex = getInitializerChildrenIndex(this.node, tag);
@@ -171,42 +211,102 @@ export const State = class AgastState extends WeakStackFrame {
           throw new Error('gap reference in gapless node');
         }
 
-        this.referencePath = TagPath.from(this.path, -1);
+        this.referenceTagPath = TagPath.from(this.path, -1);
 
         break;
       }
 
+      case BindingTag: {
+        if (!this.atReference && this.parent) {
+          throw new Error('Invalid location for BindingTag');
+        }
+
+        this.node.children = sumtree.push(this.node.children, tag);
+        break;
+      }
+
       case OpenNodeTag: {
         let parentNode = this.node;
 
         targetPath = this.path;
 
-        if (!this.atReference && this.parent) {
+        if (!this.atBinding && this.parent) {
           throw new Error('Invalid location for OpenNodeTag');
         }
 
-        if (!this.path.depth) {
-          this.node.flags = tag.value.flags;
-          this.node.children = sumtree.push(this.node.children, tag);
-          this.node.type = tag.value.type;
-          this.node.language = tag.value.language;
-          this.node.attributes = tag.value.attributes || {};
+        let bindingTag = parentNode && sumtree.getAt(-1, parentNode.children);
+
+        if (bindingTag && !bindingTag.value.languagePath) throw new Error();
+
+        let node = createNode(tag);
+
+        if (!this.path) {
+          this.path = Path.create(node);
+
+          if (!tag.value.type && this.doctype) {
+            node.children = sumtree.push(node.children, this.doctype);
+          }
         } else {
-          let node = createNode(tag);
           this.path = this.path.push(node, sumtree.getSize(parentNode.children) - 2);
-          add(parentNode, this.reference, node);
+          add(parentNode, this.referenceTag, node, bindingTag);
+        }
+
+        node.children = sumtree.push(node.children, tag);
+
+        let undefinedAttributes = 0;
+
+        let queue = [this.node.attributes];
+        while (queue.length) {
+          for (let value of Object.values(queue[queue.length - 1])) {
+            if (value === undefined) {
+              undefinedAttributes++;
+            } else if (isArray(value) || isObject(value)) {
+              queue.push(value);
+            }
+          }
+          queue.pop();
         }
 
+        nodeStates.set(this.node, { undefinedAttributes });
+
         break;
       }
 
       case CloseNodeTag: {
         if (this.atReference) throw new Error('invalid location for close tag');
 
+        if (this.node.type) {
+          for (const value of Object.values(this.node.properties)) {
+            if (!Array.isArray(value) && value.node === undefined) {
+              addProperty(
+                this.node,
+                buildProperty(value.reference, buildBindingTag().value, buildNullNode()),
+              );
+            }
+          }
+        }
+
+        let path = [];
+        let queue = [this.node.attributes];
+        while (queue.length) {
+          for (const { 0: key, 1: value } of Object.entries(queue[queue.length - 1])) {
+            if (value === undefined) {
+              path.push(key);
+              defineAttribute(this.node, buildAttributeDefinition(path, null));
+              path.pop(key);
+            } else if (isArray(value) || isObject(value)) {
+              queue.push(value);
+              path.push(key);
+            }
+          }
+          queue.pop();
+        }
+
         this.node.children = sumtree.push(this.node.children, tag);
 
-        if (this.node.undefinedAttributes?.size)
-          throw new Error('Grammar failed to bind all attributes');
+        if (!this.path) {
+          this.done = true;
+        }
 
         finalizeNode(this.node);
 
@@ -214,46 +314,43 @@ export const State = class AgastState extends WeakStackFrame {
         break;
       }
 
-      case GapTag: {
+      case Property: {
         let target;
+        let property = tag.value;
+        let { node } = this.path;
         let lastTagPath = TagPath.from(this.path, -1);
 
-        if (!this.atReference) {
-          throw new Error('Invalid location for GapTag');
+        if (!this.atBinding && !isStubNode(property.node)) {
+          throw new Error('Invalid location for Property');
         }
 
-        if (this.held && lastTagPath.tag.type !== ShiftTag) {
-          target = this.held.node;
-
-          this.held = null;
-        } else {
-          this.expressions.advance();
-
-          if (!this.expressions.done) {
-            const expression = this.expressions.value;
-
-            if (isArray(expression)) {
-              throw new Error('Invalid array interpolation');
-            }
-
-            if (expression == null) {
-              target = treeFromStream(buildNullTag());
-            } else {
-              target = getRoot(expression);
-            }
+        if (this.held) {
+          if (isGapNode(property.node)) {
+            property = buildProperty(property.reference, this.held.binding, this.held.node);
           } else {
-            if (!this.node.flags.hasGap) throw new Error('Node must allow gaps');
-
-            target = buildStubNode(tag);
+            let { height } = lastTagPath.previousSibling.tag.value;
+            let matchesHeld =
+              isGapNode(property.node) ||
+              this.held.node === property.node ||
+              this.held.node === getOriginalFirstNode(property.node, (height ?? 1) - 1);
+            if (!matchesHeld) {
+              throw new Error();
+            }
           }
+        }
+
+        if (this.held && lastTagPath.previousSibling.tag.type !== ShiftTag) {
+          target = this.held.node;
+        } else {
+          // if (!this.node.flags.hasGap) throw new Error('Node must allow gaps');
 
-          this.held = null;
+          target = buildStubNode(tag);
         }
 
         const range = getRange(target);
 
         this.resultPath = range ? range[1] : this.resultPath;
-        this.referencePath = null;
+        this.referenceTagPath = null;
 
         let lastRefPath = [ShiftTag, ReferenceTag].includes(lastTagPath.tag.type)
           ? lastTagPath
@@ -261,80 +358,88 @@ export const State = class AgastState extends WeakStackFrame {
 
         if (![ShiftTag, ReferenceTag].includes(lastRefPath.tag.type)) throw new Error();
 
-        let refTag = lastRefPath.tag;
-
-        if (refTag.type === ShiftTag) {
-          let refIndex = lastRefPath.childrenIndex - lastRefPath.tag.value.index * 2;
-          refTag = sumtree.getAt(refIndex, this.node.children);
-        }
-
-        if (refTag) {
-          add(
-            this.path.node,
-            refTag,
-            target,
-            lastRefPath.tag.type === ShiftTag
-              ? lastRefPath.tag.value.index
-              : refTag.value.flags.expression
-              ? 0
-              : null,
-          );
+        if (lastRefPath.tag.type === ShiftTag) {
+          shiftProperty(node, property);
+        } else {
+          addProperty(node, property);
         }
 
+        this.held = null;
         break;
       }
 
+      case GapTag:
       case NullTag: {
-        const { node: parentNode, reference } = this;
+        const { node: parentNode, referenceTag } = this;
+
+        if (this.held) throw new Error();
 
         if (!this.atReference && this.parent) {
-          throw new Error('Invalid location for OpenNodeTag');
+          throw new Error('Invalid location for NullTag');
         }
 
         let stubNode = buildStubNode(tag);
 
-        add(parentNode, reference, stubNode);
+        add(parentNode, referenceTag, stubNode);
+
+        targetPath = this.path.push(stubNode, sumtree.getSize(this.node.children) - 3);
+        break;
+      }
+
+      case AttributeDefinition: {
+        if (this.held) throw new Error('invalid place for an atrribute binding');
+
+        let nodeState = nodeStates.get(this.node);
+
+        nodeState.undefinedAttributes--;
+
+        // add undefined attributes from value
+
+        defineAttribute(this.node, tag);
 
-        targetPath = this.path.push(stubNode, sumtree.getSize(this.node.children) - 2);
         break;
       }
 
       case InitializerTag: {
         const { isArray } = tag.value;
-        const { node, reference } = this;
-        const { name } = reference.value;
+        const { node, referenceTag } = this;
+        const { name } = referenceTag.value;
 
         if (!this.atReference && this.parent) {
-          throw new Error('Invalid location for OpenNodeTag');
+          throw new Error('Invalid location for InitializerTag');
+        }
+
+        if (this.held && sumtree.getAt(2, node.children)?.type === InitializerTag) {
+          throw new Error();
         }
 
-        if (node.properties[name] && node.properties[name]?.node === undefined) {
+        if (
+          hasOwn(node.properties, name) &&
+          (isArray
+            ? btree.getSize(node.properties[name])
+            : node.properties[name]?.node !== undefined)
+        ) {
           throw new Error();
         }
 
-        add(node, reference, isArray ? [] : undefined);
+        add(node, referenceTag, isArray ? [] : undefined);
         break;
       }
 
       case ShiftTag: {
-        if (this.atReference) throw new Error('invalid location for shift');
-
-        const finishedPath = this.resultPath.innerPath;
-        const finishedNode = finishedPath.node;
-        const ref = TagPath.from(
-          this.resultPath,
-          this.resultPath.childrenIndex - tag.value.index * 2 + 1,
-        ).tag;
+        if (this.resultPath.tag.type !== Property) throw new Error('invalid location for shift');
 
-        this.held = { node: finishedNode, path: finishedPath };
+        let heldProperty = this.resultPath.tag.value;
 
-        if (!ref.value.name) throw new Error();
+        if (!this.held) {
+          this.held = heldProperty;
+        }
 
-        if (!ref.value.flags.expression) throw new Error();
+        if (!heldProperty.reference.flags.expression) throw new Error();
 
         this.node.children = sumtree.push(this.node.children, tag);
 
-        this.referencePath = TagPath.from(this.path, -1);
+        this.referenceTagPath = TagPath.from(this.path, -1);
 
         // this.path = finishedPath;
         targetPath = this.path;
@@ -351,15 +456,11 @@ export const State = class AgastState extends WeakStackFrame {
         throw new Error();
     }
 
-    this.resultPath = TagPath.from(targetPath, -1);
+    this.resultPath = targetPath && TagPath.from(targetPath, -1);
 
     return tag;
   }
 
-  get ctx() {
-    return this.context;
-  }
-
   get isGap() {
     return this.tag.type === GapTag;
   }
@@ -372,8 +473,17 @@ export const State = class AgastState extends WeakStackFrame {
     return this.path.parent.node;
   }
 
-  get reference() {
-    return this.referencePath.tag;
+  get referenceTag() {
+    return this.referenceTagPath?.tag;
+  }
+
+  get bindingPath() {
+    let path = this.referenceTagPath.nextSibling;
+    return path.tag.type === BindingTag ? path : null;
+  }
+
+  get binding() {
+    return this.bindingPath?.tag;
   }
 
   get node() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,11 +12,8 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.7.0",
-    "@bablr/agast-vm-helpers": "0.7.0",
-    "@bablr/coroutine": "0.1.0",
-    "@bablr/weak-stack": "1.0.0",
-    "@iter-tools/imm-stack": "1.1.0"
+    "@bablr/agast-helpers": "0.8.0",
+    "@bablr/agast-vm-helpers": "0.8.0"
   },
   "devDependencies": {
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",