occam-verify-cli 0.0.505 → 0.0.507

package/src/matcher/premise.js

@@ -0,0 +1,94 @@
+"use strict";
+
+import Matcher from "../matcher";
+import Substitution from "../substitution";
+
+import { first } from "../utilities/array";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME} from "../ruleNames";
+
+class PremiseMatcher extends Matcher {
+  matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const ruleName = nonTerminalNode.getRuleName(),
+          premiseNonTerminalNodeRuleName = premiseNonTerminalNode.getRuleName(),
+          ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME),
+          premiseNonTerminalNodeRuleNameMetastatementRuleName = (premiseNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+
+    if (ruleNameStatementRuleName && premiseNonTerminalNodeRuleNameMetastatementRuleName) {
+      const statementNode = nonTerminalNode,  ///
+            premiseMetastatementNode = premiseNonTerminalNode,  ///
+            metastatementNodeMatches = this.matchMetastatementNode(premiseMetastatementNode, statementNode, substitutions);
+
+      if (metastatementNodeMatches) {
+        nonTerminalNodeMatches = true;
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
+      }
+    } else if (ruleName === premiseNonTerminalNodeRuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchMetavariableNode(premiseMetavariableNode, statementNode, substitutions) {
+    let metavariableNodeMatches;
+
+    const premiseMetavariableName = metavariableNameFromMetavariableNode(premiseMetavariableNode),
+          substitution = substitutions.find((substitution) => {
+            const metavariableName = substitution.getMetavariableName();
+
+            if (metavariableName === premiseMetavariableName) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const substitutionNodesMatch = substitution.matchStatementNode(statementNode);
+
+      metavariableNodeMatches = substitutionNodesMatch;  ///
+    } else {
+      const metavariableName = premiseMetavariableName, ///
+            substitution = Substitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode);
+
+      substitutions.push(substitution);
+
+      metavariableNodeMatches = true;
+    }
+
+    return metavariableNodeMatches;
+  }
+
+  matchMetastatementNode(premiseMetastatementNode, statementNode, substitutions) {
+    let metastatementNodeMatches = false;
+
+    const premiseNonTerminalNode = premiseMetastatementNode,  ///
+          premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
+          premiseNonTerminalNodeChildNodesLength = premiseNonTerminalNodeChildNodes.length;
+
+    if (premiseNonTerminalNodeChildNodesLength === 1) {
+      const firstPremiseChildNode = first(premiseNonTerminalNodeChildNodes),
+            premiseChildNode = firstPremiseChildNode,  ///
+            premiseChildNodeNonTerminalNode = premiseChildNode.isNonTerminalNode();
+
+      if (premiseChildNodeNonTerminalNode) {
+        const premiseNonTerminalChildNode = premiseChildNode,  ///
+              premiseNonTerminalChildNodeRuleName = premiseNonTerminalChildNode.getRuleName(),
+              premiseNonTerminalChildNodeRuleNameMetavariableRuleName = (premiseNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
+
+        if (premiseNonTerminalChildNodeRuleNameMetavariableRuleName) {
+          const premiseMetavariableNode = premiseNonTerminalChildNode,  ///
+                metaVariableNodeMatches = this.matchMetavariableNode(premiseMetavariableNode, statementNode, substitutions);
+
+          metastatementNodeMatches = metaVariableNodeMatches; ///
+        }
+      }
+    }
+
+    return metastatementNodeMatches;
+  }
+}
+
+export const premiseMatcher = new PremiseMatcher();

package/src/matcher/supposition.js

@@ -0,0 +1,97 @@
+"use strict";
+
+import Matcher from "../matcher";
+import Substitution from "../substitution";
+
+import { first } from "../utilities/array";
+import { variableNameFromVariableNode } from "../utilities/query";
+import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+
+class SuppositionMatcher extends Matcher {
+  matchNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const ruleName = nonTerminalNode.getRuleName(),
+          suppositionRuleName = suppositionNonTerminalNode.getRuleName(); ///
+
+    if (ruleName === suppositionRuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
+
+      if (!nonTerminalNodeMatches) {
+        const ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME);
+
+        if (ruleNameStatementRuleName) {
+          const statementNode = nonTerminalNode,  ///
+                suppositionStatementNode = suppositionNonTerminalNode,  ///
+                statementNodeMatches = this.matchStatementNode(suppositionStatementNode, statementNode, substitutions);
+
+          nonTerminalNodeMatches = statementNodeMatches; ///
+        }
+      }
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchStatementNode(suppositionStatementNode, statementNode, substitutions) {
+    let statementNodeMatches = 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, ///
+                variableMatches = this.matchVariable(suppositionVariableNode, nodes, substitutions);
+
+          statementNodeMatches = variableMatches; ///
+        }
+      }
+    }
+
+    return statementNodeMatches;
+  }
+
+  matchVariable(suppositionVariableNode, nodes, substitutions) {
+    let variableMatches;
+
+    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);
+
+      variableMatches = substitutionNodesMatch;  ///
+    } else {
+      const variableName = suppositionVariableName, ///
+            substitution = Substitution.fromVariableNameAndNodes(variableName, nodes);
+
+      substitutions.push(substitution);
+
+      variableMatches = true;
+    }
+
+    return variableMatches;
+  }
+}
+
+export const suppositionMatcher = new SuppositionMatcher();

