git2svn 0.5.2__tar.gz → 0.6.1__tar.gz

{git2svn-0.5.2/git2svn.egg-info → git2svn-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git2svn
-Version: 0.5.2
+Version: 0.6.1
 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.5.2 → git2svn-0.6.1}/git2svn/__init__.py

@@ -6,6 +6,7 @@ to a local Subversion (SVN) working copy.
 from __future__ import annotations
 
 from .cli import build_parser, main, parse_cli_args
+from .colors import TerminalColor
 from .core import Synchronizer
 from .eol import detect_file_eol, normalize_file_eol
 from .git import FileChange, GitRepo, parse_name_status, parse_name_status_z, parse_ref_arguments
@@ -43,6 +44,7 @@ __all__ = [
     "SvnLockError",
     "SvnOutOfDateError",
     "Patcher",
+    "TerminalColor",
     "FileChange",
     "parse_ref_arguments",
     "parse_name_status",

{git2svn-0.5.2 → git2svn-0.6.1}/git2svn/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.5.2'
-__version_tuple__ = version_tuple = (0, 5, 2)
+__version__ = version = '0.6.1'
+__version_tuple__ = version_tuple = (0, 6, 1)
 
 __commit_id__ = commit_id = None

{git2svn-0.5.2 → git2svn-0.6.1}/git2svn/cli.py

@@ -67,6 +67,12 @@ def build_parser() -> argparse.ArgumentParser:
         default=argparse.SUPPRESS,
         help="Enable verbose output",
     )
