occam-verify-cli 0.0.492 → 0.0.494

package/src/equality.js

@@ -1,231 +0,0 @@
-"use strict";
-
-import { nodeQuery } from "./utilities/query";
-import { TERM_RULE_NAME } from "./ruleNames";
-import { EQUALS_CHARACTER } from "./constants";
-
-const specialNodeQuery = nodeQuery("/statement/@special!"),
-      leftTermNodeQuery = nodeQuery("/statement/term[0]"),
-      rightTermNodeQuery = nodeQuery("/statement/term[1]");
-
-export default class Equality {
-  constructor(leftTermNode, rightTermNode) {
-    this.leftTermNode = leftTermNode;
-    this.rightTermNode = rightTermNode;
-  }
-
-  getLeftTermNode() {
-    return this.leftTermNode;
-  }
-
-  getRightTermNode() {
-    return this.rightTermNode;
-  }
-
-  match(equality, equalities, proofContext) {
-    let matches = false;
-
-    const leftTermNode = equality.getLeftTermNode(),
-          rightTermNode = equality.getRightTermNode();
-
-    if (!matches) {
-      const reversed = false,
-            leftTermNodeAndRightTermNodeMatch = this.matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities, proofContext);
-
-      matches = leftTermNodeAndRightTermNodeMatch;  ///
-    }
-
-    if (!matches) {
-      const reversed = true,
-            leftTermNodeAndRightTermNodeMatch = this.matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities, proofContext);
-
-      matches = leftTermNodeAndRightTermNodeMatch;  ///
-    }
-
-    return matches;
-  }
-
-  matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities, proofContext) {
-    let leftTermNodeAndRightTermNodeMatch = true;
-
-    if (leftTermNodeAndRightTermNodeMatch) {
-      const leftNonTerminalNode = reversed ?
-                                    this.rightTermNode :
-                                      this.leftTermNode,  ///
-            rightNonTerminalNode = leftTermNode,  ///
-            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, proofContext);
-
-      leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
-    }
-
-    if (leftTermNodeAndRightTermNodeMatch) {
-      const leftNonTerminalNode = reversed ?
-                                    this.leftTermNode :
-                                      this.rightTermNode,  ///
-            rightNonTerminalNode = rightTermNode,  ///
-            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, proofContext);
-
-      leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
-    }
-
-    return leftTermNodeAndRightTermNodeMatch;
-  }
-
-  equate(equalities, proofContext) {
-    const leftNonTerminalNode = this.leftTermNode,  ///
-          rightNonTerminalNode = this.rightTermNode,  ///
-          nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, proofContext),
-          equates = nonTerminalNodeEquates; ///
-
-    return equates;
-  }
-
-  static fromProofStep(proofStep) {
-    let equality = null;
-
-    const statementNode = proofStep.getStatementNode();
-
-    if (statementNode !== null) {
-      const specialNode = specialNodeQuery(statementNode);
-
-      if (specialNode !== null) {
-        const terminalNode = specialNode, ///
-              terminalNodeContent = terminalNode.getContent();
-
-        if (terminalNodeContent === EQUALS_CHARACTER) {
-          const leftTermNode = leftTermNodeQuery(statementNode),
-                rightTermNode = rightTermNodeQuery(statementNode);
-
-          equality = new Equality(leftTermNode, rightTermNode);
-        }
-      }
-    }
-
-    return equality;
-  }
-
-  static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
-    const equality = new Equality(leftTermNode, rightTermNode);
-
-    return equality;
-  }
-}
-
-function equateNode(nodeA, nodeB, equalities, proofContext) {
-  let nodeEquates = false;
-
-  const nodeATerminalNode = nodeA.isTerminalNode(),
-        nodeBTerminalNode = nodeB.isTerminalNode();
-
-  if (nodeATerminalNode === nodeBTerminalNode) {
-    if (nodeATerminalNode) {
-      const terminalNodeA = nodeA,  ///
-            terminalNodeB = nodeB,  ///
-            terminalNodeEquates = equateTerminalNode(terminalNodeA, terminalNodeB, equalities, proofContext);
-
-      nodeEquates = terminalNodeEquates;  ///
-    } else {
-      const nonTerminalNodeA = nodeA,  ///
-            nonTerminalNodeB = nodeB, ///
-            nonTerminalNodeEquates = equateNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equalities, proofContext);
-
-      nodeEquates = nonTerminalNodeEquates; ///
-    }
-  }
-
-  return nodeEquates;
-}
-
-function equateNodes(leftNodes, rightNodes, equalities, proofContext) {
-  let nodesEquate = false;
-
-  const leftNodesLength = leftNodes.length,
-        rightNodesLength = rightNodes.length;
-
-  if (leftNodesLength === rightNodesLength) {
-    nodesEquate = leftNodes.every((LeftNode, index) => {
-      const rightNode = rightNodes[index],
-            nodeEquates = equateNode(LeftNode, rightNode, equalities, proofContext);
-
-      if (nodeEquates) {
-        return true;
-      }
-    });
-  }
-
-  return nodesEquate;
-}
-
-function equateTerminalNode(terminalNodeA, terminalNodeB, equalities, proofContext) {
-  const matches = terminalNodeA.match(terminalNodeB),
-        terminalNodeEquates = matches;  ///
-
-  return terminalNodeEquates;
-}
-
-function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, proofContext) {
-  let nonTerminalNodeEquates = false;
-
-  const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
-        rightNonTerminalNodeRuleName = rightNonTerminalNode.getRuleName();
-
-  if (leftNonTerminalNodeRuleName === rightNonTerminalNodeRuleName) {
-    const ruleName = leftNonTerminalNodeRuleName, ///
-          ruleNameTermRuleName = (ruleName === TERM_RULE_NAME);
-
-    if (ruleNameTermRuleName) {
-      const leftTermNode = leftNonTerminalNode, ///
-            rightTermNode = rightNonTerminalNode, ///
-            termNodeEquates = equateTermNode(leftTermNode, rightTermNode, equalities, proofContext);
-
-      nonTerminalNodeEquates = termNodeEquates;  ///
-    }
-
-    if (!nonTerminalNodeEquates) {
-      const leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
-            rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
-            leftNodes = leftNonTerminalNodeChildNodes, ///
-            rightNodes = rightNonTerminalNodeChildNodes, ///
-            nodesEquate = equateNodes(leftNodes, rightNodes, equalities, proofContext);
-
-      nonTerminalNodeEquates = nodesEquate; ///
-    }
-  }
-
-  return nonTerminalNodeEquates;
-}
-
-function equateTermNode(leftTermNode, rightTermNode, equalities, proofContext) {
-  const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
-        equalityA = equality, ///
-        equalityMatches = equalities.some((equality) => { ///
-          let equalitiesB = equalities; ///
-
-          const equalityB = equality; ///
-
-          equalitiesB = pruneEqualities(equalitiesB, equalityB);  ///
-
-          const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB, proofContext);
-
-          if (equalityAMatchesEqualityB) {
-            return true;
-          }
-        }),
-        termNodeEquates = equalityMatches;  ///
-
-  return termNodeEquates;
-}
-
-function pruneEqualities(equalities, equality) {
-  const equalityA = equality; ///
-
-  equalities = equalities.filter((equality) => {
-    const equalityB = equality; ///
-
-    if (equalityA !== equalityB) {
-      return true;
-    }
-  });
-
-  return equalities;
-}

