occam-verify-cli 0.0.474 → 0.0.477

package/src/equality.js

@@ -1,8 +1,233 @@
 "use strict";
 
+import { nodeQuery } from "./utilities/query";
+import { TERM_RULE_NAME } from "./ruleNames";
+
+const equalityNodeQuery = nodeQuery("/statement/equality!"),
+      leftTermNodeQuery = nodeQuery("/equality/term[0]"),
+      rightTermNodeQuery = nodeQuery("/equality/term[1]");
+
 export default class Equality {
-  constructor(termNodeA, termNodeB) {
-    this.termNodeA = termNodeA;
-    this.termNodeB = termNodeB;
+  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 equalityNode = equalityNodeQuery(statementNode);
+
+      if (equalityNode !== null) {
+        const leftTermNode = leftTermNodeQuery(equalityNode),
+              rightTermNode = rightTermNodeQuery(equalityNode);
+
+        equality = new Equality(leftTermNode, rightTermNode);
+      }
+    }
+
+    return equality;
+  }
+
+  static fromEqualityNode(equalityNode) {
+    const leftTermNode = leftTermNodeQuery(equalityNode),
+          rightTermNode = rightTermNodeQuery(equalityNode),
+          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/utilities/releaseContext.js

@@ -25,12 +25,8 @@ export function createReleaseContext(dependency, dependentNames, context, callba
       return;
     }
 
-    releaseContextMap[releaseName] = releaseContext;
-
-    const { log } = context;
-
     if (releaseContext === null) {
-      log.error(`The '${releaseName}' package could not be created.`);
+      const error = `The '${releaseName}' package could not be created.`;
 
       callback(error);
 
@@ -39,24 +35,23 @@ export function createReleaseContext(dependency, dependentNames, context, callba
 
     const releaseMatchesDependency = checkReleaseMatchesDependency(dependency, dependentNames, releaseContext, context);
 
-    if (!releaseMatchesDependency) {
+    if (!releaseMatchesDependency)  {
       const version = releaseContext.getVersion(),
             versionString = version.toString(),
             lastDependentName = last(dependentNames),
             dependentName = lastDependentName,  ///
             dependencyName = dependency.getName(),
             shortenedVersion = dependency.getShortedVersion(),
-            shortenedVersionString = shortenedVersion.toString();
-
-      error = `Version mismatch: '${dependentName}' requires '${dependencyName}' to be version ${shortenedVersionString}.0 or higher but version ${versionString} has been supplied.`;
-
-      log.error(error);
+            shortenedVersionString = shortenedVersion.toString(),
+            error = `Version mismatch: '${dependentName}' requires '${dependencyName}' to be version ${shortenedVersionString}.0 or higher but version ${versionString} has been supplied.`;
 
       callback(error);
 
       return;
     }
 
+    releaseContextMap[releaseName] = releaseContext;
+
     createDependencyReleaseContexts(dependency, dependentNames, context, callback);
   }, context);
 }
@@ -109,23 +104,11 @@ export default {
   initialiseReleaseContext
 };
 
-function checkCyclicDependencyExists(dependency, dependentNames, context) {
+function checkCyclicDependencyExists(dependency, dependentNames) {
   const dependencyName = dependency.getName(),
         dependentNamesIncludesDependencyName = dependentNames.includes(dependencyName),
         cyclicDependencyExists = dependentNamesIncludesDependencyName;  ///
 
-  if (cyclicDependencyExists) {
-    const { log } = context,
-          firstDependentName = first(dependentNames),
-          dependencyNames = [  ///
-              ...dependentNames,
-            firstDependentName
-          ],
-          dependencyNamesString = dependencyNames.join(`' -> '`);
-
-    log.error(`There is a cyclic dependency: '${dependencyNamesString}'.`);
-  }
-
   return cyclicDependencyExists;
 }
 
@@ -156,10 +139,16 @@ function createDependencyReleaseContexts(dependency, dependentNames, context, ca
   dependentNames = [ ...dependentNames, dependencyName ];  ///
 
   dependencies.asynchronousForEachDependency((dependency, next, done) => {
-    const cyclicDependencyExists = checkCyclicDependencyExists(dependency, dependentNames, context);
+    const cyclicDependencyExists = checkCyclicDependencyExists(dependency, dependentNames);
 
     if (cyclicDependencyExists) {
-      const error = null;
+      const firstDependentName = first(dependentNames),
+            dependencyNames = [  ///
+              ...dependentNames,
+              firstDependentName
+            ],
+            dependencyNamesString = dependencyNames.join(`' -> '`),
+            error =`There is a cyclic dependency: '${dependencyNamesString}'.`;
 
       callback(error);
 

package/src/variable.js

@@ -35,6 +35,22 @@ export default class Variable {
     return matchesName;
   }
 
+  isEqualTo(variable) {
+    let equalTo = false;
+
+    if (variable === this) {
+      equalTo = true;
+    } else {
+      const value = variable.getValue();
+
+      if (value === this.value) {
+        equalTo = true;
+      }
+    }
+
+    return equalTo;
+  }
+
   asString() {
     let string;
 

package/src/verify/equality.js

@@ -1,13 +1,15 @@
 "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 { MAXIMUM_INDEXES_LENGTH } from "../constants";
 
-const firstTermNodeQuery = nodeQuery("/equality/term[0]"),
-      secondTermNodeQuery = nodeQuery("/equality/term[1]");
+const leftTermNodeQuery = nodeQuery("/equality/term[0]"),
+      rightTermNodeQuery = nodeQuery("/equality/term[1]");
 
 export default function verifyEquality(equalityNode, proofContext) {
   let equalityVerified = false;
@@ -24,7 +26,12 @@ export default function verifyEquality(equalityNode, proofContext) {
     const derived = proofContext.isDerived();
 
     if (derived) {
-      debugger
+      const equality = Equality.fromEqualityNode(equalityNode),
+            proofSteps = proofContext.getProofSteps(),
+            equalities = equalitiesFromProofSteps(proofSteps),
+            equalityEquates = equality.equate(equalities, proofContext);
+
+      equalityVerified = equalityEquates;  ///
     } else {
       equalityVerified = true;
     }
@@ -46,20 +53,40 @@ function verifyEqualityTypes(equalityNode, proofContext) {
 
   const types = [],
         context = proofContext,  ///
-        firstTermNode = firstTermNodeQuery(equalityNode),
-        secondTermNode = secondTermNodeQuery(equalityNode),
-        firstTermVerified = verifyTerm(firstTermNode, types, context),
-        secondTermVerified = verifyTerm(secondTermNode, types, context);
+        leftTermNode = leftTermNodeQuery(equalityNode),
+        rightTermNode = rightTermNodeQuery(equalityNode),
+        leftTermVerified = verifyTerm(leftTermNode, types, context),
+        rightTermVerified = verifyTerm(rightTermNode, types, context);
 
-  if (firstTermVerified && secondTermVerified) {
+  if (leftTermVerified && rightTermVerified) {
     const firstType = first(types),
           secondType = second(types),
-          firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType = firstType.isEqualToSubTypeOfOrSuperTypeOf(secondType);
+          leftType = firstType, ///
+          rightType = secondType, ///
+          leftTypeEqualToSubTypeOfOrSuperTypeOfRightType = leftType.isEqualToSubTypeOfOrSuperTypeOf(rightType);
 
-    if (firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType) {
+    if (leftTypeEqualToSubTypeOfOrSuperTypeOfRightType) {
       equalityTypesVerified = true;
     }
   }
 
   return equalityTypesVerified;
 }
+
+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;
+}

package/src/verify/term.js

@@ -141,17 +141,15 @@ function verifyNode(node, constructorNode, context) {
   return nodeVerified;
 }
 
-function verifyChildNodes(childNodes, constructorChildNodes, context) {
-  let childNodesVerified = false;
+function verifyNodes(nodes, constructorNodes, context) {
+  let nodesVerified = false;
 
-  const childNodesLength = childNodes.length,
-        constructorChildNodesLength = constructorChildNodes.length;
+  const nodesLength = nodes.length,
+        constructorNodesLength = constructorNodes.length;
 
-  if (childNodesLength === constructorChildNodesLength) {
-    childNodesVerified = childNodes.every((childNode, index) => {
-      const constructorChildNode = constructorChildNodes[index],
-            node = childNode, ///
-            constructorNode = constructorChildNode,  ///
+  if (nodesLength === constructorNodesLength) {
+    nodesVerified = nodes.every((node, index) => {
+      const constructorNode = constructorNodes[index],
             nodeVerified = verifyNode(node, constructorNode, context);
 
       if (nodeVerified) {
@@ -160,7 +158,7 @@ function verifyChildNodes(childNodes, constructorChildNodes, context) {
     });
   }
 
-  return childNodesVerified;
+  return nodesVerified;
 }
 
 function verifyTerminalNode(terminalNode, constructorTerminalNode, context) {
@@ -178,8 +176,8 @@ function verifyTerminalNode(terminalNode, constructorTerminalNode, context) {
 function verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {
   let nonTerminalNodeVerified = false;
 
-  const ruleName = nonTerminalNode.getRuleName(),
-        constructorRuleName = constructorNonTerminalNode.getRuleName();
+  const ruleName = nonTerminalNode.getRuleName(), ///
+        constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
 
   if (ruleName === constructorRuleName) {
     switch (ruleName) {
@@ -196,9 +194,11 @@ function verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, cont
       default: {
         const childNodes = nonTerminalNode.getChildNodes(),
               constructorChildNodes = constructorNonTerminalNode.getChildNodes(),
-              childNodesVerified = verifyChildNodes(childNodes, constructorChildNodes, context);
+              nodes = childNodes, ///
+              constructorNodes = constructorChildNodes, ///
+              nodesVerified = verifyNodes(nodes, constructorNodes, context);
 
-        nonTerminalNodeVerified = childNodesVerified; ///
+        nonTerminalNodeVerified = nodesVerified; ///
 
         break;
       }