diff-cover 9.1.0__tar.gz → 9.2.0__tar.gz

{diff_cover-9.1.0 → diff_cover-9.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diff_cover
-Version: 9.1.0
+Version: 9.2.0
 Summary: Run coverage and linting reports on diffs
 Home-page: https://github.com/Bachmann1234/diff-cover
 License: Apache-2.0
@@ -307,6 +307,18 @@ It can be enabled by using the ``-q``/``--quiet`` flag:
 
 If enabled, the tool will only print errors and failures but no information or warning messages.
 
+Compatibility with multi-line statements
+----------------------------------------
+``diff-cover`` relies on the comparison of diff reports and coverage reports, and does not report
+lines that appear in one and not in the other. While diff reports list all lines that changed,
+coverage reports usually list code statements. As a result, a change in a multi-line statement may not be analyzed by ``diff-cover``.
+
+As a workaround, you can use the argument ``--expand-coverage-report``: lines not appearing in the coverage reports will be added to them with the same number of hits as the previously reported line. ``diff-cover`` will then perform diff coverage analysis on all changed lines.
+
+Notes:
+- This argument is only available for XML coverage reports.
+- This workaround is designed under the assumption that the coverage tool reports untested statements with hits set to 0, and it reports statements based on the opening line.
+
 Configuration files
 -------------------
 Both tools allow users to specify the options in a configuration file with `--config-file`/`-c`:

{diff_cover-9.1.0 → diff_cover-9.2.0}/README.rst

@@ -274,6 +274,18 @@ It can be enabled by using the ``-q``/``--quiet`` flag:
 
 If enabled, the tool will only print errors and failures but no information or warning messages.
 
+Compatibility with multi-line statements
+----------------------------------------
+``diff-cover`` relies on the comparison of diff reports and coverage reports, and does not report
+lines that appear in one and not in the other. While diff reports list all lines that changed,
+coverage reports usually list code statements. As a result, a change in a multi-line statement may not be analyzed by ``diff-cover``.
+
+As a workaround, you can use the argument ``--expand-coverage-report``: lines not appearing in the coverage reports will be added to them with the same number of hits as the previously reported line. ``diff-cover`` will then perform diff coverage analysis on all changed lines.
+
+Notes:
+- This argument is only available for XML coverage reports.
+- This workaround is designed under the assumption that the coverage tool reports untested statements with hits set to 0, and it reports statements based on the opening line.
+
 Configuration files
 -------------------
 Both tools allow users to specify the options in a configuration file with `--config-file`/`-c`:

{diff_cover-9.1.0 → diff_cover-9.2.0}/diff_cover/diff_cover_tool.py

@@ -41,6 +41,9 @@ DIFF_RANGE_NOTATION_HELP = (
 )
 QUIET_HELP = "Only print errors and failures"
 SHOW_UNCOVERED = "Show uncovered lines on the console"
+EXPAND_COVERAGE_REPORT = (
+    "Append missing lines in coverage reports based on the hits of the previous line."
+)
 INCLUDE_UNTRACKED_HELP = "Include untracked files"
 CONFIG_FILE_HELP = "The configuration file to use"
 DIFF_FILE_HELP = "The diff file to use"
@@ -93,6 +96,13 @@ def parse_coverage_args(argv):
         "--show-uncovered", action="store_true", default=None, help=SHOW_UNCOVERED
     )
 
+    parser.add_argument(
+        "--expand-coverage-report",
+        action="store_true",
+        default=None,
+        help=EXPAND_COVERAGE_REPORT,
+    )
+
     parser.add_argument(
         "--external-css-file",
         metavar="FILENAME",
@@ -183,6 +193,7 @@ def parse_coverage_args(argv):
         "ignore_whitespace": False,
         "diff_range_notation": "...",
         "quiet": False,
+        "expand_coverage_report": False,
     }
 
     return get_config(parser=parser, argv=argv, defaults=defaults, tool=Tool.DIFF_COVER)