+    common_parser.add_argument(
+        "--color",
+        choices=["auto", "always", "never"],
+        default=argparse.SUPPRESS,
+        help="Control colored output (auto, always, never; default: git config git2svn.color or auto)",
+    )
 
     parser = argparse.ArgumentParser(
         prog="git2svn",
@@ -435,8 +441,21 @@ def main(argv: Optional[List[str]] = None) -> int:
         print(f"Error: '{svn_dir}' does not appear to be an SVN working copy (no .svn found).", file=sys.stderr)
         return 1
 
+    # Color mode: CLI --color -> git config git2svn.color -> "auto"
+    color_mode = getattr(args, "color", None)
+    if not color_mode:
+        config_color = git_repo.get_config("git2svn.color")
+        color_mode = config_color if config_color in ("auto", "always", "never") else "auto"
+
     patcher = Patcher(svn_dir, dry_run=dry_run)
-    sync_mgr = Synchronizer(git_repo, svn_workspace, patcher, dry_run=dry_run, auto_update=auto_update)
+    sync_mgr = Synchronizer(
+        git_repo,
+        svn_workspace,
+        patcher,
+        dry_run=dry_run,
+        auto_update=auto_update,
+        color_mode=color_mode,
+    )
 
     # Fallback to git2svn.defaultRange if ref1 is omitted
     ref1 = getattr(args, "ref1", None)
@@ -454,6 +473,11 @@ def main(argv: Optional[List[str]] = None) -> int:
 
     try:
         if args.command == "stage":
+            is_snapshot = getattr(args, "snapshot", False)
+            if not ref1 and is_snapshot:
+                ref1 = "HEAD"
+                logger.info("No ref specified for snapshot stage; defaulting to HEAD.")
+
             if not ref1:
                 print(
                     "Error: stage requires a commit or range (e.g. 'git2svn stage main..feature') "
@@ -465,7 +489,7 @@ def main(argv: Optional[List[str]] = None) -> int:
                 ref1,
                 ref2,
                 use_copy=use_copy,
-                snapshot=getattr(args, "snapshot", False),
+                snapshot=is_snapshot,
             )
         elif args.command == "replay":
             action = getattr(args, "replay_action", None)

git2svn-0.6.1/git2svn/colors.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import os
+import sys
+
+
+class TerminalColor:
+    """ANSI terminal color formatting with auto/always/never detection and NO_COLOR support."""
+
+    # ANSI Styles & Colors
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    GRAY = "\033[90m"
+
+    BOLD_RED = "\033[1;31m"
+    BOLD_GREEN = "\033[1;32m"
+    BOLD_YELLOW = "\033[1;33m"
+    BOLD_CYAN = "\033[1;36m"
+
+    def __init__(self, mode: str = "auto"):
+        self.mode = mode.lower()
+        self.enabled = self._resolve_enabled()
+
+    def _resolve_enabled(self) -> bool:
+        if self.mode == "always":
+            return True
+        if self.mode == "never":
+            return False
+
+        # Mode is "auto"
+        # 1. Respect NO_COLOR standard (https://no-color.org/)
+        if "NO_COLOR" in os.environ and os.environ["NO_COLOR"] != "":
+            return False
+
+        # 2. Check for dumb terminals
+        if os.environ.get("TERM") == "dumb":
+            return False
+
+        # 3. Check if stdout is an interactive TTY
+        try:
+            return sys.stdout.isatty()
+        except Exception:
+            return False
+
+    def colorize(self, text: str, ansi_code: str) -> str:
+        """Wrap text in ANSI color escape codes if coloring is enabled."""
+        if not self.enabled:
+            return text
+        return f"{ansi_code}{text}{self.RESET}"
+
+    # Style helpers
+    def bold(self, text: str) -> str:
+        return self.colorize(text, self.BOLD)
+
+    def dim(self, text: str) -> str:
+        return self.colorize(text, self.DIM)
+
+    def red(self, text: str) -> str:
+        return self.colorize(text, self.RED)
+
+    def green(self, text: str) -> str:
+        return self.colorize(text, self.GREEN)
+
+    def yellow(self, text: str) -> str:
+        return self.colorize(text, self.YELLOW)
+
+    def cyan(self, text: str) -> str:
+        return self.colorize(text, self.CYAN)
+
+    def gray(self, text: str) -> str:
+        return self.colorize(text, self.GRAY)
+
+    def bold_red(self, text: str) -> str:
+        return self.colorize(text, self.BOLD_RED)
+
+    def bold_green(self, text: str) -> str:
+        return self.colorize(text, self.BOLD_GREEN)
+
+    def bold_yellow(self, text: str) -> str:
+        return self.colorize(text, self.BOLD_YELLOW)
+
+    def bold_cyan(self, text: str) -> str:
+        return self.colorize(text, self.BOLD_CYAN)
+
+    # Semantic badges
+    def ok(self, text: str = "OK") -> str:
+        return self.bold_green(f"✔ {text}")
+
+    def clean(self, text: str = "Clean") -> str:
+        return self.bold_green(f"✔ {text}")
+
+    def warn(self, text: str = "Warning") -> str:
+        return self.bold_yellow(f"⚠ {text}")
+
+    def error(self, text: str = "Error") -> str:
+        return self.bold_red(f"✖ {text}")

{git2svn-0.5.2 → git2svn-0.6.1}/git2svn/core.py

@@ -7,6 +7,7 @@ import sys
 from pathlib import Path
 from typing import Dict, List, Optional
 
+from .colors import TerminalColor
 from .eol import detect_file_eol, normalize_file_eol
 from .git import FileChange, GitRepo, parse_ref_arguments
 from .patcher import Patcher
@@ -32,12 +33,14 @@ class Synchronizer:
         patcher: Patcher,
         dry_run: bool = False,
         auto_update: bool = False,
+        color_mode: str = "auto",
     ):
         self.git = git_repo
         self.svn = svn_workspace
         self.patcher = patcher
         self.dry_run = dry_run
         self.auto_update = auto_update
+        self.color = TerminalColor(color_mode)
 
     def show_identity_banner(self, target_ref_spec: str) -> None:
         """Display identity banner showing active Git and SVN target branches/URLs."""
@@ -68,7 +71,10 @@ class Synchronizer:
         If use_copy=True, brute-force copies files using Git object DB (bypassing patch).
         """
         if snapshot:
-            self.stage_snapshot(ref1)
+            # If a range was supplied (e.g. origin/main..main or ref1 and ref2), snapshot targets the end ref
+            is_single, start_or_commit, end_ref = parse_ref_arguments(ref1, ref2)
+            target_ref = end_ref if not is_single and end_ref else start_or_commit
+            self.stage_snapshot(target_ref)
             return
 
         is_single, start_or_commit, end_ref = parse_ref_arguments(ref1, ref2)
@@ -522,6 +528,7 @@ class Synchronizer:
             1 if errors, working copy locked, merge conflicts, or linear violations exist
         """
         has_error = False
+        c = self.color
 
         # 1. Check in-progress replay state
         state = load_replay_state(self.svn.workspace_dir)
@@ -534,59 +541,69 @@ class Synchronizer:
             completed = state.get("completed_commits", 0)
             total = state.get("total_commits", len(remaining) + 1)
 
