occam-languages 0.0.128 → 0.0.129

package/lib/utilities/verification.js

@@ -9,83 +9,135 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get createReleaseContext () {
-        return createReleaseContext;
+    get createReleaseContexts () {
+        return createReleaseContexts;
     },
     get default () {
         return _default;
     },
-    get initialiseReleaseContext () {
-        return initialiseReleaseContext;
+    get initialiseReleaseContexts () {
+        return initialiseReleaseContexts;
     },
-    get verifyReleaseContext () {
-        return verifyReleaseContext;
+    get verifyReleaseContexts () {
+        return verifyReleaseContexts;
     }
 });
+const _occamdirectedgraphs = require("occam-directed-graphs");
 const _necessary = require("necessary");
+const _constants = require("../constants");
 const _dependency = require("../utilities/dependency");
-const { last } = _necessary.arrayUtilities;
-function initialiseReleaseContext(dependency, context) {
-    const { log, releaseContextMap } = context, dependencyName = dependency.getName(), releaseName = dependencyName, releaseContext = releaseContextMap[releaseName] || null;
+const { first, last } = _necessary.arrayUtilities;
+async function createReleaseContexts(dependency, context) {
+    let releaseContextsCreated = false;
+    const dependentNames = [], releaseContextCreated = await createReleaseContext(dependency, dependentNames, context);
+    if (releaseContextCreated) {
+        releaseContextsCreated = true;
+    }
+    return releaseContextsCreated;
+}
+function initialiseReleaseContexts(dependency, context) {
+    let releaseContextsInitialised = false;
+    const directedGraph = _occamdirectedgraphs.DirectedGraph.fromNothing(), visitedDependencyNames = [];
+    addDependencyRelations(dependency, directedGraph, visitedDependencyNames, context);
+    const cyclicDependenciesPresent = checkCyclicDependenciesPresent(directedGraph, context);
+    if (!cyclicDependenciesPresent) {
+        const { releaseContextMap } = context, releaseNames = Object.keys(releaseContextMap), orderedVertexNames = directedGraph.getOrderedVertexNames(), orderedDependencyNames = orderedVertexNames; ///
+        releaseNames.forEach((releaseName)=>{
+            const releaseContext = releaseContextMap[releaseName];
+            initialiseReleaseContext(releaseContext, orderedDependencyNames, context);
+        });
+        releaseContextsInitialised = true;
+    }
+    return releaseContextsInitialised;
+}
+async function verifyReleaseContexts(dependency, context) {
+    let releaseContextsVerify = false;
+    const dependencyName = dependency.getName(), releaseName = dependencyName, dependentName = null, dependentReleased = false, releaseContextVerifies = await verifyReleaseContext(releaseName, dependentName, dependentReleased, context);
+    if (releaseContextVerifies) {
+        releaseContextsVerify = true;
+    }
+    return releaseContextsVerify;
+}
+const _default = {
+    createReleaseContexts,
+    initialiseReleaseContexts,
+    verifyReleaseContexts
+};
+function addDependencyRelations(dependency, directedGraph, visitedDependencyNames, context) {
+    const dependencyName = dependency.getName(), visitedDependencyNameIncludesDependencyName = visitedDependencyNames.includes(dependencyName);
+    if (visitedDependencyNameIncludesDependencyName) {
+        return;
+    }
+    const visiteddependencyName = dependencyName; ///
+    visitedDependencyNames.push(visiteddependencyName);
+    const { log, releaseContextMap } = context, releaseName = dependencyName, releaseContext = releaseContextMap[releaseName] || null;
     if (releaseContext === null) {
-        log.warning(`Unable to initialise the '${dependencyName}' context because it has not been created.`);
-    } else {
-        const releaseContextInitialised = releaseContext.isInitialised();
-        if (!releaseContextInitialised) {
-            initialiseDependencyReleaseContexts(dependency, releaseContext, context);
-            const releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
-            log.info(`Initialising the '${dependencyName}' context...`);
-            const { FileContextFromFilePath } = context;
-            releaseContext.initialise(releaseContexts, FileContextFromFilePath);
-            log.debug(`...initialised the '${dependencyName}' context.`);
-        }
+        const dependencyString = dependency.getString();
+        log.warning(`No package context has been created for the '${dependencyString}' dependency. `);
+        return;
     }
+    const dependencies = releaseContext.getDependencies(), targetVertexName = dependencyName; ///
+    dependencies.forEachDependency((dependency)=>{
+        const dependencyName = dependency.getName(), sourceVertexName = dependencyName; ///
+        directedGraph.addEdgeBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
+        addDependencyRelations(dependency, directedGraph, visitedDependencyNames, context);
+    });
+}
+function initialiseReleaseContext(releaseContext, orderedDependencyNames, context) {
+    const { log, releaseContextMap, FileContextFromFilePath } = context, releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap), releaseContextName = releaseContext.getName();
+    releaseContexts.sort((releaseContextA, releaseContextB)=>{
+        const releaseContextAName = releaseContextA.getName(), releaseContextBName = releaseContextB.getName(), dependencyNameA = releaseContextAName, dependencyNameB = releaseContextBName, indexA = orderedDependencyNames.indexOf(dependencyNameA), indexB = orderedDependencyNames.indexOf(dependencyNameB);
+        return indexA - indexB;
+    });
+    log.info(`Initialising the '${releaseContextName}' package context...`);
+    releaseContext.initialise(releaseContexts, FileContextFromFilePath);
+    log.debug(`...initialised the '${releaseContextName}' package context.`);
 }
 async function createReleaseContext(dependency, dependentNames, context) {
     let releaseContextCreated = false;
-    const { log, releaseContextMap } = context, dependencyName = dependency.getName(), releaseName = dependencyName, releaseContext = releaseContextMap[releaseName] || null;
+    const { log, releaseContextMap, releaseContextFromDependency } = context, dependencyName = dependency.getName(), releaseName = dependencyName, releaseContext = releaseContextMap[releaseName] || null;
     if (releaseContext !== null) {
         const releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);
         if (releaseMatchesDependency) {
-            log.debug(`The '${releaseName}' context has already been created.`);
+            log.debug(`The '${releaseName}' package context has already been created.`);
             releaseContextCreated = true;
         }
     } else {
         const dependencyString = dependency.asString(), dependentNamesLength = dependentNames.length;
         if (dependentNamesLength === 0) {
-            log.info(`Creating the '${releaseName}' context...`);
+            log.info(`Creating the '${releaseName}' package context...`);
         } else {
             const lastDependentName = last(dependentNames), dependentName = lastDependentName; ///
-            log.info(`Creating the '${releaseName}' context given the '${dependentName}' dependant's '${dependencyString}' dependency...`);
+            log.info(`Creating the '${releaseName}' package context given the '${dependentName}' dependant's '${dependencyString}' dependency...`);
         }
-        const { releaseContextFromDependency } = context, releaseContext = await releaseContextFromDependency(dependency, context);
+        const releaseContext = await releaseContextFromDependency(dependency, context);
         if (releaseContext !== null) {
             const releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);
             if (releaseMatchesDependency) {
                 releaseContextMap[releaseName] = releaseContext;
-                const dependencyReleaseContextsCreated = await createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context);
+                const dependencyReleaseContextsCreated = await createDependencyReleaseContexts(releaseContext, dependency, dependentNames, context);
                 if (dependencyReleaseContextsCreated) {
                     releaseContextCreated = true;
                 }
             }
         } else {
             const dependencyName = dependency.getName(), releaseName = dependencyName; ///
-            log.warning(`The '${releaseName}' context could not be created. Perhaps the 'meta.json' file is missing or invalid. Or there could be a dependency mismatch.`);
+            log.warning(`The '${releaseName}' package context could not be created. Perhaps the 'meta.json' file is missing or invalid. Or there could be a dependency mismatch.`);
         }
