occam-verify-cli 0.0.677 → 0.0.679

package/src/verify/statementAsCombinator.js

@@ -1,22 +1,22 @@
 "use strict";
 
 import Combinator from "../combinator";
-import verifyTerm from "../verify/term";
-import verifyStatement from "../verify/statement";
-
-import { typeNameFromTypeNode } from "../utilities/query";
-import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+import statementAsCombinatorNodeVerifier from "../verifier/node/statementAsCombinator";
 
 export default function verifyStatementAsCombinator(statementNode, fileContext) {
   let statementVerifiedAsCombinator = false;
 
   const statementString = fileContext.nodeAsString(statementNode);
 
-  fileContext.debug(`Verifying the '${statementString}' combinator....`, statementNode);
+  fileContext.trace(`Verifying the '${statementString}' statement as a combinator....`, statementNode);
 
-  const nonTerminalNode = statementNode,  ///
+  const nonTerminalNode = statementNode, ///
         childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = verifyChildNodes(childNodes, fileContext);
+        childNodesVerified = statementAsCombinatorNodeVerifier.verifyChildNodes(childNodes, fileContext, () => {
+          const verifiedAhead = true;
+
+          return verifiedAhead;
+        });
 
   if (childNodesVerified) {
     const tokens = fileContext.getTokens(),
@@ -28,128 +28,8 @@ export default function verifyStatementAsCombinator(statementNode, fileContext)
   }
 
   if (statementVerifiedAsCombinator) {
-    fileContext.info(`Verified the '${statementString}' combinator.`, statementNode);
+    fileContext.debug(`...verified the '${statementString}' statement as a combinator.`, statementNode);
   }
 
   return statementVerifiedAsCombinator;
 }
-
-function verifyNode(node, fileContext) {
-  let nodeVerified;
-
-  const nodeTerminalNode = node.isTerminalNode();
-
-  if (nodeTerminalNode) {
-    const terminalNode = node,  ///
-          terminalNodeVerified = verifyTerminalNode(terminalNode, fileContext);
-
-    nodeVerified = terminalNodeVerified;  ///
-  } else {
-    const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, fileContext);
-
-    nodeVerified = nonTerminalNodeVerified; ///
-  }
-
-  return nodeVerified;
-}
-
-function verifyChildNodes(childNodes, fileContext) {
-  const childNodesVerified = childNodes.every((childNode) => {
-    const node = childNode, ///
-          nodeVerified = verifyNode(node, fileContext);
-
-    if (nodeVerified) {
-      return true;
-    }
-  });
-
-  return childNodesVerified;
-}
-
-function verifyTerminalNode(terminalNode, fileContext) {
-  const terminalNodeVerified = true;
-
-  return terminalNodeVerified;
-}
-
-function verifyNonTerminalNode(nonTerminalNode, fileContext) {
-  let nonTerminalNodeVerified;
-
-  const ruleName = nonTerminalNode.getRuleName();
-
-  switch (ruleName) {
-    case TYPE_RULE_NAME: {
-      const typeNode = nonTerminalNode, ///
-            typeNodeVerified = verifyTypeNode(typeNode, fileContext);
-
-      nonTerminalNodeVerified = typeNodeVerified; ///
-
-      break;
-    }
-
-    case TERM_RULE_NAME: {
-      const termNode = nonTerminalNode, ///
-            termNodeVerified = verifyTermNode(termNode, fileContext);
-
-      nonTerminalNodeVerified = termNodeVerified; ///
-
-      break;
-    }
-
-    case STATEMENT_RULE_NAME: {
-      const statmentNode = nonTerminalNode, ///
-            statmentNodeVerified = verifyStatementNode(statmentNode, fileContext);
-
-      nonTerminalNodeVerified = statmentNodeVerified; ///
-
-      break;
-    }
-
-    default: {
-      const childNodes = nonTerminalNode.getChildNodes(),
-            childNodesVerified = verifyChildNodes(childNodes, fileContext);
-
-      nonTerminalNodeVerified = childNodesVerified; ///
-
-      break;
-    }
-  }
-
-  return nonTerminalNodeVerified;
-}
-
-function verifyTypeNode(typeNode, fileContext) {
-  let typeNodeVerified = false;
-
-  const typeName = typeNameFromTypeNode(typeNode),
-        typePresent = fileContext.isTypePresentByTypeName(typeName);
-
-  if (!typePresent) {
-    fileContext.error(`The type '${typeName}' not present.`, typeNode);
-  } else {
-    typeNodeVerified = true;
-  }
-
-  return typeNodeVerified;
-}
-
-function verifyTermNode(termNode, fileContext) {
-  const types = [],
-        context = fileContext,  ///
-        termVerified = verifyTerm(termNode, types, context),
-        termNodeVerified = termVerified;  ///
-
-  return termNodeVerified;
-}
-
-function verifyStatementNode(statementNode, fileContext) {
-  const context = fileContext,  ///
-        derived = false,
-        assignments = [],
-        statementVerified = verifyStatement(statementNode, assignments, derived, context),
-        statementNodeVerified = statementVerified;  ///
-
-  return statementNodeVerified;
-}
-

