git2svn 0.7.1__tar.gz → 0.8.0__tar.gz

{git2svn-0.7.1/git2svn.egg-info → git2svn-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git2svn
-Version: 0.7.1
+Version: 0.8.0
 Summary: CLI utility to synchronize changes from a local Git repository to a local SVN working copy
 Author: Simon
 License: Apache-2.0

{git2svn-0.7.1 → git2svn-0.8.0}/docs/user-guide/commands.md

@@ -1,6 +1,6 @@
-# Command Reference: `setup`, `stage` & `replay`
+# Command Reference: `stage`, `diff`, `replay`, `setup` & `status`
 
-This document details the usage, flags, and mechanics for `git2svn setup`, `git2svn stage`, and `git2svn replay`.
+This document details the usage, flags, and mechanics for all `git2svn` commands.
 
 
 ---
@@ -43,9 +43,30 @@ Compares the full tree of a target Git branch or commit against the SVN workspac
 git2svn stage feature/login --snapshot -s /path/to/svn
 ```
 
+### 1.5 Immediate Diff Preview (`--diff` / `-p`)
+Immediately preview the staged diff upon completion without needing to run a separate command:
+
+```bash
+git2svn stage main..feature/login --diff
+```
+
+---
+
+## 2. Command: `diff`
+
+Inspect uncommitted changes in the SVN workspace staged by `git2svn stage`.
+
+```bash
+# View full unified diff of staged changes:
+git2svn diff
+
+# View compact diffstat summary:
+git2svn diff --stat
+```
+
 ---
 
-## 2. Command: `replay`
+## 3. Command: `replay`
 
 Sequentially ports Git commits onto the SVN workspace, creating an **atomic `svn commit` for each** with its original Git commit message, author body, and timestamps.
 

{git2svn-0.7.1 → git2svn-0.8.0}/git2svn/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.7.1'
-__version_tuple__ = version_tuple = (0, 7, 1)
+__version__ = version = '0.8.0'
+__version_tuple__ = version_tuple = (0, 8, 0)
 
 __commit_id__ = commit_id = None

{git2svn-0.7.1 → git2svn-0.8.0}/git2svn/cli.py

@@ -136,6 +136,13 @@ def build_parser() -> argparse.ArgumentParser:
         default=argparse.SUPPRESS,
         help="Mirror the exact tree of ref1 onto SVN without knowing base ref (adds new, removes missing, updates modified)",
     )
+    parser_stage.add_argument(
+        "--diff",
+        "-p",
+        action="store_true",
+        default=argparse.SUPPRESS,
+        help="Immediately show 'svn diff' preview of staged changes after staging",
+    )
 
     # replay
     parser_replay = subparsers.add_parser(
@@ -214,6 +221,20 @@ def build_parser() -> argparse.ArgumentParser:
         help="Path to SVN working copy (optional if already configured or set via --svn-dir)",
     )
 
+    # diff
+    parser_diff = subparsers.add_parser(
+        "diff",
+        parents=[common_parser],
+        help="Inspect uncommitted changes in the SVN workspace (preview after staging)",
+        description="Run svn diff on the SVN workspace to inspect uncommitted changes staged by git2svn.",
+    )
+    parser_diff.add_argument(
+        "--stat",
+        action="store_true",
+        default=False,
+        help="Display a diffstat summary of changed files instead of the full patch",
+    )
+
     # status
     subparsers.add_parser(
         "status",
@@ -249,6 +270,8 @@ def parse_cli_args(argv: Optional[List[str]] = None) -> argparse.Namespace:
         verbose=False,
         copy=False,
         snapshot=False,
+        diff=False,
+        stat=False,
         replay_action=None,
         update=None,
     )
@@ -380,6 +403,15 @@ def main(argv: Optional[List[str]] = None) -> int:
                 use_copy=use_copy,
                 snapshot=is_snapshot,
             )
+            if getattr(args, "diff", False):
+                diff_output = sync_mgr.diff()
+                if diff_output.strip():
+                    print(diff_output, end="")
+        elif args.command == "diff":
+            show_stat = getattr(args, "stat", False)
+            diff_output = sync_mgr.diff(stat=show_stat)
+            if diff_output.strip():
+                print(diff_output, end="")
         elif args.command == "replay":
             action = getattr(args, "replay_action", None)
             if action == "continue":

{git2svn-0.7.1 → git2svn-0.8.0}/git2svn/core.py

@@ -4,6 +4,7 @@ import logging
 import os
 import shutil
 import sys
+import time
 from pathlib import Path
 from typing import Dict, List, Optional
 
@@ -210,6 +211,13 @@ class Synchronizer:
             modified_count,
         )
 
+    def diff(self, stat: bool = False) -> str:
+        """
+        Inspect uncommitted changes in the SVN workspace using svn diff.
+        Returns the diff output text (or stat summary if stat=True).
+        """
+        return self.svn.diff(stat=stat)
+
     def replay(self, ref1: str, ref2: Optional[str] = None) -> None:
         """
         Replay a single commit or range of commits onto SVN, committing each with its Git message.
@@ -218,6 +226,11 @@ class Synchronizer:
         target_spec = f"{start_or_commit}..{end_ref}" if not is_single else start_or_commit
         self.show_identity_banner(target_spec)
 
+        if not self.dry_run and not self.svn.is_clean():
+            raise RuntimeError(
+                "SVN workspace has uncommitted changes. Please commit, stash, or revert them before starting a replay."
+            )
+
         if is_single:
             commit_hash = start_or_commit
             logger.info("Replaying single commit %s", commit_hash)
@@ -226,11 +239,6 @@ class Synchronizer:
             start_ref = start_or_commit
             assert end_ref is not None
 
-            if not self.dry_run and not self.svn.is_clean():
-                raise RuntimeError(
-                    "SVN workspace has uncommitted changes. Please commit, stash, or revert them before starting a replay."
-                )
-
             merges = self.git.get_merge_commits(start_ref, end_ref)
             if merges:
                 raise RuntimeError(
@@ -336,6 +344,7 @@ class Synchronizer:
 
     def _execute_replay_queue(self, commits: List[str], total_commits: int, start_index: int) -> None:
         """Execute a list of commits sequentially, catching conflicts and persisting state."""
+        queue_start = time.perf_counter()
         pad_width = len(str(total_commits))
         for idx, commit_hash in enumerate(commits, start=start_index):
             commit_msg = self.git.get_commit_message(commit_hash)
@@ -351,19 +360,23 @@ class Synchronizer:
                 sys.stdout.write(f"{progress_prefix}... ")
                 sys.stdout.flush()
 
+            commit_start = time.perf_counter()
             try:
                 self._patch_and_stage_commit(commit_hash)
                 self.svn.commit(commit_msg)
-                sys.stdout.write("OK\n")
+                elapsed = time.perf_counter() - commit_start
+                sys.stdout.write(f"OK ({elapsed:.2f}s)\n")
                 sys.stdout.flush()
             except SvnError:
-                sys.stdout.write("FAILED (SVN error)\n")
+                elapsed = time.perf_counter() - commit_start
+                sys.stdout.write(f"FAILED (SVN error, {elapsed:.2f}s)\n")
                 sys.stdout.flush()
                 # SVN operational failure (e.g. working copy locked, out-of-date, collision)
                 # Re-raise directly to display actionable SVN resolution hints
                 raise
             except Exception:
-                sys.stdout.write("CONFLICT\n")
+                elapsed = time.perf_counter() - commit_start
+                sys.stdout.write(f"CONFLICT ({elapsed:.2f}s)\n")
                 sys.stdout.flush()
                 remaining = commits[idx - start_index + 1 :]
                 state_data = {
@@ -398,7 +411,12 @@ class Synchronizer:
                 )
                 raise
         clear_replay_state(self.svn.workspace_dir)
-        logger.info("Replay completed successfully! All %d commits applied.", total_commits)
+        total_elapsed = time.perf_counter() - queue_start
+        logger.info(
+            "Replay completed successfully! All %d commits applied in %.2fs.",
+            total_commits,
+            total_elapsed,
+        )
         if self.auto_update:
             self.svn.update()
 

{git2svn-0.7.1 → git2svn-0.8.0}/git2svn/svn.py

@@ -153,6 +153,21 @@ class SvnWorkspace:
             raise parse_svn_error(res.stderr, "check status", self.workspace_dir)
         return not bool(res.stdout.strip())
 
+    def diff(self, target: Optional[str] = None, stat: bool = False) -> str:
+        """
+        Run 'svn diff' on the workspace or a specific target.
+        If stat is True, runs 'svn diff --stat' (summarized file changes).
+        """
+        args = ["diff"]
+        if stat:
+            args.append("--stat")
+        if target:
+            args.append(target)
+        res = self.run_cmd(args, check=False)
+        if res.returncode != 0:
+            raise parse_svn_error(res.stderr, "diff", self.workspace_dir)
+        return res.stdout
+
     def get_status_summary(self) -> List[str]:
         """Return lines of uncommitted changes from 'svn status -q'."""
         res = self.run_cmd(["status", "-q"], check=False)

{git2svn-0.7.1 → git2svn-0.8.0/git2svn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git2svn
-Version: 0.7.1
+Version: 0.8.0
 Summary: CLI utility to synchronize changes from a local Git repository to a local SVN working copy
 Author: Simon
 License: Apache-2.0

{git2svn-0.7.1 → git2svn-0.8.0}/tests/test_cli.py

@@ -193,6 +193,39 @@ class TestCli(unittest.TestCase):
             mock_is_file.return_value = False
             self.assertEqual(git2svn.svn.find_svn_binary(), "svn")
 
+    def test_diff_subcommand_args(self):
+        """Verify diff subcommand argument parsing."""
+        args = git2svn.parse_cli_args(["diff", "-s", "/path/to/svn"])
+        self.assertEqual(args.command, "diff")
+        self.assertFalse(args.stat)
+
+        args_stat = git2svn.parse_cli_args(["diff", "--stat", "-s", "/path/to/svn"])
+        self.assertEqual(args_stat.command, "diff")
+        self.assertTrue(args_stat.stat)
+
+        args_stage_diff = git2svn.parse_cli_args(["stage", "HEAD", "-p", "-s", "/path/to/svn"])
+        self.assertEqual(args_stage_diff.command, "stage")
+        self.assertTrue(args_stage_diff.diff)
+
+    def test_diff_command_execution(self):
+        """Verify git2svn diff invokes synchronizer.diff and prints output."""
+        git_dir = self.path / "diff_git"
+        git_dir.mkdir()
+        subprocess.run(["git", "init"], cwd=git_dir, check=True, capture_output=True)
+
+        svn_dir = self.path / "diff_svn"
+        svn_dir.mkdir()
+        (svn_dir / ".svn").mkdir()
+
+        with patch("git2svn.cli.Synchronizer") as mock_sync_cls, patch("sys.stdout", new=io.StringIO()) as fake_out:
+            mock_sync = mock_sync_cls.return_value
+            mock_sync.diff.return_value = "Index: file.txt\n=== diff content ===\n"
+
+            code = git2svn.main(["--git-dir", str(git_dir), "--svn-dir", str(svn_dir), "diff"])
+            self.assertEqual(code, 0)
+            mock_sync.diff.assert_called_once_with(stat=False)
+            self.assertIn("=== diff content ===", fake_out.getvalue())
+
 
 if __name__ == "__main__":
     unittest.main()

{git2svn-0.7.1 → git2svn-0.8.0}/tests/test_core.py

@@ -481,7 +481,7 @@ class TestSynchronizer(unittest.TestCase):
         with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
             self.sync_mgr.replay(base_hash, feat_hash)
             output = mock_stdout.getvalue()
-            self.assertIn(f"[1/1] Applying {feat_hash[:8]}: feat: progress indicator... OK", output)
+            self.assertIn(f"[1/1] Applying {feat_hash[:8]}: feat: progress indicator... OK (", output)
 
     @patch.object(git2svn.SvnWorkspace, "run_cmd")
     def test_stage_with_git_config_default_range(self, mock_svn_cmd):
@@ -677,6 +677,20 @@ class TestSynchronizer(unittest.TestCase):
             self.assertEqual(res, 1)
             mock_tb.assert_called_once()
 
+    def test_replay_raises_if_svn_workspace_dirty(self):
+        """Verify replay raises RuntimeError if SVN workspace has uncommitted changes."""
+        with patch.object(self.svn_ws, "is_clean", return_value=False):
+            with self.assertRaises(RuntimeError) as cm:
+                self.sync_mgr.replay("HEAD~1..HEAD")
+            self.assertIn("SVN workspace has uncommitted changes", str(cm.exception))
+
+    def test_replay_single_commit_raises_if_dirty(self):
+        """Verify replay of single commit raises RuntimeError if SVN workspace has uncommitted changes."""
+        with patch.object(self.svn_ws, "is_clean", return_value=False):
+            with self.assertRaises(RuntimeError) as cm:
+                self.sync_mgr.replay("HEAD")
+            self.assertIn("SVN workspace has uncommitted changes", str(cm.exception))
+
 
 if __name__ == "__main__":
     unittest.main()

{git2svn-0.7.1 → git2svn-0.8.0}/tests/test_svn.py

@@ -135,6 +135,20 @@ class TestSvnLockAndCollisionHandling(unittest.TestCase):
         with self.assertRaises(git2svn.SvnLockError):
             self.workspace.is_clean()
 
+    @patch.object(git2svn.SvnWorkspace, "run_cmd")
+    def test_diff(self, mock_cmd):
+        mock_cmd.return_value = subprocess.CompletedProcess([], 0, stdout="Index: file.txt\n", stderr="")
+        output = self.workspace.diff()
+        self.assertEqual(output, "Index: file.txt\n")
+        mock_cmd.assert_called_once_with(["diff"], check=False)
+
+    @patch.object(git2svn.SvnWorkspace, "run_cmd")
+    def test_diff_stat(self, mock_cmd):
+        mock_cmd.return_value = subprocess.CompletedProcess([], 0, stdout="file.txt | 2 +-\n", stderr="")
+        output = self.workspace.diff(stat=True)
+        self.assertEqual(output, "file.txt | 2 +-\n")
+        mock_cmd.assert_called_once_with(["diff", "--stat"], check=False)
+
 
 if __name__ == "__main__":
     unittest.main()