occam-verify-cli 0.0.677 → 0.0.679

package/src/verify/declaration/variable.js

@@ -3,6 +3,7 @@
 import verifyVariable from "../../verify/variable";
 
 import { nodeQuery } from "../../utilities/query";
+import { EMPTY_STRING } from "../../constants";
 
 const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable");
@@ -12,9 +13,22 @@ export default function verifyVariableDeclaration(variableDeclarationNode, fileC
 
   const typeNode = typeNodeQuery(variableDeclarationNode),
         variableNode = variableNodeQuery(variableDeclarationNode),
-        variableVVerified = verifyVariable(variableNode, typeNode, fileContext);
+        typeString = fileContext.nodeAsString(typeNode),
+        variableString = fileContext.nodeAsString(variableNode);
+
+  (typeString === EMPTY_STRING) ?
+    fileContext.trace(`Verifying the '${variableString}' variable declaration...`, variableDeclarationNode) :
+      fileContext.trace(`Verifying the '${variableString}:${typeString}' variable declaration...`, variableDeclarationNode);
+
+  const variableVVerified = verifyVariable(variableNode, typeNode, fileContext);
 
   variableDeclarationVerified = variableVVerified;  ///
 
+  if (variableDeclarationVerified) {
+    (typeString === EMPTY_STRING) ?
+      fileContext.debug(`...verified the '${variableString}' variable declaration.`, variableDeclarationNode) :
+        fileContext.debug(`...verified the '${variableString}:${typeString}' variable declaration.`, variableDeclarationNode);
+  }
+
   return variableDeclarationVerified;
 }

package/src/verify/file.js