package/src/verify/supposition.js

@@ -14,7 +14,7 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
 
   const suppositionString = proofContext.nodeAsString(suppositionNode);
 
-  proofContext.debug(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
+  proofContext.trace(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
 
   const derived = false,
         assignments = [],
@@ -38,7 +38,7 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
   }
 
   if (suppositionVerified) {
-    proofContext.info(`Verified the '${suppositionString}' supposition.`, suppositionNode);
+    proofContext.debug(`...verified the '${suppositionString}' supposition.`, suppositionNode);
   }
 
   return suppositionVerified;

package/src/verify/term.js

@@ -1,222 +1,157 @@
 "use strict";
 
-import Verifier from "../verifier";
+import termNodesVerifier from "../verifier/nodes/term";
 
 import { first } from "../utilities/array";
-import { objectType } from "../type";
-import { OBJECT_TYPE_NAME } from "../typeNames";
-import { ARGUMENT_RULE_NAME } from "../ruleNames";
-import { nodeQuery, typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities/query";
+import { nodeQuery, variableNameFromVariableNode } from "../utilities/query";
 
-const termNodeQuery = nodeQuery("/argument/term!"),
-      typeNodeQuery = nodeQuery("/argument/type!"),
-      variableNodeQuery = nodeQuery("/term/variable!");
+const variableNodeQuery = nodeQuery("/term/variable!");
 
-class TermVerifier extends Verifier {
-  verifyTerminalNode(terminalNode, constructorTerminalNode, context) {
-    let terminalNodeVerified = false;
+function verifyTerm(termNode, types, context, verifyAhead) {
+  let termVerified;
 
-    const matches = terminalNode.match(constructorTerminalNode);
+  const termString = context.nodeAsString(termNode);
 
-    if (matches) {
-      terminalNodeVerified = true;
-    }
+  context.trace(`Verifying the '${termString}' term...`, termNode);
 
-    return terminalNodeVerified;
-  }
+  const verifyTermFunctions = [
+    verifyTermAsStandaloneVariable,
+    verifyTermAgainstConstructors
+  ];
 
-  verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {
-    let nonTerminalNodeVerified = false;
+  termVerified = verifyTermFunctions.some((verifyTermFunction) => {
+    const termVerified = verifyTermFunction(termNode, types, context, verifyAhead);
 
-    const ruleName = nonTerminalNode.getRuleName(), ///
-          constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
+    if (termVerified) {
+      return true;
+    }
+  });
 
-    if (ruleName === constructorRuleName) {
-      switch (ruleName) {
-        case ARGUMENT_RULE_NAME: {
-          const argumentNode = nonTerminalNode, ///
-                constructorArgumentNode = constructorNonTerminalNode, ///
-                argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, context);
+  if (termVerified) {
+    const firstType = first(types),
+          type = firstType, ///
+          typeName = type.getName();
 
-          nonTerminalNodeVerified = argumentNodeVerified; ///
+    context.debug(`...verified the '${termString}' term, which has been given the '${typeName}' type.`, termNode);
+  }
 
-          break;
-        }
+  return termVerified;
+}
 
-        default: {
-          const childNodes = nonTerminalNode.getChildNodes(),
-                constructorChildNodes = constructorNonTerminalNode.getChildNodes(),
-                nodes = childNodes, ///
-                constructorNodes = constructorChildNodes, ///
-                nodesVerified = this.verifyNodes(nodes, constructorNodes, context);
+Object.assign(termNodesVerifier, {
+  verifyTerm
+});
 
-          nonTerminalNodeVerified = nodesVerified; ///
+export default verifyTerm;
 
-          break;
-        }
-      }
-    }
+export function verifyTermAgainstConstructors(termNode, types, context, verifyAhead) {
+  let termVerifiedAgainstConstructors;
 
-    return nonTerminalNodeVerified;
-  }
+  const constructors = context.getConstructors();
 
-  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),
-                firstType = first(types),
-                termType = firstType, ///
-                termTypeName = termType.getName(),
-                constructorType = (constructorTypeName === OBJECT_TYPE_NAME) ?
-                                    objectType :
-                                      context.findTypeByTypeName(constructorTypeName),
-                termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
-
-          if (termTypeEqualToOrSubTypeOfType) {
-            const termString = context.nodeAsString(termNode);
-
-            context.trace(`The '${termTypeName}' type of the '${termString}' term is equal to or a sub-type of the '${constructorTypeName}' type in the constructor.`, argumentNode);
-
-            argumentNodeVerified = true;
-          }
-        }
-      }
+  termVerifiedAgainstConstructors = constructors.some((constructor) => {
+    const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, types, constructor, context, verifyAhead);
+
+    if (termVerifiedAgainstConstructor) {
+      return true;
     }
+  });
 
