patch-fixer 0.2.3__py3-none-any.whl → 0.3.1__py3-none-any.whl

patch_fixer/patch_fixer.py

@@ -6,16 +6,16 @@ from pathlib import Path
 
 from git import Repo
 
-path_regex = r'(?:/[A-Za-z0-9_.-]+)*'
+path_regex = r'(?:[A-Za-z0-9_.-]+/?)+'
 regexes = {
-    "DIFF_LINE": re.compile(rf'diff --git (a{path_regex}+) (b{path_regex}+)'),
+    "DIFF_LINE": re.compile(rf'diff --git (a/{path_regex}) (b/{path_regex})'),
     "MODE_LINE": re.compile(r'(new|deleted) file mode [0-7]{6}'),
     "INDEX_LINE": re.compile(r'index [0-9a-f]{7,64}\.\.[0-9a-f]{7,64}(?: [0-7]{6})?|similarity index ([0-9]+)%'),
-    "BINARY_LINE": re.compile(rf'Binary files (a{path_regex}+|/dev/null) and (b{path_regex}+|/dev/null) differ'),
+    "BINARY_LINE": re.compile(rf'Binary files (a/{path_regex}|/dev/null) and (b/{path_regex}|/dev/null) differ'),
     "RENAME_FROM": re.compile(rf'rename from ({path_regex})'),
     "RENAME_TO": re.compile(rf'rename to ({path_regex})'),
-    "FILE_HEADER_START": re.compile(rf'--- (a{path_regex}+|/dev/null)'),
-    "FILE_HEADER_END": re.compile(rf'\+\+\+ (b{path_regex}+|/dev/null)'),
+    "FILE_HEADER_START": re.compile(rf'--- (a/{path_regex}|/dev/null)'),
+    "FILE_HEADER_END": re.compile(rf'\+\+\+ (b/{path_regex}|/dev/null)'),
     "HUNK_HEADER": re.compile(r'^@@ -(\d+),(\d+) \+(\d+),(\d+) @@(.*)$'),
     "END_LINE": re.compile(r'\')
 }
@@ -25,13 +25,41 @@ class MissingHunkError(Exception):
     pass
 
 
+class BadCarriageReturn(ValueError):
+    pass
+
+
 def normalize_line(line):
-    if line.startswith('+'):
-        # safe to normalize new content
-        return '+' + line[1:].rstrip() + "\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:
-        # preserve exactly (only normalize line endings)
-        return line.rstrip("\r\n") + "\n"
+        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):
     """Search original_lines for context_lines and return start line index (0-based)."""
@@ -40,7 +68,8 @@ def find_hunk_start(context_lines, original_lines):
         if line.startswith(" "):
             ctx.append(line.lstrip(" "))
         elif line.startswith("-"):
-            ctx.append(line.lstrip("-"))
+            # can't use lstrip; we want to keep other dashes in the line
+            ctx.append(line[1:])
         elif line.isspace() or line == "":
             ctx.append(line)
     if not ctx:
@@ -75,9 +104,9 @@ def reconstruct_file_header(diff_line, header_type):
     a, b = diff_groups
     match header_type:
         case "FILE_HEADER_START":
-            return f"--- {a}"
+            return f"--- {a}\n"
         case "FILE_HEADER_END":
-            return f"+++ {b}"
+            return f"+++ {b}\n"
         case _:
             raise ValueError(f"Unsupported header type: {header_type}")
 
@@ -87,14 +116,24 @@ def capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context):
     old_count = sum(1 for l in current_hunk if l.startswith((' ', '-')))
     new_count = sum(1 for l in current_hunk if l.startswith((' ', '+')))
 
-    # compute starting line in original file
-    old_start = find_hunk_start(current_hunk, original_lines) + 1
-
-    # if the line number descends, we either have a bad match or a new file
-    if old_start < last_hunk:
-        raise MissingHunkError
+    if old_count > 0:
+        # compute starting line in original file
+        old_start = find_hunk_start(current_hunk, original_lines) + 1
+
+        # if the line number descends, we either have a bad match or a new file
+        if old_start < last_hunk:
+            raise MissingHunkError
+        else:
+            if new_count == 0:
+                # complete deletion of remaining content
+                new_start = 0
+            else:
+                new_start = old_start + offset
     else:
-        new_start = old_start + offset
+        # old count of zero can only mean file creation, since adding lines to
+        # an existing file requires surrounding context lines without a +
+        old_start = 0
+        new_start = 1   # line numbers are 1-indexed in the real world
 
     offset += (new_count - old_count)
 
