path-sync 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

path_sync/cmd_validate.py

@@ -1,51 +0,0 @@
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-
-import typer
-
-from path_sync import git_ops
-from path_sync.models import find_repo_root
-from path_sync.typer_app import app
-from path_sync.validation import parse_skip_sections, validate_no_unauthorized_changes
-
-logger = logging.getLogger(__name__)
-
-
-@app.command("validate-no-changes")
-def validate_no_changes(
-    branch: str = typer.Option(
-        "main", "-b", "--branch", help="Default branch to compare against"
-    ),
-    skip_sections_opt: str = typer.Option(
-        "",
-        "--skip-sections",
-        help="Comma-separated path:section_id pairs to skip (e.g., 'justfile:coverage,pyproject.toml:default')",
-    ),
-) -> None:
-    """Validate no unauthorized changes to synced files."""
-    repo_root = find_repo_root(Path.cwd())
-    repo = git_ops.get_repo(repo_root)
-
-    current_branch = repo.active_branch.name
-    if current_branch.startswith("sync/"):
-        logger.info(f"On sync branch {current_branch}, validation skipped")
-        return
-    if current_branch == branch:
-        logger.info(f"On default branch {branch}, validation skipped")
-        return
-
-    skip_sections = (
-        parse_skip_sections(skip_sections_opt) if skip_sections_opt else None
-    )
-    unauthorized = validate_no_unauthorized_changes(repo_root, branch, skip_sections)
-
-    if unauthorized:
-        files_list = "\n  ".join(unauthorized)
-        logger.error(
-            f"Unauthorized changes in {len(unauthorized)} files:\n  {files_list}"
-        )
-        raise typer.Exit(1)
-
-    logger.info("Validation passed: no unauthorized changes")

path_sync/conftest.py

@@ -1,15 +0,0 @@
-import pytest
-from git import Repo
-
-
-@pytest.fixture
-def tmp_repo(tmp_path):
-    """Create a temporary git repo."""
-
-    repo_path = tmp_path / "repo"
-    repo_path.mkdir()
-    repo = Repo.init(repo_path)
-    (repo_path / ".gitkeep").write_text("")
-    repo.index.add([".gitkeep"])
-    repo.index.commit("Initial commit")
-    return repo_path

path_sync/file_utils.py

@@ -1,7 +0,0 @@
-from pathlib import Path
-
-
-def ensure_parents_write_text(path: Path | str, text: str) -> None:
-    path = Path(path)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(text)

path_sync/git_ops.py

