occam-verify-cli 0.0.506 → 0.0.507

package/src/premise.js

@@ -1,14 +1,10 @@
 "use strict";
 
-import Substitution from "./substitution";
-import MetaSubstitution from "./metaSubstitution";
-
-import { first } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
+import { premiseMatcher } from "./matcher/premise";
+import { premiseMetaMatcher } from "./metaMatcher/premise";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { metavariableNameFromMetavariableNode } from "./utilities/query";
 import { metastatementNodeFromMetastatementString } from "./utilities/string";
-import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "./ruleNames";
 
 const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
       ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion!"),
@@ -47,9 +43,9 @@ export default class Premise {
           const statementNode = statementNodes[index],
                 nonTerminalNode = statementNode, ///
                 premiseNonTerminalNode = ruleSubproofAssertionMetastatementNode,  ///
-                premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
+                nonTerminalNodeMatches = premiseMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
 
-          if (premiseNonTerminalNodeMatches) {
+          if (nonTerminalNodeMatches) {
             return true;
           }
         });
@@ -62,8 +58,8 @@ export default class Premise {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNode = statementNode,  ///
           premiseNonTerminalNode = this.metastatementNode,  ///
-          premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions),
-          statementNodeMatches = premiseNonTerminalNodeMatches; ///
+          nonTerminalNodeMatches = premiseMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions),
+          statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
   }
@@ -89,9 +85,9 @@ export default class Premise {
                                     const metastatementNode = metastatementNodes[index],
                                           nonTerminalNode = metastatementNode, ///
                                           premiseNonTerminalNode = ruleSubproofAssertionMetastatementNode,  ///
-                                          premiseNonTerminalNodeMatches = metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+                                          nonTerminalNodeMatches = premiseMetaMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
 
-                                    if (premiseNonTerminalNodeMatches) {
+                                    if (nonTerminalNodeMatches) {
                                       return true;
                                     }
                                   });
@@ -104,8 +100,8 @@ export default class Premise {
   matchMetastatementNode(metastatementNode, metaSubstitutions) {
     const nonTerminalNode = metastatementNode,  ///
           premiseNonTerminalNode = this.metastatementNode,  ///
-          premiseNonTerminalNodeMatches = metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions),
-          metastatementNodeMatches = premiseNonTerminalNodeMatches; ///
+          nonTerminalNodeMatches = premiseMetaMatcher.matchNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          metastatementNodeMatches = nonTerminalNodeMatches; ///
 
     return metastatementNodeMatches;
   }
@@ -135,287 +131,3 @@ export default class Premise {
     return premise;
   }
 }
