feat(utils): truncate paths with shared prefix and/or suffix

Author: matejchalk

packages/plugin-coverage/src/lib/runner/lcov/lcov-runner.ts

@@ -14,6 +14,7 @@ import {
   pluralizeToken,
   readTextFile,
   toUnixNewlines,
+  truncatePaths,
 } from '@code-pushup/utils';
 import type { CoverageResult, CoverageType } from '../../config.js';
 import { ALL_COVERAGE_TYPES } from '../../constants.js';
@@ -169,7 +170,8 @@ function getCoverageStatsFromLcovRecord<T extends CoverageType>(
 }
 
 function logLcovRecords(recordsPerReport: Record<string, LCOVRecord[]>): void {
-  const reportsCount = Object.keys(recordsPerReport).length;
+  const reportPaths = Object.keys(recordsPerReport);
+  const reportsCount = reportPaths.length;
   const sourceFilesCount = new Set(
     Object.values(recordsPerReport)
       .flat()
@@ -183,11 +185,13 @@ function logLcovRecords(recordsPerReport: Record<string, LCOVRecord[]>): void {
     return;
   }
 
+  const truncatedPaths = truncatePaths(reportPaths);
+
   logger.newline();
   logger.debug(
     formatAsciiTable({
       columns: [
-        { key: 'reportPath', label: 'LCOV report', align: 'left' },
+        { key: 'report', label: 'LCOV report', align: 'left' },
         { key: 'filesCount', label: 'Files', align: 'right' },
         ...ALL_COVERAGE_TYPES.map(
           (type): TableColumnObject => ({
@@ -197,20 +201,22 @@ function logLcovRecords(recordsPerReport: Record<string, LCOVRecord[]>): void {
           }),
         ),
       ],
-      // TODO: truncate report paths (replace shared segments with ellipsis)
-      rows: Object.entries(recordsPerReport).map(([reportPath, records]) => {
-        const groups = groupLcovRecordsByCoverageType(
-          records,
-          ALL_COVERAGE_TYPES,
-        );
-        const stats: Record<CoverageType, string> = objectFromEntries(
-          objectToEntries(groups).map(([type, files = []]) => [
-            type,
-            formatCoverageSum(files),
-          ]),
-        );
-        return { reportPath, filesCount: records.length, ...stats };
-      }),
+      rows: Object.entries(recordsPerReport).map(
+        ([reportPath, records], idx) => {
+          const groups = groupLcovRecordsByCoverageType(
+            records,
+            ALL_COVERAGE_TYPES,
+          );
+          const stats: Record<CoverageType, string> = objectFromEntries(
+            objectToEntries(groups).map(([type, files = []]) => [
+              type,
+              formatCoverageSum(files),
+            ]),
+          );
+          const report = truncatedPaths[idx] ?? reportPath;
+          return { report, filesCount: records.length, ...stats };
+        },
+      ),
     }),
   );
   logger.newline();
@@ -227,6 +233,10 @@ function formatCoverageSum(files: FileCoverage[]): string {
     { covered: 0, total: 0 },
   );
 
+  if (total === 0) {
+    return 'n/a';
+  }
+
   const percentage = (covered / total) * 100;
   return `${percentage.toFixed(1)}%`;
 }

packages/utils/src/index.ts

@@ -43,6 +43,7 @@ export {
   readJsonFile,
   readTextFile,
   removeDirectoryIfExists,
+  truncatePaths,
   type CrawlFileSystemOptions,
 } from './lib/file-system.js';
 export { filterItemRefsBy } from './lib/filter.js';

packages/utils/src/lib/file-system.ts

@@ -180,3 +180,46 @@ export function splitFilePath(filePath: string): SplitFilePath {
   }
   return { folders, file };
 }
+
+export function truncatePaths(paths: string[]): string[] {
+  const segmentedPaths = paths
+    .map(splitFilePath)
+    .map(({ folders, file }): string[] => [...folders, file]);
+
+  const first = segmentedPaths[0];
+  const others = segmentedPaths.slice(1);
+  if (!first) {
+    return paths;
+  }
+
+  /* eslint-disable functional/no-let,functional/no-loop-statements,unicorn/no-for-loop */
+  let offsetLeft = 0;
+  let offsetRight = 0;
+  for (let left = 0; left < first.length; left++) {
+    if (others.every(segments => segments[left] === first[left])) {
+      offsetLeft++;
+    } else {
+      break;
+    }
+  }
+  for (let right = 1; right <= first.length; right++) {
+    if (others.every(segments => segments.at(-right) === first.at(-right))) {
+      offsetRight++;
+    } else {
+      break;
+    }
+  }
+  /* eslint-enable functional/no-let,functional/no-loop-statements,unicorn/no-for-loop */
+
+  return segmentedPaths.map(segments => {
+    const uniqueSegments = segments.slice(
+      offsetLeft,
+      offsetRight > 0 ? -offsetRight : undefined,
+    );
+    return path.join(
+      offsetLeft > 0 ? '…' : '',
+      ...uniqueSegments,
+      offsetRight > 0 ? '…' : '',
+    );
+  });
+}

packages/utils/src/lib/file-system.unit.test.ts

@@ -12,6 +12,7 @@ import {
   findNearestFile,
   projectToFilename,
   splitFilePath,
+  truncatePaths,
 } from './file-system.js';
 
 describe('ensureDirectoryExists', () => {
@@ -268,3 +269,60 @@ describe('splitFilePath', () => {
     });
   });
 });
