occam-verify-cli 0.0.317 → 0.0.319

package/src/verify/rule.js

@@ -16,20 +16,19 @@ const labelNodesQuery = nodesQuery("/rule/label"),
       conditionalInferenceNodeQuery = nodeQuery("/rule/conditionalInference!"),
       unconditionalInferenceNodeQuery = nodeQuery("/rule/unconditionalInference!");
 
-export default function verifyRule(ruleNode, context) {
+export default function verifyRule(ruleNode, fileContext) {
   let ruleVerified = false;
 
-  const labelNodes = labelNodesQuery(ruleNode),
-        labelsString = nodesAsString(labelNodes);
-
-  const metaproofContext = MetaproofContext.fromContext(context);
+  fileContext.begin(ruleNode);
 
-  context = metaproofContext; ///
+  const labelNodes = labelNodesQuery(ruleNode),
+        labelsString = nodesAsString(labelNodes),
+        metaproofContext = MetaproofContext.fromFileContext(fileContext);
 
-  context.debug(`Verifying the '${labelsString}' rule...`, ruleNode);
+  fileContext.debug(`Verifying the '${labelsString}' rule...`);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, context);
+        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
     const premises = [],
@@ -41,11 +40,11 @@ export default function verifyRule(ruleNode, context) {
         unconditionalInferenceVerified = false;
 
     if (conditionalInferenceNode !== null) {
-      conditionalInferenceVerified = verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context);
+      conditionalInferenceVerified = verifyConditionalInference(conditionalInferenceNode, premises, conclusions, metaproofContext);
     }
 
     if (unconditionalInferenceNode !== null) {
-      unconditionalInferenceVerified = verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, context);
+      unconditionalInferenceVerified = verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, metaproofContext);
     }
 
     if (conditionalInferenceVerified || unconditionalInferenceVerified) {
@@ -56,22 +55,22 @@ export default function verifyRule(ruleNode, context) {
       let metaproofVerified = true;
 
       if (metaproofNode !== null) {
-        metaproofVerified = verifyMetaproof(metaproofNode, conclusion, context);
+        metaproofVerified = verifyMetaproof(metaproofNode, conclusion, metaproofContext);
       }
 
       if (metaproofVerified) {
         const rule = Rule.fromPremisesConclusionAndLabels(premises, conclusion, labels);
 
-        context.addRule(rule);
+        fileContext.addRule(rule);
 
         ruleVerified = true;
       }
     }
-
-    if (ruleVerified) {
-      context.info(`Verified the '${labelsString}' rule.`, ruleNode);
-    }
   }
 
+  ruleVerified ?
+    fileContext.complete(ruleNode) :
+      fileContext.complete(ruleNode);
+
   return ruleVerified;
 }

package/src/verify/statement/qualified.js

@@ -6,10 +6,19 @@ import { nodeQuery } from "../../utilities/query";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
-export default function verifyQualifiedStatement(qualifiedStatementNode, context) {
+export default function verifyQualifiedStatement(qualifiedStatementNode, proofContext) {
+  let qualifiedStatementVerified;
+
+  proofContext.begin(qualifiedStatementNode);
+
   const statementNode = statementNodeQuery(qualifiedStatementNode),
-        statementVerified = verifyStatement(statementNode, context),
-        qualifiedStatementVerified = statementVerified; ///
+        statementVerified = verifyStatement(statementNode, proofContext);
+
+  qualifiedStatementVerified = statementVerified; ///
+
+  qualifiedStatementVerified ?
+    proofContext.complete(qualifiedStatementNode) :
+      proofContext.halt(qualifiedStatementNode);
 
   return qualifiedStatementVerified;
 }

package/src/verify/statement/unqualified.js

@@ -6,20 +6,26 @@ import { nodeQuery } from "../../utilities/query";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
-export default function verifyUnqualifiedStatement(unqualifiedStatementNode, context) {
+export default function verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext) {
   let unqualifiedStatementVerified = false;
 
+  proofContext.begin(unqualifiedStatementNode);
+
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementVerified = verifyStatement(statementNode, context);
+    const statementVerified = verifyStatement(statementNode, proofContext);
 
     if (statementVerified) {
-      context.addStatementNode(statementNode);
+      debugger
 
       unqualifiedStatementVerified = true;
     }
   }
 
+  unqualifiedStatementVerified ?
+    proofContext.complete(unqualifiedStatementNode) :
+      proofContext.halt(unqualifiedStatementNode);
+
   return unqualifiedStatementVerified;
 }

