occam-furtle 2.0.290 → 2.0.291

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-furtle",
   "author": "James Smith",
-  "version": "2.0.290",
+  "version": "2.0.291",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-furtle",
   "description": "Occam's Furtle language.",
@@ -11,7 +11,8 @@
   },
   "dependencies": {
     "necessary": "^17.0.9",
-    "occam-grammars": "^1.3.437"
+    "occam-grammars": "^1.3.439",
+    "occam-parsers": "^23.1.38"
   },
   "devDependencies": {
     "@swc/core": "1.13.20",
@@ -19,8 +20,8 @@
     "express": "^5.1.0",
     "lively-cli": "^2.0.77",
     "mocha": "^6.0.2",
-    "occam-custom-grammars": "^5.0.1340",
-    "occam-entities": "^1.0.444",
+    "occam-custom-grammars": "^5.0.1341",
+    "occam-entities": "^1.0.445",
     "occam-query": "^4.1.142",
     "watchful-cli": "^1.7.67"
   },

package/src/furtle/lexer.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { FurtleLexer as FurtleLexerBase } from "occam-grammars";
+
+export default class FurtleLexer extends FurtleLexerBase {}

package/src/furtle/parser.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import { FurtleParser as FurtleParserBase } from "occam-grammars";
+
+import NonTerminalNode from "../nonTerminalNode";
+import NonTerminalNodeMap from "../nonTerminalNodeMap";
+
+export default class FurtleParser extends FurtleParserBase {
+  static NonTerminalNodeMap = NonTerminalNodeMap;
+
+  static defaultNonTerminalNode = NonTerminalNode;
+}

package/src/index.js

@@ -7,6 +7,7 @@ export { default as Expressions } from "./element/expressions";
 export { default as Log } from "./log";
 export { default as Element } from "./element";
 export { default as FileContext } from "./context/file";
+export { default as NonTerminalNode } from "./nonTerminalNode";
 
 export { default as nodeUtilities } from "./utilities/node";
 export { default as queryUtilities } from "./utilities/query";

