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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.3.1
+Version: 0.3.3
 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,57 @@ 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`. The clean-workspace checks and the pre-sync hooks are the one
+thing that runs earlier: resolving the sequence costs several Perforce queries, so they go first, and a
+dirty workspace or a hook that aborts the sync says so before that work. They run once for the whole sync,
+and not at all for a `--dry-run` or when there is nothing to 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 +632,49 @@ 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. Link it into your workspace's `pre-sync` hook directory - on macOS and Linux:
+
+```sh
+ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
+```
+
+On Windows, from PowerShell. Note that `-Path` is the link to create and `-Target` the existing file, the
+reverse of the `ln -s` argument order, and that `-Target` should be absolute: a relative path is resolved
+against the current directory and quietly produces a broken link.
+
+```powershell
+New-Item -ItemType SymbolicLink `
+  -Path   "C:\p4\my-workspace\.git-p4son\hooks\pre-sync\block-while-running.py" `
+  -Target "C:\src\git-p4son\examples\hooks\pre-sync\block-while-running.py"
+```
+
+Creating a symlink on Windows needs either an elevated shell or Developer Mode enabled (Settings > System >
+For developers). Without one of those, copy the file instead and re-copy it whenever the clone updates.
+
+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.3}/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,57 @@ 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`. The clean-workspace checks and the pre-sync hooks are the one
+thing that runs earlier: resolving the sequence costs several Perforce queries, so they go first, and a
+dirty workspace or a hook that aborts the sync says so before that work. They run once for the whole sync,
+and not at all for a `--dry-run` or when there is nothing to 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 +609,49 @@ 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. Link it into your workspace's `pre-sync` hook directory - on macOS and Linux:
+
+```sh
+ln -s /path/to/git-p4son/examples/hooks/pre-sync/block-while-running.py .git-p4son/hooks/pre-sync/
+```
+
+On Windows, from PowerShell. Note that `-Path` is the link to create and `-Target` the existing file, the
+reverse of the `ln -s` argument order, and that `-Target` should be absolute: a relative path is resolved
+against the current directory and quietly produces a broken link.
+
+```powershell
+New-Item -ItemType SymbolicLink `
+  -Path   "C:\p4\my-workspace\.git-p4son\hooks\pre-sync\block-while-running.py" `
+  -Target "C:\src\git-p4son\examples\hooks\pre-sync\block-while-running.py"
+```
+
+Creating a symlink on Windows needs either an elevated shell or Developer Mode enabled (Settings > System >
+For developers). Without one of those, copy the file instead and re-copy it whenever the clone updates.
+
+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.3}/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.3"
 __author__ = "Andreas Andersson"
 __email__ = "andreas@neoboid.com"

{git_p4son-0.3.1 → git_p4son-0.3.3}/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.3}/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.3}/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: