occam-verify-cli 0.0.507 → 0.0.508

package/src/matcher/consequence.js

@@ -1,89 +0,0 @@
-"use strict";
-
-import Matcher from "../matcher";
-
-import { first } from "../utilities/array";
-import { variableNameFromVariableNode } from "../utilities/query";
-import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
-
-class ConsequenceMatcher extends Matcher {
-  matchNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions) {
-    let nonTerminalNodeMatches = false;
-
-    const ruleName = nonTerminalNode.getRuleName(),
-          consequenceRuleName = consequenceNonTerminalNode.getRuleName(); ///
-
-    if (ruleName === consequenceRuleName) {
-      nonTerminalNodeMatches = super.matchNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions);
-
-      if (!nonTerminalNodeMatches) {
-        const ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME);
-
-        if (ruleNameStatementRuleName) {
-          const statementNode = nonTerminalNode,  ///
-                consequenceStatementNode = consequenceNonTerminalNode,  ///
-                statementNodeMatches = this.matchStatementNode(consequenceStatementNode, statementNode, metaSubstitutions);
-
-          nonTerminalNodeMatches = statementNodeMatches; ///
-        }
-      }
-    }
-
-    return nonTerminalNodeMatches;
-  }
-
-  matchStatementNode(consequenceStatementNode, statementNode, metaSubstitutions) {
-    let statementNodeMatches = false;
-
-    const consequenceNonTerminalNode = consequenceStatementNode,  ///
-          consequenceChildNodes = consequenceNonTerminalNode.getChildNodes(),
-          consequenceChildNodesLength = consequenceChildNodes.length;
-
-    if (consequenceChildNodesLength === 1) {
-      const firstConsequenceChildNode = first(consequenceChildNodes),
-            consequenceChildNode = firstConsequenceChildNode,  ///
-            consequenceChildNodeNonTerminalNode = consequenceChildNode.isNonTerminalNode();
-
-      if (consequenceChildNodeNonTerminalNode) {
-        const consequenceNonTerminalChildNode = consequenceChildNode,  ///
-              consequenceNonTerminalChildNodeRuleName = consequenceNonTerminalChildNode.getRuleName(),
-              consequenceNonTerminalChildNodeRuleNameVariableRuleName = (consequenceNonTerminalChildNodeRuleName === VARIABLE_RULE_NAME);
-
-        if (consequenceNonTerminalChildNodeRuleNameVariableRuleName) {
-          const consequenceVariableNode = consequenceNonTerminalChildNode,  ///
-                nonTerminalNode = statementNode,  ///
-                childNodes = nonTerminalNode.getChildNodes(),
-                nodes = childNodes, ///
-                variableMatches = this.matchVariable(consequenceVariableNode, nodes, metaSubstitutions);
-
-          statementNodeMatches = variableMatches; ///
-        }
-      }
-    }
-
-    return statementNodeMatches;
-  }
-
-  matchVariable(consequenceVariableNode, nodes, metaSubstitutions) {
-    let variableMatches = true;
-
-    const consequenceVariableName = variableNameFromVariableNode(consequenceVariableNode),
-          metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
-            const variableName = metaSubstitution.getVariableName();
-
-            if (variableName === consequenceVariableName) {
-              return true;
-            }
-          }) || null;
-
-    if (metaSubstitution !== null) {
-      const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
-
-      variableMatches = metaSubstitutionNodesMatch;  ///
-    }
-
-    return variableMatches;
-  }
-}
-
-export const consequenceMatcher = new ConsequenceMatcher();

package/src/matcher/premise.js

@@ -1,94 +0,0 @@
-"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

@@ -1,97 +0,0 @@
-"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/metaMatcher/conclusion.js

@@ -1,86 +0,0 @@
-"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

@@ -1,94 +0,0 @@
-"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

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

package/src/mixins/matcher.js

@@ -1,81 +0,0 @@
-"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;