diff-cover 10.4.1__tar.gz → 10.5.0__tar.gz

{diff_cover-10.4.1 → diff_cover-10.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: diff_cover
-Version: 10.4.1
+Version: 10.5.0
 Summary: Run coverage and linting reports on diffs
 License: Apache-2.0
 Author: See Contributors
@@ -606,6 +606,21 @@ Important notes:
   * Marked with the ``@diff_cover_hookimpl`` decorator
   * Named ``diff_cover_report_quality``. (This distinguishes it from any other
     plugin types ``diff_cover`` may support.)
+* The function may declare either, both, or neither of the hook's arguments:
+
+  * ``reports`` - the list of open file handles for the pre-generated reports
+    passed on the command line.
+  * ``options`` - the string given to ``--options``.
+
+  Only the arguments you declare are passed, so the zero-argument form above
+  keeps working. A plugin that wants the user's input would be written as:
+
+  .. code:: python
+
+      @diff_cover_hookimpl
+      def diff_cover_report_quality(reports, options):
+          return SQLFluffViolationReporter(reports=reports, options=options)
+
 * The function should return an object with the following properties and methods:
 
   * ``supported_extensions`` property with a list of supported file extensions

{diff_cover-10.4.1 → diff_cover-10.5.0}/README.rst

@@ -574,6 +574,21 @@ Important notes:
   * Marked with the ``@diff_cover_hookimpl`` decorator
   * Named ``diff_cover_report_quality``. (This distinguishes it from any other
     plugin types ``diff_cover`` may support.)
+* The function may declare either, both, or neither of the hook's arguments:
+
+  * ``reports`` - the list of open file handles for the pre-generated reports
+    passed on the command line.
+  * ``options`` - the string given to ``--options``.
+
+  Only the arguments you declare are passed, so the zero-argument form above
+  keeps working. A plugin that wants the user's input would be written as:
+
+  .. code:: python
+
+      @diff_cover_hookimpl
+      def diff_cover_report_quality(reports, options):
+          return SQLFluffViolationReporter(reports=reports, options=options)
+
 * The function should return an object with the following properties and methods:
 
   * ``supported_extensions`` property with a list of supported file extensions

{diff_cover-10.4.1 → diff_cover-10.5.0}/diff_cover/diff_cover_tool.py

@@ -76,6 +76,16 @@ def format_type(value):
     return dict((item.split(":", 1) for item in value.split(",")) if value else {})
 
 
+def normalize_format(config):
+    """
+    Config files provide ``format`` as a raw string, because ``type=`` is only
+    applied to values that come from the command line. Parse it the same way.
+    """
+    if isinstance(config.get("format"), str):
+        config["format"] = format_type(config["format"])
+    return config
+
+
 def parse_coverage_args(argv):
     """
     Parse command line arguments, returning a dict of
@@ -99,7 +109,7 @@ def parse_coverage_args(argv):
     parser.add_argument(
         "--format",
         type=format_type,
-        default="",
+        default=None,
         help=FORMAT_HELP,
     )
 
@@ -217,6 +227,7 @@ def parse_coverage_args(argv):
         "show_uncovered": False,
         "show_covered": False,
         "compare_branch": "origin/main",
+        "format": {},
         "fail_under": 0,
         "ignore_staged": False,
         "ignore_unstaged": False,
@@ -230,7 +241,9 @@ def parse_coverage_args(argv):
         "total_percent_float": False,
     }
 
-    return get_config(parser=parser, argv=argv, defaults=defaults, tool=Tool.DIFF_COVER)
+    return normalize_format(
+        get_config(parser=parser, argv=argv, defaults=defaults, tool=Tool.DIFF_COVER)
+    )
 
 
 def generate_coverage_report(

{diff_cover-10.4.1 → diff_cover-10.5.0}/diff_cover/diff_quality_tool.py

@@ -4,6 +4,7 @@ Implement the command-line tool interface for diff_quality.
 
 import argparse
 import contextlib
+import inspect
 import io
 import logging
 import os
@@ -33,6 +34,7 @@ from diff_cover.diff_cover_tool import (
     TOTAL_PERCENT_FLOAT_HELP,
     format_type,
     handle_old_format,
+    normalize_format,
 )
 from diff_cover.diff_reporter import GitDiffReporter
 from diff_cover.git_diff import GitDiffTool
@@ -119,7 +121,7 @@ def parse_quality_args(argv):
     parser.add_argument(
         "--format",
         type=format_type,
-        default="",
+        default=None,
         help=FORMAT_HELP,
     )
 
@@ -211,6 +213,7 @@ def parse_quality_args(argv):
     defaults = {
         "ignore_whitespace": False,
         "compare_branch": "origin/main",
+        "format": {},
         "diff_range_notation": "...",
         "input_reports": [],
         "fail_under": 0,
@@ -221,8 +224,8 @@ def parse_quality_args(argv):
         "total_percent_float": False,
     }
 
-    return get_config(
-        parser=parser, argv=argv, defaults=defaults, tool=Tool.DIFF_QUALITY
+    return normalize_format(
+        get_config(parser=parser, argv=argv, defaults=defaults, tool=Tool.DIFF_QUALITY)
     )
 
 
@@ -297,6 +300,27 @@ def generate_quality_report(
     return reporter.total_percent_covered()
 
 
+def _call_reporter_factory(factory_fn, reports, options):
+    """
+    Call a plugin's ``diff_cover_report_quality`` implementation.
+
+    Plugins are free to declare only the arguments they need (including none
+    at all, as documented in the README), so pass only what the function
+    actually accepts.
+    """
+    available = {"reports": reports, "options": options}
+    try:
+        parameters = inspect.signature(factory_fn).parameters
+    except (TypeError, ValueError):  # pragma: no cover - builtins/C callables
+        return factory_fn(**available)
+
+    if any(p.kind is inspect.Parameter.VAR_KEYWORD for p in parameters.values()):
+        return factory_fn(**available)
+
+    kwargs = {name: value for name, value in available.items() if name in parameters}
+    return factory_fn(**kwargs)
+
+
 def main(argv=None, directory=None):
     """
     Main entry point for the tool, script installed via pyproject.toml
@@ -366,8 +390,8 @@ def main(argv=None, directory=None):
 
                 reporter = QualityReporter(driver, input_reports, user_options)
             elif reporter_factory_fn:
-                reporter = reporter_factory_fn(
-                    reports=input_reports, options=user_options
+                reporter = _call_reporter_factory(
+                    reporter_factory_fn, input_reports, user_options
                 )
 
             percent_passing = generate_quality_report(

diff_cover-10.5.0/diff_cover/hookspecs.py

@@ -0,0 +1,16 @@
+import pluggy
+
+hookspec = pluggy.HookspecMarker("diff_cover")
+
+
+@hookspec
+def diff_cover_report_quality(reports, options):  # pylint: disable=unused-argument
+    """
+    Return a 2-part tuple:
+    - Quality plugin name
+    - Object that implements the BaseViolationReporter protocol
+
+    ``reports`` is the list of open pre-generated report file handles and
+    ``options`` the user options string; both are passed by ``diff-quality``.
+    A plugin may declare either or neither argument.
+    """

{diff_cover-10.4.1 → diff_cover-10.5.0}/diff_cover/violationsreporters/violations_reporter.py

@@ -46,6 +46,11 @@ class XmlCoverageReporter(BaseViolationReporter):
         # Values are output of `self._get_xml_classes()`
         self._xml_cache = [{} for i in range(len(xml_roots))]
 
+        # Which format each report is in. Classifying costs a search through the
+        # document, and the answer cannot change, so do it once here rather than
+        # once per source file in `_cache_file`.
+        self._report_formats = [self._detect_report_format(root) for root in xml_roots]
+
         self._src_roots = src_roots or [""]
         self._expand_coverage_report = expand_coverage_report
         self._branch_coverage = branch_coverage
@@ -129,19 +134,53 @@ class XmlCoverageReporter(BaseViolationReporter):
         If file is not present in `xml_document`, return None
         """
 
-        files = [
-            file_tree
-            for file_tree in xml_document.findall(".//file")
-            if GitPathTool.relative_path(file_tree.get("path")) == src_path
-        ]
+        files = []
+        normalized_src_path = util.to_unix_path(src_path)
+        for file_tree in xml_document.findall(".//file"):
+            file_path = file_tree.get("path") or file_tree.get("name")
+            if not file_path:
+                continue
+
+            normalized_file_path = util.to_unix_path(file_path)
+            relative_file_path = util.to_unix_path(GitPathTool.relative_path(file_path))
+            if (
+                relative_file_path == normalized_src_path
+                or normalized_file_path.endswith(f"/{normalized_src_path}")
+            ):
+                files.append(file_tree)
         if not files:
             return None
         lines = []
         for file_tree in files:
+            # Clover marks an executable line as one of these three types. PHPUnit's
+            # writer emits `method` for the declaration line of every function it
+            # measured; leaving it out reported those lines as unmeasured.
+            # https://github.com/sebastianbergmann/php-code-coverage/blob/main/src/Report/Clover.php
+            lines.append(file_tree.findall('./line[@type="method"]'))
             lines.append(file_tree.findall('./line[@type="stmt"]'))
             lines.append(file_tree.findall('./line[@type="cond"]'))
         return list(itertools.chain(*lines))
 
+    @staticmethod
+    def _detect_report_format(xml_document):
+        """
+        Return which of the supported formats `xml_document` is in.
+
+        Clover writes a `clover` attribute on the root, but PHPUnit's Clover
+        writer does not, so fall back to the shape of its line elements.
+        """
+        if (
+            xml_document.findall(".[@clover]")
+            or xml_document.find(".//file/line[@num][@count]") is not None
+        ):
+            # see etc/schema/clover.xsd at https://bitbucket.org/atlassian/clover/src
+            return "clover"
+        if xml_document.findall(".[@name]"):
+            # https://github.com/jacoco/jacoco/blob/master/org.jacoco.report/src/org/jacoco/report/xml/report.dtd
+            return "jacoco"
+        # https://github.com/cobertura/web/blob/master/htdocs/xml/coverage-04.dtd
+        return "cobertura"
+
     def _measured_source_path_matches(self, package_name, file_name, src_path):
         # find src_path in any of the source roots
         if not src_path.endswith(util.to_unix_path(file_name)):
@@ -204,22 +243,20 @@ class XmlCoverageReporter(BaseViolationReporter):
 
             # Loop through the files that contain the xml roots
             for i, xml_document in enumerate(self._xml_roots):
-                if xml_document.findall(".[@clover]"):
-                    # see etc/schema/clover.xsd at  https://bitbucket.org/atlassian/clover/src
+                report_format = self._report_formats[i]
+                if report_format == "clover":
                     line_nodes = self.get_src_path_line_nodes_clover(
                         xml_document, src_path
                     )
                     _number = "num"
                     _hits = "count"
-                elif xml_document.findall(".[@name]"):
-                    # https://github.com/jacoco/jacoco/blob/master/org.jacoco.report/src/org/jacoco/report/xml/report.dtd
+                elif report_format == "jacoco":
                     line_nodes = self.get_src_path_line_nodes_jacoco(
                         xml_document, src_path
                     )
                     _number = "nr"
                     _hits = "ci"
                 else:
-                    # https://github.com/cobertura/web/blob/master/htdocs/xml/coverage-04.dtd
                     line_nodes = self.get_src_path_line_nodes_cobertura(
                         i, xml_document, src_path
                     )

{diff_cover-10.4.1 → diff_cover-10.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "diff_cover"
-version = "10.4.1"
+version = "10.5.0"
 description = "Run coverage and linting reports on diffs"
 authors = ["See Contributors"]
 homepage = "https://github.com/Bachmann1234/diff-cover"
@@ -61,7 +61,7 @@ pydocstyle = "^6.1.1"
 black = "^26.1.0"
 isort = ">=6.0.1,<9.0.0"
 doc8 = "2.0.0"
-ruff = ">=0.11.10,<0.16.0"
+ruff = ">=0.11.10,<0.17.0"
 
 [tool.poetry.extras]
 toml = ["tomli"]

{diff_cover-10.4.1 → diff_cover-10.5.0}/tests/test_diff_cover_tool.py

@@ -156,3 +156,31 @@ def test_parse_with_include():
 
 def test_parse_with_exclude():
     _test_parse_with_path_patterns("exclude")
+
+
+def test_parse_format_from_config_file(tmp_path):
+    config_file = tmp_path / "diff_cover.toml"
+    config_file.write_text('[tool.diff_cover]\nformat = "html:report.html"\n')
+
+    arg_dict = parse_coverage_args(
+        ["reports/coverage.xml", "--config-file", str(config_file)]
+    )
+
+    assert arg_dict["format"] == {"html": "report.html"}
+
+
+def test_parse_format_cli_overrides_config_file(tmp_path):
+    config_file = tmp_path / "diff_cover.toml"
+    config_file.write_text('[tool.diff_cover]\nformat = "html:report.html"\n')
+
+    arg_dict = parse_coverage_args(
+        [
+            "reports/coverage.xml",
+            "--config-file",
+            str(config_file),
+            "--format",
+            "json:report.json",
+        ]
+    )
+
+    assert arg_dict["format"] == {"json": "report.json"}

{diff_cover-10.4.1 → diff_cover-10.5.0}/tests/test_diff_quality_main.py

@@ -2,9 +2,15 @@
 
 """Test for diff_cover.diff_quality - main"""
 
+import pluggy
 import pytest
 
-from diff_cover.diff_quality_tool import main, parse_quality_args
+from diff_cover import hookspecs
+from diff_cover.diff_quality_tool import (
+    _call_reporter_factory,
+    main,
+    parse_quality_args,
+)
 
 
 def test_parse_with_html_report():
@@ -147,3 +153,42 @@ def _run_main(report, argv):
     quality_reporter = report.call_args[0][0]
     assert quality_reporter.driver.name == "pylint"
     assert quality_reporter.options == "--foobar"
+
+
+def test_parse_format_from_config_file(tmp_path):
+    config_file = tmp_path / "diff_quality.toml"
+    config_file.write_text('[tool.diff_quality]\nformat = "html:report.html"\n')
+
+    arg_dict = parse_quality_args(
+        ["--violations", "pylint", "--config-file", str(config_file)]
+    )
+
+    assert arg_dict.get("format") == {"html": "report.html"}
+
+
+def test_plugin_may_declare_hook_arguments():
+    """A plugin declaring reports/options must validate against the hookspec."""
+    hookimpl = pluggy.HookimplMarker("diff_cover")
+
+    class Plugin:
+        @hookimpl
+        def diff_cover_report_quality(self, reports, options):
+            return (reports, options)
+
+    plugin_manager = pluggy.PluginManager("diff_cover")
+    plugin_manager.add_hookspecs(hookspecs)
+    plugin_manager.register(Plugin(), name="myplugin")
+
+
+@pytest.mark.parametrize(
+    "factory,expected",
+    [
+        (lambda: "none", "none"),
+        (lambda options: options, "--foobar"),
+        (lambda reports: reports, ["report"]),
+        (lambda reports, options: (reports, options), (["report"], "--foobar")),
+        (lambda **kwargs: kwargs, {"reports": ["report"], "options": "--foobar"}),
+    ],
+)
+def test_call_reporter_factory_passes_declared_arguments(factory, expected):
+    assert _call_reporter_factory(factory, ["report"], "--foobar") == expected

{diff_cover-10.4.1 → diff_cover-10.5.0}/tests/test_violations_reporter.py

@@ -497,6 +497,60 @@ class TestCloverXmlCoverageReporterTest:
         result = coverage.violations("file1.java")
         assert result == violations
 
+    def test_phpunit_clover_without_clover_attribute(self):
+        xml = self._coverage_xml(
+            ["/workspace/project/subdir/file.java"],
+            self.FEW_VIOLATIONS,
+            self.FEW_MEASURED,
+        )
+        del xml.attrib["clover"]
+        file_node = xml.find(".//file")
+        file_node.set("name", file_node.attrib.pop("path"))
+
+        coverage = XmlCoverageReporter([xml])
+
+        assert coverage.violations("subdir/file.java") == self.FEW_VIOLATIONS
+        assert coverage.measured_lines("subdir/file.java") == self.FEW_MEASURED
+
+    def test_method_lines_are_measured(self):
+        # PHPUnit's Clover writer emits type="method" for the declaration line of
+        # every measured function. Those lines carry a count like any other and
+        # must not be reported as unmeasured.
+        xml = self._coverage_xml(
+            ["file1.java"], self.FEW_VIOLATIONS, self.FEW_MEASURED, method_lines={42}
+        )
+
+        coverage = XmlCoverageReporter([xml])
+
+        assert 42 in coverage.measured_lines("file1.java")
+        assert coverage.violations("file1.java") == self.FEW_VIOLATIONS
+
+    def test_method_line_can_be_a_violation(self):
+        xml = self._coverage_xml(
+            ["file1.java"], self.FEW_VIOLATIONS, self.FEW_MEASURED, method_lines={42}
+        )
+        method_line = xml.find('.//line[@type="method"]')
+        method_line.set("count", "0")
+
+        coverage = XmlCoverageReporter([xml])
+
+        assert 42 in coverage.measured_lines("file1.java")
+        assert Violation(42, None) in coverage.violations("file1.java")
+
+    def test_report_format_is_detected_once(self):
+        # Classifying the report is a search through the whole document; doing it
+        # per source file was the review comment on #617.
+        xml = self._coverage_xml(
+            ["file1.java", "file2.java"], self.FEW_VIOLATIONS, self.FEW_MEASURED
+        )
+
+        coverage = XmlCoverageReporter([xml])
+
+        assert coverage._report_formats == ["clover"]
+        coverage.violations("file1.java")
+        coverage.violations("file2.java")
+        assert coverage._report_formats == ["clover"]
+
     def test_two_inputs_first_violate(self):
         # Construct the XML report
         file_paths = ["file1.java"]
@@ -620,7 +674,7 @@ class TestCloverXmlCoverageReporterTest:
         result = coverage.violations("file.java")
         assert result == set()
 
-    def _coverage_xml(self, file_paths, violations, measured):
+    def _coverage_xml(self, file_paths, violations, measured, method_lines=None):
         """
         Build an XML tree with source files specified by `file_paths`.
         Each source fill will have the same set of covered and
@@ -630,6 +684,9 @@ class TestCloverXmlCoverageReporterTest:
         `line_dict` is a dictionary with keys that are line numbers
         and values that are True/False indicating whether the line
         is covered
+        `method_lines` is an optional set of line numbers to emit as
+        `type="method"` instead of `type="stmt"`, the way PHPUnit's Clover
+        writer marks the declaration line of a measured function
 
         This leaves out some attributes of the Cobertura format,
         but includes all the elements.
@@ -654,6 +711,12 @@ class TestCloverXmlCoverageReporterTest:
                 line.set("count", str(hits))
                 line.set("num", str(line_num))
                 line.set("type", "stmt")
+
+            for line_num in method_lines or ():
+                line = etree.SubElement(src_node, "line")
+                line.set("count", "1")
+                line.set("num", str(line_num))
+                line.set("type", "method")
         return root
 
 

diff_cover-10.4.1/diff_cover/hookspecs.py

@@ -1,12 +0,0 @@
-import pluggy
-
-hookspec = pluggy.HookspecMarker("diff_cover")
-
-
-@hookspec
-def diff_cover_report_quality():
-    """
-    Return a 2-part tuple:
-    - Quality plugin name
-    - Object that implements the BaseViolationReporter protocol
-    """