occam-verify-cli 0.0.316 → 0.0.318

package/bin/callbacks.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const { Callbacks } = require("../lib/index");
+
+const { HALT_MESSAGE, BEGIN_MESSAGE, COMPLETED_MESSAGE } = require("./messages");
+
+function halt(filePath, leastLineIndex, greatestLineIndex) { message(HALT_MESSAGE, filePath, leastLineIndex, greatestLineIndex); }  ///
+
+function begin(filePath, leastLineIndex, greatestLineIndex) { message(BEGIN_MESSAGE, filePath, leastLineIndex, greatestLineIndex); }  ///
+
+function complete(filePath, leastLineIndex, greatestLineIndex) { message(COMPLETED_MESSAGE, filePath, leastLineIndex, greatestLineIndex); }  ///
+
+const callbacks = Callbacks.fromHaltBeginAndComplete(halt, begin, complete);
+
+module.exports = callbacks;
+
+function message(message, filePath, leastLineIndex, greatestLineIndex) {
+  if (leastLineIndex === greatestLineIndex) {
+    const lineIndex = leastLineIndex; ///
+
+    message = `'${filePath}' : [${lineIndex}] - ${message}`;
+  } else {
+    message = `'${filePath}' : [${leastLineIndex}-${greatestLineIndex}] - ${message}`;
+  }
+
+  console.log(message);
+}

package/bin/main.js

