git2svn 0.5.2__tar.gz → 0.6.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git2svn
-Version: 0.5.2
+Version: 0.6.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.5.2 → git2svn-0.6.0}/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.0}/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.0'
+__version_tuple__ = version_tuple = (0, 6, 0)
 
 __commit_id__ = commit_id = None

{git2svn-0.5.2 → git2svn-0.6.0}/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)

git2svn-0.6.0/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.0}/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."""
@@ -522,6 +525,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 +538,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 +609,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 +624,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.0/git2svn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git2svn
-Version: 0.5.2
+Version: 0.6.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.5.2 → git2svn-0.6.0}/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.0}/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.0}/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()