@@ -204,6 +215,7 @@ def generate_coverage_report(
     src_roots=None,
     quiet=False,
     show_uncovered=False,
+    expand_coverage_report=False,
 ):
     """
     Generate the diff coverage report, using kwargs from `parse_args()`.
@@ -231,7 +243,7 @@ def generate_coverage_report(
     if len(xml_roots) > 0 and len(lcov_roots) > 0:
         raise ValueError(f"Mixing LCov and XML reports is not supported yet")
     elif len(xml_roots) > 0:
-        coverage = XmlCoverageReporter(xml_roots, src_roots)
+        coverage = XmlCoverageReporter(xml_roots, src_roots, expand_coverage_report)
     else:
         coverage = LcovCoverageReporter(lcov_roots, src_roots)
 
@@ -308,6 +320,7 @@ def main(argv=None, directory=None):
         src_roots=arg_dict["src_roots"],
         quiet=quiet,
         show_uncovered=arg_dict["show_uncovered"],
+        expand_coverage_report=arg_dict["expand_coverage_report"],
     )
 
     if percent_covered >= fail_under:

{diff_cover-9.1.0 → diff_cover-9.2.0}/diff_cover/diff_reporter.py

@@ -165,18 +165,31 @@ class GitDiffReporter(BaseDiffReporter):
 
         # Get the diff dictionary
         diff_dict = self._git_diff()
-
         # include untracked files
         if self._include_untracked:
             for path in self._git_diff_tool.untracked():
-                with open(path) as file_handle:
-                    num_lines = len(file_handle.readlines())
+                if not self._validate_path_to_diff(path):
+                    continue
+
+                num_lines = self._get_file_lines(path)
                 diff_dict[path] = list(range(1, num_lines + 1))
 
         # Return the changed file paths (dict keys)
         # in alphabetical order
         return sorted(diff_dict.keys(), key=lambda x: x.lower())
 
+    @staticmethod
+    def _get_file_lines(path):
+        """
+        Return the number of lines in a file.
+        """
+
+        try:
+            with open(path, encoding="utf-8") as file_handle:
+                return len(file_handle.readlines())
+        except UnicodeDecodeError:
+            return 0
+
     def lines_changed(self, src_path):
         """
         See base class docstring.
@@ -224,23 +237,16 @@ class GitDiffReporter(BaseDiffReporter):
                 diff_dict = self._parse_diff_str(diff_str)
 
                 for src_path, (added_lines, deleted_lines) in diff_dict.items():
-                    if self._is_path_excluded(src_path):
+                    if not self._validate_path_to_diff(src_path):
                         continue
-                    # If no _supported_extensions provided, or extension present: process
-                    _, extension = os.path.splitext(src_path)
-                    extension = extension[1:].lower()
-                    # 'not self._supported_extensions' tests for both None and empty list []
-                    if (
-                        not self._supported_extensions
-                        or extension in self._supported_extensions
-                    ):
-                        # Remove any lines from the dict that have been deleted
-                        # Include any lines that have been added
-                        result_dict[src_path] = [
-                            line
-                            for line in result_dict.get(src_path, [])
-                            if line not in deleted_lines
-                        ] + added_lines
+
+                    # Remove any lines from the dict that have been deleted
+                    # Include any lines that have been added
+                    result_dict[src_path] = [
+                        line
+                        for line in result_dict.get(src_path, [])
+                        if line not in deleted_lines
+                    ] + added_lines
 
             # Eliminate repeats and order line numbers
             for src_path, lines in result_dict.items():
@@ -252,6 +258,29 @@ class GitDiffReporter(BaseDiffReporter):
         # Return the diff cache
         return self._diff_dict
 