-        releaseContextCreated ? log.debug(`...created the '${releaseName}' context.`) : log.warning(`...unable to create the '${releaseName}' context.`);
+        releaseContextCreated ? log.debug(`...created the '${releaseName}' package context.`) : log.warning(`...unable to create the '${releaseName}' package context.`);
     }
     return releaseContextCreated;
 }
 async function verifyReleaseContext(releaseName, dependentName, dependentReleased, releaseContextMap) {
     let releaseContextVerifies = false;
-    const releaseContext = releaseContextMap[releaseName];
+    const releaseContext = releaseContextMap[releaseName] || null;
     if (releaseContext !== null) {
         const released = releaseContext.isReleased();
         if (released) {
             releaseContextVerifies = true;
         } else {
             if (dependentReleased) {
-                releaseContext.warning(`The '${releaseName}' project cannot be verifies because its '${dependentName}' dependent is a package.`);
+                releaseContext.warning(`The '${releaseName}' project cannot be verified because its '${dependentName}' dependent is a package.`);
             } else {
                 const dependentName = releaseName, dependentReleased = released, dependencyReleaseContextsVerify = await verifyDependencyReleaseContexts(releaseContext, dependentName, dependentReleased, releaseContextMap);
                 if (dependencyReleaseContextsVerify) {
@@ -106,25 +158,17 @@ async function verifyReleaseContext(releaseName, dependentName, dependentRelease
     }
     return releaseContextVerifies;
 }
-const _default = {
-    createReleaseContext,
-    verifyReleaseContext,
-    initialiseReleaseContext
-};
-async function createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context) {
+async function createDependencyReleaseContexts(releaseContext, dependency, dependentNames, context) {
     let dependencyReleaseContextsCreated;
-    const dependencyName = dependency.getName(), dependencies = releaseContext.getDependencies();
+    const name = releaseContext.getName(), dependencies = releaseContext.getDependencies(), dependencyName = name; ///
     dependentNames = [
         ...dependentNames,
         dependencyName
     ]; ///
     dependencyReleaseContextsCreated = await (0, _dependency.asyncEveryDependency)(dependencies, async (dependency)=>{
-        const cyclicDependencyExists = checkCyclicDependencyExists(dependency, dependentNames, context);
-        if (!cyclicDependencyExists) {
-            const releaseContextCreated = await createReleaseContext(dependency, dependentNames, context);
-            if (releaseContextCreated) {
-                return true;
-            }
+        const releaseContextCreated = await createReleaseContext(dependency, dependentNames, context);
+        if (releaseContextCreated) {
+            return true;
         }
     });
     return dependencyReleaseContextsCreated;
@@ -138,40 +182,22 @@ async function verifyDependencyReleaseContexts(releaseContext, dependentName, de
     });
     return dependencyReleaseContextsVerify;
 }
-function retrieveReleaseContexts(releaseContext, releaseContextMap) {
-    const releaseContexts = [], remainingReleaseContext = releaseContext, remainingReleaseContexts = [
-        remainingReleaseContext
-    ];
-    let remainingReleaseContextsLength = remainingReleaseContexts.length;
-    while(remainingReleaseContextsLength > 0){
-        const remainingReleaseContext = remainingReleaseContexts.shift(), releaseContext = remainingReleaseContext; ///
-        releaseContexts.push(releaseContext);
-        const dependencies = releaseContext.getDependencies();
-        dependencies.forEachDependency((dependency)=>{
-            const dependencyName = dependency.getName(), releaseName = dependencyName, releaseContext = releaseContextMap[releaseName], releaseContextsIncludesReleaseContext = releaseContexts.includes(releaseContext), remainingReleaseContextsIncludesReleaseContext = remainingReleaseContexts.includes(releaseContext);
-            if (!releaseContextsIncludesReleaseContext && !remainingReleaseContextsIncludesReleaseContext) {
-                const remainingReleaseContext = releaseContext; ///
-                remainingReleaseContexts.push(remainingReleaseContext);
-            }
-        });
-        remainingReleaseContextsLength = remainingReleaseContexts.length;
+function retrieveReleaseContexts(releaseContext, releaseContextMap, releaseContexts = []) {
+    const releaseContextsIncludesReleaseContext = releaseContexts.includes(releaseContext);
+    if (releaseContextsIncludesReleaseContext) {
+        return;
     }
+    releaseContexts.push(releaseContext);
+    const dependencies = releaseContext.getDependencies();
+    dependencies.forEachDependency((dependency)=>{
+        const dependencyName = dependency.getName(), releaseName = dependencyName, releaseContext = releaseContextMap[releaseName];
+        retrieveReleaseContexts(releaseContext, releaseContextMap, releaseContexts);
+    });
     return releaseContexts;
 }
-function checkCyclicDependencyExists(dependency, dependentNames, context) {
-    const dependencyName = dependency.getName(), dependentNamesIncludesDependencyName = dependentNames.includes(dependencyName), cyclicDependencyExists = dependentNamesIncludesDependencyName; ///
-    if (cyclicDependencyExists) {
-        const { log } = context, firstDependentName = first(dependentNames), dependencyNames = [
-            ...dependentNames,
-            firstDependentName
-        ], dependencyNamesString = dependencyNames.join(`' -> '`);
-        log.warning(`There is a cyclic dependency, '${dependencyNamesString}'.`);
-    }
-    return cyclicDependencyExists;
-}
 function checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context) {
     let releaseMatchesDependency = true;
-    const shortenedVersion = dependency.getShortedVersion();
+    const shortenedVersion = dependency.getShortenedVersion();
     if (shortenedVersion !== null) {
         const entriesMatchShortenedVersion = releaseContext.matchShortenedVersion(shortenedVersion);
         if (!entriesMatchShortenedVersion) {
@@ -182,11 +208,18 @@ function checkReleaseMatchesDependency(releaseContext, dependency, dependentName
     }
     return releaseMatchesDependency;
 }
-function initialiseDependencyReleaseContexts(dependency, releaseContext, context) {
-    const dependencies = releaseContext.getDependencies();
-    dependencies.forEachDependency((dependency)=>{
-        initialiseReleaseContext(dependency, context);
-    });
+function checkCyclicDependenciesPresent(directedGraph, context) {
+    let cyclicDependenciesPresent = false;
+    const firstCycle = directedGraph.getFirstCycle();
+    if (firstCycle !== null) {
+        const { log } = context, vertexNames = firstCycle.getVertexNames(), dependencyNames = vertexNames, firstDependencyName = first(dependencyNames), cyclicDependencyNames = [
+            ...dependencyNames,
+            firstDependencyName
+        ], cycleString = cyclicDependencyNames.join(_constants.SINGLE_SPACE);
+        log.warning(`There is at least one '${cycleString}'. cyclic dependency`);
+        cyclicDependenciesPresent = true;
+    }
+    return cyclicDependenciesPresent;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/verification.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport { asyncEveryDependency } from \"../utilities/dependency\";\n\nconst { last } = arrayUtilities;\n\nexport function initialiseReleaseContext(dependency, context) {\n  const { log, releaseContextMap } = context,\n        dependencyName = dependency.getName(),\n        releaseName = dependencyName, ///\n        releaseContext = releaseContextMap[releaseName] || null;\n\n  if (releaseContext === null) {\n    log.warning(`Unable to initialise the '${dependencyName}' context because it has not been created.`);\n  } else {\n    const releaseContextInitialised = releaseContext.isInitialised();\n\n    if (!releaseContextInitialised) {\n      initialiseDependencyReleaseContexts(dependency, releaseContext, context);\n\n      const releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);\n\n      log.info(`Initialising the '${dependencyName}' context...`);\n\n      const { FileContextFromFilePath } = context;\n\n      releaseContext.initialise(releaseContexts, FileContextFromFilePath);\n\n      log.debug(`...initialised the '${dependencyName}' context.`);\n    }\n  }\n}\n\nexport async function createReleaseContext(dependency, dependentNames, context) {\n  let releaseContextCreated = false;\n\n  const { log, releaseContextMap } = context,\n        dependencyName = dependency.getName(),\n        releaseName = dependencyName, ///\n        releaseContext = releaseContextMap[releaseName] || null;\n\n  if (releaseContext !== null) {\n    const releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);\n\n    if (releaseMatchesDependency) {\n      log.debug(`The '${releaseName}' context has already been created.`);\n\n      releaseContextCreated = true;\n    }\n  } else {\n    const dependencyString = dependency.asString(),\n          dependentNamesLength = dependentNames.length;\n\n    if (dependentNamesLength === 0) {\n      log.info(`Creating the '${releaseName}' context...`);\n    } else {\n      const lastDependentName = last(dependentNames),\n            dependentName = lastDependentName;  ///\n\n      log.info(`Creating the '${releaseName}' context given the '${dependentName}' dependant's '${dependencyString}' dependency...`);\n    }\n\n    const { releaseContextFromDependency } = context,\n          releaseContext = await releaseContextFromDependency(dependency, context);\n\n    if (releaseContext !== null) {\n      const releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);\n\n      if (releaseMatchesDependency) {\n        releaseContextMap[releaseName] = releaseContext;\n\n        const dependencyReleaseContextsCreated = await createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context);\n\n        if (dependencyReleaseContextsCreated) {\n          releaseContextCreated = true;\n        }\n      }\n    } else {\n      const dependencyName = dependency.getName(),\n            releaseName = dependencyName; ///\n\n      log.warning(`The '${releaseName}' context could not be created. Perhaps the 'meta.json' file is missing or invalid. Or there could be a dependency mismatch.`);\n    }\n\n    releaseContextCreated ?\n      log.debug(`...created the '${releaseName}' context.`) :\n        log.warning(`...unable to create the '${releaseName}' context.`);\n  }\n\n  return releaseContextCreated;\n}\n\nexport async function verifyReleaseContext(releaseName, dependentName, dependentReleased, releaseContextMap) {\n  let releaseContextVerifies = false;\n\n  const releaseContext = releaseContextMap[releaseName];\n\n  if (releaseContext !== null) {\n    const released = releaseContext.isReleased();\n\n    if (released) {\n      releaseContextVerifies = true;\n    } else {\n      if (dependentReleased) {\n        releaseContext.warning(`The '${releaseName}' project cannot be verifies because its '${dependentName}' dependent is a package.`);\n      } else {\n        const dependentName = releaseName,  ///\n              dependentReleased = released, ///\n              dependencyReleaseContextsVerify = await verifyDependencyReleaseContexts(releaseContext, dependentName, dependentReleased, releaseContextMap);\n\n        if (dependencyReleaseContextsVerify) {\n          const releaseContextVerified = releaseContext.hasVerified();\n\n          if (releaseContextVerified) {\n            releaseContextVerifies = true;\n          } else {\n            releaseContext.info(`Verifying the '${releaseName}' project...`);\n\n            const verifies = await releaseContext.verify();\n\n            if (verifies) {\n              releaseContext.info(`...verified the '${releaseName}' project.`);\n\n              releaseContextVerifies = true;\n            }\n          }\n        }\n      }\n    }\n  }\n\n  return releaseContextVerifies;\n}\n\nexport default {\n  createReleaseContext,\n  verifyReleaseContext,\n  initialiseReleaseContext\n};\n\nasync function createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context) {\n  let dependencyReleaseContextsCreated;\n\n  const dependencyName = dependency.getName(),\n        dependencies = releaseContext.getDependencies();\n\n  dependentNames = [ ...dependentNames, dependencyName ];  ///\n\n  dependencyReleaseContextsCreated = await asyncEveryDependency(dependencies, async (dependency) => {\n    const cyclicDependencyExists = checkCyclicDependencyExists(dependency, dependentNames, context);\n\n    if (!cyclicDependencyExists) {\n      const releaseContextCreated = await createReleaseContext(dependency, dependentNames, context);\n\n      if (releaseContextCreated) {\n        return true;\n      }\n    }\n  });\n\n  return dependencyReleaseContextsCreated;\n}\n\nasync function verifyDependencyReleaseContexts(releaseContext, dependentName, dependentReleased, releaseContextMap) {\n  const dependencies = releaseContext.getDependencies(),\n        dependencyReleaseContextsVerify = await asyncEveryDependency(dependencies, async (dependency) => {\n          const name = dependency.getName(),\n                releaseName = name, ///\n                releaseContextVerifies = await verifyReleaseContext(releaseName, dependentName, dependentReleased, releaseContextMap);\n\n          if (releaseContextVerifies) {\n            return true;\n          }\n        });\n\n  return dependencyReleaseContextsVerify;\n}\n\nfunction retrieveReleaseContexts(releaseContext, releaseContextMap) {\n  const releaseContexts = [],\n        remainingReleaseContext = releaseContext,  ///\n        remainingReleaseContexts = [\n          remainingReleaseContext\n        ];\n\n  let remainingReleaseContextsLength = remainingReleaseContexts.length;\n\n  while (remainingReleaseContextsLength > 0) {\n    const remainingReleaseContext = remainingReleaseContexts.shift(),\n          releaseContext = remainingReleaseContext;  ///\n\n    releaseContexts.push(releaseContext);\n\n    const dependencies = releaseContext.getDependencies();\n\n    dependencies.forEachDependency((dependency) => {\n      const dependencyName = dependency.getName(),\n            releaseName = dependencyName, ///\n            releaseContext = releaseContextMap[releaseName],\n            releaseContextsIncludesReleaseContext = releaseContexts.includes(releaseContext),\n            remainingReleaseContextsIncludesReleaseContext = remainingReleaseContexts.includes(releaseContext);\n\n      if (!releaseContextsIncludesReleaseContext && !remainingReleaseContextsIncludesReleaseContext) {\n        const remainingReleaseContext = releaseContext; ///\n\n        remainingReleaseContexts.push(remainingReleaseContext);\n      }\n    });\n\n    remainingReleaseContextsLength = remainingReleaseContexts.length;\n  }\n\n  return releaseContexts;\n}\n\nfunction checkCyclicDependencyExists(dependency, dependentNames, context) {\n  const dependencyName = dependency.getName(),\n        dependentNamesIncludesDependencyName = dependentNames.includes(dependencyName),\n        cyclicDependencyExists = dependentNamesIncludesDependencyName;  ///\n\n  if (cyclicDependencyExists) {\n    const { log } = context,\n          firstDependentName = first(dependentNames),\n          dependencyNames = [  ///\n            ...dependentNames,\n            firstDependentName\n          ],\n          dependencyNamesString = dependencyNames.join(`' -> '`);\n\n    log.warning(`There is a cyclic dependency, '${dependencyNamesString}'.`);\n  }\n\n  return cyclicDependencyExists;\n}\n\nfunction checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context) {\n  let releaseMatchesDependency = true;\n\n  const shortenedVersion = dependency.getShortedVersion();\n\n  if (shortenedVersion !== null) {\n    const entriesMatchShortenedVersion = releaseContext.matchShortenedVersion(shortenedVersion);\n\n    if (!entriesMatchShortenedVersion) {\n      const { log } = context,\n            version = releaseContext.getVersion(),\n            lastDependentName = last(dependentNames),\n            dependentName = lastDependentName,  ///\n            versionString = version.toString(),\n            dependencyString = dependency.asString();\n\n      log.warning(`The '${dependentName}' dependent requires the '${dependencyString}' dependency but a context with version '${versionString}' was provided.`);\n\n      releaseMatchesDependency = false;\n    }\n  }\n\n  return releaseMatchesDependency;\n}\n\nfunction initialiseDependencyReleaseContexts(dependency, releaseContext, context) {\n  const dependencies = releaseContext.getDependencies();\n\n  dependencies.forEachDependency((dependency) => {  ///\n    initialiseReleaseContext(dependency, context);\n  });\n}\n"],"names":["createReleaseContext","initialiseReleaseContext","verifyReleaseContext","last","arrayUtilities","dependency","context","log","releaseContextMap","dependencyName","getName","releaseName","releaseContext","warning","releaseContextInitialised","isInitialised","initialiseDependencyReleaseContexts","releaseContexts","retrieveReleaseContexts","info","FileContextFromFilePath","initialise","debug","dependentNames","releaseContextCreated","releaseMatchesDependency","checkReleaseMatchesDependency","dependencyString","asString","dependentNamesLength","length","lastDependentName","dependentName","releaseContextFromDependency","dependencyReleaseContextsCreated","createDependencyReleaseContexts","dependentReleased","releaseContextVerifies","released","isReleased","dependencyReleaseContextsVerify","verifyDependencyReleaseContexts","releaseContextVerified","hasVerified","verifies","verify","dependencies","getDependencies","asyncEveryDependency","cyclicDependencyExists","checkCyclicDependencyExists","name","remainingReleaseContext","remainingReleaseContexts","remainingReleaseContextsLength","shift","push","forEachDependency","releaseContextsIncludesReleaseContext","includes","remainingReleaseContextsIncludesReleaseContext","dependentNamesIncludesDependencyName","firstDependentName","first","dependencyNames","dependencyNamesString","join","shortenedVersion","getShortedVersion","entriesMatchShortenedVersion","matchShortenedVersion","version","getVersion","versionString","toString"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/verification.js"],"sourcesContent":["\"use strict\";\n\nimport { DirectedGraph } from \"occam-directed-graphs\";\nimport { arrayUtilities } from \"necessary\";\n\nimport {  SINGLE_SPACE} from \"../constants\";\nimport { asyncEveryDependency } from \"../utilities/dependency\";\n\nconst { first, last } = arrayUtilities;\n\nexport async function createReleaseContexts(dependency, context) {\n  let releaseContextsCreated = false;\n\n  const dependentNames = [],\n        releaseContextCreated = await createReleaseContext(dependency, dependentNames, context);\n\n  if (releaseContextCreated) {\n    releaseContextsCreated = true;\n  }\n\n  return releaseContextsCreated;\n}\n\nexport function initialiseReleaseContexts(dependency, context) {\n  let releaseContextsInitialised = false;\n\n  const directedGraph = DirectedGraph.fromNothing(),\n        visitedDependencyNames = [];\n\n  addDependencyRelations(dependency, directedGraph, visitedDependencyNames, context);\n\n  const cyclicDependenciesPresent = checkCyclicDependenciesPresent(directedGraph, context);\n\n  if (!cyclicDependenciesPresent) {\n    const { releaseContextMap } = context,\n          releaseNames = Object.keys(releaseContextMap),\n          orderedVertexNames = directedGraph.getOrderedVertexNames(),\n          orderedDependencyNames = orderedVertexNames;  ///\n\n    releaseNames.forEach((releaseName) => {\n      const releaseContext = releaseContextMap[releaseName];\n\n      initialiseReleaseContext(releaseContext, orderedDependencyNames, context);\n    });\n\n    releaseContextsInitialised = true;\n  }\n\n  return releaseContextsInitialised;\n}\n\nexport async function verifyReleaseContexts(dependency, context) {\n  let releaseContextsVerify = false;\n\n  const dependencyName = dependency.getName(),\n        releaseName = dependencyName, ///\n        dependentName = null,\n        dependentReleased = false,\n        releaseContextVerifies = await verifyReleaseContext(releaseName, dependentName, dependentReleased, context);\n\n  if (releaseContextVerifies) {\n    releaseContextsVerify = true;\n  }\n\n  return releaseContextsVerify;\n}\n\nexport default {\n  createReleaseContexts,\n  initialiseReleaseContexts,\n  verifyReleaseContexts\n};\n\nfunction addDependencyRelations(dependency, directedGraph, visitedDependencyNames, context) {\n  const dependencyName = dependency.getName(),\n        visitedDependencyNameIncludesDependencyName = visitedDependencyNames.includes(dependencyName);\n\n  if (visitedDependencyNameIncludesDependencyName) {\n    return;\n  }\n\n  const visiteddependencyName = dependencyName; ///\n\n  visitedDependencyNames.push(visiteddependencyName);\n\n  const { log, releaseContextMap } = context,\n        releaseName = dependencyName, ///\n        releaseContext = releaseContextMap[releaseName] || null;\n\n  if (releaseContext === null) {\n    const dependencyString = dependency.getString();\n\n    log.warning(`No package context has been created for the '${dependencyString}' dependency. `);\n\n    return;\n  }\n\n  const dependencies = releaseContext.getDependencies(),\n        targetVertexName = dependencyName;  ///\n\n  dependencies.forEachDependency((dependency) => {\n    const dependencyName = dependency.getName(),\n      sourceVertexName = dependencyName;  ///\n\n    directedGraph.addEdgeBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);\n\n    addDependencyRelations(dependency, directedGraph, visitedDependencyNames, context);\n  });\n}\n\nfunction initialiseReleaseContext(releaseContext, orderedDependencyNames, context) {\n  const { log, releaseContextMap, FileContextFromFilePath } = context,\n        releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap),\n        releaseContextName = releaseContext.getName();\n\n  releaseContexts.sort((releaseContextA, releaseContextB) => {\n    const releaseContextAName = releaseContextA.getName(),\n          releaseContextBName = releaseContextB.getName(),\n          dependencyNameA = releaseContextAName,  ///\n          dependencyNameB = releaseContextBName,  ///\n          indexA = orderedDependencyNames.indexOf(dependencyNameA),\n          indexB = orderedDependencyNames.indexOf(dependencyNameB);\n\n    return (indexA - indexB);\n  });\n\n  log.info(`Initialising the '${releaseContextName}' package context...`);\n\n  releaseContext.initialise(releaseContexts, FileContextFromFilePath);\n\n  log.debug(`...initialised the '${releaseContextName}' package context.`);\n}\n\nasync function createReleaseContext(dependency, dependentNames, context) {\n  let releaseContextCreated = false;\n\n  const { log, releaseContextMap, releaseContextFromDependency } = context,\n        dependencyName = dependency.getName(),\n        releaseName = dependencyName, ///\n        releaseContext = releaseContextMap[releaseName] || null;\n\n  if (releaseContext !== null) {\n    const releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);\n\n    if (releaseMatchesDependency) {\n      log.debug(`The '${releaseName}' package context has already been created.`);\n\n      releaseContextCreated = true;\n    }\n  } else {\n    const dependencyString = dependency.asString(),\n          dependentNamesLength = dependentNames.length;\n\n    if (dependentNamesLength === 0) {\n      log.info(`Creating the '${releaseName}' package context...`);\n    } else {\n      const lastDependentName = last(dependentNames),\n            dependentName = lastDependentName;  ///\n\n      log.info(`Creating the '${releaseName}' package context given the '${dependentName}' dependant's '${dependencyString}' dependency...`);\n    }\n\n    const releaseContext = await releaseContextFromDependency(dependency, context);\n\n    if (releaseContext !== null) {\n      const releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);\n\n      if (releaseMatchesDependency) {\n        releaseContextMap[releaseName] = releaseContext;\n\n        const dependencyReleaseContextsCreated = await createDependencyReleaseContexts(releaseContext, dependency, dependentNames, context);\n\n        if (dependencyReleaseContextsCreated) {\n          releaseContextCreated = true;\n        }\n      }\n    } else {\n      const dependencyName = dependency.getName(),\n            releaseName = dependencyName; ///\n\n      log.warning(`The '${releaseName}' package context could not be created. Perhaps the 'meta.json' file is missing or invalid. Or there could be a dependency mismatch.`);\n    }\n\n    releaseContextCreated ?\n      log.debug(`...created the '${releaseName}' package context.`) :\n        log.warning(`...unable to create the '${releaseName}' package context.`);\n  }\n\n  return releaseContextCreated;\n}\n\nasync function verifyReleaseContext(releaseName, dependentName, dependentReleased, releaseContextMap) {\n  let releaseContextVerifies = false;\n\n  const releaseContext = releaseContextMap[releaseName] || null;\n\n  if (releaseContext !== null) {\n    const released = releaseContext.isReleased();\n\n    if (released) {\n      releaseContextVerifies = true;\n    } else {\n      if (dependentReleased) {\n        releaseContext.warning(`The '${releaseName}' project cannot be verified because its '${dependentName}' dependent is a package.`);\n      } else {\n        const dependentName = releaseName,  ///\n              dependentReleased = released, ///\n              dependencyReleaseContextsVerify = await verifyDependencyReleaseContexts(releaseContext, dependentName, dependentReleased, releaseContextMap);\n\n        if (dependencyReleaseContextsVerify) {\n          const releaseContextVerified = releaseContext.hasVerified();\n\n          if (releaseContextVerified) {\n            releaseContextVerifies = true;\n          } else {\n            releaseContext.info(`Verifying the '${releaseName}' project...`);\n\n            const verifies = await releaseContext.verify();\n\n            if (verifies) {\n              releaseContext.info(`...verified the '${releaseName}' project.`);\n\n              releaseContextVerifies = true;\n            }\n          }\n        }\n      }\n    }\n  }\n\n  return releaseContextVerifies;\n}\n\nasync function createDependencyReleaseContexts(releaseContext, dependency, dependentNames, context) {\n  let dependencyReleaseContextsCreated;\n\n  const name = releaseContext.getName(),\n        dependencies = releaseContext.getDependencies(),\n        dependencyName = name;  ///\n\n  dependentNames = [ ...dependentNames, dependencyName ];  ///\n\n  dependencyReleaseContextsCreated = await asyncEveryDependency(dependencies, async (dependency) => {\n    const releaseContextCreated = await createReleaseContext(dependency, dependentNames, context);\n\n    if (releaseContextCreated) {\n      return true;\n    }\n  });\n\n  return dependencyReleaseContextsCreated;\n}\n\nasync function verifyDependencyReleaseContexts(releaseContext, dependentName, dependentReleased, releaseContextMap) {\n  const dependencies = releaseContext.getDependencies(),\n        dependencyReleaseContextsVerify = await asyncEveryDependency(dependencies, async (dependency) => {\n          const name = dependency.getName(),\n                releaseName = name, ///\n                releaseContextVerifies = await verifyReleaseContext(releaseName, dependentName, dependentReleased, releaseContextMap);\n\n          if (releaseContextVerifies) {\n            return true;\n          }\n        });\n\n  return dependencyReleaseContextsVerify;\n}\n\nfunction retrieveReleaseContexts(releaseContext, releaseContextMap, releaseContexts = []) {\n  const releaseContextsIncludesReleaseContext = releaseContexts.includes(releaseContext);\n\n  if (releaseContextsIncludesReleaseContext) {\n    return;\n  }\n\n  releaseContexts.push(releaseContext);\n\n  const dependencies = releaseContext.getDependencies();\n\n  dependencies.forEachDependency((dependency) => {\n    const dependencyName = dependency.getName(),\n          releaseName = dependencyName, ///\n          releaseContext = releaseContextMap[releaseName];\n\n    retrieveReleaseContexts(releaseContext, releaseContextMap, releaseContexts);\n  });\n\n  return releaseContexts;\n}\n\nfunction checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context) {\n  let releaseMatchesDependency = true;\n\n  const shortenedVersion = dependency.getShortenedVersion();\n\n  if (shortenedVersion !== null) {\n    const entriesMatchShortenedVersion = releaseContext.matchShortenedVersion(shortenedVersion);\n\n    if (!entriesMatchShortenedVersion) {\n      const { log } = context,\n            version = releaseContext.getVersion(),\n            lastDependentName = last(dependentNames),\n            dependentName = lastDependentName,  ///\n            versionString = version.toString(),\n            dependencyString = dependency.asString();\n\n      log.warning(`The '${dependentName}' dependent requires the '${dependencyString}' dependency but a context with version '${versionString}' was provided.`);\n\n      releaseMatchesDependency = false;\n    }\n  }\n\n  return releaseMatchesDependency;\n}\n\nfunction checkCyclicDependenciesPresent(directedGraph, context) {\n  let cyclicDependenciesPresent = false;\n\n  const firstCycle = directedGraph.getFirstCycle();\n\n  if (firstCycle !== null) {\n    const { log } = context,\n          vertexNames = firstCycle.getVertexNames(),\n          dependencyNames = vertexNames,  ///\n          firstDependencyName = first(dependencyNames),\n          cyclicDependencyNames = [\n            ...dependencyNames,\n            firstDependencyName\n          ],\n          cycleString = cyclicDependencyNames.join(SINGLE_SPACE);\n\n    log.warning(`There is at least one '${cycleString}'. cyclic dependency`);\n\n    cyclicDependenciesPresent = true;\n  }\n\n  return cyclicDependenciesPresent;\n}\n"],"names":["createReleaseContexts","initialiseReleaseContexts","verifyReleaseContexts","first","last","arrayUtilities","dependency","context","releaseContextsCreated","dependentNames","releaseContextCreated","createReleaseContext","releaseContextsInitialised","directedGraph","DirectedGraph","fromNothing","visitedDependencyNames","addDependencyRelations","cyclicDependenciesPresent","checkCyclicDependenciesPresent","releaseContextMap","releaseNames","Object","keys","orderedVertexNames","getOrderedVertexNames","orderedDependencyNames","forEach","releaseName","releaseContext","initialiseReleaseContext","releaseContextsVerify","dependencyName","getName","dependentName","dependentReleased","releaseContextVerifies","verifyReleaseContext","visitedDependencyNameIncludesDependencyName","includes","visiteddependencyName","push","log","dependencyString","getString","warning","dependencies","getDependencies","targetVertexName","forEachDependency","sourceVertexName","addEdgeBySourceVertexNameAndTargetVertexName","FileContextFromFilePath","releaseContexts","retrieveReleaseContexts","releaseContextName","sort","releaseContextA","releaseContextB","releaseContextAName","releaseContextBName","dependencyNameA","dependencyNameB","indexA","indexOf","indexB","info","initialise","debug","releaseContextFromDependency","releaseMatchesDependency","checkReleaseMatchesDependency","asString","dependentNamesLength","length","lastDependentName","dependencyReleaseContextsCreated","createDependencyReleaseContexts","released","isReleased","dependencyReleaseContextsVerify","verifyDependencyReleaseContexts","releaseContextVerified","hasVerified","verifies","verify","name","asyncEveryDependency","releaseContextsIncludesReleaseContext","shortenedVersion","getShortenedVersion","entriesMatchShortenedVersion","matchShortenedVersion","version","getVersion","versionString","toString","firstCycle","getFirstCycle","vertexNames","getVertexNames","dependencyNames","firstDependencyName","cyclicDependencyNames","cycleString","join","SINGLE_SPACE"],"mappings":"AAAA;;;;;;;;;;;QAUsBA;eAAAA;;QAyDtB;eAAA;;QA5CgBC;eAAAA;;QA4BMC;eAAAA;;;qCAjDQ;2BACC;2BAEF;4BACQ;AAErC,MAAM,EAAEC,KAAK,EAAEC,IAAI,EAAE,GAAGC,yBAAc;AAE/B,eAAeL,sBAAsBM,UAAU,EAAEC,OAAO;IAC7D,IAAIC,yBAAyB;IAE7B,MAAMC,iBAAiB,EAAE,EACnBC,wBAAwB,MAAMC,qBAAqBL,YAAYG,gBAAgBF;IAErF,IAAIG,uBAAuB;QACzBF,yBAAyB;IAC3B;IAEA,OAAOA;AACT;AAEO,SAASP,0BAA0BK,UAAU,EAAEC,OAAO;IAC3D,IAAIK,6BAA6B;IAEjC,MAAMC,gBAAgBC,kCAAa,CAACC,WAAW,IACzCC,yBAAyB,EAAE;IAEjCC,uBAAuBX,YAAYO,eAAeG,wBAAwBT;IAE1E,MAAMW,4BAA4BC,+BAA+BN,eAAeN;IAEhF,IAAI,CAACW,2BAA2B;QAC9B,MAAM,EAAEE,iBAAiB,EAAE,GAAGb,SACxBc,eAAeC,OAAOC,IAAI,CAACH,oBAC3BI,qBAAqBX,cAAcY,qBAAqB,IACxDC,yBAAyBF,oBAAqB,GAAG;QAEvDH,aAAaM,OAAO,CAAC,CAACC;YACpB,MAAMC,iBAAiBT,iBAAiB,CAACQ,YAAY;YAErDE,yBAAyBD,gBAAgBH,wBAAwBnB;QACnE;QAEAK,6BAA6B;IAC/B;IAEA,OAAOA;AACT;AAEO,eAAeV,sBAAsBI,UAAU,EAAEC,OAAO;IAC7D,IAAIwB,wBAAwB;IAE5B,MAAMC,iBAAiB1B,WAAW2B,OAAO,IACnCL,cAAcI,gBACdE,gBAAgB,MAChBC,oBAAoB,OACpBC,yBAAyB,MAAMC,qBAAqBT,aAAaM,eAAeC,mBAAmB5B;IAEzG,IAAI6B,wBAAwB;QAC1BL,wBAAwB;IAC1B;IAEA,OAAOA;AACT;MAEA,WAAe;IACb/B;IACAC;IACAC;AACF;AAEA,SAASe,uBAAuBX,UAAU,EAAEO,aAAa,EAAEG,sBAAsB,EAAET,OAAO;IACxF,MAAMyB,iBAAiB1B,WAAW2B,OAAO,IACnCK,8CAA8CtB,uBAAuBuB,QAAQ,CAACP;IAEpF,IAAIM,6CAA6C;QAC/C;IACF;IAEA,MAAME,wBAAwBR,gBAAgB,GAAG;IAEjDhB,uBAAuByB,IAAI,CAACD;IAE5B,MAAM,EAAEE,GAAG,EAAEtB,iBAAiB,EAAE,GAAGb,SAC7BqB,cAAcI,gBACdH,iBAAiBT,iBAAiB,CAACQ,YAAY,IAAI;IAEzD,IAAIC,mBAAmB,MAAM;QAC3B,MAAMc,mBAAmBrC,WAAWsC,SAAS;QAE7CF,IAAIG,OAAO,CAAC,CAAC,6CAA6C,EAAEF,iBAAiB,cAAc,CAAC;QAE5F;IACF;IAEA,MAAMG,eAAejB,eAAekB,eAAe,IAC7CC,mBAAmBhB,gBAAiB,GAAG;IAE7Cc,aAAaG,iBAAiB,CAAC,CAAC3C;QAC9B,MAAM0B,iBAAiB1B,WAAW2B,OAAO,IACvCiB,mBAAmBlB,gBAAiB,GAAG;QAEzCnB,cAAcsC,4CAA4C,CAACD,kBAAkBF;QAE7E/B,uBAAuBX,YAAYO,eAAeG,wBAAwBT;IAC5E;AACF;AAEA,SAASuB,yBAAyBD,cAAc,EAAEH,sBAAsB,EAAEnB,OAAO;IAC/E,MAAM,EAAEmC,GAAG,EAAEtB,iBAAiB,EAAEgC,uBAAuB,EAAE,GAAG7C,SACtD8C,kBAAkBC,wBAAwBzB,gBAAgBT,oBAC1DmC,qBAAqB1B,eAAeI,OAAO;IAEjDoB,gBAAgBG,IAAI,CAAC,CAACC,iBAAiBC;QACrC,MAAMC,sBAAsBF,gBAAgBxB,OAAO,IAC7C2B,sBAAsBF,gBAAgBzB,OAAO,IAC7C4B,kBAAkBF,qBAClBG,kBAAkBF,qBAClBG,SAASrC,uBAAuBsC,OAAO,CAACH,kBACxCI,SAASvC,uBAAuBsC,OAAO,CAACF;QAE9C,OAAQC,SAASE;IACnB;IAEAvB,IAAIwB,IAAI,CAAC,CAAC,kBAAkB,EAAEX,mBAAmB,oBAAoB,CAAC;IAEtE1B,eAAesC,UAAU,CAACd,iBAAiBD;IAE3CV,IAAI0B,KAAK,CAAC,CAAC,oBAAoB,EAAEb,mBAAmB,kBAAkB,CAAC;AACzE;AAEA,eAAe5C,qBAAqBL,UAAU,EAAEG,cAAc,EAAEF,OAAO;IACrE,IAAIG,wBAAwB;IAE5B,MAAM,EAAEgC,GAAG,EAAEtB,iBAAiB,EAAEiD,4BAA4B,EAAE,GAAG9D,SAC3DyB,iBAAiB1B,WAAW2B,OAAO,IACnCL,cAAcI,gBACdH,iBAAiBT,iBAAiB,CAACQ,YAAY,IAAI;IAEzD,IAAIC,mBAAmB,MAAM;QAC3B,MAAMyC,2BAA2BC,8BAA8B1C,gBAAgBvB,YAAYG,gBAAgBF;QAE3G,IAAI+D,0BAA0B;YAC5B5B,IAAI0B,KAAK,CAAC,CAAC,KAAK,EAAExC,YAAY,2CAA2C,CAAC;YAE1ElB,wBAAwB;QAC1B;IACF,OAAO;QACL,MAAMiC,mBAAmBrC,WAAWkE,QAAQ,IACtCC,uBAAuBhE,eAAeiE,MAAM;QAElD,IAAID,yBAAyB,GAAG;YAC9B/B,IAAIwB,IAAI,CAAC,CAAC,cAAc,EAAEtC,YAAY,oBAAoB,CAAC;QAC7D,OAAO;YACL,MAAM+C,oBAAoBvE,KAAKK,iBACzByB,gBAAgByC,mBAAoB,GAAG;YAE7CjC,IAAIwB,IAAI,CAAC,CAAC,cAAc,EAAEtC,YAAY,6BAA6B,EAAEM,cAAc,eAAe,EAAES,iBAAiB,eAAe,CAAC;QACvI;QAEA,MAAMd,iBAAiB,MAAMwC,6BAA6B/D,YAAYC;QAEtE,IAAIsB,mBAAmB,MAAM;YAC3B,MAAMyC,2BAA2BC,8BAA8B1C,gBAAgBvB,YAAYG,gBAAgBF;YAE3G,IAAI+D,0BAA0B;gBAC5BlD,iBAAiB,CAACQ,YAAY,GAAGC;gBAEjC,MAAM+C,mCAAmC,MAAMC,gCAAgChD,gBAAgBvB,YAAYG,gBAAgBF;gBAE3H,IAAIqE,kCAAkC;oBACpClE,wBAAwB;gBAC1B;YACF;QACF,OAAO;YACL,MAAMsB,iBAAiB1B,WAAW2B,OAAO,IACnCL,cAAcI,gBAAgB,GAAG;YAEvCU,IAAIG,OAAO,CAAC,CAAC,KAAK,EAAEjB,YAAY,oIAAoI,CAAC;QACvK;QAEAlB,wBACEgC,IAAI0B,KAAK,CAAC,CAAC,gBAAgB,EAAExC,YAAY,kBAAkB,CAAC,IAC1Dc,IAAIG,OAAO,CAAC,CAAC,yBAAyB,EAAEjB,YAAY,kBAAkB,CAAC;IAC7E;IAEA,OAAOlB;AACT;AAEA,eAAe2B,qBAAqBT,WAAW,EAAEM,aAAa,EAAEC,iBAAiB,EAAEf,iBAAiB;IAClG,IAAIgB,yBAAyB;IAE7B,MAAMP,iBAAiBT,iBAAiB,CAACQ,YAAY,IAAI;IAEzD,IAAIC,mBAAmB,MAAM;QAC3B,MAAMiD,WAAWjD,eAAekD,UAAU;QAE1C,IAAID,UAAU;YACZ1C,yBAAyB;QAC3B,OAAO;YACL,IAAID,mBAAmB;gBACrBN,eAAegB,OAAO,CAAC,CAAC,KAAK,EAAEjB,YAAY,0CAA0C,EAAEM,cAAc,yBAAyB,CAAC;YACjI,OAAO;gBACL,MAAMA,gBAAgBN,aAChBO,oBAAoB2C,UACpBE,kCAAkC,MAAMC,gCAAgCpD,gBAAgBK,eAAeC,mBAAmBf;gBAEhI,IAAI4D,iCAAiC;oBACnC,MAAME,yBAAyBrD,eAAesD,WAAW;oBAEzD,IAAID,wBAAwB;wBAC1B9C,yBAAyB;oBAC3B,OAAO;wBACLP,eAAeqC,IAAI,CAAC,CAAC,eAAe,EAAEtC,YAAY,YAAY,CAAC;wBAE/D,MAAMwD,WAAW,MAAMvD,eAAewD,MAAM;wBAE5C,IAAID,UAAU;4BACZvD,eAAeqC,IAAI,CAAC,CAAC,iBAAiB,EAAEtC,YAAY,UAAU,CAAC;4BAE/DQ,yBAAyB;wBAC3B;oBACF;gBACF;YACF;QACF;IACF;IAEA,OAAOA;AACT;AAEA,eAAeyC,gCAAgChD,cAAc,EAAEvB,UAAU,EAAEG,cAAc,EAAEF,OAAO;IAChG,IAAIqE;IAEJ,MAAMU,OAAOzD,eAAeI,OAAO,IAC7Ba,eAAejB,eAAekB,eAAe,IAC7Cf,iBAAiBsD,MAAO,GAAG;IAEjC7E,iBAAiB;WAAKA;QAAgBuB;KAAgB,EAAG,GAAG;IAE5D4C,mCAAmC,MAAMW,IAAAA,gCAAoB,EAACzC,cAAc,OAAOxC;QACjF,MAAMI,wBAAwB,MAAMC,qBAAqBL,YAAYG,gBAAgBF;QAErF,IAAIG,uBAAuB;YACzB,OAAO;QACT;IACF;IAEA,OAAOkE;AACT;AAEA,eAAeK,gCAAgCpD,cAAc,EAAEK,aAAa,EAAEC,iBAAiB,EAAEf,iBAAiB;IAChH,MAAM0B,eAAejB,eAAekB,eAAe,IAC7CiC,kCAAkC,MAAMO,IAAAA,gCAAoB,EAACzC,cAAc,OAAOxC;QAChF,MAAMgF,OAAOhF,WAAW2B,OAAO,IACzBL,cAAc0D,MACdlD,yBAAyB,MAAMC,qBAAqBT,aAAaM,eAAeC,mBAAmBf;QAEzG,IAAIgB,wBAAwB;YAC1B,OAAO;QACT;IACF;IAEN,OAAO4C;AACT;AAEA,SAAS1B,wBAAwBzB,cAAc,EAAET,iBAAiB,EAAEiC,kBAAkB,EAAE;IACtF,MAAMmC,wCAAwCnC,gBAAgBd,QAAQ,CAACV;IAEvE,IAAI2D,uCAAuC;QACzC;IACF;IAEAnC,gBAAgBZ,IAAI,CAACZ;IAErB,MAAMiB,eAAejB,eAAekB,eAAe;IAEnDD,aAAaG,iBAAiB,CAAC,CAAC3C;QAC9B,MAAM0B,iBAAiB1B,WAAW2B,OAAO,IACnCL,cAAcI,gBACdH,iBAAiBT,iBAAiB,CAACQ,YAAY;QAErD0B,wBAAwBzB,gBAAgBT,mBAAmBiC;IAC7D;IAEA,OAAOA;AACT;AAEA,SAASkB,8BAA8B1C,cAAc,EAAEvB,UAAU,EAAEG,cAAc,EAAEF,OAAO;IACxF,IAAI+D,2BAA2B;IAE/B,MAAMmB,mBAAmBnF,WAAWoF,mBAAmB;IAEvD,IAAID,qBAAqB,MAAM;QAC7B,MAAME,+BAA+B9D,eAAe+D,qBAAqB,CAACH;QAE1E,IAAI,CAACE,8BAA8B;YACjC,MAAM,EAAEjD,GAAG,EAAE,GAAGnC,SACVsF,UAAUhE,eAAeiE,UAAU,IACnCnB,oBAAoBvE,KAAKK,iBACzByB,gBAAgByC,mBAChBoB,gBAAgBF,QAAQG,QAAQ,IAChCrD,mBAAmBrC,WAAWkE,QAAQ;YAE5C9B,IAAIG,OAAO,CAAC,CAAC,KAAK,EAAEX,cAAc,0BAA0B,EAAES,iBAAiB,yCAAyC,EAAEoD,cAAc,eAAe,CAAC;YAExJzB,2BAA2B;QAC7B;IACF;IAEA,OAAOA;AACT;AAEA,SAASnD,+BAA+BN,aAAa,EAAEN,OAAO;IAC5D,IAAIW,4BAA4B;IAEhC,MAAM+E,aAAapF,cAAcqF,aAAa;IAE9C,IAAID,eAAe,MAAM;QACvB,MAAM,EAAEvD,GAAG,EAAE,GAAGnC,SACV4F,cAAcF,WAAWG,cAAc,IACvCC,kBAAkBF,aAClBG,sBAAsBnG,MAAMkG,kBAC5BE,wBAAwB;eACnBF;YACHC;SACD,EACDE,cAAcD,sBAAsBE,IAAI,CAACC,uBAAY;QAE3DhE,IAAIG,OAAO,CAAC,CAAC,uBAAuB,EAAE2D,YAAY,oBAAoB,CAAC;QAEvEtF,4BAA4B;IAC9B;IAEA,OAAOA;AACT"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-languages",
   "author": "James Smith",
-  "version": "0.0.128",
+  "version": "0.0.129",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-languages",
   "description": "Occam's common language functionality.",
@@ -12,6 +12,7 @@
   "dependencies": {
     "necessary": "^17.1.7",
     "occam-custom-grammars": "^6.0.17",
+    "occam-directed-graphs": "^3.0.87",
     "occam-parsers": "^23.1.50"
   },
   "devDependencies": {

package/src/utilities/verification.js

@@ -1,42 +1,140 @@
 "use strict";
 
+import { DirectedGraph } from "occam-directed-graphs";
 import { arrayUtilities } from "necessary";
 
+import {  SINGLE_SPACE} from "../constants";
 import { asyncEveryDependency } from "../utilities/dependency";
 
-const { last } = arrayUtilities;
+const { first, last } = arrayUtilities;
+
+export async function createReleaseContexts(dependency, context) {
+  let releaseContextsCreated = false;
+
+  const dependentNames = [],
+        releaseContextCreated = await createReleaseContext(dependency, dependentNames, context);
+
+  if (releaseContextCreated) {
+    releaseContextsCreated = true;
+  }
+
+  return releaseContextsCreated;
+}
+
+export function initialiseReleaseContexts(dependency, context) {
+  let releaseContextsInitialised = false;
+
+  const directedGraph = DirectedGraph.fromNothing(),
+        visitedDependencyNames = [];
+
+  addDependencyRelations(dependency, directedGraph, visitedDependencyNames, context);
+
+  const cyclicDependenciesPresent = checkCyclicDependenciesPresent(directedGraph, context);
+
+  if (!cyclicDependenciesPresent) {
+    const { releaseContextMap } = context,
+          releaseNames = Object.keys(releaseContextMap),
+          orderedVertexNames = directedGraph.getOrderedVertexNames(),
+          orderedDependencyNames = orderedVertexNames;  ///
+
+    releaseNames.forEach((releaseName) => {
+      const releaseContext = releaseContextMap[releaseName];
+
+      initialiseReleaseContext(releaseContext, orderedDependencyNames, context);
+    });
+
+    releaseContextsInitialised = true;
+  }
+
+  return releaseContextsInitialised;
+}
+
+export async function verifyReleaseContexts(dependency, context) {
+  let releaseContextsVerify = false;
+
+  const dependencyName = dependency.getName(),
+        releaseName = dependencyName, ///
+        dependentName = null,
+        dependentReleased = false,
+        releaseContextVerifies = await verifyReleaseContext(releaseName, dependentName, dependentReleased, context);
+
+  if (releaseContextVerifies) {
+    releaseContextsVerify = true;
+  }
+
+  return releaseContextsVerify;
+}
+
+export default {
+  createReleaseContexts,
+  initialiseReleaseContexts,
+  verifyReleaseContexts
+};
+
+function addDependencyRelations(dependency, directedGraph, visitedDependencyNames, context) {
+  const dependencyName = dependency.getName(),
+        visitedDependencyNameIncludesDependencyName = visitedDependencyNames.includes(dependencyName);
+
+  if (visitedDependencyNameIncludesDependencyName) {
+    return;
+  }
+
+  const visiteddependencyName = dependencyName; ///
+
+  visitedDependencyNames.push(visiteddependencyName);
 
-export function initialiseReleaseContext(dependency, context) {
   const { log, releaseContextMap } = context,
-        dependencyName = dependency.getName(),
         releaseName = dependencyName, ///
         releaseContext = releaseContextMap[releaseName] || null;
 
   if (releaseContext === null) {
-    log.warning(`Unable to initialise the '${dependencyName}' context because it has not been created.`);
-  } else {
-    const releaseContextInitialised = releaseContext.isInitialised();
+    const dependencyString = dependency.getString();
 
-    if (!releaseContextInitialised) {
-      initialiseDependencyReleaseContexts(dependency, releaseContext, context);
+    log.warning(`No package context has been created for the '${dependencyString}' dependency. `);
 
-      const releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
+    return;
+  }
 
-      log.info(`Initialising the '${dependencyName}' context...`);
+  const dependencies = releaseContext.getDependencies(),
+        targetVertexName = dependencyName;  ///
 
-      const { FileContextFromFilePath } = context;
+  dependencies.forEachDependency((dependency) => {
+    const dependencyName = dependency.getName(),
+      sourceVertexName = dependencyName;  ///
 
-      releaseContext.initialise(releaseContexts, FileContextFromFilePath);
+    directedGraph.addEdgeBySourceVertexNameAndTargetVertexName(sourceVertexName, targetVertexName);
 
-      log.debug(`...initialised the '${dependencyName}' context.`);
-    }
-  }
+    addDependencyRelations(dependency, directedGraph, visitedDependencyNames, context);
+  });
 }
 
-export async function createReleaseContext(dependency, dependentNames, context) {
+function initialiseReleaseContext(releaseContext, orderedDependencyNames, context) {
+  const { log, releaseContextMap, FileContextFromFilePath } = context,
+        releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap),
+        releaseContextName = releaseContext.getName();
+
+  releaseContexts.sort((releaseContextA, releaseContextB) => {
+    const releaseContextAName = releaseContextA.getName(),
+          releaseContextBName = releaseContextB.getName(),
+          dependencyNameA = releaseContextAName,  ///
+          dependencyNameB = releaseContextBName,  ///
+          indexA = orderedDependencyNames.indexOf(dependencyNameA),
+          indexB = orderedDependencyNames.indexOf(dependencyNameB);
+
+    return (indexA - indexB);
+  });
+
+  log.info(`Initialising the '${releaseContextName}' package context...`);
+
+  releaseContext.initialise(releaseContexts, FileContextFromFilePath);
+
+  log.debug(`...initialised the '${releaseContextName}' package context.`);
+}
+
+async function createReleaseContext(dependency, dependentNames, context) {
   let releaseContextCreated = false;
 
-  const { log, releaseContextMap } = context,
+  const { log, releaseContextMap, releaseContextFromDependency } = context,
         dependencyName = dependency.getName(),
         releaseName = dependencyName, ///
         releaseContext = releaseContextMap[releaseName] || null;
@@ -45,7 +143,7 @@ export async function createReleaseContext(dependency, dependentNames, context)
     const releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);
 
     if (releaseMatchesDependency) {
-      log.debug(`The '${releaseName}' context has already been created.`);
+      log.debug(`The '${releaseName}' package context has already been created.`);
 
       releaseContextCreated = true;
     }
@@ -54,16 +152,15 @@ export async function createReleaseContext(dependency, dependentNames, context)
           dependentNamesLength = dependentNames.length;
 
     if (dependentNamesLength === 0) {
-      log.info(`Creating the '${releaseName}' context...`);
+      log.info(`Creating the '${releaseName}' package context...`);
     } else {
       const lastDependentName = last(dependentNames),
             dependentName = lastDependentName;  ///
 
-      log.info(`Creating the '${releaseName}' context given the '${dependentName}' dependant's '${dependencyString}' dependency...`);
+      log.info(`Creating the '${releaseName}' package context given the '${dependentName}' dependant's '${dependencyString}' dependency...`);
     }
 
-    const { releaseContextFromDependency } = context,
-          releaseContext = await releaseContextFromDependency(dependency, context);
+    const releaseContext = await releaseContextFromDependency(dependency, context);
 
     if (releaseContext !== null) {
       const releaseMatchesDependency = checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context);
@@ -71,7 +168,7 @@ export async function createReleaseContext(dependency, dependentNames, context)
       if (releaseMatchesDependency) {
         releaseContextMap[releaseName] = releaseContext;
 
-        const dependencyReleaseContextsCreated = await createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context);
+        const dependencyReleaseContextsCreated = await createDependencyReleaseContexts(releaseContext, dependency, dependentNames, context);
 
         if (dependencyReleaseContextsCreated) {
           releaseContextCreated = true;
@@ -81,21 +178,21 @@ export async function createReleaseContext(dependency, dependentNames, context)
       const dependencyName = dependency.getName(),
             releaseName = dependencyName; ///
 
-      log.warning(`The '${releaseName}' context could not be created. Perhaps the 'meta.json' file is missing or invalid. Or there could be a dependency mismatch.`);
+      log.warning(`The '${releaseName}' package context could not be created. Perhaps the 'meta.json' file is missing or invalid. Or there could be a dependency mismatch.`);
     }
 
     releaseContextCreated ?
-      log.debug(`...created the '${releaseName}' context.`) :
-        log.warning(`...unable to create the '${releaseName}' context.`);
+      log.debug(`...created the '${releaseName}' package context.`) :
+        log.warning(`...unable to create the '${releaseName}' package context.`);
   }
 
   return releaseContextCreated;
 }
 
-export async function verifyReleaseContext(releaseName, dependentName, dependentReleased, releaseContextMap) {
+async function verifyReleaseContext(releaseName, dependentName, dependentReleased, releaseContextMap) {
   let releaseContextVerifies = false;
 
-  const releaseContext = releaseContextMap[releaseName];
+  const releaseContext = releaseContextMap[releaseName] || null;
 
   if (releaseContext !== null) {
     const released = releaseContext.isReleased();
@@ -104,7 +201,7 @@ export async function verifyReleaseContext(releaseName, dependentName, dependent
       releaseContextVerifies = true;
     } else {
       if (dependentReleased) {
-        releaseContext.warning(`The '${releaseName}' project cannot be verifies because its '${dependentName}' dependent is a package.`);
+        releaseContext.warning(`The '${releaseName}' project cannot be verified because its '${dependentName}' dependent is a package.`);
       } else {
         const dependentName = releaseName,  ///
               dependentReleased = released, ///
@@ -134,29 +231,20 @@ export async function verifyReleaseContext(releaseName, dependentName, dependent
   return releaseContextVerifies;
 }
 
-export default {
-  createReleaseContext,
-  verifyReleaseContext,
-  initialiseReleaseContext
-};
-
-async function createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context) {
+async function createDependencyReleaseContexts(releaseContext, dependency, dependentNames, context) {
   let dependencyReleaseContextsCreated;
 
-  const dependencyName = dependency.getName(),
-        dependencies = releaseContext.getDependencies();
+  const name = releaseContext.getName(),
+        dependencies = releaseContext.getDependencies(),
+        dependencyName = name;  ///
 
   dependentNames = [ ...dependentNames, dependencyName ];  ///
 
   dependencyReleaseContextsCreated = await asyncEveryDependency(dependencies, async (dependency) => {
-    const cyclicDependencyExists = checkCyclicDependencyExists(dependency, dependentNames, context);
-
-    if (!cyclicDependencyExists) {
-      const releaseContextCreated = await createReleaseContext(dependency, dependentNames, context);
+    const releaseContextCreated = await createReleaseContext(dependency, dependentNames, context);
 
-      if (releaseContextCreated) {
-        return true;
-      }
+    if (releaseContextCreated) {
+      return true;
     }
   });
 
@@ -178,67 +266,32 @@ async function verifyDependencyReleaseContexts(releaseContext, dependentName, de
   return dependencyReleaseContextsVerify;
 }
 
-function retrieveReleaseContexts(releaseContext, releaseContextMap) {
-  const releaseContexts = [],
-        remainingReleaseContext = releaseContext,  ///
-        remainingReleaseContexts = [
-          remainingReleaseContext
-        ];
-
-  let remainingReleaseContextsLength = remainingReleaseContexts.length;
-
-  while (remainingReleaseContextsLength > 0) {
-    const remainingReleaseContext = remainingReleaseContexts.shift(),
-          releaseContext = remainingReleaseContext;  ///
-
-    releaseContexts.push(releaseContext);
-
-    const dependencies = releaseContext.getDependencies();
-
-    dependencies.forEachDependency((dependency) => {
-      const dependencyName = dependency.getName(),
-            releaseName = dependencyName, ///
-            releaseContext = releaseContextMap[releaseName],
-            releaseContextsIncludesReleaseContext = releaseContexts.includes(releaseContext),
-            remainingReleaseContextsIncludesReleaseContext = remainingReleaseContexts.includes(releaseContext);
-
-      if (!releaseContextsIncludesReleaseContext && !remainingReleaseContextsIncludesReleaseContext) {
-        const remainingReleaseContext = releaseContext; ///
+function retrieveReleaseContexts(releaseContext, releaseContextMap, releaseContexts = []) {
+  const releaseContextsIncludesReleaseContext = releaseContexts.includes(releaseContext);
 
-        remainingReleaseContexts.push(remainingReleaseContext);
-      }
-    });
-
-    remainingReleaseContextsLength = remainingReleaseContexts.length;
+  if (releaseContextsIncludesReleaseContext) {
+    return;
   }
 
-  return releaseContexts;
-}
+  releaseContexts.push(releaseContext);
 
-function checkCyclicDependencyExists(dependency, dependentNames, context) {
-  const dependencyName = dependency.getName(),
-        dependentNamesIncludesDependencyName = dependentNames.includes(dependencyName),
-        cyclicDependencyExists = dependentNamesIncludesDependencyName;  ///
+  const dependencies = releaseContext.getDependencies();
 
-  if (cyclicDependencyExists) {
-    const { log } = context,
-          firstDependentName = first(dependentNames),
-          dependencyNames = [  ///
-            ...dependentNames,
-            firstDependentName
-          ],
-          dependencyNamesString = dependencyNames.join(`' -> '`);
+  dependencies.forEachDependency((dependency) => {
+    const dependencyName = dependency.getName(),
+          releaseName = dependencyName, ///
+          releaseContext = releaseContextMap[releaseName];
 
-    log.warning(`There is a cyclic dependency, '${dependencyNamesString}'.`);
-  }
+    retrieveReleaseContexts(releaseContext, releaseContextMap, releaseContexts);
+  });
 
-  return cyclicDependencyExists;
+  return releaseContexts;
 }
 
 function checkReleaseMatchesDependency(releaseContext, dependency, dependentNames, context) {
   let releaseMatchesDependency = true;
 
-  const shortenedVersion = dependency.getShortedVersion();
+  const shortenedVersion = dependency.getShortenedVersion();
 
   if (shortenedVersion !== null) {
     const entriesMatchShortenedVersion = releaseContext.matchShortenedVersion(shortenedVersion);
@@ -260,10 +313,26 @@ function checkReleaseMatchesDependency(releaseContext, dependency, dependentName
   return releaseMatchesDependency;
 }
 
-function initialiseDependencyReleaseContexts(dependency, releaseContext, context) {
-  const dependencies = releaseContext.getDependencies();
+function checkCyclicDependenciesPresent(directedGraph, context) {
+  let cyclicDependenciesPresent = false;
 
-  dependencies.forEachDependency((dependency) => {  ///
-    initialiseReleaseContext(dependency, context);
-  });
+  const firstCycle = directedGraph.getFirstCycle();
+
+  if (firstCycle !== null) {
+    const { log } = context,
+          vertexNames = firstCycle.getVertexNames(),
+          dependencyNames = vertexNames,  ///
+          firstDependencyName = first(dependencyNames),
+          cyclicDependencyNames = [
+            ...dependencyNames,
+            firstDependencyName
+          ],
+          cycleString = cyclicDependencyNames.join(SINGLE_SPACE);
+
+    log.warning(`There is at least one '${cycleString}'. cyclic dependency`);
+
+    cyclicDependenciesPresent = true;
+  }
+
+  return cyclicDependenciesPresent;
 }