git-p4son 0.1.0__py3-none-any.whl

git_p4son/__init__.py

@@ -0,0 +1,11 @@
+"""
+git-p4son - Utility for keeping a Perforce workspace and local git repo in sync.
+
+This package provides two main commands:
+- sync: Sync local git repository with a Perforce workspace
+- edit: Open local git changes for edit in Perforce
+"""
+
+__version__ = "0.1.0"
+__author__ = "Andreas Andersson"
+__email__ = "andreas@neoboid.com"

git_p4son/__main__.py

@@ -0,0 +1,10 @@
+"""
+Entry point for running git-p4son as a module: python -m git_p4son
+"""
+
+import sys
+from .cli import main
+
+if __name__ == '__main__':
+    exit_code = main()
+    sys.exit(exit_code)

git_p4son/alias.py

@@ -0,0 +1,162 @@
+"""
+Alias command implementation for git-p4son.
+"""
+
+import argparse
+from .changelist_store import (
+    save_changelist_alias,
+    list_changelist_aliases,
+    delete_changelist_alias,
+)
+from .log import log
+
+
+def alias_list_command(args: argparse.Namespace) -> int:
+    """
+    Execute the 'alias list' command.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code (0 for success, non-zero for failure)
+    """
+    workspace_dir = args.workspace_dir
+
+    aliases = list_changelist_aliases(workspace_dir)
+    if not aliases:
+        log.info('No aliases defined')
+        return 0
+
+    for name, changelist in aliases:
+        log.info(f'{name} -> {changelist}')
+
+    return 0
+
+
+def alias_set_command(args: argparse.Namespace) -> int:
+    """
+    Execute the 'alias set' command.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code (0 for success, non-zero for failure)
+    """
+    workspace_dir = args.workspace_dir
+
+    if not args.changelist.isdigit():
+        log.error(f'Invalid changelist number: {args.changelist}')
+        return 1
+
+    if not save_changelist_alias(args.alias, args.changelist,
+                                 workspace_dir, force=args.force):
+        return 1
+
+    log.detail('alias', f'{args.alias} -> {args.changelist}')
+    return 0
+
+
+def alias_delete_command(args: argparse.Namespace) -> int:
+    """
+    Execute the 'alias delete' command.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code (0 for success, non-zero for failure)
+    """
+    workspace_dir = args.workspace_dir
+
+    if not delete_changelist_alias(args.alias, workspace_dir):
+        return 1
+
+    log.info(f'Deleted alias "{args.alias}"')
+    return 0
+
+
+def alias_clean_command(args: argparse.Namespace) -> int:
+    """
+    Execute the 'alias clean' command with interactive prompts.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code (0 for success, non-zero for failure)
+    """
+    workspace_dir = args.workspace_dir
+
+    aliases = list_changelist_aliases(workspace_dir)
+    if not aliases:
+        log.info('No aliases to clean')
+        return 0
+
+    delete_all = False
+    deleted_count = 0
+
+    for name, changelist in aliases:
+        # Interactive output stays as print() — it's a prompt-response UI
+        print(f'{name} -> {changelist}')
+
+        if delete_all:
+            delete_changelist_alias(name, workspace_dir)
+            deleted_count += 1
+            print(f'  Deleted')
+            continue
+
+        while True:
+            try:
+                response = input(
+                    'Delete? [y]es / [n]o / [a]ll / [q]uit: ').strip().lower()
+            except EOFError:
+                print()
+                return 0
+
+            if response in ('y', 'yes'):
+                delete_changelist_alias(name, workspace_dir)
+                deleted_count += 1
+                print(f'  Deleted')
+                break
+            elif response in ('n', 'no'):
+                break
+            elif response in ('a', 'all'):
+                delete_all = True
+                delete_changelist_alias(name, workspace_dir)
+                deleted_count += 1
+                print(f'  Deleted')
+                break
+            elif response in ('q', 'quit'):
+                print(f'Deleted {deleted_count} alias(es)')
+                return 0
+            else:
+                print('Please enter y, n, a, or q')
+
+    print(f'Deleted {deleted_count} alias(es)')
+    return 0
+
+
+def alias_command(args: argparse.Namespace) -> int:
+    """
+    Dispatch alias subcommands.
+
+    Args:
+        args: Parsed command line arguments
+
+    Returns:
+        Exit code (0 for success, non-zero for failure)
+    """
+    if args.alias_action == 'list':
+        return alias_list_command(args)
+    elif args.alias_action == 'set':
+        return alias_set_command(args)
+    elif args.alias_action == 'delete':
+        return alias_delete_command(args)
+    elif args.alias_action == 'clean':
+        return alias_clean_command(args)
+    else:
+        log.error(
+            'No alias action specified. Use "git-p4son alias -h" for help.')
+        return 1

