occam-verify-cli 0.0.702 → 0.0.705

package/src/verify/metastatement.js

@@ -9,17 +9,14 @@ function verifyMetastatement(metastatementNode, derived, localMetaContext) {
 
   localMetaContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
 
-  const verifyMetastatementFunctions = [
-    verifyStandaloneMetastatement
-  ];
+  const nonTerminalNode = metastatementNode, ///
+        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localMetaContext, () => {
+          const verifiedAhead = true;
 
-  metastatementVerified = verifyMetastatementFunctions.some((verifyMetastatementFunction) => {
-    const metastatementVerified = verifyMetastatementFunction(metastatementNode, derived, localMetaContext);
+          return verifiedAhead;
+        });
 
-    if (metastatementVerified) {
-      return true;
-    }
-  });
+  metastatementVerified = nonTerminalNodeVerified;  ///
 
   if (metastatementVerified) {
     localMetaContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
@@ -33,27 +30,3 @@ Object.assign(metastatementNodeVerifier, {
 });
 
 export default verifyMetastatement;
-
-function verifyStandaloneMetastatement(metastatementNode, derived, localMetaContext) {
-  let standaloneMetastatementVerified;
-
-  const metastatementString = localMetaContext.nodeAsString(metastatementNode);
-
-  localMetaContext.trace(`Verifying the '${metastatementString}' standalone metastatement...`, metastatementNode);
-
-  const nonTerminalNode = metastatementNode, ///
-        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localMetaContext, () => {
-          const verifiedAhead = true;
-
-          return verifiedAhead;
-        });
-
-  standaloneMetastatementVerified = nonTerminalNodeVerified;  ///
-
-  if (standaloneMetastatementVerified) {
-    localMetaContext.debug(`...verified the '${metastatementString}' standalone metastatement.`, metastatementNode);
-  }
-
-  return standaloneMetastatementVerified;
-
-}

package/src/verify/statement.js

@@ -38,6 +38,27 @@ function verifyStatement(statementNode, assignments, derived, context, verifyAhe
   return statementVerified;
 }
 
+export function verifyStandaloneStatement(statementNode, fileContext, verifyAhead) {
+  let standaloneStatementVerified;
+
+  const statementString = fileContext.nodeAsString(statementNode);
+
+  fileContext.trace(`Verifying the '${statementString}' standalone statement...`, statementNode);
+
+  const context = fileContext,  ///
+        derived = false,
+        assignments = [],
+        statementVerified = verifyStatement(statementNode, assignments, derived, context, verifyAhead);
+
+  standaloneStatementVerified = statementVerified;  ///
+
+  if (standaloneStatementVerified) {
+    fileContext.debug(`...verified the '${statementString}' standalone statement.`, statementNode);
+  }
+
+  return standaloneStatementVerified;
+}
+
 Object.assign(statementNodesVerifier, {
   verifyStatement
 });

package/src/verify/term.js

@@ -33,6 +33,26 @@ function verifyTerm(termNode, terms, context, verifyAhead) {
   return termVerified;
 }
 
+export function verifyStandaloneTerm(termNode, fileContext, verifyAhead) {
+  let standaloneTermVerified;
+
+  const termString = fileContext.nodeAsString(termNode);
+
+  fileContext.trace(`Verifying the '${termString}' standalone term...`, termNode);
+
+  const terms = [],
+        context = fileContext,  ///
+        termVerified = verifyTerm(termNode, terms, context, verifyAhead);
+
+  standaloneTermVerified = termVerified;  ///
+
+  if (standaloneTermVerified) {
+    fileContext.debug(`...verified the '${termString}' standalone term.`, termNode);
+  }
+
+  return standaloneTermVerified;
+}
+
 Object.assign(termNodesVerifier, {
   verifyTerm
 });

package/src/verify/type.js

@@ -46,3 +46,29 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
 
   return typeVerified;
 }
+
+export function verifyStandaloneType(typeNode, fileContext, verifyAhead) {
+  let standaloneTypeVerified = false;
+
+  const typeString = fileContext.nodeAsString(typeNode);
+
+  fileContext.trace(`Verifying the '${typeString}' standalone type...`, typeNode);
+
+  const typeName = typeNameFromTypeNode(typeNode),
+        typePresent = fileContext.isTypePresentByTypeName(typeName);
+
+  if (!typePresent) {
+    fileContext.debug(`The type '${typeName}' is not present.`, typeNode);
+  } else {
+    const verifiedAhead = verifyAhead();
+
+    standaloneTypeVerified = verifiedAhead;  ///
+
+  }
+
+  if (standaloneTypeVerified) {
+    fileContext.debug(`...verified the '${typeString}' standalone type.`, typeNode);
+  }
+
+  return standaloneTypeVerified;
+}