occam-verify-cli 0.0.932 → 0.0.933

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;
-}