CI/code coverage improvement (#71)

* fix(ci): Remove unsupported branch coverage

* feat(ci): Compress uncovered lines into ranges

AI-assisted-by: Gemini 2.5 Pro

correct readme

feat(ci): check for uncovered lines in PRs

Adds a new step to the CI workflow to check for uncovered lines in pull requests.

This is done by:
- A new Python script that compares the git diff of the PR with the Cobertura coverage report.
- The script outputs a list of uncovered lines that are part of the PR's changes.
- The CI workflow is updated to run this script and post the results as a comment on the PR.
- The PR comment is updated on subsequent pushes to avoid spamming.

AI-assisted-by: Gemini 2.5 Pro

fix(ci): always post new coverage comment

Removes the logic for editing existing PR comments for code coverage.
The CI will now post a new comment on every run, as requested.

This resolves the error from the previous CI run where the '--edit' flag
for 'gh pr comment' was causing a failure.

AI-assisted-by: Gemini 2.5 Pro

* correct script path

Author: dustinblack

.github/scripts/check_pr_coverage.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+
+import os
+import subprocess
+import sys
+import xml.etree.ElementTree as ET
+from collections import defaultdict
+
+
+def get_pr_diff(base_branch):
+    """
+    Get the diff of the current branch against the base branch and return a dictionary
+    mapping file paths to a set of added or modified line numbers.
+    """
+    diff_files = defaultdict(set)
+    # We fetch the base branch to ensure it's available for diffing
+    subprocess.run(
+        ["git", "fetch", "origin", base_branch],
+        check=True,
+        capture_output=True,
+    )
+    result = subprocess.run(
+        ["git", "diff", f"origin/{base_branch}", "--unified=0"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    file_path = None
+    for line in result.stdout.splitlines():
+        if line.startswith("+++ b/"):
+            file_path = line[6:]
+        elif line.startswith("@@"):
+            parts = line.split(" ")
+            if len(parts) > 2 and parts[2].startswith("+"):
+                line_info = parts[2][1:].split(",")
+                start_line = int(line_info[0])
+                num_lines = int(line_info[1]) if len(line_info) > 1 else 1
+                for i in range(num_lines):
+                    diff_files[file_path].add(start_line + i)
+    return diff_files
+
+
+def get_uncovered_lines(cobertura_path):
+    """
+    Parse the Cobertura XML report and return a dictionary mapping file paths
+    to a set of uncovered line numbers.
+    """
+    uncovered_lines = defaultdict(set)
+    if not os.path.exists(cobertura_path):
+        print(f"Error: Coverage report not found at {cobertura_path}", file=sys.stderr)
+        sys.exit(1)
+
+    tree = ET.parse(cobertura_path)
+    root = tree.getroot()
+    packages = root.find("packages")
+    if packages is None:
+        return uncovered_lines
+
+    for package in packages.findall("package"):
+        classes = package.find("classes")
+        if classes is None:
+            continue
+        for klass in classes.findall("class"):
+            file_path = klass.attrib["filename"]
+            lines = klass.find("lines")
+            if lines is None:
+                continue
+            for line in lines.findall("line"):
+                if line.attrib["hits"] == "0":
+                    uncovered_lines[file_path].add(int(line.attrib["number"]))
+    return uncovered_lines
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python check_pr_coverage.py <base-branch>", file=sys.stderr)
+        sys.exit(1)
+
+    base_branch = sys.argv[1]
+    cobertura_xml_path = "./coverage-reports/cobertura.xml"
+
+    try:
+        pr_diff = get_pr_diff(base_branch)
+        uncovered_lines = get_uncovered_lines(cobertura_xml_path)
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    uncovered_in_pr = defaultdict(list)
+    for file_path, changed_lines in pr_diff.items():
+        if file_path in uncovered_lines:
+            intersection = sorted(list(changed_lines.intersection(uncovered_lines[file_path])))
+            if intersection:
+                uncovered_in_pr[file_path] = intersection
+
+    if uncovered_in_pr:
+        print("### 🚨 Uncovered lines in this PR\n")
+        for file_path, lines in uncovered_in_pr.items():
+            lines_str = ", ".join(map(str, lines))
+            print(f"- **{file_path}:** `{lines_str}`")
+    else:
+        print("### ✅ All new and modified lines are covered by tests!")
+
+
+if __name__ == "__main__":
+    main()

.github/workflows/ci.yml

@@ -243,7 +243,6 @@ jobs:
           --verbose \
           --all-features \
           --workspace \
-          --branch \
           --engine llvm \
           --timeout 120 \
           --out Xml \
@@ -269,15 +268,35 @@ jobs:
         import xml.etree.ElementTree as ET
         import os
 
+        def to_ranges(numbers):
+            if not numbers:
+                return ""
+            numbers = sorted([int(n) for n in numbers])
+            ranges = []
+            start = end = numbers[0]
+            for n in numbers[1:]:
+                if n == end + 1:
+                    end = n
+                else:
+                    if start == end:
+                        ranges.append(str(start))
+                    else:
+                        ranges.append(f"{start}-{end}")
+                    start = end = n
+            if start == end:
+                ranges.append(str(start))
+            else:
+                ranges.append(f"{start}-{end}")
+            return ", ".join(ranges)
+
         tree = ET.parse("./coverage-reports/cobertura.xml")
         root = tree.getroot()
         line_rate = float(root.attrib["line-rate"]) * 100
-        branch_rate = float(root.attrib["branch-rate"]) * 100
 
         with open("./coverage-reports/coverage-summary.md", "w") as f:
             f.write("### 📊 Code Coverage Summary\n\n")
-            f.write("| File | Line Coverage | Branch Coverage | Uncovered Lines |\n")
-            f.write("|------|---------------|-----------------|-----------------|\n")
+            f.write("| File | Line Coverage | Uncovered Lines |\n")
+            f.write("|------|---------------|-----------------|\n")
 
             packages = root.find("packages")
             all_classes = []
@@ -295,7 +314,6 @@ jobs:
                 if "target/debug/build" in filename:
                     continue
                 line_rate_class = float(klass.attrib["line-rate"]) * 100
-                branch_rate_class = float(klass.attrib["branch-rate"]) * 100
                 
                 uncovered_lines = []
                 lines = klass.find("lines")
@@ -304,10 +322,10 @@ jobs:
                         if line.attrib["hits"] == "0":
                             uncovered_lines.append(line.attrib["number"])
                 
-                uncovered_lines_str = ", ".join(uncovered_lines)
-                f.write(f"| `{filename}` | {line_rate_class:.2f}% | {branch_rate_class:.2f}% | `{uncovered_lines_str}` |\n")
+                uncovered_lines_str = to_ranges(uncovered_lines)
+                f.write(f"| `{filename}` | {line_rate_class:.2f}% | `{uncovered_lines_str}` |\n")
 
-            f.write(f"| **Total** | **{line_rate:.2f}%** | **{branch_rate:.2f}%** | | \n")
+            f.write(f"| **Total** | **{line_rate:.2f}%** | | \n")
         '
     - name: Add Markdown summary table to Job Summary
       run: |
@@ -330,21 +348,35 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+        with:
+          # Fetch the full history to allow diff-coverage checking
+          fetch-depth: 0
       - name: Download coverage report artifact
         uses: actions/download-artifact@v4
         with:
           name: coverage-reports
           path: ./coverage-reports/
 
+      - name: Check for uncovered lines in PR
+        id: pr_coverage_check
+        run: |
+          set -e
+          echo "PR_COVERAGE_REPORT=$(./.github/scripts/check_pr_coverage.py ${{ github.base_ref }})" >> $GITHUB_OUTPUT
+
       - name: Post Coverage Comment
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           PR_NUMBER: ${{ github.event.pull_request.number }}
         run: |
           MARKER="<!-- gemini-coverage-comment -->"
           BODY=$(cat ./coverage-reports/coverage-summary.md)
+          PR_COVERAGE_REPORT="${{ steps.pr_coverage_check.outputs.PR_COVERAGE_REPORT }}"
+          
           COMMENT_BODY="$MARKER
+          $PR_COVERAGE_REPORT
+
           $BODY"
+          
           gh pr comment "$PR_NUMBER" --body "$COMMENT_BODY"
 
   benchmarks:

README.md

@@ -435,7 +435,7 @@ This project uses GitHub Actions for continuous integration. The CI pipeline is
 
 - **Linting and Formatting**: Ensures code style and quality using `cargo fmt` and `cargo clippy`.
 - **Testing**: Runs the full test suite on stable, beta, and MSRV Rust across Linux, Windows, and macOS.
-- **Code Coverage**: Generates a code coverage report using `cargo-tarpaulin` and uploads it to Codecov.
+- **Code Coverage**: Generates a code coverage report using `cargo-tarpaulin`.
 - **Security Audit**: Scans for vulnerabilities using `cargo audit`.
 - **Docker Build**: Validates that the Docker image can be built and run successfully.