package/src/matcher.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import matcherMixins from "./mixins/matcher";
+
+export default class Matcher {}
+
+Object.assign(Matcher.prototype, matcherMixins);
+
+export const matcher = new Matcher();

package/src/metaMatcher/conclusion.js

@@ -0,0 +1,86 @@
+"use strict";
+
+import MetaMatcher from "../metaMatcher";
+
+import { first } from "../utilities/array";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "../ruleNames";
+
+class ConclusionMetaMatcher extends MetaMatcher {
+  matchNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const ruleName = nonTerminalNode.getRuleName(),
+          conclusionNonTerminalNodeRuleName = conclusionNonTerminalNode.getRuleName(),
+          ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME),
+          conclusionNonTerminalNodeRuleNameMetastatementRuleName = (conclusionNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+
+    if (ruleNameMetastatementRuleName && conclusionNonTerminalNodeRuleNameMetastatementRuleName) {
+      const statementNode = nonTerminalNode,  ///
+            conclusionMetastatementNode = conclusionNonTerminalNode,  ///
+            metastatementNodeMatches = this.matchMetastatementNode(conclusionMetastatementNode, statementNode, metaSubstitutions);
+
+      if (metastatementNodeMatches) {
+        nonTerminalNodeMatches = true; ///
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions);
+      }
+    } else if (ruleName === conclusionNonTerminalNodeRuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions);
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchMetavariableNode(conclusionMetavariableNode, metastatementNode, metaSubstitutions) {
+    let metavariableNodeMatches = true;
+
+    const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
+          metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+            const metavariableName = metaSubstitution.getMetavariableName();
+
+            if (metavariableName === conclusionMetavariableName) {
+              return true;
+            }
+          }) || null;
+
+    if (metaSubstitution !== null) {
+      const metaSubstitutionNodesMatch = metaSubstitution.matchMetastatementNode(metastatementNode);
+
+      metavariableNodeMatches = metaSubstitutionNodesMatch;  ///
+    }
+
+    return metavariableNodeMatches;
+  }
+
+  matchMetastatementNode(conclusionMetastatementNode, metastatementNode, metaSubstitutions) {
+    let metastatementNodeMatches = false;
+
+    const conclusionNonTerminalNode = conclusionMetastatementNode,  ///
+          conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
+          conclusionNonTerminalNodeChildNodesLength = conclusionNonTerminalNodeChildNodes.length;
+
+    if (conclusionNonTerminalNodeChildNodesLength === 1) {
+      const firstConclusionChildNode = first(conclusionNonTerminalNodeChildNodes),
+            conclusionChildNode = firstConclusionChildNode,  ///
+            conclusionChildNodeNonTerminalNode = conclusionChildNode.isNonTerminalNode();
+
+      if (conclusionChildNodeNonTerminalNode) {
+        const conclusionNonTerminalChildNode = conclusionChildNode,  ///
+              conclusionNonTerminalChildNodeRuleName = conclusionNonTerminalChildNode.getRuleName(),
+              conclusionNonTerminalChildNodeRuleNameMetavariableRuleName = (conclusionNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
+
+        if (conclusionNonTerminalChildNodeRuleNameMetavariableRuleName) {
+          const conclusionMetavariableNode = conclusionNonTerminalChildNode,  ///
+                metavariableNodeMatches = this.matchMetavariableNode(conclusionMetavariableNode, metastatementNode, metaSubstitutions);
+
+          metastatementNodeMatches = metavariableNodeMatches; ///
+        }
+      }
+    }
+
+    return metastatementNodeMatches;
+  }
+}
+
+export const conclusionMetaMatcher = new ConclusionMetaMatcher();