@@ -1,188 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-import subprocess
-from contextlib import suppress
-from pathlib import Path
-
-from git import GitCommandError, InvalidGitRepositoryError, NoSuchPathError, Repo
-
-logger = logging.getLogger(__name__)
-
-
-def _auth_url(url: str) -> str:
-    """Inject GH_TOKEN into HTTPS URL for authentication."""
-    token = os.environ.get("GH_TOKEN", "")
-    if not token:
-        return url
-    if url.startswith("https://github.com/"):
-        return url.replace("https://", f"https://x-access-token:{token}@")
-    return url
-
-
-def get_repo(path: Path) -> Repo:
-    try:
-        return Repo(path)
-    except InvalidGitRepositoryError as e:
-        raise ValueError(f"Not a git repository: {path}") from e
-
-
-def is_git_repo(path: Path) -> bool:
-    with suppress(InvalidGitRepositoryError, NoSuchPathError):
-        Repo(path)
-        return True
-    return False
-
-
-def get_default_branch(repo: Repo) -> str:
-    with suppress(GitCommandError):
-        return repo.git.symbolic_ref("refs/remotes/origin/HEAD", short=True).replace(
-            "origin/", ""
-        )
-    return "main"
-
-
-def clone_repo(url: str, dest: Path) -> Repo:
-    logger.info(f"Cloning {url} to {dest}")
-    dest.parent.mkdir(parents=True, exist_ok=True)
-    return Repo.clone_from(_auth_url(url), str(dest))
-
-
-def checkout_branch(repo: Repo, branch: str) -> None:
-    current = repo.active_branch.name
-    if current == branch:
-        return
-    logger.info(f"Checking out {branch}")
-    try:
-        repo.git.checkout(branch)
-    except GitCommandError:
-        repo.git.checkout("-b", branch)
-
-
-def prepare_copy_branch(
-    repo: Repo, default_branch: str, copy_branch: str, from_default: bool = False
-) -> None:
-    """Prepare copy_branch for syncing.
-
-    Args:
-        from_default: If True, fetch origin and reset to origin/default_branch
-                      before creating copy_branch. Use in CI for clean state.
-                      If False, just switch to or create copy_branch from current HEAD.
-    """
-    if from_default:
-        logger.info("Fetching origin")
-        repo.git.fetch("origin")
-
-        logger.info(f"Checking out {default_branch}")
-        repo.git.checkout(default_branch)
-        repo.git.reset("--hard", f"origin/{default_branch}")
-
-        with suppress(GitCommandError):
-            repo.git.branch("-D", copy_branch)
-            logger.info(f"Deleted existing local branch: {copy_branch}")
-
-        logger.info(f"Creating fresh branch: {copy_branch}")
-        repo.git.checkout("-b", copy_branch)
-    else:
-        checkout_branch(repo, copy_branch)
-
-
-def get_current_sha(repo: Repo) -> str:
-    return repo.head.commit.hexsha
-
-
-def get_remote_url(repo: Repo, remote_name: str = "origin") -> str:
-    try:
-        return repo.remote(remote_name).url
-    except ValueError:
-        return ""
-
-
-def has_changes(repo: Repo) -> bool:
-    return repo.is_dirty() or len(repo.untracked_files) > 0
-
-
-def commit_changes(repo: Repo, message: str) -> None:
-    repo.git.add("-A")
-    if repo.is_dirty():
-        _ensure_git_user(repo)
-        repo.git.commit("-m", message)
-        logger.info(f"Committed: {message}")
-
-
-def _ensure_git_user(repo: Repo) -> None:
-    """Configure git user if not already set."""
-    try:
-        repo.config_reader().get_value("user", "name")
-    except Exception:
-        repo.config_writer().set_value("user", "name", "path-sync[bot]").release()
-        repo.config_writer().set_value(
-            "user", "email", "path-sync[bot]@users.noreply.github.com"
-        ).release()
-
-
-def push_branch(repo: Repo, branch: str, force: bool = True) -> None:
-    logger.info(f"Pushing {branch}" + (" (force)" if force else ""))
-    args = ["--force", "-u", "origin", branch] if force else ["-u", "origin", branch]
-    repo.git.push(*args)
-
-
-def update_pr_body(repo_path: Path, branch: str, body: str) -> bool:
-    cmd = ["gh", "pr", "edit", branch, "--body", body]
-    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
-    if result.returncode != 0:
-        logger.warning(f"Failed to update PR body: {result.stderr}")
-        return False
-    logger.info("Updated PR body")
-    return True
-
-
-def create_or_update_pr(
-    repo_path: Path,
-    branch: str,
-    title: str,
-    body: str = "",
-    labels: list[str] | None = None,
-    reviewers: list[str] | None = None,
-    assignees: list[str] | None = None,
-) -> str:
-    cmd = ["gh", "pr", "create", "--head", branch, "--title", title]
-    cmd.extend(["--body", body or ""])
-    if labels:
-        cmd.extend(["--label", ",".join(labels)])
-    if reviewers:
-        cmd.extend(["--reviewer", ",".join(reviewers)])
-    if assignees:
-        cmd.extend(["--assignee", ",".join(assignees)])
-
-    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
-    if result.returncode != 0:
-        if "already exists" in result.stderr:
-            logger.info("PR already exists, updating body")
-            update_pr_body(repo_path, branch, body)
-            return ""
-        raise RuntimeError(f"Failed to create PR: {result.stderr}")
-    logger.info(f"Created PR: {result.stdout.strip()}")
-    return result.stdout.strip()
-
-
-def file_has_git_changes(repo: Repo, file_path: Path, base_ref: str = "HEAD") -> bool:
-    rel_path = str(file_path.relative_to(repo.working_dir))
-    diff = repo.git.diff("--name-only", base_ref, "--", rel_path)
-    return bool(diff.strip())
-
-
-def get_changed_files(repo: Repo, base_ref: str = "HEAD") -> list[Path]:
-    diff = repo.git.diff("--name-only", base_ref)
-    if not diff.strip():
-        return []
-    repo_root = Path(repo.working_dir)
-    return [repo_root / p for p in diff.strip().split("\n")]
-
-
-def get_file_content_at_ref(repo: Repo, file_path: Path, ref: str) -> str | None:
-    rel_path = str(file_path.relative_to(repo.working_dir))
-    with suppress(GitCommandError):
-        return repo.git.show(f"{ref}:{rel_path}")
-    return None

