occam-verify-cli 0.0.506 → 0.0.508

package/src/substitution/statementForVariable.js

@@ -0,0 +1,64 @@
+"use strict";
+
+import { matcher } from "../matcher";
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
+
+export default class StatementForVariableSubstitution {
+  constructor(variableName, statementNode) {
+    this.variableName = variableName;
+    this.statementNode = statementNode;
+  }
+
+  getVariableName() {
+    return this.variableName;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  matchStatementNode(statementNode) {
+    let matchesStatementNode;
+
+    const nodeA = this.statementNode,  ///
+          nodeB = statementNode,
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+    matchesStatementNode = nodeMatches;  ///
+
+    if (!matchesStatementNode) {
+      const nonTerminalNode = statementNode,  ///
+            childNodes = nonTerminalNode.getChildNodes(), ///
+            ruleName = STATEMENT_RULE_NAME;
+
+      statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+
+      if (statementNode !== null) {
+        const nodeA = this.statementNode,  ///
+              nodeB = statementNode,
+              nodeMatches = matchNode(nodeA, nodeB);
+
+        matchesStatementNode = nodeMatches;  ///
+      }
+    }
+
+    return matchesStatementNode;
+  }
+
+  static fromVariableNameAndStatementNode(variableName, statementNode) {
+    let statementForVariableSubstitution = new StatementForVariableSubstitution(variableName, statementNode);
+
+    const nonTerminalNode = statementNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          ruleName = STATEMENT_RULE_NAME;
+
+    statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+
+    if (statementNode !== null) {
+      statementForVariableSubstitution = new StatementForVariableSubstitution(variableName, statementNode);
+    }
+
+    return statementForVariableSubstitution;
+  }
+}

package/src/supposition.js

@@ -1,18 +1,14 @@
 "use strict";
 
-import Substitution from "./substitution";
-
-import { first } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { variableNameFromVariableNode } from "./utilities/query";
 import { statementNodeFromStatementString } from "./utilities/string";
-import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
+import { suppositionStatementForVariableMatcher } from "./matcher/statementForVariable/supposition";
 
-const statementNodesQuery = nodesQuery("/subproofAssertion/statement"),
-      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      unqualifiedStatementStatementNodesQuery = nodesQuery("/subproof/unqualifiedStatement/statement!"),
-      qualifiedOrUnqualifiedStatementStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!");
+const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
+      subproofSubDerivationLastStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!");
 
 export default class Supposition {
   constructor(statementNode) {
@@ -29,27 +25,27 @@ export default class Supposition {
     const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
 
     if (subproofAssertionNode !== null) {
-      const subproofAssertionStatementNodes = statementNodesQuery(subproofAssertionNode),
-            unqualifiedStatementStatementNodes = unqualifiedStatementStatementNodesQuery(subproofNode),
-            qualifiedOrUnqualifiedStatementStatementNode = qualifiedOrUnqualifiedStatementStatementNodeQuery(subproofNode),
-            statementNodes = [
-              ...unqualifiedStatementStatementNodes,
-              qualifiedOrUnqualifiedStatementStatementNode
+      const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+            subproofSubDerivationLastStatementNode = subproofSubDerivationLastStatementNodeQuery(subproofNode),
+            subproofStatementNodes = [
+              ...subproofSuppositionStatementNodes,
+              subproofSubDerivationLastStatementNode
             ],
-            statementNodesLength = statementNodes.length,
+            subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode),
+            subproofStatementNodesLength = subproofStatementNodes.length,
             subproofAssertionStatementNodesLength = subproofAssertionStatementNodes.length;
 
-      if (statementNodesLength === subproofAssertionStatementNodesLength) {
+      if (subproofStatementNodesLength === subproofAssertionStatementNodesLength) {
         subproofNodeMatches = subproofAssertionStatementNodes.every((subproofAssertionStatementNode, index) => {
-                                    const statementNode = statementNodes[index],
-                                          nonTerminalNode = statementNode, ///
-                                          suppositionNonTerminalNode = subproofAssertionStatementNode,  ///
-                                          suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
-
-                                    if (suppositionNonTerminalNodeMatches) {
-                                      return true;
-                                    }
-                                  });
+                                const subproofStatementNode = subproofStatementNodes[index],
+                                      nonTerminalNodeA = subproofAssertionStatementNode,  ///
+                                      nonTerminalNodeB = subproofStatementNode, ///
+                                      nonTerminalNodeMatches = suppositionStatementForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+
+                                if (nonTerminalNodeMatches) {
+                                  return true;
+                                }
+                              });
       }
     }
 
@@ -57,10 +53,10 @@ export default class Supposition {
   }
 
   matchStatementNode(statementNode, substitutions) {
-    const nonTerminalNode = statementNode,  ///
-          suppositionNonTerminalNode = this.statementNode,  ///
-          suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions),
-          statementNodeMatches = suppositionNonTerminalNodeMatches; ///
+    const nonTerminalNodeA = this.statementNode,  ///
+          nonTerminalNodeB = statementNode,  ///
+          nonTerminalNodeMatches = suppositionStatementForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
   }
@@ -90,146 +86,3 @@ export default class Supposition {
     return supposition;
   }
 }
-
-function matchSuppositionNode(suppositionNode, node, substitutions) {
-  let suppositionNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = suppositionNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            suppositionTerminalNode = suppositionNode,  ///
-            suppositionTerminalNodeMatches = matchSuppositionTerminalNode(suppositionTerminalNode, terminalNode, substitutions);
-
-      suppositionNodeMatches = suppositionTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            suppositionNonTerminalNode = suppositionNode,  ///
-            suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
-
-      suppositionNodeMatches = suppositionNonTerminalNodeMatches; ///
-    }
-  }
-
-  return suppositionNodeMatches;
-}
-
-function matchSuppositionNodes(suppositionNodes, nodes, substitutions) {
-  let suppositionNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        suppositionNodesLength = suppositionNodes.length;
-
-  if (nodesLength === suppositionNodesLength) {
-    suppositionNodesMatches = nodes.every((node, index) => {
-      const suppositionNode = suppositionNodes[index],
-            suppositionNodeMatches = matchSuppositionNode(suppositionNode, node, substitutions);
-
-      if (suppositionNodeMatches) {
-        return true;
-      }
-    });
-  }
-
-  return suppositionNodesMatches;
-}
-
-function matchSuppositionVariable(suppositionVariableNode, nodes, substitutions) {
-  let suppositionVariableMatches;
-
-  const suppositionVariableName = variableNameFromVariableNode(suppositionVariableNode),
-        substitution = substitutions.find((substitution) => {
-          const variableName = substitution.getVariableName();
-
-          if (variableName === suppositionVariableName) {
-            return true;
-          }
-        }) || null;
-
-  if (substitution !== null) {
-    const substitutionNodesMatch = substitution.matchNodes(nodes);
-
-    suppositionVariableMatches = substitutionNodesMatch;  ///
-  } else {
-    const variableName = suppositionVariableName, ///
-          substitution = Substitution.fromVariableNameAndNodes(variableName, nodes);
-
-    substitutions.push(substitution);
-
-    suppositionVariableMatches = true;
-  }
-
-  return suppositionVariableMatches;
-}
-
-function matchSuppositionTerminalNode(suppositionTerminalNode, terminalNode, substitutions) {
-  const matches = suppositionTerminalNode.match(terminalNode),
-        suppositionTerminalNodeMatches = matches;
-
-  return suppositionTerminalNodeMatches;
-}
-
-function matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions) {
-  let suppositionNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        suppositionRuleName = suppositionNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === suppositionRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          suppositionChildNodes = suppositionNonTerminalNode.getChildNodes(),
-          nodes = childNodes, ///
-          suppositionNodes = suppositionChildNodes, ///
-          suppositionChildNodesMatches = matchSuppositionNodes(suppositionNodes, nodes, substitutions);
-
-    suppositionNonTerminalNodeMatches = suppositionChildNodesMatches; ///
-
-    if (!suppositionNonTerminalNodeMatches) {
-      const ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME);
-
-      if (ruleNameStatementRuleName) {
-        const statementNode = nonTerminalNode,  ///
-              suppositionStatementNode = suppositionNonTerminalNode,  ///
-              suppositionStatementNodeMatches = matchSuppositionStatementNode(suppositionStatementNode, statementNode, substitutions);
-
-        suppositionNonTerminalNodeMatches = suppositionStatementNodeMatches; ///
-      }
-    }
-  }
-
-  return suppositionNonTerminalNodeMatches;
-}
-
-function matchSuppositionStatementNode(suppositionStatementNode, statementNode, substitutions) {
-  let suppositionStatementNodeMatches = false;
-
-  const suppositionNonTerminalNode = suppositionStatementNode,  ///
-        suppositionChildNodes = suppositionNonTerminalNode.getChildNodes(),
-        suppositionChildNodesLength = suppositionChildNodes.length;
-
-  if (suppositionChildNodesLength === 1) {
-    const firstSuppositionChildNode = first(suppositionChildNodes),
-          suppositionChildNode = firstSuppositionChildNode,  ///
-          suppositionChildNodeNonTerminalNode = suppositionChildNode.isNonTerminalNode();
-
-    if (suppositionChildNodeNonTerminalNode) {
-      const suppositionNonTerminalChildNode = suppositionChildNode,  ///
-            suppositionNonTerminalChildNodeRuleName = suppositionNonTerminalChildNode.getRuleName(),
-            suppositionNonTerminalChildNodeRuleNameVariableRuleName = (suppositionNonTerminalChildNodeRuleName === VARIABLE_RULE_NAME);
-
-      if (suppositionNonTerminalChildNodeRuleNameVariableRuleName) {
-        const suppositionVariableNode = suppositionNonTerminalChildNode,  ///
-              nonTerminalNode = statementNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              suppositionVariableMatches = matchSuppositionVariable(suppositionVariableNode, nodes, substitutions);
-
-        suppositionStatementNodeMatches = suppositionVariableMatches; ///
-      }
-    }
-  }
-
-  return suppositionStatementNodeMatches;
-}