-            print("[Replay In Progress]")
-            print(f'  State     : PAUSED (conflict at commit {current_commit[:8]} "{first_msg}")')
+            print(c.bold_red("[Replay In Progress]"))
+            print(
+                f'  State     : {c.bold_red("PAUSED")} (conflict at commit {c.yellow(current_commit[:8])} "{first_msg}")'
+            )
             print(f"  Progress  : {completed} of {total} commits applied ({len(remaining)} remaining)")
 
             rej_files = find_conflict_artifacts(self.svn.workspace_dir)
             if rej_files:
                 rel_rejs = [str(r.relative_to(self.svn.workspace_dir)) for r in rej_files]
-                print(f"  Conflicts : {', '.join(rel_rejs)}")
-            print("  Action    : Resolve conflicts and run 'git2svn replay --continue' (or '--abort' / '--skip')\n")
+                print(f"  Conflicts : {c.bold_red(', '.join(rel_rejs))}")
+            action_text = (
+                f"Resolve conflicts and run {c.bold_cyan('git2svn replay --continue')} (or '--abort' / '--skip')"
+            )
+            print(f"  Action    : {action_text}\n")
 
         # 2. Git Workspace Status
         git_clean = self.git.is_clean()
         branch = self.git.get_current_branch()
         head_commit = self.git.get_head_commit()
         head_subject = self.git.get_head_subject()
-        head_desc = f'{head_commit} "{head_subject}"' if head_subject else head_commit
+        head_desc = f'{c.yellow(head_commit)} "{head_subject}"' if head_subject else c.yellow(head_commit)
 
-        print("[Git Workspace]")
+        print(c.bold_cyan("[Git Workspace]"))
         print(f"  Repository: {self.git.repo_dir}")
-        print(f"  Branch    : {branch} (at {head_desc})")
-        print(f"  Tree      : {'Clean' if git_clean else 'Dirty (uncommitted changes present)'}")
+        print(f"  Branch    : {c.bold(branch)} (at {head_desc})")
+        if git_clean:
+            print(f"  Tree      : {c.bold_green('Clean')}")
+        else:
+            print(f"  Tree      : {c.bold_yellow('Dirty')} (uncommitted changes present)")
 
         # 3. SVN Working Copy Status
-        print("\n[SVN Working Copy]")
+        print(f"\n{c.bold_cyan('[SVN Working Copy]')}")
         print(f"  Path      : {self.svn.workspace_dir}")
         svn_info = self.svn.get_info()
         svn_url = svn_info.get("URL") or svn_info.get("Relative URL") or "unknown"
         svn_rev = svn_info.get("Revision")
-        rev_str = f" (r{svn_rev})" if svn_rev else ""
+        rev_str = f" ({c.dim(f'r{svn_rev}')})" if svn_rev else ""
         print(f"  Target    : {svn_url}{rev_str}")
 
         try:
             svn_clean = self.svn.is_clean()
             if svn_clean:
-                print("  Tree      : Clean (no uncommitted changes, unlocked)")
+                print(f"  Tree      : {c.bold_green('Clean')} (no uncommitted changes, unlocked)")
             else:
                 uncommitted = self.svn.get_status_summary()
-                print(f"  Tree      : Dirty ({len(uncommitted)} uncommitted changes)")
+                print(f"  Tree      : {c.bold_yellow(f'Dirty ({len(uncommitted)} uncommitted changes)')}")
                 for item in uncommitted[:5]:
                     print(f"              {item}")
                 if len(uncommitted) > 5:
-                    print(f"              ... and {len(uncommitted) - 5} more")
+                    print(f"              {c.dim(f'... and {len(uncommitted) - 5} more')}")
         except SvnError as e:
             has_error = True
-            print(f"  Tree      : Error: {e.args[0].splitlines()[0]}")
+            print(f"  Tree      : {c.bold_red(f'Error: {e.args[0].splitlines()[0]}')}")
 
         # 4. Synchronization Queue & Default Range
         default_range = self.git.get_config("git2svn.defaultRange")
-        print("\n[Synchronization]")
+        print(f"\n{c.bold_cyan('[Synchronization]')}")
         if not default_range:
-            print("  Range     : Not configured (run 'git2svn setup' or 'git config git2svn.defaultRange <range>')")
+            print(
+                f"  Range     : {c.dim('Not configured')} (run 'git2svn setup' or 'git config git2svn.defaultRange <range>')"
+            )
         else:
-            print(f"  Range     : {default_range}")
+            print(f"  Range     : {c.bold(default_range)}")
             try:
                 is_single, start_ref, end_ref = parse_ref_arguments(default_range)
                 if is_single:
@@ -595,11 +612,13 @@ class Synchronizer:
                 else:
                     assert end_ref is not None
                     if not self.git.ref_exists(start_ref):
-                        print(f"  Warning   : Range start ref '{start_ref}' not found in Git.")
+                        warn_msg = f"Range start ref '{start_ref}' not found in Git."
+                        print(f"  Warning   : {c.bold_yellow(warn_msg)}")
                         commits = []
                         merges = []
                     elif not self.git.ref_exists(end_ref):
-                        print(f"  Warning   : Range end ref '{end_ref}' not found in Git.")
+                        warn_msg = f"Range end ref '{end_ref}' not found in Git."
+                        print(f"  Warning   : {c.bold_yellow(warn_msg)}")
                         commits = []
                         merges = []
                     else:
@@ -608,24 +627,25 @@ class Synchronizer:
 
                 if merges:
                     has_error = True
-                    print(
-                        f"  Linearity : INVALID ({len(merges)} merge commits found in range - linear rebase required)"
-                    )
+                    inv_msg = f"INVALID ({len(merges)} merge commits found in range - linear rebase required)"
+                    print(f"  Linearity : {c.bold_red(inv_msg)}")
                 else:
-                    print("  Linearity : OK (strictly linear)")
+                    print(f"  Linearity : {c.bold_green('OK')} (strictly linear)")
 
                 if not commits:
-                    print("  Pending   : In sync (0 commits to replay)")
+                    print(f"  Pending   : {c.bold_green('In sync')} (0 commits to replay)")
                 else:
-                    print(f"  Pending   : {len(commits)} commit(s) ready to replay:")
+                    pending_title = f"{len(commits)} commit(s) ready to replay:"
+                    print(f"  Pending   : {c.bold_yellow(pending_title)}")
                     for idx, c_hash in enumerate(commits[:10], start=1):
                         msg = self.git.get_commit_message(c_hash)
                         subject = msg.splitlines()[0] if msg else ""
-                        print(f"              {idx}. [{c_hash[:8]}] {subject}")
+                        print(f"              {c.dim(f'{idx}.')} [{c.yellow(c_hash[:8])}] {subject}")
                     if len(commits) > 10:
-                        print(f"              ... and {len(commits) - 10} more")
+                        print(f"              {c.dim(f'... and {len(commits) - 10} more')}")
             except Exception as e:
-                print(f"  Error     : Could not parse range '{default_range}': {e}")
+                err_msg = f"Could not parse range '{default_range}': {e}"
+                print(f"  Error     : {c.bold_red(err_msg)}")
                 has_error = True
 
         if has_error:

{git2svn-0.5.2 → git2svn-0.6.1/git2svn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git2svn
-Version: 0.5.2
+Version: 0.6.1
 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.5.2 → git2svn-0.6.1}/git2svn.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ git2svn/__init__.py
 git2svn/__main__.py
 git2svn/_version.py
 git2svn/cli.py
+git2svn/colors.py
 git2svn/core.py
 git2svn/eol.py
 git2svn/git.py

{git2svn-0.5.2 → git2svn-0.6.1}/git2svn.egg-info/scm_file_list.json

@@ -21,6 +21,7 @@
     "git2svn/__init__.py",
     "git2svn/__main__.py",
     "git2svn/cli.py",
+    "git2svn/colors.py",
     "git2svn/core.py",
     "git2svn/eol.py",
     "git2svn/git.py",

{git2svn-0.5.2 → git2svn-0.6.1}/pyproject.toml

@@ -98,7 +98,7 @@ disallow_incomplete_defs = true
 check_untyped_defs = true
 no_implicit_optional = true
 warn_redundant_casts = true
-warn_unused_ignores = true
+warn_unused_ignores = false
 warn_return_any = true
 show_error_codes = true
 

{git2svn-0.5.2 → git2svn-0.6.1}/tests/test_e2e.py

@@ -233,6 +233,27 @@ class TestGit2SvnE2E(unittest.TestCase):
         self.assertIn("D       obsolete.txt", status)
         self.assertIn("A       brand_new.txt", status)
 
