diff-cover 9.3.2__tar.gz → 9.4.0__tar.gz

{diff_cover-9.3.2 → diff_cover-9.4.0}/PKG-INFO

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

{diff_cover-9.3.2 → diff_cover-9.4.0}/diff_cover/diff_cover_tool.py

@@ -17,6 +17,7 @@ from diff_cover.report_generator import (
     MarkdownReportGenerator,
     StringReportGenerator,
 )
+from diff_cover.util import open_file
 from diff_cover.violationsreporters.violations_reporter import (
     LcovCoverageReporter,
     XmlCoverageReporter,
@@ -81,7 +82,7 @@ def parse_coverage_args(argv):
     """
     parser = argparse.ArgumentParser(description=DESCRIPTION)
 
-    parser.add_argument("coverage_file", type=str, help=COVERAGE_FILE_HELP, nargs="+")
+    parser.add_argument("coverage_files", type=str, help=COVERAGE_FILE_HELP, nargs="+")
 
     parser.add_argument(
         "--format",
@@ -236,9 +237,9 @@ def generate_coverage_report(
         for coverage_file in coverage_files
         if not coverage_file.endswith(".xml")
     ]
-    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:
+    if xml_roots and lcov_roots:
+        raise ValueError("Mixing LCov and XML reports is not supported yet")
+    if xml_roots:
         coverage = XmlCoverageReporter(xml_roots, src_roots, expand_coverage_report)
     else:
         coverage = LcovCoverageReporter(lcov_roots, src_roots)
@@ -250,7 +251,7 @@ def generate_coverage_report(
         if css_url is not None:
             css_url = os.path.relpath(css_file, os.path.dirname(html_report))
         reporter = HtmlReportGenerator(coverage, diff, css_url=css_url)
-        with open(html_report, "wb") as output_file:
+        with open_file(html_report, "wb") as output_file:
             reporter.generate_report(output_file)
         if css_file is not None:
             with open(css_file, "wb") as output_file:
@@ -259,7 +260,7 @@ def generate_coverage_report(
     if "json" in report_formats:
         json_report = report_formats["json"] or JSON_REPORT_DEFAULT_PATH
         reporter = JsonReportGenerator(coverage, diff)
-        with open(json_report, "wb") as output_file:
+        with open_file(json_report, "wb") as output_file:
             reporter.generate_report(output_file)
 
     if "markdown" in report_formats:
@@ -351,7 +352,7 @@ def main(argv=None, directory=None):
         diff_tool = GitDiffFileTool(arg_dict["diff_file"])
 
     percent_covered = generate_coverage_report(
-        arg_dict["coverage_file"],
+        arg_dict["coverage_files"],
         arg_dict["compare_branch"],
         diff_tool,
         report_formats=arg_dict["format"],

{diff_cover-9.3.2 → diff_cover-9.4.0}/diff_cover/diff_quality_tool.py

@@ -41,6 +41,7 @@ from diff_cover.report_generator import (
     MarkdownQualityReportGenerator,
     StringQualityReportGenerator,
 )
+from diff_cover.util import open_file
 from diff_cover.violationsreporters.base import QualityReporter
 from diff_cover.violationsreporters.java_violations_reporter import (
     CheckstyleXmlDriver,
@@ -248,7 +249,7 @@ def generate_quality_report(
         if css_url is not None:
             css_url = os.path.relpath(css_file, os.path.dirname(html_report))
         reporter = HtmlQualityReportGenerator(tool, diff, css_url=css_url)
-        with open(html_report, "wb") as output_file:
+        with open_file(html_report, "wb") as output_file:
             reporter.generate_report(output_file)
         if css_file is not None:
             with open(css_file, "wb") as output_file:
@@ -257,13 +258,13 @@ def generate_quality_report(
     if "json" in report_formats:
         json_report = report_formats["json"] or JSON_REPORT_DEFAULT_PATH
         reporter = JsonReportGenerator(tool, diff)
-        with open(json_report, "wb") as output_file:
+        with open_file(json_report, "wb") as output_file:
             reporter.generate_report(output_file)
 
     if "markdown" in report_formats:
         markdown_report = report_formats["markdown"] or MARKDOWN_REPORT_DEFAULT_PATH
         reporter = MarkdownQualityReportGenerator(tool, diff)
-        with open(markdown_report, "wb") as output_file:
+        with open_file(markdown_report, "wb") as output_file:
             reporter.generate_report(output_file)
 
     # Generate the report for stdout

{diff_cover-9.3.2 → diff_cover-9.4.0}/diff_cover/diff_reporter.py

@@ -349,22 +349,20 @@ class GitDiffReporter(BaseDiffReporter):
 
             # Every other line is stored in the dictionary for this source file
             # once we find a hunk section
-            else:
-                # Only add lines if we're in a hunk section
-                # (ignore index and files changed lines)
-                if found_hunk or line.startswith("@@"):
-                    # Remember that we found a hunk
-                    found_hunk = True
-
-                    if src_path is not None:
-                        source_dict[src_path].append(line)
-
-                    else:
-                        # We tolerate other information before we have
-                        # a source file defined, unless it's a hunk line
-                        if line.startswith("@@"):
-                            msg = f"Hunk has no source file: '{line}'"
-                            raise GitDiffError(msg)
+            # Only add lines if we're in a hunk section
+            # (ignore index and files changed lines)
+            elif found_hunk or line.startswith("@@"):
+                # Remember that we found a hunk
+                found_hunk = True
+
+                if src_path is not None:
+                    source_dict[src_path].append(line)
+
+                # We tolerate other information before we have
+                # a source file defined, unless it's a hunk line
+                elif line.startswith("@@"):
+                    msg = f"Hunk has no source file: '{line}'"
+                    raise GitDiffError(msg)
 
         return source_dict
 

{diff_cover-9.3.2 → diff_cover-9.4.0}/diff_cover/git_diff.py

@@ -65,9 +65,7 @@ class GitDiffTool:
         Raises a `GitDiffError` if `git diff` outputs anything
         to stderr.
         """
-        diff_range = "{branch}{notation}HEAD".format(
-            branch=compare_branch, notation=self.range_notation
-        )
+        diff_range = f"{compare_branch}{self.range_notation}HEAD"
         try:
             return execute(
                 self._default_git_args + self._default_diff_args + [diff_range]

{diff_cover-9.3.2 → diff_cover-9.4.0}/diff_cover/util.py

@@ -1,5 +1,35 @@
+import contextlib
 import os.path
 import posixpath
+import sys
+
+
+@contextlib.contextmanager
+def open_file(path, mode, encoding="utf-8"):
+    """
+    Behaves like open(), but with some special cases for stdout and stderr.
+
+    :param path: string of the path to open
+    :param mode: string of the mode to open the file in
+    :param encoding: encoding to use when opening the file (text mode only)
+    :return: a context manager that yields the file object
+    """
+    output_file = None
+    if path in ("/dev/stdout", "-"):
+        output_file = sys.stdout
+    elif path == "/dev/stderr":
+        output_file = sys.stderr
+
+    if output_file:
+        if "b" in mode:
+            output_file = output_file.buffer
+        yield output_file
+    else:
+        if "b" in mode:
+            encoding = None
+
+        with open(path, mode, encoding=encoding) as f:
+            yield f
 
 
 def to_unix_path(path):

{diff_cover-9.3.2 → diff_cover-9.4.0}/diff_cover/violationsreporters/base.py

@@ -150,27 +150,27 @@ class QualityReporter(BaseViolationReporter):
         """
         if not any(src_path.endswith(ext) for ext in self.driver.supported_extensions):
             return []
+
         if src_path not in self.violations_dict:
             if self.reports:
                 self.violations_dict = self.driver.parse_reports(self.reports)
-            else:
-                if self.driver_tool_installed is None:
-                    self.driver_tool_installed = self.driver.installed()
-                if not self.driver_tool_installed:
-                    raise OSError(f"{self.driver.name} is not installed")
-                command = copy.deepcopy(self.driver.command)
-                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()))
-
-                    output = execute(command, self.driver.exit_codes)
-                    if self.driver.output_stderr:
-                        output = output[1]
-                    else:
-                        output = output[0]
-                    self.violations_dict.update(self.driver.parse_reports([output]))
+                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:
+                msg = f"{self.driver.name} is not installed"
+                raise OSError(msg)
+            command = copy.deepcopy(self.driver.command)
+            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()))
+
+            stdout, stderr = execute(command, self.driver.exit_codes)
+            output = stderr if self.driver.output_stderr else stdout
+            self.violations_dict.update(self.driver.parse_reports([output]))
 
         return self.violations_dict[src_path]
 

{diff_cover-9.3.2 → diff_cover-9.4.0}/diff_cover/violationsreporters/violations_reporter.py

@@ -308,8 +308,15 @@ class LcovCoverageReporter(BaseViolationReporter):
     def parse(lcov_file):
         """
         Parse a single LCov coverage report
-        File format: https://ltp.sourceforge.net/coverage/lcov/geninfo.1.php
+        File format: https://linux.die.net/man/1/geninfo
+        More info: https://github.com/linux-test-project/lcov/issues/113#issuecomment-762335134
         """
+        branch_coverage = defaultdict(
+            lambda: defaultdict(lambda: {"total": 0, "hit": 0, "executions": 0})
+        )
+        function_lines = defaultdict(
+            dict
+        )  # { source_file: { func_name: (line_no, hit_count) } }
         lcov_report = defaultdict(dict)
         lcov = open(lcov_file)
         while True:
@@ -336,22 +343,92 @@ class LcovCoverageReporter(BaseViolationReporter):
                 if line_no not in lcov_report[source_file]:
                     lcov_report[source_file][line_no] = 0
                 lcov_report[source_file][line_no] += num_executions
+            elif directive == "BRDA":
+                args = content.split(",")
+                if len(args) != 4:
+                    raise ValueError(f"Unknown syntax in lcov report: {line}")
+                if source_file is None:
+                    raise ValueError(
+                        f"No source file specified for line coverage: {line}"
+                    )
+                line_no = int(args[0])
+                taken = (
+                    int(args[3]) if args[3] != "-" else 0
+                )  # Handle '-' for untaken branches
+                branch_coverage[source_file][line_no]["total"] += 1
+                branch_coverage[source_file][line_no]["executions"] += taken
+                if taken > 0:
+                    branch_coverage[source_file][line_no]["hit"] += 1
+            elif directive == "FN":
+                args = content.split(",")
+                if len(args) != 2:
+                    raise ValueError(f"Unknown syntax in lcov report: {line}")
+                if source_file is None:
+                    raise ValueError(
+                        f"No source file specified for line coverage: {line}"
+                    )
+                line_no = int(args[0])
+                func_name = args[1]
+                function_lines[source_file][func_name] = (line_no, 0)
+            elif directive == "FNDA":
+                args = content.split(",")
+                if len(args) != 2:
+                    raise ValueError(f"Unknown syntax in lcov report: {line}")
+                if source_file is None:
+                    raise ValueError(
+                        f"No source file specified for line coverage: {line}"
+                    )
+                hit_count = int(args[0])
+                func_name = args[1]
+                if func_name in function_lines[source_file]:
+                    line_no, _ = function_lines[source_file][func_name]
+                    function_lines[source_file][func_name] = (line_no, hit_count)
             elif directive in [
-                "TN",
-                "FNF",
-                "FNH",
-                "FN",
-                "FNDA",
-                "LH",
-                "LF",
-                "BRF",
-                "BRH",
-                "BRDA",
-                "VER",
+                "TN",  # Test name
+                "FNF",  # Functions found
+                "FNH",  # Functions hit
+                "LH",  # Lines hit
+                "LF",  # Lines found
+                "BRF",  # Branches found
+                "BRH",  # Branches hit
+                "VER",  # Version
+                "FNL",  # Function line coverage (alternative format)
+                "FNA",  # Function name (alternative format)
             ]:
-                # these are valid lines, but not we don't need them
+                # Valid directives that we don't need to process
                 continue
             elif directive == "end_of_record":
+                # Process collected coverage data for current source file
+
+                # 1. Apply branch coverage logic
+                for line_no, info in branch_coverage[source_file].items():
+                    has_da_directive = line_no in lcov_report[source_file]
+
+                    if not has_da_directive:
+                        # No line execution data, use branch coverage
+                        if info["total"] > 0 and info["hit"] < info["total"]:
+                            lcov_report[source_file][
+                                line_no
+                            ] = 0  # Partial branch coverage
+                        else:
+                            lcov_report[source_file][line_no] = info["executions"]
+                        continue
+                    if not lcov_report[source_file][line_no]:
+                        # Line shows 0 executions, but check if branches were hit
+                        if info["executions"] > 0:
+                            lcov_report[source_file][line_no] = info["executions"]
+                    # Note: Don't override existing positive execution counts
+
+                # 2. Apply function coverage logic
+                for func_name, (line_no, hit) in function_lines[source_file].items():
+                    if line_no not in lcov_report[source_file]:
+                        # No existing line data, use function hit count
+                        lcov_report[source_file][line_no] = hit
+                    # Note: Don't override existing line execution data
+
+                # 3. Clean up temporary data for current file
+                branch_coverage[source_file].clear()
+                function_lines[source_file].clear()
                 source_file = None
             else:
                 raise ValueError(f"Unknown syntax in lcov report: {line}")
@@ -639,7 +716,7 @@ class PylintDriver(QualityDriver):
                 current_line += 1
                 match = self.multi_line_violation_regex.match(lines[current_line])
                 src_path, l_number = match.groups()
-                src_paths.append(("%s.py" % src_path, l_number))
+                src_paths.append((f"{src_path}.py", l_number))
         return src_paths
 
     def parse_reports(self, reports):
@@ -659,36 +736,32 @@ class PylintDriver(QualityDriver):
 
                 # Ignore any line that isn't matched
                 # (for example, snippets from the source code)
-                if match is not None:
-                    (
-                        pylint_src_path,
-                        line_number,
-                        pylint_code,
-                        function_name,
-                        message,
-                    ) = match.groups()
-                    if pylint_code == self.dupe_code_violation:
-                        files_involved = self._process_dupe_code_violation(
-                            output_lines, output_line_number, message
-                        )
-                    else:
-                        files_involved = [(pylint_src_path, line_number)]
-
-                    for violation in files_involved:
-                        pylint_src_path, line_number = violation
-                        # pylint might uses windows paths
-                        pylint_src_path = util.to_unix_path(pylint_src_path)
-                        # If we're looking for a particular source file,
-                        # ignore any other source files.
-                        if function_name:
-                            error_str = "{}: {}: {}".format(
-                                pylint_code, function_name, message
-                            )
-                        else:
-                            error_str = f"{pylint_code}: {message}"
+                if match is None:
+                    continue
+
+                (
+                    pylint_src_path,
+                    line_number,
+                    pylint_code,
+                    function_name,
+                    message,
+                ) = match.groups()
+                files_involved = [(pylint_src_path, line_number)]
+                if pylint_code == self.dupe_code_violation:
+                    files_involved = self._process_dupe_code_violation(
+                        output_lines, output_line_number, message
+                    )
+
+                for pylint_src_path, line_number in files_involved:
+                    # If we're looking for a particular source file,
+                    # ignore any other source files.
+                    error_str = f"{pylint_code}: {message}"
+                    if function_name:
+                        error_str = f"{pylint_code}: {function_name}: {message}"
 
-                        violation = Violation(int(line_number), error_str)
-                        violations_dict[pylint_src_path].append(violation)
+                    clean_path = util.to_unix_path(pylint_src_path)
+                    violation = Violation(int(line_number), error_str)
+                    violations_dict[clean_path].append(violation)
 
         return violations_dict
 

{diff_cover-9.3.2 → diff_cover-9.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "diff_cover"
-version = "9.3.2"
+version = "9.4.0"
 description = "Run coverage and linting reports on diffs"
 authors = ["See Contributors"]
 homepage = "https://github.com/Bachmann1234/diff-cover"
@@ -53,8 +53,8 @@ pytest-datadir = "^1.5.0"
 pytest-mock = "^3.14.0"
 pytest-xdist = "^3.6.1"
 pycodestyle = ">=2.9.1"
-flake8 = "^5.0.4"
-pyflakes = "^2.5.0"
+flake8 = "^7.2.0"
+pyflakes = "^3.3.2 "
 pylint = "^3.3.4"
 pylint-pytest = "^1.1.8"
 pydocstyle = "^6.1.1"
@@ -99,9 +99,10 @@ show_missing = true
 exclude_also = [
     "if typing.TYPE_CHECKING:",
     "if TYPE_CHECKING:",
+    "if __name__ == \"__main__\":",
     "raise NotImplementedError",
     "raise AssertionError",
-    "pass",
+    "^\\s*pass\\s*$",
 ]
 
 [tool.coverage.html]

diff_cover-9.4.0/tests/fixtures/cpp_functions_console_report.txt

@@ -0,0 +1,10 @@
+-------------
+Diff Coverage
+Diff: origin/main...HEAD, staged and unstaged changes
+-------------
+calculator.cpp (92.3%): Missing lines 12
+-------------
+Total:   13 lines
+Missing: 1 line
+Coverage: 92%
+------------- 

diff_cover-9.4.0/tests/fixtures/cpp_functions_coverage.lcov

@@ -0,0 +1,30 @@
+TN:
+SF:calculator.cpp
+FNL:0,3,4
+FNA:0,1,_ZN10Calculator3addEdd
+FNL:1,7,12
+FNA:1,2,_ZN10Calculator6divideEdd
+FNL:2,14,28
+FNA:2,2,_ZN10Calculator14processNumbersE
+FNF:3
+FNH:3
+DA:3,1
+DA:4,1
+DA:7,2
+DA:8,2
+DA:9,1
+DA:11,1
+DA:12,0
+DA:14,2
+DA:16,2
+DA:17,4
+DA:18,1
+DA:20,2
+DA:21,2
+DA:23,8
+DA:24,6
+DA:27,2
+DA:28,2
+LF:17
+LH:16
+end_of_record 

diff_cover-9.4.0/tests/fixtures/git_diff_cpp.txt

@@ -0,0 +1,50 @@
+diff --git a/calculator.cpp b/calculator.cpp
+new file mode 100644
+index 0000000..1234567
+--- /dev/null
++++ b/calculator.cpp
+@@ -0,0 +1,44 @@
++#include "calculator.h"
++
++double Calculator::add(double a, double b) {
++    return a + b;
++}
++
++double Calculator::divide(double a, double b) {
++    if (b == 0) {
++        throw std::invalid_argument("Division by zero");
++    }
++    return a / b;
++}
++
++std::vector<double> Calculator::processNumbers(const std::vector<double>& numbers,
++                                             std::function<double(double)> processor) {
++    if (!processor) {
++        processor = [](double x) { return x * 2; };
++    }
++
++    std::vector<double> result;
++    result.reserve(numbers.size());
++    
++    for (const auto& num : numbers) {
++        result.push_back(processor(num));
++    }
++    
++    return result;
++}
++
++std::string Calculator::getGrade(double score) {
++    if (score < 0 || score > 100) {
++        throw std::invalid_argument("Invalid score");
++    }
++    
++    if (score >= 90) {
++        return "A";
++    } else if (score >= 80) {
++        return "B";
++    } else if (score >= 70) {
++        return "C";
++    } else {
++        return "F";
++    }
++} 

diff_cover-9.4.0/tests/fixtures/git_diff_cpp_functions.txt

@@ -0,0 +1,28 @@
+diff --git a/calculator.cpp b/calculator.cpp
+new file mode 100644
+index 0000000..abc1234
+--- /dev/null
++++ b/calculator.cpp
+@@ -0,0 +1,28 @@
++#include "calculator.h"
++
++double Calculator::add(double a, double b) {
++    return a + b;
++}
++
++double Calculator::divide(double a, double b) {
++    if (b == 0) {
++        throw std::invalid_argument("Division by zero");
++    }
++    return a / b;
++}
++
++std::vector<double> Calculator::processNumbers(const std::vector<double>& numbers, std::function<double(double)> processor) {
++    std::vector<double> result;
++    
++    for (const auto& num : numbers) {
++        result.push_back(processor(num));
++    }
++    
++    return result;
++} 

diff_cover-9.4.0/tests/fixtures/git_diff_python.txt

@@ -0,0 +1,38 @@
+diff --git a/calculator.py b/calculator.py
+new file mode 100644
+index 0000000..abcdef1
+--- /dev/null
++++ b/calculator.py
+@@ -0,0 +1,32 @@
++from typing import List, Callable
++
++class Calculator:
++    def add(self, a: float, b: float) -> float:
++        """Function coverage example"""
++        return a + b
++
++    def divide(self, a: float, b: float) -> float:
++        """Branch coverage example"""
++        if b == 0:
++            raise ValueError("Division by zero")
++        return a / b
++
++    def process_numbers(self, numbers: List[float], processor: Callable[[float], float] = None) -> List[float]:
++        """Lambda function coverage example"""
++        if processor is None:
++            processor = lambda x: x * 2
++        return list(map(processor, numbers))
++
++    def get_grade(self, score: float) -> str:
++        """Line and branch coverage example"""
++        if score < 0 or score > 100:
++            raise ValueError("Invalid score")
++        
++        if score >= 90:
++            return "A"
++        elif score >= 80:
++            return "B"
++        elif score >= 70:
++            return "C"
++        else:
++            return "F" 

diff_cover-9.4.0/tests/fixtures/git_diff_typescript.txt

@@ -0,0 +1,45 @@
+diff --git a/src/calculator.ts b/src/calculator.ts
+new file mode 100644
+index 0000000..fedcba0
+--- /dev/null
++++ b/src/calculator.ts
+@@ -0,0 +1,40 @@
++export class Calculator {
++  // Function coverage
++  add(a: number, b: number): number {
++    return a + b;
++  }
++
++  // Branch coverage
++  divide(a: number, b: number): number {
++    if (b === 0) {
++      throw new Error("Division by zero");
++    }
++    return a / b;
++  }
++
++  // Anonymous function coverage
++  processNumbers(
++    numbers: number[],
++    processor: (n: number) => number = (n) => n * 2
++  ): number[] {
++    return numbers.map(processor);
++  }
++
++  // Line and branch coverage
++  getGrade(score: number): string {
++    if (score < 0 || score > 100) {
++      throw new Error("Invalid score");
++    }
++
++    if (score >= 90) {
++      return "A";
++    } else if (score >= 80) {
++      return "B";
++    } else if (score >= 70) {
++      return "C";
++    } else {
++      return "F";
++    }
++  }
++}