before-push 0.1.0__tar.gz

before_push-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: before-push
+Version: 0.1.0
+Summary: A small CLI that checks your current Git branch before you push or open a pull request.
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: rich>=15.0.0
+
+## BeforePush

before_push-0.1.0/README.md

@@ -0,0 +1 @@
+## BeforePush

before_push-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "before-push"
+version = "0.1.0"
+description = "A small CLI that checks your current Git branch before you push or open a pull request."
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "rich>=15.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]
+
+[project.scripts]
+beforepush = "cli:main"
+
+[tool.uv]
+package = true

before_push-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

before_push-0.1.0/src/before_push.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: before-push
+Version: 0.1.0
+Summary: A small CLI that checks your current Git branch before you push or open a pull request.
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: rich>=15.0.0
+
+## BeforePush

before_push-0.1.0/src/before_push.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/checks.py
+src/cli.py
+src/git.py
+src/output.py
+src/before_push.egg-info/PKG-INFO
+src/before_push.egg-info/SOURCES.txt
+src/before_push.egg-info/dependency_links.txt
+src/before_push.egg-info/entry_points.txt
+src/before_push.egg-info/requires.txt
+src/before_push.egg-info/top_level.txt
+tests/test_check.py
+tests/test_cli.py
+tests/test_git.py

before_push-0.1.0/src/before_push.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

before_push-0.1.0/src/before_push.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+beforepush = cli:main

before_push-0.1.0/src/before_push.egg-info/requires.txt

@@ -0,0 +1 @@
+rich>=15.0.0

before_push-0.1.0/src/before_push.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+checks
+cli
+git
+output

before_push-0.1.0/src/checks.py

@@ -0,0 +1,147 @@
+from dataclasses import dataclass
+from enum import Enum
+
+import git
+
+
+class CheckStatus(Enum):
+    PASS = "pass"
+    WARNING = "warning"
+    FAIL = "fail"
+
+# Check result data class
+@dataclass
+class CheckResult:
+    name: str
+    status: CheckStatus
+    message: str
+
+
+def check_git_repository() -> CheckResult:
+    """Check whether the current directory is a Git repository."""
+    if git.is_git_repository():
+        return CheckResult(
+            name="Git repository",
+            status=CheckStatus.PASS,
+            message="Current directory is a Git repository.",
+        )
+
+    return CheckResult(
+        name="Git repository",
+        status=CheckStatus.FAIL,
+        message="Current directory is not a Git repository.",
+    )
+
+
+def check_current_branch() -> CheckResult:
+    """Check whether a branch is currently checked out."""
+    try:
+        branch = git.get_current_branch()
+    except RuntimeError:
+        return CheckResult(
+            name="Current branch",
+            status=CheckStatus.FAIL,
+            message="Could not determine the current branch.",
+        )
+
+    if branch:
+        return CheckResult(
+            name="Current branch",
+            status=CheckStatus.PASS,
+            message=f"Currently on '{branch}'.",
+        )
+
+    return CheckResult(
+        name="Current branch",
+        status=CheckStatus.FAIL,
+        message="No branch is currently checked out.",
+    )
+
+
+def check_working_tree() -> CheckResult:
+    """Check whether the working tree is clean."""
+    try:
+        has_changes = git.has_changes()
+    except RuntimeError:
+        return CheckResult(
+            name="Working tree",
+            status=CheckStatus.FAIL,
+            message="Could not read the Git working tree.",
+        )
+
+    if not has_changes:
+        return CheckResult(
+            name="Working tree",
+            status=CheckStatus.PASS,
+            message="Working tree is clean.",
+        )
+
+    return CheckResult(
+        name="Working tree",
+        status=CheckStatus.FAIL,
+        message="Uncommitted or untracked changes detected.",
+    )
+
+def check_upstream_branch() -> CheckResult:
+    """Check whether the current branch has an upstream branch."""
+    try:
+        upstream = git.get_upstream_branch()
+    except RuntimeError:
+        return CheckResult(
+            name="Upstream branch",
+            status=CheckStatus.WARNING,
+            message="No upstream branch configured.",
+        )
+
+    return CheckResult(
+        name="Upstream branch",
+        status=CheckStatus.PASS,
+        message=f"Tracking '{upstream}'.",
+    )
+
+def check_target_branch(target: str) -> CheckResult:
+    """Check whether the current branch is behind the target branch."""
+    try:
+        current_branch = git.get_current_branch()
+       
+
+        if current_branch == target:
+            return CheckResult(
+                name="Target branch",
+                status=CheckStatus.PASS,
+                message=f"Currently on target branch '{target}'.",
+            )
+
+        behind = git.get_behind_count(target)
+
+    except RuntimeError:
+        return CheckResult(
+            name="Target branch",
+            status=CheckStatus.FAIL,
+            message=f"Could not compare with '{target}'.",
+        )
+
+    if behind == 0:
+        return CheckResult(
+            name="Target branch",
+            status=CheckStatus.PASS,
+            message=f"Branch is up to date with {target}.",
+        )
+    commit_word = "commit" if behind == 1 else "commits"
+    return CheckResult(
+        name="Target branch",
+        status=CheckStatus.FAIL,
+        message=f"Branch is {behind} {commit_word} behind {target}. "
+                f"Update your branch before opening a PR.",
+    )
+
+
+def run_checks(target: str) -> list[CheckResult]:
+    """Run all repository readiness checks."""
+    return [
+        check_git_repository(),
+        check_current_branch(),
+        check_working_tree(),
+        check_upstream_branch(),
+        check_target_branch(target),
+    ]

