git-p4son 0.3.1__tar.gz → 0.3.2__tar.gz

{git_p4son-0.3.1 → git_p4son-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.3.1
+Version: 0.3.2
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -233,8 +233,8 @@ commit any files that need attention.
 
 ## Usage
 
-git-p4son provides eight commands: `init`, `sync`, `new`, `update`, `review`, `list-changes`, `alias`,
-and `completion`.
+git-p4son provides nine commands: `init`, `sync`, `sync-split`, `new`, `update`, `review`, `list-changes`,
+`alias`, and `completion`.
 
 To see help for any command, use `-h`:
 
@@ -315,6 +315,54 @@ changelists is given, the pre-sync hooks run once, before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs [hooks](#hooks)
 from `.git-p4son/hooks/post-sync/`.
 
+### Sync-Split Command
+
+Sync forward from the last synced changelist, splitting selected users' changelists into their own commits:
+
+```sh
+git p4son sync-split [changelist] [--user NAME ...] [--dry-run]
+```
+
+Syncing straight to the latest changelist lumps your own submitted changelists together with everyone
+else's in a single commit. `sync-split` resolves the sequence for you: it looks up the last synced
+changelist in the git log, asks Perforce which changelists the selected users submitted since then, and
+syncs the changelist submitted immediately before each of those first. The result is a git history where
+every changelist those users submitted is a commit containing nothing but their own change.
+
+By default the selected user is you (the current p4 user), which covers the common case of reviewing your
+own submits one at a time. Repeat `--user` to split out several people's changelists in the same run.
+
+It is equivalent to working out the numbers by hand and running
+`git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
+resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
+all behave exactly as they do for `sync`.
+
+**Arguments:**
+- `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
+  latest changelist affecting the workspace.
+
+**Options:**
+- `-u, --user NAME`: Perforce user whose changelists to split into their own commits. Repeat the flag to
+  select several users. Defaults to the current p4 user (from `p4 info`).
+- `-n, --dry-run`: Print the resolved sync sequence without syncing.
+
+**Examples:**
+```sh
+git p4son sync-split                  # sync to latest, your own changelists split out
+git p4son sync-split head             # same, explicit
+git p4son sync-split 12345            # stop at changelist 12345
+git p4son sync-split --dry-run        # show the sequence that would be synced
+git p4son sync-split -u alice         # split out alice's changelists instead of yours
+git p4son sync-split -u alice -u bob  # split out both alice's and bob's changelists
+```
+
+For example, with the last sync at CL 100 and your own changelists at 102 and 105, `sync-split` resolves
+to `git p4son sync 101 102 104 105 106`, producing five commits where CL 102 and CL 105 each hold only
+your change.
+
+`sync-split` only moves forward: it requires a previous sync to start from, and refuses a target older
+than the last synced changelist (use `git p4son sync --force` for that).
+
 ### New Command
 
 Create a new Perforce changelist and add changed files to it. Description will contain an enumerated list of git commits since the base branch.
@@ -581,6 +629,36 @@ before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs executable hooks from
 `.git-p4son/hooks/post-sync/`.
 
+### Example hooks
+
+The [`examples/hooks/`](examples/hooks/) directory holds ready-made hooks. Nothing installs them for you:
+symlink or copy the one you want into the matching hook directory in your workspace. Symlinking keeps the hook
+up to date with the clone it points at, and on macOS and Linux the executable bit comes from the file in the
+clone, so no `chmod` is needed.
+
+#### block-while-running (pre-sync)
+
+Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
+has loaded:
+
+```sh
+ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
+```
+
+Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
+stays per-project:
+
+```toml
+[hooks.block-while-running]
+processes = ["UnrealEditor", "UnrealLightmass"]
+```
+
+Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers
+`UnrealEditor.exe` on Windows and `UnrealEditor` on macOS. Without that table the hook checks nothing and the
+sync proceeds; a table that is present but malformed aborts the sync rather than silently skipping the check.
+
+Set `GIT_P4SON_SKIP_PROCESS_CHECK=1` to run one sync without the check.
+
 ## Shell Completions
 
 Tab completion is available for bash, zsh, and PowerShell, including commands, flags, and dynamic alias names.

{git_p4son-0.3.1 → git_p4son-0.3.2}/README.md

@@ -210,8 +210,8 @@ commit any files that need attention.
 
 ## Usage
 
-git-p4son provides eight commands: `init`, `sync`, `new`, `update`, `review`, `list-changes`, `alias`,
-and `completion`.
+git-p4son provides nine commands: `init`, `sync`, `sync-split`, `new`, `update`, `review`, `list-changes`,
+`alias`, and `completion`.
 
 To see help for any command, use `-h`:
 
@@ -292,6 +292,54 @@ changelists is given, the pre-sync hooks run once, before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs [hooks](#hooks)
 from `.git-p4son/hooks/post-sync/`.
 
+### Sync-Split Command
+
+Sync forward from the last synced changelist, splitting selected users' changelists into their own commits:
+
+```sh
+git p4son sync-split [changelist] [--user NAME ...] [--dry-run]
+```
+
+Syncing straight to the latest changelist lumps your own submitted changelists together with everyone
+else's in a single commit. `sync-split` resolves the sequence for you: it looks up the last synced
+changelist in the git log, asks Perforce which changelists the selected users submitted since then, and
+syncs the changelist submitted immediately before each of those first. The result is a git history where
+every changelist those users submitted is a commit containing nothing but their own change.
+
+By default the selected user is you (the current p4 user), which covers the common case of reviewing your
+own submits one at a time. Repeat `--user` to split out several people's changelists in the same run.
+
+It is equivalent to working out the numbers by hand and running
+`git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
+resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
+all behave exactly as they do for `sync`.
+
+**Arguments:**
+- `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
+  latest changelist affecting the workspace.
+
+**Options:**
+- `-u, --user NAME`: Perforce user whose changelists to split into their own commits. Repeat the flag to
+  select several users. Defaults to the current p4 user (from `p4 info`).
+- `-n, --dry-run`: Print the resolved sync sequence without syncing.
+
+**Examples:**
+```sh
+git p4son sync-split                  # sync to latest, your own changelists split out
+git p4son sync-split head             # same, explicit
+git p4son sync-split 12345            # stop at changelist 12345
+git p4son sync-split --dry-run        # show the sequence that would be synced
+git p4son sync-split -u alice         # split out alice's changelists instead of yours
+git p4son sync-split -u alice -u bob  # split out both alice's and bob's changelists
+```
+
+For example, with the last sync at CL 100 and your own changelists at 102 and 105, `sync-split` resolves
+to `git p4son sync 101 102 104 105 106`, producing five commits where CL 102 and CL 105 each hold only
+your change.
+
+`sync-split` only moves forward: it requires a previous sync to start from, and refuses a target older
+than the last synced changelist (use `git p4son sync --force` for that).
+
 ### New Command
 
 Create a new Perforce changelist and add changed files to it. Description will contain an enumerated list of git commits since the base branch.
@@ -558,6 +606,36 @@ before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs executable hooks from
 `.git-p4son/hooks/post-sync/`.
 
+### Example hooks
+
+The [`examples/hooks/`](examples/hooks/) directory holds ready-made hooks. Nothing installs them for you:
+symlink or copy the one you want into the matching hook directory in your workspace. Symlinking keeps the hook
+up to date with the clone it points at, and on macOS and Linux the executable bit comes from the file in the
+clone, so no `chmod` is needed.
+
+#### block-while-running (pre-sync)
+
+Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
+has loaded:
+
+```sh
+ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
+```
+
+Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
+stays per-project:
+
+```toml
+[hooks.block-while-running]
+processes = ["UnrealEditor", "UnrealLightmass"]
+```
+
+Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers
+`UnrealEditor.exe` on Windows and `UnrealEditor` on macOS. Without that table the hook checks nothing and the
+sync proceeds; a table that is present but malformed aborts the sync rather than silently skipping the check.
+
+Set `GIT_P4SON_SKIP_PROCESS_CHECK=1` to run one sync without the check.
+
 ## Shell Completions
 
 Tab completion is available for bash, zsh, and PowerShell, including commands, flags, and dynamic alias names.

{git_p4son-0.3.1 → git_p4son-0.3.2}/git_p4son/__init__.py

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

{git_p4son-0.3.1 → git_p4son-0.3.2}/git_p4son/cli.py

@@ -9,6 +9,7 @@ import time
 from importlib.resources import files
 from . import __version__
 from .sync import sync_command
+from .sync_split import sync_split_command
 from .new import new_command
 from .update import update_command
 from .list_changes import list_changes_command
@@ -36,6 +37,9 @@ 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-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
   git-p4son new -m "Fix bug"    # Create changelist, alias defaults to branch name
   git-p4son new -m "Fix bug" --review  # Create changelist, create Swarm review
   git-p4son new -m "Fix bug" --no-alias # Create changelist without saving an alias
@@ -96,6 +100,38 @@ Examples:
         help='Allow syncing to changelists older than the current one.'
     )
 
+    # Sync-split subcommand
+    sync_split_parser = subparsers.add_parser(
+        'sync-split',
+        help='Sync forward, splitting a user\'s changelists into own commits',
+        description='Sync from the last synced changelist up to a target '
+        'changelist (the latest by default), syncing the changelist submitted '
+        'just before each of the selected users\' submits first so that every '
+        'changelist they submitted lands in a git commit of its own.'
+    )
+    sync_split_parser.add_argument(
+        'changelist',
+        nargs='?',
+        default=None,
+        metavar='CHANGELIST',
+        help='Changelist number to sync up to, or "head" for the latest. '
+             'Omit to sync to the latest changelist affecting the workspace'
+    )
+    sync_split_parser.add_argument(
+        '-u', '--user',
+        action='append',
+        default=None,
+        metavar='NAME',
+        help='Perforce user whose changelists to split into their own '
+             'commits. Repeat to select several users. '
+             'Defaults to the current p4 user'
+    )
+    sync_split_parser.add_argument(
+        '-n', '--dry-run',
+        action='store_true',
+        help='Print the resolved sync sequence without syncing'
+    )
+
     # New subcommand
     new_parser = subparsers.add_parser(
         'new',
@@ -429,6 +465,8 @@ def run_command(args: argparse.Namespace) -> int:
 
     if args.command == 'sync':
         return sync_command(args)
+    elif args.command == 'sync-split':
+        return sync_split_command(args)
     elif args.command == 'new':
         return new_command(args)
     elif args.command == 'update':

{git_p4son-0.3.1 → git_p4son-0.3.2}/git_p4son/complete.py

@@ -117,6 +117,10 @@ def _complete_positional(command, subcommand, positional_count,
         return _filter(
             [('head', 'Sync to the latest changelist')], prefix)
 
+    if command == 'sync-split' and positional_count == 0:
+        return _filter(
+            [('head', 'Sync to the latest changelist')], prefix)
+
     if command == 'update' and positional_count == 0:
         branch_candidates = _get_branch_candidates(prefix, workspace_dir)
         return branch_candidates + _filter(aliases, prefix)

{git_p4son-0.3.1 → git_p4son-0.3.2}/git_p4son/perforce.py

@@ -204,6 +204,33 @@ def get_latest_changelist(depot_root: str, workspace_dir: str) -> int:
     return int(fields['change'])
 
 
+@dataclass
+class P4Change:
+    """A submitted changelist affecting the depot root."""
+
+    change: int
+    user: str
+
+
+def get_submitted_changes(depot_root: str, start: int, end: int,
+                          workspace_dir: str) -> list[P4Change]:
+    """List changelists submitted to the depot root in [start, end], oldest first."""
+    res = run(['p4', '-ztag', 'changes', '-s', 'submitted',
+               f'{depot_root}/...@{start},@{end}'], cwd=workspace_dir)
+    records = parse_ztag_multi_output(res.stdout)
+    changes = [P4Change(change=int(r['change']), user=r.get('user', ''))
+               for r in records if 'change' in r]
+    return sorted(changes, key=lambda c: c.change)
+
+
+def get_p4_user(workspace_dir: str) -> str | None:
+    """Get the Perforce user name of the current connection."""
+    res = run(['p4', '-ztag', 'info'], cwd=workspace_dir)
+    fields = parse_ztag_output(res.stdout)
+    user = fields.get('userName')
+    return user or None
+
+
 # --- file operations ---
 
 def get_changelist_for_file(filename: str, workspace_dir: str) -> tuple[str, str] | None:

{git_p4son-0.3.1 → git_p4son-0.3.2}/git_p4son/sync.py

@@ -30,6 +30,7 @@ from .perforce import (
     p4_fstat_file_info,
     p4_get_opened_files,
     p4_sync_preview,
+    P4ClientSpec,
     P4SyncOutputProcessor,
     P4SyncPreviewFile,
 )
@@ -554,28 +555,48 @@ def _sync_pass(changelist: int, label: str, depot_root: str,
     return prep
 
 
-def sync_command(args: argparse.Namespace) -> int:
-    """Execute the sync command."""
-    workspace_dir = args.workspace_dir
-    invocation_dir = vars(args).get('invocation_dir', workspace_dir)
+@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 1
+        return None
 
-    # 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 further down.
     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 1
+        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)
+
+
+def sync_command(args: argparse.Namespace) -> int:
+    """Execute the sync command."""
+    workspace_dir = args.workspace_dir
+    invocation_dir = vars(args).get('invocation_dir', workspace_dir)
+
+    resolved = resolve_depot_root(workspace_dir)
+    if resolved is None:
+        return 1
+    depot_root = resolved.depot_root
+    client_spec = resolved.client_spec
 
     log.heading('Checking git workspace')
     dirty_files = get_dirty_files(workspace_dir)

git_p4son-0.3.2/git_p4son/sync_split.py

@@ -0,0 +1,148 @@
+"""
+Sync-split command implementation for git-p4son.
+"""
+
+import argparse
+
+from .log import log
+from .perforce import (
+    P4Change,
+    get_latest_changelist,
+    get_p4_user,
+    get_submitted_changes,
+)
+from .sync import git_last_sync, resolve_depot_root, sync_command
+
+
+def build_sync_targets(changes: list[P4Change], users: list[str],
+                       last_synced: int, upper: int) -> list[int]:
+    """Build the sync sequence that splits out the given users' changelists.
+
+    changes is every submitted changelist affecting the depot root in
+    [last_synced, upper], oldest first. Each changelist submitted by one of
+    users gets the changelist submitted just before it synced first, so that
+    submit lands in a commit containing nothing else. Changelists at or below
+    last_synced are already in git and dropped, and the sequence always ends
+    at upper.
+    """
+    targets: list[int] = []
+    lowered = {u.lower() for u in users}
+    for i, change in enumerate(changes):
+        if change.change <= last_synced or change.user.lower() not in lowered:
+            continue
+        last = targets[-1] if targets else last_synced
+        if i > 0 and changes[i - 1].change > last:
+            targets.append(changes[i - 1].change)
+            last = targets[-1]
+        if change.change > last:
+            targets.append(change.change)
+    if not targets or upper > targets[-1]:
+        targets.append(upper)
+    return targets
+
+
+def _resolve_users(args: argparse.Namespace, workspace_dir: str) -> list[str]:
+    """Resolve the users whose changelists to split out, or [] on failure.
+
+    Defaults to the current Perforce user when no --user was given. Repeated
+    names are collapsed, keeping the order they were given in.
+    """
+    log.heading('Finding Perforce users')
+    given = args.user or []
+    if not given:
+        current = get_p4_user(workspace_dir)
+        if not current:
+            log.error('Cannot determine the current Perforce user. '
+                      'Pass --user NAME.')
+            return []
+        given = [current]
+
+    users: list[str] = []
+    seen: set[str] = set()
+    for user in given:
+        if user.lower() not in seen:
+            seen.add(user.lower())
+            users.append(user)
+    log.success(', '.join(users))
+    return users
+
+
+def sync_split_command(args: argparse.Namespace) -> int:
+    """Execute the sync-split command."""
+    workspace_dir = args.workspace_dir
+
+    resolved = resolve_depot_root(workspace_dir)
+    if resolved is None:
+        return 1
+    depot_root = resolved.depot_root
+
+    log.heading('Finding last synced changelist')
+    last_sync = git_last_sync(workspace_dir)
+    if not last_sync:
+        log.error('No previous sync found. Run "git p4son sync" once to '
+                  'establish a starting point.')
+        return 1
+    log.success(f'CL {last_sync.changelist}')
+    last_synced = last_sync.changelist
+
+    if args.changelist is None or args.changelist.lower() == 'head':
+        log.heading('Finding latest changelist')
+        upper = get_latest_changelist(depot_root, workspace_dir)
+        log.success(f'CL {upper}')
+    else:
+        try:
+            upper = int(args.changelist)
+        except ValueError:
+            log.error(f'Invalid changelist number: {args.changelist}')
+            return 1
+
+    # sync-split only ever moves forward from the last synced changelist: the
+    # range it scans for the users' submits starts there.
+    if upper == last_synced:
+        log.info('Already synced, nothing to do.')
+        return 0
+    if upper < last_synced:
+        log.error(f'Cannot sync back to CL {upper} '
+                  f'(currently at CL {last_synced}). '
+                  'Use "git p4son sync --force" to sync to an older '
+                  'changelist.')
+        return 1
+
+    users = _resolve_users(args, workspace_dir)
+    if not users:
+        return 1
+
+    # One query covers both jobs: which changelists in the range belong to
+    # the given users, and which changelist was submitted immediately before
+    # each of them (its predecessor in this same list).
+    log.heading(f'Finding changelists submitted to {depot_root} '
+                f'in CL {last_synced}..{upper}')
+    changes = get_submitted_changes(depot_root, last_synced, upper,
+                                    workspace_dir)
+    log.success(f'{len(changes)} changelists')
+
+    lowered = {u.lower() for u in users}
+    matched = [c for c in changes
+               if c.change > last_synced and c.user.lower() in lowered]
+    log.heading('Finding changelists to split into their own commits')
+    if matched:
+        for change in matched:
+            log.info(f'CL {change.change} ({change.user})')
+        label = 'changelist' if len(matched) == 1 else 'changelists'
+        log.success(f'{len(matched)} {label} to split out')
+    else:
+        log.warning('None found, syncing to the target changelist only')
+
+    targets = build_sync_targets(changes, users, last_synced, upper)
+
+    log.heading('Sync sequence')
+    log.success(' '.join(str(cl) for cl in targets))
+
+    if args.dry_run:
+        log.info(f'Would run: git p4son sync '
+                 f'{" ".join(str(cl) for cl in targets)}')
+        return 0
+
+    args.changelist = [str(cl) for cl in targets]
+    args.force = False
+    return sync_command(args)

{git_p4son-0.3.1 → git_p4son-0.3.2}/git_p4son.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.3.1
+Version: 0.3.2
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -233,8 +233,8 @@ commit any files that need attention.
 
 ## Usage
 
-git-p4son provides eight commands: `init`, `sync`, `new`, `update`, `review`, `list-changes`, `alias`,
-and `completion`.
+git-p4son provides nine commands: `init`, `sync`, `sync-split`, `new`, `update`, `review`, `list-changes`,
+`alias`, and `completion`.
 
 To see help for any command, use `-h`:
 
@@ -315,6 +315,54 @@ changelists is given, the pre-sync hooks run once, before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs [hooks](#hooks)
 from `.git-p4son/hooks/post-sync/`.
 
+### Sync-Split Command
+
+Sync forward from the last synced changelist, splitting selected users' changelists into their own commits:
+
+```sh
+git p4son sync-split [changelist] [--user NAME ...] [--dry-run]
+```
+
+Syncing straight to the latest changelist lumps your own submitted changelists together with everyone
+else's in a single commit. `sync-split` resolves the sequence for you: it looks up the last synced
+changelist in the git log, asks Perforce which changelists the selected users submitted since then, and
+syncs the changelist submitted immediately before each of those first. The result is a git history where
+every changelist those users submitted is a commit containing nothing but their own change.
+
+By default the selected user is you (the current p4 user), which covers the common case of reviewing your
+own submits one at a time. Repeat `--user` to split out several people's changelists in the same run.
+
+It is equivalent to working out the numbers by hand and running
+`git p4son sync <before-theirs> <theirs> ... head`, and it delegates to `sync` once the sequence is
+resolved, so [pre-sync and post-sync hooks](#hooks), writable-file merging, and the clean-workspace checks
+all behave exactly as they do for `sync`.
+
+**Arguments:**
+- `changelist` (optional): Changelist number to sync up to, or `head` for the latest. Omit to sync to the
+  latest changelist affecting the workspace.
+
+**Options:**
+- `-u, --user NAME`: Perforce user whose changelists to split into their own commits. Repeat the flag to
+  select several users. Defaults to the current p4 user (from `p4 info`).
+- `-n, --dry-run`: Print the resolved sync sequence without syncing.
+
+**Examples:**
+```sh
+git p4son sync-split                  # sync to latest, your own changelists split out
+git p4son sync-split head             # same, explicit
+git p4son sync-split 12345            # stop at changelist 12345
+git p4son sync-split --dry-run        # show the sequence that would be synced
+git p4son sync-split -u alice         # split out alice's changelists instead of yours
+git p4son sync-split -u alice -u bob  # split out both alice's and bob's changelists
+```
+
+For example, with the last sync at CL 100 and your own changelists at 102 and 105, `sync-split` resolves
+to `git p4son sync 101 102 104 105 106`, producing five commits where CL 102 and CL 105 each hold only
+your change.
+
+`sync-split` only moves forward: it requires a previous sync to start from, and refuses a target older
+than the last synced changelist (use `git p4son sync --force` for that).
+
 ### New Command
 
 Create a new Perforce changelist and add changed files to it. Description will contain an enumerated list of git commits since the base branch.
@@ -581,6 +629,36 @@ before the first sync.
 After a successful `git-p4son sync` that actually performs sync work, git-p4son runs executable hooks from
 `.git-p4son/hooks/post-sync/`.
 
+### Example hooks
+
+The [`examples/hooks/`](examples/hooks/) directory holds ready-made hooks. Nothing installs them for you:
+symlink or copy the one you want into the matching hook directory in your workspace. Symlinking keeps the hook
+up to date with the clone it points at, and on macOS and Linux the executable bit comes from the file in the
+clone, so no `chmod` is needed.
+
+#### block-while-running (pre-sync)
+
+Aborts the sync while a named process is running, so a sync cannot swap out assets that a running editor still
+has loaded:
+
+```sh
+ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
+```
+
+Which processes block a sync is read from your workspace's own `.git-p4son/config.toml`, so a symlinked hook
+stays per-project:
+
+```toml
+[hooks.block-while-running]
+processes = ["UnrealEditor", "UnrealLightmass"]
+```
+
+Names are matched with any `.exe` suffix stripped and case ignored, so a single entry covers
+`UnrealEditor.exe` on Windows and `UnrealEditor` on macOS. Without that table the hook checks nothing and the
+sync proceeds; a table that is present but malformed aborts the sync rather than silently skipping the check.
+
+Set `GIT_P4SON_SKIP_PROCESS_CHECK=1` to run one sync without the check.
+
 ## Shell Completions
 
 Tab completion is available for bash, zsh, and PowerShell, including commands, flags, and dynamic alias names.

{git_p4son-0.3.1 → git_p4son-0.3.2}/git_p4son.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ git_p4son/perforce.py
 git_p4son/review.py
 git_p4son/state.py
 git_p4son/sync.py
+git_p4son/sync_split.py
 git_p4son/update.py
 git_p4son.egg-info/PKG-INFO
 git_p4son.egg-info/SOURCES.txt
@@ -47,4 +48,5 @@ tests/test_new.py
 tests/test_perforce.py
 tests/test_review.py
 tests/test_state.py
-tests/test_sync.py
+tests/test_sync.py
+tests/test_sync_split.py

{git_p4son-0.3.1 → git_p4son-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "git-p4son"
-version = "0.3.1"
+version = "0.3.2"
 description = "Utility for keeping a Perforce workspace and local git repo in sync"
 readme = "README.md"
 requires-python = ">=3.11"

{git_p4son-0.3.1 → git_p4son-0.3.2}/tests/test_complete.py

@@ -136,7 +136,8 @@ class TestComplete(unittest.TestCase):
         self.assertIn('alias', names)
         self.assertIn('review', names)
         self.assertIn('init', names)
-        self.assertEqual(len(names), 7)
+        self.assertIn('sync-split', names)
+        self.assertEqual(len(names), 8)
 
     def test_empty_excludes_complete(self, _ws, _aliases):
         result = _complete(self.parser, [''], workspace_dir='/ws')
@@ -151,7 +152,7 @@ class TestComplete(unittest.TestCase):
     def test_prefix_filters_commands(self, _ws, _aliases):
         result = _complete(self.parser, ['sy'], workspace_dir='/ws')
         names = self._names(result)
-        self.assertEqual(names, ['sync'])
+        self.assertEqual(names, ['sync', 'sync-split'])
 
     def test_hidden_command_not_completed(self, _ws, _aliases):
         result = _complete(self.parser, ['c'], workspace_dir='/ws')

{git_p4son-0.3.1 → git_p4son-0.3.2}/tests/test_perforce.py

@@ -5,8 +5,9 @@ from unittest import mock
 
 from git_p4son.perforce import (
     P4ClientSpec, P4FileInfo, P4SyncPreviewFile, get_client_spec,
-    is_binary_file_type, p4_fstat_file_info, p4_sync_preview,
-    parse_ztag_multi_output, parse_ztag_output,
+    get_p4_user, get_submitted_changes, is_binary_file_type,
+    p4_fstat_file_info, p4_sync_preview, parse_ztag_multi_output,
+    parse_ztag_output,
 )
 from tests.helpers import make_run_result
 
@@ -253,3 +254,48 @@ class TestGetClientSpec(unittest.TestCase):
         ])
         spec = get_client_spec('/ws')
         self.assertIsNone(spec)
+
+
+class TestGetSubmittedChanges(unittest.TestCase):
+    @mock.patch('git_p4son.perforce.run')
+    def test_parses_and_sorts_changes(self, mock_run):
+        # p4 lists newest first; the sequence builder needs oldest first.
+        mock_run.return_value = make_run_result(stdout=[
+            '... change 105',
+            '... user andreas',
+            '... desc Fix the thing',
+            '',
+            '... change 102',
+            '... user colleague',
+            '... desc Some other work',
+            '',
+        ])
+        changes = get_submitted_changes('//myclient', 100, 105, '/ws')
+        self.assertEqual([(c.change, c.user) for c in changes],
+                         [(102, 'colleague'), (105, 'andreas')])
+        mock_run.assert_called_once_with(
+            ['p4', '-ztag', 'changes', '-s', 'submitted',
+             '//myclient/...@100,@105'], cwd='/ws')
+
+    @mock.patch('git_p4son.perforce.run')
+    def test_no_changes_in_range(self, mock_run):
+        mock_run.return_value = make_run_result(stdout=[])
+        self.assertEqual(get_submitted_changes('//myclient', 100, 105, '/ws'),
+                         [])
+
+
+class TestGetP4User(unittest.TestCase):
+    @mock.patch('git_p4son.perforce.run')
+    def test_reads_user_name(self, mock_run):
+        mock_run.return_value = make_run_result(stdout=[
+            '... userName andreas',
+            '... clientName my-ws',
+        ])
+        self.assertEqual(get_p4_user('/ws'), 'andreas')
+        mock_run.assert_called_once_with(
+            ['p4', '-ztag', 'info'], cwd='/ws')
+
+    @mock.patch('git_p4son.perforce.run')
+    def test_missing_user_name(self, mock_run):
+        mock_run.return_value = make_run_result(stdout=['... clientName x'])
+        self.assertIsNone(get_p4_user('/ws'))

git_p4son-0.3.2/tests/test_sync_split.py

@@ -0,0 +1,260 @@
+"""Tests for git_p4son.sync_split module."""
+
+import unittest
+from unittest import mock
+
+from git_p4son.perforce import P4Change
+from git_p4son.sync import LastSync, ResolvedDepot
+from git_p4son.sync_split import (
+    build_sync_targets, sync_split_command,
+)
+
+
+def _changes(*pairs):
+    """Build a change list from (changelist, user) pairs."""
+    return [P4Change(change=cl, user=user) for cl, user in pairs]
+
+
+class TestBuildSyncTargets(unittest.TestCase):
+    """The sequence must isolate each of the user's own changelists in a
+    commit of its own while staying strictly increasing."""
+
+    def test_single_own_changelist(self):
+        changes = _changes((100, 'other'), (101, 'other'),
+                           (102, 'me'), (103, 'other'))
+        targets = build_sync_targets(changes, ['me'], 100, 103)
+        self.assertEqual(targets, [101, 102, 103])
+
+    def test_two_own_changelists(self):
+        changes = _changes((100, 'other'), (101, 'other'), (102, 'me'),
+                           (103, 'other'), (104, 'other'), (105, 'me'),
+                           (106, 'other'))
+        targets = build_sync_targets(changes, ['me'], 100, 106)
+        self.assertEqual(targets, [101, 102, 104, 105, 106])
+
+    def test_back_to_back_own_changelists(self):
+        """A predecessor that is itself one of the user's changelists is
+        already a target, so it must not be repeated."""
+        changes = _changes((100, 'other'), (101, 'other'),
+                           (102, 'me'), (103, 'me'))
+        targets = build_sync_targets(changes, ['me'], 100, 103)
+        self.assertEqual(targets, [101, 102, 103])
+
+    def test_predecessor_is_last_synced(self):
+        """The changelist before the user's own submit is already in git,
+        so only the user's own submit is synced separately."""
+        changes = _changes((100, 'other'), (101, 'me'), (102, 'other'))
+        targets = build_sync_targets(changes, ['me'], 100, 102)
+        self.assertEqual(targets, [101, 102])
+
+    def test_own_changelist_is_the_upper_bound(self):
+        changes = _changes((100, 'other'), (101, 'other'), (102, 'me'))
+        targets = build_sync_targets(changes, ['me'], 100, 102)
+        self.assertEqual(targets, [101, 102])
+
+    def test_no_own_changelists(self):
+        changes = _changes((100, 'other'), (101, 'other'), (102, 'other'))
+        targets = build_sync_targets(changes, ['me'], 100, 102)
+        self.assertEqual(targets, [102])
+
+    def test_no_changes_at_all(self):
+        """Nothing affected the depot root in the range, so the upper bound
+        is still synced: it may be a changelist elsewhere in the depot."""
+        targets = build_sync_targets([], ['me'], 100, 120)
+        self.assertEqual(targets, [120])
+
+    def test_user_match_is_case_insensitive(self):
+        changes = _changes((100, 'other'), (101, 'other'), (102, 'Me'))
+        targets = build_sync_targets(changes, ['me'], 100, 103)
+        self.assertEqual(targets, [101, 102, 103])
+
+    def test_two_users_both_split_out(self):
+        changes = _changes((100, 'other'), (101, 'other'), (102, 'alice'),
+                           (103, 'other'), (104, 'other'), (105, 'bob'),
+                           (106, 'other'))
+        targets = build_sync_targets(changes, ['alice', 'bob'], 100, 106)
+        self.assertEqual(targets, [101, 102, 104, 105, 106])
+
+    def test_adjacent_changelists_from_two_selected_users(self):
+        """alice's changelist is the predecessor of bob's, so it is already
+        a target and must not be repeated."""
+        changes = _changes((100, 'other'), (101, 'other'),
+                           (102, 'alice'), (103, 'bob'))
+        targets = build_sync_targets(changes, ['alice', 'bob'], 100, 103)
+        self.assertEqual(targets, [101, 102, 103])
+
+    def test_unselected_user_is_not_split_out(self):
+        changes = _changes((100, 'other'), (101, 'other'), (102, 'alice'),
+                           (103, 'other'), (104, 'bob'))
+        targets = build_sync_targets(changes, ['alice'], 100, 104)
+        self.assertEqual(targets, [101, 102, 104])
+
+    def test_targets_are_strictly_increasing(self):
+        changes = _changes((100, 'me'), (101, 'me'), (102, 'other'),
+                           (103, 'me'), (104, 'me'), (105, 'other'))
+        targets = build_sync_targets(changes, ['me'], 100, 105)
+        self.assertEqual(targets, sorted(set(targets)))
+        self.assertEqual(targets, [101, 102, 103, 104, 105])
+
+
+class TestSyncMineCommand(unittest.TestCase):
+
+    def setUp(self):
+        patcher = mock.patch(
+            'git_p4son.sync_split.resolve_depot_root',
+            return_value=ResolvedDepot(depot_root='//myclient',
+                                       client_spec=None))
+        patcher.start()
+        self.addCleanup(patcher.stop)
+
+    def _args(self, **overrides):
+        values = dict(changelist=None, user=None, dry_run=False,
+                      workspace_dir='/ws')
+        values.update(overrides)
+        return mock.Mock(**values)
+
+    @mock.patch('git_p4son.sync_split.sync_command', return_value=0)
+    @mock.patch('git_p4son.sync_split.get_submitted_changes')
+    @mock.patch('git_p4son.sync_split.get_p4_user', return_value='me')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=106)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    def test_delegates_resolved_sequence_to_sync(
+            self, _last_sync, _latest, _user, mock_changes, mock_sync):
+        mock_changes.return_value = _changes(
+            (100, 'other'), (101, 'other'), (102, 'me'),
+            (103, 'other'), (104, 'other'), (105, 'me'), (106, 'other'))
+        args = self._args()
+        rc = sync_split_command(args)
+        self.assertEqual(rc, 0)
+        mock_sync.assert_called_once_with(args)
+        self.assertEqual(args.changelist, ['101', '102', '104', '105', '106'])
+        self.assertFalse(args.force)
+
+    @mock.patch('git_p4son.sync_split.sync_command', return_value=0)
+    @mock.patch('git_p4son.sync_split.get_submitted_changes')
+    @mock.patch('git_p4son.sync_split.get_p4_user', return_value='me')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist')
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    def test_explicit_upper_bound_skips_head_lookup(
+            self, _last_sync, mock_latest, _user, mock_changes, mock_sync):
+        mock_changes.return_value = _changes(
+            (100, 'other'), (101, 'other'), (102, 'me'))
+        args = self._args(changelist='103')
+        rc = sync_split_command(args)
+        self.assertEqual(rc, 0)
+        mock_latest.assert_not_called()
+        mock_changes.assert_called_once_with('//myclient', 100, 103, '/ws')
+        self.assertEqual(args.changelist, ['101', '102', '103'])
+
+    @mock.patch('git_p4son.sync_split.sync_command', return_value=0)
+    @mock.patch('git_p4son.sync_split.get_submitted_changes')
+    @mock.patch('git_p4son.sync_split.get_p4_user')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=103)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    def test_user_option_overrides_p4_user(
+            self, _last_sync, _latest, mock_p4_user, mock_changes, _sync):
+        mock_changes.return_value = _changes(
+            (100, 'other'), (101, 'other'), (102, 'colleague'))
+        args = self._args(user=['colleague'])
+        rc = sync_split_command(args)
+        self.assertEqual(rc, 0)
+        mock_p4_user.assert_not_called()
+        self.assertEqual(args.changelist, ['101', '102', '103'])
+
+    @mock.patch('git_p4son.sync_split.sync_command')
+    @mock.patch('git_p4son.sync_split.get_submitted_changes')
+    @mock.patch('git_p4son.sync_split.get_p4_user', return_value='me')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=103)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    def test_dry_run_does_not_sync(
+            self, _last_sync, _latest, _user, mock_changes, mock_sync):
+        mock_changes.return_value = _changes(
+            (100, 'other'), (101, 'other'), (102, 'me'))
+        rc = sync_split_command(self._args(dry_run=True))
+        self.assertEqual(rc, 0)
+        mock_sync.assert_not_called()
+
+    @mock.patch('git_p4son.sync_split.git_last_sync', return_value=None)
+    def test_no_previous_sync_aborts(self, _last_sync):
+        """Without a synced changelist there is no lower bound for the scan."""
+        rc = sync_split_command(self._args())
+        self.assertEqual(rc, 1)
+
+    @mock.patch('git_p4son.sync_split.sync_command')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=100)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    def test_already_at_target_is_a_no_op(
+            self, _last_sync, _latest, mock_sync):
+        rc = sync_split_command(self._args())
+        self.assertEqual(rc, 0)
+        mock_sync.assert_not_called()
+
+    @mock.patch('git_p4son.sync_split.sync_command')
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    def test_older_target_aborts(self, _last_sync, mock_sync):
+        rc = sync_split_command(self._args(changelist='90'))
+        self.assertEqual(rc, 1)
+        mock_sync.assert_not_called()
+
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    def test_invalid_changelist_aborts(self, _last_sync):
+        rc = sync_split_command(self._args(changelist='not-a-number'))
+        self.assertEqual(rc, 1)
+
+    @mock.patch('git_p4son.sync_split.get_p4_user', return_value=None)
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=103)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    def test_unknown_p4_user_aborts(self, _last_sync, _latest, _user):
+        rc = sync_split_command(self._args())
+        self.assertEqual(rc, 1)
+
+    @mock.patch('git_p4son.sync_split.resolve_depot_root', return_value=None)
+    def test_unresolved_depot_root_aborts(self, _resolved):
+        rc = sync_split_command(self._args())
+        self.assertEqual(rc, 1)
+
+    @mock.patch('git_p4son.sync_split.sync_command', return_value=0)
+    @mock.patch('git_p4son.sync_split.get_submitted_changes')
+    @mock.patch('git_p4son.sync_split.get_p4_user')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=106)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    def test_multiple_users_are_all_split_out(
+            self, _last_sync, _latest, mock_p4_user, mock_changes, _sync):
+        mock_changes.return_value = _changes(
+            (100, 'other'), (101, 'other'), (102, 'alice'),
+            (103, 'other'), (104, 'other'), (105, 'bob'), (106, 'other'))
+        args = self._args(user=['alice', 'bob'])
+        rc = sync_split_command(args)
+        self.assertEqual(rc, 0)
+        mock_p4_user.assert_not_called()
+        self.assertEqual(args.changelist, ['101', '102', '104', '105', '106'])
+
+    @mock.patch('git_p4son.sync_split.sync_command', return_value=0)
+    @mock.patch('git_p4son.sync_split.get_submitted_changes')
+    @mock.patch('git_p4son.sync_split.get_p4_user')
+    @mock.patch('git_p4son.sync_split.get_latest_changelist', return_value=103)
+    @mock.patch('git_p4son.sync_split.git_last_sync',
+                return_value=LastSync(changelist=100, commit='abc123'))
+    def test_repeated_user_names_are_collapsed(
+            self, _last_sync, _latest, _p4_user, mock_changes, _sync):
+        """Naming the same user twice (in any casing) must not change the
+        resolved sequence."""
+        mock_changes.return_value = _changes(
+            (100, 'other'), (101, 'other'), (102, 'alice'))
+        args = self._args(user=['alice', 'Alice'])
+        rc = sync_split_command(args)
+        self.assertEqual(rc, 0)
+        self.assertEqual(args.changelist, ['101', '102', '103'])
+
+
+if __name__ == '__main__':
+    unittest.main()