WIP

Author: spoorcc

dfetch.code-workspace

@@ -63,7 +63,7 @@
 				"module": "dfetch.__main__",
 				"justMyCode": false,
 				"args": [
-					"update"
+					"updatepatch", "sphinxcontrib.asciinema"
 				]
 			}
 		]

dfetch/__main__.py

@@ -15,6 +15,7 @@
 import dfetch.commands.init
 import dfetch.commands.report
 import dfetch.commands.update
+import dfetch.commands.update_patch
 import dfetch.commands.validate
 import dfetch.log
 import dfetch.util.cmdline
@@ -45,6 +46,7 @@ def create_parser() -> argparse.ArgumentParser:
     dfetch.commands.init.Init.create_menu(subparsers)
     dfetch.commands.report.Report.create_menu(subparsers)
     dfetch.commands.update.Update.create_menu(subparsers)
+    dfetch.commands.update_patch.UpdatePatch.create_menu(subparsers)
     dfetch.commands.validate.Validate.create_menu(subparsers)
 
     return parser

dfetch/commands/update_patch.py

@@ -0,0 +1,58 @@
+"""Update is the main functionality of dfetch.
+
+You can add Projects to your :ref:`Manifest` and update will fetch the version specified.
+It tries to determine what kind of vcs it is: git, svn or something else.
+
+"""
+
+import argparse
+import os
+from pathlib import Path
+
+import dfetch.commands.command
+import dfetch.manifest.project
+import dfetch.project
+from dfetch.commands.common import check_child_manifests
+from dfetch.log import get_logger
+from dfetch.project.superproject import SuperProject
+from dfetch.util.util import catch_runtime_exceptions, in_directory
+
+logger = get_logger(__name__)
+
+
+class UpdatePatch(dfetch.commands.command.Command):
+    """Update a patch to reflect the last changes.
+
+    Some stuff
+    """
+
+    @staticmethod
+    def create_menu(subparsers: dfetch.commands.command.SubparserActionType) -> None:
+        """Add the menu for the update-patch action."""
+        parser = dfetch.commands.command.Command.parser(subparsers, UpdatePatch)
+        parser.add_argument(
+            "projects",
+            metavar="<project>",
+            type=str,
+            nargs="*",
+            help="Specific project(s) to update",
+        )
+
+    def __call__(self, args: argparse.Namespace) -> None:
+        """Perform the update patch."""
+        superproject = SuperProject()
+
+        exceptions: list[str] = []
+        destinations: list[str] = [
+            os.path.realpath(project.destination)
+            for project in superproject.manifest.projects
+        ]
+        with in_directory(superproject.root_directory):
+            for project in superproject.manifest.selected_projects(args.projects):
+                with catch_runtime_exceptions(exceptions) as exceptions:
+                    dfetch.project.make(project).update_patch(
+                        files_to_ignore=superproject.ignored_files(project.destination),
+                    )
+
+        if exceptions:
+            raise RuntimeError("\n".join(exceptions))

dfetch/project/git.py

@@ -52,11 +52,15 @@ def current_revision(self) -> str:
         return str(self._local_repo.get_current_hash())
 
     def _diff_impl(
-        self, old_revision: str, new_revision: Optional[str], ignore: Sequence[str]
+        self,
+        old_revision: str,
+        new_revision: Optional[str],
+        ignore: Sequence[str],
+        reverse: bool = False,
     ) -> str:
         """Get the diff of two revisions."""
         diff_since_revision = str(
-            self._local_repo.create_diff(old_revision, new_revision, ignore)
+            self._local_repo.create_diff(old_revision, new_revision, ignore, reverse)
         )
 
         if new_revision:

dfetch/project/subproject.py

@@ -3,6 +3,7 @@
 import fnmatch
 import os
 import pathlib