@@ -10,11 +10,9 @@ const { first } = arrayUtilities;
 function main(commands, options) {
   const firstCommand = first(commands),
         { name = firstCommand } = options, ///
-        releaseContextMap = {};
-
-  createReleaseContext(name, releaseContextMap);
-
-  const releaseContext = releaseContextMap[name];
+        releaseContextMap = {},
+        shortenedVersion = null,
+        releaseContext = createReleaseContext(name, shortenedVersion, releaseContextMap);
 
   if (releaseContext !== null) {
     verifyRelease(name, releaseContextMap);

package/bin/messages.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const HALT_MESSAGE = "Halted verification.",
+      BEGIN_MESSAGE = "Begun verification...",
+      COMPLETED_MESSAGE = "...completed verification.";
+
+module.exports = {
+  HALT_MESSAGE,
+  BEGIN_MESSAGE,
+  COMPLETED_MESSAGE
+};

package/bin/utilities/logging.js

@@ -4,16 +4,8 @@ const { levels } = require("necessary");
 
 const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL, FATAL_LEVEL } = levels;
 
-function log(level, message, filePath = null, leastLineIndex = null, greatestLineIndex = null) {
-  if (filePath === null) {
-    console.log(`(${level}) ${message}`)
-  } else if (leastLineIndex === greatestLineIndex) {
-    const lineIndex = leastLineIndex; ///
-
-    console.log(`(${level}) '${filePath}' : [${lineIndex}] - ${message}`);
-  } else  {
-    console.log(`(${level}) '${filePath}' : [${leastLineIndex}-${greatestLineIndex}] - ${message}`);
-  }
+function log(level, message) {
+  console.log(`(${level}) ${message}`)
 }
 
 function trace(message) { log(TRACE_LEVEL, message); }

package/bin/utilities/release.js

@@ -4,81 +4,106 @@ const { arrayUtilities } = require("necessary"),
       { ReleaseContext } = require("../../lib/index"),
       { fileSystemUtilities } = require("occam-file-system");
 
+const callbacks = require("../callbacks");
+
 const { log } = require("../utilities/logging"),
       { PERIOD } = require("../constants");
 
 const { first } = arrayUtilities,
       { loadRelease } = fileSystemUtilities;
 
-function createReleaseContext(name, releaseContextMap, dependentNames = []) {
+function createReleaseContext(name, shortenedVersion, releaseContextMap, dependentNames = []) {
   let releaseContext = releaseContextMap[name] || null;
 
+  if (releaseContext === null) {
+    const release = createRelease(name);
+
+    if (release !== null) {
+      releaseContext = ReleaseContext.fromLogReleaseAndCallbacks(log, release, callbacks);
+    }
+  }
+
   if (releaseContext !== null) {
-    return;
+    const releaseMatchesShortedVersion = checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion),
+          dependencyReleaseContextsCreated = createDependencyReleaseContexts(releaseContext, releaseContextMap, dependentNames);
+
+    if (!releaseMatchesShortedVersion || !dependencyReleaseContextsCreated) {
+      releaseContext = null;
+    }
   }
 
+  releaseContextMap[name] = releaseContext;
+
+  return releaseContext;
+}
+
+module.exports = {
+  createReleaseContext
+};
+
+function createRelease(name) {
   const topmostDirectoryName = name, ///
-        projectsDirectoryPath = PERIOD,
-        release = loadRelease(topmostDirectoryName, projectsDirectoryPath);
+        projectsDirectoryPath = PERIOD;
+
+  let release = loadRelease(topmostDirectoryName, projectsDirectoryPath);
 
   if (release === null) {
     log.error(`The '${name}' package cannot be loaded.`);
-  } else {
-    const releaseContext = ReleaseContext.fromLogAndRelease(log, release);
+  }
 
-    createDependencyReleaseContexts(releaseContext, releaseContextMap, dependentNames);
+  return release;
+}
+
+function checkCyclicDependencyExists(name, dependentNames, releaseContext) {
+  const dependentNamesIncludesName = dependentNames.includes(name),
+        cyclicDependencyExists = dependentNamesIncludesName;  ///
+
+  if (cyclicDependencyExists) {
+    const firstDependentName = first(dependentNames),
+          dependencyNames = dependentNames.concat(firstDependentName),
+          dependencyNamesString = dependencyNames.join(`' -> '`);
 
-    releaseContextMap[name] = releaseContext;
+    releaseContext.error(`There is a cyclic dependency: '${dependencyNamesString}'.`);
   }
+
+  return cyclicDependencyExists;
 }
 
 function createDependencyReleaseContexts(releaseContext, releaseContextMap, dependentNames = []) {
   const name = releaseContext.getName(),
-        version = releaseContext.getVersion(),
-        dependencies = releaseContext.getDependencies(),
-        dependencyNames = dependencies.reduceDependency((dependencyNames, dependency) => {
-          const dependencyName = dependency.getName(),
-                dependencyMatchesVersion = dependency.matchVersion(version);
-
-          if (dependencyMatchesVersion) {
-            dependencyNames.push(dependencyName);
-          } else {
-            releaseContext.error(`The '${dependencyName}' dependency's  does to mat.`)
-          }
-
-          return dependencyNames;
-        }, []);
+        dependencies = releaseContext.getDependencies();
 
   dependentNames = [ ...dependentNames, name ];  ///
 
-  dependencyNames.forEach((dependencyName) => {
-    const cyclicDependencyExists = checkCyclicDependencyExists(dependencyName, dependentNames, releaseContext);
-
-    if (cyclicDependencyExists) {
-      return;
-    }
+  const dependencyReleaseContextsCreated = dependencies.everyDependency((dependency) => {
+    const name = dependency.getName(),
+          shortenedVersion = dependency.getShortedVersion(),
+          cyclicDependencyExists = checkCyclicDependencyExists(name, dependentNames, releaseContext);
 
-    const name = dependencyName; ///
+    if (!cyclicDependencyExists) {
+      const releaseContext = createReleaseContext(name, shortenedVersion, releaseContextMap, dependentNames);
 
-    createReleaseContext(name, releaseContextMap, dependentNames);
+      if (releaseContext !== null) {
+        return true;
+      }
+    }
   });
-}
 
-module.exports = {
-  createReleaseContext
-};
+  return dependencyReleaseContextsCreated;
+}
 
-function checkCyclicDependencyExists(dependencyName, dependentNames, releaseContext) {
-  const dependentNamesIncludesDependencyName = dependentNames.includes(dependencyName),
-        cyclicDependencyExists = dependentNamesIncludesDependencyName;  ///
+function checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion) {
+  const release = releaseContext.getRelease(),
+        releaseMatchesShortedVersion = release.matchShortenedVersion(shortenedVersion);
 
-  if (cyclicDependencyExists) {
-    const firstDependentName = first(dependentNames),
-          dependencyNames = dependentNames.concat(firstDependentName),
-          dependencyNamesString = dependencyNames.join(`' -> '`);
+  if (!releaseMatchesShortedVersion) {
+    const name = releaseContext.getName(),
+          version = releaseContext.getVersion(),
+          versionString = version.toString(),
+          shortenedVersionString = shortenedVersion.toString();
 
-    releaseContext.error(`There is a cyclic dependency: '${dependencyNamesString}'.`);
+    releaseContext.error(`The '${name}' package's version of ${versionString} does not match the dependency's shortened version of ${shortenedVersionString}.`);
   }
 
-  return cyclicDependencyExists;
+  return releaseMatchesShortedVersion;
 }

package/lib/callbacks.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Callbacks;
+    }
+});
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+var Callbacks = /*#__PURE__*/ function() {
+    function Callbacks(halt, begin, complete) {
+        _classCallCheck(this, Callbacks);
+        this.halt = halt;
+        this.begin = begin;
+        this.complete = complete;
+    }
+    _createClass(Callbacks, [
+        {
+            key: "getHalt",
+            value: function getHalt() {
+                return this.halt;
+            }
+        },
+        {
+            key: "getBegin",
+            value: function getBegin() {
+                return this.begin;
+            }
+        },
+        {
+            key: "getComplete",
+            value: function getComplete() {
+                return this.complete;
+            }
+        }
+    ], [
+        {
+            key: "fromHaltBeginAndComplete",
+            value: function fromHaltBeginAndComplete(halt, begin, complete) {
+                var callbacks = new Callbacks(halt, begin, complete);
+                return callbacks;
+            }
+        }
+    ]);
+    return Callbacks;
+}();
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jYWxsYmFja3MuanMiLCI8PGpzeC1jb25maWctcHJhZ21hLmpzPj4iXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIENhbGxiYWNrcyB7XG4gIGNvbnN0cnVjdG9yKGhhbHQsIGJlZ2luLCBjb21wbGV0ZSkge1xuICAgIHRoaXMuaGFsdCA9IGhhbHQ7XG4gICAgdGhpcy5iZWdpbiA9IGJlZ2luO1xuICAgIHRoaXMuY29tcGxldGUgPSBjb21wbGV0ZTtcbiAgfVxuXG4gIGdldEhhbHQoKSB7XG4gICAgcmV0dXJuIHRoaXMuaGFsdDtcbiAgfVxuXG4gIGdldEJlZ2luKCkge1xuICAgIHJldHVybiB0aGlzLmJlZ2luO1xuICB9XG5cbiAgZ2V0Q29tcGxldGUoKSB7XG4gICAgcmV0dXJuIHRoaXMuY29tcGxldGU7XG4gIH1cblxuICBzdGF0aWMgZnJvbUhhbHRCZWdpbkFuZENvbXBsZXRlKGhhbHQsIGJlZ2luLCBjb21wbGV0ZSkge1xuICAgIGNvbnN0IGNhbGxiYWNrcyA9IG5ldyBDYWxsYmFja3MoaGFsdCwgYmVnaW4sIGNvbXBsZXRlKTtcblxuICAgIHJldHVybiBjYWxsYmFja3M7XG4gIH1cbn1cbiIsIlJlYWN0LmNyZWF0ZUVsZW1lbnQiXSwibmFtZXMiOlsiQ2FsbGJhY2tzIiwiaGFsdCIsImJlZ2luIiwiY29tcGxldGUiLCJnZXRIYWx0IiwiZ2V0QmVnaW4iLCJnZXRDb21wbGV0ZSIsImZyb21IYWx0QmVnaW5BbmRDb21wbGV0ZSIsImNhbGxiYWNrcyJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7ZUFFcUJBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQU4sSUFBQSxBQUFNQSwwQkFBTjthQUFNQSxVQUNQQyxJQUFJLEVBQUVDLEtBQUssRUFBRUMsUUFBUTs4QkFEZEg7UUFFakIsSUFBSSxDQUFDQyxJQUFJLEdBQUdBO1FBQ1osSUFBSSxDQUFDQyxLQUFLLEdBQUdBO1FBQ2IsSUFBSSxDQUFDQyxRQUFRLEdBQUdBOztpQkFKQ0g7O1lBT25CSSxLQUFBQTttQkFBQUEsU0FBQUEsVUFBVTtnQkFDUixPQUFPLElBQUksQ0FBQ0gsSUFBSTtZQUNsQjs7O1lBRUFJLEtBQUFBO21CQUFBQSxTQUFBQSxXQUFXO2dCQUNULE9BQU8sSUFBSSxDQUFDSCxLQUFLO1lBQ25COzs7WUFFQUksS0FBQUE7bUJBQUFBLFNBQUFBLGNBQWM7Z0JBQ1osT0FBTyxJQUFJLENBQUNILFFBQVE7WUFDdEI7Ozs7WUFFT0ksS0FBQUE7bUJBQVAsU0FBT0EseUJBQXlCTixJQUFJLEVBQUVDLEtBQUssRUFBRUMsUUFBUSxFQUFFO2dCQUNyRCxJQUFNSyxZQUFZLElBcEJEUixVQW9CZUMsTUFBTUMsT0FBT0M7Z0JBRTdDLE9BQU9LO1lBQ1Q7OztXQXZCbUJSIn0=