occam-dom 4.0.15 → 5.0.0

package/src/query.js

@@ -0,0 +1,207 @@
+"use strict";
+
+import { characters } from "necessary";
+
+import Expression from "./expression";
+
+import { push, clear, includes } from "./utilities/array";
+
+const { WILDCARD_CHARACTER } = characters;
+
+export default class Query {
+  constructor(spread, subQuery, ruleNames, tokenTypes, maximumDepth, infiniteDescent, intermediateNodes) {
+    this.spread = spread;
+    this.subQuery = subQuery;
+    this.ruleNames = ruleNames;
+    this.tokenTypes = tokenTypes;
+    this.maximumDepth = maximumDepth;
+    this.infiniteDescent = infiniteDescent;
+    this.intermediateNodes = intermediateNodes;
+  }
+
+  getSpread() {
+    return this.sprea;
+  }
+
+  getSubQuery() {
+    return this.subQuery;
+  }
+
+  getRuleNames() {
+    return this.ruleNames;
+  }
+
+  getTokenTypes() {
+    return this.tokenTypes;
+  }
+
+  getMaximumDepth() {
+    return this.maximumDepth;
+  }
+
+  isInfiniteDescent() {
+    return this.infiniteDescent;
+  }
+
+  getIntermediateNodes() {
+    return this.intermediateNodes;
+  }
+
+  execute(node, depth = 0, maximumDepth = this.maximumDepth) {
+    const nodes = [];
+
+    this.clear();
+
+    this.find(node, depth, maximumDepth);
+
+    this.apply(nodes, depth, maximumDepth);
+
+    return nodes;
+  }
+
+  clear() {
+    clear(this.intermediateNodes);
+  }
+
+  find(node, depth, maximumDepth) {
+    if (depth > maximumDepth) {
+      return;
+    }
+
+    const nodeTerminalNode = node.isTerminalNode(),
+          nodeNonTerminalNode = !nodeTerminalNode;
+
+    let found;
+
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            types = this.tokenTypes,  ///
+            type = terminalNode.getType();
+
+      found = includes(types, type, WILDCARD_CHARACTER);
+    }
+
+    if (nodeNonTerminalNode) {
+      const nonTerminalNode = node, ///
+            ruleName = nonTerminalNode.getRuleName();
+
+      found = includes(this.ruleNames, ruleName, WILDCARD_CHARACTER);
+    }
+
+    if (found) {
+      const intermediateNode = node; ///
+
+      this.intermediateNodes.push(intermediateNode);
+    }
+
+    if (this.infiniteDescent) {
+      if (nodeNonTerminalNode) {
+        depth++;
+
+        const nonTerminalNode = node; ///
+
+        nonTerminalNode.forEachChildNode((childNode) => {
+          this.find(childNode, depth, maximumDepth);
+        });
+      }
+    }
+  }
+
+  apply(nodes, depth, maximumDepth) {
+    this.spread.adjustNodes(this.intermediateNodes);
+
+    if (this.subQuery === null) {
+      push(nodes, this.intermediateNodes);
+    } else {
+      this.intermediateNodes.forEach((intermediateNode) => {
+        const intermediateNodeNonTerminalNode = intermediateNode.isNonTerminalNode();
+
+        if (intermediateNodeNonTerminalNode) {
+          depth++;
+
+          const nonTerminalNode = intermediateNode; ///
+
+          this.subQuery.clear();
+
+          nonTerminalNode.forEachChildNode((childNode) => {
+            this.subQuery.find(childNode, depth, maximumDepth);
+          });
+
+          this.subQuery.apply(nodes, depth, maximumDepth);
+        }
+      });
+    }
+  }
+
+  static fromExpression(expression, maximumDepth = Infinity) {
+    const spread = expression.getSpread(),
+          subQuery = subQueryFromExpression(expression),
+          ruleNames = expression.getRuleNames(),
+          tokenTypes = expression.getTokenTypes(),
+          infiniteDescent = expression.isInfiniteDescent(),
+          intermediateNodes = [],
+          query = new Query(spread, subQuery, ruleNames, tokenTypes, maximumDepth, infiniteDescent, intermediateNodes);
+
+    return query;
+  }
+
+  static fromSubExpression(subExpression) {
+    const spread = subExpression.getSpread(),
+          subQuery = subQueryFromSubExpression(subExpression),
+          ruleNames = subExpression.getRuleNames(),
+          tokenTypes = subExpression.getTokenTypes(),
+          maximumDepth = Infinity,
+          infiniteDescent = subExpression.isInfiniteDescent(),
+          intermediateNodes = [],
+          query = new Query(spread, subQuery, ruleNames, tokenTypes, maximumDepth, infiniteDescent, intermediateNodes);
+
+    return query;
+  }
+
+  static fromExpressionString(expressionString, maximumDepth = Infinity) {
+    let query = null;
+
+    const expression = Expression.fromExpressionString(expressionString);
+
+    if (expression !== null) {
+      const spread = expression.getSpread(),
+            subQuery = subQueryFromExpression(expression),
+            ruleNames = expression.getRuleNames(),
+            tokenTypes = expression.getTokenTypes(),
+            infiniteDescent = expression.isInfiniteDescent(),
+            intermediateNodes = [];
+
+      query = new Query(spread, subQuery, ruleNames, tokenTypes, maximumDepth, infiniteDescent, intermediateNodes);
+    }
+
+    return query;
+  }
+}
+
+function subQueryFromExpression(expression) {
+  let subQuery = null;
+
+  const subExpression = expression.getSubExpression();
+
+  if (subExpression !== null) {
+    const query = Query.fromSubExpression(subExpression);
+
+    subQuery = query; ///
+  }
+
+  return subQuery;
+}
+
+function subQueryFromSubExpression(subExpression) {
+  let subQuery = null;
+
+  subExpression = subExpression.getSubExpression(); ///
+
+  if (subExpression !== null) {
+    const query = Query.fromSubExpression(subExpression);
+
+    subQuery = query; ///
+  }
+
+  return subQuery;
+}

