diff-cover 10.4.0__tar.gz → 10.4.2__tar.gz

{diff_cover-10.4.0 → diff_cover-10.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: diff_cover
-Version: 10.4.0
+Version: 10.4.2
 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.0 → diff_cover-10.4.2}/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.0 → diff_cover-10.4.2}/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.0 → diff_cover-10.4.2}/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.4.2/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.0 → diff_cover-10.4.2}/diff_cover/snippets.py

@@ -17,6 +17,17 @@ from pygments.util import ClassNotFound
 
 from diff_cover.git_path import GitPathTool
 
+# Below this, chardet is essentially guessing. Short files with only a
+# handful of non-ascii bytes decode cleanly under every single byte
+# encoding, so which one comes back is down to the detector's internals
+# (chardet 7 answers MacRoman at 0.16 confidence for latin-1 text that
+# chardet 5 called ISO-8859-1 at 0.73).
+MIN_DETECTION_CONFIDENCE = 0.5
+
+# What to try before an unconfident guess. cp1252 is the de facto default
+# for undeclared western text and is a superset of latin-1 in practice.
+FALLBACK_ENCODING = "cp1252"
+
 
 class Snippet:
     """
@@ -284,9 +295,15 @@ class Snippet:
                 contents = src_file.read()
 
         if isinstance(contents, bytes):
-            encoding = chardet.detect(contents).get("encoding", "utf-8")
-            with contextlib.suppress(UnicodeDecodeError):
-                contents = contents.decode(encoding)
+            detected = chardet.detect(contents)
+            candidates = [detected.get("encoding") or "utf-8"]
+            if (detected.get("confidence") or 0) < MIN_DETECTION_CONFIDENCE:
+                candidates.insert(0, FALLBACK_ENCODING)
+
+            for encoding in candidates:
+                with contextlib.suppress(UnicodeDecodeError, LookupError):
+                    contents = contents.decode(encoding)
+                    break
 
         if isinstance(contents, bytes):
             # We failed to decode the file.

{diff_cover-10.4.0 → diff_cover-10.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "diff_cover"
-version = "10.4.0"
+version = "10.4.2"
 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.0 → diff_cover-10.4.2}/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.0 → diff_cover-10.4.2}/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.0 → diff_cover-10.4.2}/tests/test_snippets.py

@@ -429,3 +429,42 @@ def test_latin_one_undeclared(tmp_path):
 
     contents = Snippet.load_contents(str(file))
     assert contents == "I am some latin 1 Â encoded text"
+
+
+def test_unconfident_detection_falls_back(tmp_path, mocker):
+    # Which single byte encoding chardet picks for a short file varies by
+    # version (5 said ISO-8859-1, 6 WINDOWS-1252, 7 MacRoman) so pin the
+    # low confidence branch rather than depending on the installed one.
+    mocker.patch(
+        "diff_cover.snippets.chardet.detect",
+        return_value={"encoding": "MacRoman", "confidence": 0.16},
+    )
+    file = tmp_path / "tmp"
+    file.write_bytes("I am some latin 1 Â encoded text".encode("latin1"))
+
+    contents = Snippet.load_contents(str(file))
+    assert contents == "I am some latin 1 Â encoded text"
+
+
+def test_confident_detection_is_trusted(tmp_path, mocker):
+    mocker.patch(
+        "diff_cover.snippets.chardet.detect",
+        return_value={"encoding": "MacRoman", "confidence": 0.99},
+    )
+    file = tmp_path / "tmp"
+    file.write_bytes("I am some latin 1 Â encoded text".encode("latin1"))
+
+    contents = Snippet.load_contents(str(file))
+    assert contents == "I am some latin 1 ¬ encoded text"
+
+
+def test_detection_returns_no_encoding(tmp_path, mocker):
+    mocker.patch(
+        "diff_cover.snippets.chardet.detect",
+        return_value={"encoding": None, "confidence": None},
+    )
+    file = tmp_path / "tmp"
+    file.write_bytes("I am some latin 1 Â encoded text".encode("latin1"))
+
+    contents = Snippet.load_contents(str(file))
+    assert contents == "I am some latin 1 Â encoded text"

diff_cover-10.4.0/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
-    """