@code-pushup/coverage-plugin 0.16.8 → 0.17.0

package/index.js

@@ -1,5 +1,6 @@
 // packages/plugin-coverage/src/lib/coverage-plugin.ts
-import { join as join3 } from "node:path";
+import { dirname, join as join3 } from "node:path";
+import { fileURLToPath } from "node:url";
 
 // packages/models/src/lib/audit.ts
 import { z as z2 } from "zod";
@@ -549,11 +550,18 @@ var reportSchema = packageVersionSchema({
 // packages/utils/src/lib/file-system.ts
 import { bundleRequire } from "bundle-require";
 import chalk from "chalk";
-import { mkdir, readFile, readdir, stat } from "node:fs/promises";
+import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
-async function readTextFile(path) {
-  const buffer = await readFile(path);
-  return buffer.toString();
+async function ensureDirectoryExists(baseDir) {
+  try {
+    await mkdir(baseDir, { recursive: true });
+    return;
+  } catch (error) {
+    console.error(error.message);
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
 }
 function pluginWorkDir(slug) {
   return join("node_modules", ".code-pushup", slug);
@@ -573,53 +581,23 @@ import chalk3 from "chalk";
 import CliTable3 from "cli-table3";
 
 // packages/utils/src/lib/transform.ts
-import { platform } from "node:os";
-function toUnixPath(path, options) {
-  const unixPath = path.replace(/\\/g, "/");
-  if (options?.toRelative) {
-    return unixPath.replace(`${process.cwd().replace(/\\/g, "/")}/`, "");
-  }
-  return unixPath;
-}
-function toUnixNewlines(text) {
-  return platform() === "win32" ? text.replace(/\r\n/g, "\n") : text;
-}
 function capitalize(text) {
   return `${text.charAt(0).toLocaleUpperCase()}${text.slice(
     1
   )}`;
 }
-function toNumberPrecision(value, decimalPlaces) {
-  return Number(
-    `${Math.round(
-      Number.parseFloat(`${value}e${decimalPlaces}`)
-    )}e-${decimalPlaces}`
-  );
-}
-function toOrdinal(value) {
-  if (value % 10 === 1 && value % 100 !== 11) {
-    return `${value}st`;
-  }
-  if (value % 10 === 2 && value % 100 !== 12) {
-    return `${value}nd`;
-  }
-  if (value % 10 === 3 && value % 100 !== 13) {
-    return `${value}rd`;
-  }
-  return `${value}th`;
-}
 
 // packages/utils/src/lib/logging.ts
 import chalk4 from "chalk";
 
 // packages/plugin-coverage/package.json
 var name = "@code-pushup/coverage-plugin";
-var version = "0.16.8";
+var version = "0.17.0";
 
 // packages/plugin-coverage/src/lib/config.ts
 import { z as z13 } from "zod";
 var coverageTypeSchema = z13.enum(["function", "branch", "line"]);
-var coverageReportSchema = z13.object({
+var coverageResultSchema = z13.object({
   resultsPath: z13.string().includes("lcov"),
   pathToProject: z13.string({
     description: "Path from workspace root to project root. Necessary for LCOV reports."
@@ -635,7 +613,7 @@ var coveragePluginConfigSchema = z13.object({
   coverageTypes: z13.array(coverageTypeSchema, {
     description: "Coverage types measured. Defaults to all available types."
   }).min(1).default(["function", "branch", "line"]),
-  reports: z13.array(coverageReportSchema, {
+  reports: z13.array(coverageResultSchema, {
     description: "Path to all code coverage report files. Only LCOV format is supported for now."
   }).min(1),
   perfectScoreThreshold: z13.number({
@@ -643,193 +621,80 @@ var coveragePluginConfigSchema = z13.object({
   }).gt(0).max(1).optional()
 });
 
-// packages/plugin-coverage/src/lib/runner/lcov/runner.ts
+// packages/plugin-coverage/src/lib/runner/index.ts
+import chalk5 from "chalk";
+import { writeFile } from "node:fs/promises";
+
+// packages/plugin-coverage/src/lib/utils.ts
+var coverageDescription = {
+  branch: "Measures how many branches were executed after conditional statements in at least one test.",
+  line: "Measures how many lines of code were executed in at least one test.",
+  function: "Measures how many functions were called in at least one test."
+};
+function applyMaxScoreAboveThreshold(outputs, threshold) {
+  return outputs.map(
+    (output) => output.score >= threshold ? { ...output, score: 1 } : output
+  );
+}
+var coverageTypeWeightMapper = {
+  function: 6,
+  branch: 3,
+  line: 1
+};
+
+// packages/plugin-coverage/src/lib/runner/constants.ts
 import { join as join2 } from "node:path";
+var WORKDIR = pluginWorkDir("coverage");
+var RUNNER_OUTPUT_PATH = join2(WORKDIR, "runner-output.json");
+var PLUGIN_CONFIG_PATH = join2(
+  process.cwd(),
+  WORKDIR,
+  "plugin-config.json"
+);
 
 // packages/plugin-coverage/src/lib/runner/lcov/parse-lcov.ts
 import parseLcovExport from "parse-lcov";
 var godKnows = parseLcovExport;
 var parseLcov = "default" in godKnows ? godKnows.default : godKnows;
 
-// packages/plugin-coverage/src/lib/runner/lcov/utils.ts
-function calculateCoverage(hit, found) {
-  return found > 0 ? hit / found : 1;
-}
-function mergeConsecutiveNumbers(numberArr) {
-  return [...numberArr].sort().reduce((acc, currValue) => {
-    const prevValue = acc.at(-1);
-    if (prevValue != null && (prevValue.start === currValue - 1 || prevValue.end === currValue - 1)) {
-      return [...acc.slice(0, -1), { start: prevValue.start, end: currValue }];
-    }
-    return [...acc, { start: currValue }];
-  }, []);
-}
-
-// packages/plugin-coverage/src/lib/runner/lcov/transform.ts
-function lcovReportToFunctionStat(record) {
-  return {
-    totalFound: record.functions.found,
-    totalHit: record.functions.hit,
-    issues: record.functions.hit < record.functions.found ? record.functions.details.filter((detail) => !detail.hit).map(
-      (detail) => ({
-        message: `Function ${detail.name} is not called in any test case.`,
-        severity: "error",
-        source: {
-          file: toUnixPath(record.file),
-          position: { startLine: detail.line }
-        }
-      })
-    ) : []
-  };
-}
-function lcovReportToLineStat(record) {
-  const missingCoverage = record.lines.hit < record.lines.found;
-  const lines = missingCoverage ? record.lines.details.filter((detail) => !detail.hit).map((detail) => detail.line) : [];
-  const linePositions = mergeConsecutiveNumbers(lines);
+// packages/plugin-coverage/src/lib/runner/index.ts
+async function createRunnerConfig(scriptPath, config) {
+  await ensureDirectoryExists(WORKDIR);
+  await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));
+  const threshold = config.perfectScoreThreshold;
   return {
-    totalFound: record.lines.found,
-    totalHit: record.lines.hit,
-    issues: missingCoverage ? linePositions.map((linePosition) => {
-      const lineReference = linePosition.end == null ? `Line ${linePosition.start} is` : `Lines ${linePosition.start}-${linePosition.end} are`;
-      return {
-        message: `${lineReference} not covered in any test case.`,
-        severity: "warning",
-        source: {
-          file: toUnixPath(record.file),
-          position: {
-            startLine: linePosition.start,
-            endLine: linePosition.end
-          }
-        }
-      };
-    }) : []
-  };
-}
-function lcovReportToBranchStat(record) {
-  return {
-    totalFound: record.branches.found,
-    totalHit: record.branches.hit,
-    issues: record.branches.hit < record.branches.found ? record.branches.details.filter((detail) => !detail.taken).map(
-      (detail) => ({
-        message: `${toOrdinal(
-          detail.branch + 1
-        )} branch is not taken in any test case.`,
-        severity: "error",
-        source: {
-          file: toUnixPath(record.file),
-          position: { startLine: detail.line }
-        }
-      })
-    ) : []
-  };
-}
-var recordToStatFunctionMapper = {
-  branch: lcovReportToBranchStat,
-  line: lcovReportToLineStat,
-  function: lcovReportToFunctionStat
-};
-function lcovCoverageToAuditOutput(stat2, coverageType) {
-  const coverage = calculateCoverage(stat2.totalHit, stat2.totalFound);
-  const MAX_DECIMAL_PLACES = 4;
-  const roundedIntValue = toNumberPrecision(coverage * 100, 0);
-  return {
-    slug: `${coverageType}-coverage`,
-    score: toNumberPrecision(coverage, MAX_DECIMAL_PLACES),
-    value: roundedIntValue,
-    displayValue: `${roundedIntValue} %`,
-    ...stat2.issues.length > 0 && { details: { issues: stat2.issues } }
-  };
-}
-
-// packages/plugin-coverage/src/lib/runner/lcov/runner.ts
-async function lcovResultsToAuditOutputs(reports, coverageTypes) {
-  const parsedReports = await Promise.all(
-    reports.map(async (report) => {
-      const reportContent = await readTextFile(report.resultsPath);
-      const parsedRecords = parseLcov(toUnixNewlines(reportContent));
-      return parsedRecords.map((record) => ({
-        ...record,
-        file: report.pathToProject == null ? record.file : join2(report.pathToProject, record.file)
-      }));
-    })
-  );
-  if (parsedReports.length !== reports.length) {
-    throw new Error("Some provided LCOV reports were not valid.");
-  }
-  const flatReports = parsedReports.flat();
-  if (flatReports.length === 0) {
-    throw new Error("All provided reports are empty.");
-  }
-  const totalCoverageStats = getTotalCoverageFromLcovReports(
-    flatReports,
-    coverageTypes
-  );
-  return coverageTypes.map((coverageType) => {
-    const stats = totalCoverageStats[coverageType];
-    if (!stats) {
-      return null;
+    command: "node",
+    args: [scriptPath],
+    outputFile: RUNNER_OUTPUT_PATH,
+    ...threshold != null && {
+      outputTransform: (outputs) => applyMaxScoreAboveThreshold(outputs, threshold)
     }
-    return lcovCoverageToAuditOutput(stats, coverageType);
-  }).filter(exists);
-}
-function getTotalCoverageFromLcovReports(records, coverageTypes) {
-  return records.reduce(
-    (acc, report) => Object.fromEntries([
-      ...Object.entries(acc),
-      ...Object.entries(
-        getCoverageStatsFromLcovRecord(report, coverageTypes)
-      ).map(([type, stats]) => [
-        type,
-        {
-          totalFound: (acc[type]?.totalFound ?? 0) + stats.totalFound,
-          totalHit: (acc[type]?.totalHit ?? 0) + stats.totalHit,
-          issues: [...acc[type]?.issues ?? [], ...stats.issues]
-        }
-      ])
-    ]),
-    {}
-  );
-}
-function getCoverageStatsFromLcovRecord(record, coverageTypes) {
-  return Object.fromEntries(
-    coverageTypes.map((coverageType) => [
-      coverageType,
-      recordToStatFunctionMapper[coverageType](record)
-    ])
-  );
-}
-
-// packages/plugin-coverage/src/lib/utils.ts
-function applyMaxScoreAboveThreshold(outputs, threshold) {
-  return outputs.map(
-    (output) => output.score >= threshold ? { ...output, score: 1 } : output
-  );
+  };
 }
 
 // packages/plugin-coverage/src/lib/coverage-plugin.ts
-var RUNNER_OUTPUT_PATH = join3(
-  pluginWorkDir("coverage"),
-  "runner-output.json"
-);
-function coveragePlugin(config) {
-  const { reports, perfectScoreThreshold, coverageTypes, coverageToolCommand } = coveragePluginConfigSchema.parse(config);
-  const audits = coverageTypes.map(
+async function coveragePlugin(config) {
+  const coverageConfig = coveragePluginConfigSchema.parse(config);
+  const audits = coverageConfig.coverageTypes.map(
     (type) => ({
       slug: `${type}-coverage`,
       title: `${capitalize(type)} coverage`,
-      description: `${capitalize(type)} coverage percentage on the project.`
+      description: coverageDescription[type]
     })
   );
-  const getAuditOutputs = async () => perfectScoreThreshold ? applyMaxScoreAboveThreshold(
-    await lcovResultsToAuditOutputs(reports, coverageTypes),
-    perfectScoreThreshold
-  ) : await lcovResultsToAuditOutputs(reports, coverageTypes);
-  const runner = coverageToolCommand == null ? getAuditOutputs : {
-    command: coverageToolCommand.command,
-    args: coverageToolCommand.args,
-    outputFile: RUNNER_OUTPUT_PATH,
-    outputTransform: getAuditOutputs
+  const group = {
+    slug: "coverage",
+    title: "Code coverage metrics",
+    description: "Group containing all defined coverage types as audits.",
+    refs: audits.map((audit) => ({
+      ...audit,
+      weight: coverageTypeWeightMapper[audit.slug.slice(0, audit.slug.indexOf("-"))]
+    }))
   };
+  const runnerScriptPath = join3(
+    fileURLToPath(dirname(import.meta.url)),
+    "bin.js"
+  );
   return {
     slug: "coverage",
     title: "Code coverage",
@@ -839,12 +704,68 @@ function coveragePlugin(config) {
     packageName: name,
     version,
     audits,
-    runner
+    groups: [group],
+    runner: await createRunnerConfig(runnerScriptPath, coverageConfig)
   };
 }
 
+// packages/plugin-coverage/src/lib/nx/coverage-paths.ts
+import chalk6 from "chalk";
+import { join as join4 } from "node:path";
+async function getNxCoveragePaths(targets = ["test"]) {
+  console.info(
+    chalk6.bold("\u{1F4A1} Gathering coverage from the following nx projects:")
+  );
+  const { createProjectGraphAsync } = await import("@nx/devkit");
+  const { nodes } = await createProjectGraphAsync({ exitOnError: false });
+  const coverageResults = targets.map((target) => {
+    const relevantNodes = Object.values(nodes).filter(
+      (graph) => hasNxTarget(graph, target)
+    );
+    return relevantNodes.map(({ name: name2, data }) => {
+      const targetConfig = data.targets?.[target];
+      const coveragePath = getCoveragePathForTarget(target, targetConfig, name2);
+      const rootToReportsDir = join4(data.root, coveragePath);
+      console.info(`- ${name2}: ${target}`);
+      return {
+        pathToProject: data.root,
+        resultsPath: join4(rootToReportsDir, "lcov.info")
+      };
+    });
+  });
+  console.info("\n");
+  return coverageResults.flat();
+}
+function hasNxTarget(project, target) {
+  return project.data.targets != null && target in project.data.targets;
+}
+function getCoveragePathForTarget(target, targetConfig, projectName) {
+  if (targetConfig.executor?.includes("@nx/vite")) {
+    const { reportsDirectory } = targetConfig.options;
+    if (reportsDirectory == null) {
+      throw new Error(
+        `Coverage configuration not found for target ${target} in ${projectName}. Define your Vitest coverage directory in the reportsDirectory option.`
+      );
+    }
+    return reportsDirectory;
+  }
+  if (targetConfig.executor?.includes("@nx/jest")) {
+    const { coverageDirectory } = targetConfig.options;
+    if (coverageDirectory == null) {
+      throw new Error(
+        `Coverage configuration not found for target ${target} in ${projectName}. Define your Jest coverage directory in the coverageDirectory option.`
+      );
+    }
+    return coverageDirectory;
+  }
+  throw new Error(
+    `Unsupported executor ${targetConfig.executor}. @nx/vite and @nx/jest are currently supported.`
+  );
+}
+
 // packages/plugin-coverage/src/index.ts
 var src_default = coveragePlugin;
 export {
-  src_default as default
+  src_default as default,
+  getNxCoveragePaths
 };

package/package.json

@@ -1,12 +1,21 @@
 {
   "name": "@code-pushup/coverage-plugin",
-  "version": "0.16.8",
+  "version": "0.17.0",
   "dependencies": {
     "@code-pushup/models": "*",
     "@code-pushup/utils": "*",
     "parse-lcov": "^1.0.4",
+    "chalk": "^5.3.0",
     "zod": "^3.22.4"
   },
+  "peerDependencies": {
+    "@nx/devkit": "^17.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@nx/devkit": {
+      "optional": true
+    }
+  },
   "license": "MIT",
   "homepage": "https://github.com/code-pushup/cli#readme",
   "bugs": {

package/src/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/src/index.d.ts

@@ -1,3 +1,4 @@
 import { coveragePlugin } from './lib/coverage-plugin';
 export default coveragePlugin;
 export type { CoveragePluginConfig } from './lib/config';
+export { getNxCoveragePaths } from './lib/nx/coverage-paths';

package/src/lib/config.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const coverageTypeSchema: z.ZodEnum<["function", "branch", "line"]>;
 export type CoverageType = z.infer<typeof coverageTypeSchema>;
-export declare const coverageReportSchema: z.ZodObject<{
+export declare const coverageResultSchema: z.ZodObject<{
     resultsPath: z.ZodString;
     pathToProject: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -11,7 +11,7 @@ export declare const coverageReportSchema: z.ZodObject<{
     resultsPath: string;
     pathToProject?: string | undefined;
 }>;
-export type CoverageReport = z.infer<typeof coverageReportSchema>;
+export type CoverageResult = z.infer<typeof coverageResultSchema>;
 export declare const coveragePluginConfigSchema: z.ZodObject<{
     coverageToolCommand: z.ZodOptional<z.ZodObject<{
         command: z.ZodString;
@@ -59,3 +59,4 @@ export declare const coveragePluginConfigSchema: z.ZodObject<{
     perfectScoreThreshold?: number | undefined;
 }>;
 export type CoveragePluginConfig = z.input<typeof coveragePluginConfigSchema>;
+export type FinalCoveragePluginConfig = z.infer<typeof coveragePluginConfigSchema>;

package/src/lib/coverage-plugin.d.ts

@@ -1,6 +1,5 @@
 import type { PluginConfig } from '@code-pushup/models';
 import { CoveragePluginConfig } from './config';
-export declare const RUNNER_OUTPUT_PATH: string;
 /**
  * Instantiates Code PushUp code coverage plugin for core config.
  *
@@ -19,4 +18,4 @@ export declare const RUNNER_OUTPUT_PATH: string;
  *
  * @returns Plugin configuration.
  */
-export declare function coveragePlugin(config: CoveragePluginConfig): PluginConfig;
+export declare function coveragePlugin(config: CoveragePluginConfig): Promise<PluginConfig>;

package/src/lib/nx/coverage-paths.d.ts

@@ -0,0 +1,6 @@
+import { CoverageResult } from '../config';
+/**
+ * @param targets nx targets to be used for measuring coverage, test by default
+ * @returns An array of coverage result information for the coverage plugin.
+ */
+export declare function getNxCoveragePaths(targets?: string[]): Promise<CoverageResult[]>;

package/src/lib/runner/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const WORKDIR: string;
+export declare const RUNNER_OUTPUT_PATH: string;
+export declare const PLUGIN_CONFIG_PATH: string;

package/src/lib/runner/index.d.ts

@@ -0,0 +1,4 @@
+import type { RunnerConfig } from '@code-pushup/models';
+import { FinalCoveragePluginConfig } from '../config';
+export declare function executeRunner(): Promise<void>;
+export declare function createRunnerConfig(scriptPath: string, config: FinalCoveragePluginConfig): Promise<RunnerConfig>;

package/src/lib/runner/lcov/lcov-runner.d.ts

@@ -0,0 +1,9 @@
+import { AuditOutputs } from '@code-pushup/models';
+import { CoverageResult, CoverageType } from '../../config';
+/**
+ *
+ * @param results Paths to LCOV results
+ * @param coverageTypes types of coverage to be considered
+ * @returns Audit outputs with complete coverage data.
+ */
+export declare function lcovResultsToAuditOutputs(results: CoverageResult[], coverageTypes: CoverageType[]): Promise<AuditOutputs>;

package/src/lib/utils.d.ts

@@ -1,4 +1,6 @@
 import type { AuditOutputs } from '@code-pushup/models';
+import { CoverageType } from './config';
+export declare const coverageDescription: Record<CoverageType, string>;
 /**
  * Since more code coverage does not necessarily mean better score, this optional override allows for defining custom coverage goals.
  * @param outputs original results
@@ -6,3 +8,4 @@ import type { AuditOutputs } from '@code-pushup/models';
  * @returns Outputs with overriden score (not value) to 1 if it reached a defined threshold.
  */
 export declare function applyMaxScoreAboveThreshold(outputs: AuditOutputs, threshold: number): AuditOutputs;
+export declare const coverageTypeWeightMapper: Record<CoverageType, number>;

package/src/lib/runner/lcov/runner.d.ts

@@ -1,9 +0,0 @@
-import { AuditOutputs } from '@code-pushup/models';
-import { CoverageReport, CoverageType } from '../../config';
-/**
- *
- * @param reports report files
- * @param coverageTypes types of coverage to be considered
- * @returns Audit outputs with complete coverage data.
- */
-export declare function lcovResultsToAuditOutputs(reports: CoverageReport[], coverageTypes: CoverageType[]): Promise<AuditOutputs>;