occam-verify-cli 0.0.932 → 0.0.934

package/src/verifier/nodes/metaLevel.js

@@ -1,109 +0,0 @@
-"use strict";
-
-import NodesVerifier from "../../verifier/nodes";
-import verifyVariableAgainstTerm from "../../verify/variableAgainstTerm";
-import verifyMetavariableAgainstStatement from "../../verify/metavariableAgainstStatement";
-
-import { nodeQuery } from "../../utilities/query";
-import { verifyNodes } from "../../utilities/verifier";
-
-const termNodeQuery = nodeQuery("/term!"),
-      statementNodeQuery = nodeQuery("/statement!"),
-      nonTerminalNodeQuery = nodeQuery("/*"),
-      termVariableNodeQuery = nodeQuery("/term/variable!"),
-      statementSubstitutionNodeQuery = nodeQuery("/statement/substitution!"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
-
-class MetaLevelNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let nonTerminalNodeVerified;
-
-    const nodeQueryMaps = [
-      {
-        nodeQueryA: statementMetavariableNodeQuery,
-        nodeQueryB: statementNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const statementNodeA = nonTerminalNodeA,  ///
-                statementNodeB = nodeB, ///
-                statementMetavariableNodeA = nodeA, ///
-                statementSubstitutionNodeA = statementSubstitutionNodeQuery(statementNodeA),
-                metavariableNodeVerifiedAgainstStatementNode =
-
-                  this.verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-          nonTerminalNodeVerified = metavariableNodeVerifiedAgainstStatementNode;  ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQueryA: termVariableNodeQuery,
-        nodeQueryB: termNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const termNodeB = nodeB,  ///
-                termVariableNodeA = nodeA,  ///
-                termVariableNodeVerifiedAgainstTermNode =
-
-                  this.verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-          nonTerminalNodeVerified = termVariableNodeVerifiedAgainstTermNode;  ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQueryA: nonTerminalNodeQuery,
-        nodeQueryB: nonTerminalNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNodeA = nodeA, ///
-                nonTerminalNodeB = nodeB; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-    nonTerminalNodeVerified = nodesVerified;  ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let metavariableNodeVerifiedAgainstStatementNode;
-
-    const substitutionNode = statementSubstitutionNodeA,  ///
-          metavariableNodeA = statementMetavariableNodeA, ///
-          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead);
-
-    metavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement;  ///
-
-    return metavariableNodeVerifiedAgainstStatementNode;
-  }
-
-  verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let termVariableNodeVerifiedAgainstTermNode;
-
-    const variableNodeA = termVariableNodeA, ///
-          termVerifiedAgainstVariable = verifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-    termVariableNodeVerifiedAgainstTermNode = termVerifiedAgainstVariable;  ///
-
-    return termVariableNodeVerifiedAgainstTermNode;
-  }
-}
-
-const metaLevelNodesVerifier = new MetaLevelNodesVerifier();
-
-export default metaLevelNodesVerifier;

package/src/verifier/nodes/statementAgainstCombinator.js