path_sync/header.py

@@ -1,80 +0,0 @@
-from __future__ import annotations
-
-import re
-from pathlib import Path
-
-from path_sync.models import (
-    DEFAULT_COMMENT_PREFIXES,
-    DEFAULT_COMMENT_SUFFIXES,
-    HEADER_TEMPLATE,
-    HeaderConfig,
-)
-
-COMMENT_PREFIXES = DEFAULT_COMMENT_PREFIXES
-
-HEADER_PATTERN = re.compile(r"path-sync copy -n (?P<config_name>[\w-]+)")
-
-
-def get_header_line(
-    extension: str,
-    config_name: str,
-    config: HeaderConfig | None = None,
-) -> str:
-    if config:
-        prefix = config.comment_prefixes.get(extension, "")
-        suffix = config.comment_suffixes.get(extension, "")
-    else:
-        prefix = DEFAULT_COMMENT_PREFIXES.get(extension, "")
-        suffix = DEFAULT_COMMENT_SUFFIXES.get(extension, "")
-
-    if not prefix:
-        raise ValueError(f"No comment prefix found for extension: {extension}")
-    header_text = HEADER_TEMPLATE.format(config_name=config_name)
-    return f"{prefix} {header_text}{suffix}"
-
-
-def has_header(content: str) -> bool:
-    first_line = content.split("\n", 1)[0] if content else ""
-    return bool(HEADER_PATTERN.search(first_line))
-
-
-def get_config_name(content: str) -> str | None:
-    first_line = content.split("\n", 1)[0] if content else ""
-    if match := HEADER_PATTERN.search(first_line):
-        return match.group("config_name")
-    return None
-
-
-def add_header(
-    content: str,
-    extension: str,
-    config_name: str,
-    config: HeaderConfig | None = None,
-) -> str:
-    header = get_header_line(extension, config_name, config)
-    return f"{header}\n{content}"
-
-
-def remove_header(content: str) -> str:
-    if not has_header(content):
-        return content
-    lines = content.split("\n", 1)
-    return lines[1] if len(lines) > 1 else ""
-
-
-def file_get_config_name(path: Path) -> str | None:
-    """Read first line and extract config name if present."""
-    if not path.exists() or path.suffix not in DEFAULT_COMMENT_PREFIXES:
-        return None
-    try:
-        with path.open() as f:
-            first_line = f.readline()
-    except (UnicodeDecodeError, OSError):
-        return None
-    return get_config_name(first_line)
-
-
-def file_has_header(path: Path, config: HeaderConfig | None = None) -> bool:
-    if config and path.suffix not in config.comment_prefixes:
-        return False
-    return file_get_config_name(path) is not None

path_sync/header_test.py

