git-p4son 0.3.3__tar.gz → 0.4.0__tar.gz

{git_p4son-0.3.3 → git_p4son-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.3.3
+Version: 0.4.0
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -231,10 +231,21 @@ be managed manually or via Perforce directly.
 After syncing, git-p4son prints a summary of how each writable file was handled, and instructs you to review and
 commit any files that need attention.
 
+**Workspaces with `allwrite`** - When your client spec has the `allwrite` option, every file is writable by design,
+so the read-only flag carries no information about local changes. git-p4son classifies files exactly as above (the
+verdict comes from git, not from the flag), but leaves the write bit alone on files it finds unchanged: with
+`noclobber` Perforce compares digests before refusing to overwrite a writable file, and unchanged files pass that
+check. Only files with local changes are made read-only for the duration of the sync, since those are the ones
+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`:
 
@@ -276,6 +287,9 @@ 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:
@@ -371,6 +385,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]
@@ -406,7 +424,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]
@@ -432,6 +453,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.
@@ -575,6 +617,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.3 → git_p4son-0.4.0}/README.md

@@ -208,10 +208,21 @@ be managed manually or via Perforce directly.
 After syncing, git-p4son prints a summary of how each writable file was handled, and instructs you to review and
 commit any files that need attention.
 
+**Workspaces with `allwrite`** - When your client spec has the `allwrite` option, every file is writable by design,
+so the read-only flag carries no information about local changes. git-p4son classifies files exactly as above (the
+verdict comes from git, not from the flag), but leaves the write bit alone on files it finds unchanged: with
+`noclobber` Perforce compares digests before refusing to overwrite a writable file, and unchanged files pass that
+check. Only files with local changes are made read-only for the duration of the sync, since those are the ones
+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`:
 
@@ -253,6 +264,9 @@ 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:
@@ -348,6 +362,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]
@@ -383,7 +401,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]
@@ -409,6 +430,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.
@@ -552,6 +594,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.3 → git_p4son-0.4.0}/git_p4son/__init__.py

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