package/src/metaMatcher/premise.js

@@ -0,0 +1,94 @@
+"use strict";
+
+import MetaMatcher from "../metaMatcher";
+import MetaSubstitution from "../metaSubstitution";
+
+import { first } from "../utilities/array";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "../ruleNames";
+
+class PremiseMetaMatcher extends MetaMatcher {
+  matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const ruleName = nonTerminalNode.getRuleName(),
+          premiseNonTerminalNodeRuleName = premiseNonTerminalNode.getRuleName(),
+          ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME),
+          premiseNonTerminalNodeRuleNameMetastatementRuleName = (premiseNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+
+    if (ruleNameMetastatementRuleName && premiseNonTerminalNodeRuleNameMetastatementRuleName) {
+      const metastatementNode = nonTerminalNode,  ///
+            premiseMetastatementNode = premiseNonTerminalNode,  ///
+            metastatementNodeMatches = this.matchMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions);
+
+      if (metastatementNodeMatches) {
+        nonTerminalNodeMatches = true;
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+      }
+    } else if (ruleName === premiseNonTerminalNodeRuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchMetavariableNode(premiseMetavariableNode, metastatementNode, metaSubstitutions) {
+    let metavariableNodeMatches;
+
+    const premiseMetavariableName = metavariableNameFromMetavariableNode(premiseMetavariableNode),
+          metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+            const metavariableName = metaSubstitution.getMetavariableName();
+
+            if (metavariableName === premiseMetavariableName) {
+              return true;
+            }
+          }) || null;
+
+    if (metaSubstitution !== null) {
+      const metaSubstitutionNodesMatch = metaSubstitution.matchMetastatementNode(metastatementNode);
+
+      metavariableNodeMatches = metaSubstitutionNodesMatch;  ///
+    } else {
+      const metavariableName = premiseMetavariableName, ///
+            metaSubstitution = MetaSubstitution.fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode);
+
+      metaSubstitutions.push(metaSubstitution);
+
+      metavariableNodeMatches = true;
+    }
+
+    return metavariableNodeMatches;
+  }
+
+  matchMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions) {
+    let metastatementNodeMatches = false;
+
+    const premiseNonTerminalNode = premiseMetastatementNode,  ///
+          premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
+          premiseNonTerminalNodeChildNodesLength = premiseNonTerminalNodeChildNodes.length;
+
+    if (premiseNonTerminalNodeChildNodesLength === 1) {
+      const firstPremiseChildNode = first(premiseNonTerminalNodeChildNodes),
+            premiseChildNode = firstPremiseChildNode,  ///
+            premiseChildNodeNonTerminalNode = premiseChildNode.isNonTerminalNode();
+
+      if (premiseChildNodeNonTerminalNode) {
+        const premiseNonTerminalChildNode = premiseChildNode,  ///
+              premiseNonTerminalChildNodeRuleName = premiseNonTerminalChildNode.getRuleName(),
+              premiseNonTerminalChildNodeRuleNameMetavariableRuleName = (premiseNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
+
+        if (premiseNonTerminalChildNodeRuleNameMetavariableRuleName) {
+          const premiseMetavariableNode = premiseNonTerminalChildNode,  ///
+                metaVariableNodeMatches = this.matchMetavariableNode(premiseMetavariableNode, metastatementNode, metaSubstitutions);
+
+          metastatementNodeMatches = metaVariableNodeMatches; ///
+        }
+      }
+    }
+
+    return metastatementNodeMatches;
+  }
+}
+
+export const premiseMetaMatcher = new PremiseMetaMatcher();

