occam-verify-cli 1.0.254 → 1.0.256

package/src/node/lemma.js

@@ -1,51 +1,13 @@
 "use strict";
 
-import NonTerminalNode from "../node/nonTerminal";
+import TopLevelAssertionNode from "../node/topLevelAssertion";
 
 import { LEMMA_BODY_RULE_NAME, LEMMA_HEADER_RULE_NAME } from "../ruleNames";
 
-export default class LemmaNode extends NonTerminalNode {
-  getLemmaBodyNode() {
-    const ruleName = LEMMA_BODY_RULE_NAME,
-          lemmaBodyNode = this.getNodeByRuleName(ruleName);
+export default class LemmaNode extends TopLevelAssertionNode {
+  static bodyRuleName = LEMMA_BODY_RULE_NAME;
 
-    return lemmaBodyNode;
-  }
+  static headerRuleName = LEMMA_HEADER_RULE_NAME;
 
-  getLemmaHeaderNode() {
-    const ruleName = LEMMA_HEADER_RULE_NAME,
-          lemmaHeaderNode = this.getNodeByRuleName(ruleName);
-
-    return lemmaHeaderNode;
-  }
-
-  getLabelNodes() {
-    const lemmaHeaderNode = this.getLemmaHeaderNode(),
-          labelNodes = lemmaHeaderNode.getLabelNodes();
-
-    return labelNodes;
-  }
-
-  getSuppositionNodes() {
-    const lemmaBodyNode = this.getLemmaBodyNode(),
-          suppositionNodes = lemmaBodyNode.getSuppositionNodes();
-
-    return suppositionNodes;
-  }
-
-  getDeductionNode() {
-    const lemmaBodyNode = this.getLemmaBodyNode(),
-          deductionNode = lemmaBodyNode.getDeductionNode();
-
-    return deductionNode;
-  }
-
-  getProofNode() {
-    const lemmaBodyNode = this.getLemmaBodyNode(),
-          proofNode = lemmaBodyNode.getProofNode();
-
-    return proofNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(LemmaNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(LemmaNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metaLemma.js

@@ -1,51 +1,13 @@
 "use strict";
 
-import NonTerminalNode from "../node/nonTerminal";
+import TopLevelMetaAssertionNode from "../node/topLevelMetaAssertion";
 
 import { META_LEMMA_BODY_RULE_NAME, META_LEMMA_HEADER_RULE_NAME } from "../ruleNames";
 
-export default class MetaLemmaNode extends NonTerminalNode {
-  getMetaLemmaBodyNode() {
-    const ruleName = META_LEMMA_BODY_RULE_NAME,
-          metaLemmaBodyNode = this.getNodeByRuleName(ruleName);
+export default class MetaLemmaNode extends TopLevelMetaAssertionNode {
+  static bodyRuleName = META_LEMMA_BODY_RULE_NAME;
 
-    return metaLemmaBodyNode;
-  }
+  static headerRuleName = META_LEMMA_HEADER_RULE_NAME;
 
-  getMetaLemmaHeaderNode() {
-    const ruleName = META_LEMMA_HEADER_RULE_NAME,
-          metaLemmaHeaderNode = this.getNodeByRuleName(ruleName);
-
-    return metaLemmaHeaderNode;
-  }
-
-  getLabelNode() {
-    const metaLemmaHeaderNode = this.getMetaLemmaHeaderNode(),
-          labelNode = metaLemmaHeaderNode.getLabelNode();
-
-    return labelNode;
-  }
-
-  getSuppositionNodes() {
-    const metaLemmaBodyNode = this.getMetaLemmaBodyNode(),
-          suppositionNodes = metaLemmaBodyNode.getSuppositionNodes();
-
-    return suppositionNodes;
-  }
-
-  getDeductionNode() {
-    const metaLemmaBodyNode = this.getMetaLemmaBodyNode(),
-          deductionNode = metaLemmaBodyNode.getDeductionNode();
-
-    return deductionNode;
-  }
-
-  getProofNode() {
-    const metaLemmaBodyNode = this.getMetaLemmaBodyNode(),
-          proofNode = metaLemmaBodyNode.getProofNode();
-
-    return proofNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metatheorem.js

@@ -1,51 +1,13 @@
 "use strict";
 
-import NonTerminalNode from "../node/nonTerminal";
+import TopLevelMetaAssertionNode from "../node/topLevelMetaAssertion";
 
 import { METATHEOREM_BODY_RULE_NAME, METATHEOREM_HEADER_RULE_NAME } from "../ruleNames";
 
-export default class MetatheoremNode extends NonTerminalNode {
-  getMetatheoremBodyNode() {
-    const ruleName = METATHEOREM_BODY_RULE_NAME,
-          metatheoremBodyNode = this.getNodeByRuleName(ruleName);
+export default class MetatheoremNode extends TopLevelMetaAssertionNode {
+  static bodyRuleName = METATHEOREM_BODY_RULE_NAME;
 
-    return metatheoremBodyNode;
-  }
+  static headerRuleName = METATHEOREM_HEADER_RULE_NAME;
 
-  getMetatheoremHeaderNode() {
-    const ruleName = METATHEOREM_HEADER_RULE_NAME,
-          metatheoremHeaderNode = this.getNodeByRuleName(ruleName);
-
-    return metatheoremHeaderNode;
-  }
-
-  getLabelNode() {
-    const metatheoremHeaderNode = this.getMetatheoremHeaderNode(),
-          labelNode = metatheoremHeaderNode.getLabelNode();
-
-    return labelNode;
-  }
-
-  getSuppositionNodes() {
-    const metatheoremBodyNode = this.getMetatheoremBodyNode(),
-          suppositionNodes = metatheoremBodyNode.getSuppositionNodes();
-
-    return suppositionNodes;
-  }
-
-  getConclusionNode() {
-    const metatheoremBodyNode = this.getMetatheoremBodyNode(),
-          conclusionNode = metatheoremBodyNode.getConclusionNode();
-
-    return conclusionNode;
-  }
-
-  getProofNode() {
-    const metatheoremBodyNode = this.getMetatheoremBodyNode(),
-          proofNode = metatheoremBodyNode.getProofNode();
-
-    return proofNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/parameter.js

@@ -3,21 +3,21 @@
 import NonTerminalNode from "../node/nonTerminal";
 
 export default class ParameterNode extends NonTerminalNode {
-  getParameterName() {
-    let parameterName;
+  getParameterValue() {
+    let parameterValue;
 
     this.someChildNode((childNode, index) => {
-      const nameTerminalNode = childNode, ///
-            content = nameTerminalNode.getContent();
+      const terminalNode = childNode, ///
+            content = terminalNode.getContent();
 
-      parameterName = content;  ///
+      parameterValue = content;  ///
 
       if (index === 0) {
         return true;
       }
     });
 
-    return parameterName;
+    return parameterValue;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ParameterNode, ruleName, childNodes, opacity, precedence); }

package/src/node/theorem.js

@@ -1,51 +1,13 @@
 "use strict";
 
-import NonTerminalNode from "../node/nonTerminal";
+import TopLevelAssertionNode from "../node/topLevelAssertion";
 
 import { THEOREM_BODY_RULE_NAME, THEOREM_HEADER_RULE_NAME } from "../ruleNames";
 
-export default class TheoremNode extends NonTerminalNode {
-  getTheoremBodyNode() {
-    const ruleName = THEOREM_BODY_RULE_NAME,
-          theoremBodyNode = this.getNodeByRuleName(ruleName);
+export default class TheoremNode extends TopLevelAssertionNode {
+  static bodyRuleName = THEOREM_BODY_RULE_NAME;
 
-    return theoremBodyNode;
-  }
+  static headerRuleName = THEOREM_HEADER_RULE_NAME;
 
-  getTheoremHeaderNode() {
-    const ruleName = THEOREM_HEADER_RULE_NAME,
-          theoremHeaderNode = this.getNodeByRuleName(ruleName);
-
-    return theoremHeaderNode;
-  }
-
-  getLabelsNode() {
-    const theoremHeaderNode = this.getTheoremHeaderNode(),
-          labelNodes = theoremHeaderNode.getLabelNodes();
-
-    return labelNodes;
-  }
-
-  getSuppositionNodes() {
-    const theoremBodyNode = this.getTheoremBodyNode(),
-          suppositionNodes = theoremBodyNode.getSuppositionNodes();
-
-    return suppositionNodes;
-  }
-
-  getDeductionNode() {
-    const theoremBodyNode = this.getTheoremBodyNode(),
-          deductionNode = theoremBodyNode.getDeductionNode();
-
-    return deductionNode;
-  }
-
-  getProofNode() {
-    const theoremBodyNode = this.getTheoremBodyNode(),
-          proofNode = theoremBodyNode.getProofNode();
-
-    return proofNode;
-  }
-
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TheoremNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(TheoremNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/topLevelAssertion.js

@@ -0,0 +1,58 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+export default class TopLevelAssertionNode extends NonTerminalNode {
+  getBodyNode() {
+    const { bodyRuleName } = this.constructor,
+          ruleName = bodyRuleName,  ///
+          axiomBodyNode = this.getNodeByRuleName(ruleName);
+
+    return axiomBodyNode;
+  }
+
+  getHeaderNode() {
+    const { headerRuleName } = this.constructor,
+          ruleName = headerRuleName,  ///
+          headerNode = this.getNodeByRuleName(ruleName);
+
+    return headerNode;
+  }
+
+  getSignatureNode() {
+    const headerNode = this.getHeaderNode(),
+          signatureNode = headerNode.getSignatureNode();
+
+    return signatureNode;
+  }
+
+  getLabelNodes() {
+    const headerNode = this.getHeaderNode(),
+          labelNodes = headerNode.getLabelNodes();
+
+    return labelNodes;
+  }
+
+  getSuppositionNodes() {
+    const bodyNode = this.getBodyNode(),
+          suppositionNodes = bodyNode.getSuppositionNodes();
+
+    return suppositionNodes;
+  }
+
+  getDeductionNode() {
+    const bodyNode = this.getBodyNode(),
+          deductionNode = bodyNode.getDeductionNode();
+
+    return deductionNode;
+  }
+
+  getProofNode() {
+    const bodyNode = this.getBodyNode(),
+          proofNode = bodyNode.getProofNode();
+
+    return proofNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/topLevelMetaAssertion.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+export default class TopLevelMetaAssertionNode extends NonTerminalNode {
+  getBodyNode() {
+    const { bodyRuleName } = this.constructor,
+          ruleName = bodyRuleName,  ///
+          axiomBodyNode = this.getNodeByRuleName(ruleName);
+
+    return axiomBodyNode;
+  }
+
+  getHeaderNode() {
+    const { headerRuleName } = this.constructor,
+          ruleName = headerRuleName,  ///
+          headerNode = this.getNodeByRuleName(ruleName);
+
+    return headerNode;
+  }
+
+  getLabelNode() {
+    const headerNode = this.getHeaderNode(),
+          labelNode = headerNode.getLabelNode();
+
+    return labelNode;
+  }
+
+  getProofNode() {
+    const bodyNode = this.getBodyNode(),
+          proofNode = bodyNode.getProofNode();
+
+    return proofNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+}