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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: diff_cover
-Version: 10.4.2
+Version: 10.5.1
 Summary: Run coverage and linting reports on diffs
 License: Apache-2.0
 Author: See Contributors

{diff_cover-10.4.2 → diff_cover-10.5.1}/diff_cover/command_runner.py

@@ -1,6 +1,8 @@
 import subprocess
 import sys
 
+GIT_INSTALL_URL = "https://git-scm.com/book/en/v2/Getting-Started-Installing-Git"
+
 
 class CommandError(Exception):
     """
@@ -8,6 +10,16 @@ class CommandError(Exception):
     """
 
 
+class ExecutableNotFoundError(CommandError):
+    """
+    Error raised when the executable of a command cannot be found at all.
+
+    This is a `CommandError` so that existing handling keeps working, but a
+    distinct type so the command line tools can tell "your tooling is not
+    installed" apart from "the command ran and failed".
+    """
+
+
 def execute(command, exit_codes=None):
     """Execute provided command returning the stdout
     Args:
@@ -24,7 +36,12 @@ def execute(command, exit_codes=None):
         exit_codes = [0]
 
     stdout_pipe = subprocess.PIPE
-    with subprocess.Popen(command, stdout=stdout_pipe, stderr=stdout_pipe) as process:
+    try:
+        popen = subprocess.Popen(command, stdout=stdout_pipe, stderr=stdout_pipe)
+    except FileNotFoundError as exc:
+        raise ExecutableNotFoundError(_executable_not_found_message(command)) from exc
+
+    with popen as process:
         try:
             stdout, stderr = process.communicate()
         except OSError:
@@ -52,6 +69,20 @@ def run_command_for_code(command):
     return process.returncode
 
 
+def _executable_not_found_message(command):
+    """
+    Explain that the executable of `command` is not installed or not on PATH.
+    """
+    executable = _ensure_unicode(command[0]) if command else ""
+    message = (
+        f"'{executable}' was not found. diff-cover needs '{executable}' to be "
+        "installed and on your PATH in order to run."
+    )
+    if executable == "git":
+        message += f" See {GIT_INSTALL_URL} for installation instructions."
+    return message
+
+
 def _ensure_unicode(text):
     """
     Ensures the text passed in becomes unicode

{diff_cover-10.4.2 → diff_cover-10.5.1}/diff_cover/diff_cover_tool.py

@@ -7,6 +7,7 @@ import warnings
 import xml.etree.ElementTree as etree
 
 from diff_cover import DESCRIPTION, VERSION
+from diff_cover.command_runner import ExecutableNotFoundError
 from diff_cover.config_parser import Tool, get_config
 from diff_cover.diff_reporter import GitDiffReporter
 from diff_cover.git_diff import GitDiffFileTool, GitDiffTool
@@ -418,7 +419,11 @@ def main(argv=None, directory=None):
     level = logging.ERROR if quiet else logging.WARNING
     logging.basicConfig(format="%(message)s", level=level)
 
-    GitPathTool.set_cwd(directory)
+    try:
+        GitPathTool.set_cwd(directory)
+    except ExecutableNotFoundError as exc:
+        LOGGER.error("%s", exc)
+        return 1
     fail_under = arg_dict.get("fail_under")
     diff_tool = None
 

{diff_cover-10.4.2 → diff_cover-10.5.1}/diff_cover/diff_quality_tool.py

@@ -14,6 +14,7 @@ import pluggy
 
 import diff_cover
 from diff_cover import hookspecs