package/src/metaMatcher.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import matcherMixins from "./mixins/matcher";
+
+export default class MetaMatcher {}
+
+Object.assign(MetaMatcher.prototype, matcherMixins);
+
+export const metaMatcher = new MetaMatcher();

package/src/metaSubstitution.js

@@ -1,7 +1,8 @@
 "use strict";
 
+import { matcher } from "./matcher";
 import { METASTATEMENT_RULE_NAME } from "./ruleNames";
-import { matchNode, bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/node";
+import { bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/substitution";
 
 export default class MetaSubstitution {
   constructor(metavariableName, metastatementNode) {
@@ -22,7 +23,7 @@ export default class MetaSubstitution {
 
     const nodeA = this.metastatementNode,  ///
           nodeB = metastatementNode,
-          nodeMatches = matchNode(nodeA, nodeB);
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
 
     matchesMetastatementNode = nodeMatches;  ///
 
@@ -36,7 +37,7 @@ export default class MetaSubstitution {
       if (metastatementNode !== null) {
         const nodeA = this.metastatementNode,  ///
               nodeB = metastatementNode,
-              nodeMatches = matchNode(nodeA, nodeB);
+              nodeMatches = matcher.matchNode(nodeA, nodeB);
 
         matchesMetastatementNode = nodeMatches;  ///
       }

package/src/mixins/matcher.js

@@ -0,0 +1,81 @@
+"use strict";
+
+function matchNode(nodeA, nodeB, ...remainingArguments) {
+  let nodeMatches = false;
+
+  const nodeATerminalNode = nodeA.isTerminalNode(),
+        nodeBTerminalNode = nodeB.isTerminalNode();
+
+  if (nodeATerminalNode === nodeBTerminalNode) {
+    if (nodeATerminalNode) {
+      const terminalNodeA = nodeA,  ///
+            terminalNodeB = nodeB,  ///
+            terminalNodeMatches = this.matchTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments);
+
+      nodeMatches = terminalNodeMatches;  ///
+    } else {
+      const nonTerminalNodeA = nodeA,  ///
+            nonTerminalNodeB = nodeB, ///
+            nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);
+
+      nodeMatches = nonTerminalNodeMatches; ///
+    }
+  }
+
+  return nodeMatches;
+}
+
+function matchNodes(nodesA, nodesB, ...remainingArguments) {
+  let nodesMatch = false;
+
+  const nodesALength = nodesA.length,
+        nodesBLength = nodesB.length;
+
+  if (nodesALength === nodesBLength) {
+    nodesMatch = nodesA.every((nodeA, index) => {
+      const nodeB = nodesB[index],
+            nodeMatches = this.matchNode(nodeA, nodeB, ...remainingArguments);
+
+      if (nodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return nodesMatch;
+}
+
+function matchTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {
+  const matches = terminalNodeA.match(terminalNodeB),
+        terminalNodeMatches = matches;  ///
+
+  return terminalNodeMatches;
+}
+
+function matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+  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 = this.matchNodes(nodesA, nodesB, ...remainingArguments);
+
+    nonTerminalNodeMatches = nodesMatch; ///
+  }
+
+  return nonTerminalNodeMatches;
+}
+
+const matcherMixins = {
+  matchNode,
+  matchNodes,
+  matchTerminalNode,
+  matchNonTerminalNode
+};
+
+export default matcherMixins;