Ruff implementation

.git-blame-ignore-revs

@@ -1,2 +1,7 @@
 # Migrate code style to Black
 e1db83a447700237a96be7a9db4413fe5024d328
+# Migrate code style to Ruff
+# ########################################################################
+# TODO: IMPORTANT replace this with the real commit once it's merged
+# ########################################################################
+d1cbd0bbfd80e19f7ab6231251389fadfd4b9b22

diff_cover/__init__.py

@@ -1,5 +1,6 @@
 from importlib.metadata import version
 
+
 VERSION = version("diff_cover")
 DESCRIPTION = "Automatically find diff lines that need test coverage."
 QUALITY_DESCRIPTION = "Automatically find diff lines with quality violations."

diff_cover/command_runner.py

@@ -57,8 +57,10 @@ def _ensure_unicode(text):
     Ensures the text passed in becomes unicode
     Args:
         text (str|unicode)
+
     Returns:
         unicode
+
     """
     if isinstance(text, bytes):
         return text.decode(sys.getfilesystemencoding(), "replace")

diff_cover/config_parser.py

@@ -1,6 +1,7 @@
 import abc
 import enum
 
+
 try:
     import tomli as toml
 

diff_cover/diff_cover_tool.py

@@ -21,6 +21,7 @@
     XmlCoverageReporter,
 )
 
+
 HTML_REPORT_HELP = "Diff coverage HTML output"
 JSON_REPORT_HELP = "Diff coverage JSON output"
 MARKDOWN_REPORT_HELP = "Diff coverage Markdown output"
@@ -240,9 +241,10 @@ 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:
+        msg = "Mixing LCov and XML reports is not supported yet"
+        raise ValueError(msg)
+    if xml_roots:
         coverage = XmlCoverageReporter(xml_roots, src_roots, expand_coverage_report)
     else:
         coverage = LcovCoverageReporter(lcov_roots, src_roots)

diff_cover/diff_quality_tool.py

@@ -58,6 +58,7 @@
     shellcheck_driver,
 )
 
+
 QUALITY_DRIVERS = {
     "cppcheck": CppcheckDriver(),
     "pycodestyle": pycodestyle_driver,
@@ -292,7 +293,6 @@ def main(argv=None, directory=None):
     1 is an error
     0 is successful run
     """
-
     argv = argv or sys.argv
     arg_dict = parse_quality_args(argv[1:])
 

diff_cover/diff_reporter.py

@@ -162,7 +162,6 @@ def src_paths_changed(self):
         """
         See base class docstring.
         """
-
         # Get the diff dictionary
         diff_dict = self._git_diff()
         # include untracked files
@@ -183,7 +182,6 @@ 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())
@@ -194,7 +192,6 @@ def lines_changed(self, src_path):
         """
         See base class docstring.
         """
-
         # Get the diff dictionary (cached)
         diff_dict = self._git_diff()
 
@@ -227,7 +224,6 @@ def _git_diff(self):
 
         Raises a GitDiffError if `git diff` has an error.
         """
-
         # If we do not have a cached result, execute `git diff`
         if self._diff_dict is None:
             result_dict = {}
@@ -268,7 +264,6 @@ def _validate_path_to_diff(self, src_path: str) -> bool:
         - If the path is excluded
         - If the path has an extension that is not supported
         """
-
         if self._is_path_excluded(src_path):
             return False
 
@@ -297,7 +292,6 @@ def _parse_diff_str(self, diff_str):
 
         If the output could not be parsed, raises a GitDiffError.
         """
-
         # Create a dict to hold results
         diff_dict = {}
 
@@ -320,7 +314,6 @@ def _parse_source_sections(self, diff_str):
 
         Raises a `GitDiffError` if `diff_str` is in an invalid format.
         """
-
         # Create a dict to map source files to lines in the diff output
         source_dict = {}
 
@@ -349,22 +342,20 @@ def _parse_source_sections(self, diff_str):
 
             # 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
 
@@ -378,7 +369,6 @@ def _parse_lines(self, diff_lines):
 
         Raises a `GitDiffError` if the diff lines are in an invalid format.
         """
-
         added_lines = []
         deleted_lines = []
 
@@ -502,7 +492,6 @@ def _unique_ordered_lines(line_numbers):
         Given a list of line numbers, return a list in which each line
         number is included once and the lines are ordered sequentially.
         """