@@ -122,10 +161,10 @@ def regenerate_index(old_path, new_path, cur_dir):
             "as this would require manually applying the patch first."
         )
 
-    return f"index {old_sha}..{new_sha}{mode}"
+    return f"index {old_sha}..{new_sha}{mode}\n"
 
 
-def fix_patch(patch_lines, original):
+def fix_patch(patch_lines, original, remove_binary=False):
     dir_mode = os.path.isdir(original)
     original_path = Path(original).absolute()
 
@@ -146,7 +185,10 @@ def fix_patch(patch_lines, original):
     look_for_rename = False
     similarity_index = None
     missing_index = False
+    binary_file = False
     hunk_context = ""
+    original_lines = []
+    file_loaded = False
 
     for i, line in enumerate(patch_lines):
         match_groups, line_type = match_line(line)
@@ -168,12 +210,14 @@ def fix_patch(patch_lines, original):
                     current_hunk = []
                 a, b = split_ab(match_groups)
                 if a != b:
-                    raise ValueError(f"Diff paths do not match: \n{a}\n{b}")
+                    look_for_rename = True
                 fixed_lines.append(normalize_line(line))
                 last_diff = i
                 file_start_header = False
                 file_end_header = False
                 first_hunk = True
+                binary_file = False
+                file_loaded = False
             case "MODE_LINE":
                 if last_diff != i - 1:
                     raise NotImplementedError("Missing diff line not yet supported")
@@ -188,14 +232,18 @@ def fix_patch(patch_lines, original):
                 fixed_lines.append(normalize_line(line))
                 missing_index = False
             case "BINARY_LINE":
-                raise NotImplementedError("Binary files not supported yet")
+                if remove_binary:
+                    raise NotImplementedError("Ignoring binary files not yet supported")
+                binary_file = True
+                fixed_lines.append(normalize_line(line))
             case "RENAME_FROM":
                 if not look_for_rename:
                     pass    # TODO: handle missing index line
+                if binary_file:
+                    raise NotImplementedError("Renaming binary files not yet supported")
                 if last_index != i - 1:
                     missing_index = True    # need this for existence check in RENAME_TO block
-                    similarity_index = 100  # TODO: is this a dangerous assumption?
-                    fixed_index = "similarity index 100%"
+                    fixed_index = "similarity index 100%\n"
                     fixed_lines.append(normalize_line(fixed_index))
                     last_index = i - 1
                 look_for_rename = False
@@ -204,16 +252,18 @@ def fix_patch(patch_lines, original):
                 offset = 0
                 last_hunk = 0
                 if not Path.exists(current_path):
-                    if similarity_index == 100:
-                        fixed_lines.append(normalize_line(line))
-                        look_for_rename = True
-                        continue
-                    raise NotImplementedError("Parsing files that were both renamed and modified is not yet supported.")
+                    # TODO: verify whether this block is necessary at all
+                    fixed_lines.append(normalize_line(line))
+                    look_for_rename = True
+                    file_loaded = False
+                    continue
+                if not current_path.is_file():
+                    raise IsADirectoryError(f"Rename from header points to a directory, not a file: {current_file}")
                 if dir_mode or current_path == original_path:
                     with open(current_path, encoding='utf-8') as f:
                         original_lines = [l.rstrip('\n') for l in f.readlines()]
                     fixed_lines.append(normalize_line(line))
-                    # TODO: analogous boolean to `file_start_header`?
+                    file_loaded = True
                 else:
                     raise FileNotFoundError(f"Filename {current_file} in `rename from` header does not match argument {original}")
             case "RENAME_TO":
@@ -223,18 +273,20 @@ def fix_patch(patch_lines, original):
                         last_index = i - 2
                     else:
                         raise NotImplementedError("Missing `rename from` header not yet supported.")
-                if look_for_rename:
-                    # the old file doesn't exist, so we need to read this one
-                    current_file = match_groups[0]
-                    current_path = Path(current_file).absolute()
-                    with open(current_path, encoding='utf-8') as f:
-                        original_lines = [l.rstrip('\n') for l in f.readlines()]
-                    fixed_lines.append(normalize_line(line))
-                    look_for_rename = False
-                pass
+                # TODO: do something sensible if `look_for_rename` is false
+                current_file = match_groups[0]
+                current_path = Path(current_file).absolute()
+                if current_file and current_path.is_dir():
+                    raise IsADirectoryError(f"rename to points to a directory, not a file: {current_file}")
+                fixed_lines.append(normalize_line(line))
+                look_for_rename = False
             case "FILE_HEADER_START":
                 if look_for_rename:
                     raise NotImplementedError("Replacing file header with rename not yet supported.")