+from diff_cover.command_runner import ExecutableNotFoundError
 from diff_cover.config_parser import Tool, get_config
 from diff_cover.diff_cover_tool import (
     COMPARE_BRANCH_HELP,
@@ -339,7 +340,11 @@ def main(argv=None, directory=None):
     level = logging.ERROR if quiet else logging.WARNING
     logging.basicConfig(format="%(message)s", level=level)
 
-    GitPathTool.set_cwd(directory)
+    try:
+        GitPathTool.set_cwd(directory)
+    except ExecutableNotFoundError as exc:
+        LOGGER.error("%s", exc)
+        return 1
     fail_under = arg_dict.get("fail_under")
     tool = arg_dict["violations"]
     user_options = arg_dict.get("options")

diff_cover-10.5.1/diff_cover/violationsreporters/clover.py

@@ -0,0 +1,84 @@
+"""
+Reading the ``<file>`` elements of a Clover XML coverage report.
+"""
+
+import itertools
+from collections import defaultdict
+
+from diff_cover import util
+from diff_cover.git_path import GitPathTool
+
+
+class CloverFileIndex:
+    """
+    The ``<file>`` elements of one Clover report, indexed for lookup by path.
+
+    Building the index costs one walk of the document. Looking a source path up
+    by walking the document instead costs that walk once per source path, which
+    is quadratic in a report with many files.
+    """
+
+    def __init__(self, xml_document):
+        """
+        Index every ``<file>`` element of `xml_document`.
+
+        A file is matched either by its path relative to the repository root
+        or, when the report carries absolute paths, by a suffix test. The
+        suffix can only match when the last path segment does, so candidates
+        for it are grouped by that segment and the test is applied to the few
+        that share it.
+
+        Both tables store the document position of each element so that
+        lookups can return matches in document order, as a direct walk would.
+        """
+        self._by_relative_path = defaultdict(list)
+        self._by_last_segment = defaultdict(list)
+        for position, file_tree in enumerate(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))
+            self._by_relative_path[relative_file_path].append((position, file_tree))
+            self._by_last_segment[normalized_file_path.rsplit("/", 1)[-1]].append(
+                (position, normalized_file_path, file_tree)
+            )
+
+    def _files(self, src_path):
+        """
+        Return the ``<file>`` elements for `src_path`, in document order.
+        """
+        normalized_src_path = util.to_unix_path(src_path)
+
+        matches = {}
+        for position, file_tree in self._by_relative_path.get(normalized_src_path, ()):
+            matches[position] = file_tree
+        suffix = f"/{normalized_src_path}"
+        for position, normalized_file_path, file_tree in self._by_last_segment.get(
+            normalized_src_path.rsplit("/", 1)[-1], ()
+        ):
+            if normalized_file_path.endswith(suffix):
+                matches[position] = file_tree
+
+        return [matches[position] for position in sorted(matches)]
+
+    def line_nodes(self, src_path):
+        """
+        Return a list of nodes containing line information for `src_path`.
+
+        If the file is not present in the report, return None
+        """
+        files = self._files(src_path)
+        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))

{diff_cover-10.4.2 → diff_cover-10.5.1}/diff_cover/violationsreporters/violations_reporter.py

@@ -17,6 +17,7 @@ from diff_cover.violationsreporters.base import (
     RegexBasedDriver,
     Violation,
 )
+from diff_cover.violationsreporters.clover import CloverFileIndex
 
 
 class XmlCoverageReporter(BaseViolationReporter):
@@ -46,6 +47,14 @@ 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]
+
+        # A `CloverFileIndex` for each Clover report, built on first use.
+        self._clover_file_index = [None] * len(xml_roots)
+
         self._src_roots = src_roots or [""]
         self._expand_coverage_report = expand_coverage_report
         self._branch_coverage = branch_coverage
@@ -120,27 +129,36 @@ class XmlCoverageReporter(BaseViolationReporter):
         lines = [clazz.findall("./lines/line") for clazz in classes]
         return list(itertools.chain(*lines))
 
-    @staticmethod
-    def get_src_path_line_nodes_clover(xml_document, src_path):
+    def get_src_path_line_nodes_clover(self, index, xml_document, src_path):
         """
         Return a list of nodes containing line information for `src_path`
         in `xml_document`.
 
         If file is not present in `xml_document`, return None
         """
+        if self._clover_file_index[index] is None:
+            self._clover_file_index[index] = CloverFileIndex(xml_document)
+        return self._clover_file_index[index].line_nodes(src_path)
 
