git-p4son 0.3.4__tar.gz → 0.4.1__tar.gz

{git_p4son-0.3.4 → git_p4son-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.3.4
+Version: 0.4.1
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -239,10 +239,13 @@ check. Only files with local changes are made read-only for the duration of the
 Perforce would otherwise refuse to overwrite. The same digest check applies to git-ignored files: unchanged ones sync
 normally, and after the sync git-p4son lists the ones Perforce skipped because they were modified locally.
 
+**Writable mode** - With [writable mode](#writable-command) on, the files a sync touches are made writable again after
+the sync if git tracks them. The sync itself works as described above, since the workspace is not `allwrite`.
+
 ## Usage
 
-git-p4son provides nine commands: `init`, `sync`, `sync-split`, `new`, `update`, `review`, `list-changes`,
-`alias`, and `completion`.
+git-p4son provides ten commands: `init`, `sync`, `sync-split`, `new`, `update`, `review`, `list-changes`,
+`alias`, `writable`, and `completion`.
 
 To see help for any command, use `-h`:
 
@@ -274,6 +277,9 @@ The depot root determines which part of the Perforce workspace git-p4son syncs.
 workspace or just the directory's subtree where the git root is placed. The selection is saved in
 `.git-p4son/config.toml` and used by all subsequent commands.
 
+Nothing in `.git-p4son/` belongs in git. The folder has its own `.gitignore` that ignores everything in it, so there
+is no need to list it in the workspace `.gitignore`.
+
 The saved root uses a `$(workspace)` placeholder for the workspace (client) name, e.g.
 `root = "//$(workspace)/Engine"`. git-p4son substitutes the live workspace name each time it runs, so renaming
 the Perforce workspace does not break the config. You can still store a concrete name (e.g. `//my-workspace/Engine`)
@@ -284,12 +290,15 @@ The `.gitignore` is set up using this priority:
 - If `.p4ignore` exists, it is copied to `.gitignore` as a starting point
 - Otherwise, an empty `.gitignore` is created
 
+`init` also asks whether to turn on [writable mode](#writable-command), defaulting to the current setting. It only
+saves the answer; run `git p4son writable apply` once your files are committed to update their permissions.
+
 ### Sync Command
 
 Sync local git repository with a Perforce workspace:
 
 ```sh
-git p4son sync [changelist ...] [--force]
+git p4son sync [changelist ...] [--force] [--dry-run]
 ```
 
 **Arguments:**
@@ -300,6 +309,8 @@ git p4son sync [changelist ...] [--force]
 
 **Options:**
 - `-f, --force`: Allow syncing to changelists older than the current one.
+- `-n, --dry-run`: Print the resolved sync sequence without syncing. The arguments are validated as for a
+  real sync, but nothing else runs: no clean-workspace checks, no hooks, and no prompts.
 
 **Examples:**
 ```sh
@@ -310,6 +321,7 @@ git p4son sync 123 156 178  # sync each changelist in sequence, one commit each
 git p4son sync 123 156 head # sync 123, 156, then the latest changelist
 git p4son sync last-synced
 git p4son sync 12345 --force
+git p4son sync --dry-run    # show the changelists a sync to latest would visit
 ```
 
 #### pre-sync hook
@@ -379,6 +391,10 @@ than the last synced changelist (use `git p4son sync --force` for that).
 Create a new Perforce changelist and add changed files to it. Description will contain an enumerated list of git commits since the base branch.
 Optionally creates a Swarm review.
 
+Opening files requires a clean git workspace, untracked files included; `new` refuses to run otherwise. The check
+is skipped with `--no-edit`. After opening files, unchanged ones are reverted (see
+[Keeping the changelist in step with git](#keeping-the-changelist-in-step-with-git)).
+
 ```sh
 git p4son new -m <message> [alias] [--base-branch BASE_BRANCH] [--force] [--dry-run] [--no-edit] [--no-alias]
                            [--shelve] [--review]
@@ -414,7 +430,10 @@ Update an existing Perforce changelist description. Commits since the base branc
 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.
+edit, and reverts files that are no longer part of the git change (see
+[Keeping the changelist in step with git](#keeping-the-changelist-in-step-with-git)). Opening files requires a
+clean git workspace, untracked files included; `update` refuses to run otherwise. The check is skipped with
+`--no-edit`.
 
 ```sh
 git p4son update [changelist] [--base-branch BASE_BRANCH] [--dry-run] [--no-desc] [--no-edit] [--shelve]
@@ -440,6 +459,27 @@ git p4son update 12345
 git p4son update myalias -b main
 ```
 
+### Keeping the changelist in step with git
+
+`new` and `update` open every file changed since the base branch in the changelist. A file can later stop being
+part of the change, for example when a later commit undoes an edit, or a file is added in one commit and deleted
+in the next. Such files would otherwise stay opened as no-ops, so after opening files both commands revert them:
+
+- Files opened for edit that are unchanged compared to the depot are reverted with `p4 revert -a`. Changed files
+  stay opened.
+- Files opened for add that are missing from disk are reverted.
+- Files opened for delete that git still has (deleted in one commit, restored in a later one) are reverted and
+  restored from git.
+
+Only files git-p4son has authority over are touched: files tracked by git, and files opened for add that are
+missing from disk. Anything else in the changelist, such as binaries that only exist in Perforce and were opened
+by hand, is left alone even when unchanged. Files opened with other actions (`move/add`, `integrate`, ...) are
+also left alone. This step is skipped with `--no-edit`.
+
+Shelving (`--shelve`, `--review`) replaces the whole shelf with the changelist's opened files using
+`p4 shelve -r -a leaveunchanged`, so the shelf never holds stale files, and unchanged files that are still opened
+are left out of it.
+
 ### Review Command
 
 Automate the interactive rebase workflow for creating Swarm reviews. This command generates a rebase todo with `exec` lines that run `git p4son new --review` on the first commit and `git p4son update --shelve` on each subsequent commit, then opens it in your editor for review before executing.
@@ -583,6 +623,40 @@ In interactive mode, each alias is displayed in turn with a prompt:
 git p4son alias clean
 ```
 
+### Writable Command
+
+Writable mode keeps git-tracked files writable, so you can edit them without running `p4 edit` first. git-p4son
+opens changed files in Perforce itself when you run `new`, `update` or `review`. Git-ignored files, such as content
+and other Perforce-only files, stay read-only and are checked out through Perforce as usual.
+
+```sh
+git p4son writable            # Show whether writable mode is on
+git p4son writable enable     # Turn writable mode on, then apply it
+git p4son writable disable    # Turn writable mode off, then apply it
+git p4son writable apply      # Make git-tracked files match the current mode
+```
+
+`apply` makes every git-tracked file writable when the mode is on. When it's off, it makes them read-only, except
+files opened in Perforce in any changelist. On a workspace with the `allwrite` option, making files read-only is
+skipped, since the client spec wants every file writable. Git-ignored files are never changed.
+
+The setting is stored in `.git-p4son/config.toml`:
+
+```toml
+[core]
+writable = true
+```
+
+With the mode on, `sync` makes the files it synced writable again if git tracks them, since Perforce writes synced
+files read-only. Files made read-only outside git-p4son, for example by submitting from P4V, `p4 revert`, or "Get
+Latest" in P4V, stay read-only until a later sync touches them. Run `git p4son writable apply` to fix them right
+away.
+
+This replaces the `post-sync` hook some users run to make every tracked file writable after a sync.
+
+Turning the mode off also makes tracked files whose Perforce type carries the `+w` (always writable) modifier
+read-only. The next sync of such a file makes it writable again.
+
 ### Completion Command
 
 Print the path to a shell completion script:

{git_p4son-0.3.4 → git_p4son-0.4.1}/README.md

@@ -216,10 +216,13 @@ check. Only files with local changes are made read-only for the duration of the
 Perforce would otherwise refuse to overwrite. The same digest check applies to git-ignored files: unchanged ones sync
 normally, and after the sync git-p4son lists the ones Perforce skipped because they were modified locally.
 
+**Writable mode** - With [writable mode](#writable-command) on, the files a sync touches are made writable again after
+the sync if git tracks them. The sync itself works as described above, since the workspace is not `allwrite`.
+
 ## Usage
 
-git-p4son provides nine commands: `init`, `sync`, `sync-split`, `new`, `update`, `review`, `list-changes`,
-`alias`, and `completion`.
+git-p4son provides ten commands: `init`, `sync`, `sync-split`, `new`, `update`, `review`, `list-changes`,
+`alias`, `writable`, and `completion`.
 
 To see help for any command, use `-h`:
 
@@ -251,6 +254,9 @@ The depot root determines which part of the Perforce workspace git-p4son syncs.
 workspace or just the directory's subtree where the git root is placed. The selection is saved in
 `.git-p4son/config.toml` and used by all subsequent commands.
 
+Nothing in `.git-p4son/` belongs in git. The folder has its own `.gitignore` that ignores everything in it, so there
+is no need to list it in the workspace `.gitignore`.
+
 The saved root uses a `$(workspace)` placeholder for the workspace (client) name, e.g.
 `root = "//$(workspace)/Engine"`. git-p4son substitutes the live workspace name each time it runs, so renaming
 the Perforce workspace does not break the config. You can still store a concrete name (e.g. `//my-workspace/Engine`)
@@ -261,12 +267,15 @@ The `.gitignore` is set up using this priority:
 - If `.p4ignore` exists, it is copied to `.gitignore` as a starting point
 - Otherwise, an empty `.gitignore` is created
 
+`init` also asks whether to turn on [writable mode](#writable-command), defaulting to the current setting. It only
+saves the answer; run `git p4son writable apply` once your files are committed to update their permissions.
+
 ### Sync Command
 
 Sync local git repository with a Perforce workspace:
 
 ```sh
-git p4son sync [changelist ...] [--force]
+git p4son sync [changelist ...] [--force] [--dry-run]
 ```
 
 **Arguments:**
@@ -277,6 +286,8 @@ git p4son sync [changelist ...] [--force]
 
 **Options:**
 - `-f, --force`: Allow syncing to changelists older than the current one.
+- `-n, --dry-run`: Print the resolved sync sequence without syncing. The arguments are validated as for a
+  real sync, but nothing else runs: no clean-workspace checks, no hooks, and no prompts.
 
 **Examples:**
 ```sh
@@ -287,6 +298,7 @@ git p4son sync 123 156 178  # sync each changelist in sequence, one commit each
 git p4son sync 123 156 head # sync 123, 156, then the latest changelist
 git p4son sync last-synced
 git p4son sync 12345 --force
+git p4son sync --dry-run    # show the changelists a sync to latest would visit
 ```
 
 #### pre-sync hook
@@ -356,6 +368,10 @@ than the last synced changelist (use `git p4son sync --force` for that).
 Create a new Perforce changelist and add changed files to it. Description will contain an enumerated list of git commits since the base branch.
 Optionally creates a Swarm review.
 
+Opening files requires a clean git workspace, untracked files included; `new` refuses to run otherwise. The check
+is skipped with `--no-edit`. After opening files, unchanged ones are reverted (see
+[Keeping the changelist in step with git](#keeping-the-changelist-in-step-with-git)).
+
 ```sh
 git p4son new -m <message> [alias] [--base-branch BASE_BRANCH] [--force] [--dry-run] [--no-edit] [--no-alias]
                            [--shelve] [--review]
@@ -391,7 +407,10 @@ Update an existing Perforce changelist description. Commits since the base branc
 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.
+edit, and reverts files that are no longer part of the git change (see
+[Keeping the changelist in step with git](#keeping-the-changelist-in-step-with-git)). Opening files requires a
+clean git workspace, untracked files included; `update` refuses to run otherwise. The check is skipped with
+`--no-edit`.
 
 ```sh
 git p4son update [changelist] [--base-branch BASE_BRANCH] [--dry-run] [--no-desc] [--no-edit] [--shelve]
@@ -417,6 +436,27 @@ git p4son update 12345
 git p4son update myalias -b main
 ```
 
+### Keeping the changelist in step with git
+
+`new` and `update` open every file changed since the base branch in the changelist. A file can later stop being
+part of the change, for example when a later commit undoes an edit, or a file is added in one commit and deleted
+in the next. Such files would otherwise stay opened as no-ops, so after opening files both commands revert them:
+
+- Files opened for edit that are unchanged compared to the depot are reverted with `p4 revert -a`. Changed files
+  stay opened.
+- Files opened for add that are missing from disk are reverted.
+- Files opened for delete that git still has (deleted in one commit, restored in a later one) are reverted and
+  restored from git.
+
+Only files git-p4son has authority over are touched: files tracked by git, and files opened for add that are
+missing from disk. Anything else in the changelist, such as binaries that only exist in Perforce and were opened
+by hand, is left alone even when unchanged. Files opened with other actions (`move/add`, `integrate`, ...) are
+also left alone. This step is skipped with `--no-edit`.
+
+Shelving (`--shelve`, `--review`) replaces the whole shelf with the changelist's opened files using
+`p4 shelve -r -a leaveunchanged`, so the shelf never holds stale files, and unchanged files that are still opened
+are left out of it.
+
 ### Review Command
 
 Automate the interactive rebase workflow for creating Swarm reviews. This command generates a rebase todo with `exec` lines that run `git p4son new --review` on the first commit and `git p4son update --shelve` on each subsequent commit, then opens it in your editor for review before executing.
@@ -560,6 +600,40 @@ In interactive mode, each alias is displayed in turn with a prompt:
 git p4son alias clean
 ```
 
+### Writable Command
+
+Writable mode keeps git-tracked files writable, so you can edit them without running `p4 edit` first. git-p4son
+opens changed files in Perforce itself when you run `new`, `update` or `review`. Git-ignored files, such as content
+and other Perforce-only files, stay read-only and are checked out through Perforce as usual.
+
+```sh
+git p4son writable            # Show whether writable mode is on
+git p4son writable enable     # Turn writable mode on, then apply it
+git p4son writable disable    # Turn writable mode off, then apply it
+git p4son writable apply      # Make git-tracked files match the current mode
+```
+
+`apply` makes every git-tracked file writable when the mode is on. When it's off, it makes them read-only, except
+files opened in Perforce in any changelist. On a workspace with the `allwrite` option, making files read-only is
+skipped, since the client spec wants every file writable. Git-ignored files are never changed.
+
+The setting is stored in `.git-p4son/config.toml`:
+
+```toml
+[core]
+writable = true
+```
+
+With the mode on, `sync` makes the files it synced writable again if git tracks them, since Perforce writes synced
+files read-only. Files made read-only outside git-p4son, for example by submitting from P4V, `p4 revert`, or "Get
+Latest" in P4V, stay read-only until a later sync touches them. Run `git p4son writable apply` to fix them right
+away.
+
+This replaces the `post-sync` hook some users run to make every tracked file writable after a sync.
+
+Turning the mode off also makes tracked files whose Perforce type carries the `+w` (always writable) modifier
+read-only. The next sync of such a file makes it writable again.
+
 ### Completion Command
 
 Print the path to a shell completion script:

{git_p4son-0.3.4 → git_p4son-0.4.1}/git_p4son/__init__.py

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

{git_p4son-0.3.4 → git_p4son-0.4.1}/git_p4son/changelist_store.py

@@ -8,6 +8,7 @@ import os
 import re
 
 from . import CONFIG_DIR
+from .config import ensure_config_dir
 from .log import log
 
 
@@ -85,6 +86,7 @@ def save_changelist_alias(name: str, changelist: str, workspace_dir: str, force:
             f'Alias "{name}" already exists (use -f/--force to overwrite)')
         return False
 
+    ensure_config_dir(workspace_dir)
     if not os.path.isdir(changelists_dir):
         log.info(f'Creating {changelists_dir}')
         os.makedirs(changelists_dir, exist_ok=True)

{git_p4son-0.3.4 → git_p4son-0.4.1}/git_p4son/cli.py

@@ -21,6 +21,7 @@ from .common import CommandError, RunError, branch_to_alias
 from .git import get_current_branch, get_head_subject, get_workspace_dir
 from .log import log
 from .complete import run_complete
+from .writable import writable_command
 
 
 def create_parser() -> argparse.ArgumentParser:
@@ -37,6 +38,7 @@ Examples:
   git-p4son sync 123 156 178    # Sync each changelist in sequence, one commit each
   git-p4son sync 123 156 head   # Sync 123, 156, then the latest changelist
   git-p4son sync last-synced    # Re-sync the last synced changelist
+  git-p4son sync --dry-run      # Show the changelists a sync would visit
   git-p4son sync-split          # Sync to latest, your own changelists split out
   git-p4son sync-split 12345    # Same, but stop at changelist 12345
   git-p4son sync-split -u alice -u bob  # Split out alice's and bob's changelists
@@ -46,6 +48,9 @@ Examples:
   git-p4son update --shelve     # Update changelist for current branch and re-shelve
   git-p4son update 12345        # Update changelist 12345
   git-p4son list-changes --base-branch main # List commit subjects since main branch
+  git-p4son writable            # Show whether writable mode is on
+  git-p4son writable enable     # Keep git-tracked files writable
+  git-p4son writable apply      # Make tracked files match the writable mode
         """
     )
 
@@ -99,6 +104,11 @@ Examples:
         action='store_true',
         help='Allow syncing to changelists older than the current one.'
     )
+    sync_parser.add_argument(
+        '-n', '--dry-run',
+        action='store_true',
+        help='Print the resolved sync sequence without syncing'
+    )
 
     # Sync-split subcommand
     sync_split_parser = subparsers.add_parser(
@@ -352,6 +362,40 @@ Examples:
         help='Print the generated rebase todo without executing'
     )
 
+    # Writable subcommand
+    writable_parser = subparsers.add_parser(
+        'writable',
+        help='Show or apply writable mode for git-tracked files',
+        description='Writable mode keeps git-tracked files writable so they '
+        'can be edited without a manual p4 edit. Git-ignored files are left '
+        'to Perforce. Without an action, shows whether the mode is on.'
+    )
+    writable_subparsers = writable_parser.add_subparsers(
+        dest='writable_action',
+        help='Available writable actions',
+        metavar='ACTION'
+    )
+    writable_subparsers.add_parser(
+        'enable',
+        help='Turn writable mode on and make git-tracked files writable',
+        description='Turn writable mode on, then make every git-tracked file '
+        'writable. Sync keeps the files it syncs writable from then on.'
+    )
+    writable_subparsers.add_parser(
+        'disable',
+        help='Turn writable mode off and make git-tracked files read-only',
+        description='Turn writable mode off, then make git-tracked files '
+        'read-only, except files opened in Perforce.'
+    )
+    writable_subparsers.add_parser(
+        'apply',
+        help='Make git-tracked files match the writable mode',
+        description='With writable mode on, make every git-tracked file '
+        'writable. With it off, make them read-only, except files opened in '
+        'Perforce. Use it to fix files made read-only outside git-p4son, '
+        'for example by a submit.'
+    )
+
     # Completion subcommand (prints shell completion script path)
     completion_parser = subparsers.add_parser(
         'completion',
@@ -370,10 +414,11 @@ Examples:
         help='Print the directory instead of the full file path'
     )
 
-    # Hidden _sequence-editor subcommand (used internally by review)
+    # Hidden _sequence-editor subcommand (used internally by review). It is
+    # given no help: argparse lists a subcommand with help=SUPPRESS anyway,
+    # as "==SUPPRESS==", but leaves one without help out of the list.
     seq_editor_parser = subparsers.add_parser(
         '_sequence-editor',
-        help=argparse.SUPPRESS,
     )
     seq_editor_parser.add_argument(
         'filename',
@@ -477,6 +522,8 @@ def run_command(args: argparse.Namespace) -> int:
         return alias_command(args)
     elif args.command == 'review':
         return review_command(args)
+    elif args.command == 'writable':
+        return writable_command(args)
     elif args.command == '_sequence-editor':
         return sequence_editor_command(args)
     else:

{git_p4son-0.3.4 → git_p4son-0.4.1}/git_p4son/common.py

@@ -11,6 +11,7 @@ import subprocess
 import sys
 import threading
 import time
+from contextlib import AbstractContextManager, nullcontext
 from timeit import default_timer as timer
 from datetime import timedelta
 from typing import IO, Callable
@@ -127,6 +128,12 @@ class RunResult:
         self.elapsed: timedelta | None = elapsed
 
 
+# Commands that take a list of files pass it after a `--` separator. With
+# thousands of files synced, printing every one buries the output, so a
+# longer list is logged as a count. Verbose mode still prints it in full.
+_MAX_LOGGED_PATHS = 3
+
+
 def join_command_line(command: list[str]) -> str:
     command_line = ''
     for c in command:
@@ -137,6 +144,30 @@ def join_command_line(command: list[str]) -> str:
     return command_line
 
 
+def _command_line_for_log(command: list[str]) -> str:
+    """The command line as printed, with a long path list summarized."""
+    if log.verbose_mode or '--' not in command:
+        return join_command_line(command)
+    separator = command.index('--')
+    paths = command[separator + 1:]
+    if len(paths) <= _MAX_LOGGED_PATHS:
+        return join_command_line(command)
+    return join_command_line(command[:separator + 1]) + f' <{len(paths)} paths>'
+
+
+def batched_command_log(prefix: list[str], path_count: int,
+                        batch_count: int) -> AbstractContextManager[None]:
+    """Log a command run over a path list in several batches as one line.
+
+    prefix is the command up to and including its `--` separator. A single
+    batch is logged as the command itself."""
+    if batch_count <= 1:
+        return nullcontext()
+    return log.command_batch(
+        join_command_line(prefix)
+        + f' <{path_count} paths in {batch_count} batches>')
+
+
 def run(command: list[str], cwd: str = '.', dry_run: bool = False,
         input: str | None = None,
         env: dict[str, str] | None = None,
@@ -159,7 +190,7 @@ def run(command: list[str], cwd: str = '.', dry_run: bool = False,
         RunResult object with returncode, stdout, and stderr
     """
     use_spinner = input is None and not dry_run
-    log.command(join_command_line(command),
+    log.command(_command_line_for_log(command),
                 truncate_for_spinner=use_spinner)
 
     if dry_run:
@@ -225,6 +256,16 @@ def enqueue_lines(stream: IO[str], output_queue: queue.Queue[str]) -> None:
         output_queue.put(line.rstrip())
 
 
+def _terminate(process: subprocess.Popen) -> None:
+    """Terminate a subprocess, killing it if it does not exit in time."""
+    process.terminate()
+    try:
+        process.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        log.error("Subprocess did not terminate in time. Forcing kill...")
+        process.kill()
+
+
 def run_with_output(command: list[str], cwd: str = '.',
                     on_output: Callable[..., None] | None = None,
                     env: dict[str, str] | None = None) -> RunResult:
@@ -237,12 +278,15 @@ def run_with_output(command: list[str], cwd: str = '.',
         on_output: Callback function for processing output lines
                    If set the funciton will be called with each
                    line and stream (stdout/stderr) as they are written.
+                   An exception raised from it terminates the command
+                   and propagates.
         env: Optional environment variables to add or override
 
     Returns:
         RunResult object with returncode, stdout, and stderr
     """
-    log.command(join_command_line(command), truncate_for_spinner=True)
+    log.command(_command_line_for_log(command),
+                truncate_for_spinner=True)
     log.start_spinner()
 
     start_timestamp = timer()
@@ -320,14 +364,14 @@ def run_with_output(command: list[str], cwd: str = '.',
         except KeyboardInterrupt:
             log.stop_spinner()
             log.error("CTRL-C pressed, terminate subprocess")
-            process.terminate()
-            try:
-                process.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                log.error(
-                    "Subprocess did not terminate in time. Forcing kill...")
-                process.kill()
+            _terminate(process)
             sys.exit(1)
+        except Exception:
+            # on_output raising aborts the command: stop the subprocess
+            # rather than letting it run on unobserved.
+            log.stop_spinner()
+            _terminate(process)
+            raise
 
     log.stop_spinner()
 

{git_p4son-0.3.4 → git_p4son-0.4.1}/git_p4son/complete.py

@@ -14,6 +14,8 @@ from .git import get_current_branch, get_workspace_dir
 from .log import log
 
 _HIDDEN_COMMANDS = frozenset({'complete', 'completion', '_sequence-editor'})
+# Commands whose first positional is a nested action (alias list, ...).
+_COMMANDS_WITH_ACTIONS = frozenset({'alias', 'writable'})
 
 
 def _get_subparsers_action(parser):
@@ -125,15 +127,16 @@ def _complete_positional(command, subcommand, positional_count,
         branch_candidates = _get_branch_candidates(prefix, workspace_dir)
         return branch_candidates + _filter(aliases, prefix)
 
-    if command == 'alias':
-        if subcommand is None and positional_count == 0:
-            nested = _get_subparsers_action(command_parser)
-            if nested and hasattr(nested, '_choices_actions'):
-                candidates = [(ca.dest, ca.help or '')
-                              for ca in nested._choices_actions]
-                return _filter(candidates, prefix)
-            return []
+    if (command in _COMMANDS_WITH_ACTIONS and subcommand is None
+            and positional_count == 0):
+        nested = _get_subparsers_action(command_parser)
+        if nested and hasattr(nested, '_choices_actions'):
+            candidates = [(ca.dest, ca.help or '')
+                          for ca in nested._choices_actions]
+            return _filter(candidates, prefix)
+        return []
 
+    if command == 'alias':
         if subcommand == 'delete' and positional_count == 0:
             branch_candidates = _get_branch_candidates(prefix, workspace_dir)
             return branch_candidates + _filter(aliases, prefix)
@@ -193,7 +196,7 @@ def _complete(parser, words, workspace_dir=None):
                 current_parser = command_parser
             continue
 
-        if command == 'alias' and subcommand is None:
+        if command in _COMMANDS_WITH_ACTIONS and subcommand is None:
             nested = _get_subparsers_action(command_parser)
             if nested and word in nested.choices:
                 subcommand = word

{git_p4son-0.3.4 → git_p4son-0.4.1}/git_p4son/config.py

@@ -12,11 +12,26 @@ from . import CONFIG_DIR
 
 _BARE_KEY_RE = re.compile(r'^[A-Za-z0-9_-]+$')
 
-# Placeholder allowed in a stored depot root, substituted with the live
-# Perforce client (workspace) name each time the root is used. Storing e.g.
-# root = "//$(workspace)/Engine" keeps the config working after the workspace
-# is renamed, at the cost of one client-name lookup per command.
-WORKSPACE_PLACEHOLDER = '$(workspace)'
+
+def ensure_config_dir(workspace_dir: str) -> None:
+    """Create the config dir with a .gitignore that ignores everything in it.
+
+    Nothing in the config dir belongs in git. A .gitignore of its own keeps
+    it out without touching the workspace .gitignore, which may be checked
+    into Perforce. The file is rewritten when its content differs, which
+    also replaces the state.toml-only ignore file of earlier versions."""
+    config_dir = os.path.join(workspace_dir, CONFIG_DIR)
+    os.makedirs(config_dir, exist_ok=True)
+    gitignore = os.path.join(config_dir, '.gitignore')
+    content = '*\n'
+    try:
+        with open(gitignore, encoding='utf-8') as f:
+            if f.read() == content:
+                return
+    except FileNotFoundError:
+        pass
+    with open(gitignore, 'w', encoding='utf-8') as f:
+        f.write(content)
 
 
 def config_path(workspace_dir: str) -> str:
@@ -55,6 +70,7 @@ def save_config(workspace_dir: str, config: dict) -> None:
     merged = load_config(workspace_dir)
     for section, values in config.items():
         merged.setdefault(section, {}).update(values)
+    ensure_config_dir(workspace_dir)
     write_toml(config_path(workspace_dir), merged)
 
 
@@ -94,14 +110,3 @@ def _write_table(f, name: str, table: dict) -> None:
     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')
-
-
-def expand_depot_root(depot_root: str, workspace_name: str) -> str:
-    """Substitute the live workspace name for the $(workspace) placeholder."""
-    return depot_root.replace(WORKSPACE_PLACEHOLDER, workspace_name)