occam-verify-cli 0.0.843 → 0.0.845

package/src/verifier/nodes/substitution.js

@@ -0,0 +1,122 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+
+import TermForVariableSubstitution from "../../substitution/termForVariable";
+
+import { nodeQuery } from "../../utilities/query";
+import { TERM_RULE_NAME } from "../../ruleNames";
+
+const variableNodeQuery = nodeQuery("/term/variable");
+
+class SubstitutionNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const ruleName = nonTerminalNodeARuleName;  ///
+
+      switch (ruleName) {
+        case TERM_RULE_NAME: {
+          const termNodeA = nonTerminalNodeA, ///
+                termNodeB = nonTerminalNodeB, ///
+                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = termNodeVerified; ///
+
+          break;
+        }
+
+        default: {
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let termNodeVerified;
+
+    const variableNodeA = variableNodeQuery(termNodeA);
+
+    if (variableNodeA !== null) {
+      const variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+      termNodeVerified = variableNodeVerified; ///
+    } else {
+      const nonTerminalNodeA = termNodeA, ///
+            nonTerminalNodeB = termNodeB, ///
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+      termNodeVerified = nonTerminalNodeVerified; ///
+    }
+
+    return termNodeVerified;
+  }
+
+  verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let variableNodeVerified = false;
+
+    const variableNodeB = variableNodeQuery(termNodeB);
+
+    if (variableNodeB !== null) {
+      const variableNodeAMatchedVariableNodeB = variableNodeA.match(variableNodeB);
+
+      if (variableNodeAMatchedVariableNodeB) {
+        const verifiedAhead = verifyAhead();
+
+        variableNodeVerified = verifiedAhead;
+      }
+    } else {
+      const variableNode = variableNodeA; ///
+
+      const substitution = substitutions.find((substitution) => {
+        const matches = substitution.matchVariableNode(variableNode);
+
+        if (matches) {
+          return true;
+        }
+      }) || null;
+
+      if (substitution !== null) {
+        const termNode = termNodeB, ///
+              termNodeMatches = substitution.matchTermNode(termNode);
+
+        if (termNodeMatches) {
+          const verifiedAhead = verifyAhead();
+
+          variableNodeVerified = verifiedAhead;  ///
+        }
+      } else {
+        let verifiedAhead;
+
+        const termNode = termNodeB, ///
+              termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
+              substitution = termForVariableSubstitution; ///
+
+        substitutions.push(substitution);
+
+        verifiedAhead = verifyAhead();
+
+        if (!verifiedAhead) {
+          substitutions.pop();
+        }
+
+        variableNodeVerified = verifiedAhead;
+      }
+    }
+
+    return variableNodeVerified;
+  }
+}
+
+const substitutionNodesVerifier = new SubstitutionNodesVerifier();
+
+export default substitutionNodesVerifier;

package/src/verify/containment.js

@@ -4,33 +4,59 @@ import { second } from "../utilities/array";
 import { CONTAINED } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const variableNodesQuery = nodesQuery("/metaArgument//variable"),
