occam-verify-cli 0.0.936 → 0.0.938

package/src/unify/statementAgainstMetaType.js

@@ -1,21 +1,26 @@
 "use strict";
 
+import shim from "../shim";
+
 import { nodeQuery } from "../utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
 
-export default function unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, unifyAhead, verifyStatement) {
+export default function unifyStatementAgainstMetaType(statementNodeA, metaTypeNodeB, localContext, unifyAhead) {
   let statementVerifiedAgainstMetaType = false;
 
-  const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
+  const metaTypeNode = metaTypeNodeB, ///
+        metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
         content = metaTypeTerminalNode.getContent();
 
   if (content === STATEMENT_META_TYPE_NAME) {
     let unifiedAhead = false;
 
-    const derived = false,
+    const { verifyStatement } = shim,
+          derived = false,
           assignments = [],
+          statementNode = statementNodeA, ///
           statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     if (statementVerified) {

package/src/unify/statementAtainstStatement.js

@@ -19,15 +19,11 @@ export default function unifyStatementAgainstStatement(statementNodeA, statement
     substitutionsA.push(substitutionA);
   }
 
-  const nonTerminalNodeA = statementNodeA,  ///
-        nonTerminalNodeB = statementNodeB,  ///
-        nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutionsA, localContextA, localContextB, () => {
-          const verifiedAhead = true;
+  const nodeA = statementNodeA,  ///
+        nodeB = statementNodeB,  ///
+        unified = metaLevelUnifier.unify(nodeA, nodeB, substitutionsA, localContextA, localContextB);
 
-          return verifiedAhead;
-        });
-
-  if (nonTerminalNodeUnified) {
+  if (unified) {
     if (!transformed) {
       const substitutionB = termForVariableSubstitution,  ///
             substitutionsB = [

package/src/unify/termAgainstTerm.js

@@ -6,7 +6,7 @@ export default function unifyTermAgainstTerm(termNodeA, termNodeB, localContext,
   let termUnifiedAgainstTerm = false;
 
   const leftTermNode = termNodeA, ///
-        rightTermNode = termNodeB, ///
+        rightTermNode = termNodeB,  ///
         equivalences = localContext.getEquivalences(),
         termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
 

package/src/unify/termAgainstType.js

@@ -1,17 +1,21 @@
 "use strict";
 
+import shim from "../shim";
+
 import { first } from "../utilities/array";
 
-export default function unifyTermAgainstType(termNode, typeNode, localContext, unifyAhead, verifyTerm) {
+export default function unifyTermAgainstType(termNodeA, typeNodeB, localContext, unifyAhead) {
   let termUnifiedAgainstType;
 
-  const terms = [],
-        termVerified = verifyTerm(termNode, terms, localContext, () => {
+  const { verifyTerm } = shim,
+        terms = [],
+        termVerified = verifyTerm(termNodeA, terms, localContext, () => {
           let unifiedAhead = false;
 
           const firstTerm = first(terms),
                 term = firstTerm, ///
                 termType = term.getType(),
+                typeNode = typeNodeB, ///
                 type = localContext.findTypeByTypeNode(typeNode),
                 termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 

package/src/utilities/string.js

@@ -18,7 +18,7 @@ export function nodeAsString(node, tokens) {
       string = nonTerminalNodeAsString(nonTerminalNode, tokens);
     }
 
-    string = string.replace(/[\r\n]/, EMPTY_STRING);
+    string = string.replace(/\s+$/, EMPTY_STRING);
   }
 
   return string;

package/src/verifier/metaLevel.js

@@ -2,7 +2,6 @@
 
 import Verifier from "../verifier";
 
-import { verify } from "../verifier";
 import { nodeQuery } from "../utilities/query";
 import { verifyStandaloneTerm } from "../verify/term";
 import { verifyStandaloneVariable } from "../verify/variable";
@@ -10,96 +9,53 @@ import { verifyStandaloneMetavariable } from "../verify/metavariable";
 
 const termNodeQuery = nodeQuery("/term!"),
       variableNodeQuery = nodeQuery("/variable!"),
-      nonTerminalNodeQuery = nodeQuery("/*"),
       metavariableNodeQuery = nodeQuery("/metavariable!");
 
 class MetaLevelVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
-    let nonTerminalNodeVerified;
+  verify(node, localContext) {
+    let verified;
 
-    const nodeQueryMaps = [
-      {
-        nodeQuery: termNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
+    const nonTerminalNode = node, ///
+          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+            const verifiedAhead = true;
 
-          const termNode = node, ///
-                termNodeVerified = this.verifyTermNode(termNode, localContext, verifyAhead);
+            return verifiedAhead;
+          });
 
-          nonTerminalNodeVerified = termNodeVerified; ///
+    verified = nonTerminalNodeVerified;  ///
 
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: variableNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const variableNode = node, ///
-                variableNodeVerified = this.verifyVariableNode(variableNode, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = variableNodeVerified; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: metavariableNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const metavariableNode = node, ///
-                metavariableNodeVerified = this.verifyMetavariableNode(metavariableNode, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = metavariableNodeVerified; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: nonTerminalNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNode = node; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
-
-    nonTerminalNodeVerified = nodeVerified; ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyMetavariableNode(metavariableNode, localContext, verifyAhead) {
-    const standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localContext, verifyAhead),
-          metavariableNodeVerified = standaloneMetavariableVerified;  ///
-
-    return metavariableNodeVerified;
-  }
-
-  verifyVariableNode(variableNode, localContext, verifyAhead) {
-    const standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
-          variableNodeVerified = standaloneVariableVerified;  ///
-
-    return variableNodeVerified;
+    return verified;
   }
 
-  verifyTermNode(termNode, localContext, verifyAhead) {
-    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-          termNodeVerified = standaloneTermVerified;  ///
+  static maps = [
+    {
+      nodeQuery: metavariableNodeQuery,
+      verify: (metavariableNode, localContext, verifyAhead) => {
+        const standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localContext, verifyAhead),
+              metavariableVerified = standaloneMetavariableVerified;  ///
 
-    return termNodeVerified;
-  }
+        return metavariableVerified;
+      }
+    },
+    {
+      nodeQuery: variableNodeQuery,
+      verify: (variableNode, localContext, verifyAhead) => {
+        const standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
+              variableVerified = standaloneVariableVerified;  ///
+
+        return variableVerified;
+      }
+    },
+    {
+      nodeQuery: termNodeQuery,
+      verify: (termNode, localContext, verifyAhead) => {
+        const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+              termVerified = standaloneTermVerified;  ///
+
+        return termVerified;
+      }
+    }
+  ];
 }
 
 const metaLevelVerifier = new MetaLevelVerifier();

package/src/verifier/statementAsCombinator.js

@@ -2,7 +2,6 @@
 
 import Verifier from "../verifier";
 
-import { verify } from "../verifier";
 import { nodeQuery } from "../utilities/query";
 import { verifyStandaloneType } from "../verify/type";
 import { verifyStandaloneTerm } from "../verify/term";
@@ -10,96 +9,54 @@ import { verifyStandaloneStatement } from "../verify/statement";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),
-      statementNodeQuery = nodeQuery("/statement!"),
-      nonTerminalNodeQuery = nodeQuery("/*");
+      statementNodeQuery = nodeQuery("/statement!");
 
 class StatementAsCombinatorVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
-    let nonTerminalNodeVerified;
+  verify(statementNode, fileContext) {
+    let statementVerifiedAsCombinator;
 
-    const nodeQueryMaps = [
-      {
-        nodeQuery: termNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
+    const nonTerminalNode = statementNode, ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          childNodesVerified = this.verifyChildNodes(childNodes, fileContext, () => {
+            const verifiedAhead = true;
 
-          const termNode = node, ///
-                termNodeVerified = this.verifyTermNode(termNode, localContext, verifyAhead);
+            return verifiedAhead;
+          });
 
-          nonTerminalNodeVerified = termNodeVerified; ///
+    statementVerifiedAsCombinator = childNodesVerified;  ///
 
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: typeNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const typeNode = node, ///
-                typeNodeVerified = this.verifyTypeNode(typeNode, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = typeNodeVerified; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: statementNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const statementNode = node, ///
-                statementNodeVerified = this.verifyStatementNode(statementNode, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = statementNodeVerified; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: nonTerminalNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNode = node; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
-
-    nonTerminalNodeVerified = nodeVerified; ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyStatementNode(statementNode, localContext, verifyAhead) {
-    const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
-          statementNodeVerified = standaloneStatementVerified;  ///
-
-    return statementNodeVerified;
-  }
-
-  verifyTermNode(termNode, localContext, verifyAhead) {
-    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-          termNodeVerified = standaloneTermVerified;  ///
-
-    return termNodeVerified;
+    return statementVerifiedAsCombinator;
   }
 
-  verifyTypeNode(typeNode, localContext, verifyAhead) {
-    const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-          typeNodeVerified = standaloneTypeVerified;  ///
+  static maps = [
+    {
+      nodeQuery: termNodeQuery,
+      verify: (termNode, localContext, verifyAhead) => {
+        const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+              termVerified = standaloneTermVerified;  ///
 
-    return typeNodeVerified;
-  }
+        return termVerified;
+      }
+    },
+    {
+      nodeQuery: typeNodeQuery,
+      verify: (typeNode, localContext, verifyAhead) => {
+        const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
+              typeVerified = standaloneTypeVerified;  ///
+
+        return typeVerified;
+      }
+    },
+    {
+      nodeQuery: statementNodeQuery,
+      verify: (statementNode, localContext, verifyAhead) => {
+        const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
+              statementVerified = standaloneStatementVerified;  ///
+
+        return statementVerified;
+      }
+    }
+  ];
 }
 
 const statementAsCombinatorVerifier = new StatementAsCombinatorVerifier();

package/src/verifier/termAsConstructor.js

@@ -1,83 +1,54 @@
 "use strict";
 
 import Verifier from "../verifier";
+import LocalContext from "../context/local";
 
-import { verify } from "../verifier";
 import { nodeQuery } from "../utilities/query";
 import { verifyStandaloneType } from "../verify/type";
 import { verifyStandaloneTerm } from "../verify/term";
 
 const termNodeQuery = nodeQuery("/term!"),
-      typeNodeQuery = nodeQuery("/type!"),
-      nonTerminalNodeQuery = nodeQuery("/*");
+      typeNodeQuery = nodeQuery("/type!");
 
 class TermAsConstructorVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
-    let nonTerminalNodeVerified;
+  verify(termNode, fileContext) {
+    let termVerifiedAsConstructor;
 
-    const nodeQueryMaps = [
-      {
-        nodeQuery: termNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
+    const nonTerminalNode = termNode, ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          childNodesVerified = this.verifyChildNodes(childNodes, fileContext, () => {
+            const verifiedAhead = true;
 
-          const termNode = node, ///
-            termNodeVerified = this.verifyTermNode(termNode, localContext, verifyAhead);
+            return verifiedAhead;
+          });
 
-          nonTerminalNodeVerified = termNodeVerified; ///
+    termVerifiedAsConstructor = childNodesVerified;  ///
 
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: typeNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const typeNode = node, ///
-            typeNodeVerified = this.verifyTypeNode(typeNode, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = typeNodeVerified; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: nonTerminalNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNode = node; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
-
-    nonTerminalNodeVerified = nodeVerified; ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyTermNode(termNode, localContext, verifyAhead) {
-    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-          termNodeVerified = standaloneTermVerified;  ///
-
-    return termNodeVerified;
+    return termVerifiedAsConstructor;
   }
 
-  verifyTypeNode(typeNode, localContext, verifyAhead) {
-    const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-          typeNodeVerified = standaloneTypeVerified;  ///
+  static maps = [
+    {
+      nodeQuery: termNodeQuery,
+      verify: (termNode, fileContext, verifyAhead) => {
+        const localContext = LocalContext.fromFileContext(fileContext),
+              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+              termVerified = standaloneTermVerified;  ///
 
-    return typeNodeVerified;
-  }
+        return termVerified;
+      }
+    },
+    {
+      nodeQuery: typeNodeQuery,
+      verify: (typeNode, fileContext, verifyAhead) => {
+        const localContext = LocalContext.fromFileContext(fileContext),
+              standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
+              typeVerified = standaloneTypeVerified;  ///
+
+        return typeVerified;
+      }
+    }
+  ];
 }
 
 const termAsConstructorVerifier = new TermAsConstructorVerifier();

package/src/verifier.js

@@ -1,6 +1,20 @@
 "use strict";
 
+import { nodeQuery } from "./utilities/query";
+
+const nonTerminalNodeQuery = nodeQuery("/*");
+
 export default class Verifier {
+  verify(node, ...remainingArguments) {
+    let verified;
+
+    const nodeVerified = this.verifyNode(node, ...remainingArguments);
+
+    verified = nodeVerified;  ///
+
+    return verified;
+  }
+
   verifyNode(node, ...remainingArguments) {
     let nodeVerified;
 
@@ -46,10 +60,40 @@ export default class Verifier {
   verifyNonTerminalNode(nonTerminalNode, ...remainingArguments) {
     let nonTerminalNodeVerified;
 
-    const childNodes = nonTerminalNode.getChildNodes(), ///
-          childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
+    let { maps } = this.constructor;
+
+    maps = [ ///
+      ...maps,
+      {
+        nodeQuery: nonTerminalNodeQuery,
+        verify: (node, ...remainingArguments) => {
+          let nonTerminalNodeVerified;
+
+          const childNodes = nonTerminalNode.getChildNodes(), ///
+                childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
+
+          nonTerminalNodeVerified = childNodesVerify; ///
+
+          return nonTerminalNodeVerified;
+        }
+      }
+    ]
+
+    let nodeVerified = false;
 
-    nonTerminalNodeVerified = childNodesVerify; ///
+    maps.some((map) => {
+      const { nodeQuery, verify } = map;
+
+      const node = nodeQuery(nonTerminalNode);
+
+      if (node !== null) {
+        nodeVerified = verify(node, ...remainingArguments);
+
+        return true;
+      }
+    });
+
+    nonTerminalNodeVerified = nodeVerified; ///
 
     return nonTerminalNodeVerified;
   }
@@ -82,21 +126,3 @@ export default class Verifier {
     return childNodesVerify;
   }
 }
-
-export function verify(nodeQueryMaps, nonTerminalNode, ...remainingArguments) {
-  let nodeVerified = false;
-
-  nodeVerified = nodeQueryMaps.some((nodeQueryMap) => {
-    const { nodeQuery, verify } = nodeQueryMap;
-
-    const node = nodeQuery(nonTerminalNode);
-
-    if (node !== null) {
-      nodeVerified = verify(node, ...remainingArguments);
-
-      return true;
-    }
-  });
-
-  return nodeVerified;
-}

package/src/verify/assertion/contained.js

@@ -83,14 +83,9 @@ function verifyStatedContainedAssertion(containedAssertionNode, assignments, der
 
     localContext.debug(`The '${containedAssertionString}' stated contained assertion cannot be verified.`, containedAssertionNode);
 
-    const nonTerminalNode = containedAssertionNode, ///
-          nonTerminalNodeVerified = metaLevelVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
-            const verifiedAhead = true;
+    const verified = metaLevelVerifier.verify(containedAssertionNode, localContext);
 
-            return verifiedAhead;
-          });
-
-    statedContainedAssertionVerified = nonTerminalNodeVerified; ///
+    statedContainedAssertionVerified = verified; ///
 
     if (statedContainedAssertionVerified) {
       localContext.debug(`...verified the '${containedAssertionString}' stated contained assertion.`, containedAssertionNode);

package/src/verify/assertion/defined.js

@@ -112,14 +112,9 @@ function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived
 
     localContext.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`, definedAssertionNode);
 
-    const nonTerminalNode = definedAssertionNode, ///
-          nonTerminalNodeVerified = metaLevelVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
-            const verifiedAhead = true;
+    const verified = metaLevelVerifier.verify(definedAssertionNode, localContext);
 
-            return verifiedAhead;
-          });
-
-    statedDefinedAssertionVerified = nonTerminalNodeVerified; ///
+    statedDefinedAssertionVerified = verified; ///
 
     if (statedDefinedAssertionVerified) {
       localContext.debug(`...verified the '${definedAssertionString}' stated defined assertion.`, definedAssertionNode);

package/src/verify/assertion/subproof.js

@@ -1,9 +1,6 @@
 "use strict";
 
-import { nodesQuery } from "../../utilities/query";
-import { STATEMENT_META_TYPE_NAME } from "../../metaTypeNames";
-
-const metavariableNodesQuery = nodesQuery("/subproofAssertion/statement/metavariable!");
+import metaLevelVerifier from "../../verifier/metaLevel";
 
 export default function verifySubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
   let subproofAssertionVerified;
@@ -54,19 +51,9 @@ function verifyStatedSubproofAssertion(subproofAssertionNode, assignments, deriv
 
     localContext.trace(`Verifying the '${subproofAssertionString}' stated subproof assertion...`, subproofAssertionNode);
 
-    const metavariableNodes = metavariableNodesQuery(subproofAssertionNode);
-
-    statedSubproofAssertionVerified = metavariableNodes.every((metavariableNode) => {
-      const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
-
-      if (metavariable !== null) {
-        const metaTypeName = metavariable.getMetaTypeName();
+    const verified = metaLevelVerifier.verify(subproofAssertionNode, localContext);
 
-        if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-          return true;
-        }
-      }
-    });
+    statedSubproofAssertionVerified = verified; ///
 
     if (statedSubproofAssertionVerified) {
       localContext.debug(`...verified the '${subproofAssertionString}' stated subproof assertion.`, subproofAssertionNode);