occam-dom 4.0.16 → 5.0.2

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;
+  }
+}

package/src/parseTree/verticalBranch.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import { characters } from "necessary";
+
+import ParseTree from "../parseTree";
+
+import { EMPTY_STRING } from "../constants";
+
+const { BAR_CHARACTER } = characters;
+
+export default class VerticalBranchParseTree extends ParseTree {
+  constructor(lines, verticalBranchPosition) {
+    super(lines);
+    
+    this.verticalBranchPosition = verticalBranchPosition;
+  }
+  
+  getVerticalBranchPosition() {
+    return this.verticalBranchPosition;
+  }
+
+  addLeftMargin(leftMarginWidth) {
+    super.addLeftMargin(leftMarginWidth);
+
+    this.verticalBranchPosition += leftMarginWidth; ///
+  }
+
+  static fromWidth(width) {
+    const string = BAR_CHARACTER,
+          verticalBranchPosition = 0,
+          verticalBranchParseTree = VerticalBranchParseTree.fromStringAndVerticalBranchPosition(VerticalBranchParseTree, string, verticalBranchPosition),
+          leftMarginWidth = Math.floor(width/2),
+          rightMarginWidth = width - leftMarginWidth - 1;
+
+    verticalBranchParseTree.addLeftMargin(leftMarginWidth);
+    verticalBranchParseTree.addRightMargin(rightMarginWidth);
+
+    return verticalBranchParseTree;
+  }
+
+  static fromDepthAndVerticalBranchPosition(Class, depth, verticalBranchPosition) {
+    const lines = linesFromDepth(depth),
+          verticalBranchParseTree = new Class(lines, verticalBranchPosition);
+
+    return verticalBranchParseTree;
+  }
+
+  static fromStringAndVerticalBranchPosition(Class, string, verticalBranchPosition) {
+    if (verticalBranchPosition === undefined) {
+      verticalBranchPosition = string;  ///
+
+      string = Class; ///
+
+      Class = ParseTree;  ///
+    }
+    
+    const line = string, ///
+          lines = [
+            line
+          ],
+          verticalBranchParseTree = new Class(lines, verticalBranchPosition);
+
+    return verticalBranchParseTree;
+  }
+}
+
+function linesFromDepth(depth) {
+  const lines = [];
+
+  let index = 0;
+
+  while (index < depth) {
+    lines[index++] = EMPTY_STRING;
+  }
+
+  return lines;
+}

package/src/parseTree.js

@@ -0,0 +1,141 @@
+"use strict";
+
+import { characters, arrayUtilities } from "necessary";
+
+import { EMPTY_STRING } from "./constants";
+
+const { last } = arrayUtilities,
+      { NEW_LINE_CHARACTER, SPACE_CHARACTER } = characters;
+
+export default class ParseTree {
+  constructor(lines) {
+    this.lines = lines;
+  }
+
+  clone() {
+    const lines = this.lines.slice(),  ///
+          parseTree = new ParseTree(lines);
+
+    return parseTree;
+  }
+
+  getWidth() {
+    let width;
+
+    let linesLength = this.lines.length;
+
+    if (linesLength === 0) {
+      width = 0;
+    } else {
+      const lastLine = last(this.lines),
+            lastLineLength = lastLine.length;
+
+      width = lastLineLength; ///
+    }
+
+    return width;
+  }
+
+  getDepth() {
+    const linesLength = this.lines.length,
+          depth = linesLength;  ///
+
+    return depth;
+  }
+
+  forEachLine(callback) {
+    this.lines.forEach(callback);
+  }
+
+  appendToTop(parseTree) {
+    parseTree.forEachLine((line) => {
+      this.lines.unshift(line);
+    });
+  }
+
+  appendToLeft(parseTree) {
+    parseTree.forEachLine((line, index) => {
+      this.lines[index] = line + this.lines[index];
+    });
+  }
+
+  appendToRight(parseTree) {
+    parseTree.forEachLine((line, index) => {
+      this.lines[index] = this.lines[index] + line;
+    });
+  }
+
+  appendToBottom(parseTree) {
+    parseTree.forEachLine((line) => {
+      this.lines.push(line);
+    });
+  }
+
+  addTopMargin(topMarginDepth) {
+    const width = this.getWidth(),
+          topMarginWidth = width,  ///
+          topMarginString = marginStringFromMarginWidth(topMarginWidth);
+
+    for (let index = 0; index < topMarginDepth; index++) {
+      this.lines.unshift(topMarginString);
+    }
+  }
+
+  addLeftMargin(leftMarginWidth) {
+    const leftMarginString = marginStringFromMarginWidth(leftMarginWidth),
+          linesLength = this.lines.length;
+
+    for (let index = 0; index < linesLength; index++) {
+      this.lines[index] = leftMarginString + this.lines[index];
+    }
+  }
+
+  addRightMargin(rightMarginWidth) {
+    const rightMarginString = marginStringFromMarginWidth(rightMarginWidth),
+          linesLength = this.lines.length;
+
+    for (let index = 0; index < linesLength; index++) {
+      this.lines[index] = this.lines[index] + rightMarginString;
+    }
+  }
+
+  addBottomMargin(bottomMarginDepth) {
+    const width = this.getWidth(),
+          bottomMarginWidth = width,  ///
+          bottomMarginString = marginStringFromMarginWidth(bottomMarginWidth);
+
+    for (let index = 0; index < bottomMarginDepth; index++) {
+      this.lines.push(bottomMarginString);
+    }
+  }
+  
+  popLine() { return this.lines.pop(); }
+  
+  shiftLine() { return this.lines.shift(); }
+  
+  pushLine(line) { this.lines.push(line); }
+  
+  unshiftLine(line) { this.lines.unshift(line); }
+
+  asString() {
+    const string = this.lines.reduce((string, line) => {
+      string += line + NEW_LINE_CHARACTER;
+
+      return string;
+    }, EMPTY_STRING);
+
+    return string;
+  }
+}
+
+function marginStringFromMarginWidth(marginWidth, spaceCharacter) {
+  spaceCharacter = spaceCharacter || SPACE_CHARACTER;
+
+  let marginString = EMPTY_STRING;
+
+  for (let index = 0; index < marginWidth; index++) {
+    marginString += spaceCharacter;
+  }
+
+  return marginString;
+}