chore(progress): updates copy

src/cache/cache.mjs

@@ -87,7 +87,7 @@ export default class Cache {
         },
       ));
     this.#revisionData.cacheFormatVersion = CACHE_FORMAT_VERSION;
-    bus.debug("cache: - comparing");
+    bus.debug("cache: - compare");
     return (
       this.cacheFormatVersionCompatible(pCachedCruiseResult) &&
       this.#cacheStrategy.revisionDataEqual(

src/cache/find-content-changes.mjs

@@ -82,7 +82,7 @@ export default function findContentChanges(
   pCachedCruiseResult,
   pOptions,
 ) {
-  bus.debug("cache: - getting revision data");
+  bus.debug("cache: - get revision data");
   const lFileSet = new Set(
     findAllFiles(pDirectory, {
       baseDir: pOptions.baseDir,
@@ -91,12 +91,12 @@ export default function findContentChanges(
     }).filter(hasInterestingExtension(pOptions.extensions)),
   );
 
-  bus.debug("cache: - getting (cached - new)");
+  bus.debug("cache: - get (cached - new)");
   const lDiffCachedVsNew = pCachedCruiseResult.modules.map(
     diffCachedModuleAgainstFileSet(lFileSet, pOptions.baseDir),
   );
 
-  bus.debug("cache: - getting (new - cached)");
+  bus.debug("cache: - get (new - cached)");
   lDiffCachedVsNew.forEach(({ name }) => lFileSet.delete(name));
 
   const lDiffNewVsCached = [];
@@ -108,6 +108,6 @@ export default function findContentChanges(
     });
   }
 
-  bus.debug("cache: - returning revision data");
+  bus.debug("cache: - return revision data");
   return lDiffCachedVsNew.concat(lDiffNewVsCached);
 }

src/cache/metadata-strategy.mjs

