occam-verify-cli 0.0.269 → 0.0.270

package/bin/metaAssertion.js

@@ -10,6 +10,14 @@ class MetaAssertion {
     this.metastatementNode = metastatementNode;
   }
 
+  getNonTerminalNode() {
+    const nonTerminalNode = (this.metastatementNode !== null) ?
+                               this.metastatementNode :
+                                 null;
+
+    return nonTerminalNode;
+  }
+
   getMetaSubproofNode() {
     return this.metaSubproofNode;
   }

package/bin/rule.js

@@ -23,15 +23,15 @@ class Rule {
   }
 
   matchMetastatement(metastatementNode, context) {
-    let metastatementNodes = context.getMetastatementNodes();
+    let metaAssertions = context.getMetaAssertions();
 
     const premisesLength = this.premises.length,
           start = -premisesLength;
 
-    metastatementNodes = metastatementNodes.slice(start); ///
+    metaAssertions = metaAssertions.slice(start); ///
 
-    const matchesMetastatement = someCombination(metastatementNodes, (metastatementNodes) => {
-      const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metastatementNodes, metastatementNode);
+    const matchesMetastatement = someCombination(metaAssertions, (metaAssertions) => {
+      const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metaAssertions, metastatementNode);
 
       if (premisesMatchConclusion) {
         return true;
@@ -56,24 +56,27 @@ class Rule {
 
 module.exports = Rule;
 
-function matchPremise(premise, metastatementNodes, metaSubstitutions) {
-  const metastatementNode = prune(metastatementNodes, (metastatementNode) => {
-    const nonTerminalNode = metastatementNode,  ///
-          nonTerminalNodeMatches = premise.matchNonTerminalNode(nonTerminalNode, metaSubstitutions);
+function matchPremise(premise, metaAssertions, metaSubstitutions) {
+  const metaAssertion = prune(metaAssertions, (metaAssertion) => {
+    const nonTerminalNode = metaAssertion.getNonTerminalNode();
 
-    if (!nonTerminalNodeMatches) {  ///
-      return true;
+    if (nonTerminalNode !== null) {
+      const nonTerminalNodeMatches = premise.matchNonTerminalNode(nonTerminalNode, metaSubstitutions);
+
+      if (!nonTerminalNodeMatches) {  ///
+        return true;
+      }
     }
   }) || null;
 
-  const premiseMatches = (metastatementNode !== null);
+  const premiseMatches = (metaAssertion !== null);
 
   return premiseMatches;
 }
 
-function matchPremises(premise, metastatementNodes, metaSubstitutions) {
+function matchPremises(premise, metaAssertions, metaSubstitutions) {
   const premisesMatches = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, metastatementNodes, metaSubstitutions);
+    const premiseMatches = matchPremise(premise, metaAssertions, metaSubstitutions);
 
     if (premiseMatches) {
       return true;
@@ -91,11 +94,11 @@ function matchConclusion(conclusion, metastatementNode, metaSubstitutions) {
   return conclusionMatches;
 }
 
-function matchPremisesAndConclusion(premises, conclusion, metastatementNodes, metastatementNode) {
+function matchPremisesAndConclusion(premises, conclusion, metaAssertions, metastatementNode) {
   let premisesMatchConclusion = false;
 
   const metaSubstitutions = [],
-        premisesMatches = matchPremises(premises, metastatementNodes, metaSubstitutions);
+        premisesMatches = matchPremises(premises, metaAssertions, metaSubstitutions);
 
   if (premisesMatches) {
     const conclusionMatches = matchConclusion(conclusion, metastatementNode, metaSubstitutions);

package/bin/verify/conditinalInference.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const verifyMetaproof = require("../verify/metaproof"),
+      MetaproofContext = require("../context/metaproof"),
       verifyConclusion = require("../verify/conclusion"),
       verifyPremiseOrPremises = require("../verify/premiseOrPremises");
 
@@ -13,6 +14,10 @@ const metaproofNodeQuery = nodeQuery("/conditionalInference/metaproof!"),
 function verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context) {
   let conditionalInferenceVerified = false;
 
+  const metaproofContext = MetaproofContext.fromContext(context);
+
+  context = metaproofContext; ///
+
   const premiseOrPremisesNode = premiseOrPremisesNodeQuery(conditionalInferenceNode),
         premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
 

package/bin/verify/metaDerivation.js

@@ -68,6 +68,7 @@ function verifyMetaDerivation(metaDerivationNode, context) {
 
                 metaDerivationChildNodeVerified = true;
               }
+
               break;
             }
           }

package/bin/verify/metaproof.js

@@ -3,9 +3,7 @@
 const verifyMetaDerivation = require("../verify/metaDerivation"),
       verifyQualifiedMetastatement = require("../verify/metastatement/qualified");
 
-const { first } = require("../utilities/array"),
-      { nodeQuery } = require("../utilities/query"),
-      { nodeAsString } = require("../utilities/string");
+const { nodeQuery } = require("../utilities/query");
 
 const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement!/metastatement!"),
       metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),

package/bin/verify/metastatement/qualified.js

@@ -2,8 +2,6 @@
 
 const { loggingUtilities } = require("necessary");
 
-const MetaAssertion = require("../../metaAssertion");
-
 const { nodeAsString } = require("../../utilities/string"),
       { nodeQuery, referenceNameFromReferenceNode } = require("../../utilities/query");
 

package/bin/verify/rule.js

@@ -4,7 +4,6 @@ const { loggingUtilities } = require("necessary");
 
 const Rule = require("../rule"),
       verifyLabels = require("../verify/labels"),
-      MetaproofContext = require("../context/metaproof"),
       verifyConditionalInference = require("../verify/conditinalInference"),
       verifyUnconditionalInference = require("../verify/unconditionalInference");
 
@@ -30,10 +29,6 @@ function verifyRule(ruleNode, context) {
         labelsVerified = verifyLabels(labelNodes, labels, context);
 
   if (labelsVerified) {
-    const metaproofContext = MetaproofContext.fromContext(context);
-
-    context = metaproofContext; ///
-
     const premises = [],
           conclusions = [],
           conditionalInferenceNode = conditionalInferenceNodeQuery(ruleNode),

package/bin/verify/unconditionalInference.js

@@ -1,27 +1,43 @@
 "use strict";
 
 const Conclusion = require("../conclusion"),
+      verifyMetaproof = require("../verify/metaproof"),
+      MetaproofContext = require("../context/metaproof"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery } = require("../utilities/query");
 
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+const metaproofNodeQuery = nodeQuery("/unconditionalInference/metaproof!"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/unconditionalInference/unqualifiedMetastatement!");
 
 function verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, context) {
   let unconditionalInferenceVerified = false;
 
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(unconditionalInferenceNode);
+  const metaproofContext = MetaproofContext.fromContext(context);
 
-  const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+  context = metaproofContext; ///
+
+  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(unconditionalInferenceNode),
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
   if (unqualifiedMetastatementVerified) {
-    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-          conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+    let metaproofVerified = true;
+
+    const metaproofNode = metaproofNodeQuery(unconditionalInferenceNode);
+
+    if (metaproofNode !== null) {
+      metaproofVerified = verifyMetaproof(metaproofNode, context);
+    }
+
+    if (metaproofVerified) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            conclusion = Conclusion.fromMetastatementNode(metastatementNode);
 
-    conclusions.push(conclusion);
+      conclusions.push(conclusion);
 
-    unconditionalInferenceVerified = true;
+      unconditionalInferenceVerified = true;
+    }
   }
 
   return unconditionalInferenceVerified;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.269",
+  "version": "0.0.270",
   "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.350",
+    "occam-custom-grammars": "^5.0.351",
     "occam-dom": "^3.0.171",
     "occam-grammar-utilities": "^7.0.66",
-    "occam-grammars": "^1.0.317",
+    "occam-grammars": "^1.0.318",
     "occam-open-cli": "^5.0.37",
     "occam-parsers": "^16.0.122"
   },