#mooncov

#Why this exists

• merging unit, integration, and backend-specific coverage;
• converting MoonBit's Coveralls JSON into LCOV for another CI consumer;
• excluding generated or vendored sources with portable globs;
• failing CI when line, branch, or function coverage drops below a threshold;
• checking only instrumented lines touched by a unified Git diff;
• posting a compact Markdown table to a pull request;
• retaining all three coverage dimensions in a stable JSON artifact.

#Feature matrix

#Installation

moon add Xpeng/mooncov

import {
  "Xpeng/mooncov",
}

moon check --target all --deny-warn
moon test --target all --deny-warn

#Quick start: parse and summarize LCOV

///|
test "README: parse and summarize LCOV" {
  let input =
    #|TN:unit
    #|SF:src/lib.mbt
    #|FN:1,run
    #|FNDA:2,run
    #|DA:1,2
    #|DA:2,0
    #|BRDA:2,0,0,1
    #|BRDA:2,0,1,0
    #|end_of_record
    #|
  let report = @mooncov.parse_lcov(input)
  let summary = @mooncov.summarize(report)
  inspect(summary.lines.covered, content="1")
  inspect(summary.lines.total, content="2")
  inspect(summary.branches.covered, content="1")
  inspect(summary.functions.covered, content="1")
}

#Merge reports and enforce policy

///|
test "README: merge and gate reports" {
  let first = @mooncov.parse_lcov(
    "SF:src/lib.mbt\nDA:1,1\nDA:2,0\nend_of_record\n",
  )
  let second = @mooncov.parse_lcov(
    "SF:src/lib.mbt\nDA:1,2\nDA:2,1\nend_of_record\n",
  )
  let merged = @mooncov.merge_reports([first, second])
  inspect(merged.files[0].lines[0].hits, content="3")
  inspect(merged.files[0].lines[1].hits, content="1")
  let gate = @mooncov.check_thresholds(
    merged,
    @mooncov.CoverageThresholds::new(lines=100.0),
  )
  assert_true(gate.passed)
}

• file: normalized source path;
• line: source line number;
• branch: line, block identifier, and branch identifier;
• function: function name and optional declaration line.

#Compare against a baseline

///|
test "README: baseline regression policy" {
  let baseline = @mooncov.parse_lcov(
    "SF:src/a.mbt\nDA:1,1\nDA:2,1\nend_of_record\n",
  )
  let current = @mooncov.parse_lcov(
    "SF:src/a.mbt\nDA:1,1\nDA:2,0\nend_of_record\n",
  )
  let comparison = @mooncov.compare_reports(baseline, current)
  inspect(comparison.lines.percentage_delta, content="-50")
  let result = @mooncov.check_regressions(
    baseline,
    current,
    @mooncov.RegressionLimits::new(lines=50.0),
  )
  assert_true(result.passed)
}

#Path normalization and filtering

///|
test "README: normalize and filter paths" {
  let report = @mooncov.parse_lcov(
    "SF:D:\\repo\\src\\lib.mbt\nDA:1,1\nend_of_record\n" +
    "SF:D:\\repo\\generated\\api.mbt\nDA:1,1\nend_of_record\n",
    strip_prefix="D:/repo",
  )
  let selected = @mooncov.select_paths(report, ["src/**/*.mbt"], [
    "**/generated/**",
  ])
  inspect(selected.files.length(), content="1")
  inspect(selected.files[0].path, content="src/lib.mbt")
}

• * matches zero or more characters inside one segment;
• ? matches one non-separator character;
• ** can cross path separators;
• excludes are applied after includes and always win;
• an empty include list accepts all paths.

#Changed-line coverage

///|
test "README: changed-line gate" {
  let report = @mooncov.parse_lcov(
    "SF:src/lib.mbt\nDA:10,1\nDA:11,0\nend_of_record\n",
  )
  let diff =
    #|--- a/src/lib.mbt
    #|+++ b/src/lib.mbt
    #|@@ -9,0 +10,2 @@
    #|+covered
    #|+missed
    #|
  let ranges = @mooncov.parse_unified_diff(diff)
  let result = @mooncov.check_diff_threshold(report, ranges, 50.0)
  assert_true(result.passed)
  inspect(result.summary.lines.total, content="2")
}

#Coveralls JSON

