git-p4son 0.2.10__tar.gz → 0.2.11__tar.gz

{git_p4son-0.2.10 → git_p4son-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.2.10
+Version: 0.2.11
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -317,7 +317,11 @@ git p4son new -m "New feature" --review -b main
 
 ### Update Command
 
-Update an existing Perforce changelist description by replacing the enumerated commit list with the current commits since the base branch. By default also opens changed files for edit.
+Update an existing Perforce changelist description. Commits since the base branch replace their existing
+entries in the enumerated commit list (matched by subject) and new ones are appended; entries outside the
+range are kept and the list is renumbered. So `update -b main` rebuilds the whole list without duplicating
+it, while `update -b HEAD~3` only refreshes the last three entries. By default also opens changed files for
+edit.
 
 ```sh
 git p4son update [changelist] [--base-branch BASE_BRANCH] [--dry-run] [--no-desc] [--no-edit] [--shelve]
@@ -464,16 +468,21 @@ git p4son alias delete myfeature
 
 #### alias clean
 
-Interactively review and delete changelist aliases:
+Clean up changelist aliases:
 
 ```sh
 git p4son alias clean
 ```
 
-This command iterates through each alias, displays it, and prompts for action:
+The command lists all aliases and asks how to proceed:
+- `a` (all): Delete all aliases
+- `i` (interactive): Review each alias one by one
+- `q` (quit): Exit without deleting anything
+
+In interactive mode, each alias is displayed in turn with a prompt:
 - `y` (yes): Delete this alias
 - `n` (no): Keep this alias
-- `a` (all): Delete this and all remaining aliases
+- `a` (all): Delete this and all remaining aliases (handy for keeping the first few and sweeping the rest)
 - `q` (quit): Stop and keep remaining aliases
 
 **Examples:**

{git_p4son-0.2.10 → git_p4son-0.2.11}/README.md

@@ -294,7 +294,11 @@ git p4son new -m "New feature" --review -b main
 
 ### Update Command
 
-Update an existing Perforce changelist description by replacing the enumerated commit list with the current commits since the base branch. By default also opens changed files for edit.
+Update an existing Perforce changelist description. Commits since the base branch replace their existing
+entries in the enumerated commit list (matched by subject) and new ones are appended; entries outside the
+range are kept and the list is renumbered. So `update -b main` rebuilds the whole list without duplicating
+it, while `update -b HEAD~3` only refreshes the last three entries. By default also opens changed files for
+edit.
 
 ```sh
 git p4son update [changelist] [--base-branch BASE_BRANCH] [--dry-run] [--no-desc] [--no-edit] [--shelve]
@@ -441,16 +445,21 @@ git p4son alias delete myfeature
 
 #### alias clean
 
-Interactively review and delete changelist aliases:
+Clean up changelist aliases:
 
 ```sh
 git p4son alias clean
 ```
 
-This command iterates through each alias, displays it, and prompts for action:
+The command lists all aliases and asks how to proceed:
+- `a` (all): Delete all aliases
+- `i` (interactive): Review each alias one by one
+- `q` (quit): Exit without deleting anything
+
+In interactive mode, each alias is displayed in turn with a prompt:
 - `y` (yes): Delete this alias
 - `n` (no): Keep this alias
-- `a` (all): Delete this and all remaining aliases
+- `a` (all): Delete this and all remaining aliases (handy for keeping the first few and sweeping the rest)
 - `q` (quit): Stop and keep remaining aliases
 
 **Examples:**

{git_p4son-0.2.10 → git_p4son-0.2.11}/git_p4son/__init__.py

@@ -7,6 +7,6 @@ creating and updating changelists, and managing Swarm reviews.
 
 CONFIG_DIR = '.git-p4son'
 
-__version__ = "0.2.10"
+__version__ = "0.2.11"
 __author__ = "Andreas Andersson"
 __email__ = "andreas@neoboid.com"

{git_p4son-0.2.10 → git_p4son-0.2.11}/git_p4son/alias.py

@@ -54,43 +54,52 @@ def alias_delete_command(args: argparse.Namespace) -> int:
     return 0
 
 
-def _prompt_delete(prompt: str) -> str | None:
-    """Prompt until a valid y/n/a/q response is given. Returns None on EOF."""
+def _prompt_choice(prefix: str, options: list[str]) -> str | None:
+    """Prompt until the response matches an option or its first letter.
+
+    The choices are rendered from the options, e.g. "[y]es / [n]o", so the
+    prompt and the accepted keys cannot drift apart. Options must have
+    unique first letters. Returns the chosen option, or None on EOF.
+    """
+    shorthands = {option[0]: option for option in options}
+    rendered = ' / '.join(f'[{option[0]}]{option[1:]}' for option in options)
+    keys = list(shorthands)
     while True:
         try:
-            response = input(prompt).strip().lower()
+            response = input(f'{prefix} {rendered}: ').strip().lower()
         except EOFError:
             print()
             return None
 
-        if response in ('y', 'yes'):
-            return 'yes'
-        elif response in ('n', 'no'):
-            return 'no'
-        elif response in ('a', 'all'):
-            return 'all'
-        elif response in ('q', 'quit'):
-            return 'quit'
+        if response in shorthands:
+            return shorthands[response]
+        elif response in options:
+            return response
         else:
-            print('Please enter y, n, a, or q')
+            print('Please enter ' + ', '.join(keys[:-1]) + f' or {keys[-1]}')
 
 
-def alias_clean_command(args: argparse.Namespace) -> int:
-    """Execute the 'alias clean' command with interactive prompts."""
-    workspace_dir = args.workspace_dir
+def _clean_all(aliases: list[tuple[str, str]], workspace_dir: str) -> None:
+    """Delete every alias without further prompting."""
+    for name, _changelist in aliases:
+        if delete_changelist_alias(name, workspace_dir):
+            log.success(f'Deleted "{name}"')
 
-    aliases = list_changelist_aliases(workspace_dir)
-    if not aliases:
-        log.success('No changelist aliases to clean')
-        return 0
 
+def _clean_interactive(aliases: list[tuple[str, str]],
+                       workspace_dir: str) -> None:
+    """Review each alias in turn with yes/no/all/quit prompts.
+
+    The all option lets the user keep the first aliases and sweep the rest:
+    answer no until the last one worth keeping, then a deletes the
+    remainder without further prompts."""
     response = None
     for name, changelist in aliases:
         log.heading(f'{name} -> CL {changelist}')
 
         if response != 'all':
-            response = _prompt_delete(
-                'Delete? [y]es / [n]o / [a]ll / [q]uit: ')
+            response = _prompt_choice(
+                'Delete?', ['yes', 'no', 'all', 'quit'])
 
         if response is None or response == 'quit':
             log.info('Aborting')
@@ -102,6 +111,30 @@ def alias_clean_command(args: argparse.Namespace) -> int:
         if delete_changelist_alias(name, workspace_dir):
             log.success('Deleted')
 
+
+def alias_clean_command(args: argparse.Namespace) -> int:
+    """Execute the 'alias clean' command."""
+    workspace_dir = args.workspace_dir
+
+    aliases = list_changelist_aliases(workspace_dir)
+    if not aliases:
+        log.success('No changelist aliases to clean')
+        return 0
+
+    log.info(f'Found {len(aliases)}')
+    for name, changelist in aliases:
+        log.info(f'{name} -> {changelist}')
+
+    mode = _prompt_choice('Delete?', ['all', 'interactive', 'quit'])
+    if mode is None or mode == 'quit':
+        log.info('Aborting')
+        return 0
+
+    if mode == 'all':
+        _clean_all(aliases, workspace_dir)
+    else:
+        _clean_interactive(aliases, workspace_dir)
+
     return 0
 
 

{git_p4son-0.2.10 → git_p4son-0.2.11}/git_p4son/changelist_store.py

@@ -19,6 +19,13 @@ RESERVED_KEYWORDS = frozenset({'last-synced', 'branch'})
 # (Windows disallows trailing dots).
 _ALIAS_NAME_RE = re.compile(r'^[A-Za-z0-9_-]([A-Za-z0-9._-]*[A-Za-z0-9_-])?$')
 
+# Windows device names; opening such a path hits the device namespace
+# instead of creating a file, on any drive and regardless of extension.
+_WINDOWS_RESERVED_NAMES = frozenset(
+    {'con', 'prn', 'aux', 'nul'}
+    | {f'com{i}' for i in range(1, 10)}
+    | {f'lpt{i}' for i in range(1, 10)})
+
 
 def validate_alias_name(name: str) -> str | None:
     """Return an error message if alias name is invalid, else None."""
@@ -30,6 +37,15 @@ def validate_alias_name(name: str) -> str | None:
         return (
             f'Invalid alias name "{name}": must contain only letters, digits, '
             'hyphens, underscores, and dots, and must not start or end with a dot')
+    if name.isdigit():
+        # Digit strings are always interpreted as changelist numbers, so
+        # such an alias could be created but never referenced.
+        return (
+            f'Invalid alias name "{name}": an all-digit name would be '
+            'indistinguishable from a changelist number')
+    if name.split('.', 1)[0].lower() in _WINDOWS_RESERVED_NAMES:
+        return (
+            f'Invalid alias name "{name}": reserved device name on Windows')
     return None
 
 
@@ -38,6 +54,18 @@ def _changelists_dir(workspace_dir: str) -> str:
     return os.path.join(workspace_dir, CONFIG_DIR, 'changelists')
 
 
+def _alias_path(name: str, workspace_dir: str) -> str | None:
+    """Validate name and return its store path, or None if invalid.
+
+    Validating on every lookup, not just on save, keeps raw user input
+    (e.g. "../../somefile") from escaping the store directory."""
+    error = validate_alias_name(name)
+    if error:
+        log.error(error)
+        return None
+    return os.path.join(_changelists_dir(workspace_dir), name)
+
+
 def alias_exists(name: str, workspace_dir: str) -> bool:
     """Check whether a changelist alias exists."""
     alias_path = os.path.join(_changelists_dir(workspace_dir), name)
@@ -46,13 +74,11 @@ def alias_exists(name: str, workspace_dir: str) -> bool:
 
 def save_changelist_alias(name: str, changelist: str, workspace_dir: str, force: bool = False) -> bool:
     """Save a changelist number under a named alias."""
-    error = validate_alias_name(name)
-    if error:
-        log.error(error)
+    alias_path = _alias_path(name, workspace_dir)
+    if alias_path is None:
         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(
@@ -71,7 +97,9 @@ def save_changelist_alias(name: str, changelist: str, workspace_dir: str, force:
 
 def load_changelist_alias(name: str, workspace_dir: str) -> str | None:
     """Load a changelist number from a named alias, or None if not found."""
-    alias_path = os.path.join(_changelists_dir(workspace_dir), name)
+    alias_path = _alias_path(name, workspace_dir)
+    if alias_path is None:
+        return None
 
     if not os.path.exists(alias_path):
         log.error(f'No changelist alias found: {name}')
@@ -108,7 +136,9 @@ def list_changelist_aliases(workspace_dir: str) -> list[tuple[str, str]]:
 
 def delete_changelist_alias(name: str, workspace_dir: str) -> bool:
     """Delete a changelist alias file."""
-    alias_path = os.path.join(_changelists_dir(workspace_dir), name)
+    alias_path = _alias_path(name, workspace_dir)
+    if alias_path is None:
+        return False
 
     if not os.path.exists(alias_path):
         log.error(f'No changelist alias found: {name}')

{git_p4son-0.2.10 → git_p4son-0.2.11}/git_p4son/cli.py

@@ -149,6 +149,7 @@ Examples:
     )
     new_parser.add_argument(
         '-s', '--sleep',
+        type=int,
         help='Sleep for the specified number of seconds after the command is done'
     )
 
@@ -156,9 +157,11 @@ Examples:
     update_parser = subparsers.add_parser(
         'update',
         help='Update an existing changelist description and open files for edit',
-        description='Update an existing Perforce changelist description by '
-        'replacing the enumerated commit list with the current commits '
-        'since the base branch. By default also opens changed files for edit.'
+        description='Update an existing Perforce changelist description: '
+        'commits since the base branch replace their existing entries in '
+        'the enumerated commit list and new ones are appended; entries '
+        'outside the range are kept. By default also opens changed files '
+        'for edit.'
     )
     update_parser.add_argument(
         'changelist',
@@ -194,6 +197,7 @@ Examples:
     )
     update_parser.add_argument(
         '-s', '--sleep',
+        type=int,
         help='Sleep for the specified number of seconds after the command is done'
     )
 
@@ -268,9 +272,9 @@ Examples:
     # alias clean
     alias_subparsers.add_parser(
         'clean',
-        help='Interactive cleanup of changelist aliases',
-        description='Interactively review and delete changelist aliases with '
-        'yes/no/all/quit prompts'
+        help='Clean up changelist aliases',
+        description='List all changelist aliases, then delete all of them '
+        'or review each one interactively with yes/no/all/quit prompts'
     )
 
     # Review subcommand
@@ -468,7 +472,7 @@ def main() -> int:
         exit_code = run_command(args)
 
         if exit_code == 0 and getattr(args, 'sleep', None) is not None:
-            seconds = int(args.sleep)
+            seconds = args.sleep
             log.heading(f'Sleeping for {seconds} seconds')
             time.sleep(seconds)
             log.success('awake again')

{git_p4son-0.2.10 → git_p4son-0.2.11}/git_p4son/common.py

@@ -10,6 +10,7 @@ import re
 import subprocess
 import sys
 import threading
+import time
 from timeit import default_timer as timer
 from datetime import timedelta
 from typing import IO, Callable
@@ -91,11 +92,13 @@ class RunError(CommandError):
 class RunResult:
     """Result of a command execution."""
 
-    def __init__(self, returncode: int, stdout: list[str], stderr: list[str],
+    def __init__(self, returncode: int,
+                 stdout: list[str] | bytes,
+                 stderr: list[str] | bytes,
                  elapsed: timedelta | None = None) -> None:
         self.returncode: int = returncode
-        self.stdout: list[str] = stdout
-        self.stderr: list[str] = stderr
+        self.stdout: list[str] | bytes = stdout
+        self.stderr: list[str] | bytes = stderr
         self.elapsed: timedelta | None = elapsed
 
 
@@ -111,7 +114,10 @@ def join_command_line(command: list[str]) -> str:
 
 def run(command: list[str], cwd: str = '.', dry_run: bool = False,
         input: str | None = None,
-        env: dict[str, str] | None = None) -> RunResult:
+        env: dict[str, str] | None = None,
+        text: bool = True,
+        fail_on_returncode: bool = True
+        ) -> RunResult:
     """
     Run a command and return the result.
 
@@ -121,6 +127,8 @@ def run(command: list[str], cwd: str = '.', dry_run: bool = False,
         dry_run: If True, only print the command without executing
         input: Optional string to pass to the subprocess via stdin
         env: Optional environment variables to add or override
+        text: False to get raw bytes instead of decoded lines.
+        fail_on_returncode: False to not raise on non-zero return codes.
 
     Returns:
         RunResult object with returncode, stdout, and stderr
@@ -131,7 +139,7 @@ def run(command: list[str], cwd: str = '.', dry_run: bool = False,
 
     if dry_run:
         log.end_command()
-        return RunResult(0, [], [])
+        return RunResult(0, [] if text else b'', [] if text else b'')
 
     if input is not None:
         log.end_command()
@@ -145,27 +153,45 @@ def run(command: list[str], cwd: str = '.', dry_run: bool = False,
     if env:
         command_env.update(env)
 
-    result = subprocess.run(command,
-                            cwd=cwd,
-                            env=command_env,
-                            capture_output=True,
-                            text=True,
-                            input=input)
+    # Decode output as UTF-8 regardless of locale: git emits UTF-8, but
+    # Windows would otherwise decode with the ANSI code page (cp1252).
+    try:
+        result = subprocess.run(command,
+                                cwd=cwd,
+                                env=command_env,
+                                capture_output=True,
+                                text=text,
+                                encoding='utf-8' if text else None,
+                                errors='replace' if text else None,
+                                input=input)
+    except OSError:
+        # E.g. the executable is missing; without this the spinner thread
+        # keeps rewriting the line under the error message.
+        log.stop_spinner()
+        raise
 
     end_timestamp = timer()
     elapsed = timedelta(seconds=end_timestamp - start_timestamp)
 
     log.stop_spinner()
 
-    if result.returncode != 0:
+    if fail_on_returncode and result.returncode != 0:
+        if text:
+            stderr = result.stderr.splitlines()
+        else:
+            # Bytes mode: decode so the error still carries the reason.
+            stderr = result.stderr.decode('utf-8', 'replace').splitlines()
         raise RunError(
             join_command_line(command),
             returncode=result.returncode,
-            stderr=result.stderr.splitlines(),
+            stderr=stderr,
         )
 
-    return RunResult(result.returncode, result.stdout.splitlines(),
-                     result.stderr.splitlines(), elapsed=elapsed)
+    if text:
+        return RunResult(result.returncode, result.stdout.splitlines(),
+                         result.stderr.splitlines(), elapsed=elapsed)
+    return RunResult(result.returncode, result.stdout,
+                     result.stderr, elapsed=elapsed)
 
 
 def enqueue_lines(stream: IO[str], output_queue: queue.Queue[str]) -> None:
@@ -204,12 +230,24 @@ def run_with_output(command: list[str], cwd: str = '.',
     if env:
         command_env.update(env)
 
-    with subprocess.Popen(command,
-                          cwd=cwd,
-                          env=command_env,
-                          stdout=subprocess.PIPE,
-                          stderr=subprocess.PIPE,
-                          text=True) as process:
+    # UTF-8 for the same reason as in run(); a decode error would
+    # otherwise kill the reader threads silently.
+    try:
+        process_cm = subprocess.Popen(command,
+                                      cwd=cwd,
+                                      env=command_env,
+                                      stdout=subprocess.PIPE,
+                                      stderr=subprocess.PIPE,
+                                      text=True,
+                                      encoding='utf-8',
+                                      errors='replace')
+    except OSError:
+        # E.g. the executable is missing; without this the spinner thread
+        # keeps rewriting the line under the error message.
+        log.stop_spinner()
+        raise
+
+    with process_cm as process:
 
         output_queue: queue.Queue[str] = queue.Queue()
         out_thread = threading.Thread(
@@ -235,33 +273,24 @@ def run_with_output(command: list[str], cwd: str = '.',
                 pass
 
         try:
-            while True:
+            # The reader threads own the pipes and exit at EOF, so they are
+            # the source of truth for "no more output is coming". Looping on
+            # process.poll() instead would race: the process can exit while
+            # lines are still in the pipe buffer, and anything enqueued after
+            # the last drain would be lost.
+            while out_thread.is_alive() or err_thread.is_alive():
                 drain_queue(output_queue, stdout_lines, sys.stdout)
                 drain_queue(error_queue, stderr_lines, sys.stderr)
-                if process.poll() is not None:
-                    if output_queue.empty() and error_queue.empty():
-                        break
+                time.sleep(0.05)
 
-            # Wait for threads to finish
             out_thread.join()
             err_thread.join()
 
-            (final_stdout, final_stderr) = process.communicate()
-            returncode = process.returncode
-
-            if final_stdout:
-                final_stdout_lines = final_stdout.splitlines()
-                stdout_lines = stdout_lines + final_stdout_lines
-                for line in final_stdout_lines:
-                    if on_output:
-                        on_output(line=line, stream=sys.stdout)
+            # Final drain for lines enqueued after the last pass above.
+            drain_queue(output_queue, stdout_lines, sys.stdout)
+            drain_queue(error_queue, stderr_lines, sys.stderr)
 
-            if final_stderr:
-                final_stderr_lines = final_stderr.splitlines()
-                stderr_lines = stderr_lines + final_stderr_lines
-                for line in final_stderr_lines:
-                    if on_output:
-                        on_output(line=line, stream=sys.stderr)
+            returncode = process.wait()
 
         except KeyboardInterrupt:
             log.stop_spinner()

{git_p4son-0.2.10 → git_p4son-0.2.11}/git_p4son/complete.py

@@ -11,6 +11,7 @@ import argparse
 from .changelist_store import list_changelist_aliases
 from .common import branch_to_alias
 from .git import get_current_branch, get_workspace_dir
+from .log import log
 
 _HIDDEN_COMMANDS = frozenset({'complete', 'completion', '_sequence-editor'})
 
@@ -220,6 +221,10 @@ def _complete(parser, words, workspace_dir=None):
 def run_complete(words):
     """Execute the complete command with the given word list."""
     from .cli import create_parser
+    # stdout is reserved for completion candidates: any status line or
+    # command echo from helpers (e.g. get_current_branch running git)
+    # would be offered to the user as a candidate by the shell.
+    log.quiet_mode = True
     parser = create_parser()
     workspace_dir = get_workspace_dir()
     candidates = _complete(parser, words, workspace_dir)

git_p4son-0.2.11/git_p4son/config.py

@@ -0,0 +1,89 @@
+"""
+Configuration management for git-p4son.
+
+Reads and writes per-repo config stored in .git-p4son/config.toml.
+"""
+
+import os
+import re
+import tomllib
+
+from . import CONFIG_DIR
+
+_BARE_KEY_RE = re.compile(r'^[A-Za-z0-9_-]+$')
+
+
+def config_path(workspace_dir: str) -> str:
+    """Return the path to the config file."""
+    return os.path.join(workspace_dir, CONFIG_DIR, 'config.toml')
+
+
+def load_config(workspace_dir: str) -> dict:
+    """Read and parse the config file. Returns empty dict if missing."""
+    path = config_path(workspace_dir)
+    if not os.path.exists(path):
+        return {}
+    with open(path, 'rb') as f:
+        return tomllib.load(f)
+
+
+def save_config(workspace_dir: str, config: dict) -> None:
+    """Merge config into the config file, section by section.
+
+    Sections not named in config are preserved (e.g. a configured [hooks]
+    section survives re-running init); keys within a named section are
+    updated rather than replacing the section wholesale."""
+    merged = load_config(workspace_dir)
+    for section, values in config.items():
+        merged.setdefault(section, {}).update(values)
+
+    path = config_path(workspace_dir)
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    # tomllib reads strict UTF-8, so write UTF-8 explicitly.
+    with open(path, 'w', encoding='utf-8') as f:
+        for section, values in merged.items():
+            _write_table(f, _format_key(section), values)
+
+
+def _format_string(value: str) -> str:
+    escaped = value.replace('\\', '\\\\').replace('"', '\\"')
+    return f'"{escaped}"'
+
+
+def _format_key(key: str) -> str:
+    """Format a TOML key, quoting it when it is not a bare key."""
+    if _BARE_KEY_RE.match(key):
+        return key
+    return _format_string(key)
+
+
+def _format_value(value) -> str:
+    """Format a TOML value: strings, booleans, numbers, and lists."""
+    if isinstance(value, str):
+        return _format_string(value)
+    if isinstance(value, bool):
+        return 'true' if value else 'false'
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, list):
+        return '[' + ', '.join(_format_value(item) for item in value) + ']'
+    raise ValueError(
+        f'Unsupported config value type: {type(value).__name__}')
+
+
+def _write_table(f, name: str, table: dict) -> None:
+    """Write a [name] table; nested dicts become [name.sub] tables."""
+    scalars = {k: v for k, v in table.items() if not isinstance(v, dict)}
+    subtables = {k: v for k, v in table.items() if isinstance(v, dict)}
+    f.write(f'[{name}]\n')
+    for key, value in scalars.items():
+        f.write(f'{_format_key(key)} = {_format_value(value)}\n')
+    f.write('\n')
+    for key, subtable in subtables.items():
+        _write_table(f, f'{name}.{_format_key(key)}', subtable)
+
+
+def get_depot_root(workspace_dir: str) -> str | None:
+    """Get the depot root from config, or None if not configured."""
+    config = load_config(workspace_dir)
+    return config.get('depot', {}).get('root')