@@ -42,9 +42,9 @@ export default class MetaDataStrategy {
       ...pOptions,
     };
     try {
-      bus.debug("cache: - getting sha");
+      bus.debug("cache: - get sha");
       const lSHA = await lOptions.shaRetrievalFn();
-      bus.debug("cache: - getting diff");
+      bus.debug("cache: - get diff");
       const lDiff = /** @type {IChange[]} */ (
         await lOptions.diffListFn({ oldRevision: lSHA })
       );
@@ -55,7 +55,7 @@ export default class MetaDataStrategy {
         )
         .filter(changeHasInterestingExtension(lOptions.extensions))
         .filter(isInterestingChangeType(lOptions.interestingChangeTypes));
-      bus.debug("cache: - sha-summing diff");
+      bus.debug("cache: - sha-sum diff");
       return {
         SHA1: lSHA,
         changes: lChanges.map(lOptions.checksumFn),

src/enrich/enrich-modules.mjs

@@ -17,29 +17,29 @@ import { bus } from "#utl/bus.mjs";
  * @returns {IModule[]}
  */
 export default function enrichModules(pModules, pOptions) {
-  bus.info("analyzing: cycles");
+  bus.info("analyze: cycles");
   const lIndexedModules = new IndexedModuleGraph(pModules);
   let lModules = deriveCycles(pModules, lIndexedModules, {
     pSourceAttribute: "source",
     pDependencyName: "resolved",
     pSkipAnalysisNotInRules: pOptions.skipAnalysisNotInRules,
     pRuleSet: pOptions.ruleSet,
   });
-  bus.info("analyzing: dependents");
+  bus.info("analyze: dependents");
   lModules = addDependents(lModules, pOptions);
-  bus.info("analyzing: orphans");
+  bus.info("analyze: orphans");
   lModules = deriveOrphans(lModules, pOptions);
-  bus.info("analyzing: reachables");
+  bus.info("analyze: reachables");
   lModules = deriveReachable(lModules, pOptions.ruleSet);
-  bus.info("analyzing: module metrics");
+  bus.info("analyze: module metrics");
   lModules = deriveModuleMetrics(lModules, pOptions);
-  bus.info("analyzing: focus");
+  bus.info("analyze: focus");
   lModules = addFocus(lModules, pOptions.focus);
 
   // when validate === false we might want to skip the addValidations.
   // We don't at this time, however, as "valid" is a mandatory
   // attribute (to simplify reporter logic)
-  bus.info("analyzing: validations");
+  bus.info("analyze: validations");
   lModules = addValidations(lModules, pOptions.ruleSet, pOptions.validate);
 
   lModules = softenKnownViolations(lModules, pOptions.knownViolations);

src/enrich/index.mjs

@@ -1,6 +1,7 @@
 import enrichModules from "./enrich-modules.mjs";
 import aggregateToFolders from "./derive/folders/index.mjs";
 import summarize from "./summarize/index.mjs";
+import { bus } from "#utl/bus.mjs";
 
 /**
  * Enriches the passed modules with things like cycle detection, validations,
@@ -17,16 +18,18 @@ import summarize from "./summarize/index.mjs";
  */
 export default function enrich(pModules, pOptions, pFileAndDirectoryArray) {
   const lModules = enrichModules(pModules, pOptions);
+  bus.info("analyze: aggregate to folders");
   const lFolders = aggregateToFolders(lModules, pOptions);
 
+  bus.info("analyze: summary");
   const lReturnValue = {
     modules: lModules,
     ...lFolders,
     summary: summarize(
       lModules,
       pOptions,
       pFileAndDirectoryArray,
-      lFolders.folders
+      lFolders.folders,
     ),
   };
 

src/enrich/soften-known-violations.mjs

@@ -117,7 +117,7 @@ export default function softenKnownViolations(
   pSoftenedSeverity = "ignore",
 ) {
   if (pKnownViolations) {
-    bus.info("analyzing: comparing against known errors");
+    bus.info("analyze: compare to known errors");
     return pModules.map((pModule) =>
       softenKnownViolation(pModule, pKnownViolations, pSoftenedSeverity),
     );

src/extract/index.mjs

@@ -75,13 +75,13 @@ function extractFileDirectoryArray(
 ) {
   let lVisited = new Set();
 
-  bus.info("reading files: gathering initial sources");
+  bus.info("read files: gather initial sources");
   const lInitialSources = gatherInitialSources(
     pFileDirectoryArray,
     pCruiseOptions,
   );
 
-  bus.info("reading files: visiting dependencies");
+  bus.info("read files: visit dependencies");
   return lInitialSources.reduce((pDependencies, pFilename) => {
     if (!lVisited.has(pFilename)) {
       lVisited.add(pFilename);

src/main/cruise.mjs

@@ -18,7 +18,7 @@ export default async function cruise(
   pResolveOptions,
   pTranspileOptions,
 ) {
-  bus.summary("parsing options", c(1));
+  bus.summary("parse options", c(1));
   const lCruiseOptionsValid = assertCruiseOptionsValid(pCruiseOptions);
   /** @type {import("../../types/strict-options.js").IStrictCruiseOptions} */
   let lCruiseOptions = normalizeCruiseOptions(
@@ -29,7 +29,7 @@ export default async function cruise(
 
   if (lCruiseOptions.cache) {
     bus.summary(
-      `cache: checking freshness with ${lCruiseOptions.cache.strategy}`,
+      `cache: check freshness with ${lCruiseOptions.cache.strategy}`,
       c(2),
     );
 
@@ -41,12 +41,12 @@ export default async function cruise(
     const lCachedResults = await lCache.read(lCruiseOptions.cache.folder);
 
     if (await lCache.canServeFromCache(lCruiseOptions, lCachedResults)) {
-      bus.summary("cache: reporting from cache", c(8));
+      bus.summary("cache: report from cache", c(8));
       return await reportWrap(lCachedResults, lCruiseOptions);
     }
   }
 
-  bus.summary("importing analytical modules", c(3));
+  bus.summary("import analytical modules", c(3));
   const [
     { default: normalizeRuleSet },
     { default: assertRuleSetValid },
@@ -66,7 +66,7 @@ export default async function cruise(
   ]);
 
   if (lCruiseOptions.ruleSet) {
-    bus.summary("parsing rule set", c(4));
+    bus.summary("parse rule set", c(4));
     lCruiseOptions.ruleSet = normalizeRuleSet(
       assertRuleSetValid(lCruiseOptions.ruleSet),
     );
@@ -76,33 +76,33 @@ export default async function cruise(
     pFileAndDirectoryArray,
   );
 
-  bus.summary("determining how to resolve", c(5));
+  bus.summary("determine how to resolve", c(5));
   const lNormalizedResolveOptions = await normalizeResolveOptions(
     pResolveOptions,
     lCruiseOptions,
     pTranspileOptions?.tsConfig,
   );
 
-  bus.summary("reading files", c(6));
+  bus.summary("read files", c(6));
   const lExtractionResult = extract(
     lNormalizedFileAndDirectoryArray,
     lCruiseOptions,
     lNormalizedResolveOptions,
     pTranspileOptions,
   );
 
-  bus.summary("analyzing", c(7));
+  bus.summary("analyze", c(7));
   const lCruiseResult = enrich(
     lExtractionResult,
     lCruiseOptions,
     lNormalizedFileAndDirectoryArray,
   );
 
   if (lCruiseOptions.cache) {
-    bus.summary("cache: saving", c(8));
+    bus.summary("cache: save", c(8));
     await lCache.write(lCruiseOptions.cache.folder, lCruiseResult);
   }
 
-  bus.summary("reporting", c(9));
+  bus.summary("report", c(9));
   return await reportWrap(lCruiseResult, lCruiseOptions);
 }