occam-verify-cli 0.0.309 → 0.0.311

package/src/verify/termAsConstructor.js

@@ -15,7 +15,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, context) {
 
   const termString = nodeAsString(termNode);
 
-  context.debug(`Verifying the '${termString}' term as a constructor...`);
+  context.debug(`Verifying the '${termString}' term as a constructor...`, termNode);
 
   const nonTerminalNode = termNode,  ///
         childNodes = nonTerminalNode.getChildNodes(),
@@ -36,7 +36,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, context) {
       } else {
         const termString = nodeAsString(termNode);
 
-        context.error(`The '${termString}' constructor's '${typeName}' type is missing.`);
+        context.error(`The '${termString}' constructor's '${typeName}' type is missing.`, termNode);
       }
     }
   }
@@ -48,7 +48,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, context) {
 
     const termString = nodeAsString(termNode);
 
-    context.info(`Verified the '${termString}' constructor.`);
+    context.info(`Verified the '${termString}' constructor.`, termNode);
   }
 
   return termVerifiedAsConstructor;
@@ -121,7 +121,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.`);
+          context.error(`The type of the constructor's compound '${termString}' term node is not null.`, termNode);
         } else {
           nonTerminalNodeVerified = true; ///
         }
@@ -151,13 +151,13 @@ function verifyArgumentNode(argumentNode, context) {
   if (typeNode === null) {
     const argumentString = nodeAsString(argumentNode);
 
-    context.error(`The ${argumentString} argument should be a type.`);
+    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.`);
+      context.error(`The type '${typeName}' is missing.`, typeNode);
     } else {
       typeNodeVerified = true;
     }

package/src/verify/termAsVariable.js

@@ -14,7 +14,7 @@ export default function verifyTermAsVariable(termNode, types, names, values, con
           variablePresent = context.isVariablePresentByVariableName(variableName);
 
     if (!variablePresent) {
-      context.error(`The ${variableName} variable is not present.`)
+      context.error(`The ${variableName} variable is not present.`, variableNode)
     } else {
       const variable = context.findVariableByVariableName(variableName),
             type = variable.getType(),

package/src/verify/type.js

@@ -11,7 +11,7 @@ export default function verifyType(typeNode, superTypeNode, context) {
         typePresent = context.isTypePresentByTypeName(typeName);
 
   if (typePresent) {
-    context.error(`The type '${typeName}' is already present.`);
+    context.error(`The type '${typeName}' is already present.`, typeNode);
   } else {
     const superTypeName = typeNameFromTypeNode(superTypeNode);
 
@@ -23,12 +23,12 @@ export default function verifyType(typeNode, superTypeNode, context) {
 
       typeVerified = true;
 
-      context.info(`Verified the '${typeString}' type.`);
+      context.info(`Verified the '${typeString}' type.`, typeNode);
     } else {
       const superType = context.findTypeByTypeName(superTypeName);
 
       if (superType === null) {
-        context.error(`The super-type '${superTypeName}' is missing.`);
+        context.error(`The super-type '${superTypeName}' is missing.`, typeNode);
       } else {
         const type = Type.fromTypeNameAndSuperType(typeName, superType),
               typeString = type.asString();
@@ -37,7 +37,7 @@ export default function verifyType(typeNode, superTypeNode, context) {
 
         typeVerified = true;
 
-        context.info(`Verified the '${typeString}' type.`);
+        context.info(`Verified the '${typeString}' type.`, typeNode);
       }
     }
   }

package/src/verify/variable.js

@@ -11,7 +11,7 @@ export default function verifyVariable(variableNode, typeNode, context) {
         variablePresent = context.isVariablePresentByVariableName(variableName);
 
   if (variablePresent) {
-    context.error(`The variable '${variableName}' is already present.`);
+    context.error(`The variable '${variableName}' is already present.`, variableNode);
   } else {
     let variable = null;
 
@@ -26,7 +26,7 @@ export default function verifyVariable(variableNode, typeNode, context) {
       const type = context.findTypeByTypeName(typeName);
 
       if (type === null) {
-        context.error(`The '${variableName}' variable's '${typeName}' type is missing.`);
+        context.error(`The '${variableName}' variable's '${typeName}' type is missing.`, variableNode);
       } else {
         const name = variableName;  ///
 
@@ -41,7 +41,7 @@ export default function verifyVariable(variableNode, typeNode, context) {
 
       variableVerified = true;
 
-      context.info(`Verified the '${variableString}' variable.`);
+      context.info(`Verified the '${variableString}' variable.`, variableNode);
     }
   }
 

package/bin/loadReleaseContexts.js

@@ -1,68 +0,0 @@
-"use strict";
-
-const { ReleaseContext } = require("../lib/index"),
-      { fileSystemUtilities } = require("occam-file-system"),
-      { arrayUtilities, loggingUtilities } = require("necessary");
-
-const { PERIOD } = require("./constants");
-
-const { log } = loggingUtilities,
-      { first } = arrayUtilities,
-      { loadRelease } = fileSystemUtilities;
-
-function loadReleaseContexts(releaseName, releaseContextMap = {}, dependentReleaseNames = []) {
-  const cyclicDependencyExists = checkCyclicDependencyExists(releaseName, dependentReleaseNames);
-
-  if (!cyclicDependencyExists) {
-    const releaseContext = releaseContextMap[releaseName] || null;
-
-    if (releaseContext === null) {
-      const topmostDirectoryName = releaseName,  ///
-            projectsDirectoryPath = PERIOD,
-            release = loadRelease(topmostDirectoryName, projectsDirectoryPath);
-
-      if (release === null) {
-        log.error(`The '${releaseName}' package cannot be loaded.`);
-      } else {
-        const releaseContext = ReleaseContext.fromLogAndRelease(log, release);
-
-        releaseContextMap[releaseName] = releaseContext;
-
-        const dependencies = releaseContext.getDependencies(),
-              dependencyReleaseNames = dependencies.mapDependency((dependency) => {
-                const dependencyName = dependency.getName(),
-                      dependencyReleaseName = dependencyName;  ///
-
-                return dependencyReleaseName;
-              });
-
-        dependentReleaseNames = [ ...dependentReleaseNames, releaseName ];  ///
-
-        dependencyReleaseNames.forEach((dependencyReleaseName) => {
-          const releaseName = dependencyReleaseName;  ///
-
-          loadReleaseContexts(releaseName, releaseContextMap, dependentReleaseNames);
-        });
-      }
-    }
-  }
-
-  return releaseContextMap;
-}
-
-module.exports = loadReleaseContexts;
-
-function checkCyclicDependencyExists(releaseName, dependentReleaseNames) {
-  const dependentReleaseNamesIncludesReleaseName = dependentReleaseNames.includes(releaseName),
-        cyclicDependencyExists = dependentReleaseNamesIncludesReleaseName;  ///
-
-  if (cyclicDependencyExists) {
-    const firstDependentReleaseName = first(dependentReleaseNames),
-          releaseNames = dependentReleaseNames.concat(firstDependentReleaseName),
-          releaseNamesString = releaseNames.join(`' -> '`);
-
-    log.error(`There is a cyclic dependency: '${releaseNamesString}'.`);
-  }
-
-  return cyclicDependencyExists;
-}