-
-function matchPremiseNode(premiseNode, node, substitutions) {
-  let premiseNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-    ruleNodeTerminalNode = premiseNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            premiseTerminalNode = premiseNode,  ///
-            premiseTerminalNodeMatches = matchPremiseTerminalNode(premiseTerminalNode, terminalNode, substitutions);
-
-      premiseNodeMatches = premiseTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            premiseNonTerminalNode = premiseNode,  ///
-            premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions);
-
-      premiseNodeMatches = premiseNonTerminalNodeMatches; ///
-    }
-  }
-
-  return premiseNodeMatches;
-}
-
-function matchPremiseNodes(premiseNodes, nodes, substitutions) {
-  let premiseNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        premiseNodesLength = premiseNodes.length;
-
-  if (nodesLength === premiseNodesLength) {
-    premiseNodesMatches = nodes.every((node, index) => {
-      const premiseNode = premiseNodes[index],
-            premiseNodeMatches = matchPremiseNode(premiseNode, node, substitutions);
-
-      if (premiseNodeMatches) {
-        return true;
-      }
-    });
-  }
-
-  return premiseNodesMatches;
-}
-
-function matchPremiseTerminalNode(premiseTerminalNode, terminalNode, substitutions) {
-  const matches = premiseTerminalNode.match(terminalNode),
-        premiseTerminalNodeMatches = matches;
-
-  return premiseTerminalNodeMatches;
-}
-
-function matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, substitutions) {
-  let premiseNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        childNodes = nonTerminalNode.getChildNodes(),
-        premiseNonTerminalNodeRuleName = premiseNonTerminalNode.getRuleName(),
-        premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
-        nodes = childNodes, ///
-        premiseNodes = premiseNonTerminalNodeChildNodes, ///
-        ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME),
-        premiseNonTerminalNodeRuleNameMetastatementRuleName = (premiseNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
-
-  if (ruleNameStatementRuleName && premiseNonTerminalNodeRuleNameMetastatementRuleName) {
-    const statementNode = nonTerminalNode,  ///
-          premiseMetastatementNode = premiseNonTerminalNode,  ///
-          premiseMetastatementNodeMatches = matchPremiseMetastatementNode(premiseMetastatementNode, statementNode, substitutions);
-
-    if (premiseMetastatementNodeMatches) {
-      premiseNonTerminalNodeMatches = true;
-    } else {
-      const premiseNonTerminalNodeChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, substitutions);
-
-      premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
-    }
-  } else if (ruleName === premiseNonTerminalNodeRuleName) {
-    const premiseNonTerminalNodeChildNodesMatches = matchPremiseNodes(premiseNodes, nodes, substitutions);
-
-    premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
-  }
-
-  return premiseNonTerminalNodeMatches;
-}
-
-function matchPremiseMetavariableNode(premiseMetavariableNode, statementNode, substitutions) {
-  let premiseMetavariableNodeMatches;
-
-  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);
-
-    premiseMetavariableNodeMatches = substitutionNodesMatch;  ///
-  } else {
-    const metavariableName = premiseMetavariableName, ///
-          substitution = Substitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode);
-
-    substitutions.push(substitution);
-
-    premiseMetavariableNodeMatches = true;
-  }
-
-  return premiseMetavariableNodeMatches;
-}
-
-function matchPremiseMetastatementNode(premiseMetastatementNode, statementNode, substitutions) {
-  let premiseMetastatementNodeMatches = 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,  ///
-              premiseMetaVariableNodeMatches = matchPremiseMetavariableNode(premiseMetavariableNode, statementNode, substitutions);
-
-        premiseMetastatementNodeMatches = premiseMetaVariableNodeMatches; ///
-      }
-    }
-  }
-
-  return premiseMetastatementNodeMatches;
-}
-
-function metaMatchPremiseNode(premiseNode, node, metaSubstitutions) {
-  let premiseNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = premiseNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            premiseTerminalNode = premiseNode,  ///
-            premiseTerminalNodeMatches = metaMatchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions);
-
-      premiseNodeMatches = premiseTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            premiseNonTerminalNode = premiseNode,  ///
-            premiseNonTerminalNodeMatches = metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
-
-      premiseNodeMatches = premiseNonTerminalNodeMatches; ///
-    }
-  }
-
-  return premiseNodeMatches;
-}
-
-function metaMatchPremiseNodes(premiseNodes, nodes, metaSubstitutions) {
-  let premiseNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        premiseNodesLength = premiseNodes.length;
-
-  if (nodesLength === premiseNodesLength) {
-    premiseNodesMatches = nodes.every((node, index) => {
-      const premiseNode = premiseNodes[index],
-            premiseNodeMatches = metaMatchPremiseNode(premiseNode, node, metaSubstitutions);
-
-      if (premiseNodeMatches) {
-        return true;
-      }
-    });
-  }
-
-  return premiseNodesMatches;
-}
-
-function metaMatchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions) {
-  const matches = premiseTerminalNode.match(terminalNode),
-        premiseTerminalNodeMatches = matches;
-
-  return premiseTerminalNodeMatches;
-}
-
-function metaMatchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
-  let premiseNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        childNodes = nonTerminalNode.getChildNodes(),
-        premiseNonTerminalNodeRuleName = premiseNonTerminalNode.getRuleName(),
-        premiseNonTerminalNodeChildNodes = premiseNonTerminalNode.getChildNodes(),
-        nodes = childNodes, ///
-        premiseNodes = premiseNonTerminalNodeChildNodes, ///
-        ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME),
-        premiseNonTerminalNodeRuleNameMetastatementRuleName = (premiseNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
-
-  if (ruleNameMetastatementRuleName && premiseNonTerminalNodeRuleNameMetastatementRuleName) {
-    const metastatementNode = nonTerminalNode,  ///
-          premiseMetastatementNode = premiseNonTerminalNode,  ///
-          premiseMetastatementNodeMatches = metaMatchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions);
-
-    if (premiseMetastatementNodeMatches) {
-      premiseNonTerminalNodeMatches = true;
-    } else {
-      const premiseNonTerminalNodeChildNodesMatches = metaMatchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
-
-      premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
-    }
-  } else if (ruleName === premiseNonTerminalNodeRuleName) {
-    const premiseNonTerminalNodeChildNodesMatches = metaMatchPremiseNodes(premiseNodes, nodes, metaSubstitutions);
-
-    premiseNonTerminalNodeMatches = premiseNonTerminalNodeChildNodesMatches; ///
-  }
-
-  return premiseNonTerminalNodeMatches;
-}
-
-function metaMatchPremiseMetavariableNode(premiseMetavariableNode, metastatementNode, metaSubstitutions) {
-  let premiseMetavariableNodeMatches;
-
-  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);
-
-    premiseMetavariableNodeMatches = metaSubstitutionNodesMatch;  ///
-  } else {
-    const metavariableName = premiseMetavariableName, ///
-          metaSubstitution = MetaSubstitution.fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode);
-
-    metaSubstitutions.push(metaSubstitution);
-
-    premiseMetavariableNodeMatches = true;
-  }
-
-  return premiseMetavariableNodeMatches;
-}
-
-function metaMatchPremiseMetastatementNode(premiseMetastatementNode, metastatementNode, metaSubstitutions) {
-  let premiseMetastatementNodeMatches = 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,  ///
-              premiseMetaVariableNodeMatches = metaMatchPremiseMetavariableNode(premiseMetavariableNode, metastatementNode, metaSubstitutions);
-
-        premiseMetastatementNodeMatches = premiseMetaVariableNodeMatches; ///
-      }
-    }
-  }
-
-  return premiseMetastatementNodeMatches;
-}

