Merge pull request #70 from amartani/lcov-report

Implement LCOV format reporting

Author: jaltmayerpizzorno

src/slipcover/__init__.py

@@ -1,4 +1,4 @@
 from .version import __version__
-from .slipcover import Slipcover, merge_coverage, print_coverage, print_xml
+from .slipcover import Slipcover, merge_coverage, print_coverage, print_xml, print_lcov
 from .importer import FileMatcher, ImportManager, wrap_pytest, wrap_spec_from_file_location
 from .fuzz import wrap_function

src/slipcover/__main__.py

@@ -131,6 +131,10 @@ def merge_files(args, base_path):
             if args.xml:
                 sc.print_xml(merged, source_paths=[str(base_path)], with_branches=args.branch,
                              xml_package_depth=args.xml_package_depth, outfile=jf)
+            elif args.lcov:
+                sc.print_lcov(merged, with_branches=args.branch,
+                             test_name=args.lcov_test_name, comments=args.lcov_comments,
+                             outfile=jf)
             else:
                 json.dump(merged, jf, indent=(4 if args.pretty_print else None))
 
@@ -170,6 +174,9 @@ def main():
         "Controls which directories are identified as packages in the report. "
         "Directories deeper than this depth are not reported as packages. "
         "The default is that all directories are reported as packages."))
+    ap.add_argument('--lcov', action='store_true', help="select LCOV output")
+    ap.add_argument('--lcov-test-name', type=str, help="test name for LCOV TN: entries")
+    ap.add_argument('--lcov-comment', action='append', dest='lcov_comments', help="add comment lines at the beginning of LCOV output (can be used multiple times)")
     ap.add_argument('--out', type=Path, help="specify output file name")
     ap.add_argument('--source', help="specify directories to cover")
     ap.add_argument('--omit', help="specify file(s) to omit")
@@ -261,6 +268,10 @@ def printit(coverage, outfile):
             elif args.xml:
                 sc.print_xml(coverage, source_paths=[str(base_path)], with_branches=args.branch,
                              xml_package_depth=args.xml_package_depth, outfile=outfile)
+            elif args.lcov:
+                sc.print_lcov(coverage, with_branches=args.branch,
+                             test_name=args.lcov_test_name, comments=args.lcov_comments,
+                             outfile=outfile)
             else:
                 sc.print_coverage(coverage, outfile=outfile, skip_covered=args.skip_covered,
                                   missing_width=args.missing_width)

src/slipcover/lcovreport.py

