diff-cover 9.4.1__tar.gz → 9.6.0__tar.gz

{diff_cover-9.4.1 → diff_cover-9.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: diff_cover
-Version: 9.4.1
+Version: 9.6.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`` 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.4.1 → diff_cover-9.6.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`` 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.4.1 → diff_cover-9.6.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.4.1 → diff_cover-9.6.0}/diff_cover/diff_quality_tool.py

@@ -50,6 +50,7 @@ from diff_cover.violationsreporters.java_violations_reporter import (
     checkstyle_driver,
 )
 from diff_cover.violationsreporters.violations_reporter import (
+    ClangFormatDriver,
     CppcheckDriver,
     EslintDriver,
     PylintDriver,
@@ -63,6 +64,7 @@ from diff_cover.violationsreporters.violations_reporter import (
 )
 
 QUALITY_DRIVERS = {
+    "clang": ClangFormatDriver(),
     "cppcheck": CppcheckDriver(),
     "pycodestyle": pycodestyle_driver,
     "pyflakes": pyflakes_driver,

{diff_cover-9.4.1 → diff_cover-9.6.0}/diff_cover/report_generator.py

@@ -420,6 +420,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.6.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.4.1 → diff_cover-9.6.0}/diff_cover/violationsreporters/violations_reporter.py

@@ -831,3 +831,67 @@ class CppcheckDriver(QualityDriver):
         Returns: boolean True if installed
         """
         return run_command_for_code(self.command_to_check_install) == 0
+
+
+class ClangFormatDriver(QualityDriver):
+    """
+    Driver for clang-format
+    """
+
+    def __init__(self):
+        """
+        args:
+            expression: regex used to parse report
+        See super for other args
+        """
+        super().__init__(
+            "clang",
+            ["c", "cpp", "h", "hpp"],
+            ["clang-format", "--dry-run"],  # Use dry-run option to not modify files
+            output_stderr=True,
+        )
+
+        # Errors look like:
+        # src/foo.c:8:1: warning: code should be clang-formatted [-Wclang-format-violations]
+        # int foo;
+        #   ^
+        # Match for everything, including ":" in the file name (first capturing
+        # group), in case there are pathological path names with ":"
+        self.clang_expression = re.compile(
+            r"^(.*?):(\d+):\d+: ([^[]* \[[^]]*\])\n(.+)\n(.+)$",
+            re.MULTILINE,
+        )
+        self.command_to_check_install = ["clang-format", "--version"]
+
+    def parse_reports(self, reports):
+        """
+        Args:
+            reports: list[str] - output from the report
+        Return:
+            A dict[Str:Violation]
+            Violation is a simple named tuple Defined above
+        """
+        violations_dict = defaultdict(list)
+        for report in reports:
+
+            matches = list(re.finditer(self.clang_expression, report))
+            for match in matches:
+                if match is not None:
+                    (
+                        clang_src_path,
+                        line_number,
+                        message,
+                        code_extract,
+                        cursor_error,
+                    ) = match.groups()
+                    full_message = f"{message}\n{code_extract}\n{cursor_error}"
+                    violation = Violation(int(line_number), full_message)
+                    violations_dict[clang_src_path].append(violation)
+        return violations_dict
+
+    def installed(self):
+        """
+        Method checks if the provided tool is installed.
+        Returns: boolean True if installed
+        """
+        return run_command_for_code(self.command_to_check_install) == 0

{diff_cover-9.4.1 → diff_cover-9.6.0}/pyproject.toml

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

{diff_cover-9.4.1 → diff_cover-9.6.0}/tests/test_integration.py

@@ -2,12 +2,12 @@
 # pylint: disable=use-implicit-booleaness-not-comparison
 
 """High-level integration tests of diff-cover tool."""
-
 import json
 import os
 import os.path
 import re
 import shutil
+import textwrap
 from collections import defaultdict
 from pathlib import Path
 from subprocess import Popen
@@ -96,21 +96,23 @@ def patch_git_command(patch_popen, mocker):
     return helper
 
 
+def clean_html(html, clear_inline_css):
+    if clear_inline_css:
+        html = re.sub("<style>.*</style>", "", html, flags=re.DOTALL)
+    return html.strip()
+
+
 def compare_html(expected_html_path, html_report_path, clear_inline_css=True):
-    clean_content = re.compile("<style>.*</style>", flags=re.DOTALL)
     expected_file = open(expected_html_path, encoding="utf-8")
     html_report = open(html_report_path, encoding="utf-8")
 
     with expected_file, html_report:
-        html = html_report.read()
-        expected = expected_file.read()
-        if clear_inline_css:
-            # The CSS is provided by pygments and changes fairly often.
-            # Im ok with simply saying "There was css"
-            # Perhaps I will eat these words
-            html = clean_content.sub("", html)
-            expected = clean_content.sub("", expected)
-        assert expected.strip() == html.strip()
+        # The CSS is provided by pygments and changes fairly often.
+        # Im ok with simply saying "There was css"
+        # Perhaps I will eat these words
+        html = clean_html(html_report.read(), clear_inline_css)
+        expected = clean_html(expected_file.read(), clear_inline_css)
+        assert expected == html
 
 
 def compare_markdown(expected_file_path, actual_file_path):
@@ -179,6 +181,36 @@ class TestDiffCoverIntegration:
         compare_json("add_json_report.json", "dummy/diff_coverage.json")
         compare_markdown("add_markdown_report.md", "dummy/diff_coverage.md")
 
+    def test_all_reports_with_stdout(self, runbin, patch_git_command, capsys):
+        patch_git_command.set_stdout("git_diff_add.txt")
+        assert (
+            runbin(
+                [
+                    "coverage.xml",
+                    "--format",
+                    "html:-,json:-,markdown:-",
+                ]
+            )
+            == 0
+        )
+        output = capsys.readouterr().out
+        with open("add_console_report.txt", "r", encoding="utf-8") as f:
+            actual = f.read()
+            assert actual in output
+        with open("add_html_report.html", "r", encoding="utf-8") as f:
+            actual = clean_html(f.read(), clear_inline_css=True)
+            # can't compare the output inside <head> since it changes
+            # a lot so we just compare the body
+            actual = actual[actual.find("</head>") :]
+            assert len(actual) > 20
+            assert actual in output
+        with open("add_json_report.json", "r", encoding="utf-8") as f:
+            actual = json.dumps(json.loads(f.read()))
+            assert actual in output
+        with open("add_markdown_report.md", "r", encoding="utf-8") as f:
+            actual = f.read()
+            assert actual in output
+
     def test_added_file_console_lcov(self, runbin, patch_git_command, capsys):
         patch_git_command.set_stdout("git_diff_add.txt")
         assert runbin(["lcov.info"]) == 0
@@ -397,6 +429,54 @@ class TestDiffCoverIntegration:
         assert runbin(["coverage_missing_lines.xml", "--expand-coverage-report"]) == 0
         compare_console("expand_console_report.txt", capsys.readouterr().out)
 
+    def test_github_silent(self, runbin, patch_git_command, capsys):
+        patch_git_command.set_stdout("git_diff_add.txt")
+        assert (
+            runbin(["coverage.xml", "--format", "github-annotations:notice", "-q"]) == 0
+        )
+        expected = textwrap.dedent(
+            """\
+        ::notice file=test_src.txt,line=2,title=Missing Coverage::Line 2 missing coverage
+        ::notice file=test_src.txt,line=4,title=Missing Coverage::Line 4 missing coverage
+        ::notice file=test_src.txt,line=6,title=Missing Coverage::Line 6 missing coverage
+        ::notice file=test_src.txt,line=8,title=Missing Coverage::Line 8 missing coverage
+        ::notice file=test_src.txt,line=10,title=Missing Coverage::Line 10 missing coverage
+        """
+        )
+        assert capsys.readouterr().out == expected
+
+    @pytest.mark.usefixtures("patch_git_command")
+    def test_github_fully_covered(self, runbin, capsys):
+        assert runbin(["coverage2.xml", "--format", "github-annotations:notice"]) == 0
+        expected = textwrap.dedent(
+            """\
+        -------------
+        Diff Coverage
+        Diff: origin/main...HEAD, staged and unstaged changes
+        -------------
+        No lines with coverage information in this diff.
+        -------------
+
+        """
+        )
+        assert capsys.readouterr().out == expected
+
+    def test_github_empty_diff(self, runbin, patch_git_command, capsys):
+        patch_git_command.set_stdout("")
+        assert runbin(["coverage.xml", "--format", "github-annotations:notice"]) == 0
+        expected = textwrap.dedent(
+            """\
+        -------------
+        Diff Coverage
+        Diff: origin/main...HEAD, staged and unstaged changes
+        -------------
+        No lines with coverage information in this diff.
+        -------------
+
+        """
+        )
+        assert capsys.readouterr().out == expected
+
     def test_real_world_cpp_lcov_coverage(self, runbin, patch_git_command, capsys):
         """Test with real C++ LCOV coverage data"""
         # Create git diff for C++ files

{diff_cover-9.4.1 → diff_cover-9.6.0}/tests/test_report_generator.py

@@ -10,6 +10,7 @@ import pytest
 from diff_cover.diff_reporter import BaseDiffReporter
 from diff_cover.report_generator import (
     BaseReportGenerator,
+    GitHubAnnotationsReportGenerator,
     HtmlReportGenerator,
     JsonReportGenerator,
     MarkdownReportGenerator,
@@ -407,6 +408,64 @@ class TestStringReportGenerator(BaseReportGeneratorTest):
         self.assert_report(expected)
 
 
+class TestGitHubAnnotationsReportGenerator(BaseReportGeneratorTest):
+
+    @pytest.fixture
+    def report(self, coverage, diff):
+        # Create a concrete instance of a report generator
+        return GitHubAnnotationsReportGenerator(coverage, diff, "warning")
+
+    @pytest.mark.usefixtures("use_default_values")
+    def test_generate_report(self):
+        # Verify that we got the expected string
+        expected = dedent(
+            """
+        ::warning file=file1.py,line=10,endLine=11,title=Missing Coverage::Line 10-11 missing coverage
+        ::warning file=subdir/file2.py,line=10,endLine=11,title=Missing Coverage::Line 10-11 missing coverage
+        """
+        ).strip()
+
+        self.assert_report(expected)
+
+    def test_single_line(
+        self, diff, diff_lines_changed, coverage_violations, coverage_measured_lines
+    ):
+        diff.src_paths_changed.return_value = ["file.py"]
+        diff_lines_changed.update({"file.py": list(range(100))})
+        coverage_violations.update({"file.py": [Violation(10, None)]})
+        coverage_measured_lines.update({"file.py": [2]})
+
+        # Verify that we got the expected string
+        expected = dedent(
+            """
+        ::warning file=file.py,line=10,title=Missing Coverage::Line 10 missing coverage
+        """
+        ).strip()
+
+        self.assert_report(expected)
+
+    def test_hundred_percent(
+        self, diff, diff_lines_changed, coverage_violations, coverage_measured_lines
+    ):
+        # Have the dependencies return an empty report
+        diff.src_paths_changed.return_value = ["file.py"]
+        diff_lines_changed.update({"file.py": list(range(100))})
+        coverage_violations.update({"file.py": []})
+        coverage_measured_lines.update({"file.py": [2]})
+
+        expected = ""
+
+        self.assert_report(expected)
+
+    def test_empty_report(self):
+        # Have the dependencies return an empty report
+        # (this is the default)
+
+        expected = ""
+
+        self.assert_report(expected)
+
+
 class TestHtmlReportGenerator(BaseReportGeneratorTest):
 
     @pytest.fixture

{diff_cover-9.4.1 → diff_cover-9.6.0}/tests/test_violations_reporter.py

@@ -17,6 +17,7 @@ from diff_cover.command_runner import CommandError, run_command_for_code
 from diff_cover.violationsreporters import base
 from diff_cover.violationsreporters.base import QualityReporter
 from diff_cover.violationsreporters.violations_reporter import (
+    ClangFormatDriver,
     CppcheckDriver,
     EslintDriver,
     LcovCoverageReporter,
@@ -2238,3 +2239,23 @@ class TestRuffCheckQualityDriverTest:
 
         assert quality.name() == "ruff.check"
         assert actual_violations == expected_violations
+
+
+class TestClangFormatcheckQualityDriverTest:
+    """Tests for clang-format quality driver."""
+
+    def test_parse_report(self):
+        """Basic report test parse"""
+        expected_violations = {
+            "src/foo.c": [
+                Violation(
+                    12,
+                    "warning: code should be clang-formatted [-Wclang-format-violations]\n        int  bar;\n           ^",
+                ),
+            ]
+        }
+        report = "src/foo.c:12:1: warning: code should be clang-formatted [-Wclang-format-violations]\n        int  bar;\n           ^"
+
+        driver = ClangFormatDriver()
+        actual_violations = driver.parse_reports([report])
+        assert actual_violations == expected_violations