git_p4son/changelist_store.py

@@ -0,0 +1,147 @@
+"""
+Changelist alias utilities for git-p4son.
+
+Stores named aliases for changelist numbers in .git-p4son/changelists/<name>.
+"""
+
+import os
+
+from .log import log
+
+
+RESERVED_KEYWORDS = frozenset({'latest', 'last-synced', 'branch'})
+
+
+def _changelists_dir(workspace_dir: str) -> str:
+    """Return the path to the changelists alias directory."""
+    return os.path.join(workspace_dir, '.git-p4son', 'changelists')
+
+
+def save_changelist_alias(name: str, changelist: str, workspace_dir: str, force: bool = False) -> bool:
+    """
+    Save a changelist number under a named alias.
+
+    Creates .git-p4son/changelists/ directory if needed and writes the
+    changelist number to .git-p4son/changelists/<name>.
+
+    Args:
+        name: The alias name
+        changelist: The changelist number to store
+        workspace_dir: The workspace root directory
+        force: If True, overwrite an existing alias file
+
+    Returns:
+        True on success, False on failure
+    """
+    if name in RESERVED_KEYWORDS:
+        log.error(f'Alias name "{name}" is a reserved keyword')
+        return False
+
+    changelists_dir = _changelists_dir(workspace_dir)
+    alias_path = os.path.join(changelists_dir, name)
+
+    if os.path.exists(alias_path) and not force:
+        log.error(
+            f'Alias "{name}" already exists (use -f/--force to overwrite)')
+        return False
+
+    os.makedirs(changelists_dir, exist_ok=True)
+
+    with open(alias_path, 'w') as f:
+        f.write(changelist + '\n')
+
+    return True
+
+
+def load_changelist_alias(name: str, workspace_dir: str) -> str | None:
+    """
+    Load a changelist number from a named alias.
+
+    Args:
+        name: The alias name
+        workspace_dir: The workspace root directory
+
+    Returns:
+        The changelist number string, or None if not found
+    """
+    alias_path = os.path.join(_changelists_dir(workspace_dir), name)
+
+    if not os.path.exists(alias_path):
+        log.error(f'No changelist alias found: {name}')
+        return None
+
+    with open(alias_path, 'r') as f:
+        content = f.read().strip()
+
+    if not content:
+        log.error(f'Changelist alias "{name}" is empty')
+        return None
+
+    return content
+
+
+def resolve_changelist(value: str, workspace_dir: str) -> str | None:
+    """
+    Resolve a changelist value that may be a number or a named alias.
+
+    If the value is all digits, it is returned as-is.
+    Otherwise it is looked up as an alias.
+
+    Args:
+        value: A changelist number or alias name
+        workspace_dir: The workspace root directory
+
+    Returns:
+        The changelist number string, or None if alias lookup failed
+    """
+    if value.isdigit():
+        return value
+    return load_changelist_alias(value, workspace_dir)
+
+
+def list_changelist_aliases(workspace_dir: str) -> list[tuple[str, str]]:
+    """
+    Return a list of all changelist aliases and their values.
+
+    Args:
+        workspace_dir: The workspace root directory
+
+    Returns:
+        Sorted list of (alias_name, changelist_number) tuples.
+    """
+    changelists_dir = _changelists_dir(workspace_dir)
+
+    if not os.path.isdir(changelists_dir):
+        return []
+
+    aliases = []
+    for name in os.listdir(changelists_dir):
+        alias_path = os.path.join(changelists_dir, name)
+        if os.path.isfile(alias_path):
+            with open(alias_path, 'r') as f:
+                content = f.read().strip()
+            if content:
+                aliases.append((name, content))
+
+    return sorted(aliases, key=lambda x: x[0])
+
+
+def delete_changelist_alias(name: str, workspace_dir: str) -> bool:
+    """
+    Delete a changelist alias file.
+
+    Args:
+        name: The alias name to delete
+        workspace_dir: The workspace root directory
+
+    Returns:
+        True on success, False if not found
+    """
+    alias_path = os.path.join(_changelists_dir(workspace_dir), name)
+
+    if not os.path.exists(alias_path):
+        log.error(f'No changelist alias found: {name}')
+        return False
+
+    os.remove(alias_path)
+    return True