occam-dom 5.0.0 → 5.0.2

package/src/example/view/textarea/parseTree.js

@@ -4,8 +4,6 @@ import withStyle from "easy-with-style";  ///
 
 import Textarea from "../textarea";
 
-import { EMPTY_STRING } from "../../../constants";
-
 class ParseTreeTextarea extends Textarea {
   setParseTree(parseTree) {
     parseTree.shiftLine();  //
@@ -16,22 +14,6 @@ class ParseTreeTextarea extends Textarea {
     this.setValue(value);
   }
 
-  clearParseTree(parseTree) {
-    const value = EMPTY_STRING;
-
-    this.setValue(value);
-  }
-
-  parentContext() {
-    const setParseTree = this.setParseTree.bind(this), ///
-          clearParseTree = this.clearParseTree.bind(this); ///
-
-    return ({
-      setParseTree,
-      clearParseTree
-    });
-  }
-
   static defaultProperties = {
     className: "parse-tree",
     spellCheck: "false",

package/src/example/view.js

@@ -3,29 +3,28 @@
 import withStyle from "easy-with-style";  ///
 
 import { Element } from "easy";
-import { queryUtilities } from "../index";  ///
+import { nodeUtilities } from "../index" ///
 import { CSSLexer, CSSParser } from "with-style";
 import { RowsDiv, ColumnDiv, ColumnsDiv, VerticalSplitterDiv } from "easy-layout";
 
 import SubHeading from "./view/subHeading";
 import SizeableDiv from "./view/div/sizeable";
-import NodesTextarea from "./view/textarea/nodes";
 import ContentTextarea from "./view/textarea/content";
 import MaximumDepthInput from "./view/input/maximumDepth";
-import ExpressionStringInput from "./view/input/expressionString";
-import ParseTreeTextarea from "./view/textarea/parseTree";
+import OuterNodesTextarea from "./view/textarea/outerNodes";
+import ExpressionsTextarea from "./view/textarea/expressions";
+import OuterParseTreeTextarea from "./view/textarea/parseTree/outer";
+import InnerParseTreeTextarea from "./view/textarea/parseTree/inner";
+
+import { queryByExpressions } from "./utilities/query";
+
+const { topmostNodeFromOuterNodes: topmostInnerNodeFromOuterNodes } = nodeUtilities;
 
 const cssLexer = CSSLexer.fromNothing(),
       cssParser = CSSParser.fromNothing();
 
-const { queryByExpressionString } = queryUtilities;
-
 class View extends Element {
   keyUpHandler = (event, element) => {
-    this.clearNodes();
-
-    this.clearParseTree();
-
     const content = this.getContent(),
           tokens = cssLexer.tokenise(content),
           node = cssParser.parse(tokens);
@@ -34,17 +33,20 @@ class View extends Element {
       return;
     }
 
-    const abridged = true,
-          parseTree = node.asParseTree(tokens, abridged),
-          expressionString = this.getExpressionString(),
+    const outerNode = node, ///
+          expressions = this.getExpressions(),
           maximumDepth = this.getMaximumDepth(),
-          nodes = queryByExpressionString(node, expressionString, maximumDepth);
+          outerNodes = queryByExpressions(outerNode, expressions, maximumDepth),
+          topmostInnerNode = topmostInnerNodeFromOuterNodes(outerNodes),
+          innerNode = topmostInnerNode, ///
+          outerParseTree = outerNode.asParseTree(tokens),
+          innerParseTree = innerNode.asParseTree();
 
-    if (nodes !== null) {
-      this.setNodes(nodes, tokens); ///
+    this.setOuterNodes(outerNodes, tokens); ///
 
-      this.setParseTree(parseTree);
-    }
+    this.setOuterParseTree(outerParseTree);
+
+    this.setInnerParseTree(innerParseTree);
   }
 
   childElements() {
@@ -54,30 +56,34 @@ class View extends Element {
         <SizeableDiv>
           <RowsDiv>
             <SubHeading>
-              Expression
+              Content
             </SubHeading>
-            <ExpressionStringInput onKeyUp={this.keyUpHandler} />
+            <ContentTextarea onKeyUp={this.keyUpHandler} />
+            <SubHeading>
+              Expressions
+            </SubHeading>
+            <ExpressionsTextarea onKeyUp={this.keyUpHandler} />
             <SubHeading>
               Maximum depth
             </SubHeading>
             <MaximumDepthInput onKeyUp={this.keyUpHandler} />
+            <SubHeading>
+              Outer nodes
+            </SubHeading>
+            <OuterNodesTextarea/>
           </RowsDiv>
         </SizeableDiv>
         <VerticalSplitterDiv />
         <ColumnDiv>
           <RowsDiv>
             <SubHeading>
-              Content
-            </SubHeading>
-            <ContentTextarea onKeyUp={this.keyUpHandler} />
-            <SubHeading>
-              Parse tree
+              Outer parse tree
             </SubHeading>
-            <ParseTreeTextarea />
+            <OuterParseTreeTextarea/>
             <SubHeading>
-              Nodes
+              Inner parse tree
             </SubHeading>
-            <NodesTextarea />
+            <InnerParseTreeTextarea/>
           </RowsDiv>
         </ColumnDiv>
       </ColumnsDiv>
@@ -88,16 +94,16 @@ class View extends Element {
   initialise() {
     this.assignContext();
 
-    const { initialContent, initialExpressionString, initialMaximumDepth } = this.constructor,
+    const { initialContent, initialExpressions, initialMaximumDepth } = this.constructor,
           content = initialContent,  ///
           maximumDepth = initialMaximumDepth,  ///
-          expressionString = initialExpressionString;  ///
+          expressions = initialExpressions;  ///
 
     this.setContent(content);
 
     this.setMaximumDepth(maximumDepth);
 
-    this.setExpressionString(expressionString);
+    this.setExpressions(expressions);
 
     this.keyUpHandler();  ///
   }
@@ -107,7 +113,13 @@ class View extends Element {
 }
 `;
 
-  static initialExpressionString = "/*//@special[2...4]";
+  static initialExpressions = [
+    "//term",
+    "//ruleSet",
+    "//selectors",
+    "//propertyName",
+    "//@identifier"
+  ];
 
   static initialMaximumDepth = 5;
 

package/src/index.js

@@ -1,7 +1,4 @@
 "use strict";
 
-export { default as Query } from "./query";
-export { default as Expression } from "./expression";
-export { default as queryUtilities } from "./utilities/query";
-export { default as ExpressionLexer } from "./expression/lexer";
-export { default as ExpressionParser } from "./expression/parser";
+export { default as Node } from "./node";
+export { default as nodeUtilities } from "./utilities/node";

package/src/node.js

@@ -0,0 +1,221 @@
+"use strict";
+
+import NodeParseTree from "./parseTree/node";
+
+import { EMPTY_STRING } from "./constants";
+
+export default class Node {
+  constructor(outerNode, parentNode, childNodes) {
+    this.outerNode = outerNode;
+    this.parentNode = parentNode;
+    this.childNodes = childNodes;
+  }
+
+  getOuterNode() {
+    return this.outerNode;
+  }
+
+  getParentNode() {
+    return this.parentNode;
+  }
+
+  getChildNodes() {
+    return this.childNodes;
+  }
+
+  setOuterNode(outerNode) {
+    this.outerNode = outerNode;
+  }
+
+  setParentNode(parentNode) {
+    this.parentNode = parentNode;
+  }
+
+  setChildNodes(childNodes) {
+    this.childNodes = childNodes;
+  }
+
+  mapChildNode(callback) { return this.childNodes.map(callback); }
+
+  someChildNode(callback) { return this.childNodes.some(callback); }
+
+  findChildNode(callback) { return this.childNodes.find(callback); }
+
+  everyChildNode(callback) { return this.childNodes.every(callback); }
+
+  filterChildNode(callback) { return this.childNodes.filter(callback); }
+
+  reduceChildNode(callback, initialValue) { return this.childNodes.reduce(callback, initialValue); }
+
+  forEachChildNode(callback) { this.childNodes.forEach(callback); }
+
+  setChildNodesParentNode(childNodes) {
+    if (childNodes === undefined) {
+      childNodes = [
+        ...this.childNodes
+      ];
+    }
+
+    const parentNode = this;
+
+    childNodes.forEach((childNode) => {
+      childNode.setParentNode(parentNode);
+    });
+  }
+
+  resetChildNodesParentNode(childNodes) {
+    if (childNodes === undefined) {
+      childNodes = [
+        ...this.childNodes
+      ];
+    }
+
+    const parentNode = null;
+
+    childNodes.forEach((childNode) => {
+      childNode.setParentNode(parentNode);
+    });
+  }
+
+  addChildNode(addedChildNode, startIndex) {
+    const addedChildNodes = [
+      addedChildNode
+    ];
+
+    this.addChildNodes(addedChildNodes, startIndex);
+  }
+
+  addChildNodes(addedChildNodes, startIndex) {
+    const deleteCount = 0;
+
+    this.spliceChildNodes(startIndex, deleteCount, addedChildNodes);
+  }
+
+  removeChildNode(removedChildNode) {
+    let removedChildNodes;
+
+    removedChildNodes = [
+      removedChildNode
+    ];
+
+    removedChildNodes = this.removeChildNodes(removedChildNodes);
+
+    return removedChildNodes;
+  }
+
+  removeChildNodes(removedChildNodes) {
+    if (removedChildNodes === undefined) {
+      removedChildNodes = [
+        ...this.childNodes
+      ];
+    }
+
+    const removedChildNodesLength = removedChildNodes.length;
+
+    if (removedChildNodesLength === 0) {
+      return;
+    }
+
+    const firstReplacedChildNode = first(removedChildNodes),
+          firstIndex = this.childNodes.indexOf(firstReplacedChildNode),
+          startIndex = firstIndex, ///
+          deleteCount = removedChildNodesLength, ///
+          addedChildNodes = [];
+
+    removedChildNodes = this.spliceChildNodes(startIndex, deleteCount, addedChildNodes);
+
+    return removedChildNodes;
+  }
+
+  replaceChildNode(replacedChildNode, replacementChildNodes) {
+    const replacedChildNodes = [
+      replacedChildNode
+    ];
+
+    this.replaceChildNodes(replacedChildNodes, replacementChildNodes);
+  }
+
+  replaceChildNodes(replacedChildNodes, replacementChildNodes) {
+    const replacedChildNodesLength = replacedChildNodes.length,
+          firstReplacedChildNode = first(replacedChildNodes),
+          firstIndex = this.childNodes.indexOf(firstReplacedChildNode),
+          startIndex = firstIndex, ///
+          deleteCount = replacedChildNodesLength; ///
+
+    this.spliceChildNodes(startIndex, deleteCount, replacementChildNodes);
+  }
+
+  spliceChildNodes(startIndex, deleteCount, addedChildNodes = []) {
+    const removedChildNodes = this.childNodes.splice(startIndex, deleteCount, ...addedChildNodes);
+
+    this.resetChildNodesParentNode(removedChildNodes);
+
+    this.setChildNodesParentNode(addedChildNodes);
+
+    return removedChildNodes;
+  }
+
+  sliceChildNodes(startIndex, endIndex = Infinity) {
+    const childNodes = this.childNodes.slice(startIndex, endIndex);
+
+    return childNodes;
+  }
+
+  asString() {
+    let string = EMPTY_STRING;
+
+    if (this.outerNode !== null) {
+      const nodeTerminalNode = this.outerNode.isTerminalNode();
+
+      if (nodeTerminalNode) {
+        const terminalNode = this.outerNode,
+              type = terminalNode.getType(),
+              content = terminalNode.getContent();
+
+        string = `"${content}" [${type}]`;
+      } else {
+        const nonTerminalNode = this.outerNode,
+              ruleName = nonTerminalNode.getRuleName();
+
+        string = ruleName;  ///
+      }
+    }
+
+    return string;
+  }
+
+  asParseTree() {
+    const node = this,  ///
+          nodeParseTree = NodeParseTree.fromNode(node),
+          parseTree = nodeParseTree;  ///
+
+    return parseTree;
+  }
+
+  static fromNothing(Class) {
+    if (Class === undefined) {
+      Class = Node; ///
+    }
+
+    const outerNode = null,
+          parentNode = null,
+          childNodes = [],
+          node = new Class(outerNode, parentNode, childNodes);
+
+    return node;
+  }
+
+  static fromOuterNode(Class, outerNode) {
+    if (outerNode === undefined) {
+      outerNode = Class;  ///
+
+      Class = Node; ///
+    }
+
+    const parentNode = null,
+          childNodes = [],
+          node = new Class(outerNode, parentNode, childNodes);
+
+    return node;
+  }
+}

package/src/parseTree/childNodes.js

@@ -0,0 +1,108 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import VerticalBranchParseTree from "./verticalBranch";
+import HorizontalBranchParseTree from "./horizontalBranch";
+
+const { first } = arrayUtilities;
+
+export default class ChildNodesParseTree extends VerticalBranchParseTree {
+  static fromChildNodes(childNodes) {
+    let childNodesParseTree = null;
+
+    const childNodesLength = childNodes.length;
+
+    if (childNodesLength > 0) {
+      const childNodeParseTrees = childNodes.reduce((childNodeParseTrees, childNode) => {
+              const childNodeParseTree = childNode.asParseTree();
+
+              childNodeParseTrees.push(childNodeParseTree);
+
+              return childNodeParseTrees;
+            }, []),
+            childNodeParseTreesLength = childNodeParseTrees.length;
+
+      if (childNodeParseTreesLength === 1) {
+        const firstChildNodeParseTree = first(childNodeParseTrees);
+
+        childNodesParseTree = firstChildNodeParseTree;  ///
+      } else {
+        let firstVerticalBranchPosition,
+            lastVerticalBranchPosition = 0,
+            childNodeParseTreesWidth = 0,
+            childNodeParseTreesDepth = 0;
+
+        childNodeParseTrees.forEach((childNodeParseTree, index) => {
+          const childNodeParseTreeWidth = childNodeParseTree.getWidth(),
+                childNodeParseTreeDepth = childNodeParseTree.getDepth();
+
+          if (index === 0) {
+            const firstChildNodeParseTree = childNodeParseTree,
+                  firstChildNodeParseTreeVerticalBranchPosition = firstChildNodeParseTree.getVerticalBranchPosition();
+
+            firstVerticalBranchPosition = firstChildNodeParseTreeVerticalBranchPosition;
+          }
+
+          if (index === childNodeParseTreesLength - 1) {
+            const lastChildNodeParseTree = childNodeParseTree,
+                  lastChildNodeParseTreeVerticalBranchPosition = lastChildNodeParseTree.getVerticalBranchPosition();
+
+            lastVerticalBranchPosition += lastChildNodeParseTreeVerticalBranchPosition;
+          }
+
+          if (index < childNodeParseTreesLength - 1) {
+            lastVerticalBranchPosition += childNodeParseTreeWidth;
+            lastVerticalBranchPosition += 1;
+
+            childNodeParseTreesWidth += 1;
+          }
+
+          childNodeParseTreesWidth += childNodeParseTreeWidth;
+          childNodeParseTreesDepth = Math.max(childNodeParseTreesDepth, childNodeParseTreeDepth);
+        });
+
+        const width = lastVerticalBranchPosition - firstVerticalBranchPosition + 1,
+              verticalBranchParseTree = VerticalBranchParseTree.fromWidth(width),
+              horizontalBranchParseTree = HorizontalBranchParseTree.fromWidth(width),
+              leftMarginWidth = firstVerticalBranchPosition,
+              rightMarginWidth = childNodeParseTreesWidth - width - leftMarginWidth;
+
+        verticalBranchParseTree.addLeftMargin(leftMarginWidth);
+        verticalBranchParseTree.addRightMargin(rightMarginWidth);
+        horizontalBranchParseTree.addLeftMargin(leftMarginWidth);
+        horizontalBranchParseTree.addRightMargin(rightMarginWidth);
+
+        const verticalBranchPosition = verticalBranchParseTree.getVerticalBranchPosition(),
+              depth = childNodeParseTreesDepth; ///
+
+        childNodesParseTree = VerticalBranchParseTree.fromDepthAndVerticalBranchPosition(ChildNodesParseTree, depth, verticalBranchPosition);
+
+        childNodeParseTrees.forEach((childNodeParseTree, index) => {
+          const childNodeParseTreeDepth = childNodeParseTree.getDepth(),
+                clonedChildNodeParseTree = childNodeParseTree.clone();
+
+          if (index < childNodeParseTreesLength - 1) {
+            const rightMarginWidth = 1;
+
+            clonedChildNodeParseTree.addRightMargin(rightMarginWidth);
+          }
+
+          if (childNodeParseTreeDepth < childNodeParseTreesDepth) {
+            const bottomMarginDepth = childNodeParseTreesDepth - childNodeParseTreeDepth;
+
+            clonedChildNodeParseTree.addBottomMargin(bottomMarginDepth);
+          }
+
+          childNodesParseTree.appendToRight(clonedChildNodeParseTree);
+        });
+
+        childNodesParseTree.appendToTop(horizontalBranchParseTree);
+
+        childNodesParseTree.appendToTop(verticalBranchParseTree);
+      }
+    }
+
+    return childNodesParseTree;
+  }
+}

package/src/parseTree/horizontalBranch.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import { characters } from "necessary";
+
+import ParseTree from "../parseTree";
+
+import { EMPTY_STRING } from "../constants";
+
+const { DASH_CHARACTER } = characters;
+
+export default class HorizontalBranchParseTree extends ParseTree {
+  static fromWidth(width) {
+    const string = stringFromCharactersWidth(width, DASH_CHARACTER),
+          line = string, ///
+          lines = [
+            line
+          ],
+          horizontalBranchParseTree = new HorizontalBranchParseTree(lines);
+
+    return horizontalBranchParseTree;
+  }
+}
+
+function stringFromCharactersWidth(charactersWidth, character) {
+  let string = EMPTY_STRING;
+
+  for (let index = 0; index < charactersWidth; index++) {
+    string += character;
+  }
+
+  return string;
+}

package/src/parseTree/node.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import StringParseTree from "./string";
+import ChildNodesParseTree from "./childNodes";
+import VerticalBranchParseTree from "./verticalBranch";
+
+export default class NodeParseTree extends VerticalBranchParseTree {
+  static fromNode(node) {
+    let nodeParseTree;
+
+    const childNodes = node.getChildNodes(),
+          ruleNameParseTree = StringParseTree.fromNode(node),
+          childNodesParseTree = ChildNodesParseTree.fromChildNodes(childNodes);
+
+    if (childNodesParseTree === null) {
+      const ruleNameParseTreeDepth = ruleNameParseTree.getDepth(),
+            ruleNameParseTreeVerticalBranchPosition = ruleNameParseTree.getVerticalBranchPosition(),
+            verticalBranchPosition = ruleNameParseTreeVerticalBranchPosition, ///
+            depth = ruleNameParseTreeDepth; ///
+
+      nodeParseTree = VerticalBranchParseTree.fromDepthAndVerticalBranchPosition(NodeParseTree, depth, verticalBranchPosition);
+
+      nodeParseTree.appendToRight(ruleNameParseTree);
+    } else {
+      let ruleNameParseTreeVerticalBranchPosition = ruleNameParseTree.getVerticalBranchPosition();
+
+      const childNodesParseTreeVerticalBranchPosition = childNodesParseTree.getVerticalBranchPosition(),
+            verticalBranchPositionsDifference = ruleNameParseTreeVerticalBranchPosition - childNodesParseTreeVerticalBranchPosition;
+
+      let leftMarginWidth;
+
+      if (false) {
+        ///
+      } else if (verticalBranchPositionsDifference < 0) {
+        leftMarginWidth = -verticalBranchPositionsDifference;
+
+        ruleNameParseTree.addLeftMargin(leftMarginWidth);
+      } else if (verticalBranchPositionsDifference > 0) {
+        leftMarginWidth = +verticalBranchPositionsDifference;
+
+        childNodesParseTree.addLeftMargin(leftMarginWidth);
+      }
+
+      const ruleNameParseTreeWidth = ruleNameParseTree.getWidth(),
+            childNodesParseTreeWidth = childNodesParseTree.getWidth(),
+            widthsDifference = ruleNameParseTreeWidth - childNodesParseTreeWidth;
+
+      let rightMarginWidth;
+
+      if (false) {
+        ///
+      } else if (widthsDifference < 0) {
+        rightMarginWidth = -widthsDifference;
+
+        ruleNameParseTree.addRightMargin(rightMarginWidth);
+      } else if (widthsDifference > 0) {
+        rightMarginWidth = +widthsDifference;
+
+        childNodesParseTree.addRightMargin(rightMarginWidth);
+      }
+
+      ruleNameParseTreeVerticalBranchPosition = ruleNameParseTree.getVerticalBranchPosition();
+
+      const ruleNameParseTreeDepth = ruleNameParseTree.getDepth(),
+            verticalBranchPosition = ruleNameParseTreeVerticalBranchPosition, ///
+            depth = ruleNameParseTreeDepth; ///
+
+      nodeParseTree = VerticalBranchParseTree.fromDepthAndVerticalBranchPosition(NodeParseTree, depth, verticalBranchPosition);
+
+      nodeParseTree.appendToRight(ruleNameParseTree);
+
+      nodeParseTree.appendToBottom(childNodesParseTree);
+    }
+
+    return nodeParseTree;
+  }
+}

package/src/parseTree/string.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import VerticalBranchParseTree from "./verticalBranch";
+
+export default class StringParseTree extends VerticalBranchParseTree {
+  static fromNode(node) {
+    const string = node.asString(),
+          stringLength = string.length,
+          verticalBranchParseTreeWidth = stringLength, ///
+          verticalBranchParseTree = VerticalBranchParseTree.fromWidth(verticalBranchParseTreeWidth),
+          verticalBranchPosition = verticalBranchParseTree.getVerticalBranchPosition(),
+          ruleNameParseTree = VerticalBranchParseTree.fromStringAndVerticalBranchPosition(StringParseTree, string, verticalBranchPosition);
+
+    ruleNameParseTree.appendToTop(verticalBranchParseTree);
+
+    return ruleNameParseTree;
+  }
+}