package/src/ruleNames.js

@@ -5,6 +5,7 @@ export const TYPE_RULE_NAME = "type";
 export const LABEL_RULE_NAME = "label";
 export const ARGUMENT_RULE_NAME = "argument";
 export const SUBPROOF_RULE_NAME = "subproof";
+export const VARIABLE_RULE_NAME = "variable";
 export const STATEMENT_RULE_NAME = "statement";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";

package/src/step/metaproof.js

@@ -2,7 +2,7 @@
 
 import { first, second } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
-import { matchBracketedNonTerminalNode } from "../utilities/node";
+import { matchBracketedNonTerminalNode } from "../utilities/substitution";
 
 const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
       ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion"),

package/src/substitution.js

@@ -1,7 +1,8 @@
 "use strict";
 
+import { matcher } from "./matcher";
 import { STATEMENT_RULE_NAME } from "./ruleNames";
-import { matchNode, bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/node";
+import { bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/substitution";
 
 export default class Substitution {
   constructor(metavariableName, statementNode) {
@@ -22,7 +23,7 @@ export default class Substitution {
 
     const nodeA = this.statementNode,  ///
           nodeB = statementNode,
-          nodeMatches = matchNode(nodeA, nodeB);
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
 
     matchesStatementNode = nodeMatches;  ///
 

package/src/supposition.js

@@ -1,13 +1,9 @@
 "use strict";
 
-import Substitution from "./substitution";
-
-import { first } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
+import { suppositionMatcher } from "./matcher/supposition";
 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";
 
 const statementNodesQuery = nodesQuery("/subproofAssertion/statement"),
       subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
@@ -41,15 +37,15 @@ export default class Supposition {
 
       if (statementNodesLength === subproofAssertionStatementNodesLength) {
         subproofNodeMatches = subproofAssertionStatementNodes.every((subproofAssertionStatementNode, index) => {
-                                    const statementNode = statementNodes[index],
-                                          nonTerminalNode = statementNode, ///
-                                          suppositionNonTerminalNode = subproofAssertionStatementNode,  ///
-                                          suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
-
-                                    if (suppositionNonTerminalNodeMatches) {
-                                      return true;
-                                    }
-                                  });
+                                const statementNode = statementNodes[index],
+                                      nonTerminalNode = statementNode, ///
+                                      suppositionNonTerminalNode = subproofAssertionStatementNode,  ///
+                                      nonTerminalNodeMatches = suppositionMatcher.matchNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions);
+
+                                if (nonTerminalNodeMatches) {
+                                  return true;
+                                }
+                              });
       }
     }
 
@@ -59,8 +55,8 @@ export default class Supposition {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNode = statementNode,  ///
           suppositionNonTerminalNode = this.statementNode,  ///
-          suppositionNonTerminalNodeMatches = matchSuppositionNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, substitutions),
-          statementNodeMatches = suppositionNonTerminalNodeMatches; ///
+          nonTerminalNodeMatches = suppositionMatcher.matchNonTerminalNode(suppositionNonTerminalNode, nonTerminalNode, 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;
-}