package/src/utilities/{node.js → substitution.js}

@@ -1,59 +1,15 @@
 "use strict";
 
-import { first, second, third } from "./array";
+import { matcher } from "../matcher";
+import { first, second, third } from "../utilities/array";
 import { METASTATEMENT_RULE_NAME } from "../ruleNames";
 import { BRACKETED_CHILD_NODES_LENGTH, LEFT_BRACKET, RIGHT_BRACKET } from "../constants";
 
-export function matchNode(nodeA, nodeB) {
-  let nodeMatches = false;
-
-  const nodeATerminalNode = nodeA.isTerminalNode(),
-        nodeBTerminalNode = nodeB.isTerminalNode();
-
-  if (nodeATerminalNode === nodeBTerminalNode) {
-    if (nodeATerminalNode) {
-      const terminalNodeA = nodeA,  ///
-            terminalNodeB = nodeB,  ///
-            terminalNodeMatches = matchTerminalNode(terminalNodeA, terminalNodeB);
-
-      nodeMatches = terminalNodeMatches;  ///
-    } else {
-      const nonTerminalNodeA = nodeA,  ///
-            nonTerminalNodeB = nodeB, ///
-            nonTerminalNodeMatches = matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
-
-      nodeMatches = nonTerminalNodeMatches; ///
-    }
-  }
-
-  return nodeMatches;
-}
-
-export function matchNodes(nodesA, nodesB) {
-  let nodesMatch = false;
-
-  const nodesALength = nodesA.length,
-        nodesBLength = nodesB.length;
-
-  if (nodesALength === nodesBLength) {
-    nodesMatch = nodesA.every((nodeA, index) => {
-      const nodeB = nodesB[index],
-            nodeMatches = matchNode(nodeA, nodeB);
-
-      if (nodeMatches) {
-        return true;
-      }
-    })
-  }
-
-  return nodesMatch;
-}
-
 export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB) {
   let bracketedNodeMatches = false;
 
   if (!bracketedNodeMatches) {
-    const nonTerminalNodeMatches = matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
+    const nonTerminalNodeMatches = matcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
 
     bracketedNodeMatches = nonTerminalNodeMatches;  ///
   }
@@ -66,7 +22,7 @@ export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB
     if (bracketedNonTerminalChildNodeA !== null) {
       const nodeA = bracketedNonTerminalChildNodeA,  ///
             nodeB = nonTerminalNodeB, ///
-            nodeMatches = matchNode(nodeA, nodeB);
+            nodeMatches = matcher.matchNode(nodeA, nodeB);
 
       bracketedNodeMatches = nodeMatches; ///
     }
@@ -121,29 +77,3 @@ export function bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName
 
   return bracketedNonTerminalChildNode;
 }
