WIP: Move diff into superproject

Author: spoorcc

dfetch/commands/diff.py

@@ -60,7 +60,7 @@
 import dfetch.commands.command
 from dfetch.log import get_logger
 from dfetch.project.metadata import Metadata
-from dfetch.project.superproject import SuperProject
+from dfetch.project.superproject import NoVcsSuperProject, SuperProject
 from dfetch.util.util import catch_runtime_exceptions, in_directory
 
 logger = get_logger(__name__)
@@ -99,6 +99,11 @@ def __call__(self, args: argparse.Namespace) -> None:
         superproject = SuperProject.create()
         old_rev, new_rev = self._parse_revs(args.revs)
 
+        if isinstance(superproject, NoVcsSuperProject):
+            raise RuntimeError(
+                "Can only create patch if your project is an SVN or Git repo",
+            )
+
         with in_directory(superproject.root_directory):
             exceptions: list[str] = []
             projects = superproject.manifest.selected_projects(args.projects)
@@ -114,10 +119,9 @@ def __call__(self, args: argparse.Namespace) -> None:
                         )
                     subproject = superproject.get_sub_project(project)
 
-                    if subproject is None:
-                        raise RuntimeError(
-                            "Can only create patch if your project is an SVN or Git repo",
-                        )
+                    if not subproject:
+                        raise RuntimeError("No subproject!")
+
                     old_rev = old_rev or superproject.get_file_revision(
                         subproject.metadata_path
                     )
@@ -127,7 +131,12 @@ def __call__(self, args: argparse.Namespace) -> None:
                             f" the last revision to {Metadata.FILENAME} in {subproject.local_path}."
                             " Please either commit this, or specify a revision to start from with --revs"
                         )
-                    patch = subproject.diff(old_rev, new_rev)
+                    patch = superproject.diff(
+                        project.destination,
+                        old_rev,
+                        new_rev,
+                        ignore=(Metadata.FILENAME,),
+                    )
 
                     msg = self._rev_msg(old_rev, new_rev)
                     if patch:

dfetch/commands/update_patch.py

@@ -40,7 +40,7 @@
 import dfetch.manifest.project
 import dfetch.project
 from dfetch.log import get_logger
-from dfetch.project.superproject import GitSuperProject, SuperProject, SvnSuperProject
+from dfetch.project.superproject import GitSuperProject, NoVcsSuperProject, SuperProject
 from dfetch.util.util import catch_runtime_exceptions, in_directory
 
 logger = get_logger(__name__)
@@ -74,7 +74,7 @@ def __call__(self, args: argparse.Namespace) -> None:
 
         exceptions: list[str] = []
 
-        if not isinstance(superproject, (GitSuperProject, SvnSuperProject)):
+        if isinstance(superproject, NoVcsSuperProject):
             raise RuntimeError(
                 "The project containing the manifest is not under version control,"
                 " updating patches is not supported"
@@ -123,10 +123,11 @@ def __call__(self, args: argparse.Namespace) -> None:
                     )
 
                     # generate reverse patch
-                    patch_text = subproject.diff(
+                    patch_text = superproject.diff(
+                        subproject.local_path,
                         old_revision="",
                         new_revision="",
-                        # ignore=files_to_ignore,
+                        ignore=[],
                         reverse=True,
                     )
 

dfetch/project/gitsubproject.py

@@ -2,17 +2,15 @@
 
 import os
 import pathlib
-from collections.abc import Sequence
 from functools import lru_cache
-from typing import Optional
 
 from dfetch.log import get_logger
 from dfetch.manifest.project import ProjectEntry
 from dfetch.manifest.version import Version
 from dfetch.project.subproject import SubProject
 from dfetch.util.util import safe_rmtree
 from dfetch.vcs.git import GitLocalRepo, GitRemote, get_git_version
-from dfetch.vcs.patch import PatchInfo, reverse_patch
+from dfetch.vcs.patch import PatchInfo
 
 logger = get_logger(__name__)
 
@@ -44,39 +42,6 @@ def _list_of_tags(self) -> list[str]:
         """Get list of all available tags."""
         return [str(tag) for tag in self._remote_repo.list_of_tags()]
 
-    def _diff_impl(
-        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, reverse)
-        )
-
-        if new_revision:
-            return diff_since_revision
-
-        combined_diff = []
-
-        if diff_since_revision:
-            combined_diff += [diff_since_revision]
-
-        untracked_files_patch = str(self._local_repo.untracked_files_patch(ignore))
-        if untracked_files_patch:
-            if reverse:
-                reversed_patch = reverse_patch(untracked_files_patch.encode("utf-8"))
-                if not reversed_patch:
-                    raise RuntimeError(
-                        "Failed to reverse untracked files patch; patch parsing returned empty."
-                    )
-                untracked_files_patch = reversed_patch
-            combined_diff += [untracked_files_patch]
-
-        return "\n".join(combined_diff)
-
     @staticmethod
     def revision_is_enough() -> bool:
         """See if this VCS can uniquely distinguish branch with revision only."""

