diff-cover 9.5.0__tar.gz → 9.7.0__tar.gz

{diff_cover-9.5.0 → diff_cover-9.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: diff_cover
-Version: 9.5.0
+Version: 9.7.0
 Summary: Run coverage and linting reports on diffs
 License: Apache-2.0
 Author: See Contributors
@@ -161,7 +161,7 @@ You can use diff-cover to see quality reports on the diff as well by running
     diff-quality --violations=<tool>
 
 Where ``tool`` is the quality checker to use. Currently ``pycodestyle``, ``pyflakes``,
-``flake8``, ``pylint``, ``checkstyle``, ``checkstylexml``, ``ruff check``, ``clang`` are supported, but more
+``flake8``, ``pylint``, ``checkstyle``, ``checkstylexml``, ``ruff.check``, ``clang`` are supported, but more
 checkers can (and should!) be supported. See the section "Adding `diff-quality``
 Support for a New Quality Checker".
 

{diff_cover-9.5.0 → diff_cover-9.7.0}/README.rst

@@ -129,7 +129,7 @@ You can use diff-cover to see quality reports on the diff as well by running
     diff-quality --violations=<tool>
 
 Where ``tool`` is the quality checker to use. Currently ``pycodestyle``, ``pyflakes``,
-``flake8``, ``pylint``, ``checkstyle``, ``checkstylexml``, ``ruff check``, ``clang`` are supported, but more
+``flake8``, ``pylint``, ``checkstyle``, ``checkstylexml``, ``ruff.check``, ``clang`` are supported, but more
 checkers can (and should!) be supported. See the section "Adding `diff-quality``
 Support for a New Quality Checker".
 

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/command_runner.py

@@ -24,12 +24,12 @@ def execute(command, exit_codes=None):
         exit_codes = [0]
 
     stdout_pipe = subprocess.PIPE
-    process = subprocess.Popen(command, stdout=stdout_pipe, stderr=stdout_pipe)
-    try:
-        stdout, stderr = process.communicate()
-    except OSError:
-        sys.stderr.write(" ".join(_ensure_unicode(cmd) for cmd in command))
-        raise
+    with subprocess.Popen(command, stdout=stdout_pipe, stderr=stdout_pipe) as process:
+        try:
+            stdout, stderr = process.communicate()
+        except OSError:
+            sys.stderr.write(" ".join(_ensure_unicode(cmd) for cmd in command))
+            raise
 
     stderr = _ensure_unicode(stderr)
     if process.returncode not in exit_codes:
@@ -43,10 +43,10 @@ def run_command_for_code(command):
     Returns command's exit code.
     """
     try:
-        process = subprocess.Popen(
+        with subprocess.Popen(
             command, stdout=subprocess.PIPE, stderr=subprocess.PIPE
-        )
-        process.communicate()
+        ) as process:
+            process.communicate()
     except FileNotFoundError:
         return 1
     return process.returncode

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/config_parser.py

@@ -6,15 +6,12 @@ try:
 
     _HAS_TOML = True
 except ImportError:  # pragma: no cover
-    _HAS_TOML = False
-
-if not _HAS_TOML:
     try:
         import tomllib as toml
 
         _HAS_TOML = True
-    except ImportError:  # pragma: no cover
-        pass
+    except ImportError:
+        _HAS_TOML = False
 
 
 class Tool(enum.Enum):

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/diff_cover_tool.py

@@ -12,6 +12,7 @@ from diff_cover.diff_reporter import GitDiffReporter
 from diff_cover.git_diff import GitDiffFileTool, GitDiffTool
 from diff_cover.git_path import GitPathTool
 from diff_cover.report_generator import (
+    GitHubAnnotationsReportGenerator,
     HtmlReportGenerator,
     JsonReportGenerator,
     MarkdownReportGenerator,
@@ -266,9 +267,18 @@ def generate_coverage_report(
     if "markdown" in report_formats:
         markdown_report = report_formats["markdown"] or MARKDOWN_REPORT_DEFAULT_PATH
         reporter = MarkdownReportGenerator(coverage, diff)
-        with open(markdown_report, "wb") as output_file:
+        with open_file(markdown_report, "wb") as output_file:
             reporter.generate_report(output_file)
 
+    if "github-annotations" in report_formats:
+        # Github annotations are always written to stdout, but we can use different types
+        reporter = GitHubAnnotationsReportGenerator(
+            coverage,
+            diff,
+            report_formats["github-annotations"],
+        )
+        reporter.generate_report(sys.stdout.buffer)
+
     # Generate the report for stdout
     reporter = StringReportGenerator(coverage, diff, show_uncovered)
     output_file = io.BytesIO() if quiet else sys.stdout.buffer

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/diff_quality_tool.py

@@ -3,6 +3,7 @@ Implement the command-line tool interface for diff_quality.
 """
 
 import argparse
+import contextlib
 import io
 import logging
 import os
@@ -56,6 +57,7 @@ from diff_cover.violationsreporters.violations_reporter import (
     PylintDriver,
     flake8_driver,
     jshint_driver,
+    mypy_driver,
     pycodestyle_driver,
     pydocstyle_driver,
     pyflakes_driver,
@@ -66,6 +68,7 @@ from diff_cover.violationsreporters.violations_reporter import (
 QUALITY_DRIVERS = {
     "clang": ClangFormatDriver(),
     "cppcheck": CppcheckDriver(),
+    "mypy": mypy_driver,
     "pycodestyle": pycodestyle_driver,
     "pyflakes": pyflakes_driver,
     "pylint": PylintDriver(),
@@ -81,8 +84,8 @@ QUALITY_DRIVERS = {
     "shellcheck": shellcheck_driver,
 }
 
-VIOLATION_CMD_HELP = "Which code quality tool to use (%s)" % "/".join(
-    sorted(QUALITY_DRIVERS)
+VIOLATION_CMD_HELP = (
+    f"Which code quality tool to use ({'/'.join(sorted(QUALITY_DRIVERS))})"
 )
 INPUT_REPORTS_HELP = "Which violations reports to use"
 OPTIONS_HELP = "Options to be passed to the violations tool"
@@ -315,20 +318,24 @@ def main(argv=None, directory=None):
         plugin_manager.add_hookspecs(hookspecs)
         plugin_manager.load_setuptools_entrypoints("diff_cover")
 
-        hooks = (
-            plugin_manager.hook.diff_cover_report_quality  # pylint: disable=no-member
-        )
+        hooks = plugin_manager.hook.diff_cover_report_quality
         for hookimpl in hooks.get_hookimpls():
             if hookimpl.plugin_name == tool:
                 reporter_factory_fn = hookimpl.function
                 break
 
-    if reporter or driver or reporter_factory_fn:
-        input_reports = []
+    # If none of the reporter, driver, or reporter_factory_fn are set
+    if not any((reporter, driver, reporter_factory_fn)):
+        LOGGER.error("Quality tool not recognized: '%s'", tool)
+        return 1
+
+    with contextlib.ExitStack() as stack:
         try:
+            input_reports = []
             for path in arg_dict["input_reports"]:
                 try:
-                    input_reports.append(open(path, "rb"))
+                    file_handle = stack.enter_context(open(path, "rb"))
+                    input_reports.append(file_handle)
                 except OSError:
                     LOGGER.error("Could not load report '%s'", path)
                     return 1
@@ -373,14 +380,6 @@ def main(argv=None, directory=None):
         except OSError as exc:
             LOGGER.error("Failure: '%s'", str(exc))
             return 1
-        # Close any reports we opened
-        finally:
-            for file_handle in input_reports:
-                file_handle.close()
-
-    else:
-        LOGGER.error("Quality tool not recognized: '%s'", tool)
-        return 1
 
 
 if __name__ == "__main__":

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/diff_reporter.py

@@ -9,6 +9,7 @@ import re
 from abc import ABC, abstractmethod
 
 from diff_cover.git_diff import GitDiffError
+from diff_cover.util import to_unix_path, to_unix_paths
 
 
 class BaseDiffReporter(ABC):
@@ -85,7 +86,7 @@ class BaseDiffReporter(ABC):
         include = self._include
         if include:
             for pattern in include:
-                if path in glob.glob(pattern, recursive=True):
+                if path in to_unix_paths(glob.glob(pattern, recursive=True)):
                     break  # file is included
             else:
                 return True
@@ -200,7 +201,7 @@ class GitDiffReporter(BaseDiffReporter):
 
         # Look up the modified lines for the source file
         # If no lines modified, return an empty list
-        return diff_dict.get(src_path, [])
+        return diff_dict.get(to_unix_path(src_path), [])
 
     def _get_included_diff_results(self):
         """
@@ -237,12 +238,13 @@ class GitDiffReporter(BaseDiffReporter):
                 diff_dict = self._parse_diff_str(diff_str)
 
                 for src_path, (added_lines, deleted_lines) in diff_dict.items():
+                    src_path = to_unix_path(src_path)
                     if not self._validate_path_to_diff(src_path):
                         continue
 
                     # Remove any lines from the dict that have been deleted
                     # Include any lines that have been added
-                    result_dict[src_path] = [
+                    result_dict[to_unix_path(src_path)] = [
                         line
                         for line in result_dict.get(src_path, [])
                         if line not in deleted_lines
@@ -332,6 +334,7 @@ class GitDiffReporter(BaseDiffReporter):
 
         # Parse the diff string into sections by source file
         for line in diff_str.split("\n"):
+            line = line.rstrip()
             # If the line starts with "diff --git"
             # or "diff --cc" (in the case of a merge conflict)
             # then it is the start of a new source file
@@ -501,7 +504,7 @@ class GitDiffReporter(BaseDiffReporter):
         number is included once and the lines are ordered sequentially.
         """
 
-        if len(line_numbers) == 0:
+        if not line_numbers:
             return []
 
         # Ensure lines are unique by putting them in a set

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/git_diff.py

@@ -132,7 +132,7 @@ class GitDiffFileTool(GitDiffTool):
         Raises a `GitDiffError` if the file cannot be read.
         """
         try:
-            with open(self.diff_file_path, "r") as file:
+            with open(self.diff_file_path, "r", encoding="utf-8") as file:
                 return file.read()
         except OSError as e:
             error_message = (

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/git_path.py

@@ -6,6 +6,7 @@ import os
 import sys
 
 from diff_cover.command_runner import execute
+from diff_cover.util import to_unix_path
 
 
 class GitPathTool:
@@ -51,7 +52,7 @@ class GitPathTool:
         # and src_path is `other_package/some_file.py`
         # search for `/home/user/work/diff-cover/other_package/some_file.py`
 
-        return os.path.join(cls._root, src_path)
+        return to_unix_path(os.path.join(cls._root, src_path))
 
     @classmethod
     def _git_root(cls):

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/report_generator.py

@@ -4,13 +4,13 @@ Classes for generating diff coverage reports.
 
 import contextlib
 import json
-import os
 from abc import ABC, abstractmethod
 from gettext import gettext, ngettext
 
 from jinja2 import Environment, PackageLoader, select_autoescape
 
 from diff_cover.snippets import Snippet
+from diff_cover.util import to_unix_path
 
 
 class DiffViolations:
@@ -149,10 +149,7 @@ class BaseReportGenerator(ABC):
         """
 
         return sum(
-            [
-                len(summary.measured_lines)
-                for summary in self._diff_violations().values()
-            ]
+            len(summary.measured_lines) for summary in self._diff_violations().values()
         )
 
     def total_num_violations(self):
@@ -193,13 +190,14 @@ class BaseReportGenerator(ABC):
 
         To make this efficient, we cache and reuse the result.
         """
+
         src_paths_changed = self._diff.src_paths_changed()
         if not self._diff_violations_dict:
             try:
                 violations = self._violations.violations_batch(src_paths_changed)
                 self._diff_violations_dict = {
-                    os.path.normpath(src_path): DiffViolations(
-                        violations.get(os.path.normpath(src_path), []),
+                    to_unix_path(src_path): DiffViolations(
+                        violations.get(to_unix_path(src_path), []),
                         self._violations.measured_lines(src_path),
                         self._diff.lines_changed(src_path),
                     )
@@ -420,6 +418,27 @@ class StringReportGenerator(TemplateReportGenerator):
         self.include_snippets = show_uncovered
 
 
+class GitHubAnnotationsReportGenerator(TemplateReportGenerator):
+    """
+    Generate a diff coverage report for GitHub annotations.
+    https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-debug-message
+    https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-notice-message
+    https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-a-warning-message
+    https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-error-message
+    """
+
+    template_path = "github_coverage_annotations.txt"
+
+    def __init__(self, violations_reporter, diff_reporter, annotations_type):
+        super().__init__(violations_reporter, diff_reporter)
+        self.annotations_type = annotations_type
+
+    def _context(self):
+        context = super().report_dict()
+        context.update({"annotations_type": self.annotations_type})
+        return context
+
+
 class HtmlReportGenerator(TemplateReportGenerator):
     """
     Generate an HTML formatted diff coverage report.

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/snippets.py

@@ -128,21 +128,16 @@ class Snippet:
             if i in self._violation_lines:
                 notice = "!"
 
-            format_string = "{} {:>" + str(line_number_length) + "} {}"
-            text += format_string.format(notice, i, line)
+            text += f"{notice} {i:>{line_number_length}} {line}"
 
-        header = "Lines %d-%d\n\n" % (self._start_line, self._last_line)
+        header = f"Lines {self._start_line}-{self._last_line}\n\n"
         if self._lexer_name in self.LEXER_TO_MARKDOWN_CODE_HINT:
-            return header + (
-                "```"
-                + self.LEXER_TO_MARKDOWN_CODE_HINT[self._lexer_name]
-                + "\n"
-                + text
-                + "\n```\n"
-            )
+            code_hint = self.LEXER_TO_MARKDOWN_CODE_HINT[self._lexer_name]
+            code_block = f"""```{code_hint}\n{text}\n```\n"""
+            return header + code_block
 
         # unknown programming language, return a non-decorated fenced code block:
-        return "```\n" + text + "\n```\n"
+        return f"""```\n{text}\n```\n"""
 
     def terminal(self):
         """

diff_cover-9.7.0/diff_cover/templates/github_coverage_annotations.txt

@@ -0,0 +1,10 @@
+{% if src_stats %}
+{% for src_path, stats in src_stats|dictsort %}
+{% if stats.percent_covered < 100 %}
+{% for line in stats.violation_lines %}
+{% set splitLines = line.split("-") %}
+::{{ annotations_type }} file={{ src_path }},line={{ splitLines[0] }}{% if splitLines[1] %},endLine={{ splitLines[1] }}{% endif %},title=Missing Coverage::Line {{ line }} missing coverage
+{% endfor %}
+{% endif %}
+{% endfor %}
+{% endif %}

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/util.py

@@ -47,6 +47,10 @@ def to_unix_path(path):
     return posixpath.normpath(os.path.normcase(path).replace("\\", "/"))
 
 
+def to_unix_paths(paths):
+    return [to_unix_path(path) for path in paths]
+
+
 def to_unescaped_filename(filename: str) -> str:
     """Try to unescape the given filename.
 

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/violationsreporters/base.py

@@ -6,6 +6,7 @@ from abc import ABC, abstractmethod
 from collections import defaultdict, namedtuple
 
 from diff_cover.command_runner import execute, run_command_for_code
+from diff_cover.util import to_unix_path
 
 Violation = namedtuple("Violation", "line, message")
 
@@ -60,7 +61,7 @@ class BaseViolationReporter(ABC):
         """
         # An existing quality plugin "sqlfluff" depends on this
         # being not abstract and returning None
-        return None
+        del src_path
 
     def name(self):
         """
@@ -156,6 +157,10 @@ class QualityReporter(BaseViolationReporter):
                 self.violations_dict = self.driver.parse_reports(self.reports)
                 return self.violations_dict[src_path]
 
+            if not os.path.exists(src_path):
+                self.violations_dict[src_path] = []
+                return self.violations_dict[src_path]
+
             if self.driver_tool_installed is None:
                 self.driver_tool_installed = self.driver.installed()
             if not self.driver_tool_installed:
@@ -165,8 +170,7 @@ class QualityReporter(BaseViolationReporter):
             if self.options:
                 for arg in self.options.split():
                     command.append(arg)
-            if os.path.exists(src_path):
-                command.append(src_path.encode(sys.getfilesystemencoding()))
+            command.append(src_path.encode(sys.getfilesystemencoding()))
 
             stdout, stderr = execute(command, self.driver.exit_codes)
             output = stderr if self.driver.output_stderr else stdout
@@ -229,13 +233,15 @@ class RegexBasedDriver(QualityDriver):
             if self.expression.flags & re.MULTILINE:
                 matches = (match for match in re.finditer(self.expression, report))
             else:
-                matches = (self.expression.match(line) for line in report.split("\n"))
+                matches = (
+                    self.expression.match(line.rstrip()) for line in report.split("\n")
+                )
             for match in matches:
                 if match is not None:
                     src, line_number, message = match.groups()
                     # Transform src to a relative path, if it isn't already
-                    src = os.path.relpath(src)
-                    violation = Violation(int(line_number), message)
+                    src = to_unix_path(os.path.relpath(src))
+                    violation = Violation(int(line_number), message.rstrip())
                     violations_dict[src].append(violation)
         return violations_dict
 

{diff_cover-9.5.0 → diff_cover-9.7.0}/diff_cover/violationsreporters/java_violations_reporter.py

@@ -2,12 +2,12 @@
 Classes for querying the information in a test coverage report.
 """
 
-import os
 import xml.etree.ElementTree as etree
 from collections import defaultdict
 
 from diff_cover.command_runner import run_command_for_code
 from diff_cover.git_path import GitPathTool
+from diff_cover.util import to_unix_path
 from diff_cover.violationsreporters.base import (
     QualityDriver,
     RegexBasedDriver,
@@ -66,12 +66,11 @@ class CheckstyleXmlDriver(QualityDriver):
             for file_tree in files:
                 for error in file_tree.findall("error"):
                     line_number = error.get("line")
-                    error_str = "{}: {}".format(
-                        error.get("severity"), error.get("message")
-                    )
-                    violation = Violation(int(line_number), error_str)
+                    severity = error.get("severity")
+                    message = error.get("message")
+                    violation = Violation(int(line_number), f"{severity}: {message}")
                     filename = GitPathTool.relative_path(file_tree.get("name"))
-                    violations_dict[filename].append(violation)
+                    violations_dict[to_unix_path(filename)].append(violation)
         return violations_dict
 
     def installed(self):
@@ -113,7 +112,7 @@ class FindbugsXmlDriver(QualityDriver):
                     error_str = f"{category}: {short_message}"
                     violation = Violation(line_number, error_str)
                     filename = GitPathTool.relative_path(line.get("sourcepath"))
-                    violations_dict[filename].append(violation)
+                    violations_dict[to_unix_path(filename)].append(violation)
 
         return violations_dict
 
@@ -149,11 +148,11 @@ class PmdXmlDriver(QualityDriver):
             for node_file in node_files:
                 for error in node_file.findall("violation"):
                     line_number = error.get("beginline")
-                    error_str = "{}: {}".format(error.get("rule"), error.text.strip())
-                    violation = Violation(int(line_number), error_str)
+                    rule = error.get("rule")
+                    message = error.text.strip()
+                    violation = Violation(int(line_number), f"{rule}: {message}")
                     filename = GitPathTool.relative_path(node_file.get("name"))
-                    filename = filename.replace(os.sep, "/")
-                    violations_dict[filename].append(violation)
+                    violations_dict[to_unix_path(filename)].append(violation)
 
         return violations_dict