+    def _validate_path_to_diff(self, src_path: str) -> bool:
+        """
+        Validate if a path should be included in the diff.
+
+        Returns True if the path should be included, otherwise False.
+
+        A path should be excluded if:
+        - If the path is excluded
+        - If the path has an extension that is not supported
+        """
+
+        if self._is_path_excluded(src_path):
+            return False
+
+        # If no _supported_extensions provided, or extension present: process
+        _, extension = os.path.splitext(src_path)
+        extension = extension[1:].lower()
+
+        if self._supported_extensions and extension not in self._supported_extensions:
+            return False
+
+        return True
+
     # Regular expressions used to parse the diff output
     SRC_FILE_RE = re.compile(r'^diff --git "?a/.*"? "?b/([^\n"]*)"?')
     MERGE_CONFLICT_RE = re.compile(r"^diff --cc ([^\n]*)")

{diff_cover-9.1.0 → diff_cover-9.2.0}/diff_cover/violationsreporters/violations_reporter.py

@@ -24,7 +24,7 @@ class XmlCoverageReporter(BaseViolationReporter):
     Query information from a Cobertura|Clover|JaCoCo XML coverage report.
     """
 
-    def __init__(self, xml_roots, src_roots=None):
+    def __init__(self, xml_roots, src_roots=None, expand_coverage_report=False):
         """
         Load the XML coverage report represented
         by the cElementTree with root element `xml_root`.
@@ -41,6 +41,7 @@ class XmlCoverageReporter(BaseViolationReporter):
         self._xml_cache = [{} for i in range(len(xml_roots))]
 
         self._src_roots = src_roots or [""]
+        self._expand_coverage_report = expand_coverage_report
 
     def _get_xml_classes(self, xml_document):
         """
@@ -216,6 +217,28 @@ class XmlCoverageReporter(BaseViolationReporter):
                 if line_nodes is None:
                     continue
 
+                # Expand coverage report with not reported lines
+                if self._expand_coverage_report:
+                    reported_line_hits = {}
+                    for line in line_nodes:
+                        reported_line_hits[int(line.get(_number))] = int(
+                            line.get(_hits, 0)
+                        )
+                    if reported_line_hits:
+                        last_hit_number = 0
+                        for line_number in range(
+                            min(reported_line_hits.keys()),
+                            max(reported_line_hits.keys()),
+                        ):
+                            if line_number in reported_line_hits:
+                                last_hit_number = reported_line_hits[line_number]
+                            else:
+                                # This is an unreported line.
+                                # We add it with the previous line hit score
+                                line_nodes.append(
+                                    {_hits: last_hit_number, _number: line_number}
+                                )
+
                 # First case, need to define violations initially
                 if violations is None:
                     violations = {
@@ -264,7 +287,7 @@ class XmlCoverageReporter(BaseViolationReporter):
 
 class LcovCoverageReporter(BaseViolationReporter):
     """