@@ -23,7 +23,7 @@ export default function verifyFile(filePath, releaseContext) {
           errorNodesLength = errorNodes.length;
 
     if (errorNodesLength > 0) {
-      releaseContext.error(`The '${filePath}' file cannot be verified because it contains errors.`);
+      releaseContext.info(`The '${filePath}' file cannot be verified because it contains errors.`);
     } else {
       const topLevelDeclarationNodes = topLevelDeclarationNodesQuery(node),
             topLevelDeclarationsVerified = topLevelDeclarationNodes.every((topLevelDeclarationNode) => {
@@ -43,7 +43,7 @@ export default function verifyFile(filePath, releaseContext) {
   }
 
   if (fileVerified) {
-    releaseContext.info(`Verified the '${filePath}' file.`);
+    releaseContext.info(`...verified the '${filePath}' file.`);
   }
 
   return fileVerified;

package/src/verify/label.js

@@ -8,12 +8,16 @@ export default function verifyLabel(labelNode, labels, fileContext) {
   let labelVerified = false;
 
   const labelName = labelNameFromLabelNode(labelNode),
-        labelPresent = fileContext.isLabelPresentByLabelName(labelName);
+        labelString = fileContext.nodeAsString(labelNode);
+
+  fileContext.trace(`Verifying the '${labelString}' label...`, labelNode);
+
+  const labelPresent = fileContext.isLabelPresentByLabelName(labelName);
 
   if (labelPresent) {
     const labelString = fileContext.nodeAsString(labelNode);
 
-    fileContext.error(`The '${labelString}' label is already present.`, labelNode);
+    fileContext.info(`The '${labelString}' label is already present.`, labelNode);
   } else {
     const label = Label.fromLabelNode(labelNode);
 
@@ -22,5 +26,9 @@ export default function verifyLabel(labelNode, labels, fileContext) {
     labelVerified = true;
   }
 
+  if (labelVerified) {
+    fileContext.debug(`...verified the '${labelString}' label.`, labelNode);
+  }
+
   return labelVerified;
 }

package/src/verify/lemma.js

@@ -24,8 +24,8 @@ export default function verifyLemma(lemmaNode, fileContext) {
         proofContext = ProofContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?
-    fileContext.debug(`Verifying a lemma...`, lemmaNode) :
-      fileContext.debug(`Verifying the '${labelsString}' lemma...`, lemmaNode);
+    fileContext.trace(`Verifying a lemma...`, lemmaNode) :
+      fileContext.trace(`Verifying the '${labelsString}' lemma...`, lemmaNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -65,8 +65,8 @@ export default function verifyLemma(lemmaNode, fileContext) {
 
   if (lemmaVerified) {
     (labelsString === EMPTY_STRING) ?
-      fileContext.info(`Verified the lemma.`, lemmaNode) :
-        fileContext.info(`Verified the '${labelsString}' lemma.`, lemmaNode);
+      fileContext.debug(`...verified the lemma.`, lemmaNode) :
+        fileContext.debug(`...verified the '${labelsString}' lemma.`, lemmaNode);
   }
 
   return lemmaVerified;

package/src/verify/metastatement/qualified.js

@@ -14,7 +14,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
     const metastatementString = metaproofContext.nodeAsString(metastatementNode),
           metastatementMetaproofContext = metaproofContext; ///
 
-    metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
+    metaproofContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedMetastatementNode),
           referenceName = referenceNameFromReferenceNode(referenceNode),
@@ -25,12 +25,10 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
       qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
     }
-  }
-
-  if (qualifiedMetastatementVerified) {
-    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.info(`Verified the '${metastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+    if (qualifiedMetastatementVerified) {
+      metaproofContext.debug(`...verified the '${metastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+    }
   }
 
   return qualifiedMetastatementVerified;

package/src/verify/metastatement/unqualified.js

@@ -14,7 +14,7 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
   if (metastatementNode !== null) {
     const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
+    metaproofContext.trace(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
 
     if (derived) {
       const metastatementMatches = metaproofContext.matchMetastatement(metastatementNode);
@@ -23,16 +23,18 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
 
     if (!unqualifiedMetastatementVerified) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, derived, metaproofContext);
+      const metastatementVerified = verifyMetastatement(metastatementNode, derived, metaproofContext, () => {
+        const verifiedAhead = true;
+
+        return verifiedAhead;
+      });
 
       unqualifiedMetastatementVerified = metastatementVerified; ///
     }
-  }
 
-  if (unqualifiedMetastatementVerified) {
-    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
-
-    metaproofContext.info(`Verified the '${metastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
+    if (unqualifiedMetastatementVerified) {
+      metaproofContext.debug(`...verified the '${metastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
+    }
   }
 
   return unqualifiedMetastatementVerified;

package/src/verify/metastatement.js

@@ -1,80 +1,55 @@
 "use strict";
 
-import Verifier from "../verifier";
+import metastatementNodeVerifier from "../verifier/node/metastatement";
 
-import { METAVARIABLE_RULE_NAME } from "../ruleNames";
-import { metavariableNameFromMetavariableNode } from "../utilities/query";
+function verifyMetastatement(metastatementNode, derived, metaproofContext, verifyAhead) {
+  let metastatementVerified;
 
-class MetastatementVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, metaproofContext) {
-    let nonTerminalNodeVerified = false;
-
-    const nonTerminalNode = nonTerminalNodeA, ///
-          ruleName = nonTerminalNode.getRuleName(); ///
-
-    switch (ruleName) {
-      case METAVARIABLE_RULE_NAME: {
-        const metavariableNode = nonTerminalNode, ///
-              metavariableNodeVerified = this.verifyMetavariableNode(metavariableNode, metaproofContext);
-
-        nonTerminalNodeVerified = metavariableNodeVerified; ///
+  const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-        break;
-      }
+  metaproofContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
 
-      default: {
-        const childNodes = nonTerminalNode.getChildNodes(),
-              nodesA = childNodes, ///
-              nodesB = childNodes, ///
-              nodesVerified = this.verifyNodes(nodesA, nodesB, metaproofContext);
+  const verifyMetastatementFunctions = [
+    verifyStandaloneMetastatement
+  ];
 
-        nonTerminalNodeVerified = nodesVerified; ///
+  metastatementVerified = verifyMetastatementFunctions.some((verifyStatementFunction) => {
+    const metastatementVerified = verifyStatementFunction(metastatementNode, derived, metaproofContext, verifyAhead);
 
-        break;
-      }
+    if (metastatementVerified) {
+      return true;
     }
+  });
 
-    return nonTerminalNodeVerified;
+  if (metastatementVerified) {
+    metaproofContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
   }
 
-  verifyMetavariableNode(metavariableNode, metaproofContext) {
-    let metavariableNodeVerified = false;
-
-    const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-          metavariablePresent = metaproofContext.isMetavariablePresentByMetavariableName(metavariableName);
-
-    if (!metavariablePresent) {
-      const metavariableString = metaproofContext.nodeAsString(metavariableNode);
-
-      metaproofContext.error(`The '${metavariableString}' metavariable is not present.`, metavariableNode);
-    } else {
-      metavariableNodeVerified = true;
-    }
-
-    return metavariableNodeVerified;
-  }
+  return metastatementVerified;
 }
 
-export const metastatementVerifier = new MetastatementVerifier();
+Object.assign(verifyMetastatement, {
+  metastatementNodeVerifier
+});
 
-export default function verifyMetastatement(metastatementNode, derived, metaproofContext) {
-  let metastatementVerified = false;
+export default verifyMetastatement;
+
+function verifyStandaloneMetastatement(metastatementNode, derived, metaproofContext, verifyAhead) {
+  let standaloneMetastatementVerified;
 
   const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-  metaproofContext.debug(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
+  metaproofContext.trace(`Verifying the '${metastatementString}' standalone metastatement...`, metastatementNode);
 
-  if (!metastatementVerified) {
-    const nonTerminalNodeA = metastatementNode, ///
-          nonTerminalNodeB = metastatementNode, ///
-          nonTerminalNodeVerified = metastatementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, metaproofContext);
+  const nonTerminalNode = metastatementNode, ///
+        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, metaproofContext);
 
-    metastatementVerified = nonTerminalNodeVerified;  ///
-  }
+  standaloneMetastatementVerified = nonTerminalNodeVerified;  ///
 
-  if (metastatementVerified) {
-    metaproofContext.debug(`Verified the '${metastatementString}' metastatement.`, metastatementNode);
+  if (standaloneMetastatementVerified) {
+    metaproofContext.debug(`...verified the '${metastatementString}' standalone metastatement.`, metastatementNode);
   }
 
-  return metastatementVerified;
-}
+  return standaloneMetastatementVerified;
+
+}

package/src/verify/metavariable.js

@@ -7,12 +7,15 @@ import { metaTypeNameFromMetaTypeNode, metavariableNameFromMetavariableNode } fr
 export default function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
   let metavariableVerified = false;
 
+  const metavariableString = fileContext.nodeAsString(metavariableNode);
+
+  fileContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
   const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariableString = fileContext.nodeAsString(metavariableNode),
         metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
 
   if (metavariablePresent) {
-    fileContext.error(`The metavariable '${metavariableName}' is already present.`, metavariableNode);
+    fileContext.info(`The metavariable '${metavariableName}' is already present.`, metavariableNode);
   } else {
     const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
           metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName),
@@ -25,7 +28,7 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
   }
 
   if (metavariableVerified) {
-    fileContext.info(`Verified the '${metavariableString}' metavariable.`, metavariableNode);
+    fileContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
   }
 
   return metavariableVerified;

package/src/verify/premise.js

@@ -14,7 +14,7 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
 
   const premiseString = metaproofContext.nodeAsString(premiseNode);
 
-  metaproofContext.debug(`Verifying the '${premiseString}' premise...`, premiseNode);
+  metaproofContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
 
   const derived = false,
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode),
@@ -33,7 +33,7 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
   }
 
   if (premiseVerified) {
-    metaproofContext.info(`Verified the '${premiseString}' premise.`, premiseNode);
+    metaproofContext.debug(`...verified the '${premiseString}' premise.`, premiseNode);
   }
 
   return premiseVerified;

package/src/verify/release.js

@@ -16,7 +16,7 @@ export default function verifyRelease(releaseName, releaseContextMap) {
       if (verified) {
         releaseVerified = true;
       } else {
-        releaseContext.debug(`Verifying '${releaseName}'...`);
+        releaseContext.info(`Verifying the '${releaseName}' project...`);
 
         const releaseFilesVerified = verifyReleaseFiles(releaseContext);
 
@@ -29,7 +29,7 @@ export default function verifyRelease(releaseName, releaseContextMap) {
         }
 
         if (releaseVerified) {
-          releaseContext.info(`Verified  '${releaseName}'.`);
+          releaseContext.info(`...verified the '${releaseName}' project.`);
         }
       }
     }

package/src/verify/rule.js

@@ -22,7 +22,7 @@ export default function verifyRule(ruleNode, fileContext) {
         labelsString = fileContext.nodesAsString(labelNodes),
         metaProofContext = MetaproofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' rule...`, ruleNode);
+  fileContext.trace(`Verifying the '${labelsString}' rule...`, ruleNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -66,7 +66,7 @@ export default function verifyRule(ruleNode, fileContext) {
   }
 
   if (ruleVerified) {
-    fileContext.info(`Verified the '${labelsString}' rule.`, ruleNode);
+    fileContext.debug(`...verified the '${labelsString}' rule.`, ruleNode);
   }
 
   return ruleVerified;

package/src/verify/statement/qualified.js

@@ -14,7 +14,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
     const statementString = proofContext.nodeAsString(statementNode),
           statementProofContext = proofContext; ///
 
-    proofContext.debug(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
+    proofContext.trace(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedStatementNode),
           referenceName = referenceNameFromReferenceNode(referenceNode);
@@ -68,12 +68,10 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
         qualifiedStatementVerified = conjectureMatchesStatement; ///
       }
     }
-  }
-
-  if (qualifiedStatementVerified) {
-    const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.info(`Verified the '${statementString}' qualified statement.`, qualifiedStatementNode);
+    if (qualifiedStatementVerified) {
+      proofContext.debug(`...verified the '${statementString}' qualified statement.`, qualifiedStatementNode);
+    }
   }
 
   return qualifiedStatementVerified;

package/src/verify/statement/unqualified.js

@@ -14,7 +14,7 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
   if (statementNode !== null) {
     const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the '${statementString}' unqualified statement...`, unqualifiedStatementNode);
+    proofContext.trace(`Verifying the '${statementString}' unqualified statement...`, unqualifiedStatementNode);
 
     if (derived) {
       const statementMatches = proofContext.matchStatement(statementNode);
@@ -24,16 +24,18 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
 
     if (!unqualifiedStatementVerified) {
       const context = proofContext, ///
-            statementVerified = verifyStatement(statementNode, assignments, derived, context);
+            statementVerified = verifyStatement(statementNode, assignments, derived, context, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
 
       unqualifiedStatementVerified = statementVerified;  ///
     }
-  }
 
-  if (unqualifiedStatementVerified) {
-    const statementString = proofContext.nodeAsString(statementNode);
-
-    proofContext.info(`Verified the '${statementString}' unqualified statement.`, unqualifiedStatementNode);
+    if (unqualifiedStatementVerified) {
+      proofContext.debug(`...verified the '${statementString}' unqualified statement.`, unqualifiedStatementNode);
+    }
   }
 
   return unqualifiedStatementVerified;