-      containmentVariableNodeQuery = nodeQuery("/argument/term/variable!");
+const termNodeQuery = nodeQuery("/argument/term!"),
+      variableNodeQuery = nodeQuery("/argument/term/variable!"),
+      metaArgumentTermNodesQuery = nodesQuery("/metaArgument//term"),
+      metaArgumentVariableNodesQuery = nodesQuery("/metaArgument//variable");
 
 export default function verifyContainment(argumentNode, containmentNode, metaArgumentNode, context) {
   let containmentVerified = false;
 
-  const containmentVariableNode = containmentVariableNodeQuery(argumentNode);
+  const contained = containedFromContainmentNode(containmentNode),
+        termNode = termNodeQuery(argumentNode),
+        variableNode = variableNodeQuery(argumentNode);
 
-  if (containmentVariableNode !== null) {
-    const contained = containedFromContainmentNode(containmentNode),
-          variableNodes = variableNodesQuery(metaArgumentNode),
-          containmentVariableNodeMatchesStatementVariableNode = variableNodes.some((statementVariableNode) => {
-            const containmentVariableNodeMatchesStatementVariableNode = containmentVariableNode.match(statementVariableNode);
+  if (false) {
+    ///
+  } else if (variableNode !== null) {
+    const metaArgumentVariableNodes = metaArgumentVariableNodesQuery(metaArgumentNode),
+          variableNodeMatchesMetaArgumentVariableNode = metaArgumentVariableNodes.some((metaArgumentVariableNode) => {
+            const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metaArgumentVariableNode);
 
-            if (containmentVariableNodeMatchesStatementVariableNode) {
+            if (variableNodeMatchesMetaArgumentVariableNode) {
               return true;
             }
           });
 
     if (contained) {
-      if (containmentVariableNodeMatchesStatementVariableNode) {
+      if (variableNodeMatchesMetaArgumentVariableNode) {
         containmentVerified = true;
       }
     }
 
     if (!contained) {
-      if (!containmentVariableNodeMatchesStatementVariableNode) {
+      if (!variableNodeMatchesMetaArgumentVariableNode) {
+        containmentVerified = true;
+      }
+    }
+  } else if (termNode !== null) {
+    const metaArgumentTermNodes = metaArgumentTermNodesQuery(metaArgumentNode),
+          termNodeMatchesMetaArgumentTermNode = metaArgumentTermNodes.some((metaArgumentTermNode) => {
+            const termNodeMatchesMetaArgumentTermNode = termNode.match(metaArgumentTermNode);
+
+            if (termNodeMatchesMetaArgumentTermNode) {
+              return true;
+            }
+          });
+
+    if (contained) {
+      if (termNodeMatchesMetaArgumentTermNode) {
+        containmentVerified = true;
+      }
+    }
+
+    if (!contained) {
+      if (!termNodeMatchesMetaArgumentTermNode) {
         containmentVerified = true;
       }
     }

package/src/verify/defining.js

@@ -1,32 +1,67 @@
 "use strict";
 
-import { second } from "../utilities/array";
+import verifyTerm from "./term";
+
 import { DEFINED } from "../constants";
 import { nodeQuery } from "../utilities/query";
+import { first, second } from "../utilities/array";
 
-const definedVariableNodeQuery = nodeQuery("/argument/term/variable!");
+const termNodeQuery = nodeQuery("/argument/term!"),
+      variableNodeQuery = nodeQuery("/argument/term/variable!");
 
 export default function verifyDefining(argumentNode, definingNode, context) {
   let definingVerified = false;
 
-  const definedVariableNode = definedVariableNodeQuery(argumentNode);
+  const defined = definedFromDefiningNode(definingNode),
+        termNode = termNodeQuery(argumentNode),
+        variableNode = variableNodeQuery(argumentNode);
+
+  if (false) {
+    ///
+  } else if (variableNode !== null) {
+    const variable = context.findVariableByVariableNode(variableNode);
 
-  if (definedVariableNode !== null) {
-    const defined = definedFromDefiningNode(definingNode),
-          variableNode = definedVariableNode, ///
-          variableDefined = context.isVariableDefined(variableNode);
+    if (variable !== null) {
+      const variableDefined = context.isVariableDefined(variable);
 
-    if (defined) {
-      if (variableDefined) {
-        definingVerified = true;
+      if (defined) {
+        if (variableDefined) {
+          definingVerified = true;
+        }
       }
-    }
 
-    if (!defined) {
-      if (!variableDefined) {
-        definingVerified = true;
+      if (!defined) {
+        if (!variableDefined) {
+          definingVerified = true;
+        }
       }
     }
+  } else if (termNode !== null) {
+    const terms = [],
+          termVerified = verifyTerm(termNode, terms, context, () => {
+            let verifiedAhead;
+
+            const firstTerm = first(terms),
+                  term = firstTerm, ///
+                  termGrounded = context.isTermGrounded(term);
+
+            if (defined) {
+              if (termGrounded) {
+                verifiedAhead = true;
+              }
+            }
+
+            if (!defined) {
+              if (!termGrounded) {
+                verifiedAhead = true;
+              }
+            }
+
+            return verifiedAhead;
+          });
+
+    definingVerified = termVerified;  ///
+
   }
 
   return definingVerified;