occam-verify-cli 1.0.192 → 1.0.199

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

package/src/node/premise.js

@@ -1,30 +1,20 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeStatementNode, isNodeProcedureCallNode } from "../utilities/node";
+import { STATEMENT_RULE_NAME, PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
 
 export default class PremiseNode 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;
   }
 
   getProcedureCallNode() {
-    const procedureCallNode = this.findChildNode((childNode) => {
-      const childNodeProcedureCallNode = isNodeProcedureCallNode(childNode);
-
-      if (childNodeProcedureCallNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = PROCEDURE_CALL_RULE_NAME,
+          procedureCallNode = this.getNodeByRuleName(ruleName);
 
     return procedureCallNode;
   }

package/src/node/procedureCall.js

@@ -1,30 +1,20 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeParameterNode, isNodeReferenceNode } from "../utilities/node";
+import { REFERENCE_RULE_NAME, PARAMETER_RULE_NAME } from "../ruleNames";
 
 export default class ProcedureCallNode extends NonTerminalNode {
   getReferenceNode() {
-    const referenceNode = this.findChildNode((childNode) => {
-      const childNodeReferenceNode = isNodeReferenceNode(childNode);
-
-      if (childNodeReferenceNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = REFERENCE_RULE_NAME,
+          referenceNode = this.getNodeByRuleName(ruleName);
 
     return referenceNode;
   }
 
   getParameterNodes() {
-    const parameterNodes = this.filterChildNode((childNode) => {
-      const childNodeParameterNode = isNodeParameterNode(childNode);
-
-      if (childNodeParameterNode) {
-        return true;
-      }
-    });
+    const ruleName = PARAMETER_RULE_NAME,
+          parameterNodes = this.getNodesByRuleName(ruleName);
 
     return parameterNodes;
   }

package/src/node/proof.js

@@ -1,18 +1,13 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeDerivationNode } from "../utilities/node";
+import { DERIVATION_RULE_NAME } from "../ruleNames";
 
 export default class ProofNode extends NonTerminalNode {
   getDerivationNode() {
-    const derivationNode = this.findChildNode((childNode) => {
-      const childNodeDerivationNode = isNodeDerivationNode(childNode);
-
-      if (childNodeDerivationNode) {
-        return true;
-      }
-    });
+    const ruleName = DERIVATION_RULE_NAME,
+          derivationNode = this.getNodeByRuleName(ruleName);
 
     return derivationNode;
   }

package/src/node/property.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
 import { SINGLE_SPACE } from "../constants";
 

package/src/node/propertyRelation.js

@@ -1,29 +1,20 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
-import { isNodeTermNode, isNodePropertyNode } from "../utilities/node";
+import NonTerminalNode from "../node/nonTerminal";
+
+import { TERM_RULE_NAME, PROPERTY_RULE_NAME } from "../ruleNames";
 
 export default class PropertyRelationNode 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;
   }
 
   getPropertyNode() {
-    const propertyNode = this.findChildNode((childNode) => {
-      const childNodePropertyNode = isNodePropertyNode(childNode);
-
-      if (childNodePropertyNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = PROPERTY_RULE_NAME,
+          propertyNode = this.getNodeByRuleName(ruleName);
 
     return propertyNode;
   }

package/src/node/reference.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 ReferenceNode 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/rule.js

@@ -1,7 +1,44 @@
 "use strict";
 
-import TopLevelMetaAssertionNode from "../node/topLevelMetaAssertion";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class RuleNode extends TopLevelMetaAssertionNode {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(RuleNode, ruleName, childNodes, opacity, precedence); }
+import {  PROOF_RULE_NAME, PREMISE_RULE_NAME, CONCLUSION_RULE_NAME, PARENTHESISED_LABELS_RULE_NAME } from "../ruleNames";
+
+export default class RuleNode extends NonTerminalNode {
+  getLabelNodes() {
+    const parenthesisedLabelsNode = this.getParenthesisedLabelsNode(),
+          labelNodes = parenthesisedLabelsNode.getLabelNodes();
+
+    return labelNodes;
+  }
+
+  getProofNode() {
+    const ruleName = PROOF_RULE_NAME,
+          proofNode = this.getNodeByRuleName(ruleName);
+
+    return proofNode;
+  }
+
+  getPremiseNodes() {
+    const ruleName = PREMISE_RULE_NAME,
+          premiseNodes = this.getNodesByRuleName(ruleName);
+
+    return premiseNodes;
+  }
+
+  getConclusionNode() {
+    const ruleName = CONCLUSION_RULE_NAME,
+          conclusionNode = this.getNodeByRuleName(ruleName);
+
+    return conclusionNode;
+  }
+
+  getParenthesisedLabelsNode() {
+    const ruleName = PARENTHESISED_LABELS_RULE_NAME,
+          parenthesisedLabelsNode = this.getNodeByRuleName(ruleName);
+
+    return parenthesisedLabelsNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(RuleNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/statement.js

@@ -1,112 +1,155 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
-
-import { isNodeTermNode,
-         isNodeFrameNode,
-         isNodeEqualityNode,
-         isNodeJudgementNode,
-         isNodeMetavariableNode,
-         isNodeTypeAssertionNode,
-         isNodeSubproofAssertionNode,
-         isNodePropertyAssertionNode } from "../utilities/node";
+import NonTerminalNode from "../node/nonTerminal";
+
+import { TERM_RULE_NAME,
+         FRAME_RULE_NAME,
+         EQUALITY_RULE_NAME,
+         JUDGEMENT_RULE_NAME,
+         METAVARIABLE_RULE_NAME,
+         META_ARGUMENT_RULE_NAME,
+         TYPE_ASSERTION_RULE_NAME,
+         DEFINED_ASSERTION_RULE_NAME,
+         TERM_SUBSTITUTION_RULE_NAME,
+         PROPERTY_ASSERTION_RULE_NAME,
+         SUBPROOF_ASSERTION_RULE_NAME,
+         FRAME_SUBSTITUTION_RULE_NAME,
+         SATISFIES_ASSERTION_RULE_NAME,
+         CONTAINED_ASSERTION_RULE_NAME,
+         REFERENCE_SUBSTITUTION_RULE_NAME,
+         STATEMENT_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
 export default class StatementNode extends NonTerminalNode {
   getTermNodes() {
-    const termNodes = this.filterDescendantNode((descendantNode) => {
-      const descendantNodeTermNode = isNodeTermNode(descendantNode);
-
-      if (descendantNodeTermNode) {
-        return true;
-      }
-    });
+    const ruleName = TERM_RULE_NAME,
+          termNodes = this.getDescendantNodesByRuleName(ruleName);
 
     return termNodes;
   }
 
   getFrameNodes() {
-    const frameNodes = this.filterDescendantNode((descendantNode) => {
-      const descendantNodeFrameNode = isNodeFrameNode(descendantNode);
-
-      if (descendantNodeFrameNode) {
-        return true;
-      }
-    });
+    const ruleName = FRAME_RULE_NAME,
+          frameNodes = this.getDescendantNodesByRuleName(ruleName);
 
     return frameNodes;
   }
 
   getEqualityNode() {
-    const equalityNode = this.findChildNode((childNode) => {
-      const childNodeEqualityNode = isNodeEqualityNode(childNode);
-
-      if (childNodeEqualityNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = EQUALITY_RULE_NAME,
+          equalityNode = this.getNodeByRuleName(ruleName);
 
     return equalityNode;
   }
 
   getJudgementNode() {
-    const judgementNode = this.findChildNode((childNode) => {
-      const childNodeJudgementNode = isNodeJudgementNode(childNode);
-
-      if (childNodeJudgementNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = JUDGEMENT_RULE_NAME,
+          judgementNode = this.getNodeByRuleName(ruleName);
 
     return judgementNode;
   }
 
   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;
   }
 
   getTypeAssertionNode() {
-    const typeAssertionNode = this.findChildNode((childNode) => {
-      const childNodeTypeAssertionNode = isNodeTypeAssertionNode(childNode);
-
-      if (childNodeTypeAssertionNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = TYPE_ASSERTION_RULE_NAME,
+          typeAssertionNode = this.getNodeByRuleName(ruleName);
 
     return typeAssertionNode;
   }
 
-  getSubproofAssertionNode() {
-    const subproofAssertionNode = this.findChildNode((childNode) => {
-      const childNodeSubproofAssertionNode = isNodeSubproofAssertionNode(childNode);
+  getDefinedAssertionNode() {
+    const ruleName = DEFINED_ASSERTION_RULE_NAME,
+          definedAssertionNode = this.getNodeByRuleName(ruleName);
 
-      if (childNodeSubproofAssertionNode) {
-        return true;
-      }
-    }) || null;
+    return definedAssertionNode;
+  }
+
+  getTermSubstitutionNode() {
+    const ruleName = TERM_SUBSTITUTION_RULE_NAME,
+          termSubstitutionNode = this.getNodeByRuleName(ruleName);
+
+    return termSubstitutionNode;
+  }
+
+  getFrameSubstitutionNode() {
+    const ruleName = FRAME_SUBSTITUTION_RULE_NAME,
+          frameSubstitutionNode = this.getNodeByRuleName(ruleName);
+
+    return frameSubstitutionNode;
+  }
+
+  getSubproofAssertionNode() {
+    const ruleName = SUBPROOF_ASSERTION_RULE_NAME,
+          subproofAssertionNode = this.getNodeByRuleName(ruleName);
 
     return subproofAssertionNode;
   }
 
   getPropertyAssertionNode() {
-    const propertyAssertionNode = this.findChildNode((childNode) => {
-      const childNodePropertyAssertionNode = isNodePropertyAssertionNode(childNode);
-
-      if (childNodePropertyAssertionNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = PROPERTY_ASSERTION_RULE_NAME,
+          propertyAssertionNode = this.getNodeByRuleName(ruleName);
 
     return propertyAssertionNode;
   }
 
+  getSingularStatementNode() {
+    let singularStatementNode = null;
+
+    const singularMetaArgumentNode = this.getSingularMetaArgumentNode();
+
+    if (singularMetaArgumentNode !== null) {
+      singularStatementNode = singularMetaArgumentNode.getSingularStatementNode();
+    }
+
+    return singularStatementNode;
+  }
+
+  getContainedAssertionNode() {
+    const ruleName = CONTAINED_ASSERTION_RULE_NAME,
+          containedAssertionNode = this.getNodeByRuleName(ruleName);
+
+    return containedAssertionNode;
+  }
+
+  getSatisfiedAssertionNode() {
+    const ruleName = SATISFIES_ASSERTION_RULE_NAME,
+          satisfiedAssertionNode = this.getNodeByRuleName(ruleName);
+
+    return satisfiedAssertionNode;
+  }
+
+  getSingularMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          singularMetavariableNode = this.getSingularTNodeByRuleName(ruleName);
+
+    return singularMetavariableNode;
+  }
+
+  getSingularMetaArgumentNode() {
+    const ruleName = META_ARGUMENT_RULE_NAME,
+          singularMetaArgumentNode = this.getNodeByRuleName(ruleName);
+
+    return singularMetaArgumentNode;
+  }
+
+  getReferenceSubstitutionNode() {
+    const ruleName = REFERENCE_SUBSTITUTION_RULE_NAME,
+      referenceSubstitutionNode = this.getNodeByRuleName(ruleName);
+
+    return referenceSubstitutionNode;
+  }
+
+  getStatementSubstitutionNode() {
+    const ruleName = STATEMENT_SUBSTITUTION_RULE_NAME,
+          statementSubstitutionNode = this.getNodeByRuleName(ruleName);
+
+    return statementSubstitutionNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/step.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeStatementNode, isNodeReferenceNode } from "../utilities/node";
+import { REFERENCE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
 
 export default class StepNode extends NonTerminalNode {
   isStepNode() {
@@ -18,25 +18,15 @@ export default class StepNode 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;
   }
 
   getReferenceNode() {
-    const referenceNode = this.findChildNode((childNode) => {
-      const childNodeReferenceNode = isNodeReferenceNode(childNode);
-
-      if (childNodeReferenceNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = REFERENCE_RULE_NAME,
+          referenceNode = this.getNodeByRuleName(ruleName);
 
     return referenceNode;
   }

package/src/node/subDerivation.js

@@ -1,19 +1,23 @@
 "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 SubDerivationNode extends NonTerminalNode {
-  getStepOrSubproofNodes() {
-    const stepOrSubproofNodes = this.filterChildNode((childNode) => {
-      const childNodeStepNode = isNodeStepNode(childNode),
-            childNodeSubproofNode = isNodeSubproofNode(childNode);
+  getLastStepNode() {
+    const ruleName = STEP_RULE_NAME,
+          lastStepNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastStepNode;
+  }
 
-      if (childNodeStepNode || childNodeSubproofNode) {
-        return true;
-      }
-    });
+  getStepOrSubproofNodes() {
+    const ruleNames = [
+            STEP_RULE_NAME,
+            SUBPROOF_RULE_NAME,
+          ],
+          stepOrSubproofNodes = this.getNodesByRuleName(...ruleNames);
 
     return stepOrSubproofNodes;
   }

package/src/node/subproof.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeSuppositionNode, isNodeSubDerivationNode } from "../utilities/node";
+import { SUPPOSITION_RULE_NAME, SUB_DERIVATION_RULE_NAME } from "../ruleNames";
 
 export default class SubproofNode extends NonTerminalNode {
   isStepNode() {
@@ -17,26 +17,23 @@ export default class SubproofNode extends NonTerminalNode {
     return subproofNode;
   }
 
-  getSubDerivationNode() {
-    const subDerivationNode = this.findChildNode((childNode) => {
-      const childNodeSubDerivationNode = isNodeSubDerivationNode(childNode);
+  getLastStepNode() {
+    const subDerivationNode = this.getSubDerivationNode(),
+          lastStepNode = subDerivationNode.getLastStepNode();
 
-      if (childNodeSubDerivationNode) {
-        return true;
-      }
-    }) || null;
+    return lastStepNode;
+  }
+
+  getSubDerivationNode() {
+    const ruleName = SUB_DERIVATION_RULE_NAME,
+          subDerivationNode = this.getNodeByRuleName(ruleName);
 
     return subDerivationNode;
   }
 
   getSuppositionNodes() {
-    const suppositionNodes = this.filterChildNode((childNode) => {
-      const childNodeSuppositionNode = isNodeSuppositionNode(childNode);
-
-      if (childNodeSuppositionNode) {
-        return true;
-      }
-    });
+    const ruleName = SUPPOSITION_RULE_NAME,
+          suppositionNodes = this.getNodesByRuleName(ruleName);
 
     return suppositionNodes;
   }

package/src/node/substitution/frame.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../../node/nonTerminal";
+
+import { FRAME_RULE_NAME } from "../../ruleNames";
+
+export default class FrameSubstitutionNode extends NonTerminalNode {
+  getLastFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          lastFrameNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastFrameNode;
+  }
+
+  getFirstFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          firstFrameNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstFrameNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(FrameSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/substitution/reference.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../../node/nonTerminal";
+
+import { REFERENCE_RULE_NAME } from "../../ruleNames";
+
+export default class ReferenceSubstitutionNode extends NonTerminalNode {
+  getLastReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          lastReferenceNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastReferenceNode;
+  }
+
+  getFirstReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          firstReferenceNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstReferenceNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/substitution/statement.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../../node/nonTerminal";
+
+import { STATEMENT_RULE_NAME } from "../../ruleNames";
+
+export default class StatementSubstitutionNode extends NonTerminalNode {
+  getLastStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          lastStatementNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastStatementNode;
+  }
+
+  getFirstStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          firstStatementNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstStatementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}