diff-cover 9.0.0__tar.gz → 9.1.1__tar.gz

{diff_cover-9.0.0 → diff_cover-9.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diff_cover
-Version: 9.0.0
+Version: 9.1.1
 Summary: Run coverage and linting reports on diffs
 Home-page: https://github.com/Bachmann1234/diff-cover
 License: Apache-2.0
@@ -223,6 +223,33 @@ By default, ``diff-cover`` compares the current branch to ``origin/main``.  To s
 
     diff-cover coverage.xml --compare-branch=origin/release
 
+Diff File
+--------------
+
+You may provide a file containing the output of ``git diff`` to ``diff-cover`` instead of using a branch name.
+
+For example, Say you have 2 branches ``main`` and ``feature``. Lets say after creating and checking out the feature branch,
+you make commits ``A``, ``B``, and ``C`` in that order.
+
+
+If you want to see all changes between the ``feature`` and ``main`` branch, you can generate a diff file like this:
+
+.. code:: bash
+
+    git diff main..feature > diff.txt
+
+If you want to see the changes between the ``feature`` branch and the commit ``A``, you can generate a diff file using the following command:
+
+.. code:: bash
+
+    git diff A..feature > diff.txt
+
+You can then run ``diff-cover`` with the diff file as an argument:
+
+.. code:: bash
+
+    diff-cover coverage.xml --diff-file=diff.txt
+
 Fail Under
 ----------
 

{diff_cover-9.0.0 → diff_cover-9.1.1}/README.rst

@@ -190,6 +190,33 @@ By default, ``diff-cover`` compares the current branch to ``origin/main``.  To s
 
     diff-cover coverage.xml --compare-branch=origin/release
 
+Diff File
+--------------
+
+You may provide a file containing the output of ``git diff`` to ``diff-cover`` instead of using a branch name.
+
+For example, Say you have 2 branches ``main`` and ``feature``. Lets say after creating and checking out the feature branch,
+you make commits ``A``, ``B``, and ``C`` in that order.
+
+
+If you want to see all changes between the ``feature`` and ``main`` branch, you can generate a diff file like this:
+
+.. code:: bash
+
+    git diff main..feature > diff.txt
+
+If you want to see the changes between the ``feature`` branch and the commit ``A``, you can generate a diff file using the following command:
+
+.. code:: bash
+
+    git diff A..feature > diff.txt
+
+You can then run ``diff-cover`` with the diff file as an argument:
+
+.. code:: bash
+
+    diff-cover coverage.xml --diff-file=diff.txt
+
 Fail Under
 ----------
 

{diff_cover-9.0.0 → diff_cover-9.1.1}/diff_cover/diff_cover_tool.py

@@ -8,7 +8,7 @@ import xml.etree.ElementTree as etree
 from diff_cover import DESCRIPTION, VERSION
 from diff_cover.config_parser import Tool, get_config
 from diff_cover.diff_reporter import GitDiffReporter
-from diff_cover.git_diff import GitDiffTool
+from diff_cover.git_diff import GitDiffFileTool, GitDiffTool
 from diff_cover.git_path import GitPathTool
 from diff_cover.report_generator import (
     HtmlReportGenerator,
@@ -43,6 +43,7 @@ QUIET_HELP = "Only print errors and failures"
 SHOW_UNCOVERED = "Show uncovered lines on the console"
 INCLUDE_UNTRACKED_HELP = "Include untracked files"
 CONFIG_FILE_HELP = "The configuration file to use"
+DIFF_FILE_HELP = "The diff file to use"
 
 LOGGER = logging.getLogger(__name__)
 
@@ -169,6 +170,8 @@ def parse_coverage_args(argv):
         "-c", "--config-file", help=CONFIG_FILE_HELP, metavar="CONFIG_FILE"
     )
 
+    parser.add_argument("--diff-file", type=str, default=None, help=DIFF_FILE_HELP)
+
     defaults = {
         "show_uncovered": False,
         "compare_branch": "origin/main",
@@ -188,6 +191,7 @@ def parse_coverage_args(argv):
 def generate_coverage_report(
     coverage_files,
     compare_branch,
+    diff_tool,
     html_report=None,
     css_file=None,
     json_report=None,
@@ -198,8 +202,6 @@ def generate_coverage_report(
     exclude=None,
     include=None,
     src_roots=None,
-    diff_range_notation=None,
-    ignore_whitespace=False,
     quiet=False,
     show_uncovered=False,
 ):
@@ -208,7 +210,7 @@ def generate_coverage_report(
     """
     diff = GitDiffReporter(
         compare_branch,
-        git_diff=GitDiffTool(diff_range_notation, ignore_whitespace),
+        git_diff=diff_tool,
         ignore_staged=ignore_staged,
         ignore_unstaged=ignore_unstaged,
         include_untracked=include_untracked,
@@ -281,9 +283,19 @@ def main(argv=None, directory=None):
 
     GitPathTool.set_cwd(directory)
     fail_under = arg_dict.get("fail_under")
+    diff_tool = None
+
+    if not arg_dict["diff_file"]:
+        diff_tool = GitDiffTool(
+            arg_dict["diff_range_notation"], arg_dict["ignore_whitespace"]
+        )
+    else:
+        diff_tool = GitDiffFileTool(arg_dict["diff_file"])
+
     percent_covered = generate_coverage_report(
         arg_dict["coverage_file"],
         arg_dict["compare_branch"],
+        diff_tool,
         html_report=arg_dict["html_report"],
         json_report=arg_dict["json_report"],
         markdown_report=arg_dict["markdown_report"],
@@ -294,8 +306,6 @@ def main(argv=None, directory=None):
         exclude=arg_dict["exclude"],
         include=arg_dict["include"],
         src_roots=arg_dict["src_roots"],
-        diff_range_notation=arg_dict["diff_range_notation"],
-        ignore_whitespace=arg_dict["ignore_whitespace"],
         quiet=quiet,
         show_uncovered=arg_dict["show_uncovered"],
     )

{diff_cover-9.0.0 → diff_cover-9.1.1}/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.0.0 → diff_cover-9.1.1}/diff_cover/git_diff.py

@@ -110,3 +110,38 @@ class GitDiffTool:
         if not output:
             return []
         return [line for line in output.splitlines() if line]
+
+
+class GitDiffFileTool(GitDiffTool):
+
+    def __init__(self, diff_file_path):
+
+        self.diff_file_path = diff_file_path
+        super().__init__("...", False)
+
+    def diff_committed(self, compare_branch="origin/main"):
+        """
+        Returns the contents of a diff file.
+
+        Raises a `GitDiffError` if the file cannot be read.
+        """
+        try:
+            with open(self.diff_file_path, "r") as file:
+                return file.read()
+        except IOError as e:
+            raise ValueError(
+                dedent(
+                    f"""
+                    Could not read the diff file. Make sure '{self.diff_file_path}' exists?
+                    """
+                )
+            )
+
+    def diff_unstaged(self):
+        return ""
+
+    def diff_staged(self):
+        return ""
+
+    def untracked(self):
+        return ""

{diff_cover-9.0.0 → diff_cover-9.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "diff_cover"
-version = "9.0.0"
+version = "9.1.1"
 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.1.0"
-pylint-pytest = "^1.1.7"
+pylint = "^3.2.5"
+pylint-pytest = "^1.1.8"
 pydocstyle = "^6.1.1"
-black = "^24.3.0"
+black = "^24.4.2"
 isort = "^5.13.2"
 doc8 = "1.1.1"
 

{diff_cover-9.0.0 → diff_cover-9.1.1}/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.1/tests/test_git_diff_file.py

@@ -0,0 +1,72 @@
+# pylint: disable=missing-function-docstring
+
+"""Test for diff_cover.git_diff.GitDiffFileTool"""
+
+import pytest
+
+from diff_cover.git_diff import GitDiffFileTool
+
+
+@pytest.fixture
+def mock_file(mocker):
+    def _inner(file_content):
+        mock_open = mocker.mock_open(read_data=file_content)
+        mocker.patch("builtins.open", mock_open)
+
+    return _inner
+
+
+@pytest.fixture
+def diff_tool():
+    def _inner(file):
+        return GitDiffFileTool(file)
+
+    return _inner
+
+
+def test_diff_file_not_found(mocker, diff_tool):
+    mocker.patch("builtins.open", side_effect=IOError)
+
+    _diff_tool = diff_tool("non_existent_diff_file.txt")
+
+    with pytest.raises(ValueError) as excinfo:
+        _diff_tool.diff_committed()
+
+    assert (
+        f"Could not read the diff file. Make sure '{_diff_tool.diff_file_path}' exists?"
+        in str(excinfo.value)
+    )
+    assert _diff_tool.diff_file_path == "non_existent_diff_file.txt"
+
+
+def test_large_diff_file(mock_file, diff_tool):
+    large_diff = "diff --git a/file1 b/file2\n" * 1000000
+
+    mock_file(large_diff)
+
+    _diff_tool = diff_tool("large_diff_file.txt")
+
+    assert _diff_tool.diff_committed() == large_diff
+    assert _diff_tool.diff_file_path == "large_diff_file.txt"
+
+
+def test_diff_committed(mock_file, diff_tool):
+    diff = "diff --git a/file1 b/file2\n"
+
+    mock_file(diff)
+
+    _diff_tool = diff_tool("diff_file.txt")
+
+    assert _diff_tool.diff_committed() == diff
+    assert _diff_tool.diff_file_path == "diff_file.txt"
+
+
+def test_empty_diff_file(mock_file, diff_tool):
+    empty_diff = ""
+
+    mock_file(empty_diff)
+
+    _diff_tool = diff_tool("empty_diff.txt")
+
+    assert _diff_tool.diff_committed() == empty_diff
+    assert _diff_tool.diff_file_path == "empty_diff.txt"