occam-verify-cli 1.0.185 → 1.0.192

package/src/node/metavariable.js

@@ -1,19 +1,52 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
+
+import { isNodeTermNode, isNodeTypeNode } from "../utilities/node";
+
+export default class MetavariableNode extends NonTerminalNode {
+  getTermNode() {
+    const termNode = this.findChildNode((childNode) => {
+      const childNodeTermNode = isNodeTermNode(childNode);
+
+      if (childNodeTermNode) {
+        return true;
+      }
+    }) || null;
+
+    return termNode;
+  }
+
+  getTypeNode() {
+    const typeNode = this.findChildNode((childNode) => {
+      const childNodeTypeNode = isNodeTypeNode(childNode);
+
+      if (childNodeTypeNode) {
+        return true;
+      }
+    }) || null;
+
+    return typeNode;
+  }
 
-export default class MetavariableNode extends Node {
   getMetavariableName() {
-    const metavariableName = this.fromFirstChildNode((firstChildNode) => {
-      const nameTerminalNode = firstChildNode,  ///
-            content = nameTerminalNode.getContent(),
-            metavariableName = content; ///
+    let metaVariableName;
+
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+               content = terminalNode.getContent();
+
+        metaVariableName = content; ///
 
-      return metavariableName;
+        return true;
+      }
     });
 
-    return metavariableName;
+    return metaVariableName;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(MetavariableNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetavariableNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/parameter.js

@@ -1,7 +1,24 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class ParameterNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ParameterNode, ruleName, childNodes, opacity, precedence); }
+export default class ParameterNode extends NonTerminalNode {
+  getParameterName() {
+    let parameterName;
+
+    this.someChildNode((childNode, index) => {
+      const nameTerminalNode = childNode, ///
+            content = nameTerminalNode.getContent();
+
+      parameterName = content;  ///
+
+      if (index === 0) {
+        return true;
+      }
+    });
+
+    return parameterName;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParameterNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/parenthesisedLabels.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-parsers";
+
+import { isNodeLabelsNode } from "../utilities/node";
+
+export default class ParenthesisedLabelsNode extends NonTerminalNode {
+  getLabelNodes() {
+    const labelsNode = this.getLabelsNode(),
+           labelNodes = labelsNode.getLabelNodes();
+
+    return labelNodes;
+  }
+
+  getLabelsNode() {
+    const labelsNode = this.findChildNode((childNode) => {
+      const childNodeLabelsNode = isNodeLabelsNode(childNode);
+
+      if (childNodeLabelsNode) {
+        return true;
+      }
+    }) || null;
+
+    return labelsNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParenthesisedLabelsNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/premise.js

@@ -1,7 +1,33 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class PremiseNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(PremiseNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeStatementNode, isNodeProcedureCallNode } from "../utilities/node";
+
+export default class PremiseNode extends NonTerminalNode {
+  getStatementNode() {
+    const statementNode = this.findChildNode((childNode) => {
+      const childNodeStatementNode = isNodeStatementNode(childNode);
+
+      if (childNodeStatementNode) {
+        return true;
+      }
+    }) || null;
+
+    return statementNode;
+  }
+
+  getProcedureCallNode() {
+    const procedureCallNode = this.findChildNode((childNode) => {
+      const childNodeProcedureCallNode = isNodeProcedureCallNode(childNode);
+
+      if (childNodeProcedureCallNode) {
+        return true;
+      }
+    }) || null;
+
+    return procedureCallNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PremiseNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/procedureCall.js

@@ -1,7 +1,33 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class ProcedureCallNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ProcedureCallNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeParameterNode, isNodeReferenceNode } from "../utilities/node";
+
+export default class ProcedureCallNode extends NonTerminalNode {
+  getReferenceNode() {
+    const referenceNode = this.findChildNode((childNode) => {
+      const childNodeReferenceNode = isNodeReferenceNode(childNode);
+
+      if (childNodeReferenceNode) {
+        return true;
+      }
+    }) || null;
+
+    return referenceNode;
+  }
+
+  getParameterNodes() {
+    const parameterNodes = this.filterChildNode((childNode) => {
+      const childNodeParameterNode = isNodeParameterNode(childNode);
+
+      if (childNodeParameterNode) {
+        return true;
+      }
+    });
+
+    return parameterNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ProcedureCallNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/proof.js

@@ -1,7 +1,21 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class ProofNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ProofNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeDerivationNode } from "../utilities/node";
+
+export default class ProofNode extends NonTerminalNode {
+  getDerivationNode() {
+    const derivationNode = this.findChildNode((childNode) => {
+      const childNodeDerivationNode = isNodeDerivationNode(childNode);
+
+      if (childNodeDerivationNode) {
+        return true;
+      }
+    });
+
+    return derivationNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ProofNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/property.js

@@ -1,22 +1,28 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class PropertyNode extends Node {
+import { SINGLE_SPACE } from "../constants";
+
+export default class PropertyNode extends NonTerminalNode {
   getPropertyName() {
-    const propertyName = this.reduceChildNode((propertyName, firstChildNode) => {
-      const nameTerminalNode = firstChildNode,  ///
-            content = nameTerminalNode.getContent();
+    const names = this.getNames(),
+          propertyName = names.join(SINGLE_SPACE);
 
-      propertyName = (propertyName !== null) ?
-                       `${propertyName} ${content}` :
-                          content;  ///
+    return propertyName;
+  }
 
-      return propertyName;
-    }, null);
+  getNames() {
+    const names = this.mapChildNode((childNode) => {
+      const terminalNode = childNode, ///
+            content = terminalNode.getContent(),
+            name = content; //
 
-    return propertyName;
+      return name;
+    });
+
+    return names;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(PropertyNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/propertyRelation.js

@@ -1,7 +1,39 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
+import { isNodeTermNode, isNodePropertyNode } from "../utilities/node";
 
-export default class PropertyRelationNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(PropertyRelationNode, ruleName, childNodes, opacity, precedence); }
+export default class PropertyRelationNode extends NonTerminalNode {
+  getTermNode() {
+    const termNode = this.findChildNode((childNode) => {
+      const childNodeTermNode = isNodeTermNode(childNode);
+
+      if (childNodeTermNode) {
+        return true;
+      }
+    }) || null;
+
+    return termNode;
+  }
+
+  getPropertyNode() {
+    const propertyNode = this.findChildNode((childNode) => {
+      const childNodePropertyNode = isNodePropertyNode(childNode);
+
+      if (childNodePropertyNode) {
+        return true;
+      }
+    }) || null;
+
+    return propertyNode;
+  }
+
+  getPropertyName() {
+    const propertyNode = this.getPropertyNode(),
+          propertyName = propertyNode.getPropertyName();
+
+    return propertyName;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyRelationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/reference.js

@@ -1,7 +1,21 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class ReferenceNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeMetavariableNode } from "../utilities/node";
+
+export default class ReferenceNode extends NonTerminalNode {
+  getMetavariableNode() {
+    const metavariableNode = this.findChildNode((childNode) => {
+      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
+
+      if (childNodeMetavariableNode) {
+        return true;
+      }
+    }) || null;
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/rule.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import TopLevelMetaAssertionNode from "../node/topLevelMetaAssertion";
 
-export default class RuleNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(RuleNode, ruleName, childNodes, opacity, precedence); }
+export default class RuleNode extends TopLevelMetaAssertionNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(RuleNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/statement.js

@@ -1,7 +1,112 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class StatementNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(StatementNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeTermNode,
+         isNodeFrameNode,
+         isNodeEqualityNode,
+         isNodeJudgementNode,
+         isNodeMetavariableNode,
+         isNodeTypeAssertionNode,
+         isNodeSubproofAssertionNode,
+         isNodePropertyAssertionNode } from "../utilities/node";
+
+export default class StatementNode extends NonTerminalNode {
+  getTermNodes() {
+    const termNodes = this.filterDescendantNode((descendantNode) => {
+      const descendantNodeTermNode = isNodeTermNode(descendantNode);
+
+      if (descendantNodeTermNode) {
+        return true;
+      }
+    });
+
+    return termNodes;
+  }
+
+  getFrameNodes() {
+    const frameNodes = this.filterDescendantNode((descendantNode) => {
+      const descendantNodeFrameNode = isNodeFrameNode(descendantNode);
+
+      if (descendantNodeFrameNode) {
+        return true;
+      }
+    });
+
+    return frameNodes;
+  }
+
+  getEqualityNode() {
+    const equalityNode = this.findChildNode((childNode) => {
+      const childNodeEqualityNode = isNodeEqualityNode(childNode);
+
+      if (childNodeEqualityNode) {
+        return true;
+      }
+    }) || null;
+
+    return equalityNode;
+  }
+
+  getJudgementNode() {
+    const judgementNode = this.findChildNode((childNode) => {
+      const childNodeJudgementNode = isNodeJudgementNode(childNode);
+
+      if (childNodeJudgementNode) {
+        return true;
+      }
+    }) || null;
+
+    return judgementNode;
+  }
+
+  getMetavariableNode() {
+    const metavariableNode = this.findChildNode((childNode) => {
+      const childNodeMetavariableNode = isNodeMetavariableNode(childNode);
+
+      if (childNodeMetavariableNode) {
+        return true;
+      }
+    }) || null;
+
+    return metavariableNode;
+  }
+
+  getTypeAssertionNode() {
+    const typeAssertionNode = this.findChildNode((childNode) => {
+      const childNodeTypeAssertionNode = isNodeTypeAssertionNode(childNode);
+
+      if (childNodeTypeAssertionNode) {
+        return true;
+      }
+    }) || null;
+
+    return typeAssertionNode;
+  }
+
+  getSubproofAssertionNode() {
+    const subproofAssertionNode = this.findChildNode((childNode) => {
+      const childNodeSubproofAssertionNode = isNodeSubproofAssertionNode(childNode);
+
+      if (childNodeSubproofAssertionNode) {
+        return true;
+      }
+    }) || null;
+
+    return subproofAssertionNode;
+  }
+
+  getPropertyAssertionNode() {
+    const propertyAssertionNode = this.findChildNode((childNode) => {
+      const childNodePropertyAssertionNode = isNodePropertyAssertionNode(childNode);
+
+      if (childNodePropertyAssertionNode) {
+        return true;
+      }
+    }) || null;
+
+    return propertyAssertionNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/step.js

@@ -1,7 +1,45 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class StepNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeStatementNode, isNodeReferenceNode } from "../utilities/node";
+
+export default class StepNode extends NonTerminalNode {
+  isStepNode() {
+    const stepNode = true;
+
+    return stepNode;
+  }
+
+  isSubproofNode() {
+    const subproofNode = false;
+
+    return subproofNode;
+  }
+
+  getStatementNode() {
+    const statementNode = this.findChildNode((childNode) => {
+      const childNodeStatementNode = isNodeStatementNode(childNode);
+
+      if (childNodeStatementNode) {
+        return true;
+      }
+    }) || null;
+
+    return statementNode;
+  }
+
+  getReferenceNode() {
+    const referenceNode = this.findChildNode((childNode) => {
+      const childNodeReferenceNode = isNodeReferenceNode(childNode);
+
+      if (childNodeReferenceNode) {
+        return true;
+      }
+    }) || null;
+
+    return referenceNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/subDerivation.js

@@ -1,7 +1,22 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class SubDerivationNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(SubDerivationNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeStepNode, isNodeSubproofNode } from "../utilities/node";
+
+export default class SubDerivationNode extends NonTerminalNode {
+  getStepOrSubproofNodes() {
+    const stepOrSubproofNodes = this.filterChildNode((childNode) => {
+      const childNodeStepNode = isNodeStepNode(childNode),
+            childNodeSubproofNode = isNodeSubproofNode(childNode);
+
+      if (childNodeStepNode || childNodeSubproofNode) {
+        return true;
+      }
+    });
+
+    return stepOrSubproofNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SubDerivationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/subproof.js

@@ -1,7 +1,45 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class SubproofNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(SubproofNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeSuppositionNode, isNodeSubDerivationNode } from "../utilities/node";
+
+export default class SubproofNode extends NonTerminalNode {
+  isStepNode() {
+    const stepNode = false;
+
+    return stepNode;
+  }
+
+  isSubproofNode() {
+    const subproofNode = true;
+
+    return subproofNode;
+  }
+
+  getSubDerivationNode() {
+    const subDerivationNode = this.findChildNode((childNode) => {
+      const childNodeSubDerivationNode = isNodeSubDerivationNode(childNode);
+
+      if (childNodeSubDerivationNode) {
+        return true;
+      }
+    }) || null;
+
+    return subDerivationNode;
+  }
+
+  getSuppositionNodes() {
+    const suppositionNodes = this.filterChildNode((childNode) => {
+      const childNodeSuppositionNode = isNodeSuppositionNode(childNode);
+
+      if (childNodeSuppositionNode) {
+        return true;
+      }
+    });
+
+    return suppositionNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SubproofNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/supposition.js

@@ -1,7 +1,33 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class SuppositionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(SuppositionNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeStatementNode, isNodeProcedureCallNode } from "../utilities/node";
+
+export default class SuppositionNode extends NonTerminalNode {
+  getStatementNode() {
+    const statementNode = this.findChildNode((childNode) => {
+      const childNodeStatementNode = isNodeStatementNode(childNode);
+
+      if (childNodeStatementNode) {
+        return true;
+      }
+    }) || null;
+
+    return statementNode;
+  }
+
+  getProcedureCallNode() {
+    const procedureCallNode = this.findChildNode((childNode) => {
+      const childNodeProcedureCallNode = isNodeProcedureCallNode(childNode);
+
+      if (childNodeProcedureCallNode) {
+        return true;
+      }
+    }) || null;
+
+    return procedureCallNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SuppositionNode, ruleName, childNodes, opacity, precedence); }
 }