occam-verify-cli 0.0.526 → 0.0.529

package/src/verify/statement.js

@@ -2,7 +2,6 @@
 
 import Equality from "../equality";
 import verifyTerm from "../verify/term";
-import equalityCombinator from "../ocmbinator/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/assertion/type";
 
@@ -10,75 +9,82 @@ import { first } from "../utilities/array";
 import { objectType } from "../type";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { STATEMENT_META_TYPE } from "../metaTypes";
-import { MAXIMUM_INDEXES_LENGTH } from "../constants";
 import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
 import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
 
 const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!"),
-      metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!/@meta-type"),
+      metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
       statementNodeQuery = nodeQuery("/metaArgument/statement!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
+      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
 
 export default function verifyStatement(statementNode, assertions, derived, context) {
   let statementVerified = false;
 
-  context.begin(statementNode);
-
   if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
+    const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
 
-    statementVerified = statementVerifiedAsEquality;  //
+    statementVerified = statementVerifiedAgainstCombinators;  ///
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assertions, context);
+    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assertions, derived, context);
 
     statementVerified = statementVerifiedAsTypeAssertion; ///
   }
 
   if (!statementVerified) {
-    const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
 
-    statementVerified = statementVerifiedAgainstCombinators;  ///
+    statementVerified = statementVerifiedAsEquality;  //
   }
 
-  statementVerified ?
-    context.complete(statementNode) :
-      context.halt(statementNode);
-
   return statementVerified;
 }
 