{git_p4son-0.3.3 → git_p4son-0.4.0}/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:
@@ -46,6 +47,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
         """
     )
 
@@ -352,6 +356,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',
@@ -477,6 +515,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.3 → git_p4son-0.4.0}/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:
@@ -242,7 +273,8 @@ def run_with_output(command: list[str], cwd: str = '.',
     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()

{git_p4son-0.3.3 → git_p4son-0.4.0}/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.3 → git_p4son-0.4.0}/git_p4son/config.py

@@ -12,12 +12,6 @@ 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 config_path(workspace_dir: str) -> str:
     """Return the path to the config file."""
@@ -94,14 +88,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)

git_p4son-0.4.0/git_p4son/depot.py

@@ -0,0 +1,62 @@
+"""
+Depot root resolution for git-p4son.
+
+The depot root is the Perforce path git-p4son syncs, stored in
+.git-p4son/config.toml. This module reads it, expands the $(workspace)
+placeholder, and resolves it into the path Perforce commands run against.
+"""
+
+from dataclasses import dataclass
+
+from .config import load_config
+from .log import log
+from .perforce import P4ClientSpec, get_client_spec
+
+# 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 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)
+
+
+@dataclass
+class ResolvedDepot:
+    """The configured depot root with any placeholder expanded, plus the
+    client spec it was resolved against."""
+    depot_root: str
+    client_spec: P4ClientSpec | None
+
+
+def resolve_depot_root(workspace_dir: str) -> ResolvedDepot | None:
+    """Resolve the configured depot root, or None (with an error logged).
+
+    The client spec is queried once here: its name resolves a $(workspace)
+    placeholder in the depot root, and its line-ending/clobber options feed
+    the writable-file handling in sync.
+    """
+    log.heading('Finding depot root')
+    depot_root = get_depot_root(workspace_dir)
+    if not depot_root:
+        log.error('No depot root configured. Run "git p4son init" first.')
+        return None
+
+    client_spec = get_client_spec(workspace_dir)
+    if WORKSPACE_PLACEHOLDER in depot_root and not client_spec:
+        log.error('Cannot resolve $(workspace) in depot root: not inside a '
+                  'Perforce workspace')
+        return None
+    if client_spec:
+        depot_root = expand_depot_root(depot_root, client_spec.name)
+    log.success(depot_root)
+    return ResolvedDepot(depot_root=depot_root, client_spec=client_spec)

{git_p4son-0.3.3 → git_p4son-0.4.0}/git_p4son/git.py

@@ -10,6 +10,7 @@ import re
 from .common import (
     CommandError,
     RunError,
+    batched_command_log,
     normalize_workspace_path,
     run,
     run_with_output,
@@ -252,18 +253,28 @@ def get_tracked_files(filepaths: list[str], workspace_dir: str) -> set[str]:
     tracked: set[str] = set()
     chunks = _chunk_paths_by_length(
         list(by_git_path), _PATHSPEC_LENGTH_BUDGET)
-    for chunk in chunks:
-        # -z output is NUL-separated and verbatim; without it paths with
-        # non-ASCII characters are C-quoted and would never match.
-        result = run(['git', 'ls-files', '-z', '--'] + chunk,
-                     cwd=workspace_dir)
-        for line in result.stdout:
-            for git_path in line.split('\0'):
-                if git_path in by_git_path:
-                    tracked.add(by_git_path[git_path])
+    # -z output is NUL-separated and verbatim; without it paths with
+    # non-ASCII characters are C-quoted and would never match.
+    command = ['git', 'ls-files', '-z', '--']
+    with batched_command_log(command, len(by_git_path), len(chunks)):
+        for chunk in chunks:
+            result = run(command + chunk, cwd=workspace_dir)
+            for line in result.stdout:
+                for git_path in line.split('\0'):
+                    if git_path in by_git_path:
+                        tracked.add(by_git_path[git_path])
     return tracked
 
 
+def list_tracked_files(workspace_dir: str) -> list[str]:
+    """Return every file tracked by git, as repo-relative slash paths."""
+    # -z output is NUL-separated and verbatim, so non-ASCII paths come back
+    # as-is rather than C-quoted. run() splits its output on newlines, so
+    # they are rejoined first in case a path contains one.
+    result = run(['git', 'ls-files', '-z'], cwd=workspace_dir)
+    return [path for path in '\n'.join(result.stdout).split('\0') if path]
+
+
 # --- file retrieval ---
 
 def get_file_at_commit(filepath: str, commit: str,
@@ -361,14 +372,23 @@ def find_base_commits(filepaths: list[str], before_commit: str,
     by_git_path = {fp.replace('\\', '/'): fp for fp in filepaths}
     chunks = _chunk_paths_by_length(
         list(by_git_path), _PATHSPEC_LENGTH_BUDGET)
-    for chunk in chunks:
-        chunk_result = _find_base_commits_chunk(
-            chunk, before_commit, workspace_dir)
-        for git_path, sha in chunk_result.items():
-            result[by_git_path[git_path]] = sha
+    with batched_command_log(_find_base_commits_command(before_commit),
+                             len(by_git_path), len(chunks)):
+        for chunk in chunks:
+            chunk_result = _find_base_commits_chunk(
+                chunk, before_commit, workspace_dir)
+            for git_path, sha in chunk_result.items():
+                result[by_git_path[git_path]] = sha
     return result
 
 
+def _find_base_commits_command(before_commit: str) -> list[str]:
+    """The history walk behind find_base_commits, up to its `--`."""
+    return ['git', '-c', 'core.quotePath=false', 'log', '--no-renames',
+            '--name-status', '--pretty=format:%x01%H%x01%s',
+            before_commit, '--']
+
+
 def _find_base_commits_chunk(git_paths: list[str], before_commit: str,
                              workspace_dir: str) -> dict[str, str | None]:
     """One newest-first history walk resolving baselines for git_paths.
@@ -378,11 +398,8 @@ def _find_base_commits_chunk(git_paths: list[str], before_commit: str,
     no sync commit ever touched. core.quotePath is disabled so non-ASCII
     paths in --name-status output match the input verbatim."""
     result: dict[str, str | None] = dict.fromkeys(git_paths)
-    res = run(
-        ['git', '-c', 'core.quotePath=false', 'log', '--no-renames',
-         '--name-status', '--pretty=format:%x01%H%x01%s',
-         before_commit, '--'] + git_paths,
-        cwd=workspace_dir, fail_on_returncode=False)
+    res = run(_find_base_commits_command(before_commit) + git_paths,
+              cwd=workspace_dir, fail_on_returncode=False)
     if res.returncode != 0:
         return result