-    Query information from a Cobertura|Clover|JaCoCo XML coverage report.
+    Query information from a LCov coverage report.
     """
 
     def __init__(self, lcov_roots, src_roots=None):
@@ -324,6 +347,7 @@ class LcovCoverageReporter(BaseViolationReporter):
                 "BRF",
                 "BRH",
                 "BRDA",
+                "VER",
             ]:
                 # these are valid lines, but not we don't need them
                 continue

{diff_cover-9.1.0 → diff_cover-9.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "diff_cover"
-version = "9.1.0"
+version = "9.2.0"
 description = "Run coverage and linting reports on diffs"
 authors = ["See Contributors"]
 homepage = "https://github.com/Bachmann1234/diff-cover"
@@ -55,10 +55,10 @@ pytest-mock = "^3.14.0"
 pycodestyle = ">=2.9.1"
 flake8 = "^5.0.4"
 pyflakes = "^2.5.0"
-pylint = "^3.2.2"
+pylint = "^3.2.7"
 pylint-pytest = "^1.1.8"
 pydocstyle = "^6.1.1"
-black = "^24.4.2"
+black = "^24.8.0"
 isort = "^5.13.2"
 doc8 = "1.1.1"
 

diff_cover-9.2.0/tests/fixtures/coverage_missing_lines.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" ?>
+<!DOCTYPE coverage
+  SYSTEM 'http://cobertura.sourceforge.net/xml/coverage-03.dtd'>
+<coverage branch-rate="0" line-rate="0.8792" timestamp="1371471706873" version="3.6">
+	<packages>
+		<package branch-rate="0" complexity="0" line-rate="0.9915" name="">
+			<classes>
+                <class branch-rate="0" complexity="0" filename="test_src.txt" line-rate="0.9643" name="test_src.txt">
+					<methods/>
+					<lines>
+						<line hits="1" number="1"/>
+						<line hits="0" number="2"/>
+						<line hits="0" number="4"/>
+						<line hits="1" number="5"/>
+						<line hits="1" number="7"/>
+						<line hits="0" number="8"/>
+						<line hits="1" number="9"/>
+						<line hits="0" number="10"/>
+					</lines>
+				</class>
+			</classes>
+		</package>
+	</packages>
+</coverage>

diff_cover-9.2.0/tests/fixtures/expand_console_report.txt

@@ -0,0 +1,10 @@
+-------------
+Diff Coverage
+Diff: origin/main...HEAD, staged and unstaged changes
+-------------
+test_src.txt (50.0%): Missing lines 2-4,8,10
+-------------
+Total:   10 lines
+Missing: 5 lines
+Coverage: 50%
+-------------

{diff_cover-9.1.0 → diff_cover-9.2.0}/tests/test_diff_reporter.py

@@ -618,16 +618,63 @@ def test_include_untracked(mocker, git_diff):
         {"subdir/file1.py": line_numbers(3, 10) + line_numbers(34, 47)}
     )
     _set_git_diff_output(
-        reporter, git_diff, staged_diff=diff_output, untracked=["u1.py", " u2.py"]
+        reporter,
+        git_diff,
+        staged_diff=diff_output,
+        untracked=["u1.py", " u2.py", "binary1.bin"],
     )
 
-    open_mock = mocker.mock_open(read_data="1\n2\n3\n")
-    mocker.patch("diff_cover.diff_reporter.open", open_mock)
+    base_open_mock = mocker.mock_open(read_data="1\n2\n3\n")
+    raise_count = 0
+
+    def open_side_effect(*args, **kwargs):
+        if args[0] == "binary1.bin":
+            nonlocal raise_count
+            raise_count += 1
+
+            raise UnicodeDecodeError("utf-8", b"", 0, 1, "invalid start byte")
+        return base_open_mock(*args, **kwargs)
+
+    mocker.patch("diff_cover.diff_reporter.open", open_side_effect)
     changed = reporter.src_paths_changed()
 
-    assert sorted(changed) == [" u2.py", "subdir/file1.py", "u1.py"]
+    assert sorted(changed) == [" u2.py", "binary1.bin", "subdir/file1.py", "u1.py"]
     assert reporter.lines_changed("u1.py") == [1, 2, 3]
     assert reporter.lines_changed(" u2.py") == [1, 2, 3]
+    assert reporter.lines_changed("binary1.bin") == []
+
+    assert raise_count == 1
+
+
+@pytest.mark.parametrize(
+    "excluded, supported_extensions, path",
+    [
+        (["file.bin"], ["py"], "file.bin"),
+        ([], ["py"], "file.bin"),
+    ],
+)
+def test_include_untracked__not_valid_path__not_include_it(
+    git_diff, excluded, supported_extensions, path
+):
+    reporter = GitDiffReporter(
+        git_diff=git_diff,
+        include_untracked=True,
+        supported_extensions=supported_extensions,
+        exclude=excluded,
+    )
+    diff_output = git_diff_output(
+        {"subdir/file1.py": line_numbers(3, 10) + line_numbers(34, 47)}
+    )
+    _set_git_diff_output(
+        reporter,
+        git_diff,
+        staged_diff=diff_output,
+        untracked=[path],
+    )
+
+    changed = reporter.src_paths_changed()
+
+    assert sorted(changed) == ["subdir/file1.py"]
 
 
 def _set_git_diff_output(

{diff_cover-9.1.0 → diff_cover-9.2.0}/tests/test_integration.py

@@ -412,6 +412,20 @@ class TestDiffCoverIntegration(ToolsIntegrationBase):
             ["diff-cover", "--show-uncovered", "coverage.xml"],
         )
 
+    def test_expand_coverage_report_complete_report(self):
+        self._check_console_report(
+            "git_diff_add.txt",
+            "add_console_report.txt",
+            ["diff-cover", "coverage.xml", "--expand-coverage-report"],
+        )
+
+    def test_expand_coverage_report_uncomplete_report(self):
+        self._check_console_report(
+            "git_diff_add.txt",
+            "expand_console_report.txt",
+            ["diff-cover", "coverage_missing_lines.xml", "--expand-coverage-report"],
+        )
+
 
 class TestDiffQualityIntegration(ToolsIntegrationBase):
     """