+                if binary_file:
+                    raise NotImplementedError("A header block with both 'binary files differ' and "
+                                              "file start/end headers is a confusing state"
+                                              "\nfrom which there is no obvious way to recover.")
                 if last_index != i - 1:
                     missing_index = True
                     last_index = i - 1
@@ -242,13 +294,15 @@ def fix_patch(patch_lines, original):
                 if current_file and not dir_mode:
                     raise ValueError("Diff references multiple files but only one provided.")
                 current_file = match_groups[0]
-                offset = 0
-                last_hunk = 0
+                if not file_loaded:
+                    offset = 0
+                    last_hunk = 0
                 if current_file == "/dev/null":
                     if last_diff > last_mode:
                         raise NotImplementedError("Missing mode line not yet supported")
                     fixed_lines.append(normalize_line(line))
                     file_start_header = True
+                    file_loaded = False
                     continue
                 if current_file.startswith("a/"):
                     current_file = current_file[2:]
@@ -257,16 +311,24 @@ def fix_patch(patch_lines, original):
                 current_path = Path(current_file).absolute()
                 if not current_path.exists():
                     raise FileNotFoundError(f"File header start points to non-existent file: {current_file}")
-                if dir_mode or Path(current_file) == Path(original):
-                    with open(current_file, encoding='utf-8') as f:
-                        original_lines = [l.rstrip('\n') for l in f.readlines()]
-                    fixed_lines.append(normalize_line(line))
-                    file_start_header = True
-                else:
-                    raise FileNotFoundError(f"Filename {current_file} in header does not match argument {original}")
+                if not current_path.is_file():
+                    raise IsADirectoryError(f"File header start points to a directory, not a file: {current_file}")
+                if not file_loaded:
+                    if dir_mode or Path(current_file) == Path(original):
+                        with open(current_file, encoding='utf-8') as f:
+                            original_lines = [l.rstrip('\n') for l in f.readlines()]
+                        file_loaded = True
+                    else:
+                        raise FileNotFoundError(f"Filename {current_file} in header does not match argument {original}")
+                fixed_lines.append(normalize_line(line))
+                file_start_header = True
             case "FILE_HEADER_END":
                 if look_for_rename:
                     raise NotImplementedError("Replacing file header with rename not yet supported.")
+                if binary_file:
+                    raise NotImplementedError("A header block with both 'binary files differ' and "
+                                              "file start/end headers is a confusing state"
+                                              "\nfrom which there is no obvious way to recover.")
                 dest_file = match_groups[0]
                 dest_path = Path(dest_file).absolute()
                 if dest_file.startswith("b/"):
@@ -286,37 +348,47 @@ def fix_patch(patch_lines, original):
                     else:
                         # reconstruct file start header based on end header
                         a = match_groups[0].replace("b", "a")
-                        fixed_lines.append(normalize_line(f"--- {a}"))
+                        fixed_lines.append(normalize_line(f"--- {a}\n"))
                     file_start_header = True
                 elif current_file == "/dev/null":
                     if dest_file == "/dev/null":
                         raise ValueError("File headers cannot both be /dev/null")
-                    elif not dest_path.exists():
-                        raise FileNotFoundError(f"File header end points to non-existent file: {dest_file}")
+                    elif dest_path.exists():
+                        raise FileExistsError(f"File header start /dev/null implies file creation, "
+                                              f"but file header end would overwrite existing file: {dest_file}")
                     current_file = dest_file
                     current_path = Path(current_file).absolute()
                     if dir_mode or current_path == original_path:
-                        # TODO: in dir mode, verify that current file exists in original path
-                        with open(current_path, encoding='utf-8') as f:
-                            original_lines = [l.rstrip('\n') for l in f.readlines()]
+                        original_lines = []
                         fixed_lines.append(normalize_line(line))
                         file_end_header = True
                     else:
                         raise FileNotFoundError(f"Filename {current_file} in header does not match argument {original}")
                 elif dest_file == "/dev/null":