package/src/verify/statementAsEquality.js

@@ -1,101 +0,0 @@
-"use strict";
-
-import Equality from "../equality";
-import verifyTerm from "../verify/term";
-
-import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
-import { first, second } from "../utilities/array";
-import { EQUALS_CHARACTER, MAXIMUM_INDEXES_LENGTH } from "../constants";
-
-const specialNodeQuery = nodeQuery("/statement/@special!"),
-      leftTermNodeQuery = nodeQuery("/statement/term[0]"),
-      rightTermNodeQuery = nodeQuery("/statement/term[1]");
-
-export default function verifyStatementAsEquality(statementNode, qualified, proofContext) {
-  let statementVerifiedAsEquality = false;
-
-  proofContext.begin(statementNode);
-
-  const statementString = nodeAsString(statementNode);
-
-  proofContext.debug(`Verifying the '${statementString}' statement as an equality...`);
-
-  const specialNode = specialNodeQuery(statementNode);
-
-  if (specialNode !== null) {
-    const terminalNode = specialNode, ///
-          terminalNodeContent = terminalNode.getContent();
-
-    if (terminalNodeContent === EQUALS_CHARACTER) {
-      const types = [],
-            context = proofContext,  ///
-            leftTermNode = leftTermNodeQuery(statementNode),
-            rightTermNode = rightTermNodeQuery(statementNode),
-            leftTermVerified = verifyTerm(leftTermNode, types, context),
-            rightTermVerified = verifyTerm(rightTermNode, types, context);
-
-      if (leftTermVerified && rightTermVerified) {
-        const firstType = first(types),
-              secondType = second(types),
-              leftType = firstType, ///
-              rightType = secondType, ///
-              leftTermString = nodeAsString(leftTermNode),
-              rightTermString = nodeAsString(rightTermNode);
-
-        if ((leftType === null) && (rightType === null)) {
-          proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms are both undefined and therefore the terms cannot be equated.`);
-        } else if (rightType === null) {
-          proofContext.info(`The type of the right '${rightTermString}' term is undefined and therefore the types cannot be equated.`);
-        } else if (leftType === null) {
-          proofContext.info(`The type of the left '${leftTermString}' term is undefined and therefore the types cannot be equated.`);
-        } else {
-          const leftTypeMatchesRightType = leftType.match(rightType);
-
-          if (!leftTypeMatchesRightType) {
-            proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms do not match and therefore the terms cannot be equated.`);
-          } else {
-            if (!qualified) {
-              statementVerifiedAsEquality = true;
-            } else {
-              const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
-                    proofSteps = proofContext.getProofSteps(),
-                    equalities = equalitiesFromProofSteps(proofSteps),
-                    equalityEquates = equality.equate(equalities, proofContext);
-
-              statementVerifiedAsEquality = equalityEquates;  ///
-            }
-          }
-        }
-      }
-    }
-  }
-
-  if (statementVerifiedAsEquality) {
-    proofContext.info(`Verified the '${statementString}' equality.`);
-  }
-
-  statementVerifiedAsEquality ?
-    proofContext.complete(statementNode) :
-      proofContext.halt(statementNode);
-
-  return statementVerifiedAsEquality;
-}
-
-function equalitiesFromProofSteps(proofSteps) {
-  const start = -MAXIMUM_INDEXES_LENGTH;  ///
-
-  proofSteps = proofSteps.slice(start); ///
-
-  const equalities = proofSteps.reduce((equalities, proofStep, index) => {
-    const equality = Equality.fromProofStep(proofStep);
-
-    if (equality !== null) {
-      equalities.push(equality);
-    }
-
-    return equalities;
-  }, []);
-
-  return equalities;
-}