-        files = [
-            file_tree
-            for file_tree in xml_document.findall(".//file")
-            if GitPathTool.relative_path(file_tree.get("path")) == src_path
-        ]
-        if not files:
-            return None
-        lines = []
-        for file_tree in files:
-            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
@@ -204,22 +222,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
+                        i, 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.2 → diff_cover-10.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "diff_cover"
-version = "10.4.2"
+version = "10.5.1"
 description = "Run coverage and linting reports on diffs"
 authors = ["See Contributors"]
 homepage = "https://github.com/Bachmann1234/diff-cover"

{diff_cover-10.4.2 → diff_cover-10.5.1}/tests/test_clover_violations_reporter.py

@@ -13,7 +13,6 @@ def test_get_src_path_clover(datadir):
     GitPathTool._cwd = "/"
     GitPathTool._root = "/"
     clover_report = etree.parse(str(datadir / "test.xml"))
-    result = XmlCoverageReporter.get_src_path_line_nodes_clover(
-        clover_report, "isLucky.js"
-    )
+    reporter = XmlCoverageReporter([clover_report])
+    result = reporter.get_src_path_line_nodes_clover(0, clover_report, "isLucky.js")
     assert sorted([int(line.attrib["num"]) for line in result]) == [2, 3, 5, 6, 8, 12]

diff_cover-10.5.1/tests/test_command_runner_missing_executable.py

@@ -0,0 +1,92 @@
+# pylint: disable=missing-function-docstring
+
+"""Tests for the message shown when a required executable is not on PATH.
+
+See https://github.com/Bachmann1234/diff_cover/issues/303
+"""
+
+import pytest
+
+from diff_cover.command_runner import (
+    GIT_INSTALL_URL,
+    CommandError,
+    ExecutableNotFoundError,
+    execute,
+)
+
+
+@pytest.fixture
+def missing_git(mocker):
+    """Make every subprocess launch fail the way a missing `git` does."""
+    return mocker.patch(
+        "diff_cover.command_runner.subprocess.Popen",
+        side_effect=FileNotFoundError(2, "No such file or directory", "git"),
+    )
+
+
+@pytest.fixture
+def failing_git(mocker):
+    """Make `git` run and fail, which is a different thing entirely."""
+    process = mocker.Mock()
+    process.returncode = 1
+    process.communicate.return_value = (b"", b"fatal: not a git repository")
+    popen = mocker.patch("diff_cover.command_runner.subprocess.Popen")
+    popen.return_value.__enter__.return_value = process
+    popen.return_value.__exit__.return_value = None
+    return popen
+
+
+def test_execute_turns_a_missing_executable_into_a_helpful_error(missing_git):
+    with pytest.raises(ExecutableNotFoundError) as exc_info:
+        execute(["git", "rev-parse", "--show-toplevel"])
+
+    message = str(exc_info.value)
+    assert "git" in message
+    assert "PATH" in message
+    assert message.endswith(f"See {GIT_INSTALL_URL} for installation instructions.")
+
+
+def test_the_new_error_stays_a_command_error(missing_git):
+    """Callers that already catch CommandError must keep working."""
+    assert issubclass(ExecutableNotFoundError, CommandError)
+    with pytest.raises(CommandError):
+        execute(["git", "rev-parse", "--show-toplevel"])
+
+
+def test_execute_does_not_link_git_docs_for_other_executables(mocker):
+    mocker.patch(
+        "diff_cover.command_runner.subprocess.Popen",
+        side_effect=FileNotFoundError(2, "No such file or directory", "pycodestyle"),
+    )
+
+    with pytest.raises(ExecutableNotFoundError) as exc_info:
+        execute(["pycodestyle", "--version"])
+
+    message = str(exc_info.value)
+    assert "pycodestyle" in message
+    assert GIT_INSTALL_URL not in message
+
+
+def test_diff_cover_main_reports_missing_git_without_a_traceback(missing_git, caplog):
+    from diff_cover.diff_cover_tool import main
+
+    assert main(["diff-cover", "coverage.xml"]) == 1
+    assert "PATH" in caplog.text
+
+
+def test_diff_quality_main_reports_missing_git_without_a_traceback(missing_git, caplog):
+    from diff_cover.diff_quality_tool import main
+
+    assert main(["diff-quality", "--violations", "pycodestyle"]) == 1
+    assert "PATH" in caplog.text
+
+
+def test_a_command_that_runs_and_fails_is_left_alone(failing_git):
+    """Control. Green before and after: only a *missing* binary is reworded."""
+    with pytest.raises(CommandError) as exc_info:
+        execute(["git", "status"])
+
+    assert not isinstance(exc_info.value, ExecutableNotFoundError)
+    message = str(exc_info.value)
+    assert "fatal: not a git repository" in message
+    assert "PATH" not in message