package/src/ruleNames.js

@@ -0,0 +1,12 @@
+"use strict";
+
+export const ERROR_RULE_NAME = "error";
+export const INDEX_RULE_NAME = "index";
+export const UNIQUE_RULE_NAME = "unique";
+export const SPREAD_RULE_NAME = "spread";
+export const END_INDEX_RULE_NAME = "endIndex";
+export const RULE_NAME_RULE_NAME = "ruleName";
+export const TOKEN_TYPE_RULE_NAME = "tokenType";
+export const START_INDEX_RULE_NAME = "startIndex";
+export const SUB_EXPRESSION_RULE_NAME = "subExpression";
+export const INFINITE_DESCENT_RULE_NAME = "infiniteDescent";

package/src/spread.js

@@ -0,0 +1,104 @@
+"use strict";
+
+import { characters } from "necessary";
+
+import { clear, trim, second, third, fourth } from "./utilities/array";
+import { indexFromSpreadNode,
+         uniqueFromSpreadNode,
+         endIndexFromSpreadNode,
+         startIndexFromSpreadNode } from "./utilities/node";
+
+const { EXCLAMATION_MARK_CHARACTER } = characters;
+
+export default class Spread {
+  constructor(startIndex, endIndex, unique) {
+    this.startIndex = startIndex;
+    this.endIndex = endIndex;
+    this.unique = unique;
+  }
+
+  adjustNodes(nodes) {
+    if (this.unique) {
+      const nodesLength = nodes.length;
+
+      if (nodesLength > 1) {
+        clear(nodes);
+      }
+    } else {
+      trim(nodes, this.startIndex, this.endIndex);
+    }
+  }
+
+  static fromNothing() {
+    const startIndex = 0,
+          endIndex = Infinity,
+          unique = false,
+          spread = new Spread(startIndex, endIndex, unique);
+
+    return spread;
+  }
+
+  static fromSpreadNode(spreadNode) {
+    let startIndex = 0,
+        endIndex = Infinity,
+        unique = false;
+
+    if (spreadNode !== null) {
+      const index = indexFromSpreadNode(spreadNode);
+
+      if (index !== null) {
+        startIndex = index; ///
+
+        endIndex = index; ///
+      } else {
+        startIndex = startIndexFromSpreadNode(spreadNode);
+
+        endIndex = endIndexFromSpreadNode(spreadNode);
+      }
+
+      unique = uniqueFromSpreadNode(spreadNode);
+    }
+
+    const spread = new Spread(startIndex, endIndex, unique);
+
+    return spread;
+  }
+
+  static fromSpreadExpression(spreadExpression) {
+    let startIndex = 0,
+        endIndex = Infinity,
+        unique = false;
+
+    if (spreadExpression !== null) {
+      if (spreadExpression === EXCLAMATION_MARK_CHARACTER) {
+        unique = true;
+      } else {
+        const regExp = /\[(-?\d+)?(\.\.\.)?(-?\d+)?]/,
+              matches = spreadExpression.match(regExp),
+              secondMatch = second(matches) || null,
+              thirdMatch = third(matches) || null,
+              fourthMatch = fourth(matches) || null;
+
+        if (secondMatch !== null) {
+          startIndex = parseInt(secondMatch);
+
+          if (thirdMatch === null) {
+            endIndex = startIndex;  ///
+          }
+        }
+
+        if (fourthMatch !== null) {
+          endIndex = parseInt(fourthMatch);
+
+          if (thirdMatch === null) {
+            startIndex = endIndex;  ///
+          }
+        }
+      }
+    }
+
+    const spread = new Spread(startIndex, endIndex, unique);
+
+    return spread;
+  }
+}