package/src/verify/statement.js

@@ -9,33 +9,34 @@ import { nodeAsString } from "../utilities/string";
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-export default function verifyStatement(statementNode, context) {
+export default function verifyStatement(statementNode, proofContext) {
   let statementVerified = false;
 
-  const statementString = nodeAsString(statementNode);
-
-  context.debug(`Verifying the '${statementString}' statement...`, statementNode);
+  proofContext.begin(statementNode);
 
   const equalityNode = equalityNodeQuery(statementNode),
+        statementString = nodeAsString(statementNode),
         typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
+  proofContext.debug(`Verifying the '${statementString}' statement...`);
+
   if (false) {
     ///
   } else if (equalityNode !== null) {
-    const equalityVerified = verifyEquality(equalityNode, context);
+    const equalityVerified = verifyEquality(equalityNode, proofContext);
 
     statementVerified = equalityVerified; ///
   } else if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, context);
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, proofContext);
 
     statementVerified = typeAssertionVerified; ///
   } else {
     debugger
   }
 
-  if (statementVerified) {
-    context.info(`Verified the '${statementString}' statement.`, statementNode);
-  }
+  statementVerified ?
+    proofContext.complete(statementNode) :
+      proofContext.halt(statementNode);
 
   return statementVerified;
 }

package/src/verify/statementAsCombinator.js

@@ -6,47 +6,46 @@ import { nodeAsString } from "../utilities/string";
 import { typeNameFromTypeNode } from "../utilities/query";
 import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../ruleNames";
 