-                    # TODO: check if other modes are possible
-                    if last_mode < last_diff:
-                        last_mode = last_diff + 1
-                        fixed_lines.insert(last_mode, "deleted file mode 100644")
-                        last_index += 1     # index comes after mode
+                    current_path = Path(current_file).absolute()
+                    if not current_path.exists():
+                        raise FileNotFoundError(f"The file being 'deleted' does not exist: {current_file}")
+                    if last_mode <= last_diff:
+                        fixed_lines.insert(last_diff + 1, "deleted file mode 100644\n")
+                        last_index += 1
                     elif "deleted" not in fixed_lines[last_mode]:
-                        fixed_lines[last_mode] = "deleted file mode 100644"
-                    else:
-                        fixed_lines.append("deleted file mode 100644")
+                        fixed_lines[last_mode] = "deleted file mode 100644\n"
+                    fixed_lines.append(normalize_line(line))
+                    file_end_header = True
                 elif current_file != dest_file:
-                    raise ValueError(f"File headers do not match: \n{current_file}\n{dest_file}")
-                pass
+                    # this is a rename, original_lines is already set from FILE_HEADER_START
+                    fixed_lines.append(normalize_line(line))
+                    file_end_header = True
+                    first_hunk = True
+                else:
+                    fixed_lines.append(normalize_line(line))
+                    file_end_header = True
             case "HUNK_HEADER":
+                if binary_file:
+                    raise ValueError("Binary file can't have a hunk header.")
+                if look_for_rename:
+                    raise ValueError(f"Rename header expected but not found.\n"
+                                     f"Hint: look at lines {last_diff}-{i} of the input patch.")
                 # fix missing file headers before capturing the hunk
                 if not file_end_header:
                     diff_line = patch_lines[last_diff]
@@ -370,7 +442,7 @@ def fix_patch(patch_lines, original):
     fixed_lines.extend(current_hunk)
 
     # if original file didn't end with a newline, strip out the newline here
-    if not original_lines[-1].endswith("\n"):
+    if original_lines and not original_lines[-1].endswith("\n"):
         fixed_lines[-1] = fixed_lines[-1].rstrip("\n")
 
     return fixed_lines
@@ -395,6 +467,7 @@ def main():
 
     print(f"Fixed patch written to {output_file}")
 
+
 if __name__ == "__main__":
     main()
 

{patch_fixer-0.2.3.dist-info → patch_fixer-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patch-fixer
-Version: 0.2.3
+Version: 0.3.1
 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
@@ -69,8 +70,9 @@ cd patch-fixer
 pip install -e .[test]
 pytest
 ```
-Note that some test failures are expected as this project is in the early alpha stage.
-Please only report test failures if the same test passed in a previous version.
+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 existed and passed in the most recent `0.x.0` version.
 
 ## License
 

patch_fixer-0.3.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+patch_fixer/__init__.py,sha256=bSp2H7JW2kz1WrT0dqlg64kZpklKPp1FZlDhq2XJ2uU,34
+patch_fixer/patch_fixer.py,sha256=1Ny2NwVL4qStbVCrv6QE3b_8oPsFkPomJDLoAGUqNvI,20587
+patch_fixer-0.3.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+patch_fixer-0.3.1.dist-info/METADATA,sha256=iOhEx8d5WJV3X-mMu-0hAjQWXD-gBEPWKkiE-HnNyso,2828
+patch_fixer-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+patch_fixer-0.3.1.dist-info/top_level.txt,sha256=yyp3KjFgExJsrFsS9ZBCnkhb05xg8hPYhB7ncdpTOv0,12
+patch_fixer-0.3.1.dist-info/RECORD,,

patch_fixer-0.2.3.dist-info/RECORD

@@ -1,7 +0,0 @@
-patch_fixer/__init__.py,sha256=bSp2H7JW2kz1WrT0dqlg64kZpklKPp1FZlDhq2XJ2uU,34
-patch_fixer/patch_fixer.py,sha256=zZ48yd9eVfCFiUzJ31wVpcEOBH2Nq711kC2c71q-YzM,17463
-patch_fixer-0.2.3.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-patch_fixer-0.2.3.dist-info/METADATA,sha256=iAC5PmTsdyuTXnWPSvCjPVTD3nrEafqCyE8PrMxvuKs,2667
-patch_fixer-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-patch_fixer-0.2.3.dist-info/top_level.txt,sha256=yyp3KjFgExJsrFsS9ZBCnkhb05xg8hPYhB7ncdpTOv0,12
-patch_fixer-0.2.3.dist-info/RECORD,,