occam-verify-cli 1.0.984 → 1.0.985

package/src/node/proofAssertion/supposition.js

@@ -1,16 +0,0 @@
-"use strict";
-
-import ProofAssertionNode from "../../node/proofAssertion";
-
-import { PROCEDURE_CALL_RULE_NAME } from "../../ruleNames";
-
-export default class SuppositionNode extends ProofAssertionNode {
-  getProcedureCallNode() {
-    const ruleName = PROCEDURE_CALL_RULE_NAME,
-          procedureCallNode = this.getNodeByRuleName(ruleName);
-
-    return procedureCallNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return ProofAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(SuppositionNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/proofAssertion.js

@@ -1,23 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
-
-export default class ProofAssertionNode extends NonTerminalNode {
-  getNonsenseNode() {
-    const ruleName = NONSENSE_RULE_NAME,
-          nonsenseNode = this.getNodeByRuleName(ruleName);
-
-    return nonsenseNode;
-  }
-
-  getStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          statementNode = this.getNodeByRuleName(ruleName);
-
-    return statementNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/property.js

@@ -1,28 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { SINGLE_SPACE } from "../constants";
-
-export default class PropertyNode extends NonTerminalNode {
-  getNames() {
-    const names = this.mapChildNode((childNode) => {
-      const terminalNode = childNode, ///
-            content = terminalNode.getContent(),
-            identifier = content; //
-
-      return identifier;
-    });
-
-    return names;
-  }
-
-  getPropertyName() {
-    const names = this.getNames(),
-          propertyName = names.join(SINGLE_SPACE);
-
-    return propertyName;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/propertyRelation.js

@@ -1,30 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { TERM_RULE_NAME, PROPERTY_RULE_NAME } from "../ruleNames";
-
-export default class PropertyRelationNode extends NonTerminalNode {
-  getPropertyName() {
-    const propertyNode = this.getPropertyNode(),
-          propertyName = propertyNode.getPropertyName();
-
-    return propertyName;
-  }
-
-  getTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          termNode = this.getNodeByRuleName(ruleName);
-
-    return termNode;
-  }
-
-  getPropertyNode() {
-    const ruleName = PROPERTY_RULE_NAME,
-          propertyNode = this.getNodeByRuleName(ruleName);
-
-    return propertyNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyRelationNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/qualification.js

@@ -1,23 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { REFERENCE_RULE_NAME, SIGNATURE_ASSERTION_RULE_NAME } from "../ruleNames";
-
-export default class QualificationNode extends NonTerminalNode {
-  getReferenceNode() {
-    const ruleName = REFERENCE_RULE_NAME,
-          referenceNode = this.getNodeByRuleName(ruleName);
-
-    return referenceNode;
-  }
-
-  getSignatureAssertionNode() {
-    const ruleName = SIGNATURE_ASSERTION_RULE_NAME,
-          signatureAssertionNode = this.getNodeByRuleName(ruleName);
-
-    return signatureAssertionNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(QualificationNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/reference.js

@@ -1,16 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { METAVARIABLE_RULE_NAME } from "../ruleNames";
-
-export default class ReferenceNode extends NonTerminalNode {
-  getMetavariableNode() {
-    const ruleName = METAVARIABLE_RULE_NAME,
-          metavariableNode = this.getNodeByRuleName(ruleName);
-
-    return metavariableNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/rule.js

@@ -1,51 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { RULE_BODY_RULE_NAME, RULE_HEADER_RULE_NAME } from "../ruleNames";
-
-export default class RuleNode extends NonTerminalNode {
-  getProofNode() {
-    const ruleBodyNode = this.getRuleBodyNode(),
-          proofNode = ruleBodyNode.getProofNode();
-
-    return proofNode;
-  }
-
-  getLabelNodes() {
-    const ruleHeaderNode = this.getRuleHeaderNode(),
-          labelNodes = ruleHeaderNode.getLabelNodes();
-
-    return labelNodes;
-  }
-
-  getPremiseNodes() {
-    const ruleBodyNode = this.getRuleBodyNode(),
-          premiseNodes = ruleBodyNode.getPremiseNodes();
-
-    return premiseNodes;
-  }
-
-  getConclusionNode() {
-    const ruleBodyNode = this.getRuleBodyNode(),
-          conclusionNode = ruleBodyNode.getConclusionNode();
-
-    return conclusionNode;
-  }
-
-  getRuleBodyNode() {
-    const ruleName = RULE_BODY_RULE_NAME,
-          ruleBodyNode = this.getNodeByRuleName(ruleName);
-
-    return ruleBodyNode;
-  }
-
-  getRuleHeaderNode() {
-    const ruleName = RULE_HEADER_RULE_NAME,
-          ruleHeaderNode = this.getNodeByRuleName(ruleName);
-
-    return ruleHeaderNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(RuleNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/section.js

@@ -1,44 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { AXIOM_RULE_NAME, LEMMA_RULE_NAME, THEOREM_RULE_NAME, CONJECTURE_RULE_NAME, HYPOTHESIS_RULE_NAME } from "../ruleNames";
-
-export default class SectionNode extends NonTerminalNode {
-  getAxiomNode() {
-    const ruleName = AXIOM_RULE_NAME,
-          axiomNode = this.getNodeByRuleName(ruleName);
-
-    return axiomNode;
-  }
-
-  getLemmaNode() {
-    const ruleName = LEMMA_RULE_NAME,
-          lemmaNode = this.getNodeByRuleName(ruleName);
-
-    return lemmaNode;
-  }
-
-  getTheoremNode() {
-    const ruleName = THEOREM_RULE_NAME,
-          theoremNode = this.getNodeByRuleName(ruleName);
-
-    return theoremNode;
-  }
-
-  getConjectureNode() {
-    const ruleName = CONJECTURE_RULE_NAME,
-          conjectureNode = this.getNodeByRuleName(ruleName);
-
-    return conjectureNode;
-  }
-
-  getHypothesisNodes() {
-    const ruleName = HYPOTHESIS_RULE_NAME,
-          hypothesisNodes = this.getNodesByRuleName(ruleName);
-
-    return hypothesisNodes;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SectionNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/signature.js

@@ -1,16 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { TERM_RULE_NAME } from "../ruleNames";
-
-export default class SignatureNode extends NonTerminalNode {
-  getTermNodes() {
-    const ruleName = TERM_RULE_NAME,
-          termNodes = this.getNodesByRuleName(ruleName);
-
-    return termNodes;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SignatureNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/statement.js

@@ -1,167 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-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,
-         SIGNATURE_ASSERTION_RULE_NAME,
-         CONTAINED_ASSERTION_RULE_NAME,
-         STATEMENT_SUBSTITUTION_RULE_NAME } from "../ruleNames";
-
-export default class StatementNode extends NonTerminalNode {
-  isSingular() {
-    let singular = false;
-
-    const singularMetavariableNode = this.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      singular = true;
-    }
-
-    return singular;
-  }
-
-  getMetavariableNode() {
-    const singularMetavariableNode = this.getSingularMetavariableNode(),
-          metavariableNode = singularMetavariableNode;  ///
-
-    return metavariableNode;
-  }
-
-  getSubstitutionNode() {
-    const frameSubstitutionNode = this.getFrameSubstitutionNode(),
-          termSubstitutionNode = this.getTermSubstitutionNode(),
-          substitutionNode = (frameSubstitutionNode || termSubstitutionNode);
-
-    return substitutionNode;
-  }
-
-  getTermNodes() {
-    const ruleName = TERM_RULE_NAME,
-          termNodes = this.getDescendantNodesByRuleName(ruleName);
-
-    return termNodes;
-  }
-
-  getFrameNodes() {
-    const ruleName = FRAME_RULE_NAME,
-          frameNodes = this.getDescendantNodesByRuleName(ruleName);
-
-    return frameNodes;
-  }
-
-  getEqualityNode() {
-    const ruleName = EQUALITY_RULE_NAME,
-          equalityNode = this.getNodeByRuleName(ruleName);
-
-    return equalityNode;
-  }
-
-  getJudgementNode() {
-    const ruleName = JUDGEMENT_RULE_NAME,
-          judgementNode = this.getNodeByRuleName(ruleName);
-
-    return judgementNode;
-  }
-
-  getTypeAssertionNode() {
-    const ruleName = TYPE_ASSERTION_RULE_NAME,
-          typeAssertionNode = this.getNodeByRuleName(ruleName);
-
-    return typeAssertionNode;
-  }
-
-  getDefinedAssertionNode() {
-    const ruleName = DEFINED_ASSERTION_RULE_NAME,
-          definedAssertionNode = this.getNodeByRuleName(ruleName);
-
-    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 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;
-  }
-
-  getSignatureAssertionNode() {
-    const ruleName = SIGNATURE_ASSERTION_RULE_NAME,
-          signatureAssertionNode = this.getNodeByRuleName(ruleName);
-
-    return signatureAssertionNode;
-  }
-
-  getSingularMetavariableNode() {
-    const ruleName = METAVARIABLE_RULE_NAME,
-          singularMetavariableNode = this.getSingularNodeByRuleName(ruleName);
-
-    return singularMetavariableNode;
-  }
-
-  getSingularMetaArgumentNode() {
-    const ruleName = META_ARGUMENT_RULE_NAME,
-          singularMetaArgumentNode = this.getNodeByRuleName(ruleName);
-
-    return singularMetaArgumentNode;
-  }
-
-  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/subDerivation.js

@@ -1,19 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { STEP_RULE_NAME, SUBPROOF_RULE_NAME } from "../ruleNames";
-
-export default class SubDerivationNode extends NonTerminalNode {
-  getStepOrSubproofNodes() {
-    const ruleNames = [
-            STEP_RULE_NAME,
-            SUBPROOF_RULE_NAME,
-          ],
-          stepOrSubproofNodes = this.getNodesByRuleName(...ruleNames);
-
-    return stepOrSubproofNodes;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SubDerivationNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/subproof.js

@@ -1,35 +0,0 @@
-"use strict";
-
-import { NonTerminalNode } from "occam-languages";
-
-import { SUPPOSITION_RULE_NAME, SUB_DERIVATION_RULE_NAME } from "../ruleNames";
-
-export default class SubproofNode extends NonTerminalNode {
-  isStepNode() {
-    const stepNode = false;
-
-    return stepNode;
-  }
-
-  isSubproofNode() {
-    const subproofNode = true;
-
-    return subproofNode;
-  }
-
-  getSuppositionNodes() {
-    const ruleName = SUPPOSITION_RULE_NAME,
-          suppositionNodes = this.getNodesByRuleName(ruleName);
-
-    return suppositionNodes;
-  }
-
-  getSubDerivationNode() {
-    const ruleName = SUB_DERIVATION_RULE_NAME,
-          subDerivationNode = this.getNodeByRuleName(ruleName);
-
-    return subDerivationNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(SubproofNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/substitution/frame.js

@@ -1,37 +0,0 @@
-"use strict";
-
-import SubstitutionNode from "../../node/substitution";
-
-import { FRAME_RULE_NAME } from "../../ruleNames";
-
-export default class FrameSubstitutionNode extends SubstitutionNode {
-  getTargetFrameNode() {
-    const lastFrameNode = this.getLastFrameNode(),
-          targetFrameNode = lastFrameNode; ///
-
-    return targetFrameNode;
-  }
-
-  getReplacementFrameNode() {
-    const firstFrameNode = this.getFirstFrameNode(),
-          replacementFrameNode = firstFrameNode; ///
-
-    return replacementFrameNode;
-  }
-
-  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 SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(FrameSubstitutionNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/substitution/reference.js

@@ -1,38 +0,0 @@
-"use strict";
-
-import SubstitutionNode from "../../node/substitution";
-
-import { REFERENCE_RULE_NAME } from "../../ruleNames";
-
-export default class ReferenceSubstitutionNode extends SubstitutionNode {
-  getTargetReferenceNode() {
-    const lastReferenceNode = this.getLastReferenceNode(),
-          targetReferenceNode = lastReferenceNode; ///
-
-    return targetReferenceNode;
-  }
-
-  getReplacementReferenceNode() {
-    const firstReferenceNode = this.getFirstReferenceNode(),
-          replacementReferenceNode = firstReferenceNode; ///
-
-    return replacementReferenceNode;
-  }
-
-  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 SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(ReferenceSubstitutionNode, ruleName, childNodes, opacity, precedence); }
-}
-

package/src/node/substitution/statement.js

@@ -1,70 +0,0 @@
-"use strict";
-
-import SubstitutionNode from "../../node/substitution";
-
-import { STATEMENT_RULE_NAME } from "../../ruleNames";
-
-export default class StatementSubstitutionNode extends SubstitutionNode {
-  isResolved() {
-    let resolved = true;
-
-    const substitutionNode = this.getSubstitutionNode();
-
-    if (substitutionNode !== null) {
-      resolved = false;
-    }
-
-    return resolved;
-  }
-
-  getSubstitutionNode() {
-    const targetStatementNode = this.getTargetStatementNode(),
-      substitutionNode = targetStatementNode.getSubstitutionNode();
-
-    return substitutionNode;
-  }
-
-  getTermSubstitutionNode() {
-    const targetStatementNode = this.getTargetStatementNode(),
-          termSubstitutionNode = targetStatementNode.getTermSubstitutionNode();
-
-    return termSubstitutionNode;
-  }
-
-  getFrameSubstitutionNode() {
-    const targetStatementNode = this.getTargetStatementNode(),
-          frameSubstitutionNode = targetStatementNode.getFrameSubstitutionNode();
-
-    return frameSubstitutionNode;
-  }
-
-  getTargetStatementNode() {
-    const lastStatementNode = this.getLastStatementNode(),
-          targetStatementNode = lastStatementNode; ///
-
-    return targetStatementNode;
-  }
-
-  getReplacementStatementNode() {
-    const firstStatementNode = this.getFirstStatementNode(),
-          replacementStatementNode = firstStatementNode; ///
-
-    return replacementStatementNode;
-  }
-
-  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 SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementSubstitutionNode, ruleName, childNodes, opacity, precedence); }
-}

package/src/node/substitution/term.js

@@ -1,38 +0,0 @@
-"use strict";
-
-import SubstitutionNode from "../../node/substitution";
-
-import { TERM_RULE_NAME } from "../../ruleNames";
-
-export default class TermSubstitutionNode extends SubstitutionNode {
-  getTargetTermNode() {
-    const lastTermNode = this.getLastTermNode(),
-          targetTermNode = lastTermNode; ///
-
-    return targetTermNode;
-  }
-
-  getReplacementTermNode() {
-    const firstTermNode = this.getFirstTermNode(),
-          replacementTermNode = firstTermNode; ///
-
-    return replacementTermNode;
-  }
-
-  getLastTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          lastTermNode = this.getLastNodeByRuleName(ruleName);
-
-    return lastTermNode;
-  }
-
-  getFirstTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          firstTermNode = this.getFirstNodeByRuleName(ruleName);
-
-    return firstTermNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(TermSubstitutionNode, ruleName, childNodes, opacity, precedence); }
-}
-

package/src/node/substitution.js

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