-
-function matchTerminalNode(terminalNodeA, terminalNodeB) {
-  const matches = terminalNodeA.match(terminalNodeB),
-        terminalNodeMatches = matches;  ///
-
-  return terminalNodeMatches;
-}
-
-function matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB) {
-  let nonTerminalNodeMatches = false;
-
-  const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
-        nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
-
-  if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
-    const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-          nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-          nodesA = nonTerminalNodeAChildNodes, ///
-          nodesB = nonTerminalNodeBChildNodes, ///
-          nodesMatch = matchNodes(nodesA, nodesB);
-
-    nonTerminalNodeMatches = nodesMatch; ///
-  }
-
-  return nonTerminalNodeMatches;
-}

package/src/verify/metaproof.js

@@ -2,7 +2,7 @@
 
 import verifyMetaDerivation from "../verify/metaDerivation";
 
-import { matchNode } from "../utilities/node";
+import { matcher } from "../matcher";
 import { nodeQuery } from "../utilities/query";
 
 const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!");
@@ -22,7 +22,7 @@ export default function verifyMetaproof(metaproofNode, conclusion, metaproofCont
           conclusionMetastatementNode = conclusion.getMetastatementNode(),
           nodeA = metastatementNode,  ///
           nodeB = conclusionMetastatementNode,  ///
-          nodeMatches = matchNode(nodeA, nodeB);
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
 
     metaproofVerified = nodeMatches;  ///
   }

