occam-verify-cli 0.0.678 → 0.0.680

package/src/verify/metastatement.js

@@ -1,80 +1,59 @@
 "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) {
+  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);
 
-        break;
-      }
+    if (metastatementVerified) {
+      return true;
     }
+  });
 
-    return nonTerminalNodeVerified;
+  if (metastatementVerified) {
+    metaproofContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
   }
 
-  verifyMetavariableNode(metavariableNode, metaproofContext) {
-    let metavariableNodeVerified = false;
+  return metastatementVerified;
+}
 
-    const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-          metavariablePresent = metaproofContext.isMetavariablePresentByMetavariableName(metavariableName);
+Object.assign(verifyMetastatement, {
+  metastatementNodeVerifier
+});
 
-    if (!metavariablePresent) {
-      const metavariableString = metaproofContext.nodeAsString(metavariableNode);
+export default verifyMetastatement;
 
-      metaproofContext.error(`The '${metavariableString}' metavariable is not present.`, metavariableNode);
-    } else {
-      metavariableNodeVerified = true;
-    }
+function verifyStandaloneMetastatement(metastatementNode, derived, metaproofContext) {
+  let standaloneMetastatementVerified;
 
-    return metavariableNodeVerified;
-  }
-}
-
-export const metastatementVerifier = new MetastatementVerifier();
+  const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-export default function verifyMetastatement(metastatementNode, derived, metaproofContext) {
-  let metastatementVerified = false;
+  metaproofContext.trace(`Verifying the '${metastatementString}' standalone metastatement...`, metastatementNode);
 
-  const metastatementString = metaproofContext.nodeAsString(metastatementNode);
+  const nonTerminalNode = metastatementNode, ///
+        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, metaproofContext, () => {
+          const verifiedAhead = true;
 
-  metaproofContext.debug(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
+          return verifiedAhead;
+        });
 
-  if (!metastatementVerified) {
-    const nonTerminalNodeA = metastatementNode, ///
-          nonTerminalNodeB = metastatementNode, ///
-          nonTerminalNodeVerified = metastatementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, metaproofContext);
+  standaloneMetastatementVerified = nonTerminalNodeVerified;  ///
 
-    metastatementVerified = nonTerminalNodeVerified;  ///
+  if (standaloneMetastatementVerified) {
+    metaproofContext.debug(`...verified the '${metastatementString}' standalone metastatement.`, metastatementNode);
   }
 
-  if (metastatementVerified) {
-    metaproofContext.debug(`Verified the '${metastatementString}' metastatement.`, metastatementNode);
-  }
+  return standaloneMetastatementVerified;
 
-  return metastatementVerified;
-}
+}

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.debug(`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;