propagate-cli 1.10.0 → 1.10.3

package/lib/release.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Release;
+    }
+});
+var _version = /*#__PURE__*/ _interop_require_default(require("./version"));
+var _shell = require("./utilities/shell");
+var _packageJSON = require("./utilities/packageJSON");
+var _configuration = require("./configuration");
+function _class_call_check(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 _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var Release = /*#__PURE__*/ function() {
+    function Release(name, version, dependencyMap, devDependencyMap, subDirectoryPath) {
+        _class_call_check(this, Release);
+        this.name = name;
+        this.version = version;
+        this.dependencyMap = dependencyMap;
+        this.devDependencyMap = devDependencyMap;
+        this.subDirectoryPath = subDirectoryPath;
+    }
+    _create_class(Release, [
+        {
+            key: "getName",
+            value: function getName() {
+                return this.name;
+            }
+        },
+        {
+            key: "getVersion",
+            value: function getVersion() {
+                return this.version;
+            }
+        },
+        {
+            key: "getDependencyMap",
+            value: function getDependencyMap() {
+                return this.dependencyMap;
+            }
+        },
+        {
+            key: "getDevDependencyMap",
+            value: function getDevDependencyMap() {
+                return this.devDependencyMap;
+            }
+        },
+        {
+            key: "getSubDirectoryPath",
+            value: function getSubDirectoryPath() {
+                return this.subDirectoryPath;
+            }
+        },
+        {
+            key: "isPublishable",
+            value: function isPublishable() {
+                var publishable = this.name !== null && this.version !== null;
+                return publishable;
+            }
+        },
+        {
+            key: "getVersionString",
+            value: function getVersionString() {
+                var versionString = this.version.asString();
+                return versionString; ///
+            }
+        },
+        {
+            key: "getDependencyNames",
+            value: function getDependencyNames() {
+                var dependencyNames = Object.keys(this.dependencyMap);
+                return dependencyNames;
+            }
+        },
+        {
+            key: "getDevDependencyNames",
+            value: function getDevDependencyNames() {
+                var devDependencyNames = Object.keys(this.devDependencyMap);
+                return devDependencyNames;
+            }
+        },
+        {
+            key: "git",
+            value: function git(quietly, callback) {
+                var shellCommands = (0, _configuration.retrieveShellCommands)();
+                var git = shellCommands.git, gitShellCommands = git;
+                shellCommands = gitShellCommands; ///
+                this.executeShellCommands(shellCommands, quietly, callback);
+            }
+        },
+        {
+            key: "install",
+            value: function install(quietly, callback) {
+                var shellCommands = (0, _configuration.retrieveShellCommands)();
+                var install = shellCommands.install, installShellCommands = install;
+                shellCommands = installShellCommands; ///
+                this.executeShellCommands(shellCommands, quietly, callback);
+            }
+        },
+        {
+            key: "build",
+            value: function build(quietly, callback) {
+                var ignoredBuilds = (0, _configuration.retrieveIgnoredBuilds)(), names = ignoredBuilds, namesIncludesName = names.includes(this.name), buildIgnored = namesIncludesName; ///
+                if (buildIgnored) {
+                    console.log("Ignoring the '".concat(this.name, "' build."));
+                    var success = true;
+                    callback(success);
+                    return;
+                }
+                var shellCommands = (0, _configuration.retrieveShellCommands)();
+                var build = shellCommands.build, buildShellCommands = build;
+                shellCommands = buildShellCommands; ///
+                this.executeShellCommands(shellCommands, quietly, callback);
+            }
+        },
+        {
+            key: "publish",
+            value: function publish(quietly, callback) {
+                var ignoredPublishes = (0, _configuration.retrieveIgnoredPublishes)(), names = ignoredPublishes, namesIncludesName = names.includes(this.name), publishIgnored = namesIncludesName; ///
+                if (publishIgnored) {
+                    console.log("Ignoring the '".concat(this.name, "' publish."));
+                    var success = true;
+                    callback(success);
+                    return;
+                }
+                var shellCommands = (0, _configuration.retrieveShellCommands)();
+                var publish = shellCommands.publish, publishShellCommands = publish;
+                shellCommands = publishShellCommands; ///
+                this.executeShellCommands(shellCommands, quietly, callback);
+            }
+        },
+        {
+            key: "bumpPatchNumber",
+            value: function bumpPatchNumber() {
+                this.version.bumpPatchNumber();
+            }
+        },
+        {
+            key: "executeShellCommands",
+            value: function executeShellCommands(shellCommands, quietly, callback) {
+                var currentWorkingDirectoryPath = process.cwd();
+                process.chdir(this.subDirectoryPath);
+                (0, _shell.execute)(shellCommands, quietly, function(success) {
+                    process.chdir(currentWorkingDirectoryPath);
+                    callback(success);
+                });
+            }
+        },
+        {
+            key: "updateDependencyVersion",
+            value: function updateDependencyVersion(name, versionString) {
+                var success = updateSemver(name, versionString, this.dependencyMap);
+                if (!success) {
+                    console.log("Either the version of the '".concat(this.subDirectoryPath, "' release's '").concat(name, "' dependency is greater than or equal to the propagated '").concat(versionString, "' version or it cannot be parsed."));
+                }
+                return success;
+            }
+        },
+        {
+            key: "updateDevDependencyVersion",
+            value: function updateDevDependencyVersion(name, versionString) {
+                var success = updateSemver(name, versionString, this.devDependencyMap);
+                if (!success) {
+                    console.log("Either the version of the '".concat(this.subDirectoryPath, "' release's '").concat(name, "' developer dependency is greater than or equal to the propagated '").concat(versionString, "' version or it cannot be parsed."));
+                }
+                return success;
+            }
+        }
+    ], [
+        {
+            key: "fromSubDirectoryPath",
+            value: function fromSubDirectoryPath(subDirectoryPath) {
+                var release = null;
+                var packageJSON = (0, _packageJSON.readPackageJSONFile)(subDirectoryPath);
+                if (packageJSON !== null) {
+                    var _packageJSON_version = packageJSON.version, version = _packageJSON_version === void 0 ? null : _packageJSON_version;
+                    var _packageJSON_name = packageJSON.name, name = _packageJSON_name === void 0 ? null : _packageJSON_name, _packageJSON_dependencies = packageJSON.dependencies, dependencies = _packageJSON_dependencies === void 0 ? {} : _packageJSON_dependencies, _packageJSON_devDependencies = packageJSON.devDependencies, devDependencies = _packageJSON_devDependencies === void 0 ? {} : _packageJSON_devDependencies, versionString = version, dependencyMap = dependencies, devDependencyMap = devDependencies; ///
+                    version = _version.default.fromVersionString(versionString);
+                    release = new Release(name, version, dependencyMap, devDependencyMap, subDirectoryPath);
+                }
+                return release;
+            }
+        }
+    ]);
+    return Release;
+}();
+function updateSemver(name, versionString, map) {
+    var success = false;
+    var semver = map[name] || null;
+    var version = _version.default.fromVersionString(versionString), existingSemver = semver, existingVersion = _version.default.fromString(existingSemver);
+    if (existingVersion !== null) {
+        var versionGreaterThanExistingVersion = version.isGreaterThan(existingVersion);
+        success = versionGreaterThanExistingVersion; ///
+        if (success) {
+            semver = version.updateSemver(semver);
+            map[name] = semver;
+        }
+    }
+    return success;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/release.js"],"sourcesContent":["\"use strict\";\n\nimport Version from \"./version\";\n\nimport { execute } from \"./utilities/shell\";\nimport { readPackageJSONFile } from \"./utilities/packageJSON\";\nimport { retrieveShellCommands, retrieveIgnoredBuilds, retrieveIgnoredPublishes } from \"./configuration\";\n\nexport default class Release {\n  constructor(name, version, dependencyMap, devDependencyMap, subDirectoryPath) {\n    this.name = name;\n    this.version = version;\n    this.dependencyMap = dependencyMap;\n    this.devDependencyMap = devDependencyMap;\n    this.subDirectoryPath = subDirectoryPath;\n  }\n\n  getName() {\n    return this.name;\n  }\n\n  getVersion() {\n    return this.version;\n  }\n\n  getDependencyMap() {\n    return this.dependencyMap;\n  }\n\n  getDevDependencyMap() {\n    return this.devDependencyMap;\n  }\n\n  getSubDirectoryPath() {\n    return this.subDirectoryPath;\n  }\n\n  isPublishable() {\n    const publishable = (this.name !== null) && (this.version !== null);\n\n    return publishable;\n  }\n\n  getVersionString() {\n    const versionString = this.version.asString();\n\n    return versionString; ///\n  }\n\n  getDependencyNames() {\n    const dependencyNames = Object.keys(this.dependencyMap);\n\n    return dependencyNames;\n  }\n\n  getDevDependencyNames() {\n    const devDependencyNames = Object.keys(this.devDependencyMap);\n\n    return devDependencyNames;\n  }\n\n  git(quietly, callback) {\n    let shellCommands = retrieveShellCommands();\n\n    const { git } = shellCommands,\n          gitShellCommands = git;\n\n    shellCommands = gitShellCommands; ///\n\n    this.executeShellCommands(shellCommands, quietly, callback);\n  }\n\n  install(quietly, callback) {\n    let shellCommands = retrieveShellCommands();\n\n    const { install } = shellCommands,\n          installShellCommands = install;\n\n    shellCommands = installShellCommands; ///\n\n    this.executeShellCommands(shellCommands, quietly, callback);\n  }\n\n  build(quietly, callback) {\n    const ignoredBuilds = retrieveIgnoredBuilds(),\n          names = ignoredBuilds,\n          namesIncludesName = names.includes(this.name),\n          buildIgnored = namesIncludesName; ///\n\n    if (buildIgnored) {\n      console.log(`Ignoring the '${this.name}' build.`);\n\n      const success = true;\n\n      callback(success);\n\n      return;\n    }\n\n    let shellCommands = retrieveShellCommands();\n\n    const { build } = shellCommands,\n          buildShellCommands = build;\n\n    shellCommands = buildShellCommands; ///\n\n    this.executeShellCommands(shellCommands, quietly, callback);\n  }\n\n  publish(quietly, callback) {\n    const ignoredPublishes = retrieveIgnoredPublishes(),\n          names = ignoredPublishes,\n          namesIncludesName = names.includes(this.name),\n          publishIgnored = namesIncludesName; ///\n\n    if (publishIgnored) {\n      console.log(`Ignoring the '${this.name}' publish.`);\n\n      const success = true;\n\n      callback(success);\n\n      return;\n    }\n\n    let shellCommands = retrieveShellCommands();\n\n    const { publish } = shellCommands,\n          publishShellCommands = publish;\n\n    shellCommands = publishShellCommands; ///\n\n    this.executeShellCommands(shellCommands, quietly, callback);\n  }\n\n  bumpPatchNumber() { this.version.bumpPatchNumber(); }\n\n  executeShellCommands(shellCommands, quietly, callback) {\n    const currentWorkingDirectoryPath = process.cwd();\n\n    process.chdir(this.subDirectoryPath);\n\n    execute(shellCommands, quietly, (success) => {\n      process.chdir(currentWorkingDirectoryPath);\n\n      callback(success);\n    });\n  }\n\n  updateDependencyVersion(name, versionString) {\n    const success = updateSemver(name, versionString, this.dependencyMap);\n\n    if (!success) {\n      console.log(`Either the version of the '${this.subDirectoryPath}' release's '${name}' dependency is greater than or equal to the propagated '${versionString}' version or it cannot be parsed.`);\n    }\n\n    return success;\n  }\n\n  updateDevDependencyVersion(name, versionString) {\n    const success = updateSemver(name, versionString, this.devDependencyMap);\n\n    if (!success) {\n      console.log(`Either the version of the '${this.subDirectoryPath}' release's '${name}' developer dependency is greater than or equal to the propagated '${versionString}' version or it cannot be parsed.`);\n    }\n\n    return success;\n  }\n\n  static fromSubDirectoryPath(subDirectoryPath) {\n    let release = null;\n\n    const packageJSON = readPackageJSONFile(subDirectoryPath);\n\n    if (packageJSON !== null) {\n      let { version = null } = packageJSON;\n\n      const { name = null, dependencies = {}, devDependencies = {} } = packageJSON,\n            versionString = version,  ///\n            dependencyMap = dependencies, ///\n            devDependencyMap = devDependencies; ///\n\n      version = Version.fromVersionString(versionString);\n\n      release = new Release(name, version, dependencyMap, devDependencyMap, subDirectoryPath);\n    }\n\n    return release;\n  }\n}\n\nfunction updateSemver(name, versionString, map) {\n  let success = false;\n\n  let semver = map[name] || null;\n\n  const version = Version.fromVersionString(versionString),\n        existingSemver = semver, ///\n        existingVersion = Version.fromString(existingSemver);\n\n  if (existingVersion !== null) {\n    const versionGreaterThanExistingVersion = version.isGreaterThan(existingVersion);\n\n    success = versionGreaterThanExistingVersion;  ///\n\n    if (success) {\n      semver = version.updateSemver(semver);\n\n      map[name] = semver;\n    }\n  }\n\n  return success;\n}\n"],"names":["Release","name","version","dependencyMap","devDependencyMap","subDirectoryPath","getName","getVersion","getDependencyMap","getDevDependencyMap","getSubDirectoryPath","isPublishable","publishable","getVersionString","versionString","asString","getDependencyNames","dependencyNames","Object","keys","getDevDependencyNames","devDependencyNames","git","quietly","callback","shellCommands","retrieveShellCommands","gitShellCommands","executeShellCommands","install","installShellCommands","build","ignoredBuilds","retrieveIgnoredBuilds","names","namesIncludesName","includes","buildIgnored","console","log","success","buildShellCommands","publish","ignoredPublishes","retrieveIgnoredPublishes","publishIgnored","publishShellCommands","bumpPatchNumber","currentWorkingDirectoryPath","process","cwd","chdir","execute","updateDependencyVersion","updateSemver","updateDevDependencyVersion","fromSubDirectoryPath","release","packageJSON","readPackageJSONFile","dependencies","devDependencies","Version","fromVersionString","map","semver","existingSemver","existingVersion","fromString","versionGreaterThanExistingVersion","isGreaterThan"],"mappings":"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"}