@@ -1,41 +0,0 @@
-from path_sync import header
-
-
-def test_header_generation():
-    assert header.get_header_line(".py", "my-config") == "# path-sync copy -n my-config"
-    assert (
-        header.get_header_line(".go", "my-config") == "// path-sync copy -n my-config"
-    )
-    assert (
-        header.get_header_line(".md", "my-config")
-        == "<!-- path-sync copy -n my-config -->"
-    )
-
-
-def test_has_header_matches_any_config_name():
-    assert header.has_header("# path-sync copy -n my-config\ncode")
-    assert header.has_header("# path-sync copy -n other_name\ncode")
-    assert not header.has_header("# DO NOT EDIT: path-sync destination file\ncode")
-    assert not header.has_header("print('hello')")
-
-
-def test_add_remove_header():
-    content = "print('hello')"
-    with_header = header.add_header(content, ".py", "test-config")
-    assert header.has_header(with_header)
-    without = header.remove_header(with_header)
-    assert without == content
-
-
-def test_file_has_header(tmp_path):
-    py_file = tmp_path / "test.py"
-    py_file.write_text(header.add_header("content", ".py", "my-config"))
-    assert header.file_has_header(py_file)
-
-    no_header = tmp_path / "plain.py"
-    no_header.write_text("content")
-    assert not header.file_has_header(no_header)
-
-    unsupported = tmp_path / "data.whl"
-    unsupported.write_bytes(b"\x00\x01\x02\x03")
-    assert not header.file_has_header(unsupported)

path_sync/models.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import glob as glob_mod
-from pathlib import Path
-from typing import ClassVar
-
-from pydantic import BaseModel, Field
-
-LOG_FORMAT = "%(asctime)s %(levelname)s %(message)s"
-
-
-class PathMapping(BaseModel):
-    src_path: str
-    dest_path: str = ""
-
-    def resolved_dest_path(self) -> str:
-        return self.dest_path or self.src_path
-
-    def expand_dest_paths(self, repo_root: Path) -> list[Path]:
-        dest_path = self.resolved_dest_path()
-        pattern = repo_root / dest_path
-
-        if "*" in dest_path:
-            return [Path(p) for p in glob_mod.glob(str(pattern), recursive=True)]
-        if pattern.is_dir():
-            return [p for p in pattern.rglob("*") if p.is_file()]
-        if pattern.exists():
-            return [pattern]
-        return []
-
-
-HEADER_TEMPLATE = "path-sync copy -n {config_name}"
-DEFAULT_COMMENT_PREFIXES: dict[str, str] = {
-    ".py": "#",
-    ".sh": "#",
-    ".yaml": "#",
-    ".yml": "#",
-    ".go": "//",
-    ".js": "//",
-    ".ts": "//",
-    ".md": "<!--",
-    ".mdc": "<!--",
-    ".html": "<!--",
-}
-DEFAULT_COMMENT_SUFFIXES: dict[str, str] = {
-    ".md": " -->",
-    ".mdc": " -->",
-    ".html": " -->",
-}
-
-
-class HeaderConfig(BaseModel):
-    comment_prefixes: dict[str, str] = Field(
-        default_factory=DEFAULT_COMMENT_PREFIXES.copy
-    )
-    comment_suffixes: dict[str, str] = Field(
-        default_factory=DEFAULT_COMMENT_SUFFIXES.copy
-    )
-
-
-DEFAULT_BODY_TEMPLATE = """\
-Synced from [{src_repo_name}]({src_repo_url}) @ `{src_sha_short}`
-
-<details>
-<summary>Sync Log</summary>
-
-```
-{sync_log}
-```
-
-</details>
-"""
-
-
-class PRDefaults(BaseModel):
-    title: str = "chore: sync {name} files"
-    body_template: str = DEFAULT_BODY_TEMPLATE
-    body_suffix: str = ""
-    labels: list[str] = Field(default_factory=list)
-    reviewers: list[str] = Field(default_factory=list)
-    assignees: list[str] = Field(default_factory=list)
-
-    def format_body(
-        self,
-        src_repo_url: str,
-        src_sha: str,
-        sync_log: str,
-        dest_name: str,
-    ) -> str:
-        src_repo_name = src_repo_url.rstrip("/").rsplit("/", 1)[-1].removesuffix(".git")
-        body = self.body_template.format(
-            src_repo_url=src_repo_url,
-            src_repo_name=src_repo_name,
-            src_sha=src_sha,
-            src_sha_short=src_sha[:8],
-            sync_log=sync_log,
-            dest_name=dest_name,
-        )
-        if self.body_suffix:
-            body = f"{body}\n---\n{self.body_suffix}"
-        return body
-
-
-class Destination(BaseModel):
-    name: str
-    repo_url: str = ""
-    dest_path_relative: str
-    copy_branch: str = "sync/path-sync"
-    default_branch: str = "main"
-    skip_sections: dict[str, list[str]] = Field(default_factory=dict)
-
-
-class SrcConfig(BaseModel):
-    CONFIG_EXT: ClassVar[str] = ".src.yaml"
-
-    name: str
-    git_remote: str = "origin"
-    src_repo_url: str = ""
-    schedule: str = "0 6 * * *"
-    header_config: HeaderConfig = Field(default_factory=HeaderConfig)
-    pr_defaults: PRDefaults = Field(default_factory=PRDefaults)
-    paths: list[PathMapping] = Field(default_factory=list)
-    destinations: list[Destination] = Field(default_factory=list)
-
-    def find_destination(self, name: str) -> Destination:
-        for dest in self.destinations:
-            if dest.name == name:
-                return dest
-        raise ValueError(f"Destination not found: {name}")
-
-
-def resolve_config_path(repo_root: Path, name: str) -> Path:
-    return repo_root / ".github" / f"{name}{SrcConfig.CONFIG_EXT}"
-
-
-def find_repo_root(start_path: Path) -> Path:
-    current = start_path.resolve()
-    while current != current.parent:
-        if (current / ".git").exists():
-            return current
-        current = current.parent
-    raise ValueError(f"No git repository found from {start_path}")

