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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.4.0
+Version: 0.4.1
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -277,6 +277,9 @@ The depot root determines which part of the Perforce workspace git-p4son syncs.
 workspace or just the directory's subtree where the git root is placed. The selection is saved in
 `.git-p4son/config.toml` and used by all subsequent commands.
 
+Nothing in `.git-p4son/` belongs in git. The folder has its own `.gitignore` that ignores everything in it, so there
+is no need to list it in the workspace `.gitignore`.
+
 The saved root uses a `$(workspace)` placeholder for the workspace (client) name, e.g.
 `root = "//$(workspace)/Engine"`. git-p4son substitutes the live workspace name each time it runs, so renaming
 the Perforce workspace does not break the config. You can still store a concrete name (e.g. `//my-workspace/Engine`)
@@ -295,7 +298,7 @@ saves the answer; run `git p4son writable apply` once your files are committed t
 Sync local git repository with a Perforce workspace:
 
 ```sh
-git p4son sync [changelist ...] [--force]
+git p4son sync [changelist ...] [--force] [--dry-run]
 ```
 
 **Arguments:**
@@ -306,6 +309,8 @@ git p4son sync [changelist ...] [--force]
 
 **Options:**
 - `-f, --force`: Allow syncing to changelists older than the current one.
+- `-n, --dry-run`: Print the resolved sync sequence without syncing. The arguments are validated as for a
+  real sync, but nothing else runs: no clean-workspace checks, no hooks, and no prompts.
 
 **Examples:**
 ```sh
@@ -316,6 +321,7 @@ git p4son sync 123 156 178  # sync each changelist in sequence, one commit each
 git p4son sync 123 156 head # sync 123, 156, then the latest changelist
 git p4son sync last-synced
 git p4son sync 12345 --force
+git p4son sync --dry-run    # show the changelists a sync to latest would visit
 ```
 
 #### pre-sync hook

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

@@ -254,6 +254,9 @@ The depot root determines which part of the Perforce workspace git-p4son syncs.
 workspace or just the directory's subtree where the git root is placed. The selection is saved in
 `.git-p4son/config.toml` and used by all subsequent commands.
 
+Nothing in `.git-p4son/` belongs in git. The folder has its own `.gitignore` that ignores everything in it, so there
+is no need to list it in the workspace `.gitignore`.
+
 The saved root uses a `$(workspace)` placeholder for the workspace (client) name, e.g.
 `root = "//$(workspace)/Engine"`. git-p4son substitutes the live workspace name each time it runs, so renaming
 the Perforce workspace does not break the config. You can still store a concrete name (e.g. `//my-workspace/Engine`)
@@ -272,7 +275,7 @@ saves the answer; run `git p4son writable apply` once your files are committed t
 Sync local git repository with a Perforce workspace:
 
 ```sh
-git p4son sync [changelist ...] [--force]
+git p4son sync [changelist ...] [--force] [--dry-run]
 ```
 
 **Arguments:**
@@ -283,6 +286,8 @@ git p4son sync [changelist ...] [--force]
 
 **Options:**
 - `-f, --force`: Allow syncing to changelists older than the current one.
+- `-n, --dry-run`: Print the resolved sync sequence without syncing. The arguments are validated as for a
+  real sync, but nothing else runs: no clean-workspace checks, no hooks, and no prompts.
 
 **Examples:**
 ```sh
@@ -293,6 +298,7 @@ git p4son sync 123 156 178  # sync each changelist in sequence, one commit each
 git p4son sync 123 156 head # sync 123, 156, then the latest changelist
 git p4son sync last-synced
 git p4son sync 12345 --force
+git p4son sync --dry-run    # show the changelists a sync to latest would visit
 ```
 
 #### pre-sync hook

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

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

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

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

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

@@ -38,6 +38,7 @@ Examples:
   git-p4son sync 123 156 178    # Sync each changelist in sequence, one commit each
   git-p4son sync 123 156 head   # Sync 123, 156, then the latest changelist
   git-p4son sync last-synced    # Re-sync the last synced changelist