@@ -1,105 +0,0 @@
-"use strict";
-
-import NodesVerifier from "../../verifier/nodes";
-import verifyArgumentAgainstArgument from "../../verify/argumentAgainstArgument";
-import verifyStatementAgainstMetaType from "../../verify/statementAgainstMetaType";
-
-import { nodeQuery } from "../../utilities/query";
-import { verifyNodes } from "../../utilities/verifier";
-
-const argumentNodeQuery = nodeQuery("/argument!"),
-      nonTerminalNodeQuery = nodeQuery("/*"),
-      metaArgumentMetaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
-      metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!");
-
-class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
-    let nonTerminalNodeVerified;
-
-    const nodeQueryMaps = [
-      {
-        nodeQueryA: metaArgumentStatementNodeQuery,
-        nodeQueryB: metaArgumentMetaTypeNodeQuery,
-        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const metaArgumentMetaTypeNodeB = nodeB,  ///
-                metaArgumentStatementNodeA = nodeA, ///
-                metaArgumentStatementVerifiedAgainstMetaArgumentMetaType =
-
-                  this.verifyMetaArgumentStatementAgainstMetaArgumentMetaType(metaArgumentStatementNodeA, metaArgumentMetaTypeNodeB, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = metaArgumentStatementVerifiedAgainstMetaArgumentMetaType; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQueryA: argumentNodeQuery,
-        nodeQueryB: argumentNodeQuery,
-        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const argumentNodeA = nodeA,  ///
-                argumentNodeB = nodeB,  ///
-                argumentNodeVerifiedAgainstArgumentNode =
-
-                  this.verifyArgumentNodeAgainstArgumentNode(argumentNodeA, argumentNodeB, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = argumentNodeVerifiedAgainstArgumentNode; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQueryA: nonTerminalNodeQuery,
-        nodeQueryB: nonTerminalNodeQuery,
-        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNodeA = nodeA, ///
-                nonTerminalNodeB = nodeB; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
-
-    nonTerminalNodeVerified = nodesVerified;  ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyMetaArgumentStatementAgainstMetaArgumentMetaType(metaArgumentStatementNodeA, metaArgumentMetaTypeNodeB, localContext, verifyAhead) {
-    let metaArgumentStatementVerifiedAgainstMetaArgumentMetaType;
-
-    const { verifyStatement } = this,
-          metaTypeNode = metaArgumentMetaTypeNodeB, ///
-          statementNode = metaArgumentStatementNodeA,  ///
-          statementVerifiedAgainstMetaType = verifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, verifyAhead, verifyStatement);
-
-    metaArgumentStatementVerifiedAgainstMetaArgumentMetaType = statementVerifiedAgainstMetaType; ///
-
-    return metaArgumentStatementVerifiedAgainstMetaArgumentMetaType;
-  }
-
-  verifyArgumentNodeAgainstArgumentNode(argumentNodeA, argumentNodeB, localContext, verifyAhead) {
-    let argumentNodeVerifiedAgainstArgumentNode;
-
-    const argumentVerifiedAgainstArgument = verifyArgumentAgainstArgument(argumentNodeA, argumentNodeB, localContext, verifyAhead);
-
-    argumentNodeVerifiedAgainstArgumentNode = argumentVerifiedAgainstArgument; ///
-
-    return argumentNodeVerifiedAgainstArgumentNode;
-  }
-}
-
-const statementAgainstCombinatorNodesVerifier = new StatementAgainstCombinatorNodesVerifier();
-
-export default statementAgainstCombinatorNodesVerifier;

package/src/verifier/nodes/termAgainstConstructor.js

@@ -1,76 +0,0 @@
-"use strict";
-
-import NodesVerifier from "../../verifier/nodes";
-import verifyTermAgainstType from "../../verify/termAgainstType";
-
-import { nodeQuery } from "../../utilities/query";
-import { verifyNodes } from "../../utilities/verifier";
-
-const termNodeQuery = nodeQuery("/argument/term!"),
-      typeNodeQuery = nodeQuery("/argument/type!"),
-      nonTerminalNodeQuery = nodeQuery("/*");
-
-class TermAgainstConstructorNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
-    let nonTerminalNodeVerified;
-
-    const nodeQueryMaps = [
-      {
-        nodeQueryA: termNodeQuery,
-        nodeQueryB: typeNodeQuery,
-        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const termNodeA = nodeA,  ///
-                typeNodeB = nodeB,  ///
-                termNodeVerifiedAgainstTypeNode =
-
-                  this.verifyTermNodeAgainstTypeNode(termNodeA, typeNodeB, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = termNodeVerifiedAgainstTypeNode;  ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQueryA: nonTerminalNodeQuery,
-        nodeQueryB: nonTerminalNodeQuery,
-        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNodeA = nodeA, ///
-                nonTerminalNodeB = nodeB; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
-
-    nonTerminalNodeVerified = nodesVerified;  ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyTermNodeAgainstTypeNode(termNodeA, typeNodeB, localContext, verifyAhead) {
-    let termNodeVerifiedAgainstTypeNode;
-
-    const { verifyTerm } = this,
-          termNode = termNodeA, ///
-          typeNode = typeNodeB, ///
-          typeVerifiedAgainstTerm = verifyTermAgainstType(termNode, typeNode, localContext, verifyAhead, verifyTerm);
-
-    termNodeVerifiedAgainstTypeNode = typeVerifiedAgainstTerm; ///
-
-    return termNodeVerifiedAgainstTypeNode;
-  }
-}
-
-const termAgainstConstructorNodesVerifier = new TermAgainstConstructorNodesVerifier();
-
-export default termAgainstConstructorNodesVerifier;

package/src/verifier/nodes.js

@@ -1,114 +0,0 @@
-"use strict";
-
-import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "../utilities/terminalNodes";
-
-export default class NodesVerifier {
-  verifyNode(nodeA, nodeB, ...remainingArguments) {
-    let nodeVerified = false;
-
-    const nodeATerminalNode = nodeA.isTerminalNode(),
-          nodeBTerminalNode = nodeB.isTerminalNode(),
-          nodeANonTerminalNode = nodeA.isNonTerminalNode(),
-          nodeBNonTerminalNode = nodeB.isNonTerminalNode();
-
-    if (false) {
-      ///
-    } else if (nodeATerminalNode && nodeBTerminalNode) {
-      const terminalNodeA = nodeA,  ///
-            terminalNodeB = nodeB,  ///
-            terminalNodeVerified = this.verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments);
-
-      nodeVerified = terminalNodeVerified;  ///
-    } else if (nodeANonTerminalNode && nodeBNonTerminalNode) {
-      const nonTerminalNodeA = nodeA,  ///
-            nonTerminalNodeB = nodeB, ///
-            nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);
-
-      nodeVerified = nonTerminalNodeVerified; ///
-    }
-
-    return nodeVerified;
-  }
-
-  verifyChildNodes(childNodesA, childNodesB, ...remainingArguments) {
-    let childNodesVerified = false;
-
-    const childNodesALength = childNodesA.length,
-          childNodesBLength = childNodesB.length;
-
-    if (childNodesALength === childNodesBLength) {
-      const childTerminalNodeMapA = terminalNodeMapFromNodes(childNodesA),
-            childTerminalNodeMapB = terminalNodeMapFromNodes(childNodesB),
-            terminalNodeMapsEqual = areTerminalNodeMapsEqual(childTerminalNodeMapA, childTerminalNodeMapB);
-
-      if (terminalNodeMapsEqual) {
-        const index = 0,
-              childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
-
-        childNodesVerified = childNodesVerifyAhead; ///
-      }
-    }
-
-    return childNodesVerified;
-  }
-
-  verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) { ///
-    let terminalNodeVerified;
-
-    const verifyAhead = remainingArguments.pop(),
-          verifiedAhead = verifyAhead();
-
-    terminalNodeVerified = verifiedAhead;  ///
-
-    return terminalNodeVerified;
-  }
-
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
-    let nonTerminalNodeVerified = false;
-
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
-
-    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
-      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-            childNodesA = nonTerminalNodeAChildNodes, ///
-            childNodesB = nonTerminalNodeBChildNodes, ///
-            childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
-
-      nonTerminalNodeVerified = childNodesVerified; ///
-    }
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments) {
-    let childNodesVerified;
-
-    const verifyAhead = remainingArguments.pop(), ///
-          childNodesALength = childNodesA.length;
-
-    if (index === childNodesALength) {
-      const verifiedAhead = verifyAhead();
-
-      childNodesVerified = verifiedAhead; ///
-    } else {
-      const childNodeA = childNodesA[index],
-            childNodeB = childNodesB[index],
-            nodeA = childNodeA, ///
-            nodeB = childNodeB, ///
-            nodeVerified = this.verifyNode(nodeA, nodeB, ...remainingArguments, () => {
-              remainingArguments.push(verifyAhead); ///
-
-              const aheadIndex = index + 1,
-                    childNodesVerifyAhead = this.verifyChildNodesAhead(aheadIndex, childNodesA, childNodesB, ...remainingArguments);
-
-              return childNodesVerifyAhead;
-            });
-
-      childNodesVerified = nodeVerified;  ///
-    }
-
-    return childNodesVerified;
-  }
-}

package/src/verify/argumentAgainstArgument.js

@@ -1,15 +0,0 @@
-"use strict";
-
-import termAgainstConstructorNodesVerifier from "../verifier/nodes/termAgainstConstructor";
-
-export default function verifyArgumentAgainstArgument(argumentNodeA, argumentNodeB, localContext, verifyAhead) {
-  let argumentVerifiedAgainstArgument;
-
-  const nonTerminalNodeA = argumentNodeA, ///
-        nonTerminalNodeB = argumentNodeB, ///
-        nonTerminalNodeVerified = termAgainstConstructorNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
-
-  argumentVerifiedAgainstArgument = nonTerminalNodeVerified; ///
-
-  return argumentVerifiedAgainstArgument;
-}