-export default function verifyStatementAsCombinator(statementNode, context) {
+export default function verifyStatementAsCombinator(statementNode, fileContext) {
   let statementVerifiedAsCombinator = false;
 
-  const statementString = nodeAsString(statementNode);
-
-  context.debug(`Verifying the ${statementString} statement as a combinator...`, statementNode);
+  fileContext.begin(statementNode);
 
   const nonTerminalNode = statementNode,  ///
         childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = verifyChildNodes(childNodes, context);
+        childNodesVerified = verifyChildNodes(childNodes, fileContext);
 
   if (childNodesVerified) {
-    statementVerifiedAsCombinator = true;
-  }
+    const combinator = Combinator.fromStatementNode(statementNode),
+          statementString = nodeAsString(statementNode);
 
-  if (statementVerifiedAsCombinator) {
-    const combinator = Combinator.fromStatementNode(statementNode);
+    fileContext.info(`Verified the '${statementString}' combinator.`);
 
-    context.addCombinator(combinator);
+    fileContext.addCombinator(combinator);
 
-    const statementString = nodeAsString(statementNode);
-
-    context.info(`Verified the '${statementString}' combinator.`, statementNode);
+    statementVerifiedAsCombinator = true;
   }
 
+  statementVerifiedAsCombinator ?
+    fileContext.complete(statementNode) :
+      fileContext.halt(statementNode);
+
   return statementVerifiedAsCombinator;
 }
 
-function verifyNode(node, context) {
+function verifyNode(node, fileContext) {
   let nodeVerified;
 
   const nodeTerminalNode = node.isTerminalNode();
 
   if (nodeTerminalNode) {
     const terminalNode = node,  ///
-          terminalNodeVerified = verifyTerminalNode(terminalNode, context);
+          terminalNodeVerified = verifyTerminalNode(terminalNode, fileContext);
 
     nodeVerified = terminalNodeVerified;  ///
   } else {
     const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, context);
+          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, fileContext);
 
     nodeVerified = nonTerminalNodeVerified; ///
   }
@@ -54,10 +53,33 @@ function verifyNode(node, context) {
   return nodeVerified;
 }
 
-function verifyChildNodes(childNodes, context) {
+function verifyTypeNode(typeNode, fileContext) {
+  let typeNodeVerified = false;
+
+  const typeName = typeNameFromTypeNode(typeNode),
+        typePresent = fileContext.isTypePresentByTypeName(typeName);
+
+  if (!typePresent) {
+    fileContext.error(`The type '${typeName}' is missing.`);
+  } else {
+    typeNodeVerified = true;
+  }
+
+  return typeNodeVerified;
+}
+
+function verifyTermNode(termNode, fileContext) {
+  let termNodeVerified = false;
+
+  debugger
+
+  return termNodeVerified;
+}
+
+function verifyChildNodes(childNodes, fileContext) {
   const childNodesVerified = childNodes.every((childNode) => {
     const node = childNode, ///
-          nodeVerified = verifyNode(node, context);
+          nodeVerified = verifyNode(node, fileContext);
 
     if (nodeVerified) {
       return true;
@@ -67,13 +89,13 @@ function verifyChildNodes(childNodes, context) {
   return childNodesVerified;
 }
 
-function verifyTerminalNode(terminalNode, context) {
+function verifyTerminalNode(terminalNode, fileContext) {
   const terminalNodeVerified = true;
 
   return terminalNodeVerified;
 }
 
-function verifyNonTerminalNode(nonTerminalNode, context) {
+function verifyNonTerminalNode(nonTerminalNode, fileContext) {
   let nonTerminalNodeVerified;
 
   const ruleName = nonTerminalNode.getRuleName();
@@ -81,7 +103,7 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
   switch (ruleName) {
     case TYPE_RULE_NAME: {
       const typeNode = nonTerminalNode, ///
-            typeNodeVerified = verifyTypeNode(typeNode, context);
+            typeNodeVerified = verifyTypeNode(typeNode, fileContext);
 
       nonTerminalNodeVerified = typeNodeVerified; ///
 
@@ -90,7 +112,7 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
 
     case TERM_RULE_NAME: {
       const termNode = nonTerminalNode, ///
-            termNodeVerified = verifyTermNode(termNode, context);
+            termNodeVerified = verifyTermNode(termNode, fileContext);
 
       nonTerminalNodeVerified = termNodeVerified; ///
 
@@ -99,7 +121,7 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
 
     default: {
       const childNodes = nonTerminalNode.getChildNodes(),
-            childNodesVerified = verifyChildNodes(childNodes, context);
+            childNodesVerified = verifyChildNodes(childNodes, fileContext);
 
       nonTerminalNodeVerified = childNodesVerified; ///
 
@@ -109,26 +131,3 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
 
   return nonTerminalNodeVerified;
 }
-
-function verifyTypeNode(typeNode, context) {
-  let typeNodeVerified = false;
-
-  const typeName = typeNameFromTypeNode(typeNode),
-        typePresent = context.isTypePresentByTypeName(typeName);
-
-  if (!typePresent) {
-    context.error(`The type '${typeName}' is missing.`, typeNode);
-  } else {
-    typeNodeVerified = true;
-  }
-
-  return typeNodeVerified;
-}
-
-function verifyTermNode(termNode, context) {
-  let termNodeVerified = false;
-
-  debugger
-
-  return termNodeVerified;
-}

package/src/verify/term.js

@@ -13,6 +13,8 @@ const termNodeQuery = nodeQuery("/argument/term!"),
 export default function verifyTerm(termNode, types, values, context) {
   let termVerified = false;
 
+  context.begin(termNode);
+
   const names = [],
         termVerifiedAsVariable = verifyTermAsVariable(termNode, types, names, values, context);
 
@@ -40,6 +42,10 @@ export default function verifyTerm(termNode, types, values, context) {
     }
   }
 
+  termVerified ?
+    context.complete(termNode) :
+      context.halt(termNode);
+
   return termVerified;
 }
 
@@ -153,7 +159,7 @@ function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
   if (termNode === null) {
     const argumentString = nodeAsString(argumentNode);
 
-    context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
+    context.error(`The ${argumentString} argument should be a term, not a type`);
   } else {
     const types = [],
           values = [],

package/src/verify/termAsConstructor.js

@@ -10,18 +10,16 @@ import { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from "../ruleNames";
 
 const typeNodeQuery = nodeQuery("/argument/type");
 
-export default function verifyTermAsConstructor(termNode, typeNode, context) {
+export default function verifyTermAsConstructor(termNode, typeNode, fileContext) {
   let termVerifiedAsConstructor = false;
 
-  const termString = nodeAsString(termNode);
+  fileContext.begin(termNode);
 
-  context.debug(`Verifying the '${termString}' term as a constructor...`, termNode);
+  let type = null;
 
   const nonTerminalNode = termNode,  ///
         childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = verifyChildNodes(childNodes, context);
-
-  let type = null;
+        childNodesVerified = verifyChildNodes(childNodes, fileContext);
 
   if (childNodesVerified) {
     if (typeNode === null) {
@@ -29,44 +27,47 @@ export default function verifyTermAsConstructor(termNode, typeNode, context) {
     } else {
       const typeName = typeNameFromTypeNode(typeNode);
 
-      type = context.findTypeByTypeName(typeName);
+      type = fileContext.findTypeByTypeName(typeName);
 
       if (type !== null) {
         termVerifiedAsConstructor = true;
       } else {
         const termString = nodeAsString(termNode);
 
-        context.error(`The '${termString}' constructor's '${typeName}' type is missing.`, termNode);
+        fileContext.error(`The '${termString}' constructor's '${typeName}' type is missing.`);
       }
     }
   }
 
   if (termVerifiedAsConstructor) {
-    const constructor = Constructor.fromTermNodeAndType(termNode, type);
+    const termString = nodeAsString(termNode),
+          constructor = Constructor.fromTermNodeAndType(termNode, type);
 
-    context.addConstructor(constructor);
+    fileContext.addConstructor(constructor);
 
-    const termString = nodeAsString(termNode);
-
-    context.info(`Verified the '${termString}' constructor.`, termNode);
+    fileContext.info(`Verified the '${termString}' constructor.`);
   }
 
+  termVerifiedAsConstructor ?
+    fileContext.complete(termNode) :
+      fileContext.halt(termNode);
+
   return termVerifiedAsConstructor;
 }
 
-function verifyNode(node, context) {
+function verifyNode(node, fileContext) {
   let nodeVerified;
 
   const nodeTerminalNode = node.isTerminalNode();
 
   if (nodeTerminalNode) {
     const terminalNode = node,  ///
-          terminalNodeVerified = verifyTerminalNode(terminalNode, context);
+          terminalNodeVerified = verifyTerminalNode(terminalNode, fileContext);
 
     nodeVerified = terminalNodeVerified;  ///
   } else {
     const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, context);
+          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, fileContext);
 
     nodeVerified = nonTerminalNodeVerified; ///
   }
@@ -74,10 +75,10 @@ function verifyNode(node, context) {
   return nodeVerified;
 }
 
-function verifyChildNodes(childNodes, context) {
+function verifyChildNodes(childNodes, fileContext) {
   const childNodesVerified = childNodes.every((childNode) => {
     const node = childNode, ///
-          nodeVerified = verifyNode(node, context);
+          nodeVerified = verifyNode(node, fileContext);
 
     if (nodeVerified) {
       return true;
@@ -87,13 +88,36 @@ function verifyChildNodes(childNodes, context) {
   return childNodesVerified;
 }
 
-function verifyTerminalNode(terminalNode, context) {
+function verifyTerminalNode(terminalNode, fileContext) {
   const terminalNodeVerified = true;
 
   return terminalNodeVerified;
 }
 
-function verifyNonTerminalNode(nonTerminalNode, context) {
+function verifyArgumentNode(argumentNode, fileContext) {
+  let typeNodeVerified = false;
+
+  const typeNode = typeNodeQuery(argumentNode);
+
+  if (typeNode === null) {
+    const argumentString = nodeAsString(argumentNode);
+
+    fileContext.error(`The ${argumentString} argument should be a type.`);
+  } else {
+    const typeName = typeNameFromTypeNode(typeNode),
+          typePresent = fileContext.isTypePresentByTypeName(typeName);
+
+    if (!typePresent) {
+      fileContext.error(`The type '${typeName}' is missing.`);
+    } else {
+      typeNodeVerified = true;
+    }
+  }
+
+  return typeNodeVerified;
+}
+
+function verifyNonTerminalNode(nonTerminalNode, fileContext) {
   let nonTerminalNodeVerified;
 
   const ruleName = nonTerminalNode.getRuleName();
@@ -101,7 +125,7 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
   switch (ruleName) {
     case ARGUMENT_RULE_NAME: {
       const argumentNode = nonTerminalNode, ///
-            argumentNodeVerified = verifyArgumentNode(argumentNode, context);
+            argumentNodeVerified = verifyArgumentNode(argumentNode, fileContext);
 
       nonTerminalNodeVerified = argumentNodeVerified; ///
 
@@ -112,6 +136,7 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
       const termNode = nonTerminalNode, ///
             types = [],
             values = [],
+            context = fileContext,  ///
             termVerified = verifyTerm(termNode, types, values, context);
 
       if (termVerified) {
@@ -121,7 +146,7 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
         if (type !== null) {
           const termString = nodeAsString(termNode);
 
-          context.error(`The type of the constructor's compound '${termString}' term node is not null.`, termNode);
+          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`);
         } else {
           nonTerminalNodeVerified = true; ///
         }
@@ -132,7 +157,7 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
 
     default: {
       const childNodes = nonTerminalNode.getChildNodes(),
-            childNodesVerified = verifyChildNodes(childNodes, context);
+            childNodesVerified = verifyChildNodes(childNodes, fileContext);
 
       nonTerminalNodeVerified = childNodesVerified; ///
 
@@ -143,25 +168,3 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
   return nonTerminalNodeVerified;
 }
 
-function verifyArgumentNode(argumentNode, context) {
-  let typeNodeVerified = false;
-
-  const typeNode = typeNodeQuery(argumentNode);
-
-  if (typeNode === null) {
-    const argumentString = nodeAsString(argumentNode);
-
-    context.error(`The ${argumentString} argument should be a type.`, argumentNode);
-  } else {
-    const typeName = typeNameFromTypeNode(typeNode),
-          typePresent = context.isTypePresentByTypeName(typeName);
-
-    if (!typePresent) {
-      context.error(`The type '${typeName}' is missing.`, typeNode);
-    } else {
-      typeNodeVerified = true;
-    }
-  }
-
-  return typeNodeVerified;
-}

package/src/verify/termAsVariable.js

@@ -7,6 +7,8 @@ const variableNodeQuery = nodeQuery("/term/variable!");
 export default function verifyTermAsVariable(termNode, types, names, values, context) {
   let termVerifiedAsVariable = false;
 
+  context.begin(termNode);
+
   const variableNode = variableNodeQuery(termNode);
 
   if (variableNode !== null) {
@@ -14,7 +16,7 @@ export default function verifyTermAsVariable(termNode, types, names, values, con
           variablePresent = context.isVariablePresentByVariableName(variableName);
 
     if (!variablePresent) {
-      context.error(`The ${variableName} variable is not present.`, variableNode)
+      context.error(`The ${variableName} variable is not present.`)
     } else {
       const variable = context.findVariableByVariableName(variableName),
             type = variable.getType(),
@@ -31,5 +33,9 @@ export default function verifyTermAsVariable(termNode, types, names, values, con
     }
   }
 
+  termVerifiedAsVariable ?
+    context.complete(termNode) :
+      context.halt(termNode);
+
   return termVerifiedAsVariable;
 }

package/src/verify/type.js

@@ -2,46 +2,50 @@
 
 import Type from "../type";
 
+import { nodeAsString } from "../utilities/string";
 import { typeNameFromTypeNode } from "../utilities/query";
 
-export default function verifyType(typeNode, superTypeNode, context) {
+export default function verifyType(typeNode, superTypeNode, fileContext) {
   let typeVerified = false;
 
+  fileContext.begin(typeNode);
+
+  let type = null;
+
   const typeName = typeNameFromTypeNode(typeNode),
-        typePresent = context.isTypePresentByTypeName(typeName);
+        typePresent = fileContext.isTypePresentByTypeName(typeName);
 
   if (typePresent) {
-    context.error(`The type '${typeName}' is already present.`, typeNode);
+    fileContext.error(`The type '${typeName}' is already present.`);
   } else {
     const superTypeName = typeNameFromTypeNode(superTypeNode);
 
     if (superTypeName === null) {
-      const type = Type.fromTypeName(typeName),
-            typeString = type.asString();
-
-      context.addType(type);
-
-      typeVerified = true;
-
-      context.info(`Verified the '${typeString}' type.`, typeNode);
+      type = Type.fromTypeName(typeName);
     } else {
-      const superType = context.findTypeByTypeName(superTypeName);
+      const superType = fileContext.findTypeByTypeName(superTypeName);
 
       if (superType === null) {
-        context.error(`The super-type '${superTypeName}' is missing.`, typeNode);
+        fileContext.error(`The super-type '${superTypeName}' is missing.`);
       } else {
-        const type = Type.fromTypeNameAndSuperType(typeName, superType),
-              typeString = type.asString();
+        type = Type.fromTypeNameAndSuperType(typeName, superType);
+      }
+    }
+  }
 
-        context.addType(type);
+  if (type !== null) {
+    const typeString = nodeAsString(typeNode);
 
-        typeVerified = true;
+    fileContext.info(`Verified the '${typeString}' type.`);
 
-        context.info(`Verified the '${typeString}' type.`, typeNode);
-      }
-    }
+    fileContext.addType(type);
+
+    typeVerified = true;
   }
 
+  typeVerified ?
+    fileContext.complete(typeNode):
+      fileContext.halt(typeNode);
+
   return typeVerified;
 }
-