propagate-cli 1.9.8 → 1.9.13

package/bin/operation/createSubDirectoryMap.js

@@ -17,20 +17,26 @@ function createSubDirectoryMapOperation(proceed, abort, context) {
         ];
 
   directoryNames.forEach((directoryName) => {
-    const absoluteDirectoryPath = absolutePathFromName(directoryName),
-          entryNames = readDirectory(absoluteDirectoryPath);
-
-    entryNames.forEach((entryName) => {
-      const entryPath = `${directoryName}/${entryName}`,
-            entryDirectory = isEntryDirectory(entryPath);
-
-      if (entryDirectory) {
-        const subDirectoryName = entryName, ///
-              subDirectoryPath = entryPath; ///
-
-        subDirectoryMap[subDirectoryName] = subDirectoryPath;
-      }
-    });
+    try {
+      const absoluteDirectoryPath = absolutePathFromName(directoryName),
+            entryNames = readDirectory(absoluteDirectoryPath);
+
+      entryNames.forEach((entryName) => {
+        const entryPath = `${directoryName}/${entryName}`,
+              entryDirectory = isEntryDirectory(entryPath);
+
+        if (entryDirectory) {
+          const subDirectoryName = entryName, ///
+                subDirectoryPath = entryPath; ///
+
+          subDirectoryMap[subDirectoryName] = subDirectoryPath;
+        }
+      });
+    } catch (error) {
+      console.log(`The '${directoryName}' directory cannot be read.`);
+
+      process.exit(1);
+    }
   });
 
   Object.assign(context, {

package/bin/operation/propagateRelease.js

@@ -53,11 +53,11 @@ function propagateDependencies(release, releases, releaseMap, releaseGraph, subD
 
       if (!dependencyRelationForced) {
         dependentRelease.updateDependencyVersion(name, versionString);
-      }
 
-      const release = dependentRelease; ///
+        const release = dependentRelease; ///
 
-      propagateDependencies(release, releases, releaseMap, releaseGraph, subDirectoryMap, forcedDependencyRelations);
+        propagateDependencies(release, releases, releaseMap, releaseGraph, subDirectoryMap, forcedDependencyRelations);
+      }
     });
   }
 }
@@ -90,3 +90,10 @@ function propagateDevDependencies(releases, releaseMap, releaseGraph) {
     }
   });
 }
+
+/*
+occam-grammars
+occam-custom-grammars
+occam-documents
+occam-verifier
+ */

package/bin/releaseGraph.js

