Merge pull request #80 from mcarvin8/covered-lines

src/handlers/cloverCoverageHandler.ts

@@ -1,8 +1,6 @@
 'use strict';
 
 import { CloverCoverageObject, CloverFile, CoverageHandler } from '../helpers/types.js';
-import { setCoveredLinesClover } from '../helpers/setCoveredLinesClover.js';
-import { normalizePathToUnix } from '../helpers/normalizePathToUnix.js';
 
 export class CloverCoverageHandler implements CoverageHandler {
   private readonly coverageObj: CloverCoverageObject;
@@ -37,18 +35,16 @@ export class CloverCoverageHandler implements CoverageHandler {
     };
   }
 
-  public async processFile(
+  public processFile(
     filePath: string,
     fileName: string,
     lines: Record<string, number>,
     uncoveredLines: number[],
     coveredLines: number[],
-    repoRoot: string,
-    reportType: 'test' | 'deploy'
-  ): Promise<void> {
+  ): void {
     const fileObj: CloverFile = {
       '@name': fileName,
-      '@path': normalizePathToUnix(filePath),
+      '@path': filePath,
       metrics: {
         '@statements': uncoveredLines.length + coveredLines.length,
         '@coveredstatements': coveredLines.length,
@@ -59,18 +55,12 @@ export class CloverCoverageHandler implements CoverageHandler {
       },
       line: [],
     };
-
-    if (reportType === 'test') {
-      for (const [lineNumber, isCovered] of Object.entries(lines)) {
-        fileObj.line.push({
-          '@num': Number(lineNumber),
-          '@count': isCovered === 1 ? 1 : 0,
-          '@type': 'stmt',
-        });
-      }
-    } else if (reportType === 'deploy') {
-      fileObj.line = [...uncoveredLines.map((lineNumber) => ({ '@num': lineNumber, '@count': 0, '@type': 'stmt' }))];
-      await setCoveredLinesClover(coveredLines, uncoveredLines, repoRoot, filePath, fileObj);
+    for (const [lineNumber, isCovered] of Object.entries(lines)) {
+      fileObj.line.push({
+        '@num': Number(lineNumber),
+        '@count': isCovered === 1 ? 1 : 0,
+        '@type': 'stmt',
+      });
     }
     this.coverageObj.coverage.project.file.push(fileObj);
     const projectMetrics = this.coverageObj.coverage.project.metrics;

src/handlers/coberturaCoverageHandler.ts

@@ -1,8 +1,6 @@
 'use strict';
 
 import { CoberturaCoverageObject, CoberturaPackage, CoberturaClass, CoverageHandler } from '../helpers/types.js';
-import { setCoveredLinesCobertura } from '../helpers/setCoveredLinesCobertura.js';
-import { normalizePathToUnix } from '../helpers/normalizePathToUnix.js';
 
 export class CoberturaCoverageHandler implements CoverageHandler {
   private readonly coverageObj: CoberturaCoverageObject;
@@ -33,18 +31,16 @@ export class CoberturaCoverageHandler implements CoverageHandler {
     this.coverageObj.coverage.packages.package.push(this.packageObj);
   }
 
-  public async processFile(
+  public processFile(
     filePath: string,
     fileName: string,
     lines: Record<string, number>,
     uncoveredLines: number[],
     coveredLines: number[],
-    repoRoot: string,
-    reportType: 'test' | 'deploy'
-  ): Promise<void> {
+  ): void {
     const classObj: CoberturaClass = {
       '@name': fileName,
-      '@filename': normalizePathToUnix(filePath),
+      '@filename': filePath,
       '@line-rate': '0',
       '@branch-rate': '1',
       methods: {},
@@ -54,22 +50,12 @@ export class CoberturaCoverageHandler implements CoverageHandler {
     const totalLines = uncoveredLines.length + coveredLines.length;
     const coveredLineCount = coveredLines.length;
 
-    // Process lines for 'test' or 'deploy' reports
-    if (reportType === 'test') {
-      for (const [lineNumber, isCovered] of Object.entries(lines)) {
-        classObj.lines.line.push({
-          '@number': Number(lineNumber),
-          '@hits': isCovered === 1 ? 1 : 0,
-          '@branch': 'false',
-        });
-      }
-    } else if (reportType === 'deploy') {
-      classObj.lines.line = uncoveredLines.map((lineNumber) => ({
-        '@number': lineNumber,
-        '@hits': 0,
+    for (const [lineNumber, isCovered] of Object.entries(lines)) {
+      classObj.lines.line.push({
+        '@number': Number(lineNumber),
+        '@hits': isCovered === 1 ? 1 : 0,
         '@branch': 'false',
-      }));
-      await setCoveredLinesCobertura(coveredLines, uncoveredLines, repoRoot, filePath, classObj);
+      });
     }
 
     // Calculate and set the line rate for this class

src/handlers/lcovCoverageHandler.ts

@@ -1,8 +1,6 @@
 'use strict';
 
 import { CoverageHandler, LcovCoverageObject, LcovFile } from '../helpers/types.js';
-import { setCoveredLinesLcov } from '../helpers/setCoveredLinesLcov.js';
-import { normalizePathToUnix } from '../helpers/normalizePathToUnix.js';
 
 export class LcovCoverageHandler implements CoverageHandler {
   private readonly coverageObj: LcovCoverageObject;
@@ -11,35 +9,25 @@ export class LcovCoverageHandler implements CoverageHandler {
     this.coverageObj = { files: [] };
   }
 
-  public async processFile(
+  public processFile(
     filePath: string,
     fileName: string,
     lines: Record<string, number>,
     uncoveredLines: number[],
     coveredLines: number[],
-    repoRoot: string,
-    reportType: 'test' | 'deploy'
-  ): Promise<void> {
+  ): void {
     const lcovFile: LcovFile = {
-      sourceFile: normalizePathToUnix(filePath),
+      sourceFile: filePath,
       lines: [],
       totalLines: uncoveredLines.length + coveredLines.length,
       coveredLines: coveredLines.length,
     };
 
-    if (reportType === 'test') {
-      for (const [lineNumber, isCovered] of Object.entries(lines)) {
-        lcovFile.lines.push({
-          lineNumber: Number(lineNumber),
-          hitCount: isCovered === 1 ? 1 : 0,
-        });
-      }
-    } else if (reportType === 'deploy') {
-      lcovFile.lines = uncoveredLines.map((lineNumber) => ({
+    for (const [lineNumber, isCovered] of Object.entries(lines)) {
+      lcovFile.lines.push({
         lineNumber: Number(lineNumber),
-        hitCount: 0,
-      }));
-      await setCoveredLinesLcov(coveredLines, uncoveredLines, repoRoot, filePath, lcovFile);
+        hitCount: isCovered === 1 ? 1 : 0,
+      });
     }
 
     this.coverageObj.files.push(lcovFile);

src/handlers/sonarCoverageHandler.ts

@@ -1,8 +1,6 @@
 'use strict';
 
 import { SonarCoverageObject, SonarClass, CoverageHandler } from '../helpers/types.js';
-import { setCoveredLinesSonar } from '../helpers/setCoveredLinesSonar.js';
-import { normalizePathToUnix } from '../helpers/normalizePathToUnix.js';
 
 export class SonarCoverageHandler implements CoverageHandler {
   private readonly coverageObj: SonarCoverageObject;
@@ -11,35 +9,22 @@ export class SonarCoverageHandler implements CoverageHandler {
     this.coverageObj = { coverage: { '@version': '1', file: [] } };
   }
 
-  public async processFile(
+  public processFile(
     filePath: string,
     _fileName: string,
     lines: Record<string, number>,
-    uncoveredLines: number[],
-    coveredLines: number[],
-    repoRoot: string,
-    reportType: 'test' | 'deploy'
-  ): Promise<void> {
+  ): void {
     const fileObj: SonarClass = {
-      '@path': normalizePathToUnix(filePath),
+      '@path': filePath,
       lineToCover: [],
     };
-
-    if (reportType === 'test') {
-      for (const lineNumberString in lines) {
-        if (!Object.hasOwn(lines, lineNumberString)) continue;
-        const covered = lines[lineNumberString] === 1 ? 'true' : 'false';
-        fileObj.lineToCover.push({
-          '@lineNumber': Number(lineNumberString),
-          '@covered': covered,
-        });
-      }
-    } else if (reportType === 'deploy') {
-      fileObj.lineToCover = uncoveredLines.map((lineNumber) => ({
-        '@lineNumber': lineNumber,
-        '@covered': 'false',
-      }));
-      await setCoveredLinesSonar(coveredLines, uncoveredLines, repoRoot, filePath, fileObj);
+    for (const lineNumberString in lines) {
+      if (!Object.hasOwn(lines, lineNumberString)) continue;
+      const covered = lines[lineNumberString] === 1 ? 'true' : 'false';
+      fileObj.lineToCover.push({
+        '@lineNumber': Number(lineNumberString),
+        '@covered': covered,
+      });
     }
 
     this.coverageObj.coverage.file.push(fileObj);

src/helpers/findFilePath.ts

@@ -3,6 +3,7 @@
 
 import { readdir, stat } from 'node:fs/promises';
 import { join, relative } from 'node:path';
+import { normalizePathToUnix } from './normalizePathToUnix.js';
 
 export async function findFilePath(
   fileName: string,
@@ -13,6 +14,7 @@ export async function findFilePath(
   for (const directory of packageDirectories) {
     relativeFilePath = await findFilePathinDirectory(fileName, directory, repoRoot);
     if (relativeFilePath !== undefined) {
+      relativeFilePath = normalizePathToUnix(relativeFilePath)
       break;
     }
   }

src/helpers/setCoveredLines.ts

@@ -0,0 +1,34 @@
+'use strict';
+
+import { join } from 'node:path';
+import { getTotalLines } from './getTotalLines.js';
+
+export async function renumberLines(
+  filePath: string,
+  repoRoot: string,
+  lines: Record<string, number>
+): Promise<Record<string, number>> {
+  const totalLines = await getTotalLines(join(repoRoot, filePath));
+  const updatedLines: Record<string, number> = {};
+  const usedLines = new Set<number>();
+
+  for (const [line, status] of Object.entries(lines)) {
+    const lineNumber = parseInt(line, 10);
+
+    if (status === 1 && lineNumber > totalLines) {
+      // Find the first valid line number not already used
+      for (let randomLine = 1; randomLine <= totalLines; randomLine++) {
+        if (!usedLines.has(randomLine)) {
+          updatedLines[randomLine.toString()] = status;
+          usedLines.add(randomLine);
+          break;
+        }
+      }
+    } else {
+      updatedLines[line] = status;
+      usedLines.add(lineNumber);
+    }
+  }
+
+  return updatedLines;
+}