occam-verify-cli 0.0.613 → 0.0.615

package/src/verify/term.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import Verifier from "../verifier";
+
 import { first } from "../utilities/array";
 import { objectType } from "../type";
 import { OBJECT_TYPE_NAME } from "../typeNames";
@@ -10,6 +12,103 @@ const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!"),
       variableNodeQuery = nodeQuery("/term/variable!");
 
+class TermVerifier extends Verifier {
+  verifyTerminalNode(terminalNode, constructorTerminalNode, context) {
+    let terminalNodeVerified = false;
+
+    const matches = terminalNode.match(constructorTerminalNode);
+
+    if (matches) {
+      terminalNodeVerified = true;
+    }
+
+    return terminalNodeVerified;
+  }
+
+  verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {
+    let nonTerminalNodeVerified = false;
+
+    const ruleName = nonTerminalNode.getRuleName(), ///
+          constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
+
+    if (ruleName === constructorRuleName) {
+      switch (ruleName) {
+        case ARGUMENT_RULE_NAME: {
+          const argumentNode = nonTerminalNode, ///
+                constructorArgumentNode = constructorNonTerminalNode, ///
+                argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, context);
+
+          nonTerminalNodeVerified = argumentNodeVerified; ///
+
+          break;
+        }
+
+        default: {
+          const childNodes = nonTerminalNode.getChildNodes(),
+                constructorChildNodes = constructorNonTerminalNode.getChildNodes(),
+                nodes = childNodes, ///
+                constructorNodes = constructorChildNodes, ///
+                nodesVerified = this.verifyNodes(nodes, constructorNodes, context);
+
+          nonTerminalNodeVerified = nodesVerified; ///
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
+    let argumentNodeVerified = false;
+
+    const typeNode = typeNodeQuery(argumentNode);
+
+    if (typeNode !== null) {
+      const argumentString = context.nodeAsString(argumentNode);
+
+      context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
+    } else {
+      const termNode = termNodeQuery(argumentNode),
+            constructorTermNode = termNodeQuery(constructorArgumentNode),
+            constructorTypeNode = typeNodeQuery(constructorArgumentNode);
+
+      if (false) {
+        ///
+      } else if (constructorTermNode !== null) {
+        const node = termNode,  ///
+              constructorNode = constructorTermNode,  ///
+              nodeVerified = this.verifyNode(node, constructorNode, context);
+
+        argumentNodeVerified = nodeVerified;  ///
+      } else if (constructorTypeNode !== null) {
+        const types = [],
+              termVerified = verifyTerm(termNode, types, context);
+
+        if (termVerified) {
+          const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
+                constructorType = (constructorTypeName === OBJECT_TYPE_NAME) ?
+                                    objectType :
+                                      context.findTypeByTypeName(constructorTypeName),
+                firstType = first(types),
+                termType = firstType, ///
+                type = constructorType, ///
+                termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+
+          if (termTypeEqualToOrSubTypeOfType) {
+            argumentNodeVerified = true;
+          }
+        }
+      }
+    }
+
+    return argumentNodeVerified;
+  }
+}
+
+export const termVerifier = new TermVerifier();
+
 export default function verifyTerm(termNode, types, context) {
   let termVerified = false;
 
@@ -47,27 +146,6 @@ export default function verifyTerm(termNode, types, context) {
   return termVerified;
 }
 
-export function verifyTermAsVariable(termNode, variables, context) {
-  let termVerifiedAsVariable = false;
-
-  const variableNode = variableNodeQuery(termNode);
-
-  if (variableNode !== null) {
-    const variableName = variableNameFromVariableNode(variableNode),
-          variablePresent = context.isVariablePresentByVariableName(variableName);
-
-    if (variablePresent) {
-      const variable = context.findVariableByVariableName(variableName);
-
-      variables.push(variable);
-
-      termVerifiedAsVariable = true;
-    }
-  }
-
-  return termVerifiedAsVariable;
-}
-
 export function verifyTermAgainstConstructors(termNode, types, context) {
   let termVerifiedAgainstConstructors = false;
 
@@ -91,136 +169,33 @@ export function verifyTermAgainstConstructors(termNode, types, context) {
   return termVerifiedAgainstConstructors;
 }
 
-function verifyTermAgainstConstructor(termNode, constructor, context) {
+export function verifyTermAgainstConstructor(termNode, constructor, context) {
   const constructorTermNode = constructor.getTermNode(),
-        node = termNode,  ///
-        constructorNode = constructorTermNode, ///
-        nodeVerified = verifyNode(node, constructorNode, context),
+        nonTerminalNNdeA = termNode,  ///
+        nonTerminalNodeB = constructorTermNode,  ///
+        nodeVerified = termVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context),
         termVerifiedAgainstConstructor = nodeVerified;  ///
 
   return termVerifiedAgainstConstructor;
 }
 
-function verifyNode(node, constructorNode, context) {
-  let nodeVerified;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        constructorNodeTerminalNode = constructorNode.isTerminalNode();
-
-  if (nodeTerminalNode === constructorNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            constructorTerminalNode = constructorNode,  ///
-            terminalNodeVerified = verifyTerminalNode(terminalNode, constructorTerminalNode, context);
-
-      nodeVerified = terminalNodeVerified;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            constructorNonTerminalNode = constructorNode,  ///
-            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context);
-
-      nodeVerified = nonTerminalNodeVerified; ///
-    }
-  }
-
-  return nodeVerified;
-}
-
-function verifyNodes(nodes, constructorNodes, context) {
-  let nodesVerified = false;
-
-  const nodesLength = nodes.length,
-        constructorNodesLength = constructorNodes.length;
-
-  if (nodesLength === constructorNodesLength) {
-    nodesVerified = nodes.every((node, index) => {
-      const constructorNode = constructorNodes[index],
-            nodeVerified = verifyNode(node, constructorNode, context);
-
-      if (nodeVerified) {
-        return true;
-      }
-    });
-  }
-
-  return nodesVerified;
-}
-
-function verifyTerminalNode(terminalNode, constructorTerminalNode, context) {
-  let terminalNodeVerified = false;
-
-  const matches = terminalNode.match(constructorTerminalNode);
-
-  if (matches) {
-    terminalNodeVerified = true;
-  }
-
-  return terminalNodeVerified;
-}
-
-function verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {
-  let nonTerminalNodeVerified = false;
-
-  const ruleName = nonTerminalNode.getRuleName(), ///
-        constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === constructorRuleName) {
-    switch (ruleName) {
-      case ARGUMENT_RULE_NAME: {
-        const argumentNode = nonTerminalNode, ///
-              constructorArgumentNode = constructorNonTerminalNode, ///
-              argumentNodeVerified = verifyArgumentNode(argumentNode, constructorArgumentNode, context);
-
-        nonTerminalNodeVerified = argumentNodeVerified; ///
-
-        break;
-      }
-
-      default: {
-        const childNodes = nonTerminalNode.getChildNodes(),
-              constructorChildNodes = constructorNonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              constructorNodes = constructorChildNodes, ///
-              nodesVerified = verifyNodes(nodes, constructorNodes, context);
-
-        nonTerminalNodeVerified = nodesVerified; ///
-
-        break;
-      }
-    }
-  }
-
-  return nonTerminalNodeVerified;
-}
-
-function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
-  let argumentNodeVerified = false;
+export function verifyTermAsVariable(termNode, variables, context) {
+  let termVerifiedAsVariable = false;
 
-  const termNode = termNodeQuery(argumentNode);
+  const variableNode = variableNodeQuery(termNode);
 
-  if (termNode === null) {
-    const argumentString = context.nodeAsString(argumentNode);
+  if (variableNode !== null) {
+    const variableName = variableNameFromVariableNode(variableNode),
+          variablePresent = context.isVariablePresentByVariableName(variableName);
 
-    context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
-  } else {
-    const types = [],
-          termVerified = verifyTerm(termNode, types, context);
+    if (variablePresent) {
+      const variable = context.findVariableByVariableName(variableName);
 
-    if (termVerified) {
-      const firstType = first(types),
-            termType = firstType, ///
-            typeNode = typeNodeQuery(constructorArgumentNode),
-            typeName = typeNameFromTypeNode(typeNode),
-            type = (typeName === OBJECT_TYPE_NAME) ?
-                     objectType :  ///
-                       context.findTypeByTypeName(typeName),
-            termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+      variables.push(variable);
 
-      if (termTypeEqualToOrSubTypeOfType) {
-        argumentNodeVerified = true;
-      }
+      termVerifiedAsVariable = true;
     }
   }
 
-  return argumentNodeVerified;
+  return termVerifiedAsVariable;
 }

package/src/verify/termAsConstructor.js

@@ -7,7 +7,8 @@ import { first } from "../utilities/array";
 import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
 import { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from "../ruleNames";
 
-const typeNodeQuery = nodeQuery("/argument/type");
+const typeNodeQuery = nodeQuery("/argument/type"),
+      termNodeQuery = nodeQuery("/argument/term");
 
 export default function verifyTermAsConstructor(termNode, typeNode, fileContext) {
   let termVerifiedAsConstructor = false;
@@ -139,24 +140,28 @@ function verifyNonTerminalNode(nonTerminalNode, fileContext) {
 }
 
 function verifyArgumentNode(argumentNode, fileContext) {
-  let typeNodeVerified = false;
+  let argumentNodeVerified = false;
 
-  const typeNode = typeNodeQuery(argumentNode);
+  const typeNode = typeNodeQuery(argumentNode),
+        termNode = termNodeQuery(argumentNode);
 
-  if (typeNode === null) {
-    const argumentString = fileContext.nodeAsString(argumentNode);
-
-    fileContext.error(`The ${argumentString} argument should be a type.`, argumentNode);
-  } else {
+  if (false) {
+    ///
+  } else if (typeNode !== null) {
     const typeName = typeNameFromTypeNode(typeNode),
           typePresent = fileContext.isTypePresentByTypeName(typeName);
 
     if (!typePresent) {
       fileContext.error(`The type '${typeName}' is not present.`, argumentNode);
-    } else {
-      typeNodeVerified = true;
     }
+
+    argumentNodeVerified = typePresent; ///
+  } else if (termNode !== null) {
+    const node = termNode,  ///
+          nodeVerified = verifyNode(node, fileContext);
+
+    argumentNodeVerified = nodeVerified;  ///
   }
 
-  return typeNodeVerified;
+  return argumentNodeVerified;
 }