Branch coverage

CONTRIBUTING.md

@@ -64,3 +64,16 @@ To run the end-to-end tests, you'll need:
 - Please be aware that the tests will launch `gh auth setup-git` which might be
   surprising if you use `https` remotes (sadly, setting `GIT_CONFIG_GLOBAL`
   seems not to be enough to isolate tests.)
+
+## Coverage labs
+
+### Computing the coverage rate
+
+The coverage rate is `covered_lines / total_lines` (as one would expect).
+In case "branch coverage" is enabled, the coverage rate is
+`(covered_lines + covered_branches) / (total_lines + total_branches)`.
+In order to display coverage rates, we need to round the values. Depending on
+the situation, we either round to 0 or 2 decimal places. Rounding rules are:
+- We always round down (truncate) the value.
+- We don't display the trailing zeros in the decimal part (nor the decimal point
+  if the decimal part is 0).

coverage_comment/coverage.py

@@ -6,6 +6,7 @@
 import json
 import pathlib
 from collections.abc import Sequence
+from typing import cast
 
 from coverage_comment import log, subprocess
 
@@ -28,10 +29,10 @@ class CoverageInfo:
     percent_covered: decimal.Decimal
     missing_lines: int
     excluded_lines: int
-    num_branches: int | None
-    num_partial_branches: int | None
-    covered_branches: int | None
-    missing_branches: int | None
+    num_branches: int = 0
+    num_partial_branches: int = 0
+    covered_branches: int = 0
+    missing_branches: int = 0
 
 
 @dataclasses.dataclass
@@ -41,6 +42,8 @@ class FileCoverage:
     missing_lines: list[int]
     excluded_lines: list[int]
     info: CoverageInfo
+    executed_branches: list[list[int]] | None = None
+    missing_branches: list[list[int]] | None = None
 
 
 @dataclasses.dataclass
@@ -82,10 +85,20 @@ class DiffCoverage:
     files: dict[pathlib.Path, FileDiffCoverage]
 
 
-def compute_coverage(num_covered: int, num_total: int) -> decimal.Decimal:
-    if num_total == 0:
+def compute_coverage(
+    num_covered: int,
+    num_total: int,
+    num_branches_covered: int = 0,
+    num_branches_total: int = 0,
+) -> decimal.Decimal:
+    """Compute the coverage percentage, with or without branch coverage."""
+    num_branches_covered = cast(int, num_branches_covered)
+    num_branches_total = cast(int, num_branches_total)
+    numerator = decimal.Decimal(num_covered + num_branches_covered)
+    denominator = decimal.Decimal(num_total + num_branches_total)
+    if denominator == 0:
         return decimal.Decimal("1")
-    return decimal.Decimal(num_covered) / decimal.Decimal(num_total)
+    return numerator / denominator
 
 
 def get_coverage_info(
@@ -138,6 +151,26 @@ def generate_coverage_markdown(coverage_path: pathlib.Path) -> str:
     )
 
 
+def _make_coverage_info(data: dict) -> CoverageInfo:
+    """Build a CoverageInfo object from a "summary" or "totals" key."""
+    return CoverageInfo(
+        covered_lines=data["covered_lines"],
+        num_statements=data["num_statements"],
+        percent_covered=compute_coverage(
+            num_covered=data["covered_lines"],
+            num_total=data["num_statements"],
+            num_branches_covered=data.get("covered_branches", 0),
+            num_branches_total=data.get("num_branches", 0),
+        ),
+        missing_lines=data["missing_lines"],
+        excluded_lines=data["excluded_lines"],
+        num_branches=data.get("num_branches"),
+        num_partial_branches=data.get("num_partial_branches"),
+        covered_branches=data.get("covered_branches", 0),
+        missing_branches=data.get("missing_branches", 0),
+    )
+
+
 def extract_info(data: dict, coverage_path: pathlib.Path) -> Coverage:
     """
     {
@@ -191,39 +224,13 @@ def extract_info(data: dict, coverage_path: pathlib.Path) -> Coverage:
                 excluded_lines=file_data["excluded_lines"],
                 executed_lines=file_data["executed_lines"],
                 missing_lines=file_data["missing_lines"],
-                info=CoverageInfo(
-                    covered_lines=file_data["summary"]["covered_lines"],
-                    num_statements=file_data["summary"]["num_statements"],
-                    percent_covered=compute_coverage(
-                        file_data["summary"]["covered_lines"],
-                        file_data["summary"]["num_statements"],
-                    ),
-                    missing_lines=file_data["summary"]["missing_lines"],
-                    excluded_lines=file_data["summary"]["excluded_lines"],
-                    num_branches=file_data["summary"].get("num_branches"),
-                    num_partial_branches=file_data["summary"].get(
-                        "num_partial_branches"
-                    ),
-                    covered_branches=file_data["summary"].get("covered_branches"),
-                    missing_branches=file_data["summary"].get("missing_branches"),
-                ),
+                executed_branches=file_data.get("executed_branches"),
+                missing_branches=file_data.get("missing_branches"),
+                info=_make_coverage_info(file_data["summary"]),
             )
             for path, file_data in data["files"].items()
         },
-        info=CoverageInfo(
-            covered_lines=data["totals"]["covered_lines"],
-            num_statements=data["totals"]["num_statements"],
-            percent_covered=compute_coverage(
-                data["totals"]["covered_lines"],
-                data["totals"]["num_statements"],
-            ),
-            missing_lines=data["totals"]["missing_lines"],
-            excluded_lines=data["totals"]["excluded_lines"],
-            num_branches=data["totals"].get("num_branches"),
-            num_partial_branches=data["totals"].get("num_partial_branches"),
-            covered_branches=data["totals"].get("covered_branches"),
-            missing_branches=data["totals"].get("missing_branches"),
-        ),
+        info=_make_coverage_info(data["totals"]),
     )
 
 
@@ -256,7 +263,8 @@ def get_diff_coverage_info(
         total_num_violations += count_missing
 
         percent_covered = compute_coverage(
-            num_covered=count_executed, num_total=count_total
+            num_covered=count_executed,
+            num_total=count_total,
         )
 
         files[path] = FileDiffCoverage(