+    def test_e2e_snapshot_with_default_range(self):
+        """Test snapshot stage correctly resolves target ref when defaultRange is a range (e.g. origin/main..main)."""
+        # Create base file in SVN
+        (self.svn_wc_dir / "base.txt").write_text("v1\n", encoding="utf-8")
+        subprocess.run([SVN_BIN, "add", "base.txt"], cwd=self.svn_wc_dir, check=True)
+        subprocess.run([SVN_BIN, "commit", "-m", "init"], cwd=self.svn_wc_dir, check=True)
+
+        # In Git, create base commit and feature commit
+        (self.git_dir / "base.txt").write_text("v1\n", encoding="utf-8")
+        c1 = self._git_commit("feat: c1")
+        (self.git_dir / "base.txt").write_text("v2\n", encoding="utf-8")
+        c2 = self._git_commit("feat: c2")
+
+        # Configure defaultRange as a range c1..c2
+        subprocess.run([GIT_BIN, "config", "git2svn.defaultRange", f"{c1}..{c2}"], cwd=self.git_dir, check=True)
+
+        # Run stage --snapshot without any ref (should use end ref of defaultRange: c2)
+        exit_code = cli_main(["stage", "--snapshot", "-g", str(self.git_dir), "-s", str(self.svn_wc_dir)])
+        self.assertEqual(exit_code, 0)
+        self.assertEqual((self.svn_wc_dir / "base.txt").read_text(encoding="utf-8"), "v2\n")
+
     def test_e2e_replay_conflict_pause_and_continue(self):
         """Test replay pausing on a patch conflict in a real SVN WC and resuming with --continue."""
         # 1. Base commit in Git and SVN

{git2svn-0.5.2 → git2svn-0.6.1}/tests/test_git2svn.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+import os
 import subprocess
 import tempfile
 import unittest
@@ -1263,5 +1263,57 @@ class TestStatus(unittest.TestCase):
             mock_status.assert_called_once()
 
 
+class TestTerminalColor(unittest.TestCase):
+    def test_color_always(self):
+        color = git2svn.TerminalColor(mode="always")
+        self.assertTrue(color.enabled)
+        self.assertIn("\033[", color.bold_cyan("Test"))
+        self.assertIn("\033[", color.clean())
+        self.assertIn("\033[", color.ok())
+        self.assertIn("\033[", color.warn())
+        self.assertIn("\033[", color.error())
+
+    def test_color_never(self):
+        color = git2svn.TerminalColor(mode="never")
+        self.assertFalse(color.enabled)
+        self.assertEqual(color.bold_cyan("Test"), "Test")
+        self.assertEqual(color.clean(), "✔ Clean")
+
+    def test_color_auto_no_color_env(self):
+        with patch.dict(os.environ, {"NO_COLOR": "1"}):
+            color = git2svn.TerminalColor(mode="auto")
+            self.assertFalse(color.enabled)
+            self.assertEqual(color.bold("Hello"), "Hello")
+
+    def test_color_auto_dumb_term(self):
+        with patch.dict(os.environ, {"TERM": "dumb", "NO_COLOR": ""}):
+            color = git2svn.TerminalColor(mode="auto")
+            self.assertFalse(color.enabled)
+
+    def test_color_cli_and_git_config(self):
+        temp_dir = tempfile.TemporaryDirectory()
+        try:
+            repo_path = Path(temp_dir.name).resolve()
+            (repo_path / ".svn").mkdir()
+            subprocess.run(["git", "init"], cwd=repo_path, check=True, capture_output=True)
+            subprocess.run(["git", "config", "user.name", "Test"], cwd=repo_path, check=True)
+            subprocess.run(["git", "config", "user.email", "test@test.com"], cwd=repo_path, check=True)
+            subprocess.run(["git", "config", "git2svn.color", "always"], cwd=repo_path, check=True)
+
+            with patch("git2svn.cli.Synchronizer") as mock_sync_cls:
+                mock_sync_cls.return_value.status.return_value = 0
+                # When no --color is passed, config 'always' should be used
+                git2svn.main(["--git-dir", str(repo_path), "--svn-dir", str(repo_path), "status"])
+                _, kwargs = mock_sync_cls.call_args
+                self.assertEqual(kwargs.get("color_mode"), "always")
+
+                # When CLI --color never is passed, it overrides git config
+                git2svn.main(["--git-dir", str(repo_path), "--svn-dir", str(repo_path), "--color", "never", "status"])
+                _, kwargs = mock_sync_cls.call_args
+                self.assertEqual(kwargs.get("color_mode"), "never")
+        finally:
+            temp_dir.cleanup()
+
+
 if __name__ == "__main__":
     unittest.main()