+  git-p4son sync --dry-run      # Show the changelists a sync would visit
   git-p4son sync-split          # Sync to latest, your own changelists split out
   git-p4son sync-split 12345    # Same, but stop at changelist 12345
   git-p4son sync-split -u alice -u bob  # Split out alice's and bob's changelists
@@ -103,6 +104,11 @@ Examples:
         action='store_true',
         help='Allow syncing to changelists older than the current one.'
     )
+    sync_parser.add_argument(
+        '-n', '--dry-run',
+        action='store_true',
+        help='Print the resolved sync sequence without syncing'
+    )
 
     # Sync-split subcommand
     sync_split_parser = subparsers.add_parser(
@@ -408,10 +414,11 @@ Examples:
         help='Print the directory instead of the full file path'
     )
 
-    # Hidden _sequence-editor subcommand (used internally by review)
+    # Hidden _sequence-editor subcommand (used internally by review). It is
+    # given no help: argparse lists a subcommand with help=SUPPRESS anyway,
+    # as "==SUPPRESS==", but leaves one without help out of the list.
     seq_editor_parser = subparsers.add_parser(
         '_sequence-editor',
-        help=argparse.SUPPRESS,
     )
     seq_editor_parser.add_argument(
         'filename',

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

@@ -256,6 +256,16 @@ def enqueue_lines(stream: IO[str], output_queue: queue.Queue[str]) -> None:
         output_queue.put(line.rstrip())
 
 
+def _terminate(process: subprocess.Popen) -> None:
+    """Terminate a subprocess, killing it if it does not exit in time."""
+    process.terminate()
+    try:
+        process.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        log.error("Subprocess did not terminate in time. Forcing kill...")
+        process.kill()
+
+
 def run_with_output(command: list[str], cwd: str = '.',
                     on_output: Callable[..., None] | None = None,
                     env: dict[str, str] | None = None) -> RunResult:
@@ -268,6 +278,8 @@ def run_with_output(command: list[str], cwd: str = '.',
         on_output: Callback function for processing output lines
                    If set the funciton will be called with each
                    line and stream (stdout/stderr) as they are written.
+                   An exception raised from it terminates the command
+                   and propagates.
         env: Optional environment variables to add or override
 
     Returns:
@@ -352,14 +364,14 @@ def run_with_output(command: list[str], cwd: str = '.',
         except KeyboardInterrupt:
             log.stop_spinner()
             log.error("CTRL-C pressed, terminate subprocess")
-            process.terminate()
-            try:
-                process.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                log.error(
-                    "Subprocess did not terminate in time. Forcing kill...")
-                process.kill()
+            _terminate(process)
             sys.exit(1)
+        except Exception:
+            # on_output raising aborts the command: stop the subprocess
+            # rather than letting it run on unobserved.
+            log.stop_spinner()
+            _terminate(process)
+            raise
 
     log.stop_spinner()
 

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

@@ -13,6 +13,27 @@ from . import CONFIG_DIR
 _BARE_KEY_RE = re.compile(r'^[A-Za-z0-9_-]+$')
 
 
+def ensure_config_dir(workspace_dir: str) -> None:
+    """Create the config dir with a .gitignore that ignores everything in it.
+
+    Nothing in the config dir belongs in git. A .gitignore of its own keeps
+    it out without touching the workspace .gitignore, which may be checked
+    into Perforce. The file is rewritten when its content differs, which
+    also replaces the state.toml-only ignore file of earlier versions."""
+    config_dir = os.path.join(workspace_dir, CONFIG_DIR)
+    os.makedirs(config_dir, exist_ok=True)
+    gitignore = os.path.join(config_dir, '.gitignore')
+    content = '*\n'
+    try:
+        with open(gitignore, encoding='utf-8') as f:
+            if f.read() == content:
+                return
+    except FileNotFoundError:
+        pass
+    with open(gitignore, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+
 def config_path(workspace_dir: str) -> str:
     """Return the path to the config file."""
     return os.path.join(workspace_dir, CONFIG_DIR, 'config.toml')
@@ -49,6 +70,7 @@ def save_config(workspace_dir: str, config: dict) -> None:
     merged = load_config(workspace_dir)
     for section, values in config.items():
         merged.setdefault(section, {}).update(values)
+    ensure_config_dir(workspace_dir)
     write_toml(config_path(workspace_dir), merged)
 
 

{git_p4son-0.4.0 → git_p4son-0.4.1}/git_p4son/perforce.py

@@ -452,6 +452,16 @@ def parse_p4_sync_line(line: str) -> tuple[str | None, str | None]:
     return (None, None)
 
 
+# p4 writes a synced file to a temp file and renames it into place. On
+# Windows the rename fails when another process holds the target open, e.g.
+# an editor with the asset loaded, leaving the file unsynced.
+_RENAME_FAILED_PREFIX = 'rename: failed to rename '
+
+
+class P4SyncAbortError(CommandError):
+    """Raised to stop a p4 sync that can no longer succeed."""
+
+
 class P4SyncOutputProcessor:
     """Process p4 sync output in real-time."""
 
@@ -465,6 +475,14 @@ class P4SyncOutputProcessor:
             log.info('all files up to date')
             return
 
+        if line.startswith(_RENAME_FAILED_PREFIX):
+            log.error(line)
+            raise P4SyncAbortError(
+                'Aborting sync: p4 could not replace a file, most likely '
+                'because another process has it open. The workspace is left '
+                'partially synced: close that process, then commit or '
+                'restore the synced files before syncing again.')
+
         mode, filename = parse_p4_sync_line(line)
         if not mode or not filename:
             log.warning(f'Unparsable line: {line}')

{git_p4son-0.4.0 → git_p4son-0.4.1}/git_p4son/review.py

@@ -10,6 +10,7 @@ import os
 import shlex
 import subprocess
 from . import CONFIG_DIR
+from .config import ensure_config_dir
 from .changelist_store import alias_exists, validate_alias_name
 from .git import get_commit_lines_since, resolve_editor
 from .log import log
@@ -112,6 +113,7 @@ def review_command(args: argparse.Namespace) -> int:
 
     # Write todo to .git-p4son/reviews/todo
     reviews_dir = _reviews_dir(workspace_dir)
+    ensure_config_dir(workspace_dir)
     os.makedirs(reviews_dir, exist_ok=True)
     todo_file = _todo_path(workspace_dir)
     with open(todo_file, 'w') as f:

git_p4son-0.4.1/git_p4son/state.py

@@ -0,0 +1,38 @@
+"""
+Local, per-user state for git-p4son.
+
+Stored in .git-p4son/state.toml. State here reflects a single user's workspace
+and preferences, e.g. dismissed warnings.
+"""
+
+import os
+
+from . import CONFIG_DIR
+from .config import ensure_config_dir, load_toml, write_toml
+
+
+def state_path(workspace_dir: str) -> str:
+    """Return the path to the local state file."""
+    return os.path.join(workspace_dir, CONFIG_DIR, 'state.toml')
+
+
+def _load(workspace_dir: str) -> dict:
+    return load_toml(state_path(workspace_dir))
+
+
+def _save(workspace_dir: str, state: dict) -> None:
+    ensure_config_dir(workspace_dir)
+    write_toml(state_path(workspace_dir), state)
+
+
+def is_clobber_warning_dismissed(workspace_dir: str) -> bool:
+    """Return whether the user permanently dismissed the clobber warning."""
+    return bool(_load(workspace_dir).get('clobber', {})
+                .get('dismiss_warning', False))
+
+
+def dismiss_clobber_warning(workspace_dir: str) -> None:
+    """Persist that the clobber warning should never be shown again."""
+    state = _load(workspace_dir)
+    state.setdefault('clobber', {})['dismiss_warning'] = True
+    _save(workspace_dir, state)

{git_p4son-0.4.0 → git_p4son-0.4.1}/git_p4son/sync.py

@@ -821,6 +821,17 @@ def sync_command(args: argparse.Namespace) -> int:
             return 0
         targets = resolved_targets
 
+    # A dry run stops once the sequence is known: it syncs nothing, so it
+    # skips the clobber prompt, the workspace checks and the hooks.
+    if vars(args).get('dry_run', False):
+        log.heading('Sync sequence')
+        if resync_last_synced:
+            log.success(f'{last_sync.changelist} ({LAST_SYNCED_LABEL})')
+        else:
+            log.success(' '.join(str(cl) for cl, _ in targets))
+        log.info('Dry run, nothing synced.')
+        return 0
+
     # Workspace line ending governs how staged git content is normalized so
     # the post-sync merge doesn't conflict on LF-vs-CRLF differences alone.
     # The clobber option changes whether git-ignored writable files survive

{git_p4son-0.4.0 → git_p4son-0.4.1}/git_p4son.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.4.0
+Version: 0.4.1
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -277,6 +277,9 @@ The depot root determines which part of the Perforce workspace git-p4son syncs.
 workspace or just the directory's subtree where the git root is placed. The selection is saved in
 `.git-p4son/config.toml` and used by all subsequent commands.
 
+Nothing in `.git-p4son/` belongs in git. The folder has its own `.gitignore` that ignores everything in it, so there
+is no need to list it in the workspace `.gitignore`.
+
 The saved root uses a `$(workspace)` placeholder for the workspace (client) name, e.g.
 `root = "//$(workspace)/Engine"`. git-p4son substitutes the live workspace name each time it runs, so renaming
 the Perforce workspace does not break the config. You can still store a concrete name (e.g. `//my-workspace/Engine`)
@@ -295,7 +298,7 @@ saves the answer; run `git p4son writable apply` once your files are committed t
 Sync local git repository with a Perforce workspace:
 
 ```sh
-git p4son sync [changelist ...] [--force]
+git p4son sync [changelist ...] [--force] [--dry-run]
 ```
 
 **Arguments:**
@@ -306,6 +309,8 @@ git p4son sync [changelist ...] [--force]
 
 **Options:**
 - `-f, --force`: Allow syncing to changelists older than the current one.
+- `-n, --dry-run`: Print the resolved sync sequence without syncing. The arguments are validated as for a
+  real sync, but nothing else runs: no clean-workspace checks, no hooks, and no prompts.
 
 **Examples:**
 ```sh
@@ -316,6 +321,7 @@ git p4son sync 123 156 178  # sync each changelist in sequence, one commit each
 git p4son sync 123 156 head # sync 123, 156, then the latest changelist
 git p4son sync last-synced
 git p4son sync 12345 --force
+git p4son sync --dry-run    # show the changelists a sync to latest would visit
 ```
 
 #### pre-sync hook

{git_p4son-0.4.0 → git_p4son-0.4.1}/pyproject.toml

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

{git_p4son-0.4.0 → git_p4son-0.4.1}/tests/test_changelist_store.py

@@ -4,6 +4,7 @@ import os
 import tempfile
 import unittest
 
+from git_p4son import CONFIG_DIR
 from git_p4son.changelist_store import (
     delete_changelist_alias,
     load_changelist_alias,
@@ -29,6 +30,12 @@ class TestAliasStoreValidatesNames(unittest.TestCase):
         self.assertTrue(delete_changelist_alias('feature', self.ws))
         self.assertIsNone(load_changelist_alias('feature', self.ws))
 
+    def test_save_ensures_config_gitignore(self):
+        save_changelist_alias('feature', '123', self.ws)
+        gitignore = os.path.join(self.ws, CONFIG_DIR, '.gitignore')
+        with open(gitignore, encoding='utf-8') as f:
+            self.assertEqual(f.read(), '*\n')
+
     def test_load_rejects_path_traversal(self):
         # The store directory must exist for the relative path to resolve.
         save_changelist_alias('some-alias', '1', self.ws)

{git_p4son-0.4.0 → git_p4son-0.4.1}/tests/test_cli.py

@@ -47,6 +47,12 @@ class TestCreateParser(unittest.TestCase):
         args = self.parser.parse_args(['sync', '100', '-f'])
         self.assertTrue(args.force)
 
+    def test_sync_command_dry_run(self):
+        self.assertFalse(self.parser.parse_args(['sync']).dry_run)
+        for flag in ('--dry-run', '-n'):
+            args = self.parser.parse_args(['sync', flag])
+            self.assertTrue(args.dry_run)
+
     def test_new_command_no_message(self):
         args = self.parser.parse_args(['new'])
         self.assertEqual(args.command, 'new')
@@ -122,6 +128,11 @@ class TestCreateParser(unittest.TestCase):
             with contextlib.redirect_stderr(io.StringIO()):
                 self.parser.parse_args(['update', '100', '-s', 'abc'])
 
+    def test_sequence_editor_hidden_from_help(self):
+        help_text = self.parser.format_help()
+        self.assertNotIn('_sequence-editor', help_text)
+        self.assertNotIn('SUPPRESS', help_text)
+
     def test_version_flag(self):
         with self.assertRaises(SystemExit) as ctx:
             self.parser.parse_args(['--version'])

{git_p4son-0.4.0 → git_p4son-0.4.1}/tests/test_common.py

@@ -4,6 +4,7 @@ import os
 import subprocess
 import sys
 import tempfile
+import time
 import unittest
 from unittest import mock
 
@@ -408,6 +409,24 @@ class TestRunWithOutput(unittest.TestCase):
         self.assertEqual(result.stderr[-1], 'err499')
         self.assertEqual(len(callback_lines), 5500)
 
+    def test_callback_exception_terminates_process(self):
+        """Raising from on_output stops the command instead of waiting."""
+        code = ('import sys, time\n'
+                'print("bad", flush=True)\n'
+                'time.sleep(60)\n')
+
+        def callback(line, stream):
+            raise CommandError(f'abort on {line}')
+
+        start = time.monotonic()
+        with mock.patch('git_p4son.common.log') as mock_log:
+            with self.assertRaises(CommandError) as ctx:
+                run_with_output([sys.executable, '-c', code],
+                                on_output=callback)
+        self.assertEqual(str(ctx.exception), 'abort on bad')
+        self.assertLess(time.monotonic() - start, 30)
+        mock_log.stop_spinner.assert_called_once()
+
 
 class TestMissingExecutable(unittest.TestCase):
     def test_run_stops_spinner_and_raises(self):

{git_p4son-0.4.0 → git_p4son-0.4.1}/tests/test_complete.py

@@ -201,6 +201,8 @@ class TestComplete(unittest.TestCase):
         names = self._names(result)
         self.assertIn('-f', names)
         self.assertIn('--force', names)
+        self.assertIn('-n', names)
+        self.assertIn('--dry-run', names)
 
     # -- new command --
 

{git_p4son-0.4.0 → git_p4son-0.4.1}/tests/test_config.py

@@ -1,17 +1,59 @@
 """Tests for git_p4son.config module."""
 
 import os
+import subprocess
 import tempfile
 import unittest
 
 from git_p4son import CONFIG_DIR
 from git_p4son.config import (
     config_path,
+    ensure_config_dir,
     load_config,
     save_config,
 )
 
 
+def _read_config_gitignore(workspace_dir):
+    with open(os.path.join(workspace_dir, CONFIG_DIR, '.gitignore'),
+              encoding='utf-8') as f:
+        return f.read()
+
+
+class TestEnsureConfigDir(unittest.TestCase):
+    def setUp(self):
+        self._tempdir = tempfile.TemporaryDirectory()
+        self.ws = self._tempdir.name
+
+    def tearDown(self):
+        self._tempdir.cleanup()
+
+    def test_creates_dir_ignoring_everything(self):
+        ensure_config_dir(self.ws)
+        self.assertEqual(_read_config_gitignore(self.ws), '*\n')
+
+    def test_replaces_state_only_gitignore(self):
+        """Earlier versions ignored only state.toml."""
+        os.makedirs(os.path.join(self.ws, CONFIG_DIR))
+        with open(os.path.join(self.ws, CONFIG_DIR, '.gitignore'), 'w',
+                  encoding='utf-8') as f:
+            f.write('state.toml\n')
+        ensure_config_dir(self.ws)
+        self.assertEqual(_read_config_gitignore(self.ws), '*\n')
+
+    def test_save_config_ensures_gitignore(self):
+        save_config(self.ws, {'depot': {'root': '//ws/...'}})
+        self.assertEqual(_read_config_gitignore(self.ws), '*\n')
+
+    def test_git_ignores_config_dir(self):
+        subprocess.run(['git', 'init', '-q', self.ws], check=True)
+        save_config(self.ws, {'depot': {'root': '//ws/...'}})
+        status = subprocess.run(
+            ['git', 'status', '--porcelain', '--untracked-files=all'],
+            cwd=self.ws, check=True, capture_output=True, text=True)
+        self.assertEqual(status.stdout, '')
+
+
 class TestConfigPath(unittest.TestCase):
     def test_returns_expected_path(self):
         result = config_path('/workspace')

git_p4son-0.4.1/tests/test_state.py

@@ -0,0 +1,39 @@
+"""Tests for git_p4son.state module."""
+
+import os
+import tempfile
+import unittest
+
+from git_p4son import CONFIG_DIR
+from git_p4son.state import (
+    dismiss_clobber_warning,
+    is_clobber_warning_dismissed,
+    state_path,
+)
+
+
+class TestClobberWarningState(unittest.TestCase):
+    def setUp(self):
+        self._tempdir = tempfile.TemporaryDirectory()
+        self.ws = self._tempdir.name
+
+    def tearDown(self):
+        self._tempdir.cleanup()
+
+    def test_default_is_not_dismissed(self):
+        self.assertFalse(is_clobber_warning_dismissed(self.ws))
+
+    def test_dismiss_persists(self):
+        dismiss_clobber_warning(self.ws)
+        self.assertTrue(is_clobber_warning_dismissed(self.ws))
+        self.assertTrue(os.path.exists(state_path(self.ws)))
+
+    def test_dismiss_ensures_config_gitignore(self):
+        dismiss_clobber_warning(self.ws)
+        gitignore = os.path.join(self.ws, CONFIG_DIR, '.gitignore')
+        with open(gitignore, encoding='utf-8') as f:
+            self.assertEqual(f.read(), '*\n')
+
+
+if __name__ == '__main__':
+    unittest.main()

{git_p4son-0.4.0 → git_p4son-0.4.1}/tests/test_sync.py

@@ -9,6 +9,7 @@ from unittest import mock
 
 from git_p4son.common import CommandError, RunError
 from git_p4son.perforce import (
+    P4SyncAbortError,
     P4SyncOutputProcessor,
     P4SyncPreviewFile,
     get_latest_changelist,
@@ -455,6 +456,13 @@ class TestP4SyncOutputProcessor(unittest.TestCase):
         processor('//...@12345 - file(s) up-to-date.', sys.stdout)
         self.assertEqual(processor.synced_file_count, 0)
 
+    def test_failed_rename_aborts(self):
+        processor = P4SyncOutputProcessor()
+        with self.assertRaises(P4SyncAbortError):
+            processor('rename: failed to rename D:\\ws\\a.uasset after 10 '
+                      'attempts: Cannot create a file when that file '
+                      'already exists.', sys.stderr)
+
 
 class TestP4Sync(unittest.TestCase):
     @mock.patch('git_p4son.sync.run_with_output')
@@ -1655,6 +1663,82 @@ class TestSyncCommand(unittest.TestCase):
         self.assertEqual(rc, 1)
 
 
+class TestSyncDryRun(unittest.TestCase):
+    """A dry run resolves the sync sequence, prints it and stops before
+    anything that touches the workspaces or asks the user."""
+
+    def setUp(self):
+        for target, value in (
+                ('git_p4son.depot.get_client_spec', None),
+                ('git_p4son.depot.get_depot_root', '//myclient'),
+                ('git_p4son.sync.get_latest_changelist', 10500)):
+            patcher = mock.patch(target, return_value=value)
+            patcher.start()
+            self.addCleanup(patcher.stop)
+        patcher = mock.patch('git_p4son.sync.git_last_sync',
+                             return_value=LastSync(changelist=10000,
+                                                   commit='abc123'))
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        patcher = mock.patch('git_p4son.sync.log')
+        self.mock_log = patcher.start()
+        self.addCleanup(patcher.stop)
+        # Everything past the dry-run exit: none of it may run.
+        self.untouched = {}
+        for name in ('_handle_clobber_warning', 'sync_preflight',
+                     'run_hooks', 'get_head_commit', '_sync_pass',
+                     'commit'):
+            patcher = mock.patch(f'git_p4son.sync.{name}')
+            self.untouched[name] = patcher.start()
+            self.addCleanup(patcher.stop)
+
+    def _run(self, changelist, force=False):
+        args = mock.Mock(changelist=changelist, force=force,
+                         workspace_dir='/ws', dry_run=True)
+        return sync_command(args)
+
+    def _sequence(self):
+        """The line logged under the "Sync sequence" heading."""
+        self.mock_log.heading.assert_any_call('Sync sequence')
+        return self.mock_log.success.call_args_list[-1].args[0]
+
+    def _assert_nothing_run(self):
+        for name, patched in self.untouched.items():
+            with self.subTest(name=name):
+                patched.assert_not_called()
+
+    def test_latest(self):
+        self.assertEqual(self._run([]), 0)
+        self.assertEqual(self._sequence(), '10500')
+        self._assert_nothing_run()
+
+    def test_sequence_ending_in_head(self):
+        self.assertEqual(self._run(['10100', '10200', 'head']), 0)
+        self.assertEqual(self._sequence(), '10100 10200 10500')
+        self._assert_nothing_run()
+
+    def test_last_synced(self):
+        self.assertEqual(self._run(['last-synced']), 0)
+        self.assertEqual(self._sequence(), '10000 (last synced)')
+        self._assert_nothing_run()
+
+    def test_older_changelist_with_force(self):
+        self.assertEqual(self._run(['9000'], force=True), 0)
+        self.assertEqual(self._sequence(), '9000')
+        self._assert_nothing_run()
+
+    def test_invalid_arguments_still_fail(self):
+        """A dry run validates the targets exactly as a real sync does."""
+        self.assertEqual(self._run(['9000']), 1)
+        self.mock_log.error.assert_called_once()
+        self._assert_nothing_run()
+
+    def test_already_synced(self):
+        self.assertEqual(self._run(['10000']), 0)
+        self.mock_log.info.assert_any_call('Already synced, nothing to do.')
+        self._assert_nothing_run()
+
+
 class TestMergeChangedFiles(unittest.TestCase):
     """Tests for _merge_changed_files."""
 

git_p4son-0.4.0/git_p4son/state.py

@@ -1,56 +0,0 @@
-"""
-Local, per-user state for git-p4son.
-
-Stored in .git-p4son/state.toml, which is kept out of version control (unlike
-config.toml, which carries shared repo setup). State here reflects a single
-user's workspace and preferences, e.g. dismissed warnings.
-"""
-
-import os
-
-from . import CONFIG_DIR
-from .config import load_toml, write_toml
-
-
-def state_path(workspace_dir: str) -> str:
-    """Return the path to the local state file."""
-    return os.path.join(workspace_dir, CONFIG_DIR, 'state.toml')
-
-
-def _load(workspace_dir: str) -> dict:
-    return load_toml(state_path(workspace_dir))
-
-
-def _save(workspace_dir: str, state: dict) -> None:
-    write_toml(state_path(workspace_dir), state)
-    _ensure_gitignored(workspace_dir)
-
-
-def _ensure_gitignored(workspace_dir: str) -> None:
-    """Make sure state.toml is ignored via a .gitignore inside CONFIG_DIR.
-
-    A self-contained ignore file keeps the local state out of version control
-    without touching the user's top-level .gitignore."""
-    gitignore = os.path.join(workspace_dir, CONFIG_DIR, '.gitignore')
-    entry = 'state.toml'
-    existing = []
-    if os.path.exists(gitignore):
-        with open(gitignore, encoding='utf-8') as f:
-            existing = [line.strip() for line in f]
-        if entry in existing:
-            return
-    with open(gitignore, 'a', encoding='utf-8') as f:
-        f.write(f'{entry}\n')
-
-
-def is_clobber_warning_dismissed(workspace_dir: str) -> bool:
-    """Return whether the user permanently dismissed the clobber warning."""
-    return bool(_load(workspace_dir).get('clobber', {})
-                .get('dismiss_warning', False))
-
-
-def dismiss_clobber_warning(workspace_dir: str) -> None:
-    """Persist that the clobber warning should never be shown again."""
-    state = _load(workspace_dir)
-    state.setdefault('clobber', {})['dismiss_warning'] = True
-    _save(workspace_dir, state)

git_p4son-0.4.0/tests/test_state.py

@@ -1,64 +0,0 @@
-"""Tests for git_p4son.state module."""
-
-import os
-import tempfile
-import unittest
-
-from git_p4son import CONFIG_DIR
-from git_p4son.state import (
-    dismiss_clobber_warning,
-    is_clobber_warning_dismissed,
-    state_path,
-)
-
-
-class TestClobberWarningState(unittest.TestCase):
-    def setUp(self):
-        self._tempdir = tempfile.TemporaryDirectory()
-        self.ws = self._tempdir.name
-
-    def tearDown(self):
-        self._tempdir.cleanup()
-
-    def test_default_is_not_dismissed(self):
-        self.assertFalse(is_clobber_warning_dismissed(self.ws))
-
-    def test_dismiss_persists(self):
-        dismiss_clobber_warning(self.ws)
-        self.assertTrue(is_clobber_warning_dismissed(self.ws))
-        self.assertTrue(os.path.exists(state_path(self.ws)))
-
-    def test_dismiss_is_gitignored(self):
-        """The state file must be kept out of version control via a
-        .gitignore inside the config dir."""
-        dismiss_clobber_warning(self.ws)
-        gitignore = os.path.join(self.ws, CONFIG_DIR, '.gitignore')
-        self.assertTrue(os.path.exists(gitignore))
-        with open(gitignore, encoding='utf-8') as f:
-            entries = [line.strip() for line in f]
-        self.assertIn('state.toml', entries)
-
-    def test_gitignore_not_duplicated(self):
-        dismiss_clobber_warning(self.ws)
-        dismiss_clobber_warning(self.ws)
-        gitignore = os.path.join(self.ws, CONFIG_DIR, '.gitignore')
-        with open(gitignore, encoding='utf-8') as f:
-            entries = [line.strip() for line in f if line.strip()]
-        self.assertEqual(entries.count('state.toml'), 1)
-
-    def test_dismiss_preserves_existing_gitignore_entries(self):
-        os.makedirs(os.path.join(self.ws, CONFIG_DIR))
-        gitignore = os.path.join(self.ws, CONFIG_DIR, '.gitignore')
-        with open(gitignore, 'w', encoding='utf-8') as f:
-            f.write('other.local\n')
-
-        dismiss_clobber_warning(self.ws)
-
-        with open(gitignore, encoding='utf-8') as f:
-            entries = [line.strip() for line in f if line.strip()]
-        self.assertIn('other.local', entries)
-        self.assertIn('state.toml', entries)
-
-
-if __name__ == '__main__':
-    unittest.main()