package/src/subExpression.js

@@ -0,0 +1,52 @@
+"use strict";
+
+import Path from "./path";
+import Spread from "./spread";
+
+import { pathNodeFromSubExpressionNode, spreadNodeFromSubExpressionNode, subExpressionNodeFromSubExpressionNode } from "./utilities/node";
+
+export default class SubExpression {
+  constructor(path, spread, subExpression) {
+    this.path = path;
+    this.spread = spread;
+    this.subExpression = subExpression;
+  }
+
+  getPath() {
+    return this.path;
+  }
+
+  getSpread() {
+    return this.spread;
+  }
+
+  getSubExpression() {
+    return this.subExpression;
+  }
+
+  getRuleNames() { return this.path.getRuleNames(); }
+
+  getTokenTypes() { return this.path.getTokenTypes(); }
+
+  isInfiniteDescent() { return this.path.isInfiniteDescent(); }
+
+  static fromSubExpressionNode(subExpressionNode) {
+    let subExpression = null;
+
+    if (subExpressionNode !== null) {
+      const pathNode = pathNodeFromSubExpressionNode(subExpressionNode),
+            spreadNode = spreadNodeFromSubExpressionNode(subExpressionNode);
+
+      subExpressionNode = subExpressionNodeFromSubExpressionNode(subExpressionNode);  ///
+
+      const path = Path.fromPathNode(pathNode),
+            spread = Spread.fromSpreadNode(spreadNode);
+
+      subExpression = SubExpression.fromSubExpressionNode(subExpressionNode);
+
+      subExpression = new SubExpression(path, spread, subExpression); ///
+    }
+
+    return subExpression;
+  }
+}

package/src/utilities/array.js

@@ -0,0 +1,30 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+export const { clear, push, first, second, third, fourth, fifth, last } = arrayUtilities;
+
+export function trim(array, startIndex, endIndex) {
+  if (startIndex < 0) {
+    const length = array.length; ///
+
+    startIndex = length + startIndex; ///
+
+    endIndex = length + endIndex; ///
+  }
+
+  if (endIndex !== Infinity) {
+    const start = endIndex + 1;
+
+    array.splice(start);
+  }
+
+  const start = 0,
+        deleteCount = startIndex; ///
+
+  array.splice(start, deleteCount);
+}
+
+export function includes(array, ...elements) {
+  return elements.some((element) => array.includes(element));
+}