package/lib/releaseGraph.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ReleaseGraph;
+    }
+});
+var _occamdirectedgraphs = require("occam-directed-graphs");
+function _class_call_check(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 _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+var ReleaseGraph = /*#__PURE__*/ function() {
+    function ReleaseGraph(dependencyDirectedGraph, devDependencyDirectedGraph) {
+        _class_call_check(this, ReleaseGraph);
+        this.dependencyDirectedGraph = dependencyDirectedGraph;
+        this.devDependencyDirectedGraph = devDependencyDirectedGraph;
+    }
+    _create_class(ReleaseGraph, [
+        {
+            key: "getDependencyDirectedGraph",
+            value: function getDependencyDirectedGraph() {
+                return this.dependencyDirectedGraph;
+            }
+        },
+        {
+            key: "getDevDependencyDirectedGraph",
+            value: function getDevDependencyDirectedGraph() {
+                return this.devDependencyDirectedGraph;
+            }
+        },
+        {
+            key: "isCyclicDependencyPresent",
+            value: function isCyclicDependencyPresent() {
+                var cyclesPresent = this.dependencyDirectedGraph.areCyclesPresent(), cyclicDependencyPresent = cyclesPresent; ///
+                return cyclicDependencyPresent;
+            }
+        },
+        {
+            key: "isCyclicDevDependencyPresent",
+            value: function isCyclicDevDependencyPresent() {
+                var cyclesPresent = this.devDependencyDirectedGraph.areCyclesPresent(), cyclicDevDependencyPresent = cyclesPresent; ///
+                return cyclicDevDependencyPresent;
+            }
+        },
+        {
+            key: "getCyclicDependencySubDirectoryPaths",
+            value: function getCyclicDependencySubDirectoryPaths() {
+                var firstCycle = this.dependencyDirectedGraph.getFirstCycle(), vertexNames = firstCycle.getVertexNames(), cyclicDependencySubDirectoryPaths = vertexNames; ///
+                return cyclicDependencySubDirectoryPaths;
+            }
+        },
+        {
+            key: "getCyclicDevDependencySubDirectoryPaths",
+            value: function getCyclicDevDependencySubDirectoryPaths() {
+                var firstCycle = this.devDependencyDirectedGraph.getFirstCycle(), vertexNames = firstCycle.getVertexNames(), cyclicDevDependencySubDirectoryPaths = vertexNames; ///
+                return cyclicDevDependencySubDirectoryPaths;
+            }
+        },
+        {
+            key: "getOrderedDependencySubDirectoryPaths",
+            value: function getOrderedDependencySubDirectoryPaths() {
+                var dependencyDirectedGraphOrderedVertexNames = this.dependencyDirectedGraph.getOrderedVertexNames(), orderedDependencySubDirectoryPaths = dependencyDirectedGraphOrderedVertexNames; ///
+                return orderedDependencySubDirectoryPaths;
+            }
+        },
+        {
+            key: "getOrderedDevDependencySubDirectoryPaths",
+            value: function getOrderedDevDependencySubDirectoryPaths() {
+                var dependencyDirectedGraphOrderedVertexNames = this.devDependencyDirectedGraph.getOrderedVertexNames(), orderedDevDependencySubDirectoryPaths = dependencyDirectedGraphOrderedVertexNames; ///
+                return orderedDevDependencySubDirectoryPaths;
+            }
+        },
+        {
+            key: "retrieveDependentReleases",
+            value: function retrieveDependentReleases(release, releaseMap) {
+                var subDirectoryPath = release.getSubDirectoryPath(), vertexName = subDirectoryPath, immediateSuccessorVertexNames = this.dependencyDirectedGraph.getImmediateSuccessorVertexNamesByVertexName(vertexName), dependentSubDirectoryPaths = immediateSuccessorVertexNames, dependentReleases = dependentSubDirectoryPaths.map(function(dependentSubDirectoryPath) {
+                    var dependentRelease = releaseMap.retrieveRelease(dependentSubDirectoryPath);
+                    return dependentRelease;
+                });
+                return dependentReleases;
+            }
+        },
+        {
+            key: "retrieveDevDependentReleases",
+            value: function retrieveDevDependentReleases(release, releaseMap) {
+                var subDirectoryPath = release.getSubDirectoryPath(), vertexName = subDirectoryPath, immediateSuccessorVertexNames = this.devDependencyDirectedGraph.getImmediateSuccessorVertexNamesByVertexName(vertexName), devDependentSubDirectoryPaths = immediateSuccessorVertexNames, devDependentReleases = devDependentSubDirectoryPaths.map(function(devDependentSubDirectoryPath) {
+                    var devDependentRelease = releaseMap.retrieveRelease(devDependentSubDirectoryPath);
+                    return devDependentRelease;
+                });
+                return devDependentReleases;
+            }
+        }
+    ], [
+        {
+            key: "fromReleaseMapSubDirectoryMapAndForcedDependencyRelations",
+            value: function fromReleaseMapSubDirectoryMapAndForcedDependencyRelations(releaseMap, subDirectoryMap, forcedDependencyRelations) {
+                var dependencyDirectedGraph = _occamdirectedgraphs.DirectedGraph.fromNothing(), devDependencyDirectedGraph = _occamdirectedgraphs.DirectedGraph.fromNothing(), releaseNames = releaseMap.getNames(), subDirectoryPaths = releaseMap.getSubDirectoryPaths(), nameToSubDirectoryPathMap = releaseMap.getNameToSubDirectoryPathMap(), vertexNames = subDirectoryPaths; ///
+                dependencyDirectedGraph.addVertexesByVertexNames(vertexNames);
+                devDependencyDirectedGraph.addVertexesByVertexNames(vertexNames);
+                subDirectoryPaths.forEach(function(subDirectoryPath) {
+                    var release = releaseMap.retrieveRelease(subDirectoryPath), releaseDependencyNames = release.getDependencyNames(), releaseDevDependencyNames = release.getDevDependencyNames();
+                    releaseDependencyNames.forEach(function(releaseDependencyName) {
+                        var releaseNamesIncludesReleaseDependencyName = releaseNames.includes(releaseDependencyName);
+                        if (releaseNamesIncludesReleaseDependencyName) {
+                            var dependencySubDirectoryPath = nameToSubDirectoryPathMap[releaseDependencyName], sourceVertexName = dependencySubDirectoryPath, targetVertexName = subDirectoryPath; ///
+                            dependencyDirectedGraph.addEdgeBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
+                        }
+                    });
+                    releaseDevDependencyNames.forEach(function(releaseDevDependencyName) {
+                        var releaseNamesIncludesReleaseDevDependencyName = releaseNames.includes(releaseDevDependencyName);
+                        if (releaseNamesIncludesReleaseDevDependencyName) {
+                            var devDependencySubDirectoryPath = nameToSubDirectoryPathMap[releaseDevDependencyName], sourceVertexName = devDependencySubDirectoryPath, targetVertexName = subDirectoryPath; ///
+                            devDependencyDirectedGraph.addEdgeBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
+                        }
+                    });
+                });
+                forcedDependencyRelations.forEach(function(forcedDependencyRelation) {
+                    var dependent = forcedDependencyRelation.dependent, dependentSubDirectoryName = dependent, dependentSubDirectoryPath = subDirectoryMap[dependentSubDirectoryName], dependentRelease = releaseMap.retrieveRelease(dependentSubDirectoryPath);
+                    if (dependentRelease === null) {
+                        console.log("The '".concat(dependent, "' forced dependent does not exist."));
+                        return;
+                    }
+                    var dependency = forcedDependencyRelation.dependency, dependencySubDirectoryName = dependency, dependencySubDirectoryPath = subDirectoryMap[dependencySubDirectoryName], dependencyRelease = releaseMap.retrieveRelease(dependencySubDirectoryPath);
+                    if (dependencyRelease === null) {
+                        console.log("The '".concat(dependency, "' forced dependency does not exist."));
+                        return;
+                    }
+                    var sourceVertexName = dependencySubDirectoryPath, targetVertexName = dependentSubDirectoryPath; ///
+                    var dependencyDirectedGraphEdgePresent = dependencyDirectedGraph.isEdgePresentBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName), dependencyRelationPresent = dependencyDirectedGraphEdgePresent; ///
+                    if (dependencyRelationPresent) {
+                        console.log("The '".concat(dependency, "' -> '").concat(dependent, "' dependency relation is present and therefore cannot be forced."));
+                        return;
+                    }
+                    var devDependencyDirectedGraphEdgePresent = devDependencyDirectedGraph.isEdgePresentBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName), devDependencyRelationPresent = devDependencyDirectedGraphEdgePresent; ///
+                    if (!devDependencyRelationPresent) {
+                        console.log("The '".concat(dependency, "' -> '").concat(dependent, "' developer dependency relation is not present and therefore cannot be forced."));
+                        return;
+                    }
+                    if (dependencyRelease) {
+                        dependencyDirectedGraph.addEdgeBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
+                    }
+                });
+                var releaseGraph = new ReleaseGraph(dependencyDirectedGraph, devDependencyDirectedGraph);
+                return releaseGraph;
+            }
+        }
+    ]);
+    return ReleaseGraph;
+}();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/releaseGraph.js"],"sourcesContent":["\"use strict\";\n\nimport { DirectedGraph } from \"occam-directed-graphs\";\n\nexport default class ReleaseGraph {\n  constructor(dependencyDirectedGraph, devDependencyDirectedGraph) {\n    this.dependencyDirectedGraph = dependencyDirectedGraph;\n    this.devDependencyDirectedGraph = devDependencyDirectedGraph;\n  }\n\n  getDependencyDirectedGraph() {\n    return this.dependencyDirectedGraph;\n  }\n\n  getDevDependencyDirectedGraph() {\n    return this.devDependencyDirectedGraph;\n  }\n\n  isCyclicDependencyPresent() {\n    const cyclesPresent = this.dependencyDirectedGraph.areCyclesPresent(),\n          cyclicDependencyPresent = cyclesPresent;  ///\n\n    return cyclicDependencyPresent;\n  }\n\n  isCyclicDevDependencyPresent() {\n    const cyclesPresent = this.devDependencyDirectedGraph.areCyclesPresent(),\n          cyclicDevDependencyPresent = cyclesPresent;  ///\n\n    return cyclicDevDependencyPresent;\n  }\n\n  getCyclicDependencySubDirectoryPaths() {\n    const firstCycle = this.dependencyDirectedGraph.getFirstCycle(),\n          vertexNames = firstCycle.getVertexNames(),\n          cyclicDependencySubDirectoryPaths = vertexNames;  ///\n\n    return cyclicDependencySubDirectoryPaths;\n  }\n\n  getCyclicDevDependencySubDirectoryPaths() {\n    const firstCycle = this.devDependencyDirectedGraph.getFirstCycle(),\n          vertexNames = firstCycle.getVertexNames(),\n          cyclicDevDependencySubDirectoryPaths = vertexNames;  ///\n\n    return cyclicDevDependencySubDirectoryPaths;\n  }\n\n  getOrderedDependencySubDirectoryPaths() {\n    const dependencyDirectedGraphOrderedVertexNames = this.dependencyDirectedGraph.getOrderedVertexNames(),\n          orderedDependencySubDirectoryPaths = dependencyDirectedGraphOrderedVertexNames; ///\n\n    return orderedDependencySubDirectoryPaths;\n  }\n\n  getOrderedDevDependencySubDirectoryPaths() {\n    const dependencyDirectedGraphOrderedVertexNames = this.devDependencyDirectedGraph.getOrderedVertexNames(),\n          orderedDevDependencySubDirectoryPaths = dependencyDirectedGraphOrderedVertexNames; ///\n\n    return orderedDevDependencySubDirectoryPaths;\n  }\n\n  retrieveDependentReleases(release, releaseMap) {\n    const subDirectoryPath = release.getSubDirectoryPath(),\n          vertexName = subDirectoryPath,  ///\n          immediateSuccessorVertexNames = this.dependencyDirectedGraph.getImmediateSuccessorVertexNamesByVertexName(vertexName),\n          dependentSubDirectoryPaths = immediateSuccessorVertexNames,\n          dependentReleases = dependentSubDirectoryPaths.map((dependentSubDirectoryPath) => {\n            const dependentRelease = releaseMap.retrieveRelease(dependentSubDirectoryPath);\n\n            return dependentRelease;\n          });\n\n    return dependentReleases;\n  }\n\n  retrieveDevDependentReleases(release, releaseMap) {\n    const subDirectoryPath = release.getSubDirectoryPath(),\n          vertexName = subDirectoryPath,  ///\n          immediateSuccessorVertexNames = this.devDependencyDirectedGraph.getImmediateSuccessorVertexNamesByVertexName(vertexName),\n          devDependentSubDirectoryPaths = immediateSuccessorVertexNames,\n          devDependentReleases = devDependentSubDirectoryPaths.map((devDependentSubDirectoryPath) => {\n            const devDependentRelease = releaseMap.retrieveRelease(devDependentSubDirectoryPath);\n\n            return devDependentRelease;\n          });\n\n    return devDependentReleases;\n  }\n\n  static fromReleaseMapSubDirectoryMapAndForcedDependencyRelations(releaseMap, subDirectoryMap, forcedDependencyRelations) {\n    const dependencyDirectedGraph = DirectedGraph.fromNothing(),\n          devDependencyDirectedGraph = DirectedGraph.fromNothing(),\n          releaseNames = releaseMap.getNames(),\n          subDirectoryPaths = releaseMap.getSubDirectoryPaths(),\n          nameToSubDirectoryPathMap = releaseMap.getNameToSubDirectoryPathMap(),\n          vertexNames = subDirectoryPaths;  ///\n\n    dependencyDirectedGraph.addVertexesByVertexNames(vertexNames);\n\n    devDependencyDirectedGraph.addVertexesByVertexNames(vertexNames);\n\n    subDirectoryPaths.forEach((subDirectoryPath) => {\n      const release = releaseMap.retrieveRelease(subDirectoryPath),\n            releaseDependencyNames = release.getDependencyNames(),\n            releaseDevDependencyNames = release.getDevDependencyNames();\n\n      releaseDependencyNames.forEach((releaseDependencyName) => {\n        const releaseNamesIncludesReleaseDependencyName = releaseNames.includes(releaseDependencyName);\n\n        if (releaseNamesIncludesReleaseDependencyName) {\n          const dependencySubDirectoryPath = nameToSubDirectoryPathMap[releaseDependencyName],\n                sourceVertexName = dependencySubDirectoryPath,  ///\n                targetVertexName = subDirectoryPath;  ///\n\n          dependencyDirectedGraph.addEdgeBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);\n        }\n      });\n\n      releaseDevDependencyNames.forEach((releaseDevDependencyName) => {\n        const releaseNamesIncludesReleaseDevDependencyName = releaseNames.includes(releaseDevDependencyName);\n\n        if (releaseNamesIncludesReleaseDevDependencyName) {\n          const devDependencySubDirectoryPath = nameToSubDirectoryPathMap[releaseDevDependencyName],\n                sourceVertexName = devDependencySubDirectoryPath,  ///\n                targetVertexName = subDirectoryPath;  ///\n\n          devDependencyDirectedGraph.addEdgeBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);\n        }\n      });\n    });\n\n    forcedDependencyRelations.forEach((forcedDependencyRelation) => {\n      const { dependent } = forcedDependencyRelation,\n            dependentSubDirectoryName = dependent, //\n            dependentSubDirectoryPath = subDirectoryMap[dependentSubDirectoryName], ///\n            dependentRelease = releaseMap.retrieveRelease(dependentSubDirectoryPath);\n\n      if (dependentRelease === null) {\n        console.log(`The '${dependent}' forced dependent does not exist.`);\n\n        return;\n      }\n\n      const { dependency } = forcedDependencyRelation,\n            dependencySubDirectoryName = dependency,  ///\n            dependencySubDirectoryPath = subDirectoryMap[dependencySubDirectoryName],  ///\n            dependencyRelease = releaseMap.retrieveRelease(dependencySubDirectoryPath);\n\n      if (dependencyRelease === null) {\n        console.log(`The '${dependency}' forced dependency does not exist.`);\n\n        return;\n      }\n\n      const sourceVertexName = dependencySubDirectoryPath,  ///\n            targetVertexName = dependentSubDirectoryPath;  ///\n\n      const dependencyDirectedGraphEdgePresent = dependencyDirectedGraph.isEdgePresentBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName),\n            dependencyRelationPresent = dependencyDirectedGraphEdgePresent; ///\n\n      if (dependencyRelationPresent) {\n        console.log(`The '${dependency}' -> '${dependent}' dependency relation is present and therefore cannot be forced.`);\n\n        return;\n      }\n\n      const devDependencyDirectedGraphEdgePresent = devDependencyDirectedGraph.isEdgePresentBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName),\n            devDependencyRelationPresent = devDependencyDirectedGraphEdgePresent; ///\n\n      if (!devDependencyRelationPresent) {\n        console.log(`The '${dependency}' -> '${dependent}' developer dependency relation is not present and therefore cannot be forced.`);\n\n        return;\n      }\n\n      if (dependencyRelease) {\n        dependencyDirectedGraph.addEdgeBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);\n      }\n    });\n\n    const releaseGraph = new ReleaseGraph(dependencyDirectedGraph, devDependencyDirectedGraph);\n\n    return releaseGraph;\n  }\n}\n"],"names":["ReleaseGraph","dependencyDirectedGraph","devDependencyDirectedGraph","getDependencyDirectedGraph","getDevDependencyDirectedGraph","isCyclicDependencyPresent","cyclesPresent","areCyclesPresent","cyclicDependencyPresent","isCyclicDevDependencyPresent","cyclicDevDependencyPresent","getCyclicDependencySubDirectoryPaths","firstCycle","getFirstCycle","vertexNames","getVertexNames","cyclicDependencySubDirectoryPaths","getCyclicDevDependencySubDirectoryPaths","cyclicDevDependencySubDirectoryPaths","getOrderedDependencySubDirectoryPaths","dependencyDirectedGraphOrderedVertexNames","getOrderedVertexNames","orderedDependencySubDirectoryPaths","getOrderedDevDependencySubDirectoryPaths","orderedDevDependencySubDirectoryPaths","retrieveDependentReleases","release","releaseMap","subDirectoryPath","getSubDirectoryPath","vertexName","immediateSuccessorVertexNames","getImmediateSuccessorVertexNamesByVertexName","dependentSubDirectoryPaths","dependentReleases","map","dependentSubDirectoryPath","dependentRelease","retrieveRelease","retrieveDevDependentReleases","devDependentSubDirectoryPaths","devDependentReleases","devDependentSubDirectoryPath","devDependentRelease","fromReleaseMapSubDirectoryMapAndForcedDependencyRelations","subDirectoryMap","forcedDependencyRelations","DirectedGraph","fromNothing","releaseNames","getNames","subDirectoryPaths","getSubDirectoryPaths","nameToSubDirectoryPathMap","getNameToSubDirectoryPathMap","addVertexesByVertexNames","forEach","releaseDependencyNames","getDependencyNames","releaseDevDependencyNames","getDevDependencyNames","releaseDependencyName","releaseNamesIncludesReleaseDependencyName","includes","dependencySubDirectoryPath","sourceVertexName","targetVertexName","addEdgeBySourceVertexNameAndTargetVertexName","releaseDevDependencyName","releaseNamesIncludesReleaseDevDependencyName","devDependencySubDirectoryPath","forcedDependencyRelation","dependent","dependentSubDirectoryName","console","log","dependency","dependencySubDirectoryName","dependencyRelease","dependencyDirectedGraphEdgePresent","isEdgePresentBySourceVertexNameAndTargetVertexName","dependencyRelationPresent","devDependencyDirectedGraphEdgePresent","devDependencyRelationPresent","releaseGraph"],"mappings":"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"}

