occam-verify-cli 1.0.192 → 1.0.198

package/src/node/declaration/type.js

@@ -1,29 +1,11 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
 import { PROVISIONAL } from "../../constants";
-import { isNodeTypeNode } from "../../utilities/node";
+import { TYPE_RULE_NAME, TYPES_RULE_NAME } from "../../ruleNames";
 
 export default class TypeDeclarationNode extends NonTerminalNode {
-  getTypeName() {
-    let typeName = null;
-
-    this.someChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
-
-      if (childNodeTypeNode) {
-        const typeNode = childNode;  ///
-
-        typeName = typeNode.getTypeName();
-
-        return true;
-      }
-    });
-
-    return typeName;
-  }
-
   isProvisional() {
     let provisional = false;
 
@@ -31,7 +13,7 @@ export default class TypeDeclarationNode extends NonTerminalNode {
       const childNodeTerminalNode = childNode.isTerminalNode();
 
       if (childNodeTerminalNode) {
-        const terminalNode = childNode, ///
+        const terminalNode = childNode,
               content = terminalNode.getContent(),
               contentProvisional = (content === PROVISIONAL);
 
@@ -46,18 +28,42 @@ export default class TypeDeclarationNode extends NonTerminalNode {
     return provisional;
   }
 
+  getTypeName() {
+    let typeName = null;
+
+    const typeNode = this.getTypeNode();
+
+    if (typeNode !== null) {
+      typeName = typeNode.getTypeName();
+    }
+
+    return typeName;
+  }
+
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
+
+    return typeNode;
+  }
+
+  getTypesNode() {
+    const ruleName = TYPES_RULE_NAME,
+          typesNode = this.getNodeByRuleName(ruleName);
+
+    return typesNode;
+  }
+
   getSuperTypeNodes() {
-    const typeNodes = this.filterChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
+    let superTypeNodes = [];
 
-      if (childNodeTypeNode) {
-        return true;
-      }
-    });
+    const typesNode = this.getTypesNode();
 
-    typeNodes.pop();
+    if (typesNode !== null) {
+      const typeNodes = typesNode.getTypeNodes();
 
-    const superTypeNodes = typeNodes; ///
+      superTypeNodes = typeNodes; ///
+    }
 
     return superTypeNodes;
   }

package/src/node/declaration/variable.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../../node/nonTerminal";
 
 import { PROVISIONALLY } from "../../constants";
