occam-verify-cli 0.0.506 → 0.0.508

package/src/matcher/statementForMetavariable.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import Matcher from "../matcher";
+import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
+
+import { first } from "../utilities/array";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class StatementForMetavariableMatcher extends Matcher {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
+          nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
+          nonTerminalNodeBRuleNameStatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);
+
+    if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
+      const metastatementNodeA = nonTerminalNodeA,  ///
+            statementNodeB = nonTerminalNodeB,  ///
+            statementNodeMatches = this.matchStatementNode(metastatementNodeA, statementNodeB, substitutions);
+
+      if (statementNodeMatches) {
+        nonTerminalNodeMatches = true;  ///
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      }
+    } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchStatementNode(metastatementNodeA, statementNodeB, substitutions) {
+    let statementNodeMatches = false;
+
+    const nonTerminalNodeA = metastatementNodeA,  ///
+          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          nonTerminalNodeAChildNodesLength = nonTerminalNodeAChildNodes.length;
+
+    if (nonTerminalNodeAChildNodesLength === 1) {
+      const firstNonTerminalNodeAChildNode = first(nonTerminalNodeAChildNodes),
+        cChildNodeA = firstNonTerminalNodeAChildNode,  ///
+        cChildNodeANonTerminalNode = cChildNodeA.isNonTerminalNode();
+
+      if (cChildNodeANonTerminalNode) {
+        const nonTerminalNodeA = cChildNodeA,  ///
+              nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+              nonTerminalNodeARuleNameMetavariableRuleName = (nonTerminalNodeARuleName === METAVARIABLE_RULE_NAME);
+
+        if (nonTerminalNodeARuleNameMetavariableRuleName) {
+          const metavariableNodeA = nonTerminalNodeA,  ///
+                metaVariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
+
+          statementNodeMatches = metaVariableNodeMatches; ///
+        }
+      }
+    }
+
+    return statementNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions) {
+    let metavariableNodeMatches;
+
+    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
+          substitution = substitutions.find((substitution) => {
+            const metavariableName = substitution.getMetavariableName();
+
+            if (metavariableName === metavariableNameA) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const statementNode = statementNodeB, ///
+            substitutionNodesMatch = substitution.matchStatementNode(statementNode);
+
+      metavariableNodeMatches = substitutionNodesMatch;  ///
+    } else {
+      const { createSubstitutions } = this.constructor;
+
+      if (createSubstitutions) {
+        const metavariableName = metavariableNameA, ///
+              statementNode = statementNodeB, ///
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode),
+              substitution = statementForMetavariableSubstitution;  ///
+
+        substitutions.push(substitution);
+      }
+
+      metavariableNodeMatches = true;
+    }
+
+    return metavariableNodeMatches;
+  }
+}

package/src/matcher/statementForVariable/consequence.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForVariableMatcher from "../../matcher/statementForVariable";
+
+class ConsequenceStatementForVariableMatcher extends StatementForVariableMatcher {
+  static createSubstitutions = false;
+}
+
+export const consequenceStatementForVariableMatcher = new ConsequenceStatementForVariableMatcher();

package/src/matcher/statementForVariable/supposition.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForVariableMatcher from "../../matcher/statementForVariable";
+
+class SuppositionStatementForVariableMatcher extends StatementForVariableMatcher {
+  static createSubstitutions = true;
+}
+
+export const suppositionStatementForVariableMatcher = new SuppositionStatementForVariableMatcher();

package/src/matcher/statementForVariable.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import Matcher from "../matcher";
+import StatementForVariableSubstitution from "../substitution/statementForVariable";
+
+import { first } from "../utilities/array";
+import { variableNameFromVariableNode } from "../utilities/query";
+import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class StatementForVariableMatcher extends Matcher {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
+          nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === STATEMENT_RULE_NAME),
+          nonTerminalNodeBRuleNameMetastatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);
+
+    if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
+      const statementNodeA = nonTerminalNodeA,  ///
+            statementNodeB = nonTerminalNodeB,  ///
+            statementNodeMatches = this.matchStatementNode(statementNodeA, statementNodeB, substitutions);
+
+      if (statementNodeMatches) {
+        nonTerminalNodeMatches = true;  ///
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      }
+    } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchStatementNode(statementNodeA, statementNodeB, substitutions) {
+    let statementNodeMatches = false;
+
+    const nonTerminalNodeA = statementNodeA,  ///
+          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          nonTerminalNodeAChildNodesLength = nonTerminalNodeAChildNodes.length;
+
+    if (nonTerminalNodeAChildNodesLength === 1) {
+      const firstNonTerminalNodeAChildNode = first(nonTerminalNodeAChildNodes),
+            childNodeA = firstNonTerminalNodeAChildNode,  ///
+            childNodeANonTerminalNode = childNodeA.isNonTerminalNode();
+
+      if (childNodeANonTerminalNode) {
+        const nonTerminalNodeA = childNodeA,  ///
+              nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+              nonTerminalNodeARuleNameVariableRuleName = (nonTerminalNodeARuleName === VARIABLE_RULE_NAME);
+
+        if (nonTerminalNodeARuleNameVariableRuleName) {
+          const variableNodeA = nonTerminalNodeA,  ///
+                variableMatches = this.matchVariableNode(variableNodeA, statementNodeB, substitutions);
+
+          statementNodeMatches = variableMatches; ///
+        }
+      }
+    }
+
+    return statementNodeMatches;
+  }
+
+  matchVariableNode(variableNodeB, statementNodeB, substitutions) {
+    let variableMatches;
+
+    const variableNameA = variableNameFromVariableNode(variableNodeB),
+          substitution = substitutions.find((substitution) => {
+            const variableName = substitution.getVariableName();
+
+            if (variableName === variableNameA) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const statementNode = statementNodeB, ///
+            substitutionNodesMatch = substitution.matchStatementNode(statementNode);
+
+      variableMatches = substitutionNodesMatch;  ///
+    } else {
+      const { createSubstitutions } = this.constructor;
+
+      if (createSubstitutions) {
+        const variableName = variableNameA, ///
+              statementNode = statementNodeB, ///
+              statementForVariableSubstitution = StatementForVariableSubstitution.fromVariableNameAndStatementNode(variableName, statementNode),
+              substitution = statementForVariableSubstitution;  ///
+
+        substitutions.push(substitution);
+      }
+
+      variableMatches = true;
+    }
+
+    return variableMatches;
+  }
+}

package/src/matcher.js

@@ -0,0 +1,76 @@
+"use strict";
+
+export default class Matcher {
+  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;
+  }
+
+  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;
+  }
+
+  matchTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {
+    const matches = terminalNodeA.match(terminalNodeB),
+          terminalNodeMatches = matches;  ///
+
+    return terminalNodeMatches;
+  }
+
+  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;
+  }
+}
+
+export const matcher = new Matcher();