dfetch/project/subproject.py

@@ -385,16 +385,6 @@ def _are_there_local_changes(self, files_to_ignore: Sequence[str]) -> bool:
     def _fetch_impl(self, version: Version) -> Version:
         """Fetch the given version of the subproject, should be implemented by the child class."""
 
-    @abstractmethod
-    def _diff_impl(
-        self,
-        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."""
-
     @abstractmethod
     def get_default_branch(self) -> str:
         """Get the default branch of this repository."""
@@ -407,12 +397,6 @@ def is_license_file(filename: str) -> bool:
             for pattern in SubProject.LICENSE_GLOBS
         )
 
-    def diff(self, old_revision: str, new_revision: str, reverse: bool = False) -> str:
-        """Generate a relative diff for a subproject."""
-        return self._diff_impl(
-            old_revision, new_revision, ignore=(Metadata.FILENAME,), reverse=reverse
-        )
-
     @abstractmethod
     def create_formatted_patch_header(self, patch_info: PatchInfo) -> str:
         """Create a formatted patch header for the given patch info."""

dfetch/project/superproject.py

@@ -21,8 +21,16 @@
 from dfetch.project.gitsubproject import GitSubProject
 from dfetch.project.subproject import SubProject
 from dfetch.project.svnsubproject import SvnSubProject
-from dfetch.util.util import resolve_absolute_path
+from dfetch.util.util import (
+    in_directory,
+    resolve_absolute_path,
+)
 from dfetch.vcs.git import GitLocalRepo
+from dfetch.vcs.patch import (
+    combine_patches,
+    create_svn_patch_for_new_file,
+    reverse_patch,
+)
 from dfetch.vcs.svn import SvnRepo
 
 logger = get_logger(__name__)
@@ -102,6 +110,17 @@ def get_file_revision(self, path: str | pathlib.Path) -> str:
     def import_projects() -> Sequence[ProjectEntry]:
         """Import projects from underlying superproject."""
 
+    @abstractmethod
+    def diff(
+        self,
+        path: str | pathlib.Path,
+        old_revision: str,
+        new_revision: str | None,
+        ignore: Sequence[str],
+        reverse: bool = False,
+    ) -> str:
+        """Get the diff of two revisions."""
+
 
 class GitSuperProject(SuperProject):
     """A git specific superproject."""
@@ -192,6 +211,41 @@ def import_projects() -> Sequence[ProjectEntry]:
 
         return projects
 
+    def diff(
+        self,
+        path: str | pathlib.Path,
+        old_revision: str,
+        new_revision: str | None,
+        ignore: Sequence[str],
+        reverse: bool = False,
+    ) -> str:
+        """Get the diff of two revisions."""
+        local_repo = GitLocalRepo(path)
+        diff_since_revision = str(
+            local_repo.create_diff(old_revision, new_revision, ignore, reverse)
+        )
+
+        if new_revision:
+            return diff_since_revision
+
+        combined_diff = []
+
+        if diff_since_revision:
+            combined_diff += [diff_since_revision]
+
+        untracked_files_patch = str(local_repo.untracked_files_patch(ignore))
+        if untracked_files_patch:
+            if reverse:
+                reversed_patch = reverse_patch(untracked_files_patch.encode("utf-8"))
+                if not reversed_patch:
+                    raise RuntimeError(
+                        "Failed to reverse untracked files patch; patch parsing returned empty."
+                    )
+                untracked_files_patch = reversed_patch
+            combined_diff += [untracked_files_patch]
+
+        return "\n".join(combined_diff)
+
 
 class SvnSuperProject(SuperProject):
     """A SVN specific superproject."""
@@ -263,6 +317,40 @@ def import_projects() -> Sequence[ProjectEntry]:
 
         return projects
 
+    def diff(
+        self,
+        path: str | pathlib.Path,
+        old_revision: str,
+        new_revision: str | None,
+        ignore: Sequence[str],
+        reverse: bool = False,
+    ) -> str:
+        """Get the diff between two revisions."""
+        repo = SvnRepo(path)
+        if reverse:
+            if new_revision:
+                new_revision, old_revision = old_revision, new_revision
+
+        filtered = repo.create_diff(old_revision, new_revision, ignore)
+
+        if new_revision:
+            return filtered
+
+        patches: list[bytes] = [filtered.encode("utf-8")] if filtered else []
+        with in_directory(path):
+            for file_path in repo.untracked_files(".", ignore):
+                patch = create_svn_patch_for_new_file(file_path)
+                if patch:
+                    patches.append(patch.encode("utf-8"))
+
+        patch_str = combine_patches(patches)
+
+        # SVN has no way of producing a reverse working copy patch, reverse ourselves
+        if reverse and not new_revision:
+            patch_str = reverse_patch(patch_str.encode("UTF-8"))
+
+        return patch_str
+
 
 class NoVcsSuperProject(SuperProject):
     """A superproject without any version control."""
@@ -318,3 +406,14 @@ def import_projects() -> Sequence[ProjectEntry]:
             "Only git or SVN projects can be imported.",
             "Run this command within either a git or SVN repository",
         )
+
+    def diff(
+        self,
+        path: str | pathlib.Path,
+        old_revision: str,
+        new_revision: str | None,
+        ignore: Sequence[str],
+        reverse: bool = False,
+    ) -> str:
+        """Get the diff between two revisions."""
+        return ""

dfetch/project/svnsubproject.py

@@ -3,8 +3,6 @@
 import os
 import pathlib
 import urllib.parse
-from collections.abc import Sequence
-from typing import Optional
 
 from dfetch.log import get_logger
 from dfetch.manifest.project import ProjectEntry
@@ -13,15 +11,9 @@
 from dfetch.util.util import (
     find_matching_files,
     find_non_matching_files,
-    in_directory,
     safe_rm,
 )
-from dfetch.vcs.patch import (
-    PatchInfo,
-    combine_patches,
-    create_svn_patch_for_new_file,
-    reverse_patch,
-)
+from dfetch.vcs.patch import PatchInfo
 from dfetch.vcs.svn import SvnRemote, SvnRepo, get_svn_version
 
 logger = get_logger(__name__)
@@ -186,38 +178,6 @@ def _license_files(url_path: str) -> list[str]:
     def _get_revision(self, branch: str) -> str:
         return self._get_info(branch)["Revision"]
 
-    def _diff_impl(
-        self,
-        old_revision: str,
-        new_revision: Optional[str],
-        ignore: Sequence[str],
-        reverse: bool = False,
-    ) -> str:
-        """Get the diff between two revisions."""
-        if reverse:
-            if new_revision:
-                new_revision, old_revision = old_revision, new_revision
-
-        filtered = self._repo.create_diff(old_revision, new_revision, ignore)
-
-        if new_revision:
-            return filtered
-
-        patches: list[bytes] = [filtered.encode("utf-8")] if filtered else []
-        with in_directory(self.local_path):
-            for file_path in self._repo.untracked_files(".", ignore):
-                patch = create_svn_patch_for_new_file(file_path)
-                if patch:
-                    patches.append(patch.encode("utf-8"))
-
-        patch_str = combine_patches(patches)
-
-        # SVN has no way of producing a reverse working copy patch, reverse ourselves
-        if reverse and not new_revision:
-            patch_str = reverse_patch(patch_str.encode("UTF-8"))
-
-        return patch_str
-
     def get_default_branch(self) -> str:
         """Get the default branch of this repository."""
         return self._repo.DEFAULT_BRANCH

tests/test_subproject.py

@@ -43,15 +43,6 @@ def wanted_version(self):
     def _list_of_tags(self):
         return []
 
-    def _diff_impl(
-        self,
-        old_revision,
-        new_revision,
-        ignore,
-        reverse=False,
-    ):
-        return ""
-
     def get_default_branch(self):
         return ""