+import shutil
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from typing import Optional
@@ -93,7 +94,10 @@ def update_is_required(self, force: bool = False) -> Optional[Version]:
         return wanted
 
     def update(
-        self, force: bool = False, files_to_ignore: Optional[Sequence[str]] = None
+        self,
+        force: bool = False,
+        files_to_ignore: Optional[Sequence[str]] = None,
+        no_patch: bool = True,
     ) -> None:
         """Update this subproject if required.
 
@@ -128,7 +132,7 @@ def update(
             actually_fetched = self._fetch_impl(to_fetch)
         self._log_project(f"Fetched {actually_fetched}")
 
-        applied_patches = self._apply_patches()
+        applied_patches = [] if not no_patch else self._apply_patches()
 
         self.__metadata.fetched(
             actually_fetched,
@@ -139,6 +143,56 @@ def update(
         logger.debug(f"Writing repo metadata to: {self.__metadata.path}")
         self.__metadata.dump()
 
+    def update_patch(self, files_to_ignore: Optional[Sequence[str]] = None) -> None:
+        """Update the patch."""
+
+        # Check if the project has a patch, maybe suggest creating one?
+        if not self.__project.patch:
+            self._log_project(
+                f'skipped - there is no patch file, use "dfetch diff {self.__project.name}" instead'
+            )
+            return
+
+        # Check if the project was ever fetched
+        on_disk_version = self.on_disk_version()
+        if not on_disk_version:
+            self._log_project(
+                f'skipped - the project was never fetched before, use "dfetch update {self.__project.name}" '
+            )
+            return
+
+        # Make sure no uncommitted changes (don't care about ignored files)
+        if self._are_there_local_changes(files_to_ignore):
+            self._log_project(
+                "skipped - local changes after last update (use --force to overwrite)"
+            )
+            return
+
+        # Select patch to overwrite & make backup
+        patch_to_update = self.__project.patch[-1]
+        shutil.move(patch_to_update, patch_to_update + ".backup")
+
+        # force update to fetched version from metadata without applying patch
+        self.update(force=True, files_to_ignore=files_to_ignore, no_patch=True)
+
+        # generate reverse patch
+        patch_text = self._diff_impl(
+            old_revision=self.metadata_revision(),
+            new_revision=None,
+            ignore=files_to_ignore,
+            reverse=True,
+        )
+
+        if patch_text:
+            patch_path = pathlib.Path(patch_to_update)
+            self._log_project(f"Updating patch {patch_to_update}")
+            patch_path.write_text(patch_text, encoding="UTF-8")
+        else:
+            self._log_project(f"No diffs found, kept patch {patch_to_update} unchanged")
+
+        # force update again to fetched version from metadata but with applying patch
+        self.update(force=True, files_to_ignore=files_to_ignore, no_patch=False)
+
     def _apply_patches(self) -> list[str]:
         """Apply the patches."""
         cwd = pathlib.Path(".").resolve()
@@ -386,6 +440,7 @@ def _diff_impl(
         old_revision: str,  # noqa
         new_revision: Optional[str],  # noqa
         ignore: Sequence[str],
+        reverse: bool = False,
     ) -> str:
         """Get the diff of two revisions, should be implemented by the child class."""
 

dfetch/project/svn.py

@@ -190,9 +190,20 @@ def current_revision(self) -> str:
         return SvnRepo.get_last_changed_revision(self.local_path)
 
     def _diff_impl(
-        self, old_revision: str, new_revision: Optional[str], ignore: Sequence[str]
+        self,
+        old_revision: str,
+        new_revision: Optional[str],
+        ignore: Sequence[str],
+        reverse=False,
     ) -> str:
         """Get the diff between two revisions."""
+
+        if not new_revision:
+            new_revision = "HEAD"
+
+        if reverse:
+            new_revision, old_revision = old_revision, new_revision
+
         filtered = self._repo.create_diff(old_revision, new_revision, ignore)
 
         if new_revision:

dfetch/vcs/git.py

@@ -383,6 +383,7 @@ def create_diff(
         old_hash: Optional[str],
         new_hash: Optional[str],
         ignore: Optional[Sequence[str]] = None,
+        reverse: bool = False,
     ) -> str:
         """Generate a relative diff patch."""
         with in_directory(self._path):
@@ -394,6 +395,10 @@ def create_diff(
                 "--no-ext-diff",  # Don't allow external diff tools
                 "--no-color",
             ]
+
+            if reverse:
+                cmd.extend(["-R", "--src-prefix=b/", "--dst-prefix=a/"])
+
             if old_hash:
                 cmd.append(old_hash)
                 if new_hash: