// Shared JaCoCo XML parser used by CI workflows.

// Extracts overall and per-class coverage counters from a JaCoCo XML report.

const fs = require('fs');

const zeroCov = { covered: 0, missed: 0 };

function parseJacocoXml(jacocoFile) {

const result = { overall: {}, classes: {} };

if (!fs.existsSync(jacocoFile)) {

return null;

}

const xml = fs.readFileSync(jacocoFile, 'utf8');

// Overall counters (outside <package> tags)

const stripped = xml.replace(/<package[\s\S]*?<\/package>/g, '');

const re = /<counter type="(\w+)" missed="(\d+)" covered="(\d+)"\/>/g;

let m;

while ((m = re.exec(stripped)) !== null) {

const entry = { covered: parseInt(m[3]), missed: parseInt(m[2]) };

if (m[1] === 'LINE') result.overall.line = entry;

else if (m[1] === 'BRANCH') result.overall.branch = entry;

else if (m[1] === 'METHOD') result.overall.method = entry;

}

// Per-class counters from <package>/<class> elements.

// The negative lookbehind (?<!\/) prevents matching self-closing <class .../> tags

// (interfaces, annotations) which have no body and would otherwise steal the next

// class's counters.

const pkgRe = /<package\s+name="([^"]+)">([\s\S]*?)<\/package>/g;

let pkgMatch;

while ((pkgMatch = pkgRe.exec(xml)) !== null) {

const pkgBody = pkgMatch[2];

const classRe = /<class\s+name="([^"]+)"[^>]*(?<!\/)>([\s\S]*?)<\/class>/g;

let classMatch;

while ((classMatch = classRe.exec(pkgBody)) !== null) {

const className = classMatch[1].replace(/\//g, '.');

const classBody = classMatch[2];

const counters = { line: { ...zeroCov }, branch: { ...zeroCov }, method: { ...zeroCov } };

const cntRe = /<counter type="(\w+)" missed="(\d+)" covered="(\d+)"\/>/g;

let cntMatch;

while ((cntMatch = cntRe.exec(classBody)) !== null) {

const entry = { covered: parseInt(cntMatch[3]), missed: parseInt(cntMatch[2]) };

if (cntMatch[1] === 'LINE') counters.line = entry;

else if (cntMatch[1] === 'BRANCH') counters.branch = entry;

else if (cntMatch[1] === 'METHOD') counters.method = entry;

}

// Extract per-method counters within this class.

// JaCoCo XML contains <method name="..." desc="..." line="..."> elements

// each with their own <counter> children.

const methods = [];

const methodRe = /<method\s+name="([^"]+)"\s+desc="([^"]+)"(?:\s+line="(\d+)")?[^>]*>([\s\S]*?)<\/method>/g;

let methodMatch;

while ((methodMatch = methodRe.exec(classBody)) !== null) {

const mCounters = { line: { ...zeroCov }, branch: { ...zeroCov }, method: { ...zeroCov } };

const mCntRe = /<counter type="(\w+)" missed="(\d+)" covered="(\d+)"\/>/g;

let mCntMatch;

while ((mCntMatch = mCntRe.exec(methodMatch[4])) !== null) {

const entry = { covered: parseInt(mCntMatch[3]), missed: parseInt(mCntMatch[2]) };

if (mCntMatch[1] === 'LINE') mCounters.line = entry;

else if (mCntMatch[1] === 'BRANCH') mCounters.branch = entry;

else if (mCntMatch[1] === 'METHOD') mCounters.method = entry;

}

const totalLines = mCounters.line.covered + mCounters.line.missed;

if (totalLines > 0) {

methods.push({

name: methodMatch[1],

desc: methodMatch[2],

line: methodMatch[3] ? parseInt(methodMatch[3]) : null,

counters: mCounters,

});

}

}

// Skip classes with 0 total lines (empty interfaces, annotations)

if (counters.line.covered + counters.line.missed > 0) {

result.classes[className] = counters;

if (methods.length > 0) {

result.classes[className].methods = methods;

}

}

}

}

return result;

}

function pct(covered, missed) {

const total = covered + missed;

return total === 0 ? 0 : (covered / total * 100);

}

// A coverage metric is a "real regression" when BOTH the percentage drops

// beyond the tolerance AND the absolute number of missed items increases.

// This avoids false positives when well-covered code is extracted/moved out

// of a class (which lowers the percentage without actually losing coverage).

function isRegression(currPct, basePct, currMissed, baseMissed, tolerance = 0.05) {

return currPct < basePct - tolerance && currMissed > baseMissed;

}

module.exports = { parseJacocoXml, pct, zeroCov, isRegression };