path_sync/models_test.py

@@ -1,69 +0,0 @@
-from path_sync.models import (
-    Destination,
-    PathMapping,
-    PRDefaults,
-    SrcConfig,
-    find_repo_root,
-    resolve_config_path,
-)
-
-
-def test_path_mapping_resolved():
-    m1 = PathMapping(src_path="src/file.py")
-    assert m1.resolved_dest_path() == "src/file.py"
-
-    m2 = PathMapping(src_path="src/file.py", dest_path="dest/file.py")
-    assert m2.resolved_dest_path() == "dest/file.py"
-
-
-def test_resolve_config_path(tmp_path):
-    src_path = resolve_config_path(tmp_path, "sdlc")
-    assert src_path == tmp_path / ".github" / "sdlc.src.yaml"
-
-
-def test_find_repo_root(tmp_repo):
-    subdir = tmp_repo / "a" / "b"
-    subdir.mkdir(parents=True)
-    found = find_repo_root(subdir)
-    assert found == tmp_repo
-
-
-def test_src_config_find_destination():
-    config = SrcConfig(
-        name="test",
-        destinations=[
-            Destination(name="repo1", dest_path_relative="../repo1"),
-            Destination(name="repo2", dest_path_relative="../repo2"),
-        ],
-    )
-    dest = config.find_destination("repo1")
-    assert dest.name == "repo1"
-
-
-def test_destination_skip_sections():
-    dest = Destination(
-        name="test",
-        dest_path_relative="../test",
-        skip_sections={"justfile": ["pkg-ext"], "pyproject.toml": ["coverage"]},
-    )
-    assert dest.skip_sections["justfile"] == ["pkg-ext"]
-    assert dest.skip_sections.get("unknown", []) == []
-
-
-def test_pr_defaults_format_body():
-    pr = PRDefaults()
-    body = pr.format_body(
-        src_repo_url="https://github.com/user/my-repo",
-        src_sha="abc12345def67890",
-        sync_log="INFO Wrote: file.py",
-        dest_name="dest1",
-    )
-    assert "[my-repo](https://github.com/user/my-repo)" in body
-    assert "`abc12345`" in body
-    assert "INFO Wrote: file.py" in body
-
-
-def test_pr_defaults_format_body_extracts_repo_name():
-    pr = PRDefaults(body_template="{src_repo_name}")
-    assert pr.format_body("https://github.com/u/repo", "sha", "", "") == "repo"
-    assert pr.format_body("https://github.com/u/repo.git", "sha", "", "") == "repo"