patch-fixer 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

patch_fixer/__init__.py

@@ -1 +1,2 @@
-from .patch_fixer import fix_patch
+from .patch_fixer import fix_patch
+from .split import split_patch

patch_fixer/patch_fixer.py

@@ -25,9 +25,40 @@ class MissingHunkError(Exception):
     pass
 
 
+class BadCarriageReturn(ValueError):
+    pass
+
+
 def normalize_line(line):
-    # preserve whitespace, only normalize line endings
-    return line.rstrip("\r\n") + "\n"
+    """Normalize line endings while preserving whitespace."""
+    if not isinstance(line, str):
+        raise TypeError(f"Cannot normalize non-string object {line}")
+
+    # edge case: empty string
+    if line == "":
+        return "\n"
+
+    # special malformed ending: ...\n\r
+    if line.endswith("\n\r"):
+        raise BadCarriageReturn(f"carriage return after line feed: {line}")
+
+    # handle CRLF and simple CR/LF endings
+    if line.endswith("\r\n"):
+        core = line[:-2]
+    elif line.endswith("\r"):
+        core = line[:-1]
+    elif line.endswith("\n"):
+        core = line[:-1]
+    else:
+        core = line
+
+    # check for interior CR/LF (anything before the final terminator)
+    if "\n" in core:
+        raise ValueError(f"line feed in middle of line: {line}")
+    if "\r" in core:
+        raise BadCarriageReturn(f"carriage return in middle of line: {line}")
+
+    return core + "\n"
 
 
 def find_hunk_start(context_lines, original_lines):
@@ -173,7 +204,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
                         ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context)
                     except MissingHunkError:
                         raise NotImplementedError(f"Could not find hunk in {current_file}:"
-                                                  f"\n\n{"".join(current_hunk)}")
+                                                  f"\n\n{''.join(current_hunk)}")
                     fixed_lines.append(fixed_header)
                     fixed_lines.extend(current_hunk)
                     current_hunk = []
@@ -384,7 +415,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
                     ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context)
                 except MissingHunkError:
                     raise NotImplementedError(f"Could not find hunk in {current_file}:"
-                                              f"\n\n{"".join(current_hunk)}")
+                                              f"\n\n{''.join(current_hunk)}")
                 fixed_lines.append(fixed_header)
                 fixed_lines.extend(current_hunk)
                 current_hunk = []
@@ -406,7 +437,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
         ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context)
     except MissingHunkError:
         raise NotImplementedError(f"Could not find hunk in {current_file}:"
-                                  f"\n\n{"".join(current_hunk)}")
+                                  f"\n\n{''.join(current_hunk)}")
     fixed_lines.append(fixed_header)
     fixed_lines.extend(current_hunk)
 

patch_fixer/split.py

@@ -0,0 +1,119 @@
+"""
+Idea:
+
+1. main function takes in:
+    a. patch file
+    b. list of files to split out
+2. reads patch file, splits based on file headers (assumed to be valid)
+3. for each file being patched:
+    a. if the file is in the list, send its hunks to output 1
+    b. otherwise send its hunks to output 2
+    c. hunks include all header lines so each output is a valid diff
+
+Could share some functionality with refactored, modular version of fix_patch
+"""
+
+import re
+from typing import List, Tuple
+
+from .patch_fixer import match_line, normalize_line, split_ab
+
+
+def get_file_path_from_diff(line: str) -> str:
+    """Extract the file path from a diff line."""
+    match_groups, line_type = match_line(line)
+    if line_type != "DIFF_LINE":
+        raise ValueError(f"Expected DIFF_LINE but got {line_type}")
+
+    # get the 'a' path (source file)
+    a_path, _ = split_ab(match_groups)
+    return a_path
+
+
+def split_patch(patch_lines: List[str], files_to_include: List[str]) -> Tuple[List[str], List[str]]:
+    """
+    Split a patch into two parts based on a list of files to include.
+
+    Parameters
+    ----------
+    patch_lines : List[str]
+        Lines of the patch file to split.
+    files_to_include : List[str]
+        List of file paths (relative, starting with ./) to include in the first output.
+        Files not in this list go to the second output.
+
+    Returns
+    -------
+    included_lines : List[str]
+        Lines for the patch containing only the included files.
+    excluded_lines : List[str]
+        Lines for the patch containing all other files.
+
+    Notes
+    -----
+    The function preserves all header information for each file's hunks
+    to ensure both output patches are valid. File paths are normalized
+    to start with './' for comparison purposes.
+
+    Raises
+    ------
+    ValueError
+        If the patch format is invalid or cannot be parsed.
+    """
+    if not patch_lines:
+        raise ValueError("Empty patch provided")
+
+    # normalize file paths to include
+    normalized_include = set()
+    for path in files_to_include:
+        if not path.startswith("./"):
+            path = f"./{path}"
+        normalized_include.add(path)
+
+    included_lines = []
+    excluded_lines = []
+    current_file_lines = []
+    current_file_path = None
+    in_file_block = False
+
+    for line in patch_lines:
+        match_groups, line_type = match_line(line)
+
+        if line_type == "DIFF_LINE":
+            # start of a new file block
+            if in_file_block and current_file_lines:
+                # output the previous file block
+                if current_file_path in normalized_include:
+                    included_lines.extend(current_file_lines)
+                else:
+                    excluded_lines.extend(current_file_lines)
+
+            # start collecting new file block
+            current_file_lines = [normalize_line(line)]
+            current_file_path = get_file_path_from_diff(line)
+            in_file_block = True
+
+        elif in_file_block:
+            # continue collecting lines for current file
+            current_file_lines.append(normalize_line(line))
+
+        else:
+            # lines before any diff (shouldn't happen in well-formed patches)
+            # add to both outputs to preserve any global headers
+            normalized = normalize_line(line)
+            included_lines.append(normalized)
+            excluded_lines.append(normalized)
+
+    # don't forget the last file block
+    if in_file_block and current_file_lines:
+        if current_file_path in normalized_include:
+            included_lines.extend(current_file_lines)
+        else:
+            excluded_lines.extend(current_file_lines)
+
+    # handle edge case where no files were split (no diff lines)
+    if not in_file_block:
+        # patch had no diff lines at all
+        return patch_lines, []
+
+    return included_lines, excluded_lines

{patch_fixer-0.3.0.dist-info → patch_fixer-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patch-fixer
-Version: 0.3.0
+Version: 0.3.2
 Summary: Fixes erroneous git apply patches to the best of its ability.
 Maintainer-email: Alex Mueller <amueller474@gmail.com>
 License-Expression: Apache-2.0
@@ -22,6 +22,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: GitPython
 Provides-Extra: test
+Requires-Dist: hypothesis; extra == "test"
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: requests; extra == "test"
 Dynamic: license-file
@@ -71,7 +72,7 @@ pytest
 ```
 From version `0.3.0` onward (at least until version `1.0`), some test failures are expected
 in bugfix versions as I like to use test-driven development to build out new features. 
-Please only report test failures if the same test passed in the most recent `0.x.0` version.
+Please only report test failures if the same test existed and passed in the most recent `0.x.0` version.
 
 ## License
 

patch_fixer-0.3.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+patch_fixer/__init__.py,sha256=n5DDMr4jbO3epK3ybBvjDyRddTWlWamN6ao5BC7xHFo,65
+patch_fixer/patch_fixer.py,sha256=GAavb15H5cEoNFgGlO5hIY7EOF88VCsjHcLrfyGW4_0,20587
+patch_fixer/split.py,sha256=l0rHM6-ZBuB9Iv6Ng6rxqZH5eKfvk2t87j__nDu67kM,3869
+patch_fixer-0.3.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+patch_fixer-0.3.2.dist-info/METADATA,sha256=DWi_Bf1beGb5Q0RyGxyDRlmb9RYjCuUhYcvJF0TisY0,2828
+patch_fixer-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+patch_fixer-0.3.2.dist-info/top_level.txt,sha256=yyp3KjFgExJsrFsS9ZBCnkhb05xg8hPYhB7ncdpTOv0,12
+patch_fixer-0.3.2.dist-info/RECORD,,

patch_fixer-0.3.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-patch_fixer/__init__.py,sha256=bSp2H7JW2kz1WrT0dqlg64kZpklKPp1FZlDhq2XJ2uU,34
-patch_fixer/patch_fixer.py,sha256=GIXSlWWbHy9gvZ61mOyxZ9oSqyIeR1rTKJDQGdZ-IYc,19730
-patch_fixer-0.3.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-patch_fixer-0.3.0.dist-info/METADATA,sha256=tR6BAvwh8PvNyKouq0p1CN0aEsasymao-_9hkZCglP0,2773
-patch_fixer-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-patch_fixer-0.3.0.dist-info/top_level.txt,sha256=yyp3KjFgExJsrFsS9ZBCnkhb05xg8hPYhB7ncdpTOv0,12
-patch_fixer-0.3.0.dist-info/RECORD,,