-
         if len(line_numbers) == 0:
             return []
 

diff_cover/git_diff.py

@@ -65,9 +65,7 @@ def diff_committed(self, compare_branch="origin/main"):
         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]
@@ -112,18 +110,11 @@ def untracked(self):
             return self._untracked_cache
 
         output = execute(["git", "ls-files", "--exclude-standard", "--others"])[0]
-        self._untracked_cache = []
-        if output:
-            self._untracked_cache = [
-                to_unescaped_filename(line) for line in output.splitlines() if line
-            ]
-        return self._untracked_cache
+        return [to_unescaped_filename(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)
 
@@ -134,7 +125,7 @@ def diff_committed(self, compare_branch="origin/main"):
         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) as file:
                 return file.read()
         except OSError as e:
             error_message = (

diff_cover/hook.py

@@ -1,4 +1,5 @@
 import pluggy
 
+
 # Other packages that implement diff_cover plugins use this.
 hookimpl = pluggy.HookimplMarker("diff_cover")

diff_cover/hookspecs.py

@@ -1,5 +1,6 @@
 import pluggy
 
+
 hookspec = pluggy.HookspecMarker("diff_cover")
 
 

diff_cover/report_generator.py

@@ -134,7 +134,6 @@ def violation_lines(self, src_path):
         If we have no coverage information for
         `src_path`, returns an empty list.
         """
-
         diff_violations = self._diff_violations().get(src_path)
 
         if diff_violations is None:
@@ -147,7 +146,6 @@ def total_num_lines(self):
         Return the total number of lines in the diff for
         which we have coverage info.
         """
-
         return sum(
             [
                 len(summary.measured_lines)
@@ -160,7 +158,6 @@ def total_num_violations(self):
         Returns the total number of lines in the diff
         that are in violation.
         """
-
         return sum(len(summary.lines) for summary in self._diff_violations().values())
 
     def total_percent_covered(self):
@@ -233,7 +230,6 @@ def _src_path_stats(self, src_path):
         """
         Return a dict of statistics for the source file at `src_path`.
         """
-
         covered_lines = self.covered_lines(src_path)
 
         # Find violation lines
@@ -296,7 +292,6 @@ def generate_report(self, output_file):
         See base class.
         output_file must be a file handler that takes in bytes!
         """
-
         if self.template_path is not None:
             template = TEMPLATE_ENV.get_template(self.template_path)
             report = template.render(self._context())
@@ -340,7 +335,6 @@ def _context(self):
             'total_percent_covered': TOTAL_PERCENT_COVERED
         }
         """
-
         # Include snippet style info if we're displaying
         # source code snippets
         if self.include_snippets:

diff_cover/snippets.py

@@ -78,7 +78,8 @@ def __init__(
         Raises a `ValueError` if `start_line` is less than 1
         """
         if start_line < 1:
-            raise ValueError("Start line must be >= 1")
+            msg = "Start line must be >= 1"
+            raise ValueError(msg)
 
         self._src_tokens = src_tokens
         self._src_filename = src_filename
@@ -116,7 +117,6 @@ def markdown(self):
         Return a Markdown representation of the snippet using Markdown fenced code blocks.
         See https://github.github.com/gfm/#fenced-code-blocks.
         """
-
         line_number_length = len(str(self._last_line))
 
         text = ""
@@ -188,7 +188,6 @@ def load_formatted_snippets(cls, src_path, violation_lines):
 
         See `load_snippets()` for details.
         """
-
         # load once...
         snippet_list = cls.load_snippets(src_path, violation_lines)
 
@@ -266,7 +265,6 @@ def _parse_src(cls, src_contents, src_filename):
         Uses `src_filename` to guess the type of file
         so it can highlight syntax correctly.
         """
-
         # Parse the source into tokens
         try:
             lexer = guess_lexer_for_filename(src_filename, src_contents)
@@ -302,7 +300,6 @@ def _group_tokens(cls, token_stream, range_list):
         The algorithm is slightly complicated because a single token
         can contain multiple line breaks.
         """
-
         # Create a map from ranges (start/end tuples) to tokens
         token_map = {rng: [] for rng in range_list}