before_push-0.1.0/src/cli.py

@@ -0,0 +1,25 @@
+import argparse
+
+from checks import run_checks
+from output import display_results
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Check whether your Git branch is ready before pushing or opening a PR."
+    )
+
+    parser.add_argument(
+        "--target",
+        default="main",
+        help="Target branch to compare against (default: main)",
+    )
+
+    args = parser.parse_args()
+
+    results = run_checks(args.target)
+    display_results(results, args.target)
+
+
+if __name__ == "__main__":
+    main()

before_push-0.1.0/src/git.py

@@ -0,0 +1,60 @@
+import subprocess
+
+
+def run_git_command(*args: str) -> str:
+    """Run a Git command and return its output."""
+    result = subprocess.run(
+        ["git", *args],
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        raise RuntimeError(result.stderr.strip())
+
+    return result.stdout.strip()
+
+
+def is_git_repository() -> bool:
+    """Check whether the current directory is a Git repository."""
+    result = subprocess.run(
+        ["git", "rev-parse", "--is-inside-work-tree"],
+        capture_output=True,
+        text=True,
+    )
+
+    return result.returncode == 0 and result.stdout.strip() == "true"
+
+
+def get_current_branch() -> str:
+    """Get the current branch name."""
+    return run_git_command("branch", "--show-current")
+
+
+def get_status() -> str:
+    """Get the repository status in porcelain format."""
+    return run_git_command("status", "--porcelain")
+
+
+def has_changes() -> bool:
+    """Check whether the working tree contains changes."""
+    return bool(get_status())
+
+def get_upstream_branch() -> str:
+    """Get the upstream branch configured for the current branch."""
+    return run_git_command(
+        "rev-parse",
+        "--abbrev-ref",
+        "--symbolic-full-name",
+        "@{u}",
+    )
+
+def get_behind_count(target: str) -> int:
+    """Return the number of commits the current branch is behind the target."""
+    output = run_git_command(
+        "rev-list",
+        "--count",
+        f"HEAD..{target}",
+    )
+
+    return int(output)

before_push-0.1.0/src/output.py

@@ -0,0 +1,153 @@
+import time
+
+from checks import CheckResult, CheckStatus
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+
+def print_header(target: str) -> None:
+    """Print the application header."""
+    title = Text()
+    title.append("BeforePush", style="bold cyan")
+    title.append("\nGit branch readiness check", style="dim")
+
+    console.print()
+    console.print(
+        Panel(
+            title,
+            border_style="bright_blue",
+            padding=(0, 2),
+        )
+    )
+
+    console.print(f"  [dim]Target[/dim]     [bold]{target}[/bold]")
+    console.print()
+
+
+def get_check_display(result: CheckResult) -> tuple[str, str]:
+    """Return the symbol and style for a check result."""
+    if result.status == CheckStatus.PASS:
+        return "✓", "green"
+
+    if result.status == CheckStatus.WARNING:
+        return "⚠", "yellow"
+
+    return "✗", "red"
+
+
+def print_check(result: CheckResult, animate: bool = True) -> None:
+    """Print a single check result."""
+    symbol, style = get_check_display(result)
+
+    if animate and console.is_terminal:
+        with console.status(
+            f"  [dim]Checking {result.name.lower()}...[/dim]",
+            spinner="dots",
+        ):
+            time.sleep(0.25)
+
+    console.print(
+        f"  [{style}]{symbol}[/{style}]  "
+        f"[bold]{result.name}[/bold]"
+    )
+    console.print(
+        f"     [dim]{result.message}[/dim]"
+    )
+    console.print()
+
+
+def print_summary(
+    results: list[CheckResult],
+) -> None:
+    """Print the final readiness summary."""
+    failed = sum(
+        result.status == CheckStatus.FAIL
+        for result in results
+    )
+
+    warnings = sum(
+        result.status == CheckStatus.WARNING
+        for result in results
+    )
+
+    console.print("  [dim]" + "─" * 44 + "[/dim]")
+    console.print()
+
+    if failed == 0 and warnings == 0:
+        summary = Text()
+        summary.append("✓ READY\n", style="bold green")
+        summary.append(
+            "All checks passed. Safe to push.",
+            style="green",
+        )
+
+        console.print(
+            Panel(
+                summary,
+                border_style="green",
+                padding=(0, 2),
+            )
+        )
+
+    else:
+        parts = []
+
+        if failed:
+            word = "check" if failed == 1 else "checks"
+            parts.append(f"{failed} {word} failed")
+
+        if warnings:
+            word = "warning" if warnings == 1 else "warnings"
+            parts.append(f"{warnings} {word}")
+
+        summary = Text()
+        summary.append("✗ NOT READY\n", style="bold red")
+        summary.append(
+            f"{' · '.join(parts)}.",
+            style="red",
+        )
+
+        console.print(
+            Panel(
+                summary,
+                border_style="red",
+                padding=(0, 2),
+            )
+        )
+
+    console.print()
+
+
+def print_results(
+    results: list[CheckResult],
+) -> None:
+    """Print all check results and the final status."""
+    console.print("  [bold]Checks[/bold]")
+    console.print()
+
+    animate = console.is_terminal
+
+    for result in results:
+        print_check(result, animate=animate)
+
+    print_summary(results)
+
+
+def display_results(
+    results: list[CheckResult],
+    target: str,
+) -> None:
+    """Display the complete check report."""
+    print_header(target)
+
+    if console.is_terminal:
+        with console.status(
+            "[bold cyan]Running checks...[/bold cyan]",
+            spinner="dots",
+        ):
+            time.sleep(0.5)
+
+    print_results(results)

before_push-0.1.0/tests/test_check.py

@@ -0,0 +1,168 @@
+import git
+
+from checks import (
+    CheckStatus,
+    check_current_branch,
+    check_git_repository,
+    check_target_branch,
+    check_upstream_branch,
+    check_working_tree,
+)
+
+
+def test_git_repository_pass(monkeypatch):
+    monkeypatch.setattr(git, "is_git_repository", lambda: True)
+
+    result = check_git_repository()
+
+    assert result.status == CheckStatus.PASS
+    assert result.name == "Git repository"
+
+
+def test_git_repository_fail(monkeypatch):
+    monkeypatch.setattr(git, "is_git_repository", lambda: False)
+
+    result = check_git_repository()
+
+    assert result.status == CheckStatus.FAIL
+    assert result.name == "Git repository"
+
+
+def test_current_branch_pass(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "get_current_branch",
+        lambda: "feature/test",
+    )
+
+    result = check_current_branch()
+
+    assert result.status == CheckStatus.PASS
+    assert "feature/test" in result.message
+
+
+def test_current_branch_fail(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "get_current_branch",
+        lambda: "",
+    )
+
+    result = check_current_branch()
+
+    assert result.status == CheckStatus.FAIL
+    assert "No branch" in result.message
+
+
+def test_working_tree_clean(monkeypatch):
+    monkeypatch.setattr(git, "has_changes", lambda: False)
+
+    result = check_working_tree()
+
+    assert result.status == CheckStatus.PASS
+    assert "clean" in result.message
+
+
+def test_working_tree_has_changes(monkeypatch):
+    monkeypatch.setattr(git, "has_changes", lambda: True)
+
+    result = check_working_tree()
+
+    assert result.status == CheckStatus.FAIL
+    assert "changes detected" in result.message
+
+
+def test_upstream_branch_pass(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "get_upstream_branch",
+        lambda: "origin/main",
+    )
+
+    result = check_upstream_branch()
+
+    assert result.status == CheckStatus.PASS
+    assert "origin/main" in result.message
+
+
+def test_upstream_branch_warning(monkeypatch):
+    def raise_error():
+        raise RuntimeError("No upstream")
+
+    monkeypatch.setattr(
+        git,
+        "get_upstream_branch",
+        raise_error,
+    )
+
+    result = check_upstream_branch()
+
+    assert result.status == CheckStatus.WARNING
+    assert "No upstream branch" in result.message
+
+
+def test_target_branch_current(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "get_current_branch",
+        lambda: "main",
+    )
+
+    result = check_target_branch("main")
+
+    assert result.status == CheckStatus.PASS
+    assert "target branch 'main'" in result.message
+
+
+def test_target_branch_up_to_date(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "get_current_branch",
+        lambda: "feature/test",
+    )
+    monkeypatch.setattr(
+        git,
+        "get_behind_count",
+        lambda target: 0,
+    )
+
+    result = check_target_branch("main")
+
+    assert result.status == CheckStatus.PASS
+    assert "up to date" in result.message
+
+
+def test_target_branch_behind_one_commit(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "get_current_branch",
+        lambda: "feature/test",
+    )
+    monkeypatch.setattr(
+        git,
+        "get_behind_count",
+        lambda target: 1,
+    )
+
+    result = check_target_branch("main")
+
+    assert result.status == CheckStatus.FAIL
+    assert "1 commit behind main" in result.message
+
+
+def test_target_branch_behind_multiple_commits(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "get_current_branch",
+        lambda: "feature/test",
+    )
+    monkeypatch.setattr(
+        git,
+        "get_behind_count",
+        lambda target: 3,
+    )
+
+    result = check_target_branch("main")
+
+    assert result.status == CheckStatus.FAIL
+    assert "3 commits behind main" in result.message

before_push-0.1.0/tests/test_cli.py

@@ -0,0 +1,51 @@
+import cli
+
+
+def test_cli_uses_main_by_default(monkeypatch):
+    captured = {}
+
+    def fake_run_checks(target):
+        captured["target"] = target
+        return []
+
+    def fake_display_results(results, target):
+        captured["results"] = results
+        captured["display_target"] = target
+
+    monkeypatch.setattr(cli, "run_checks", fake_run_checks)
+    monkeypatch.setattr(cli, "display_results", fake_display_results)
+
+    monkeypatch.setattr(
+        "sys.argv",
+        ["beforepush"],
+    )
+
+    cli.main()
+
+    assert captured["target"] == "main"
+    assert captured["display_target"] == "main"
+    assert captured["results"] == []
+
+
+def test_cli_accepts_custom_target(monkeypatch):
+    captured = {}
+
+    def fake_run_checks(target):
+        captured["target"] = target
+        return []
+
+    def fake_display_results(results, target):
+        captured["display_target"] = target
+
+    monkeypatch.setattr(cli, "run_checks", fake_run_checks)
+    monkeypatch.setattr(cli, "display_results", fake_display_results)
+
+    monkeypatch.setattr(
+        "sys.argv",
+        ["beforepush", "--target", "develop"],
+    )
+
+    cli.main()
+
+    assert captured["target"] == "develop"
+    assert captured["display_target"] == "develop"

before_push-0.1.0/tests/test_git.py

@@ -0,0 +1,122 @@
+import subprocess
+import pytest
+import git
+
+
+def test_run_git_command_success(monkeypatch):
+    def fake_run(*args, **kwargs):
+        return subprocess.CompletedProcess(
+            args=["git", "status"],
+            returncode=0,
+            stdout="clean",
+            stderr="",
+        )
+
+    monkeypatch.setattr(subprocess, "run", fake_run)
+
+    result = git.run_git_command("status")
+
+    assert result == "clean"
+
+
+def test_run_git_command_failure(monkeypatch):
+    def fake_run(*args, **kwargs):
+        return subprocess.CompletedProcess(
+            args=["git", "status"],
+            returncode=1,
+            stdout="",
+            stderr="fatal: not a git repository",
+        )
+
+    monkeypatch.setattr(subprocess, "run", fake_run)
+
+    with pytest.raises(RuntimeError, match="not a git repository"):
+        git.run_git_command("status")
+
+
+def test_is_git_repository_true(monkeypatch):
+    def fake_run(*args, **kwargs):
+        return subprocess.CompletedProcess(
+            args=["git", "rev-parse"],
+            returncode=0,
+            stdout="true\n",
+            stderr="",
+        )
+
+    monkeypatch.setattr(subprocess, "run", fake_run)
+
+    assert git.is_git_repository() is True
+
+
+def test_is_git_repository_false(monkeypatch):
+    def fake_run(*args, **kwargs):
+        return subprocess.CompletedProcess(
+            args=["git", "rev-parse"],
+            returncode=128,
+            stdout="",
+            stderr="fatal: not a git repository",
+        )
+
+    monkeypatch.setattr(subprocess, "run", fake_run)
+
+    assert git.is_git_repository() is False
+
+
+def test_get_current_branch(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "run_git_command",
+        lambda *args: "feature/test",
+    )
+
+    assert git.get_current_branch() == "feature/test"
+
+
+def test_get_status(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "run_git_command",
+        lambda *args: "M src/checks.py",
+    )
+
+    assert git.get_status() == "M src/checks.py"
+
+
+def test_has_changes_true(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "get_status",
+        lambda: " M src/checks.py",
+    )
+
+    assert git.has_changes() is True
+
+
+def test_has_changes_false(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "get_status",
+        lambda: "",
+    )
+
+    assert git.has_changes() is False
+
+
+def test_get_upstream_branch(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "run_git_command",
+        lambda *args: "origin/main",
+    )
+
+    assert git.get_upstream_branch() == "origin/main"
+
+
+def test_get_behind_count(monkeypatch):
+    monkeypatch.setattr(
+        git,
+        "run_git_command",
+        lambda *args: "3",
+    )
+
+    assert git.get_behind_count("main") == 3