-    return argumentNodeVerified;
-  }
+  return termVerifiedAgainstConstructors;
 }
 
-export const termVerifier = new TermVerifier();
-
-export default function verifyTerm(termNode, types, context) {
-  let termVerified = false;
+export function verifyTermAsVariable(termNode, variables, context, verifyAhead) {
+  let termVerifiedAsVariable = false;
 
   const termString = context.nodeAsString(termNode);
 
-  context.debug(`Verifying the '${termString}' term...`, termNode);
+  context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
-  if (!termVerified) {
-    const variables = [],
-          termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
+  const variableNode = variableNodeQuery(termNode);
 
-    if (termVerifiedAsVariable) {
-      const firstVariable = first(variables),
-            variable = firstVariable, ///
-            type = variable.getType();
+  if (variableNode !== null) {
+    const variableName = variableNameFromVariableNode(variableNode),
+          variablePresent = context.isVariablePresentByVariableName(variableName);
 
-      types.push(type);
+    if (variablePresent) {
+      let verifiedAhead;
 
-      termVerified = true;
-    }
-  }
+      const variable = context.findVariableByVariableName(variableName);
+
+      variables.push(variable);
 
-  if (!termVerified) {
-    const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
+      verifiedAhead = verifyAhead();
 
-    if (termVerifiedAgainstConstructors) {
-      termVerified = true;
+      termVerifiedAsVariable = verifiedAhead; ///
     }
   }
 
-  if (termVerified) {
-    const firstType = first(types),
-          type = firstType, ///
-          typeName = type.getName();
-
-    context.debug(`Verified the '${termString}' term, which has type '${typeName}'.`, termNode);
+  if (termVerifiedAsVariable) {
+    context.debug(`...verified the '${termString}' term as a variable.`, termNode);
   }
 
-  return termVerified;
+  return termVerifiedAsVariable;
 }
 
-export function verifyTermAgainstConstructors(termNode, types, context) {
-  let termVerifiedAgainstConstructors = false;
-
-  const termString = context.nodeAsString(termNode);
+function verifyTermAgainstConstructor(termNode, types, constructor, context, verifyAhead) {
+  let termVerifiedAgainstConstructor;
 
-  context.trace(`Verifying the '${termString}' term against constructors...`, termNode);
-
-  const constructors = context.getConstructors(),
-        constructor = constructors.find((constructor) => {
-          const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);
+  const termString = context.nodeAsString(termNode),
+        constructorString = constructor.getString();
 
-          if (termVerifiedAgainstConstructor) {
-            return true;
-          }
-        }) || null;
+  context.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
 
-  if (constructor !== null) {
-    const type = constructor.getType();
+  const constructorTermNode = constructor.getTermNode(),
+        nonTerminalNNdeA = termNode,  ///
+        nonTerminalNodeB = constructorTermNode,  ///
+        nodeVerified = termNodesVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context, () => {
+          let verifiedAhead;
 
-    types.push(type);
+          const type = constructor.getType();
 
-    termVerifiedAgainstConstructors = true;
-  }
+          types.push(type);
 
-  return termVerifiedAgainstConstructors;
-}
+          verifiedAhead = verifyAhead();
 
-export function verifyTermAgainstConstructor(termNode, constructor, context) {
-  const termString = context.nodeAsString(termNode),
-        constructorString = constructor.getString();
+          return verifiedAhead;
+        });
 
-  context.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor.`, termNode);
+  termVerifiedAgainstConstructor = nodeVerified;  ///
 
-  const constructorTermNode = constructor.getTermNode(),
-        nonTerminalNNdeA = termNode,  ///
-        nonTerminalNodeB = constructorTermNode,  ///
-        nodeVerified = termVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context),
-        termVerifiedAgainstConstructor = nodeVerified;  ///
+  if (termVerifiedAgainstConstructor) {
+    context.debug(`...verified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
+  }
 
   return termVerifiedAgainstConstructor;
 }
 
-export function verifyTermAsVariable(termNode, variables, context) {
-  let termVerifiedAsVariable = false;
+function verifyTermAsStandaloneVariable(termNode, types, context, verifyAhead) {
+  let termVerifiedAsStandaloneVariable;
 
   const termString = context.nodeAsString(termNode);
 
-  context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
+  context.trace(`Verifying the '${termString}' term as a standalone variable...`, termNode);
 
-  const variableNode = variableNodeQuery(termNode);
+  const variables = [],
+        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {
+          let verifiedAhead;
 
-  if (variableNode !== null) {
-    const variableName = variableNameFromVariableNode(variableNode),
-          variablePresent = context.isVariablePresentByVariableName(variableName);
+          const firstVariable = first(variables),
+                variable = firstVariable, ///
+                type = variable.getType();
 
-    if (variablePresent) {
-      const variable = context.findVariableByVariableName(variableName);
+          types.push(type);
 
-      variables.push(variable);
+          verifiedAhead = verifyAhead();
 
-      termVerifiedAsVariable = true;
-    }
+          return verifiedAhead;
+        });
+
+  termVerifiedAsStandaloneVariable = termVerifiedAsVariable;  ///
+
+  if (termVerifiedAsStandaloneVariable) {
+    context.debug(`...verified the '${termString}' term as a standalone variable.`, termNode);
   }
 
-  return termVerifiedAsVariable;
+  return termVerifiedAsStandaloneVariable;
 }

package/src/verify/termAsConstructor.js

@@ -1,27 +1,28 @@
 "use strict";
 
-import verifyTerm from "../verify/term";
 import Constructor from "../constructor";
+import termAsConstructorNodeVerifier from "../verifier/node/termAsConstructor";
 
-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"),
-      termNodeQuery = nodeQuery("/argument/term");
+import { typeNameFromTypeNode } from "../utilities/query";
 
 export default function verifyTermAsConstructor(termNode, typeNode, fileContext) {
   let termVerifiedAsConstructor = false;
 
-  let type = null;
+  const termString = fileContext.nodeAsString(termNode);
+
+  fileContext.debug(`Verifying the '${termString}' term as a constructor...`, termNode);
 
-  const nonTerminalNode = termNode,  ///
-        termString = fileContext.nodeAsString(termNode);
+  const nonTerminalNode = termNode, ///
+        childNodes = nonTerminalNode.getChildNodes(),
+        childNodesVerified = termAsConstructorNodeVerifier.verifyChildNodes(childNodes, fileContext, () => {
+          const verifiedAhead = true;
 
-  const childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = verifyChildNodes(childNodes, fileContext);
+          return verifiedAhead;
+        });
 
   if (childNodesVerified) {
+    let type = null;
+
     if (typeNode === null) {
       termVerifiedAsConstructor = true;
     } else {
@@ -32,137 +33,21 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
       if (type !== null) {
         termVerifiedAsConstructor = true;
       } else {
-        fileContext.error(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);
+        fileContext.info(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);
       }
     }
-  }
 
-  if (termVerifiedAsConstructor) {
-    const tokens = fileContext.getTokens(),
-          constructor = Constructor.fromTermNodeTypeAndTokens(termNode, type, tokens);
+    if (termVerifiedAsConstructor) {
+      const tokens = fileContext.getTokens(),
+            constructor = Constructor.fromTermNodeTypeAndTokens(termNode, type, tokens);
 
-    fileContext.addConstructor(constructor);
+      fileContext.addConstructor(constructor);
+    }
   }
 
   if (termVerifiedAsConstructor) {
-    fileContext.info(`Verified the '${termString}' constructor.`, termNode);
+    fileContext.debug(`...verified the '${termString}' term as a constructor.`, termNode);
   }
 
   return termVerifiedAsConstructor;
 }
-
-function verifyNode(node, fileContext) {
-  let nodeVerified;
-
-  const nodeTerminalNode = node.isTerminalNode();
-
-  if (nodeTerminalNode) {
-    const terminalNode = node,  ///
-          terminalNodeVerified = verifyTerminalNode(terminalNode, fileContext);
-
-    nodeVerified = terminalNodeVerified;  ///
-  } else {
-    const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, fileContext);
-
-    nodeVerified = nonTerminalNodeVerified; ///
-  }
-
-  return nodeVerified;
-}
-
-function verifyChildNodes(childNodes, fileContext) {
-  const childNodesVerified = childNodes.every((childNode) => {
-    const node = childNode, ///
-          nodeVerified = verifyNode(node, fileContext);
-
-    if (nodeVerified) {
-      return true;
-    }
-  });
-
-  return childNodesVerified;
-}
-
-function verifyTerminalNode(terminalNode, fileContext) {
-  const terminalNodeVerified = true;
-
-  return terminalNodeVerified;
-}
-
-function verifyNonTerminalNode(nonTerminalNode, fileContext) {
-  let nonTerminalNodeVerified;
-
-  const ruleName = nonTerminalNode.getRuleName();
-
-  switch (ruleName) {
-    case ARGUMENT_RULE_NAME: {
-      const argumentNode = nonTerminalNode, ///
-            argumentNodeVerified = verifyArgumentNode(argumentNode, fileContext);
-
-      nonTerminalNodeVerified = argumentNodeVerified; ///
-
-      break;
-    }
-
-    case TERM_RULE_NAME: {
-      const termNode = nonTerminalNode, ///
-            types = [],
-            context = fileContext,  ///
-            termVerified = verifyTerm(termNode, types, context);
-
-      if (termVerified) {
-        const firstType = first(types),
-              type = firstType; ///
-
-        if (type !== null) {
-          const termString = fileContext.nodeAsString(termNode);
-
-          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`, termNode);
-        } else {
-          nonTerminalNodeVerified = true; ///
-        }
-      }
-
-      break;
-    }
-
-    default: {
-      const childNodes = nonTerminalNode.getChildNodes(),
-            childNodesVerified = verifyChildNodes(childNodes, fileContext);
-
-      nonTerminalNodeVerified = childNodesVerified; ///
-
-      break;
-    }
-  }
-
-  return nonTerminalNodeVerified;
-}
-
-function verifyArgumentNode(argumentNode, fileContext) {
-  let argumentNodeVerified = false;
-
-  const typeNode = typeNodeQuery(argumentNode),
-        termNode = termNodeQuery(argumentNode);
-
-  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);
-    }
-
-    argumentNodeVerified = typePresent; ///
-  } else if (termNode !== null) {
-    const node = termNode,  ///
-          nodeVerified = verifyNode(node, fileContext);
-
-    argumentNodeVerified = nodeVerified;  ///
-  }
-
-  return argumentNodeVerified;
-}