-function verifyStatementAsEquality(statementNode, derived, context) {
-  let statementVerifiedAsEquality = false;
+export function verifyStatementAgainstCombinator(statementNode, combinator, context) {
+  const combinatorStatementNode = combinator.getStatementNode(),
+        node = statementNode,  ///
+        combinatorNode = combinatorStatementNode, ///
+        nodeVerified = verifyNode(node, combinatorNode, context),
+        statementVerifiedAgainstCombinator = nodeVerified;  ///
+
+  return statementVerifiedAgainstCombinator;
+}
 
-  const combinator = equalityCombinator,  ///
-        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
+function verifyStatementAgainstCombinators(statementNode, context) {
+  let statementVerifiedAgainstCombinators = false;
 
-  if (statementVerifiedAgainstCombinator) {
-    statementVerifiedAsEquality = true;
+  let combinators = context.getCombinators();
 
-    if (derived) {
-      const equality = Equality.fromStatementNode(statementNode),
-            proofSteps = context.getProofSteps(),
-            equalities = equalitiesFromProofSteps(proofSteps),
-            equalityEquates = equality.equate(equalities);
+  combinators = [ ///
+    bracketedCombinator,
+    ...combinators
+  ];
 
-      statementVerifiedAsEquality = equalityEquates; ///
+  const combinator = combinators.find((combinator) => {
+    const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
+
+    if (statementVerifiedAgainstCombinator) {
+      return true;
     }
+  }) || null;
+
+  if (combinator !== null) {
+    statementVerifiedAgainstCombinators = true;
   }
 
-  return statementVerifiedAsEquality;
+  return statementVerifiedAgainstCombinators;
 }
 
-function verifyStatementAsTypeAssertion(statementNode, assertions, context) {
+function verifyStatementAsTypeAssertion(statementNode, assertions, derived, context) {
   let statementVerifiedAsTypeAssertion = false;
 
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
   if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, context);
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, derived, context);
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
   }
@@ -86,39 +92,26 @@ function verifyStatementAsTypeAssertion(statementNode, assertions, context) {
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAgainstCombinators(statementNode, context) {
-  let statementVerifiedAgainstCombinators = false;
+function verifyStatementAsEquality(statementNode, derived, context) {
+  let statementVerifiedAsEquality = false;
 
-  let combinators = context.getCombinators();
+  const equality = Equality.fromStatementNode(statementNode, context);
 
-  combinators = [ ///
-    bracketedCombinator,
-    ...combinators
-  ];
+  if (equality !== null) {
+    statementVerifiedAsEquality = true; ///
 
-  const combinator = combinators.find((combinator) => {
-          const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
+    if (derived) {
+      const equalities = context.getEqualities();
 
-          if (statementVerifiedAgainstCombinator) {
-            return true;
-          }
-        }) || null;
+      if (equalities !== null) {
+        const equalityEquates = equality.equate(equalities, context);
 
-  if (combinator !== null) {
-    statementVerifiedAgainstCombinators = true;
+        statementVerifiedAsEquality = equalityEquates; ///
+      }
+    }
   }
 
-  return statementVerifiedAgainstCombinators;
-}
-
-function verifyStatementAgainstCombinator(statementNode, combinator, context) {
-  const combinatorStatementNode = combinator.getStatementNode(),
-        node = statementNode,  ///
-        combinatorNode = combinatorStatementNode, ///
-        nodeVerified = verifyNode(node, combinatorNode, context),
-        statementVerifiedAgainstCombinator = nodeVerified;  ///
-
-  return statementVerifiedAgainstCombinator;
+  return statementVerifiedAsEquality;
 }
 
 function verifyNode(node, combinatorNode, context) {
@@ -231,7 +224,7 @@ function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
   if (termNode === null) {
     const argumentString = context.nodeAsString(argumentNode);
 
-    context.error(`The ${argumentString} argument should be a term, not a type`);
+    context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
   } else {
     const types = [],
           termVerified = verifyTerm(termNode, types, context);
@@ -258,53 +251,30 @@ function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
 function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context) {
   let metaArgumentNodeVerified = false;
 
-  const statementNode = statementNodeQuery(metaArgumentNode);
+  const statementNode = statementNodeQuery(metaArgumentNode),
+        combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
 
   if (statementNode === null) {
     const metaArgumentString = context.nodeAsString(metaArgumentNode);
 
-    context.error(`The '${metaArgumentString}' meta-argument should be a statement, not a meta-type.`);
+    context.error(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
   } else {
-    const derived = false,
-          assertions = null,
-          statementVerified = verifyStatement(statementNode, assertions, derived, context);
-
-    if (statementVerified) {
-      const combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
-
-      if (combinatorMetaTYpeNode !== null) {
-        const terminalNode = combinatorMetaTYpeNode,  ///
-              terminalNodeContent = terminalNode.getContent(),
-              terminalNodeContentStatementMetaType = (terminalNodeContent === STATEMENT_META_TYPE);
-
-        metaArgumentNodeVerified = terminalNodeContentStatementMetaType;  ///
-      }
-
-      if (!metaArgumentNodeVerified) {
-        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
+    if (combinatorMetaTYpeNode === null) {
+      const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
 
-        context.error(`The '${combinatorMetaargumentString}' combinator meta-argument should be the 'Statement' meta-type.`);
+      context.error(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
+    } else {
+      const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
+            content = combinatorMetaTypeTerminalNode.getContent(),
+            contentStatementMetaType = (content === STATEMENT_META_TYPE);
+
+      if (!contentStatementMetaType) {
+        context.error(`Expected the meta-type to be 'Statement' but got '${content}'.`, metaArgumentNode);
+      } else {
+        metaArgumentNodeVerified = true;
       }
     }
   }
 
   return metaArgumentNodeVerified;
 }
-
-function equalitiesFromProofSteps(proofSteps) {
-  const start = -MAXIMUM_INDEXES_LENGTH;  ///
-
-  proofSteps = proofSteps.slice(start); ///
-
-  const equalities = proofSteps.reduce((equalities, proofStep, index) => {
-    const equality = Equality.fromProofStep(proofStep);
-
-    if (equality !== null) {
-      equalities.push(equality);
-    }
-
-    return equalities;
-  }, []);
-
-  return equalities;
-}

package/src/verify/statementAsCombinator.js

@@ -10,11 +10,9 @@ import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleName
 export default function verifyStatementAsCombinator(statementNode, fileContext) {
   let statementVerifiedAsCombinator = false;
 
-  fileContext.begin(statementNode);
-
   const statementString = fileContext.nodeAsString(statementNode);
 
-  fileContext.debug(`Verifying the '${statementString}' combinator....`);
+  fileContext.debug(`Verifying the '${statementString}' combinator....`, statementNode);
 
   const nonTerminalNode = statementNode,  ///
         childNodes = nonTerminalNode.getChildNodes(),
@@ -29,13 +27,9 @@ export default function verifyStatementAsCombinator(statementNode, fileContext)
   }
 
   if (statementVerifiedAsCombinator) {
-    fileContext.info(`Verified the '${statementString}' combinator.`);
+    fileContext.info(`Verified the '${statementString}' combinator.`, statementNode);
   }
 
-  statementVerifiedAsCombinator ?
-    fileContext.complete(statementNode) :
-      fileContext.halt(statementNode);
-
   return statementVerifiedAsCombinator;
 }
 
@@ -131,7 +125,7 @@ function verifyTypeNode(typeNode, fileContext) {
         typePresent = fileContext.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    fileContext.error(`The type '${typeName}' is missing.`);
+    fileContext.error(`The type '${typeName}' not present.`, typeNode);
   } else {
     typeNodeVerified = true;
   }

package/src/verify/supposition.js

@@ -12,11 +12,9 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
 export default function verifySupposition(suppositionNode, suppositions, proofContext) {
   let suppositionVerified;
 
-  proofContext.begin(suppositionNode);
-
   const suppositionString = proofContext.nodeAsString(suppositionNode);
 
-  proofContext.debug(`Verifying the '${suppositionString}' supposition...`);
+  proofContext.debug(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
 
   const derived = false,
         assertions = [],
@@ -39,9 +37,5 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
     suppositionVerified = true;
   }
 
-  suppositionVerified ?
-    proofContext.complete(suppositionNode) :
-      proofContext.halt(suppositionNode);
-
   return suppositionVerified;
 }

package/src/verify/term.js

@@ -13,11 +13,9 @@ const termNodeQuery = nodeQuery("/argument/term!"),
 export default function verifyTerm(termNode, types, context) {
   let termVerified = false;
 
-  context.begin(termNode);
-
   const termString = context.nodeAsString(termNode);
 
-  context.debug(`Verifying the '${termString}' term...`);
+  context.trace(`Verifying the '${termString}' term...`, termNode);
 
   if (!termVerified) {
     const variables = [],
@@ -43,21 +41,15 @@ export default function verifyTerm(termNode, types, context) {
   }
 
   if (termVerified) {
-    context.info(`Verified the '${termString}' term.`);
+    context.debug(`Verified the '${termString}' term.`, termNode);
   }
 
-  termVerified ?
-    context.complete(termNode) :
-      context.halt(termNode);
-
   return termVerified;
 }
 
 export function verifyTermAsVariable(termNode, variables, context) {
   let termVerifiedAsVariable = false;
 
-  context.begin(termNode);
-
   const variableNode = variableNodeQuery(termNode);
 
   if (variableNode !== null) {
@@ -73,18 +65,12 @@ export function verifyTermAsVariable(termNode, variables, context) {
     }
   }
 
-  termVerifiedAsVariable ?
-    context.complete(termNode) :
-      context.halt(termNode);
-
   return termVerifiedAsVariable;
 }
 
 export function verifyTermAgainstConstructors(termNode, types, context) {
   let termVerifiedAgainstConstructors = false;
 
-  context.begin(termNode);
-
   const constructors = context.getConstructors(),
         constructor = constructors.find((constructor) => {
           const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);
@@ -102,10 +88,6 @@ export function verifyTermAgainstConstructors(termNode, types, context) {
     termVerifiedAgainstConstructors = true;
   }
 
-  termVerifiedAgainstConstructors ?
-    context.complete(termNode) :
-      context.halt(termNode);
-
   return termVerifiedAgainstConstructors;
 }
 
@@ -219,7 +201,7 @@ function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
   if (termNode === null) {
     const argumentString = context.nodeAsString(argumentNode);
 
-    context.error(`The ${argumentString} argument should be a term, not a type`);
+    context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
   } else {
     const types = [],
           termVerified = verifyTerm(termNode, types, context);

package/src/verify/termAsConstructor.js

@@ -12,15 +12,11 @@ const typeNodeQuery = nodeQuery("/argument/type");
 export default function verifyTermAsConstructor(termNode, typeNode, fileContext) {
   let termVerifiedAsConstructor = false;
 
-  fileContext.begin(termNode);
-
   let type = null;
 
   const nonTerminalNode = termNode,  ///
         termString = fileContext.nodeAsString(termNode);
 
-  fileContext.debug(`Verifying the '${termString}' constructor...`);
-
   const childNodes = nonTerminalNode.getChildNodes(),
         childNodesVerified = verifyChildNodes(childNodes, fileContext);
 
@@ -35,7 +31,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
       if (type !== null) {
         termVerifiedAsConstructor = true;
       } else {
-        fileContext.error(`The '${termString}' constructor's '${typeName}' type is missing.`);
+        fileContext.error(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);
       }
     }
   }
@@ -47,13 +43,9 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
   }
 
   if (termVerifiedAsConstructor) {
-    fileContext.info(`Verified the '${termString}' constructor.`);
+    fileContext.info(`Verified the '${termString}' constructor.`, termNode);
   }
 
-  termVerifiedAsConstructor ?
-    fileContext.complete(termNode) :
-      fileContext.halt(termNode);
-
   return termVerifiedAsConstructor;
 }
 
@@ -124,7 +116,7 @@ function verifyNonTerminalNode(nonTerminalNode, fileContext) {
         if (type !== null) {
           const termString = fileContext.nodeAsString(termNode);
 
-          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`);
+          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`, termNode);
         } else {
           nonTerminalNodeVerified = true; ///
         }
@@ -154,13 +146,13 @@ function verifyArgumentNode(argumentNode, fileContext) {
   if (typeNode === null) {
     const argumentString = fileContext.nodeAsString(argumentNode);
 
-    fileContext.error(`The ${argumentString} argument should be a type.`);
+    fileContext.error(`The ${argumentString} argument should be a type.`, argumentNode);
   } else {
     const typeName = typeNameFromTypeNode(typeNode),
           typePresent = fileContext.isTypePresentByTypeName(typeName);
 
     if (!typePresent) {
-      fileContext.error(`The type '${typeName}' is missing.`);
+      fileContext.error(`The type '${typeName}' is not present.`, argumentNode);
     } else {
       typeNodeVerified = true;
     }

package/src/verify/theorem.js

@@ -8,7 +8,6 @@ import verifySupposition from "./supposition";
 import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
-import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/theorem/proof!"),
@@ -19,13 +18,11 @@ const proofNodeQuery = nodeQuery("/theorem/proof!"),
 export default function verifyTheorem(theoremNode, fileContext) {
   let theoremVerified = false;
 
-  fileContext.begin(theoremNode);
-
   const labelNodes = labelNodesQuery(theoremNode),
         labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' theorem...`);
+  fileContext.debug(`Verifying the '${labelsString}' theorem...`, theoremNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -64,12 +61,8 @@ export default function verifyTheorem(theoremNode, fileContext) {
   }
 
   if (theoremVerified) {
-    fileContext.info(`Verified the '${labelsString}' theorem.`);
+    fileContext.info(`Verified the '${labelsString}' theorem.`, theoremNode);
   }
 
-  theoremVerified ?
-    fileContext.complete(theoremNode) :
-      fileContext.complete(theoremNode);
-
   return theoremVerified;
 }

package/src/verify/type.js

@@ -7,17 +7,12 @@ import { typeNameFromTypeNode } from "../utilities/query";
 export default function verifyType(typeNode, superTypeNode, fileContext) {
   let typeVerified = false;
 
-  fileContext.begin(typeNode);
-
-  const typeString = fileContext.nodeAsString(typeNode);
-
-  fileContext.debug(`Verifying the '${typeString}' type...`);
-
   const typeName = typeNameFromTypeNode(typeNode),
+        typeString = fileContext.nodeAsString(typeNode),
         typePresent = fileContext.isTypePresentByTypeName(typeName);
 
   if (typePresent) {
-    fileContext.error(`The type '${typeName}' is already present.`);
+    fileContext.error(`The type '${typeName}' is already present.`, typeNode);
   } else {
     let type;
 
@@ -29,7 +24,7 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
       const superType = fileContext.findTypeByTypeName(superTypeName);
 
       if (superType === null) {
-        fileContext.error(`The super-type '${superTypeName}' is missing.`);
+        fileContext.error(`The super-type '${superTypeName}' is not present.`, typeNode);
       } else {
         type = Type.fromTypeNameAndSuperType(typeName, superType);
       }
@@ -43,12 +38,8 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
   }
 
   if (typeVerified) {
-    fileContext.info(`Verified the '${typeString}' type.`);
+    fileContext.info(`Verified the '${typeString}' type.`, typeNode);
   }
 
-  typeVerified ?
-    fileContext.complete(typeNode):
-      fileContext.halt(typeNode);
-
   return typeVerified;
 }

package/src/verify/variable.js

@@ -8,17 +8,12 @@ import { typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities
 export default function verifyVariable(variableNode, typeNode, fileContext) {
   let variableVerified = false;
 
-  fileContext.begin(variableNode);
-
-  const variableString = fileContext.nodeAsString(variableNode);
-
-  fileContext.debug(`Verifying the '${variableString}' variable...`);
-
   const variableName = variableNameFromVariableNode(variableNode),
+        variableString = fileContext.nodeAsString(variableNode),
         variablePresent = fileContext.isVariablePresentByVariableName(variableName);
 
   if (variablePresent) {
-    fileContext.error(`The variable '${variableName}' is already present.`);
+    fileContext.error(`The variable '${variableName}' is already present.`, variableNode);
   } else {
     let variable;
 
@@ -33,7 +28,7 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
       const type = fileContext.findTypeByTypeName(typeName);
 
       if (type === null) {
-        fileContext.error(`The '${variableName}' variable's '${typeName}' type is missing.`);
+        fileContext.error(`The '${variableName}' variable's '${typeName}' type is not present.`, variableNode);
       } else {
         const name = variableName;  ///
 
@@ -49,12 +44,8 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
   }
 
   if (variableVerified) {
-    fileContext.info(`Verified the '${variableString}' variable.`);
+    fileContext.info(`Verified the '${variableString}' variable.`, variableNode);
   }
 
-  variableVerified ?
-    fileContext.complete(variableNode) :
-      fileContext.halt(variableNode);
-
   return variableVerified;
 }

package/bin/callbacks.js

@@ -1,48 +0,0 @@
-"use strict";
-
-const { Callbacks } = require("../lib/index"),  ///
-      { loggingUtilities } = require("necessary");
-
-const { log } = loggingUtilities,
-      { trace } = log,
-      { HALT_MESSAGE, BEGIN_MESSAGE, COMPLETED_MESSAGE } = Callbacks;
-
-function halt(filePath, leastLineIndex, greatestLineIndex) {
-  let message = HALT_MESSAGE;
-
-  message = formatMessage(message, filePath, leastLineIndex, greatestLineIndex); ///
-
-  trace(message);
-}
-
-function begin(filePath, leastLineIndex, greatestLineIndex) {
-  let message = BEGIN_MESSAGE;
-
-  message = formatMessage(message, filePath, leastLineIndex, greatestLineIndex); ///
-
-  trace(message);
-}
-
-function complete(filePath, leastLineIndex, greatestLineIndex) {
-  let message = COMPLETED_MESSAGE;
-
-  message = formatMessage(message, filePath, leastLineIndex, greatestLineIndex); ///
-
-  trace(message);
-}
-
-const callbacks = Callbacks.fromHaltBeginAndComplete(halt, begin, complete);
-
-module.exports = callbacks;
-
-function formatMessage(message, filePath, leastLineIndex, greatestLineIndex) {
-  if (leastLineIndex === greatestLineIndex) {
-    const lineIndex = leastLineIndex; ///
-
-    message = `'${filePath}' : [${lineIndex}] - ${message}`;
-  } else {
-    message = `'${filePath}' : [${leastLineIndex}-${greatestLineIndex}] - ${message}`;
-  }
-
-  return message;
-}