{diff_cover-9.1.0 → diff_cover-9.2.0}/tests/test_violations_reporter.py

@@ -66,6 +66,21 @@ class TestXmlCoverageReporterTest:
     ONE_VIOLATION = {Violation(11, None)}
     VERY_MANY_MEASURED = {2, 3, 5, 7, 11, 13, 17, 23, 24, 25, 26, 26, 27}
 
+    MANY_VIOLATIONS_EXPANDED_MANY_MEASURED = {
+        Violation(3, None),
+        Violation(4, None),
+        Violation(7, None),
+        Violation(8, None),
+        Violation(9, None),
+        Violation(10, None),
+        Violation(11, None),
+        Violation(12, None),
+        Violation(13, None),
+        Violation(14, None),
+        Violation(15, None),
+        Violation(16, None),
+    }
+
     @pytest.fixture(autouse=True)
     def patch_git_patch(self, mocker):
         # Paths generated by git_path are always the given argument
@@ -266,6 +281,52 @@ class TestXmlCoverageReporterTest:
         result = coverage.violations("file.py")
         assert result == set()
 
+    def test_expand_unreported_lines_when_configured(self):
+        # Construct the XML report
+        file_paths = ["file1.java"]
+        # fixture
+        violations = self.MANY_VIOLATIONS
+        measured = self.MANY_MEASURED
+        xml = self._coverage_xml(file_paths, violations, measured)
+
+        # Parse the reports
+        coverage = XmlCoverageReporter([xml], expand_coverage_report=True)
+
+        # Expect that the name is set
+        assert coverage.name() == "XML"
+
+        # By construction, each file has the same set
+        # of covered/uncovered lines
+        assert self.MANY_VIOLATIONS_EXPANDED_MANY_MEASURED == coverage.violations(
+            "file1.java"
+        )
+
+    def test_expand_unreported_lines_without_violations(self):
+        # Construct the XML report
+        file_paths = ["file1.java"]
+        # fixture
+        violations = {}
+        measured = self.MANY_MEASURED
+        xml = self._coverage_xml(file_paths, violations, measured)
+
+        # Parse the reports
+        coverage = XmlCoverageReporter([xml], expand_coverage_report=True)
+
+        assert set() == coverage.violations("file1.java")
+
+    def test_expand_unreported_lines_without_measured(self):
+        # Construct the XML report
+        file_paths = ["file1.java"]
+        # fixture
+        violations = {}
+        measured = {}
+        xml = self._coverage_xml(file_paths, violations, measured)
+
+        # Parse the reports
+        coverage = XmlCoverageReporter([xml], expand_coverage_report=True)
+
+        assert set() == coverage.violations("file1.java")
+
     def _coverage_xml(self, file_paths, violations, measured, source_paths=None):
         """
         Build an XML tree with source files specified by `file_paths`.