covgate 0.0.0-stage → 0.2.0

package/src/coverage/istanbul.js

@@ -0,0 +1,215 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { CoverageDataError } from "../errors.js";
+import { canonicalPath } from "../util.js";
+import {
+  createFileCoverage,
+  deriveLinesFromStatements,
+  mergeFileCoverage
+} from "./model.js";
+import { resolveCoverageSourcePath } from "./paths.js";
+
+/**
+ * @param {unknown} value
+ * @returns {value is Record<string, any>}
+ */
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * @param {any} data
+ * @param {string} reportPath
+ */
+function entriesFromReport(data, reportPath) {
+  if (Array.isArray(data)) return data;
+  if (!isObject(data)) {
+    throw new CoverageDataError(`Istanbul 报告不是对象：${reportPath}`);
+  }
+  if (
+    typeof data.path === "string" &&
+    (isObject(data.statementMap) || isObject(data.s))
+  ) {
+    return [data];
+  }
+  const values = Object.values(data).filter(
+    (value) => isObject(value) && typeof value.path === "string"
+  );
+  if (values.length === 0) {
+    throw new CoverageDataError(
+      `在 ${reportPath} 中找不到 Istanbul 文件覆盖率记录；请确认 coverage-final.json 的格式，或把 coverage.format 设为正确值。`
+    );
+  }
+  return values;
+}
+
+/**
+ * @param {any} value
+ * @param {string} key
+ * @param {string} message
+ */
+function integerCount(value, key, message) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new CoverageDataError(message);
+  }
+  return value;
+}
+
+/**
+ * @param {any} entry
+ * @param {string} reportPath
+ * @param {string} root
+ */
+function normalizeEntry(entry, reportPath, root) {
+  if (typeof entry.path !== "string") {
+    throw new CoverageDataError(`Istanbul 记录缺少 path 字段：${reportPath}`);
+  }
+  const absPath = resolveCoverageSourcePath(entry.path, root);
+  const file = createFileCoverage(absPath, "istanbul", root);
+  const statementMap = isObject(entry.statementMap) ? entry.statementMap : {};
+  const statementCounts = isObject(entry.s) ? entry.s : {};
+  for (const [id, location] of Object.entries(statementMap)) {
+    if (!isObject(location) || !isObject(location.start) || !isObject(location.end)) {
+      throw new CoverageDataError(`${reportPath}: 无效的 statementMap 记录 ${id}`);
+    }
+    const startLine = Number(location.start.line);
+    const startColumn = Number(location.start.column ?? 0);
+    const endLine = Number(location.end.line ?? location.start.line);
+    const endColumn = Number(location.end.column ?? startColumn);
+    const key = `${startLine}:${startColumn}:${endLine}:${endColumn}`;
+    const count = integerCount(
+      statementCounts[id] ?? 0,
+      key,
+      `${reportPath}: 无效的语句计数 ${id}`
+    );
+    file.statements?.set(key, {
+      key,
+      line: startLine,
+      column: startColumn,
+      endLine,
+      count
+    });
+  }
+  const fnMap = isObject(entry.fnMap) ? entry.fnMap : {};
+  const fnCounts = isObject(entry.f) ? entry.f : {};
+  for (const [id, meta] of Object.entries(fnMap)) {
+    if (!isObject(meta)) {
+      throw new CoverageDataError(`${reportPath}: 无效的 fnMap 记录 ${id}`);
+    }
+    const decl = isObject(meta.decl)
+      ? meta.decl
+      : isObject(meta.loc)
+        ? meta.loc
+        : null;
+    const start = decl && isObject(decl.start) ? decl.start : null;
+    const end = decl && isObject(decl.end) ? decl.end : start;
+    const line = Number(meta.line ?? start?.line ?? 0);
+    const column = Number(start?.column ?? 0);
+    const endLine = Number(end?.line ?? line);
+    const name = String(meta.name ?? `fn@${line}`);
+    const key = `${line}:${column}:${name}`;
+    const count = integerCount(
+      fnCounts[id] ?? 0,
+      key,
+      `${reportPath}: 无效的函数计数 ${id}`
+    );
+    file.functions.set(key, { key, name, line, column, endLine, count });
+  }
+  const branchMap = isObject(entry.branchMap) ? entry.branchMap : {};
+  const branchCounts = isObject(entry.b) ? entry.b : {};
+  for (const [id, meta] of Object.entries(branchMap)) {
+    if (!isObject(meta)) {
+      throw new CoverageDataError(`${reportPath}: 无效的 branchMap 记录 ${id}`);
+    }
+    const locations = Array.isArray(meta.locations) ? meta.locations : [];
+    const groupLoc = isObject(meta.loc) ? meta.loc : null;
+    const groupStart = groupLoc && isObject(groupLoc.start) ? groupLoc.start : null;
+    const groupLine = Number(groupStart?.line ?? 0);
+    const groupColumn = Number(groupStart?.column ?? 0);
+    const type = String(meta.type ?? "branch");
+    const counts = Array.isArray(branchCounts[id]) ? branchCounts[id] : [];
+    if (locations.length === 0) {
+      const key = `${groupLine}:${groupColumn}:${type}:0`;
+      const count = integerCount(
+        counts[0] ?? 0,
+        key,
+        `${reportPath}: 无效的分支计数 ${id}`
+      );
+      file.branches.set(key, {
+        key,
+        line: groupLine,
+        column: groupColumn,
+        type,
+        groupLine,
+        index: 0,
+        count
+      });
+      continue;
+    }
+    locations.forEach((location, index) => {
+      const start = isObject(location) && isObject(location.start)
+        ? location.start
+        : null;
+      const line = Number(start?.line ?? groupLine);
+      const column = Number(start?.column ?? groupColumn);
+      const key = `${groupLine}:${groupColumn}:${type}:${index}`;
+      const count = integerCount(
+        counts[index] ?? 0,
+        key,
+        `${reportPath}: 无效的分支计数 ${id}[${index}]`
+      );
+      file.branches.set(key, {
+        key,
+        line,
+        column,
+        type,
+        groupLine,
+        index,
+        count
+      });
+    });
+  }
+  file.lines = deriveLinesFromStatements(file.statements);
+  return file;
+}
+
+/**
+ * @param {string[]} reportFiles
+ * @param {string} root
+ */
+export async function parseIstanbulReports(reportFiles, root) {
+  /** @type {Map<string, import("./model.js").FileCoverage>} */
+  const files = new Map();
+  for (const reportFile of reportFiles) {
+    let text;
+    try {
+      text = await readFile(reportFile, "utf8");
+    } catch (error) {
+      throw new CoverageDataError(
+        `无法读取覆盖率报告 ${reportFile}: ${error.message}`,
+        { cause: error }
+      );
+    }
+    let data;
+    try {
+      data = JSON.parse(text.replace(/^\uFEFF/, ""));
+    } catch (error) {
+      throw new CoverageDataError(
+        `无法解析 Istanbul JSON 报告 ${reportFile}: ${error.message}`,
+        { cause: error }
+      );
+    }
+    const entries = entriesFromReport(data, reportFile);
+    for (const entry of entries) {
+      if (!isObject(entry)) {
+        throw new CoverageDataError(`Istanbul 报告包含非对象记录：${reportFile}`);
+      }
+      const file = normalizeEntry(entry, reportFile, root);
+      const key = canonicalPath(file.absPath);
+      const existing = files.get(key);
+      if (existing) mergeFileCoverage(existing, file);
+      else files.set(key, file);
+    }
+  }
+  return files;
+}