@@ -98,9 +98,12 @@ class ReleaseGraph {
 
     dependencyDirectedGraph.addVerticesByVertexNames(vertexNames);
 
+    devDependencyDirectedGraph.addVerticesByVertexNames(vertexNames);
+
     subDirectoryPaths.forEach((subDirectoryPath) => {
       const release = releaseMap.retrieveRelease(subDirectoryPath),
-            releaseDependencyNames = release.getDependencyNames();
+            releaseDependencyNames = release.getDependencyNames(),
+            releaseDevDependencyNames = release.getDevDependencyNames();
 
       releaseDependencyNames.forEach((releaseDependencyName) => {
         const releaseNamesIncludesReleaseDependencyName = releaseNames.includes(releaseDependencyName);
@@ -113,34 +116,6 @@ class ReleaseGraph {
           dependencyDirectedGraph.addEdgeByVertexNames(sourceVertexName, targetVertexName);
         }
       });
-    });
-
-    forcedDependencyRelations.forEach((forcedDependencyRelation) => {
-      const { dependent } = forcedDependencyRelation,
-            subDirectoryName = dependent, //
-            subDirectoryPath = subDirectoryMap[subDirectoryName], ///
-            release = releaseMap.retrieveRelease(subDirectoryPath);
-
-      if (release !== null) {
-        const { dependency } = forcedDependencyRelation,
-              dependencySubDirectoryName = dependency,  ///
-              dependencySubDirectoryPath = subDirectoryMap[dependencySubDirectoryName],  ///
-              dependencyRelease = releaseMap.retrieveRelease(dependencySubDirectoryPath);
-
-        if (dependencyRelease) {
-          const sourceVertexName = dependencySubDirectoryPath,  ///
-                targetVertexName = subDirectoryPath;  ///
-
-          dependencyDirectedGraph.addEdgeByVertexNames(sourceVertexName, targetVertexName);
-        }
-      }
-    });
-
-    devDependencyDirectedGraph.addVerticesByVertexNames(vertexNames);
-
-    subDirectoryPaths.forEach((subDirectoryPath) => {
-      const release = releaseMap.retrieveRelease(subDirectoryPath),
-            releaseDevDependencyNames = release.getDevDependencyNames();
 
       releaseDevDependencyNames.forEach((releaseDevDependencyName) => {
         const releaseNamesIncludesReleaseDevDependencyName = releaseNames.includes(releaseDevDependencyName);
@@ -155,6 +130,55 @@ class ReleaseGraph {
       });
     });
 
+    forcedDependencyRelations.forEach((forcedDependencyRelation) => {
+      const { dependent } = forcedDependencyRelation,
+            dependentSubDirectoryName = dependent, //
+            dependentSubDirectoryPath = subDirectoryMap[dependentSubDirectoryName], ///
+            dependentRelease = releaseMap.retrieveRelease(dependentSubDirectoryPath);
+
+      if (dependentRelease === null) {
+        console.log(`The '${dependent}' forced dependent does not exist.`);
+
+        process.exit(1);
+      }
+
+      const { dependency } = forcedDependencyRelation,
+            dependencySubDirectoryName = dependency,  ///
+            dependencySubDirectoryPath = subDirectoryMap[dependencySubDirectoryName],  ///
+            dependencyRelease = releaseMap.retrieveRelease(dependencySubDirectoryPath);
+
+      if (dependencyRelease === null) {
+        console.log(`The '${dependency}' forced dependency does not exist.`);
+
+        process.exit(1);
+      }
+
+      const sourceVertexName = dependencySubDirectoryPath,  ///
+            targetVertexName = dependentSubDirectoryPath;  ///
+
+      const dependencyDirectedGraphEdgePresent = dependencyDirectedGraph.isEdgePresentByVertexNames(sourceVertexName, targetVertexName),
+            dependencyRelationPresent = dependencyDirectedGraphEdgePresent; ///
+
+      if (dependencyRelationPresent) {
+        console.log(`The '${dependency}' -> '${dependent}' dependency relation is present and therefore cannot be forced.`);
+
+        process.exit(1);
+      }
+
+      const devDependencyDirectedGraphEdgePresent = devDependencyDirectedGraph.isEdgePresentByVertexNames(sourceVertexName, targetVertexName),
+            devDependencyRelationPresent = devDependencyDirectedGraphEdgePresent; ///
+
+      if (!devDependencyRelationPresent) {
+        console.log(`The '${dependency}' -> '${dependent}' developer dependency relation is not present and therefore cannot be forced.`);
+
+        process.exit(1);
+      }
+
+      if (dependencyRelease) {
+        dependencyDirectedGraph.addEdgeByVertexNames(sourceVertexName, targetVertexName);
+      }
+    });
+
     const releaseGraph = new ReleaseGraph(dependencyDirectedGraph, devDependencyDirectedGraph);
 
     return releaseGraph;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "propagate-cli",
   "author": "James Smith",
-  "version": "1.9.8",
+  "version": "1.9.13",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/propagate-cli",
   "description": "Propagate updated packages throughout a project.",
@@ -14,8 +14,8 @@
   },
   "dependencies": {
     "argumentative": "^2.0.15",
-    "necessary": "^10.0.7",
-    "occam-directed-graphs": "^3.0.17"
+    "necessary": "^11.0.1",
+    "occam-directed-graphs": "^3.0.23"
   },
   "devDependencies": {},
   "scripts": {}