package/src/node/assignment/array.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import AssignmentrNode from "../../node/assignment";
+
+export default class ArrayAssignmentNode extends AssignmentrNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ArrayAssignmentNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/assignment/object.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import AssignmentrNode from "../../node/assignment";
+
+export default class ObjectAssignmentNode extends AssignmentrNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ObjectAssignmentNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/assignment/variable.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import AssignmentrNode from "../../node/assignment";
+
+export default class VariableAssignmentNode extends AssignmentrNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(VariableAssignmentNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/assignment.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class AssignmentrNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/assignments/variable.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import AssignmentrsNode from "../../node/assignment";
+
+export default class VariableAssignmentsNode extends AssignmentrsNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(VariableAssignmentsNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/assignments.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class AssignmentrsNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/comparison.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class ComparisonNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ComparisonNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/declaration.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class DeclarationNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(DeclarationNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/every.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class QueryNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(QueryNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/expression.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class ExpressionNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ExpressionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/expressions.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class ExpressionsNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ExpressionsNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/label.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class LabelNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(LabelNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/parameter.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class ParamterNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParamterNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/parameters.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class ParamtersNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParamtersNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/procedure.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class ProcedureNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ProcedureNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/procedureCall.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class ProcedureCallNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ProcedureCallNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/query.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class QueryNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(QueryNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/reduce.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class ReduceNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReduceNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/reference.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class ReferenceNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/returnBlock.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class ReturnBlockNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReturnBlockNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/statement.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class StatementNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/step.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class StepNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/ternary.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class TernaryNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TernaryNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/variable.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-furtle";
+
+export default class VariableNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(VariableNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/nonTerminalNode.js

@@ -0,0 +1,136 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { NonTerminalNode as NonTerminalNodeBase } from "occam-parsers";
+
+const { first } = arrayUtilities;
+
+export default class NonTerminalNode extends NonTerminalNodeBase {
+  getNodeByRuleName(...ruleNames) {
+    const node = this.findChildNode((childNode) => {
+      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+      if (childNodeNonTerminalNode) {
+        const nonTerminalNode = childNode, ///
+              ruleName = nonTerminalNode.getRuleName(),
+              ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+        if (ruleNamesIncludesRuleName) {
+          return true;
+        }
+      }
+    }) || null;
+
+    return node;
+  }
+
+  getNodesByRuleName(...ruleNames) {
+    const nodes = this.filterChildNode((childNode) => {
+      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+      if (childNodeNonTerminalNode) {
+        const nonTerminalNode = childNode, ///
+              ruleName = nonTerminalNode.getRuleName(),
+              ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+        if (ruleNamesIncludesRuleName) {
+          return true;
+        }
+      }
+    });
+
+    return nodes;
+  }
+
+  getLastNodeByRuleName(...ruleNames) {
+    let lastNode = null;
+
+    this.backwardsSomeChildNode((childNode) => {
+      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+      if (childNodeNonTerminalNode) {
+        const nonTerminalNode = childNode, ///
+              ruleName = nonTerminalNode.getRuleName(),
+              ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+        if (ruleNamesIncludesRuleName) {
+          lastNode = childNode; ///
+
+          return true;
+        }
+      }
+    });
+
+    return lastNode;
+  }
+
+  getFirstNodeByRuleName(...ruleNames) {
+    let firstNode = null;
+
+    this.forwardsSomeChildNode((childNode) => {
+      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+      if (childNodeNonTerminalNode) {
+        const nonTerminalNode = childNode, ///
+              ruleName = nonTerminalNode.getRuleName(),
+              ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+        if (ruleNamesIncludesRuleName) {
+          firstNode = childNode; ///
+
+          return true;
+        }
+      }
+    });
+
+    return firstNode;
+  }
+
+  getSingularNodeByRuleName(...ruleNames) {
+    let singularNode = null;
+
+    const nodes = this.filterChildNode((childNode) => {
+            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+            if (childNodeNonTerminalNode) {
+              const nonTerminalNode = childNode, ///
+                    ruleName = nonTerminalNode.getRuleName(),
+                    ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+              if (ruleNamesIncludesRuleName) {
+                return true;
+              }
+            }
+          }),
+          nodesLength = nodes.length;
+
+    if (nodesLength === 1) {
+      const firstNode = first(nodes);
+
+      singularNode = firstNode; ///
+    }
+
+    return singularNode;
+  }
+
+  getDescendantNodesByRuleName(...ruleNames) {
+    const nodes = this.filterDescendantNode((descendantNode) => {
+      const descendantNodeNonTerminalNode = descendantNode.isNonTerminalNode();
+
+      if (descendantNodeNonTerminalNode) {
+        const nonTerminalNode = descendantNode, ///
+              ruleName = nonTerminalNode.getRuleName(),
+              ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+        if (ruleNamesIncludesRuleName) {
+          return true;
+        }
+      }
+    });
+
+    return nodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNodeBase.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+}

package/src/nonTerminalNodeMap.js

@@ -0,0 +1,83 @@
+"use strict";
+
+import StepNode from "./node/step";
+import SomeNode from "./node/some";
+import EveryNode from "./node/every";
+import LabelNode from "./node/label";
+import ErrorNode from "./node/error";
+import QueryNode from "./node/query";
+import BlockNode from "./node/block";
+import ReduceNode from "./node/reduce";
+import TernaryNode from "./node/ternary";
+import VariableNode from "./node/variable";
+import ReferenceNode from "./node/reference";
+import ParameterNode from "./node/parameter";
+import StatementNode from "./node/statement";
+import ProcedureNode from "./node/procedure";
+import ExpressionNode from "./node/expression";
+import ComparisonNode from "./node/comparison";
+import ParametersNode from "./node/parameters";
+import DeclarationNode from "./node/declaration";
+import ExpressionsNode from "./node/expressions";
+import ReturnBlockNode from "./node/returnBlock";
+import ProcedureCallNode from "./node/procedureCall";
+import ArrayAssignmentNode from "./node/assignment/array";
+import ObjectAssignmentNode from "./node/assignment/object";
+import VariableAssignmentNode from "./node/assignment/variable";
+import VariableAssignmentsNode from "./node/assignments/variable";
+
+import { STEP_RULE_NAME,
+         SOME_RULE_NAME,
+         EVERY_RULE_NAME,
+         LABEL_RULE_NAME,
+         ERROR_RULE_NAME,
+         QUERY_RULE_NAME,
+         BLOCK_RULE_NAME,
+         REDUCE_RULE_NAME,
+         TERNARY_RULE_NAME,
+         VARIABLE_RULE_NAME,
+         REFERENCE_RULE_NAME,
+         PARAMETER_RULE_NAME,
+         STATEMENT_RULE_NAME,
+         PROCEDURE_RULE_NAME,
+         EXPRESSION_RULE_NAME,
+         COMPARISON_RULE_NAME,
+         PARAMETERS_RULE_NAME,
+         DECLARATION_RULE_NAME,
+         EXPRESSIONS_RULE_NAME,
+         RETURN_BLOCK_RULE_NAME,
+         PROCEDURE_CALL_RULE_NAME,
+         ARRAY_ASSIGNMENT_RULE_NAME,
+         OBJECT_ASSIGNMENT_RULE_NAME,
+         VARIABLE_ASSIGNMENT_RULE_NAME,
+         VARIABLE_ASSIGNMENTS_RULE_NAME } from "./ruleNames";
+
+const NonTerminalNodeMap = {
+  [STEP_RULE_NAME]: StepNode,
+  [SOME_RULE_NAME]: SomeNode,
+  [EVERY_RULE_NAME]: EveryNode,
+  [LABEL_RULE_NAME]: LabelNode,
+  [ERROR_RULE_NAME]: ErrorNode,
+  [QUERY_RULE_NAME]: QueryNode,
+  [BLOCK_RULE_NAME]: BlockNode,
+  [REDUCE_RULE_NAME]: ReduceNode,
+  [TERNARY_RULE_NAME]: TernaryNode,
+  [VARIABLE_RULE_NAME]: VariableNode,
+  [REFERENCE_RULE_NAME]: ReferenceNode,
+  [PARAMETER_RULE_NAME]: ParameterNode,
+  [STATEMENT_RULE_NAME]: StatementNode,
+  [PROCEDURE_RULE_NAME]: ProcedureNode,
+  [EXPRESSION_RULE_NAME]: ExpressionNode,
+  [COMPARISON_RULE_NAME]: ComparisonNode,
+  [PARAMETERS_RULE_NAME]: ParametersNode,
+  [DECLARATION_RULE_NAME]: DeclarationNode,
+  [EXPRESSIONS_RULE_NAME]: ExpressionsNode,
+  [RETURN_BLOCK_RULE_NAME]: ReturnBlockNode,
+  [PROCEDURE_CALL_RULE_NAME]: ProcedureCallNode,
+  [ARRAY_ASSIGNMENT_RULE_NAME]: ArrayAssignmentNode,
+  [OBJECT_ASSIGNMENT_RULE_NAME]: ObjectAssignmentNode,
+  [VARIABLE_ASSIGNMENT_RULE_NAME]: VariableAssignmentNode,
+  [VARIABLE_ASSIGNMENTS_RULE_NAME]: VariableAssignmentsNode
+};
+
+export default NonTerminalNodeMap;

package/src/ruleNames.js

@@ -0,0 +1,27 @@
+"use strict";
+
+export const STEP_RULE_NAME = "step";
+export const SOME_RULE_NAME = "some";
+export const EVERY_RULE_NAME = "every";
+export const LABEL_RULE_NAME = "label";
+export const ERROR_RULE_NAME = "error";
+export const QUERY_RULE_NAME = "query";
+export const BLOCK_RULE_NAME = "block";
+export const REDUCE_RULE_NAME = "reduce";
+export const TERNARY_RULE_NAME = "ternary";
+export const VARIABLE_RULE_NAME = "variable";
+export const REFERENCE_RULE_NAME = "reference";
+export const PARAMETER_RULE_NAME = "parameter";
+export const STATEMENT_RULE_NAME = "statement";
+export const PROCEDURE_RULE_NAME = "procedure";
+export const EXPRESSION_RULE_NAME = "expression";
+export const COMPARISON_RULE_NAME = "comparison";
+export const PARAMETERS_RULE_NAME = "parameters";
+export const DECLARATION_RULE_NAME = "declaration";
+export const EXPRESSIONS_RULE_NAME = "expressions";
+export const RETURN_BLOCK_RULE_NAME = "returnBlock";
+export const PROCEDURE_CALL_RULE_NAME = "procedureCall";
+export const ARRAY_ASSIGNMENT_RULE_NAME = "arrayAssignment";
+export const OBJECT_ASSIGNMENT_RULE_NAME = "objectAssignment";
+export const VARIABLE_ASSIGNMENT_RULE_NAME = "variableAssignment";
+export const VARIABLE_ASSIGNMENTS_RULE_NAME = "variableAssignments";