@@ -0,0 +1,123 @@
+"""LCOV reporting for slipcover"""
+
+from __future__ import annotations
+
+import sys
+from collections import defaultdict
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
+
+if TYPE_CHECKING:
+    from typing import IO
+
+    from .schemas import Coverage, CoverageFile
+
+
+def get_branch_info(
+    file_data: CoverageFile,
+) -> Dict[int, List[Tuple[int, bool]]]:
+    """Get information about branches for LCOV format.
+
+    Returns a dict mapping line numbers to a list of (branch_dest, was_taken) tuples.
+
+    """
+    # Branches may arrive as lists (e.g. after a JSON round-trip via --merge)
+    # rather than tuples, so normalize before hashing into a set.
+    missing_branches = {tuple(b) for b in file_data.get("missing_branches", [])}
+    all_branches = sorted(
+        tuple(b) for b in file_data.get("executed_branches", []) + file_data.get("missing_branches", [])
+    )
+
+    # Group branches by their source line
+    branches_by_line: Dict[int, List[Tuple[int, bool]]] = defaultdict(list)
+
+    for branch in all_branches:
+        src_line, dest_line = branch
+        is_taken = branch not in missing_branches
+        branches_by_line[src_line].append((dest_line, is_taken))
+
+    return branches_by_line
+
+
+class LcovReporter:
+    """A reporter for writing LCOV-style coverage results."""
+
+    def __init__(
+        self,
+        coverage: Coverage,
+        with_branches: bool,
+        test_name: Optional[str] = None,
+        comments: Optional[List[str]] = None,
+    ) -> None:
+        self.coverage = coverage
+        self.with_branches = with_branches
+        self.test_name = test_name
+        self.comments = comments or []
+
+    def report(self, outfile: IO[str] | None = None) -> None:
+        """Generate an LCOV-compatible coverage report.
+
+        `outfile` is a file object to write the LCOV data to.
+
+        """
+        outfile = outfile or sys.stdout
+
+        for comment in self.comments:
+            outfile.write(f"# {comment}\n")
+
+        for file_path, file_data in sorted(self.coverage["files"].items()):
+            self._write_file_coverage(outfile, file_path, file_data)
+
+    def _write_file_coverage(
+        self, outfile: IO[str], file_path: str, file_data: CoverageFile
+    ) -> None:
+        """Write LCOV coverage data for a single file."""
+
+        # TN: Test Name (optional)
+        if self.test_name is not None:
+            outfile.write(f"TN:{self.test_name}\n")
+
+        # SF: Source File
+        sf_path = file_path.replace('\\', '/')
+        outfile.write(f"SF:{sf_path}\n")
+
+        # Get all lines (both executed and missing)
+        all_lines = sorted(file_data["executed_lines"] + file_data["missing_lines"])
+
+        # Write branch coverage data if enabled
+        if self.with_branches and (file_data.get("executed_branches") or file_data.get("missing_branches")):
+            branch_info = get_branch_info(file_data)
+
+            # BRDA: Branch data
+            # Format: BRDA:<line number>,<block number>,<branch number>,<taken count or '-'>
+            for line_num in sorted(branch_info.keys()):
+                branches = branch_info[line_num]
+                # Use line number as block number for simplicity
+                block_num = 0
+                for branch_num, (dest, is_taken) in enumerate(branches):
+                    taken_str = "1" if is_taken else "-"
+                    outfile.write(f"BRDA:{line_num},{block_num},{branch_num},{taken_str}\n")
+
+            # BRF: Branches Found
+            total_branches = len(file_data.get("executed_branches", [])) + len(file_data.get("missing_branches", []))
+            outfile.write(f"BRF:{total_branches}\n")
+
+            # BRH: Branches Hit
+            branches_hit = len(file_data.get("executed_branches", []))
+            outfile.write(f"BRH:{branches_hit}\n")
+
+        # DA: Line coverage data
+        # Format: DA:<line number>,<execution count>
+        for line in all_lines:
+            hit_count = 1 if line in file_data["executed_lines"] else 0
+            outfile.write(f"DA:{line},{hit_count}\n")
+
+        # LF: Lines Found (total instrumented lines)
+        total_lines = len(all_lines)
+        outfile.write(f"LF:{total_lines}\n")
+
+        # LH: Lines Hit (covered lines)
+        lines_hit = len(file_data["executed_lines"])
+        outfile.write(f"LH:{lines_hit}\n")
+
+        # end_of_record: End of record marker
+        outfile.write("end_of_record\n")

src/slipcover/slipcover.py

@@ -16,6 +16,7 @@
 from . import branch as br
 from .version import __version__
 from .xmlreport import XmlReporter
+from .lcovreport import LcovReporter
 
 # FIXME provide __all__
 
@@ -164,6 +165,22 @@ def print_xml(
     ).report(outfile=outfile)
 
 
+def print_lcov(
+    coverage: Coverage,
+    *,
+    with_branches: bool = False,
+    test_name: Optional[str] = None,
+    comments: Optional[List[str]] = None,
+    outfile=sys.stdout
+) -> None:
+    LcovReporter(
+        coverage=coverage,
+        with_branches=with_branches,
+        test_name=test_name,
+        comments=comments,
+    ).report(outfile=outfile)
+
+
 def print_coverage(coverage, *, outfile=sys.stdout, missing_width=None, skip_covered=False) -> None:
     """Prints coverage information for human consumption."""
     from tabulate import tabulate