feat(utils): convert files array to tree structure

Author: matejchalk

packages/utils/src/lib/coverage-tree.ts

@@ -0,0 +1,100 @@
+import type {
+  CoverageTree,
+  CoverageTreeMissingLOC,
+  CoverageTreeNode,
+} from '@code-pushup/models';
+import { splitFilePath } from './file-system.js';
+import { formatGitPath } from './git/git.js';
+
+type FileCoverage = {
+  path: string;
+  total: number;
+  hits: number;
+  missing: CoverageTreeMissingLOC[];
+};
+
+// TODO: calculate folder coverage
+const COVERAGE_PLACEHOLDER = -1;
+
+export function filesCoverageToTree(
+  files: FileCoverage[],
+  gitRoot: string,
+  title?: string,
+): CoverageTree {
+  const normalizedFiles = files.map(file => ({
+    ...file,
+    path: formatGitPath(file.path, gitRoot),
+  }));
+
+  const root = normalizedFiles.reduce<CoverageTreeNode>(
+    (acc: CoverageTreeNode, { path: filePath, ...coverage }) => {
+      const { folders, file } = splitFilePath(filePath);
+      return addNode(acc, folders, file, coverage);
+    },
+    { name: '.', values: { coverage: COVERAGE_PLACEHOLDER } },
+  );
+
+  return {
+    type: 'coverage',
+    ...(title && { title }),
+    root,
+  };
+}
+
+function addNode(
+  root: CoverageTreeNode,
+  folders: string[],
+  file: string,
+  coverage: Omit<FileCoverage, 'path'>,
+): CoverageTreeNode {
+  const folder = folders[0];
+
+  if (folder) {
+    if (root.children?.some(({ name }) => name === folder)) {
+      return {
+        ...root,
+        children: root.children.map(node =>
+          node.name === folder
+            ? addNode(node, folders.slice(1), file, coverage)
+            : node,
+        ),
+      };
+    }
+    return {
+      ...root,
+      children: [
+        ...(root.children ?? []),
+        addNode(
+          { name: folder, values: { coverage: COVERAGE_PLACEHOLDER } },
+          folders.slice(1),
+          file,
+          coverage,
+        ),
+      ],
+    };
+  }
+
+  return {
+    ...root,
+    children: [
+      ...(root.children ?? []),
+      {
+        name: file,
+        values: {
+          coverage: calculateCoverage(coverage),
+          missing: coverage.missing,
+        },
+      },
+    ],
+  };
+}
+
+function calculateCoverage({
+  hits,
+  total,
+}: Pick<FileCoverage, 'hits' | 'total'>): number {
+  if (total === 0) {
+    return 1;
+  }
+  return hits / total;
+}

packages/utils/src/lib/coverage-tree.unit.test.ts

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { filesCoverageToTree } from './coverage-tree.js';
+
+describe('filesCoverageToTree', () => {
+  it('should convert list of files to folder structure', () => {
+    const mockCoverage = { hits: 0, total: 0, missing: [] };
+    const files = [
+      {
+        ...mockCoverage,
+        path: path.join(process.cwd(), 'src', 'components', 'CreateTodo.jsx'),
+      },
+      {
+        ...mockCoverage,
+        path: path.join(process.cwd(), 'src', 'components', 'TodoFilter.jsx'),
+      },
+      {
+        ...mockCoverage,
+        path: path.join(process.cwd(), 'src', 'components', 'TodoList.jsx'),
+      },
+      {
+        ...mockCoverage,
+        path: path.join(process.cwd(), 'src', 'hooks', 'useTodos.js'),
+      },
+      {
+        ...mockCoverage,
+        path: path.join(process.cwd(), 'src', 'App.jsx'),
+      },
+    ];
+
+    expect(filesCoverageToTree(files, process.cwd())).toEqual(
+      expect.objectContaining({
+        root: expect.objectContaining({
+          name: '.',
+          children: [
+            expect.objectContaining({
+              name: 'src',
+              children: [
+                expect.objectContaining({
+                  name: 'components',
+                  children: [
+                    expect.objectContaining({ name: 'CreateTodo.jsx' }),
+                    expect.objectContaining({ name: 'TodoFilter.jsx' }),
+                    expect.objectContaining({ name: 'TodoList.jsx' }),
+                  ],
+                }),
+                expect.objectContaining({
+                  name: 'hooks',
+                  children: [expect.objectContaining({ name: 'useTodos.js' })],
+                }),
+                expect.objectContaining({ name: 'App.jsx' }),
+              ],
+            }),
+          ],
+        }),
+      }),
+    );
+  });
+});

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

@@ -159,3 +159,24 @@ export function filePathToCliArg(filePath: string): string {
 export function projectToFilename(project: string): string {
   return project.replace(/[/\\\s]+/g, '-').replace(/@/g, '');
 }
+
+type SplitFilePath = {
+  folders: string[];
+  file: string;
+};
+
+export function splitFilePath(filePath: string): SplitFilePath {
+  const file = path.basename(filePath);
+  const folders: string[] = [];
+  // eslint-disable-next-line functional/no-loop-statements
+  for (
+    // eslint-disable-next-line functional/no-let
+    let dirPath = path.dirname(filePath);
+    path.dirname(dirPath) !== dirPath;
+    dirPath = path.dirname(dirPath)
+  ) {
+    // eslint-disable-next-line functional/immutable-data
+    folders.unshift(path.basename(dirPath));
+  }
+  return { folders, file };
+}

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

@@ -12,6 +12,7 @@ import {
   findNearestFile,
   logMultipleFileResults,
   projectToFilename,
+  splitFilePath,
 } from './file-system.js';
 import * as logResults from './log-results.js';
 
@@ -263,3 +264,12 @@ describe('projectToFilename', () => {
     expect(projectToFilename(project)).toBe(file);
   });
 });
+
+describe('splitFilePath', () => {
+  it('should extract folders from file path', () => {
+    expect(splitFilePath(path.join('src', 'app', 'app.component.ts'))).toEqual({
+      folders: ['src', 'app'],
+      file: 'app.component.ts',
+    });
+  });
+});