git2svn 0.4.0__py3-none-any.whl

git2svn/git.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+logger = logging.getLogger("git2svn")
+
+
+def parse_ref_arguments(
+    primary_ref: Optional[str], secondary_ref: Optional[str] = None
+) -> Tuple[bool, str, Optional[str]]:
+    """
+    Parses CLI ref arguments into either a single commit or a (start_ref, end_ref) range.
+    Returns: (is_single, start_or_commit, end_ref)
+    Examples:
+        'abc1234' -> (True, 'abc1234', None)
+        'main..feature' -> (False, 'main', 'feature')
+        'main', 'feature' -> (False, 'main', 'feature')
+    """
+    if not primary_ref:
+        raise ValueError("A commit reference or range is required.")
+
+    if secondary_ref:
+        return False, primary_ref, secondary_ref
+
+    if ".." in primary_ref:
+        parts = primary_ref.split("..", 1)
+        return False, parts[0], parts[1]
+
+    return True, primary_ref, None
+
+
+class FileChange:
+    """Represents a file change between two Git revisions."""
+
+    def __init__(self, action: str, path: str, old_path: Optional[str] = None):
+        self.action = action.upper()
+        self.path = Path(path)
+        self.old_path = Path(old_path) if old_path else None
+
+    @property
+    def is_added(self) -> bool:
+        return self.action.startswith("A")
+
+    @property
+    def is_deleted(self) -> bool:
+        return self.action.startswith("D")
+
+    @property
+    def is_modified(self) -> bool:
+        return self.action.startswith("M")
+
+    @property
+    def is_renamed(self) -> bool:
+        return self.action.startswith("R")
+
+    @property
+    def is_copied(self) -> bool:
+        return self.action.startswith("C")
+
+    def __repr__(self) -> str:
+        if self.old_path:
+            return f"<FileChange {self.action}: {self.old_path} -> {self.path}>"
+        return f"<FileChange {self.action}: {self.path}>"
+
+
+def parse_name_status(status_output: str) -> List[FileChange]:
+    """Parse standard tabular output of `git diff --name-status`."""
+    changes: List[FileChange] = []
+    for line in status_output.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        parts = line.split("\t")
+        if not parts:
+            continue
+        status_code = parts[0].strip()
+        if not status_code:
+            continue
+
+        action_char = status_code[0].upper()
+        if action_char in ("R", "C"):
+            if len(parts) >= 3:
+                old_p = parts[1].strip().strip('"')
+                new_p = parts[2].strip().strip('"')
+                changes.append(FileChange(action=action_char, path=new_p, old_path=old_p))
+            else:
+                logger.warning("Unrecognized rename/copy format: %s", line)
+        else:
+            if len(parts) >= 2:
+                p = parts[1].strip().strip('"')
+                changes.append(FileChange(action=action_char, path=p))
+            else:
+                logger.warning("Unrecognized status format: %s", line)
+    return changes
+
+
+def parse_name_status_z(null_output: str) -> List[FileChange]:
+    """Parse NUL-delimited output from `git diff -z --name-status`."""
+    changes: List[FileChange] = []
+    tokens = null_output.split("\0")
+    idx = 0
+    while idx < len(tokens):
+        token = tokens[idx].strip()
+        if not token:
+            idx += 1
+            continue
+
+        action_char = token[0].upper()
+        if action_char in ("R", "C"):
+            if idx + 2 < len(tokens):
+                old_p = tokens[idx + 1]
+                new_p = tokens[idx + 2]
+                changes.append(FileChange(action=action_char, path=new_p, old_path=old_p))
+                idx += 3
+            else:
+                break
+        else:
+            if idx + 1 < len(tokens):
+                p = tokens[idx + 1]
+                changes.append(FileChange(action=action_char, path=p))
+                idx += 2
+            else:
+                break
+    return changes
+
+
+class GitRepo:
+    """Wrapper around git commands for the source repository."""
+
+    def __init__(self, repo_dir: Path, git_bin: str = "git"):
+        self.repo_dir = repo_dir.resolve()
+        self.git_bin = git_bin
+
+    def run_cmd(self, args: List[str], check: bool = True) -> subprocess.CompletedProcess[str]:
+        cmd = [self.git_bin] + args
+        logger.debug("Executing Git command in %s: %s", self.repo_dir, " ".join(cmd))
+        return subprocess.run(
+            cmd,
+            cwd=self.repo_dir,
+            check=check,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+
+    def run_cmd_bytes(self, args: List[str], check: bool = True) -> subprocess.CompletedProcess[bytes]:
+        cmd = [self.git_bin] + args
+        logger.debug("Executing Git command (bytes) in %s: %s", self.repo_dir, " ".join(cmd))
+        return subprocess.run(
+            cmd,
+            cwd=self.repo_dir,
+            check=check,
+            capture_output=True,
+        )
+
+    def get_file_content_bytes(self, ref: str, path: Path) -> bytes:
+        """Extract exact binary content of a file from Git's object database at revision ref."""
+        ref_path = f"{ref}:{path.as_posix()}"
+        res = self.run_cmd_bytes(["show", ref_path])
+        return res.stdout
+
+    def get_file_mode(self, ref: str, path: Path) -> Optional[str]:
+        """Return the file mode (e.g. '100644', '100755', '120000') from git ls-tree."""
+        res = self.run_cmd(["ls-tree", ref, path.as_posix()], check=False)
+        if res.returncode == 0 and res.stdout.strip():
+            parts = res.stdout.strip().split()
+            if parts:
+                return parts[0]
+        return None
+
+    def is_valid_repo(self) -> bool:
+        try:
+            res = self.run_cmd(["rev-parse", "--is-inside-work-tree"], check=False)
+            return res.returncode == 0 and res.stdout.strip() == "true"
+        except Exception:
+            return False
+
+    def get_current_branch(self) -> str:
+        """Return the current branch name or 'HEAD (detached)'."""
+        res = self.run_cmd(["rev-parse", "--abbrev-ref", "HEAD"], check=False)
+        if res.returncode == 0:
+            branch = res.stdout.strip()
+            return branch if branch != "HEAD" else "HEAD (detached)"
+        return "unknown"
+
+    def get_head_commit(self) -> str:
+        """Return the short hash of HEAD."""
+        res = self.run_cmd(["rev-parse", "--short", "HEAD"], check=False)
+        if res.returncode == 0:
+            return res.stdout.strip()
+        return "unknown"
+
+    def get_commit_parent(self, commit_hash: str) -> Optional[str]:
+        """Return the parent commit hash, or None if root commit."""
+        res = self.run_cmd(["rev-parse", "--verify", f"{commit_hash}^"], check=False)
+        if res.returncode == 0:
+            return res.stdout.strip()
+        return None
+
+    def get_diff(self, ref_spec: str) -> str:
+        """Get unified diff for the given reference specification."""
+        res = self.run_cmd(["diff", "--binary", ref_spec])
+        return res.stdout
+
+    def get_diff_root(self, commit_hash: str) -> str:
+        """Get unified diff for a root commit."""
+        empty_tree_hash = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+        res = self.run_cmd(["diff", "--binary", empty_tree_hash, commit_hash])
+        return res.stdout
+
+    def get_name_status(self, ref_spec: str) -> List[FileChange]:
+        """Get list of changed files with their status."""
+        res = self.run_cmd(["diff", "-z", "--name-status", ref_spec])
+        return parse_name_status_z(res.stdout)
+
+    def get_name_status_root(self, commit_hash: str) -> List[FileChange]:
+        """Get list of changed files for a root commit."""
+        empty_tree_hash = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+        res = self.run_cmd(["diff", "-z", "--name-status", empty_tree_hash, commit_hash])
+        return parse_name_status_z(res.stdout)
+
+    def get_commit_message(self, commit_hash: str) -> str:
+        """Get the full commit message for the given commit hash."""
+        res = self.run_cmd(["log", "-1", "--format=%B", commit_hash])
+        return res.stdout.strip()
+
+    def get_commit_range(self, start_ref: str, end_ref: str) -> List[str]:
+        """Return list of commit hashes in chronological order (start_ref..end_ref)."""
+        res = self.run_cmd(["rev-list", "--reverse", "--topo-order", f"{start_ref}..{end_ref}"])
+        return [line.strip() for line in res.stdout.splitlines() if line.strip()]
+
+    def get_merge_commits(self, start_ref: str, end_ref: str) -> List[str]:
+        """Return list of merge commits in the range (start_ref..end_ref)."""
+        res = self.run_cmd(["rev-list", "--merges", f"{start_ref}..{end_ref}"])
+        return [line.strip() for line in res.stdout.splitlines() if line.strip()]
+
+    def get_tree_files(self, ref: str) -> List[Path]:
+        """Return list of all relative file paths at revision ref (from git ls-tree -r -z)."""
+        res = self.run_cmd_bytes(["ls-tree", "-r", "-z", "--name-only", ref])
+        raw_paths = res.stdout.split(b"\0")
+        files: List[Path] = []
+        for raw in raw_paths:
+            if not raw:
+                continue
+            path_str = raw.decode("utf-8", errors="replace")
+            files.append(Path(path_str))
+        return files
+
+    def get_config(self, key: str) -> Optional[str]:
+        """Read a configuration value from git config (local repository or global)."""
+        res = self.run_cmd(["config", "--get", key], check=False)
+        if res.returncode == 0 and res.stdout.strip():
+            return res.stdout.strip()
+        return None
+
+    def get_config_bool(self, key: str) -> Optional[bool]:
+        """Read a boolean configuration value from git config (--bool)."""
+        res = self.run_cmd(["config", "--bool", "--get", key], check=False)
+        if res.returncode == 0 and res.stdout.strip():
+            val = res.stdout.strip().lower()
+            return val in ("true", "yes", "on", "1")
+        return None
+
+    def set_config(self, key: str, value: str) -> None:
+        """Set a repository-level configuration value via git config <key> <value>."""
+        self.run_cmd(["config", key, value], check=True)
+
+    def get_local_branches(self) -> List[str]:
+        """Return list of local branch names."""
+        res = self.run_cmd(["for-each-ref", "--format=%(refname:short)", "refs/heads/"], check=False)
+        if res.returncode == 0:
+            return [line.strip() for line in res.stdout.splitlines() if line.strip()]
+        return []
+
+    def get_remote_branches(self) -> List[str]:
+        """Return list of remote branch names (e.g. 'origin/trunk', 'svn-mirror/trunk')."""
+        res = self.run_cmd(["for-each-ref", "--format=%(refname:short)", "refs/remotes/"], check=False)
+        if res.returncode == 0:
+            return [
+                line.strip() for line in res.stdout.splitlines() if line.strip() and not line.strip().endswith("/HEAD")
+            ]
+        return []

git2svn/patcher.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+import sys
+from pathlib import Path
+
+logger = logging.getLogger("git2svn")
+
+
+class Patcher:
+    """Wrapper to apply diffs using git apply."""
+
+    def __init__(self, target_dir: Path, git_bin: str = "git", dry_run: bool = False):
+        self.target_dir = target_dir.resolve()
+        self.git_bin = git_bin
+        self.dry_run = dry_run
+
+    def apply_diff(self, diff_content: str) -> None:
+        """Apply unified diff text to target_dir using git apply."""
+        if not diff_content.strip():
+            logger.info("Diff is empty. Nothing to patch.")
+            return
+
+        cmd = [self.git_bin, "apply", "--ignore-whitespace", "--unsafe-paths", "--reject"]
+        if self.dry_run:
+            print(f"[DRY-RUN] (in {self.target_dir}) {' '.join(cmd)} << EOF\n{diff_content.strip()[:200]}...\nEOF")
+            return
+
+        logger.debug("Applying patch to %s using %s", self.target_dir, " ".join(cmd))
+        proc = subprocess.run(
+            cmd,
+            cwd=self.target_dir,
+            input=diff_content,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+
+        if proc.returncode != 0:
+            logger.error(
+                "git apply failed with code %d:\nSTDOUT:\n%s\nSTDERR:\n%s", proc.returncode, proc.stdout, proc.stderr
+            )
+            print(f"Error: git apply failed (exit code {proc.returncode}).", file=sys.stderr)
+            if proc.stdout:
+                print(proc.stdout, file=sys.stderr)
+            if proc.stderr:
+                print(proc.stderr, file=sys.stderr)
+            print(
+                "Tip: Check for .rej reject files in the SVN workspace or use 'git2svn stage --copy' to copy files directly.",
+                file=sys.stderr,
+            )
+            raise subprocess.CalledProcessError(proc.returncode, cmd, proc.stdout, proc.stderr)
+        else:
+            if proc.stdout or proc.stderr:
+                msg = (proc.stdout + "\n" + proc.stderr).strip()
+                logger.info("Patch applied successfully:\n%s", msg)

git2svn/state.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger("git2svn")
+
+
+def get_replay_state_path(workspace_dir: Path) -> Path:
+    """Get the path to the replay state file inside .svn metadata or workspace root."""
+    svn_meta = workspace_dir / ".svn"
+    if svn_meta.is_dir():
+        return svn_meta / "git2svn-replay.json"
+    return workspace_dir / ".git2svn-replay.json"
+
+
+def save_replay_state(workspace_dir: Path, data: Dict[str, Any]) -> None:
+    """Save replay state to disk."""
+    path = get_replay_state_path(workspace_dir)
+    path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+
+def load_replay_state(workspace_dir: Path) -> Optional[Dict[str, Any]]:
+    """Load replay state from disk if it exists."""
+    path = get_replay_state_path(workspace_dir)
+    if path.is_file():
+        try:
+            return json.loads(path.read_text(encoding="utf-8"))
+        except Exception as e:
+            logger.error("Failed to parse replay state file: %s", e)
+    return None
+
+
+def clear_replay_state(workspace_dir: Path) -> None:
+    """Remove the replay state file if it exists."""
+    path = get_replay_state_path(workspace_dir)
+    if path.is_file():
+        path.unlink(missing_ok=True)
+
+
+def find_conflict_artifacts(workspace_dir: Path) -> List[Path]:
+    """Find all .rej and .orig files in workspace_dir (ignoring .svn)."""
+    artifacts: List[Path] = []
+    for root, dirs, files in os.walk(workspace_dir):
+        if ".svn" in dirs:
+            dirs.remove(".svn")
+        for f in files:
+            if f.endswith(".rej") or f.endswith(".orig"):
+                artifacts.append(Path(root) / f)
+    return artifacts
+
+
+def clean_conflict_artifacts(workspace_dir: Path) -> List[Path]:
+    """Remove all .rej and .orig files in workspace_dir."""
+    artifacts = find_conflict_artifacts(workspace_dir)
+    for a in artifacts:
+        try:
+            a.unlink(missing_ok=True)
+            logger.debug("Removed conflict artifact: %s", a)
+        except OSError:
+            pass
+    return artifacts

git2svn/svn.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from .git import FileChange
+
+logger = logging.getLogger("git2svn")
+
+
+def find_svn_binary() -> str:
+    """Find svn executable, checking TortoiseSVN / SlikSVN default paths if on Windows."""
+    found = shutil.which("svn")
+    if found:
+        return found
+    if sys.platform == "win32":
+        candidates = [
+            Path("C:/Program Files/TortoiseSVN/bin/svn.exe"),
+            Path("C:/Program Files (x86)/TortoiseSVN/bin/svn.exe"),
+            Path("C:/Program Files/SlikSvn/bin/svn.exe"),
+            Path("C:/Program Files (x86)/SlikSvn/bin/svn.exe"),
+        ]
+        for c in candidates:
+            if c.is_file():
+                return str(c)
+    return "svn"
+
+
+class SvnWorkspace:
+    """Wrapper around SVN commands and filesystem staging operations."""
+
+    def __init__(self, workspace_dir: Path, svn_bin: Optional[str] = None, dry_run: bool = False):
+        self.workspace_dir = workspace_dir.resolve()
+        self.svn_bin = svn_bin or find_svn_binary()
+        self.dry_run = dry_run
+
+    def run_cmd(self, args: List[str], check: bool = True) -> subprocess.CompletedProcess[str]:
+        cmd = [self.svn_bin] + args
+        if self.dry_run:
+            print(f"[DRY-RUN] (in {self.workspace_dir}) {' '.join(cmd)}")
+            return subprocess.CompletedProcess(cmd, 0, stdout="", stderr="")
+
+        logger.debug("Executing SVN command in %s: %s", self.workspace_dir, " ".join(cmd))
+        return subprocess.run(
+            cmd,
+            cwd=self.workspace_dir,
+            check=check,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+
+    def is_valid_workspace(self) -> bool:
+        """Check if workspace directory exists and has .svn or svn info."""
+        if not self.workspace_dir.is_dir():
+            return False
+        if (self.workspace_dir / ".svn").exists():
+            return True
+        try:
+            res = self.run_cmd(["info"], check=False)
+            return res.returncode == 0
+        except Exception:
+            return False
+
+    def get_info(self) -> Dict[str, str]:
+        """Return key-value mapping of 'svn info' output."""
+        info: Dict[str, str] = {}
+        res = self.run_cmd(["info"], check=False)
+        if res.returncode == 0:
+            for line in res.stdout.splitlines():
+                if ":" in line:
+                    k, v = line.split(":", 1)
+                    info[k.strip()] = v.strip()
+        return info
+
+    def is_clean(self) -> bool:
+        """Check if SVN workspace has no uncommitted changes."""
+        res = self.run_cmd(["status", "-q"], check=False)
+        return not bool(res.stdout.strip())
+
+    def get_versioned_files(self) -> List[Path]:
+        """
+        Return list of all versioned file paths in the SVN workspace (relative to workspace_dir).
+        Queries 'svn status -v -q --depth infinity' (ignores unversioned files and directories).
+        Falls back to filesystem scan (excluding .svn) if svn command fails or workspace is empty.
+        """
+        files: List[Path] = []
+        res = self.run_cmd(["status", "-v", "-q", "--depth", "infinity"], check=False)
+        if res.returncode == 0 and res.stdout.strip():
+            for line in res.stdout.splitlines():
+                parts = line.strip().split()
+                if not parts:
+                    continue
+                target_str = parts[-1]
+                target_path = Path(target_str)
+                if target_path.is_absolute():
+                    try:
+                        rel = target_path.relative_to(self.workspace_dir)
+                    except ValueError:
+                        continue
+                else:
+                    rel = target_path
+
+                full_path = self.workspace_dir / rel
+                if str(rel) != "." and (full_path.is_file() or full_path.is_symlink() or not full_path.exists()):
+                    files.append(rel)
+            return files
+
+        # Filesystem fallback if not in a working copy or status was empty
+        for root, dirs, f_list in os.walk(self.workspace_dir):
+            if ".svn" in dirs:
+                dirs.remove(".svn")
+            for f in f_list:
+                full = Path(root) / f
+                try:
+                    files.append(full.relative_to(self.workspace_dir))
+                except ValueError:
+                    pass
+        return files
+
+    def revert_all(self) -> None:
+        """Revert all uncommitted changes in the workspace."""
+        logger.info("Reverting SVN workspace changes...")
+        self.run_cmd(["revert", "-R", "."], check=False)
+
+    def stage_add(self, rel_path: Path) -> None:
+        """Run svn add <filepath> --parents. Creates parent directories if needed."""
+        target_path = self.workspace_dir / rel_path
+        if not self.dry_run:
+            target_path.parent.mkdir(parents=True, exist_ok=True)
+        else:
+            print(f"[DRY-RUN] Ensure parent directory exists: {target_path.parent}")
+
+        posix_path = rel_path.as_posix()
+        res = self.run_cmd(["add", posix_path, "--parents"], check=False)
+        if res.returncode != 0:
+            if "is already under version control" not in res.stderr and "already exists" not in res.stderr:
+                logger.error("Failed to 'svn add %s': %s", posix_path, res.stderr.strip())
+                raise subprocess.CalledProcessError(
+                    res.returncode, [self.svn_bin, "add", posix_path], res.stdout, res.stderr
+                )
+
+    def stage_rm(self, rel_path: Path) -> None:
+        """Run svn rm <filepath>."""
+        posix_path = rel_path.as_posix()
+        res = self.run_cmd(["rm", posix_path], check=False)
+        if res.returncode != 0:
+            if "is not under version control" in res.stderr:
+                logger.warning("File %s not under SVN control to remove.", posix_path)
+            else:
+                logger.error("Failed to 'svn rm %s': %s", posix_path, res.stderr.strip())
+                raise subprocess.CalledProcessError(
+                    res.returncode, [self.svn_bin, "rm", posix_path], res.stdout, res.stderr
+                )
+
+    def commit(self, message: str) -> None:
+        """Run svn commit using a temporary file with -F to support arbitrary message lengths and encodings."""
+        if self.dry_run:
+            print(f"[DRY-RUN] (in {self.workspace_dir}) {self.svn_bin} commit -F <msg_file>")
+            return
+
+        logger.info("Executing svn commit in %s...", self.workspace_dir)
+        with tempfile.NamedTemporaryFile("w", encoding="utf-8", delete=False) as tf:
+            tf.write(message)
+            tf_path = Path(tf.name)
+
+        try:
+            res = self.run_cmd(["commit", "-F", str(tf_path)], check=False)
+            if res.returncode != 0:
+                logger.error("Failed to 'svn commit': %s", res.stderr.strip())
+                raise subprocess.CalledProcessError(
+                    res.returncode, [self.svn_bin, "commit", "-F", str(tf_path)], res.stdout, res.stderr
+                )
+            if res.stdout:
+                logger.info("SVN commit output:\n%s", res.stdout.strip())
+        finally:
+            tf_path.unlink(missing_ok=True)
+
+    def apply_structural_changes(self, changes: List[FileChange]) -> None:
+        """
+        Execute corresponding SVN commands for file changes:
+        - Added (A): Run svn add <filepath> --parents
+        - Deleted (D): Run svn rm <filepath>
+        - Modified (M): No SVN structural command needed
+        - Renamed (R): svn rm <old_name> and svn add <new_name> --parents
+        - Copied (C): svn add <new_name> --parents
+        """
+        for change in changes:
+            if change.is_deleted:
+                logger.info("SVN staging delete: %s", change.path)
+                self.stage_rm(change.path)
+            elif change.is_renamed:
+                assert change.old_path is not None
+                logger.info("SVN staging rename: %s -> %s", change.old_path, change.path)
+                self.stage_rm(change.old_path)
+                self.stage_add(change.path)
+            elif change.is_copied:
+                logger.info("SVN staging copied file: %s", change.path)
+                self.stage_add(change.path)
+            elif change.is_added:
+                logger.info("SVN staging add: %s", change.path)
+                self.stage_add(change.path)
+            elif change.is_modified:
+                logger.debug("Modified file requires no SVN structural command: %s", change.path)
+
+    def update(self) -> None:
+        """Run svn update on the working copy to bump the working base revision to HEAD."""
+        if self.dry_run:
+            print(f"[DRY-RUN] (in {self.workspace_dir}) {self.svn_bin} update")
+            return
+
+        logger.info("Executing svn update in %s...", self.workspace_dir)
+        res = self.run_cmd(["update"], check=False)
+        if res.returncode != 0:
+            logger.error("Failed to 'svn update': %s", res.stderr.strip())
+            raise subprocess.CalledProcessError(res.returncode, [self.svn_bin, "update"], res.stdout, res.stderr)
+        if res.stdout:
+            logger.info("SVN update output:\n%s", res.stdout.strip())