///|
test "README: Coveralls to LCOV" {
  let coveralls = "{\"source_files\":[{\"name\":\"src/a.mbt\"," +
    "\"coverage\":[1,0,null],\"branches\":[2,0,0,0]}]}"
  let report = @mooncov.parse_coveralls(coveralls)
  let lcov = @mooncov.to_lcov(report)
  assert_true(lcov.contains("DA:1,1"))
  assert_true(lcov.contains("DA:2,0"))
  assert_true(lcov.contains("BRDA:2,0,0,0"))
}

#Cobertura XML

///|
test "README: Cobertura interoperability" {
  let xml =
    #|<coverage><packages><package><classes>
    #|  <class filename="src/a.mbt">
    #|    <lines>
    #|      <line number="1" hits="2"/>
    #|      <line number="2" hits="0" branch="true"
    #|        condition-coverage="50% (1/2)"/>
    #|    </lines>
    #|  </class>
    #|</classes></package></packages></coverage>
  let report = @mooncov.parse_cobertura(xml)
  inspect(@mooncov.summarize(report).branches.total, content="2")
  let encoded = @mooncov.to_cobertura(report)
  assert_true(encoded.contains("branches-valid=\"2\""))
}

#Output APIs

///|
let lcov : String = @mooncov.to_lcov(report)

///|
let coveralls : String = @mooncov.to_coveralls_json(
  report,
  service_name="github-actions",
  service_job_id="build-42",
)

///|
let cobertura : String = @mooncov.to_cobertura(report)

///|
let markdown : String = @mooncov.to_markdown(report)

///|
let json : String = @mooncov.to_json_report(report)

#Command-line example

# Built-in demo; no input file required
moon run cmd/main

# Reproduce the repository sample
moon run cmd/main -- summary lcov examples/sample.info
moon run cmd/main -- validate lcov examples/sample.info
moon run cmd/main -- summary cobertura examples/sample.xml

# Convert any accepted format to canonical LCOV or full JSON
moon run cmd/main -- normalize coveralls path/to/coverage.json
moon run cmd/main -- json lcov path/to/lcov.info

# Exit with code 2 if line coverage is below 80%
moon run cmd/main -- gate lcov path/to/lcov.info 80

# Merge two or more inputs of the same format and print LCOV
moon run cmd/main -- merge lcov unit.info integration.info

# Compare two reports or allow at most a 2-point line-coverage drop
moon run cmd/main -- compare lcov baseline.info current.info
moon run cmd/main -- regress lcov baseline.info current.info 2

#Public API overview

• Model: CoverageReport, FileCoverage, CoverageLine, CoverageBranch, CoverageFunction;
• Formats: parse_lcov, to_lcov, parse_coveralls, to_coveralls_json, parse_cobertura, to_cobertura;
• Composition: merge_reports, canonicalize_report;
• Paths: normalize_path, glob_match, PathFilter, filter_report, select_paths;
• Statistics: summarize, summarize_file, summarize_files;
• Gates: CoverageThresholds, check_thresholds, gate_message;
• Comparison: compare_reports, RegressionLimits, check_regressions, comparison_to_markdown, regression_message;
• Diff: parse_unified_diff, summarize_diff, check_diff_threshold;
• Reports: to_markdown, to_json_report.

#Reproducible verification

moon fmt --check
moon info --target all
moon check --target all --deny-warn --warn-list +73
moon test --target all --deny-warn
moon build --target all
moon run cmd/main
moon run cmd/main -- summary lcov examples/sample.info
moon run cmd/main -- summary cobertura examples/sample.xml
moon package
git diff --exit-code

#Scope and compatibility notes

• LCOV extension tags other than VER are rejected rather than silently discarded; standard aggregate tags are accepted.
• LCOV function names may contain commas because only the first comma separates their numeric field.
• Coveralls numeric coverage values must be finite, integral, and non-negative.
• Current MoonBit Windows Coveralls output with bare path separators is accepted through a strict-first, invalid-escape-only source_files[].name repair.
• Cobertura XML supports class lines, method lines, standard XML attribute entities, and condition-coverage; DTD validation is intentionally out of scope.
• Path matching preserves case; callers targeting case-insensitive filesystems may normalize case before constructing reports.
• Unified-diff parsing handles standard Git destination headers, optional tab timestamps, destination ranges with omitted counts, new files, and deleted files. Git C-style escape sequences inside quoted path headers are not decoded in 0.1.0.
• Hit-count addition uses MoonBit Int; inputs should stay within that type's range.

#Project origin and open-source compliance

• LCOV tracefile format;
• Coveralls JSON format;
• Cobertura XML project;
• MoonBit coverage tooling.

#Contributing

#License