occam-verify-cli 0.0.271 → 0.0.273

package/bin/axiom.js

@@ -3,9 +3,9 @@
 const { labelsAsString } = require("./utilities/string");
 
 class Axiom {
-  constructor(labels, antecedent, consequent, statementNode) {
+  constructor(labels, supposition, consequent, statementNode) {
     this.labels = labels;
-    this.antecedent = antecedent;
+    this.supposition = supposition;
     this.consequent = consequent;
     this.statementNode = statementNode;
   }
@@ -14,8 +14,8 @@ class Axiom {
     return this.labels;
   }
 
-  getAntecedent() {
-    return this.antecedent;
+  getSupposition() {
+    return this.supposition;
   }
 
   getConsequent() {
@@ -33,16 +33,16 @@ class Axiom {
   }
 
   static fromStatementNodeAndLabels(statementNode, labels) {
-    const antecedent = null,
+    const supposition = null,
           consequent = null,
-          axiom = new Axiom(labels, antecedent, consequent, statementNode);
+          axiom = new Axiom(labels, supposition, consequent, statementNode);
 
     return axiom;
   }
 
-  static fromAntecedentConsequentAndLabels(antecedent, consequent, labels) {
+  static fromSuppositionConsequentAndLabels(supposition, consequent, labels) {
     const statementNode = null,
-          axiom = new Axiom(labels, antecedent, consequent, statementNode);
+          axiom = new Axiom(labels, supposition, consequent, statementNode);
 
     return axiom;
   }

package/bin/metaSubstitution.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const { matchBracketedMetastatementChildNode } = require("./utilities/metastatement");
+const { matchBracketedMetastatementChildNode, bracketedMetastatementChildNodeFromChildNodes } = require("./utilities/metastatement");
 
 class MetaSubstitution {
   constructor(metavariableName, nodes) {
@@ -43,6 +43,15 @@ class MetaSubstitution {
   }
 
   static fromMetavariableNameAndNodes(metavariableName, nodes) {
+    const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromChildNodes(nodes);
+
+    if (bracketedMetastatementChildNode !== null) {
+      const nonTerminalNode = bracketedMetastatementChildNode,  ///
+            childNodes = nonTerminalNode.getChildNodes();
+
+      nodes = childNodes; ///
+    }
+
     const metaSubstitution = new MetaSubstitution(metavariableName, nodes);
 
     return metaSubstitution;

package/bin/utilities/metastatement.js

@@ -4,8 +4,8 @@ const { first, second, third } = require("../utilities/array"),
       { METASTATEMENT_RULE_NAME } = require("../ruleNames"),
       { LEFT_BRACKET, RIGHT_BRACKET, BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH } = require("../constants");
 
-function matchBracketedMetastatementChildNode(childNodes, callback) {
-  let bracketedMetastatementChildNodeMatches = false;
+function bracketedMetastatementChildNodeFromChildNodes(childNodes) {
+  let bracketedMetastatementChildNode = null;
 
   const childNodesLength = childNodes.length;
 
@@ -29,16 +29,27 @@ function matchBracketedMetastatementChildNode(childNodes, callback) {
             nonTerminalNodeRuleNameMetastatementRuleName = (nonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
 
       if (firstTerminalNodeContentLeftBracket && nonTerminalNodeRuleNameMetastatementRuleName && secondTerminalNodeContentRightBracket) {
-        const bracketedMetastatementChildNode = nonTerminalNode;  ///
-
-        bracketedMetastatementChildNodeMatches = callback(bracketedMetastatementChildNode);
+        bracketedMetastatementChildNode = nonTerminalNode;  ///
       }
     }
   }
 
+  return bracketedMetastatementChildNode;
+}
+
+function matchBracketedMetastatementChildNode(childNodes, callback) {
+  let bracketedMetastatementChildNodeMatches = false;
+
+  const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromChildNodes(childNodes);
+
+  if (bracketedMetastatementChildNode !== null) {
+    bracketedMetastatementChildNodeMatches = callback(bracketedMetastatementChildNode);
+  }
+
   return bracketedMetastatementChildNodeMatches;
 }
 
 module.exports = {
-  matchBracketedMetastatementChildNode
+  matchBracketedMetastatementChildNode,
+  bracketedMetastatementChildNodeFromChildNodes
 };

package/bin/verify/axiom/IndicativeConditional.js

@@ -2,15 +2,15 @@
 
 const Axiom = require("../../axiom"),
       verifyLabels = require("../../verify/labels"),
-      verifyAntecedent = require("../../verify/antecedent"),
-      verifyConsequent = require("../../verify/consequent");
+      verifyConsequent = require("../../verify/consequent"),
+      verifySupposition = require("../../verify/supposition");
 
 const { first } = require("../../utilities/array"),
       { nodeQuery, nodesQuery } = require("../../utilities/query");
 
 const labelNodesQuery = nodesQuery("/axiom/label"),
-      antecedentNodeQuery = nodeQuery("/indicativeConditional/antecedent!"),
       consequentNodeQuery = nodeQuery("/indicativeConditional/consequent!"),
+      suppositionNodeQuery = nodeQuery("/indicativeConditional/supposition!"),
       indicativeConditionalNodeQuery = nodeQuery("/axiom/indicativeConditional!");
 
 function verifyIndicativeConditionalAxiom(axiomNode, context) {
@@ -24,21 +24,21 @@ function verifyIndicativeConditionalAxiom(axiomNode, context) {
           labelsVerified = verifyLabels(labelNodes, labels, context);
 
     if (labelsVerified) {
-      const antecedents = [],
-            antecedentNode = antecedentNodeQuery(indicativeConditionalNode),
-            antecedentVerified = verifyAntecedent(antecedentNode, antecedents, context);
+      const suppositions = [],
+            suppositionNode = suppositionNodeQuery(indicativeConditionalNode),
+            suppositionVerified = verifySupposition(suppositionNode, suppositions, context);
 
-      if (antecedentVerified) {
+      if (suppositionVerified) {
         const consequents = [],
               consequentNode = consequentNodeQuery(indicativeConditionalNode),
               consequentVerified = verifyConsequent(consequentNode, consequents, context);
 
         if (consequentVerified) {
-          const firstAntecedent = first(antecedents),
+          const firstSupposition = first(suppositions),
                 firstConsequent = first(consequents),
-                antecedent = firstAntecedent, ///
+                supposition = firstSupposition, ///
                 consequent = firstConsequent, ///
-                axiom = Axiom.fromAntecedentConsequentAndLabels(antecedent, consequent, labels);
+                axiom = Axiom.fromSuppositionConsequentAndLabels(supposition, consequent, labels);
 
           context.addAxiom(axiom);
 

package/bin/verify/conditinalInference.js

@@ -1,8 +1,6 @@
 "use strict";
 
-const verifyMetaproof = require("../verify/metaproof"),
-      MetaproofContext = require("../context/metaproof"),
-      verifyConclusion = require("../verify/conclusion"),
+const verifyConclusion = require("../verify/conclusion"),
       verifyPremiseOrPremises = require("../verify/premiseOrPremises");
 
 const { nodeQuery } = require("../utilities/query");
@@ -15,10 +13,6 @@ const conclusionNodeQuery = nodeQuery("/conditionalInference/conclusion!"),
 function verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context) {
   let conditionalInferenceVerified = false;
 
-  const metaproofContext = MetaproofContext.fromContext(context);
-
-  context = metaproofContext; ///
-
   const conclusionNode = conclusionNodeQuery(conditionalInferenceNode),
         metastatementNode = metastatementNodeQuery(conditionalInferenceNode),
         premiseOrPremisesNode = premiseOrPremisesNodeQuery(conditionalInferenceNode),

package/bin/verify/metaDerivation.js

@@ -2,15 +2,15 @@
 
 const MetaAssertion = require("../metaAssertion"),
       MetaproofContext = require("../context/metaproof"),
-      verifyMetaAntecedent = require("../verify/metaAntecedent"),
+      verifyMetaSupposition = require("../verify/metaSupposition"),
       verifyQualifiedMetastatement = require("../verify/metastatement/qualified"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery, nodesQuery } = require("../utilities/query"),
       { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } = require("../ruleNames");
 
-const metaAntecedentNodeQuery = nodeQuery("/metaSubproof/metaAntecedent!"),
-      metaDerivationNodeQuery = nodeQuery("/metaSubproof/metaDerivation!"),
+const metaDerivationNodeQuery = nodeQuery("/metaSubproof/metaDerivation!"),
+      metaSuppositionNodeQuery = nodeQuery("/metaSubproof/metaSupposition!"),
       metaDerivationChildNodesQuery = nodesQuery("/metaDerivation/*"),
       qualifiedMetastatementNodeQuery = nodeQuery("/metaSubproof/qualifiedMetastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/metaSubproof/unqualifiedMetastatement!");
@@ -89,10 +89,10 @@ function verifyMetaSubproof(metaSubproofNode, context) {
 
   context = metaproofContext; ///
 
-  const metaAntecedentNode = metaAntecedentNodeQuery(metaSubproofNode),
-        metaAntecedentVerified = verifyMetaAntecedent(metaAntecedentNode, context);
+  const metaSuppositionNode = metaSuppositionNodeQuery(metaSubproofNode),
+        metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, context);
 
-  if (metaAntecedentVerified) {
+  if (metaSuppositionVerified) {
     let metaDerivationVerified = true;
 
     const metaDerivationNode = metaDerivationNodeQuery(metaSubproofNode);

package/bin/verify/{metaAntecedent.js → metaSupposition.js}

@@ -5,20 +5,20 @@ const MetaAssertion = require("../metaAssertion"),
 
 const { nodeQuery } = require("../utilities/query");
 
-const unqualifiedMetastatementNodeQuery = nodeQuery("/metaAntecedent/unqualifiedMetastatement!");
+const unqualifiedMetastatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedMetastatement!");
 
-function verifyMetaAntecedent(metaAntecedentNode, context) {
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaAntecedentNode),
+function verifyMetaSupposition(metaSuppositionNode, context) {
+  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSuppositionNode),
         unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context),
-        metaAntecedentVerified = unqualifiedMetastatementVerified;  ///
+        metaSuppositionVerified = unqualifiedMetastatementVerified;  ///
 
-  if (metaAntecedentVerified) {
+  if (metaSuppositionVerified) {
     const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
 
     context.addMetaAssertion(metaAssertion);
   }
 
-  return metaAntecedentVerified;
+  return metaSuppositionVerified;
 }
 
-module.exports = verifyMetaAntecedent;
+module.exports = verifyMetaSupposition;

package/bin/verify/rule.js

@@ -5,6 +5,7 @@ const { loggingUtilities } = require("necessary");
 const Rule = require("../rule"),
       verifyLabels = require("../verify/labels"),
       verifyMetaproof = require("../verify/metaproof"),
+      MetaproofContext = require("../context/metaproof"),
       verifyConditionalInference = require("../verify/conditinalInference"),
       verifyUnconditionalInference = require("../verify/unconditionalInference");
 
@@ -25,6 +26,10 @@ function verifyRule(ruleNode, context) {
   const labelNodes = labelNodesQuery(ruleNode),
         labelsString = nodesAsString(labelNodes);
 
+  const metaproofContext = MetaproofContext.fromContext(context);
+
+  context = metaproofContext; ///
+
   log.debug(`Verifying the '${labelsString}' rule...`);
 
   const labels = [],

package/bin/verify/supposition.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const Assertion = require("../assertion"),
+      verifyUnqualifiedStatement = require("../verify/statement/unqualified");
+
+const { nodeQuery } = require("../utilities/query");
+
+const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
+
+function verifySupposition(suppositionNode, suppositions, context) {
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context),
+        suppositionVerified = unqualifiedStatementVerified;
+
+  if (suppositionVerified) {
+    const supposition = Assertion.fromUnqualifiedStatementNode(unqualifiedStatementNode);
+
+    suppositions.push(supposition);
+  }
+
+  return suppositionVerified;
+}
+
+module.exports = verifySupposition;

package/bin/verify/unconditionalInference.js

@@ -1,7 +1,6 @@
 "use strict";
 
 const Conclusion = require("../conclusion"),
-      MetaproofContext = require("../context/metaproof"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery } = require("../utilities/query");
@@ -12,10 +11,6 @@ const metastatementNodeQuery = nodeQuery("/unconditionalInference/unqualifiedMet
 function verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, context) {
   let unconditionalInferenceVerified = false;
 
-  const metaproofContext = MetaproofContext.fromContext(context);
-
-  context = metaproofContext; ///
-
   const metastatementNode = metastatementNodeQuery(unconditionalInferenceNode),
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(unconditionalInferenceNode),
         unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.271",
+  "version": "0.0.273",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,10 +12,10 @@
   "dependencies": {
     "argumentative": "^2.0.15",
     "necessary": "^11.0.40",
-    "occam-custom-grammars": "^5.0.352",
+    "occam-custom-grammars": "^5.0.354",
     "occam-dom": "^3.0.171",
     "occam-grammar-utilities": "^7.0.66",
-    "occam-grammars": "^1.0.319",
+    "occam-grammars": "^1.0.321",
     "occam-open-cli": "^5.0.37",
     "occam-parsers": "^16.0.122"
   },

package/bin/verify/antecedent.js

@@ -1,24 +0,0 @@
-"use strict";
-
-const Assertion = require("../assertion"),
-      verifyUnqualifiedStatement = require("../verify/statement/unqualified");
-
-const { nodeQuery } = require("../utilities/query");
-
-const unqualifiedStatementNodeQuery = nodeQuery("/antecedent/unqualifiedStatement!");
-
-function verifyAntecedent(antecedentNode, antecedents, context) {
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(antecedentNode),
-        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context),
-        antecedentVerified = unqualifiedStatementVerified;
-
-  if (antecedentVerified) {
-    const antecedent = Assertion.fromUnqualifiedStatementNode(unqualifiedStatementNode);
-
-    antecedents.push(antecedent);
-  }
-
-  return antecedentVerified;
-}
-
-module.exports = verifyAntecedent;

package/bin/verify/metaConsequent.js

@@ -1,23 +0,0 @@
-"use strict";
-
-const verifyUnqualifiedMetaStatement = require("../verify/metastatement/unqualified");
-
-const { nodeQuery } = require("../utilities/query");
-
-const unqualifiedMetaStatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetaStatement!");
-
-function verifyMetaConsequent(metaConsequentNode, metaConsequents, context) {
-  let metaConsequentVerified = false;
-
-  const unqualifiedMetaStatementNode = unqualifiedMetaStatementNodeQuery(metaConsequentNode);
-
-  if (unqualifiedMetaStatementNode !== null) {
-    const unqualifiedMetaStatementVerified = verifyUnqualifiedMetaStatement(unqualifiedMetaStatementNode, context);
-
-    metaConsequentVerified = unqualifiedMetaStatementVerified;
-  }
-
-  return metaConsequentVerified;
-}
-
-module.exports = verifyMetaConsequent;