package/src/coverage/lcov.js

@@ -0,0 +1,234 @@
+import { readFile } from "node:fs/promises";
+import { CoverageDataError } from "../errors.js";
+import { canonicalPath } from "../util.js";
+import { createFileCoverage, mergeFileCoverage } from "./model.js";
+import { resolveCoverageSourcePath } from "./paths.js";
+
+/**
+ * @param {string} text
+ * @param {string} reportFile
+ * @param {string} root
+ * @returns {Map<string, import("./model.js").FileCoverage>}
+ */
+export function parseLcovText(text, reportFile, root) {
+  /** @type {Map<string, import("./model.js").FileCoverage>} */
+  const files = new Map();
+  let current = null;
+  /** @type {Array<{ name: string, line: number, endLine: number, count?: number }>} */
+  let functionDefs = [];
+  /** @type {Array<{ name: string, count: number }>} */
+  let functionHits = [];
+  let sawAnyRecord = false;
+
+  const flush = () => {
+    if (!current) return;
+    if (!current.sourcePath) {
+      current = null;
+      return;
+    }
+    const absPath = resolveCoverageSourcePath(current.sourcePath, root);
+    const file = createFileCoverage(absPath, "lcov", root);
+
+    const defsByName = new Map();
+    for (const definition of functionDefs) {
+      const list = defsByName.get(definition.name) ?? [];
+      list.push(definition);
+      defsByName.set(definition.name, list);
+    }
+    const assigned = new Set();
+    for (const hit of functionHits) {
+      const candidates = defsByName.get(hit.name) ?? [];
+      let definition = candidates.find((item) => !assigned.has(item));
+      if (!definition && candidates.length > 0) definition = candidates[0];
+      if (definition) {
+        assigned.add(definition);
+        definition.count = (definition.count ?? 0) + hit.count;
+      } else {
+        const line = 0;
+        const key = `${line}:0:${hit.name}`;
+        const existing = file.functions.get(key);
+        if (existing) existing.count += hit.count;
+        else {
+          file.functions.set(key, {
+            key,
+            name: hit.name,
+            line,
+            column: 0,
+            endLine: line,
+            count: hit.count
+          });
+        }
+      }
+    }
+    for (const definition of functionDefs) {
+      if (assigned.has(definition)) continue;
+      const key = `${definition.line}:0:${definition.name}`;
+      if (!file.functions.has(key)) {
+        file.functions.set(key, {
+          key,
+          name: definition.name,
+          line: definition.line,
+          column: 0,
+          endLine: definition.endLine,
+          count: 0
+        });
+      }
+    }
+    for (const definition of functionDefs) {
+      if (definition.count === undefined) continue;
+      const key = `${definition.line}:0:${definition.name}`;
+      const existing = file.functions.get(key);
+      if (existing) {
+        existing.count = Math.max(existing.count, definition.count);
+      } else {
+        file.functions.set(key, {
+          key,
+          name: definition.name,
+          line: definition.line,
+          column: 0,
+          endLine: definition.endLine,
+          count: definition.count
+        });
+      }
+    }
+
+    for (const line of current.lines) {
+      const existing = file.lines.get(line.number);
+      if (existing === undefined || line.count > existing) {
+        file.lines.set(line.number, line.count);
+      }
+    }
+    for (const branch of current.branches) {
+      const key = `${branch.line}:${branch.block}:${branch.branch}`;
+      const existing = file.branches.get(key);
+      if (existing) existing.count += branch.taken;
+      else {
+        file.branches.set(key, {
+          key,
+          line: branch.line,
+          column: 0,
+          type: "branch",
+          groupLine: branch.line,
+          index: branch.branch,
+          count: branch.taken
+        });
+      }
+    }
+    const mapKey = canonicalPath(file.absPath);
+    const existingFile = files.get(mapKey);
+    if (existingFile) mergeFileCoverage(existingFile, file);
+    else files.set(mapKey, file);
+    current = null;
+    functionDefs = [];
+    functionHits = [];
+  };
+
+  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    if (line.startsWith("SF:")) {
+      if (current) flush();
+      current = { sourcePath: line.slice(3).trim(), lines: [], branches: [] };
+      functionDefs = [];
+      functionHits = [];
+      sawAnyRecord = true;
+      continue;
+    }
+    if (!current) continue;
+    if (line === "end_of_record") {
+      flush();
+      continue;
+    }
+    if (line.startsWith("DA:")) {
+      const fields = line.slice(3).split(",");
+      const number = Number(fields[0]);
+      const count = Number(fields[1] ?? 0);
+      if (!Number.isInteger(number) || number <= 0 || !Number.isFinite(count)) {
+        throw new CoverageDataError(`${reportFile}: 无效的 DA 记录：${line}`);
+      }
+      current.lines.push({ number, count: Math.max(0, count) });
+      continue;
+    }
+    if (line.startsWith("FN:")) {
+      const fields = line.slice(3).split(",");
+      if (fields.length >= 3 && /^\d+$/.test(fields[0]) && /^\d+$/.test(fields[1])) {
+        const startLine = Number(fields[0]);
+        const endLine = Number(fields[1]);
+        const name = fields.slice(2).join(",");
+        if (name) functionDefs.push({ name, line: startLine, endLine });
+      } else {
+        const startLine = Number(fields[0]);
+        const name = fields.slice(1).join(",");
+        if (Number.isInteger(startLine) && startLine > 0 && name) {
+          functionDefs.push({ name, line: startLine, endLine: startLine });
+        }
+      }
+      continue;
+    }
+    if (line.startsWith("FNDA:")) {
+      const separator = line.indexOf(",", 5);
+      if (separator === -1) continue;
+      const count = Number(line.slice(5, separator));
+      const name = line.slice(separator + 1);
+      if (Number.isFinite(count) && name) {
+        functionHits.push({ name, count: Math.max(0, count) });
+      }
+      continue;
+    }
+    if (line.startsWith("BRDA:")) {
+      const fields = line.slice(5).split(",");
+      if (fields.length < 4) continue;
+      const number = Number(fields[0]);
+      const block = Number(fields[1]);
+      const branch = Number(fields[2]);
+      const takenRaw = fields[3];
+      const taken = takenRaw === "-" ? 0 : Number(takenRaw);
+      if (
+        !Number.isInteger(number) ||
+        !Number.isInteger(block) ||
+        !Number.isInteger(branch) ||
+        !Number.isFinite(taken)
+      ) {
+        throw new CoverageDataError(`${reportFile}: 无效的 BRDA 记录：${line}`);
+      }
+      current.branches.push({
+        line: number,
+        block,
+        branch,
+        taken: Math.max(0, taken)
+      });
+    }
+  }
+  if (current) flush();
+  if (!sawAnyRecord) {
+    throw new CoverageDataError(`${reportFile} 中没有找到任何 LCOV SF 记录`);
+  }
+  return files;
+}
+
+/**
+ * @param {string[]} reportFiles
+ * @param {string} root
+ */
+export async function parseLcovReports(reportFiles, root) {
+  /** @type {Map<string, import("./model.js").FileCoverage>} */
+  const files = new Map();
+  for (const reportFile of reportFiles) {
+    let text;
+    try {
+      text = await readFile(reportFile, "utf8");
+    } catch (error) {
+      throw new CoverageDataError(
+        `无法读取 LCOV 报告 ${reportFile}: ${error.message}`,
+        { cause: error }
+      );
+    }
+    const parsed = parseLcovText(text.replace(/^\uFEFF/, ""), reportFile, root);
+    for (const [key, file] of parsed) {
+      const existing = files.get(key);
+      if (existing) mergeFileCoverage(existing, file);
+      else files.set(key, file);
+    }
+  }
+  return files;
+}