Simplify diff

Author: ben-edna

dfetch/commands/diff.py

@@ -98,16 +98,9 @@
 import pathlib
 
 import dfetch.commands.command
-import dfetch.project
 from dfetch.log import get_logger
-from dfetch.manifest.project import ProjectEntry
-from dfetch.project.git import GitSubProject
-from dfetch.project.subproject import SubProject
 from dfetch.project.superproject import SuperProject
-from dfetch.project.svn import SvnSubProject
 from dfetch.util.util import catch_runtime_exceptions, in_directory
-from dfetch.vcs.git import GitLocalRepo
-from dfetch.vcs.svn import SvnRepo
 
 logger = get_logger(__name__)
 
@@ -143,7 +136,7 @@ def create_menu(subparsers: dfetch.commands.command.SubparserActionType) -> None
     def __call__(self, args: argparse.Namespace) -> None:
         """Perform the diff."""
         superproject = SuperProject()
-        revs = [r for r in args.revs.strip(":").split(":", maxsplit=1) if r]
+        old_rev, new_rev = self._parse_revs(args.revs)
 
         with in_directory(superproject.root_directory):
             exceptions: list[str] = []
@@ -153,49 +146,44 @@ def __call__(self, args: argparse.Namespace) -> None:
                     f"No (such) project found! {', '.join(args.projects)}"
                 )
             for project in projects:
-                patch_name = f"{project.name}.patch"
                 with catch_runtime_exceptions(exceptions) as exceptions:
-                    patch = _get_sub_project(superproject, project).diff(revs)
-
-                    _dump_patch(
-                        superproject.root_directory, revs, project, patch_name, patch
-                    )
+                    if not os.path.exists(project.destination):
+                        raise RuntimeError(
+                            "You cannot generate a diff of a project that was never fetched"
+                        )
+                    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",
+                        )
+                    old_rev = old_rev or subproject.metadata_revision()
+                    patch = subproject.diff(old_rev, new_rev)
+
+                    msg = self._rev_msg(old_rev, new_rev)
+                    if patch:
+                        patch_path = pathlib.Path(f"{project.name}.patch")
+                        logger.print_info_line(
+                            project.name,
+                            f"Generating patch {patch_path} {msg} in {superproject.root_directory}",
+                        )
+                        patch_path.write_text(patch, encoding="UTF-8")
+                    else:
+                        logger.print_info_line(project.name, f"No diffs found {msg}")
 
         if exceptions:
             raise RuntimeError("\n".join(exceptions))
 
+    @staticmethod
+    def _parse_revs(revs_arg: str) -> tuple[str, str]:
+        revs = [r for r in revs_arg.strip(":").split(":", maxsplit=1) if r]
 
-def _get_sub_project(superproject: SuperProject, project: ProjectEntry) -> SubProject:
-    """Get the subproject in the same vcs type as the superproject."""
-    if not os.path.exists(project.destination):
-        raise RuntimeError(
-            "You cannot generate a diff of a project that was never fetched"
-        )
-    if GitLocalRepo(superproject.root_directory).is_git():
-        return GitSubProject(project)
-    if SvnRepo(superproject.root_directory).is_svn():
-        return SvnSubProject(project)
-
-    raise RuntimeError(
-        "Can only create patch if your project is an SVN or Git repo",
-    )
-
-
-def _dump_patch(
-    path: str, revs: list[str], project: ProjectEntry, patch_name: str, patch: str
-) -> None:
-    """Dump the patch to a file."""
-    if patch:
-        rev_range = f"from {revs[0]} to {revs[1]}" if revs[1] else f"since {revs[0]}"
-        logger.print_info_line(
-            project.name,
-            f"Generating patch {patch_name} {rev_range} in {os.path.dirname(path)}",
-        )
-        pathlib.Path(patch_name).write_text(patch, encoding="UTF-8")
-    else:
-        if revs[1]:
-            msg = f"No diffs found from {revs[0]} to {revs[1]}"
-        else:
-            msg = f"No diffs found since {revs[0]}"
-
-        logger.print_info_line(project.name, msg)
+        if len(revs) == 0:
+            return "", ""
+        if len(revs) == 1:
+            return revs[0], ""
+        return revs[0], revs[1]
+
+    @staticmethod
+    def _rev_msg(old_rev: str, new_rev: str) -> str:
+        return f"from {old_rev} to {new_rev}" if new_rev else f"since {old_rev}"

dfetch/project/subproject.py

@@ -393,23 +393,13 @@ def is_license_file(filename: str) -> bool:
             for pattern in SubProject.LICENSE_GLOBS
         )
 
-    def diff(self, revs: list[str]) -> str:
+    def diff(self, old_rev: str, new_rev: str) -> str:
         """Generate a relative diff for a subproject."""
-        if len(revs) > 2:
-            raise RuntimeError(f"Too many revisions given! {revs}")
-
-        if not revs:
-            revs.append(self.metadata_revision())
-            if not revs[-1]:
-                raise RuntimeError(
-                    "When not providing any revisions, dfetch starts from"
-                    f" the last revision to {Metadata.FILENAME} in {self.local_path}."
-                    " Please either revision this, or specify a revision to start from with --revs"
-                )
-
-        if len(revs) == 1:
-            revs.append("")
+        if not old_rev:
+            raise RuntimeError(
+                "When not providing any revisions, dfetch starts from"
+                f" the last revision to {Metadata.FILENAME} in {self.local_path}."
+                " Please either revision this, or specify a revision to start from with --revs"
+            )
 
-        return self._diff_impl(
-            old_revision=revs[0], new_revision=revs[1], ignore=(Metadata.FILENAME,)
-        )
+        return self._diff_impl(old_rev, new_rev, ignore=(Metadata.FILENAME,))

dfetch/project/superproject.py

@@ -12,7 +12,13 @@
 
 from dfetch.log import get_logger
 from dfetch.manifest.manifest import Manifest, find_manifest
+from dfetch.manifest.project import ProjectEntry
 from dfetch.manifest.validate import validate
+from dfetch.project.git import GitSubProject
+from dfetch.project.subproject import SubProject
+from dfetch.project.svn import SvnSubProject
+from dfetch.vcs.git import GitLocalRepo
+from dfetch.vcs.svn import SvnRepo
 
 logger = get_logger(__name__)
 
@@ -44,3 +50,12 @@ def root_directory(self) -> str:
     def manifest(self) -> Manifest:
         """The manifest of the super project."""
         return self._manifest
+
+    def get_sub_project(self, project: ProjectEntry) -> SubProject | None:
+        """Get the subproject in the same vcs type as the superproject."""
+        if GitLocalRepo(self.root_directory).is_git():
+            return GitSubProject(project)
+        if SvnRepo(self.root_directory).is_svn():
+            return SvnSubProject(project)
+
+        return None