{diff_cover-10.4.2 → diff_cover-10.5.1}/tests/test_violations_reporter.py

@@ -464,12 +464,15 @@ class TestCloverXmlCoverageReporterTest:
 
     @pytest.fixture(autouse=True)
     def patch_git_patch(self, mocker):
-        # Paths generated by git_path are always the given argument
-        _git_path_mock = mocker.patch(
-            "diff_cover.violationsreporters.violations_reporter.GitPathTool"
-        )
-        _git_path_mock.relative_path = lambda path: path
-        _git_path_mock.absolute_path = lambda path: path
+        # Paths generated by git_path are always the given argument. The Clover
+        # lookup resolves them in its own module, so patch both.
+        for module in (
+            "diff_cover.violationsreporters.violations_reporter",
+            "diff_cover.violationsreporters.clover",
+        ):
+            _git_path_mock = mocker.patch(f"{module}.GitPathTool")
+            _git_path_mock.relative_path = lambda path: path
+            _git_path_mock.absolute_path = lambda path: path
 
     def test_violations(self):
         # Construct the XML report
@@ -497,6 +500,109 @@ 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_file_lookup_is_built_once(self, mocker):
+        # Locating a source file used to walk every `.//file` again, so a report
+        # with N files cost N walks for N source paths. Each `<file>` is now
+        # classified once, which shows up as one `relative_path` call per file
+        # however many source paths are looked up.
+        file_paths = ["file1.java", "subdir/file2.java", "subdir/file3.java"]
+        xml = self._coverage_xml(file_paths, self.FEW_VIOLATIONS, self.FEW_MEASURED)
+
+        relative_path = mocker.patch(
+            "diff_cover.violationsreporters.clover.GitPathTool.relative_path",
+            side_effect=lambda path: path,
+        )
+        coverage = XmlCoverageReporter([xml])
+        for src_path in file_paths:
+            assert coverage.violations(src_path) == self.FEW_VIOLATIONS
+
+        assert relative_path.call_count == len(file_paths), (
+            "expected each <file> to be classified once, got "
+            f"{relative_path.call_count} calls for {len(file_paths)} files"
+        )
+
+    def test_absolute_paths_still_match_by_suffix(self):
+        # Reports that carry absolute paths are matched by suffix, not equality.
+        # The lookup groups those candidates by their last path segment, so a
+        # file whose segment collides with another must still resolve correctly.
+        xml = self._coverage_xml(
+            ["/build/one/shared.java", "/build/two/shared.java"],
+            self.FEW_VIOLATIONS,
+            self.FEW_MEASURED,
+        )
+
+        coverage = XmlCoverageReporter([xml])
+
+        assert coverage.violations("two/shared.java") == self.FEW_VIOLATIONS
+        assert coverage.measured_lines("two/shared.java") == self.FEW_MEASURED
+        assert coverage.violations("nowhere/shared.java") == set()
+
+    def test_file_without_a_path_is_skipped(self):
+        # A `<file>` carries its path in `path`, or in `name` from PHPUnit's
+        # writer. One with neither cannot be matched against a source path, and
+        # it must not keep the rest of the report from being indexed.
+        xml = self._coverage_xml(["file1.java"], self.FEW_VIOLATIONS, self.FEW_MEASURED)
+        xml.find(".//package").insert(0, etree.Element("file"))
+
+        coverage = XmlCoverageReporter([xml])
+
+        assert coverage.violations("file1.java") == self.FEW_VIOLATIONS
+        assert coverage.measured_lines("file1.java") == self.FEW_MEASURED
+
     def test_two_inputs_first_violate(self):
         # Construct the XML report
         file_paths = ["file1.java"]
@@ -620,7 +726,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 +736,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 +763,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