-import { isNodeTypeNode, isNodeVariableNode } from "../../utilities/node";
+import { TYPE_RULE_NAME, VARIABLE_RULE_NAME } from "../../ruleNames";
 
 export default class VariableDeclarationNode extends NonTerminalNode {
   isProvisional() {
@@ -29,25 +29,15 @@ export default class VariableDeclarationNode extends NonTerminalNode {
   }
 
   getTypeNode() {
-    const typeNode = this.findChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
-
-      if (childNodeTypeNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
     return typeNode;
   }
 
   getVariableNode() {
-    const variableNode = this.findChildNode((childNode) => {
-      const childNodeVariableNode = isNodeVariableNode(childNode);
-
-      if (childNodeVariableNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNode = this.getNodeByRuleName(ruleName);
 
     return variableNode;
   }

package/src/node/declaration.js

@@ -1,30 +1,20 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeStatementNode, isNodeMetavariableNode } from "../utilities/node";
+import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class DeclarationNode extends NonTerminalNode {
   getStatementNode() {
-    const statementNode = this.findChildNode((childNode) => {
-      const childNodeStatementNode = isNodeStatementNode(childNode);
-
-      if (childNodeStatementNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
 
     return statementNode;
   }
 
   getMetavariableNode() {
-    const metavariableNode = this.findChildNode((childNode) => {
-      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
-
-      if (childNodeMetavariableNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
 
     return metavariableNode;
   }

package/src/node/deduction.js

@@ -1,18 +1,13 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeStatementNode } from "../utilities/node";
+import { STATEMENT_RULE_NAME } from "../ruleNames";
 
 export default class DeductionNode extends NonTerminalNode {
   getStatementNode() {
-    const statementNode = this.findChildNode((childNode) => {
-      const childNodeStatementNode = isNodeStatementNode(childNode);
-
-      if (childNodeStatementNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
 
     return statementNode;
   }

package/src/node/derivation.js

@@ -1,19 +1,16 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeStepNode, isNodeSubproofNode } from "../utilities/node";
+import { STEP_RULE_NAME, SUBPROOF_RULE_NAME } from "../ruleNames";
 
 export default class DerivationNode extends NonTerminalNode {
   getStepOrSubproofNodes() {
-    const stepOrSubproofNodes = this.filterChildNode((childNode) => {
-      const childNodeStepNode = isNodeStepNode(childNode),
-            childNodeSubproofNode = isNodeSubproofNode(childNode);
-
-      if (childNodeStepNode || childNodeSubproofNode) {
-        return true;
-      }
-    });
+    const ruleNames = [
+            STEP_RULE_NAME,
+            SUBPROOF_RULE_NAME,
+          ],
+          stepOrSubproofNodes = this.getNodesByRuleName(...ruleNames);
 
     return stepOrSubproofNodes;
   }

package/src/node/equality.js

@@ -1,32 +1,33 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import { arrayUtilities } from "necessary";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { TERM_RULE_NAME } from "../ruleNames";
+
+const { first, last } = arrayUtilities;
 
 export default class EqualityNode extends NonTerminalNode {
-  getLeftTermNode() {
-    let leftTermNode;
+  getTermNodes() {
+    const ruleName = TERM_RULE_NAME,
+          termNodes = this.getNodeByRuleName(ruleName);
 
-    this.someChildNode((childNode, index) => {
-      if (index === 0) {
-        leftTermNode = childNode; ///
+    return termNodes;
+  }
 
-        return true;
-      }
-    });
+  getLeftTermNode() {
+    const termNodes = this.getTermNodes(),
+          firstTermNode = first(termNodes),
+          leftTermNode = firstTermNode; ///
 
     return leftTermNode;
   }
 
   getRightTermNode() {
-    let rightTermNode;
-
-    this.someChildNode((childNode, index) => {
-      if (index === 2) {
-        rightTermNode = childNode; ///
-
-        return true;
-      }
-    });
+    const termNodes = this.getTermNodes(),
+          firstTermNode = last(termNodes),
+          rightTermNode = firstTermNode; ///
 
     return rightTermNode;
   }

package/src/node/error.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
 export default class ErrorNode extends NonTerminalNode {
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ErrorNode, ruleName, childNodes, opacity, precedence); }

package/src/node/frame.js

@@ -1,54 +1,27 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeDeclarationNode, isNodeMetavariableNode } from "../utilities/node";
-
-const { first } = arrayUtilities;
+import { DECLARATION_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class FrameNode extends NonTerminalNode {
   getDeclarationNodes() {
-    const declarationNodes = this.filterChildNode((childNode) => {
-      const childNodeDeclarationNode = isNodeDeclarationNode(childNode);
-
-      if (childNodeDeclarationNode) {
-        return true;
-      }
-    });
+    const ruleName = DECLARATION_RULE_NAME,
+          declarationNodes = this.getNodesByRuleName(ruleName);
 
     return declarationNodes;
   }
 
   getMetavariableNodes() {
-    const metavariableNodes = this.filterChildNode((childNode) => {
-      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
-
-      if (childNodeMetavariableNode) {
-        return true;
-      }
-    });
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNodes = this.getNodesByRuleName(ruleName);
 
     return metavariableNodes;
   }
 
   getSingularMetavariableNode() {
-    let singularMetavariableNode = null;
-
-    const metavariableNodes = this.filterChildNode((childNode) => {
-            const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
-
-            if (!childNodeMetavariableNode) {
-              return true;
-            }
-          }),
-          metavariableNodesLength = metavariableNodes.length;
-
-    if (metavariableNodesLength === 1) {
-      const firstMetavariableNode = first(metavariableNodes);
-
-      singularMetavariableNode = firstMetavariableNode; ///
-    }
+    const ruleName = METAVARIABLE_RULE_NAME,
+          singularMetavariableNode = this.getSingularTNodeByRuleName(ruleName);
 
     return singularMetavariableNode;
   }

package/src/node/judgement.js

@@ -1,32 +1,22 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeFrameNode, isNodeDeclarationNode } from "../utilities/node";
+import { FRAME_RULE_NAME, DECLARATION_RULE_NAME } from "../ruleNames";
 
 export default class JudgementNode extends NonTerminalNode {
   getFrameNode() {
-    const frameNode = this.findChildNode((childNode) => {
-      const childNodeFrameNode = isNodeFrameNode(childNode);
-
-      if (childNodeFrameNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = FRAME_RULE_NAME,
+          frameNode = this.getNodesByRuleName(ruleName);
 
     return frameNode;
   }
 
-  getDeclarationNode() {
-    const declarationNode = this.findChildNode((childNode) => {
-      const childNodeDeclarationNode = isNodeDeclarationNode(childNode);
-
-      if (childNodeDeclarationNode) {
-        return true;
-      }
-    }) || null;
+  getDeclarationNodes() {
+    const ruleName = DECLARATION_RULE_NAME,
+          declarationNodes = this.getNodesByRuleName(ruleName);
 
-    return declarationNode;
+    return declarationNodes;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(JudgementNode, ruleName, childNodes, opacity, precedence); }

package/src/node/label.js

@@ -1,18 +1,13 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeMetavariableNode } from "../utilities/node";
+import { METAVARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class LabelNode extends NonTerminalNode {
   getMetavariableNode() {
-    const metavariableNode = this.findChildNode((childNode) => {
-      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
-
-      if (childNodeMetavariableNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
 
     return metavariableNode;
   }

package/src/node/labels.js

@@ -1,18 +1,13 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeLabelNode } from "../utilities/node";
+import { LABEL_RULE_NAME } from "../ruleNames";
 
 export default class LabelsNode extends NonTerminalNode {
   getLabelNodes() {
-    const labelNodes = this.filterChildNode((childNode) => {
-      const childNodeLabelNode = isNodeLabelNode(childNode);
-
-      if (childNodeLabelNode) {
-        return true;
-      }
-    });
+    const ruleName = LABEL_RULE_NAME,
+          labelNodes = this.getNodesByRuleName(ruleName);
 
     return labelNodes;
   }

package/src/node/metaArgument.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class MetaArgumentNode extends NonTerminalNode {
+  getSingularStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          singularStatementNode = this.getNodeByRuleName(ruleName);
+
+    return singularStatementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaArgumentNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/metaType.js

@@ -1,12 +1,8 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
 export default class MetaTypeNode extends NonTerminalNode {
-  getTypeNode() {
-
-  }
-
   getMetaTypeName() {
     let metaTypeName;
 

package/src/node/metavariable.js

@@ -1,30 +1,20 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeTermNode, isNodeTypeNode } from "../utilities/node";
+import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../ruleNames";
 
 export default class MetavariableNode extends NonTerminalNode {
   getTermNode() {
-    const termNode = this.findChildNode((childNode) => {
-      const childNodeTermNode = isNodeTermNode(childNode);
-
-      if (childNodeTermNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
 
     return termNode;
   }
 
   getTypeNode() {
-    const typeNode = this.findChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
-
-      if (childNodeTypeNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
     return typeNode;
   }

package/src/node/nonTerminal.js

@@ -0,0 +1,112 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { NonTerminalNode as NonTerminalNodeBase } from "occam-parsers";
+
+const { first, forwardsFind, backwardsFind } = 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) {
+    const childNodes = this.getChildNodes(),
+          lastNode = backwardsFind(childNodes, (childNode) => {
+            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+            if (childNodeNonTerminalNode) {
+              const nonTerminalNode = childNode, ///
+                    ruleName = nonTerminalNode.getRuleName(),
+                    ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+              if (ruleNamesIncludesRuleName) {
+                return true;
+              }
+            }
+          }) || null;
+
+    return lastNode;
+  }
+
+  getFirstNodeByRuleName(...ruleNames) {
+    const childNodes = this.getChildNodes(),
+          firstNode = forwardsFind(childNodes, (childNode) => {
+            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+            if (childNodeNonTerminalNode) {
+              const nonTerminalNode = childNode, ///
+                    ruleName = nonTerminalNode.getRuleName(),
+                    ruleNamesIncludesRuleName = ruleNames.includes(ruleName);
+
+              if (ruleNamesIncludesRuleName) {
+                return true;
+              }
+            }
+          }) || null;
+
+    return firstNode;
+  }
+
+  getSingularTNodeByRuleName(...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;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNodeBase.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/parameter.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
 export default class ParameterNode extends NonTerminalNode {
   getParameterName() {

package/src/node/parenthesisedLabel.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { LABEL_RULE_NAME } from "../ruleNames";
+
+export default class ParenthesisedLabelNode extends NonTerminalNode {
+  getLabelNode() {
+    const ruleName = LABEL_RULE_NAME,
+          labelNode = this.getNodeByRuleName(ruleName);
+
+    return labelNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParenthesisedLabelNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/parenthesisedLabels.js

@@ -1,25 +1,20 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeLabelsNode } from "../utilities/node";
+import { LABELS_RULE_NAME } from "../ruleNames";
 
 export default class ParenthesisedLabelsNode extends NonTerminalNode {
   getLabelNodes() {
     const labelsNode = this.getLabelsNode(),
-           labelNodes = labelsNode.getLabelNodes();
+          labelNodes = labelsNode.getLabelNodes();
 
     return labelNodes;
   }
 
   getLabelsNode() {
-    const labelsNode = this.findChildNode((childNode) => {
-      const childNodeLabelsNode = isNodeLabelsNode(childNode);
-
-      if (childNodeLabelsNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = LABELS_RULE_NAME,
+          labelsNode = this.getNodeByRuleName(ruleName);
 
     return labelsNode;
   }