occam-verify-cli 0.0.308 → 0.0.310

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;
-}