+
+describe('truncatePaths', () => {
+  it('should replace shared path prefix with ellipsis', () => {
+    expect(
+      truncatePaths([
+        path.join('dist', 'packages', 'cli'),
+        path.join('dist', 'packages', 'core'),
+        path.join('dist', 'packages', 'utils'),
+      ]),
+    ).toEqual([
+      path.join('…', 'cli'),
+      path.join('…', 'core'),
+      path.join('…', 'utils'),
+    ]);
+  });
+
+  it('should replace shared path suffix with ellipsis', () => {
+    expect(
+      truncatePaths([
+        path.join('e2e', 'cli-e2e', 'coverage', 'lcov.info'),
+        path.join('packages', 'cli', 'coverage', 'lcov.info'),
+        path.join('packages', 'core', 'coverage', 'lcov.info'),
+      ]),
+    ).toEqual([
+      path.join('e2e', 'cli-e2e', '…'),
+      path.join('packages', 'cli', '…'),
+      path.join('packages', 'core', '…'),
+    ]);
+  });
+
+  it('should replace shared path prefix and suffix at once', () => {
+    expect(
+      truncatePaths([
+        path.join('coverage', 'packages', 'cli', 'int-tests', 'lcov.info'),
+        path.join('coverage', 'packages', 'cli', 'unit-tests', 'lcov.info'),
+        path.join('coverage', 'packages', 'core', 'int-tests', 'lcov.info'),
+        path.join('coverage', 'packages', 'core', 'unit-tests', 'lcov.info'),
+        path.join('coverage', 'packages', 'utils', 'unit-tests', 'lcov.info'),
+      ]),
+    ).toEqual([
+      path.join('…', 'cli', 'int-tests', '…'),
+      path.join('…', 'cli', 'unit-tests', '…'),
+      path.join('…', 'core', 'int-tests', '…'),
+      path.join('…', 'core', 'unit-tests', '…'),
+      path.join('…', 'utils', 'unit-tests', '…'),
+    ]);
+  });
+
+  it('should leave unique paths unchanged', () => {
+    const paths = [
+      path.join('e2e', 'cli-e2e'),
+      path.join('packages', 'cli'),
+      path.join('packages', 'core'),
+    ];
+    expect(truncatePaths(paths)).toEqual(paths);
+  });
+});