package/lib/releaseMap.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return ReleaseMap;
+    }
+});
+var _release = /*#__PURE__*/ _interop_require_default(require("./release"));
+function _class_call_check(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 _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var ReleaseMap = /*#__PURE__*/ function() {
+    function ReleaseMap(map) {
+        _class_call_check(this, ReleaseMap);
+        this.map = map;
+    }
+    _create_class(ReleaseMap, [
+        {
+            key: "getNames",
+            value: function getNames() {
+                var names = [], releases = this.getReleases();
+                releases.forEach(function(release) {
+                    var name = release.getName();
+                    if (name !== null) {
+                        names.push(name);
+                    }
+                });
+                return names;
+            }
+        },
+        {
+            key: "getReleases",
+            value: function getReleases() {
+                var releases = Object.values(this.map);
+                return releases;
+            }
+        },
+        {
+            key: "getSubDirectoryPaths",
+            value: function getSubDirectoryPaths() {
+                var subDirectoryPaths = Object.keys(this.map);
+                return subDirectoryPaths;
+            }
+        },
+        {
+            key: "getNameToSubDirectoryPathMap",
+            value: function getNameToSubDirectoryPathMap() {
+                var _this = this;
+                var nameToSubDirectoryPathMap = {}, subDirectoryPaths = this.getSubDirectoryPaths();
+                subDirectoryPaths.forEach(function(subDirectoryPath) {
+                    var release = _this.retrieveRelease(subDirectoryPath), name = release.getName();
+                    if (name !== null) {
+                        nameToSubDirectoryPathMap[name] = subDirectoryPath;
+                    }
+                });
+                return nameToSubDirectoryPathMap;
+            }
+        },
+        {
+            key: "retrieveRelease",
+            value: function retrieveRelease(subDirectoryPath) {
+                var release = this.map[subDirectoryPath] || null; ///
+                return release;
+            }
+        }
+    ], [
+        {
+            key: "fromSubDirectoryMapAndIgnoredDependencies",
+            value: function fromSubDirectoryMapAndIgnoredDependencies(subDirectoryMap, ignoredDependencies) {
+                var map = {}, subDirectoryPaths = subDirectoryPathsFromSubDirectoryMapAndIgnoredDependencies(subDirectoryMap, ignoredDependencies);
+                subDirectoryPaths.forEach(function(subDirectoryPath) {
+                    var release = _release.default.fromSubDirectoryPath(subDirectoryPath);
+                    if (release !== null) {
+                        map[subDirectoryPath] = release;
+                    }
+                });
+                var releaseMap = new ReleaseMap(map);
+                return releaseMap;
+            }
+        }
+    ]);
+    return ReleaseMap;
+}();
+function subDirectoryPathsFromSubDirectoryMapAndIgnoredDependencies(subDirectoryMap, ignoredDependencies) {
+    var subDirectoryPaths = [], subDirectoryNames = Object.keys(subDirectoryMap), ignoredDependencySubDirectoryNames = ignoredDependencies; ///
+    subDirectoryNames.forEach(function(subDirectoryName) {
+        var ignoredDependencySubDirectoryNamesIncludesSubDirectoryName = ignoredDependencySubDirectoryNames.includes(subDirectoryName);
+        if (!ignoredDependencySubDirectoryNamesIncludesSubDirectoryName) {
+            var subDirectoryPath = subDirectoryMap[subDirectoryName]; ///
+            subDirectoryPaths.push(subDirectoryPath);
+        }
+    });
+    return subDirectoryPaths;
+}
+
+//# sourceMappingURL=data:application/json;base64,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