package/src/verify/proof.js

@@ -2,7 +2,7 @@
 
 import verifyDerivation from "../verify/derivation";
 
-import { matchNode } from "../utilities/node";
+import { matcher } from "../matcher";
 import { nodeQuery } from "../utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation!");
@@ -22,7 +22,7 @@ export default function verifyProof(proofNode, conclusion, proofContext) {
           conclusionStatementNode = conclusion.getStatementNode(),
           nodeA = statementNode,  ///
           nodeB = conclusionStatementNode,  ///
-          nodeMatches = matchNode(nodeA, nodeB);
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
 
     proofVerified = nodeMatches;  ///
   }

package/src/verify/ruleProof.js

@@ -2,7 +2,7 @@
 
 import verifyRuleDerivation from "../verify/ruleDerivation";
 
-import { matchNode } from "../utilities/node";
+import { matcher } from "../matcher";
 import { nodeQuery } from "../utilities/query";
 
 const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
@@ -22,7 +22,7 @@ export default function verifyRuleProof(ruleProofNode, conclusion, metaproofCont
           conclusionMetastatementNode = conclusion.getMetastatementNode(),
           nodeA = metastatementNode,  ///
           nodeB = conclusionMetastatementNode,  ///
-          nodeMatches = matchNode(nodeA, nodeB);
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
 
     ruleProofVerified = nodeMatches;  ///
   }

package/lib/metaSubstitution.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return MetaSubstitution;
-    }
-});
-var _ruleNames = require("./ruleNames");
-var _node = require("./utilities/node");
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-var MetaSubstitution = /*#__PURE__*/ function() {
-    function MetaSubstitution(metavariableName, metastatementNode) {
-        _classCallCheck(this, MetaSubstitution);
-        this.metavariableName = metavariableName;
-        this.metastatementNode = metastatementNode;
-    }
-    _createClass(MetaSubstitution, [
-        {
-            key: "getMetavariableName",
-            value: function getMetavariableName() {
-                return this.metavariableName;
-            }
-        },
-        {
-            key: "getMetastatementNode",
-            value: function getMetastatementNode() {
-                return this.metastatementNode;
-            }
-        },
-        {
-            key: "matchMetastatementNode",
-            value: function matchMetastatementNode(metastatementNode) {
-                var matchesMetastatementNode;
-                var nodeA = this.metastatementNode, nodeB = metastatementNode, nodeMatches = (0, _node.matchNode)(nodeA, nodeB);
-                matchesMetastatementNode = nodeMatches; ///
-                if (!matchesMetastatementNode) {
-                    var nonTerminalNode = metastatementNode, childNodes = nonTerminalNode.getChildNodes(), ruleName = _ruleNames.METASTATEMENT_RULE_NAME;
-                    metastatementNode = (0, _node.bracketedNonTerminalChildNodeFromChildNodes)(childNodes, ruleName); ///
-                    if (metastatementNode !== null) {
-                        var nodeA1 = this.metastatementNode, nodeB1 = metastatementNode, nodeMatches1 = (0, _node.matchNode)(nodeA1, nodeB1);
-                        matchesMetastatementNode = nodeMatches1; ///
-                    }
-                }
-                return matchesMetastatementNode;
-            }
-        }
-    ], [
-        {
-            key: "fromMetavariableNameAndMetastatementNode",
-            value: function fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode) {
-                var metaSubstitution = new MetaSubstitution(metavariableName, metastatementNode);
-                var nonTerminalNode = metastatementNode, childNodes = nonTerminalNode.getChildNodes(), ruleName = _ruleNames.METASTATEMENT_RULE_NAME;
-                metastatementNode = (0, _node.bracketedNonTerminalChildNodeFromChildNodes)(childNodes, ruleName); ///
-                if (metastatementNode !== null) {
-                    metaSubstitution = new MetaSubstitution(metavariableName, metastatementNode);
-                }
-                return metaSubstitution;
-            }
-        }
-    ]);
-    return MetaSubstitution;
-}();
-
-//# sourceMappingURL=data:application/json;base64,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