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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.3.3
+Version: 0.3.4
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -231,6 +231,14 @@ be managed manually or via Perforce directly.
 After syncing, git-p4son prints a summary of how each writable file was handled, and instructs you to review and
 commit any files that need attention.
 
+**Workspaces with `allwrite`** - When your client spec has the `allwrite` option, every file is writable by design,
+so the read-only flag carries no information about local changes. git-p4son classifies files exactly as above (the
+verdict comes from git, not from the flag), but leaves the write bit alone on files it finds unchanged: with
+`noclobber` Perforce compares digests before refusing to overwrite a writable file, and unchanged files pass that
+check. Only files with local changes are made read-only for the duration of the sync, since those are the ones
+Perforce would otherwise refuse to overwrite. The same digest check applies to git-ignored files: unchanged ones sync
+normally, and after the sync git-p4son lists the ones Perforce skipped because they were modified locally.
+
 ## Usage
 
 git-p4son provides nine commands: `init`, `sync`, `sync-split`, `new`, `update`, `review`, `list-changes`,

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

@@ -208,6 +208,14 @@ be managed manually or via Perforce directly.
 After syncing, git-p4son prints a summary of how each writable file was handled, and instructs you to review and
 commit any files that need attention.
 
+**Workspaces with `allwrite`** - When your client spec has the `allwrite` option, every file is writable by design,
+so the read-only flag carries no information about local changes. git-p4son classifies files exactly as above (the
+verdict comes from git, not from the flag), but leaves the write bit alone on files it finds unchanged: with
+`noclobber` Perforce compares digests before refusing to overwrite a writable file, and unchanged files pass that
+check. Only files with local changes are made read-only for the duration of the sync, since those are the ones
+Perforce would otherwise refuse to overwrite. The same digest check applies to git-ignored files: unchanged ones sync
+normally, and after the sync git-p4son lists the ones Perforce skipped because they were modified locally.
+
 ## Usage
 
 git-p4son provides nine commands: `init`, `sync`, `sync-split`, `new`, `update`, `review`, `list-changes`,

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

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

{git_p4son-0.3.3 → git_p4son-0.3.4}/git_p4son/perforce.py

@@ -77,6 +77,10 @@ class P4ClientSpec:
     def clobber(self) -> bool:
         return 'clobber' in self.options
 
+    @property
+    def allwrite(self) -> bool:
+        return 'allwrite' in self.options
+
     @property
     def uses_crlf(self) -> bool:
         if self.line_end == 'win':
@@ -472,6 +476,12 @@ def is_binary_file_type(head_type: str) -> bool:
     return base_type in ('binary', 'ubinary')
 
 
+def is_always_writable_file_type(head_type: str) -> bool:
+    """Check if a Perforce headType carries the +w (always writable) modifier."""
+    _, _, modifiers = head_type.partition('+')
+    return 'w' in modifiers
+
+
 @dataclass
 class P4SyncPreviewFile:
     """A file a sync would affect, from p4 sync -n output.

{git_p4son-0.3.3 → git_p4son-0.3.4}/git_p4son/sync.py

@@ -26,6 +26,7 @@ from .perforce import (
     get_client_spec,
     get_latest_changelist,
     get_writable_files,
+    is_always_writable_file_type,
     is_binary_file_type,
     p4_fstat_file_info,
     p4_get_opened_files,
@@ -101,6 +102,11 @@ class WritableSyncFileSet:
     """Writable files found during sync preview, classified."""
     changed: list[ChangedFile] = field(default_factory=list)
     ignored: list[str] = field(default_factory=list)
+    always_writable: list[str] = field(default_factory=list)
+    # Ignored files p4 actually refused to overwrite, known only after the
+    # sync. Without allwrite that is all of ignored; with it, only the
+    # locally modified ones.
+    not_synced: list[str] = field(default_factory=list)
 
 
 def _stage_temp_content(temp_root: str, rel_path: str, suffix: str,
@@ -154,12 +160,63 @@ def _stage_changed_file(meta: _ChangedFileMeta, pre_sync_head_commit: str,
                        is_binary=is_binary, added_both=meta.added_both)
 
 
+def _log_prepare_summary(result: WritableSyncFileSet, workspace_dir: str,
+                         clobber: bool, unchanged_count: int = 0,
+                         allwrite: bool = False) -> None:
+    """Log what the writable-file classification found."""
+    log.heading('Prepare sync summary')
+    if unchanged_count:
+        label = 'file' if unchanged_count == 1 else 'files'
+        log.success(
+            f'{unchanged_count} writable {label} unchanged, '
+            'skipping merge')
+
+    if result.always_writable:
+        count = len(result.always_writable)
+        label = 'file is' if count == 1 else 'files are'
+        log.success(
+            f'{count} git-ignored {label} always writable (+w), '
+            'p4 syncs them normally')
+
+    if result.changed:
+        count = len(result.changed)
+        label = 'file has' if count == 1 else 'files have'
+        log.warning(f'{count} {label} local changes, will merge after sync')
+        for cf in result.changed:
+            log.info(os.path.relpath(cf.filepath, workspace_dir))
+
+    if result.ignored:
+        count = len(result.ignored)
+        label = 'file' if count == 1 else 'files'
+        if clobber:
+            # These files are left writable, so with clobber enabled p4
+            # overwrites them during sync rather than refusing to.
+            log.warning(
+                f'{count} git-ignored writable {label} will be overwritten '
+                'by p4 (clobber is enabled on the workspace)')
+        elif allwrite:
+            # With allwrite every file is writable, and p4 digest-compares
+            # before refusing to clobber one: unchanged files sync, modified
+            # ones are skipped. Which is which is only known after the sync,
+            # which reports the skipped ones, so they are not listed here.
+            log.info(
+                f'{count} git-ignored writable {label} will be synced '
+                'unless modified locally')
+            return
+        else:
+            log.warning(
+                f'{count} git-ignored writable {label} will not be synced')
+        for f in result.ignored:
+            log.info(os.path.relpath(f, workspace_dir))
+
+
 def prepare_writable_files(preview_files: list[P4SyncPreviewFile],
                            workspace_dir: str,
                            pre_sync_head_commit: str,
                            temp_root: str,
                            uses_crlf: bool = False,
-                           clobber: bool = False) -> WritableSyncFileSet:
+                           clobber: bool = False,
+                           allwrite: bool = False) -> WritableSyncFileSet:
     """Check which preview files are writable on disk and prepare them for sync.
 
     For tracked writable files, queries Perforce for the file type (binary
@@ -172,7 +229,12 @@ def prepare_writable_files(preview_files: list[P4SyncPreviewFile],
     clobber reflects the workspace clobber option. git-ignored writable files
     are left writable and rely on p4 refusing to overwrite them, which only
     holds when clobber is off; with clobber on p4 overwrites them, so the
-    reported outcome differs.
+    reported outcome differs. Ignored files whose Perforce type is +w
+    (always writable) are exempt: p4 overwrites those regardless, so they
+    sync normally and are reported separately.
+
+    allwrite reflects the workspace allwrite option, which narrows how many
+    files have their write bit stripped (see _clear_write_bits).
     """
     result = WritableSyncFileSet()
 
@@ -203,7 +265,27 @@ def prepare_writable_files(preview_files: list[P4SyncPreviewFile],
     result.ignored = [f for f in writable if f not in tracked_set]
     log.success(f'{len(tracked)} tracked, {len(result.ignored)} ignored')
 
+    if result.ignored:
+        # A file whose Perforce type carries the +w modifier is meant to be
+        # writable in the workspace. p4 overwrites it on sync without a
+        # clobber error, so it is not at risk of being skipped and must not
+        # be reported as such.
+        log.heading('Checking ignored files for the +w (always writable) type')
+        ignored_info = p4_fstat_file_info(result.ignored, workspace_dir)
+        always_writable = set()
+        for f in result.ignored:
+            info = ignored_info.get(f)
+            if info and is_always_writable_file_type(info.head_type):
+                always_writable.add(f)
+        result.always_writable = [f for f in result.ignored
+                                  if f in always_writable]
+        result.ignored = [f for f in result.ignored
+                          if f not in always_writable]
+        log.success(f'{len(result.always_writable)} always writable (+w)')
+
     if not tracked:
+        _log_prepare_summary(result, workspace_dir, clobber,
+                             allwrite=allwrite)
         return result
 
     # Pass 1: decide which files the user modified since their baseline by
@@ -212,10 +294,12 @@ def prepare_writable_files(preview_files: list[P4SyncPreviewFile],
     # one cat-file); with hundreds of writable files after a branch switch,
     # per-file process spawning dominated the entire sync.
     log.heading('Detecting modified tracked writable files')
-    for f in tracked:
-        # Make read-only regardless of whether changed or not
-        mode = os.stat(f).st_mode
-        os.chmod(f, mode & ~stat.S_IWUSR)
+    if not allwrite:
+        # Without allwrite, noclobber makes p4 refuse to overwrite any
+        # writable file, so every tracked file goes read-only whether it
+        # changed or not. The modified ones get their local content back
+        # from the post-sync merge.
+        _clear_write_bits(tracked)
 
     rel_paths = {f: os.path.relpath(f, workspace_dir) for f in tracked}
     candidates = [f for f in tracked if f not in added_upstream]
@@ -263,6 +347,15 @@ def prepare_writable_files(preview_files: list[P4SyncPreviewFile],
 
     log.success(f'{len(metas)} changed, {unchanged_count} unchanged')
 
+    if allwrite:
+        # An allwrite workspace is writable by design, so the write bit is
+        # left alone on files p4 will overwrite cleanly: with noclobber it
+        # digest-compares first and these still match the have revision,
+        # and with clobber it overwrites regardless. Only the modified
+        # files, the ones noclobber would refuse on, are stripped; the
+        # post-sync merge makes them writable again.
+        _clear_write_bits([m.filepath for m in metas])
+
     # Pass 2: query Perforce for file type only on the changed subset. The
     # binary verdict must be known before staging so text content can be
     # written once in the workspace line ending (its only authoritative
@@ -283,37 +376,17 @@ def prepare_writable_files(preview_files: list[P4SyncPreviewFile],
                 is_binary, uses_crlf))
         log.success('')
 
-    # Log what we found
-    log.heading('Prepare sync summary')
-    if unchanged_count:
-        label = 'file' if unchanged_count == 1 else 'files'
-        log.success(
-            f'{unchanged_count} writable {label} unchanged, '
-            'skipping merge')
+    _log_prepare_summary(result, workspace_dir, clobber, unchanged_count,
+                         allwrite)
+    return result
 
-    if result.changed:
-        count = len(result.changed)
-        label = 'file has' if count == 1 else 'files have'
-        log.warning(f'{count} {label} local changes, will merge after sync')
-        for cf in result.changed:
-            log.info(os.path.relpath(cf.filepath, workspace_dir))
 
-    if result.ignored:
-        count = len(result.ignored)
-        label = 'file' if count == 1 else 'files'
-        if clobber:
-            # These files are left writable, so with clobber enabled p4
-            # overwrites them during sync rather than refusing to.
-            log.warning(
-                f'{count} git-ignored writable {label} will be overwritten '
-                'by p4 (clobber is enabled on the workspace)')
-        else:
-            log.warning(
-                f'{count} git-ignored writable {label} will not be synced')
-        for f in result.ignored:
-            log.info(os.path.relpath(f, workspace_dir))
-
-    return result
+def _clear_write_bits(filepaths: list[str]) -> None:
+    """Remove user write permission from each file, making p4 willing to
+    overwrite it."""
+    for filepath in filepaths:
+        mode = os.stat(filepath).st_mode
+        os.chmod(filepath, mode & ~stat.S_IWUSR)
 
 
 def _make_writable(filepath: str) -> None:
@@ -464,12 +537,12 @@ def _merge_changed_files(changed_files: list[ChangedFile],
 
 def p4_sync(changelist: int, label: str, depot_root: str,
             workspace_dir: str,
-            expected_clobber: set[str] | None = None) -> None:
+            expected_clobber: set[str] | None = None) -> list[str]:
     """Sync files from Perforce.
 
     If expected_clobber is provided, clobber errors for those files are
-    tolerated (they are git-ignored writable files). Unexpected clobber
-    errors cause a raise.
+    tolerated (they are git-ignored writable files) and the files are
+    returned. Unexpected clobber errors cause a raise.
     """
     log.heading(f'Syncing to {label} CL ({changelist})')
 
@@ -481,6 +554,7 @@ def p4_sync(changelist: int, label: str, depot_root: str,
         if result.elapsed:
             log.elapsed(result.elapsed)
         log.success(output_processor.get_summary())
+        return []
     except RunError as e:
         writable_files = get_writable_files(e.stderr)
         if not writable_files:
@@ -499,6 +573,7 @@ def p4_sync(changelist: int, label: str, depot_root: str,
         log.warning(
             f'{len(writable_files)} expected clobber errors (git-ignored files)'
         )
+        return writable_files
 
 
 def _handle_clobber_warning(clobber: bool, workspace_dir: str) -> bool:
@@ -601,7 +676,8 @@ def sync_preflight(depot_root: str, workspace_dir: str, invocation_dir: str,
 
 def _sync_pass(changelist: int, label: str, depot_root: str,
                workspace_dir: str, pre_sync_head_commit: str, temp_root: str,
-               uses_crlf: bool, clobber: bool) -> WritableSyncFileSet:
+               uses_crlf: bool, clobber: bool,
+               allwrite: bool) -> WritableSyncFileSet:
     """Run one sync pass: preview, prepare writable files, and p4 sync.
 
     Returns the classified writable file set. p4 sync is skipped when the
@@ -610,10 +686,11 @@ def _sync_pass(changelist: int, label: str, depot_root: str,
     preview = p4_sync_preview(changelist, depot_root, workspace_dir)
     prep = prepare_writable_files(preview, workspace_dir, pre_sync_head_commit,
                                   temp_root, uses_crlf=uses_crlf,
-                                  clobber=clobber)
+                                  clobber=clobber, allwrite=allwrite)
     if preview:
-        p4_sync(changelist, label, depot_root, workspace_dir,
-                expected_clobber=set(prep.ignored))
+        prep.not_synced = p4_sync(changelist, label, depot_root,
+                                  workspace_dir,
+                                  expected_clobber=set(prep.ignored))
     return prep
 
 
@@ -774,6 +851,7 @@ def sync_command(args: argparse.Namespace) -> int:
     # (client_spec was fetched above to resolve the depot root.)
     uses_crlf = bool(client_spec and client_spec.uses_crlf)
     clobber = bool(client_spec and client_spec.clobber)
+    allwrite = bool(client_spec and client_spec.allwrite)
 
     # Prompted before the preflight so declining here costs nothing: no
     # workspace queries, and no hooks fired for a sync that is abandoned.
@@ -797,12 +875,13 @@ def sync_command(args: argparse.Namespace) -> int:
         if resync_last_synced:
             _sync_pass(last_sync.changelist, LAST_SYNCED_LABEL, depot_root,
                        workspace_dir, pre_sync_head_commit, temp_root,
-                       uses_crlf, clobber)
+                       uses_crlf, clobber, allwrite)
             run_hooks('post-sync', workspace_dir, invocation_dir)
             return 0
 
         all_changed: list[ChangedFile] = []
         all_ignored: list[str] = []
+        all_not_synced: list[str] = []
         last_changelist = last_sync.changelist if last_sync else None
 
         # Catch-up pass to the last synced changelist. This makes locally
@@ -812,9 +891,10 @@ def sync_command(args: argparse.Namespace) -> int:
         if last_changelist is not None:
             prep = _sync_pass(last_changelist, LAST_SYNCED_LABEL,
                               depot_root, workspace_dir, pre_sync_head_commit,
-                              temp_root, uses_crlf, clobber)
+                              temp_root, uses_crlf, clobber, allwrite)
             all_changed.extend(prep.changed)
             all_ignored.extend(prep.ignored)
+            all_not_synced.extend(prep.not_synced)
 
         # Sync each target changelist in turn, committing pure Perforce state
         # for each. Local changes are merged back once at the very end so the
@@ -822,9 +902,10 @@ def sync_command(args: argparse.Namespace) -> int:
         for changelist, changelist_label in targets:
             prep = _sync_pass(changelist, changelist_label, depot_root,
                               workspace_dir, pre_sync_head_commit, temp_root,
-                              uses_crlf, clobber)
+                              uses_crlf, clobber, allwrite)
             all_changed.extend(prep.changed)
             all_ignored.extend(prep.ignored)
+            all_not_synced.extend(prep.not_synced)
 
             log.heading(f'Committing git changes for CL {changelist}')
             dirty_files = get_dirty_files(workspace_dir)
@@ -844,15 +925,21 @@ def sync_command(args: argparse.Namespace) -> int:
 
         # Report git-ignored writable files. Left writable, they are only
         # preserved because p4 refuses to clobber them; with clobber on p4
-        # overwrites them during the sync instead.
-        if all_ignored:
-            if clobber:
-                log.heading(
-                    'Git-ignored writable files overwritten by p4 '
-                    '(clobber enabled)')
-            else:
-                log.heading('Files not synced (git-ignored and writable)')
-            for f in sorted(set(all_ignored)):
+        # overwrites them during the sync instead. With allwrite p4 refuses
+        # only the locally modified ones, so report what it actually skipped.
+        if clobber:
+            reported = all_ignored
+            heading = ('Git-ignored writable files overwritten by p4 '
+                       '(clobber enabled)')
+        elif allwrite:
+            reported = all_not_synced
+            heading = 'Files not synced (git-ignored and locally modified)'
+        else:
+            reported = all_ignored
+            heading = 'Files not synced (git-ignored and writable)'
+        if reported:
+            log.heading(heading)
+            for f in sorted(set(reported)):
                 log.info(os.path.relpath(f, workspace_dir))
 
         run_hooks('post-sync', workspace_dir, invocation_dir)

{git_p4son-0.3.3 → git_p4son-0.3.4}/git_p4son/sync_split.py

@@ -145,7 +145,7 @@ def sync_split_command(args: argparse.Namespace) -> int:
         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')
+        log.success('None found, syncing to the target changelist only')
 
     targets = build_sync_targets(changes, users, last_synced, upper)
 

{git_p4son-0.3.3 → git_p4son-0.3.4}/git_p4son.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.3.3
+Version: 0.3.4
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -231,6 +231,14 @@ be managed manually or via Perforce directly.
 After syncing, git-p4son prints a summary of how each writable file was handled, and instructs you to review and
 commit any files that need attention.
 
+**Workspaces with `allwrite`** - When your client spec has the `allwrite` option, every file is writable by design,
+so the read-only flag carries no information about local changes. git-p4son classifies files exactly as above (the
+verdict comes from git, not from the flag), but leaves the write bit alone on files it finds unchanged: with
+`noclobber` Perforce compares digests before refusing to overwrite a writable file, and unchanged files pass that
+check. Only files with local changes are made read-only for the duration of the sync, since those are the ones
+Perforce would otherwise refuse to overwrite. The same digest check applies to git-ignored files: unchanged ones sync
+normally, and after the sync git-p4son lists the ones Perforce skipped because they were modified locally.
+
 ## Usage
 
 git-p4son provides nine commands: `init`, `sync`, `sync-split`, `new`, `update`, `review`, `list-changes`,

{git_p4son-0.3.3 → git_p4son-0.3.4}/pyproject.toml

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

{git_p4son-0.3.3 → git_p4son-0.3.4}/tests/test_perforce.py

@@ -5,7 +5,8 @@ from unittest import mock
 
 from git_p4son.perforce import (
     P4ClientSpec, P4FileInfo, P4SyncPreviewFile, get_client_spec,
-    get_p4_user, get_submitted_changes, is_binary_file_type,
+    get_p4_user, get_submitted_changes, is_always_writable_file_type,
+    is_binary_file_type,
     p4_fstat_file_info, p4_sync_preview, parse_ztag_multi_output,
     parse_ztag_output,
 )
@@ -102,6 +103,20 @@ class TestP4ClientSpec(unittest.TestCase):
             line_end='local')
         self.assertTrue(spec.clobber)
 
+    def test_allwrite_enabled(self):
+        spec = P4ClientSpec(
+            name='ws', root='/ws',
+            options=['allwrite', 'noclobber', 'nocompress'], stream=None,
+            line_end='local')
+        self.assertTrue(spec.allwrite)
+
+    def test_allwrite_disabled(self):
+        spec = P4ClientSpec(
+            name='ws', root='/ws',
+            options=['noallwrite', 'noclobber', 'nocompress'], stream=None,
+            line_end='local')
+        self.assertFalse(spec.allwrite)
+
     def test_clobber_disabled(self):
         spec = P4ClientSpec(
             name='ws', root='/ws',
@@ -195,6 +210,20 @@ class TestIsBinaryFileType(unittest.TestCase):
         self.assertTrue(is_binary_file_type('ubinary+x'))
 
 
+class TestIsAlwaysWritableFileType(unittest.TestCase):
+    def test_without_w_modifier(self):
+        self.assertFalse(is_always_writable_file_type('text'))
+        self.assertFalse(is_always_writable_file_type('binary'))
+        self.assertFalse(is_always_writable_file_type('binary+x'))
+        self.assertFalse(is_always_writable_file_type('text+kx'))
+
+    def test_with_w_modifier(self):
+        self.assertTrue(is_always_writable_file_type('text+w'))
+        self.assertTrue(is_always_writable_file_type('binary+w'))
+        self.assertTrue(is_always_writable_file_type('binary+Swl'))
+        self.assertTrue(is_always_writable_file_type('binary+xw'))
+
+
 class TestP4FstatFileInfo(unittest.TestCase):
     @mock.patch('git_p4son.perforce.run')
     def test_returns_head_type(self, mock_run):

{git_p4son-0.3.3 → git_p4son-0.3.4}/tests/test_sync.py

@@ -433,8 +433,15 @@ class TestP4Sync(unittest.TestCase):
             'p4 sync failed', returncode=1,
             stderr=["Can't clobber writable file /ws/a.txt",
                     "Can't clobber writable file /ws/b.txt"])
-        p4_sync(12345, 'test', '//myclient', '/ws',
-                expected_clobber={'/ws/a.txt', '/ws/b.txt'})
+        refused = p4_sync(12345, 'test', '//myclient', '/ws',
+                          expected_clobber={'/ws/a.txt', '/ws/b.txt'})
+        self.assertEqual(sorted(refused), ['/ws/a.txt', '/ws/b.txt'])
+
+    @mock.patch('git_p4son.sync.run_with_output')
+    def test_clean_sync_refuses_nothing(self, mock_rwo):
+        mock_rwo.return_value = mock.Mock(elapsed=None)
+        self.assertEqual(
+            p4_sync(12345, 'test', '//myclient', '/ws'), [])
 
     @mock.patch('git_p4son.sync.run_with_output')
     def test_unexpected_clobber_raises(self, mock_rwo):
@@ -540,6 +547,57 @@ class TestPrepareWritableFiles(unittest.TestCase):
             mode = os.stat(path).st_mode
             self.assertFalse(mode & stat.S_IWUSR)
 
+    @mock.patch('git_p4son.sync.get_blob_oids',
+                return_value={('head123', 'a.txt'): 'same_oid',
+                              ('sync456', 'a.txt'): 'same_oid'})
+    @mock.patch('git_p4son.sync.get_file_at_commit')
+    @mock.patch('git_p4son.sync.find_base_commits',
+                return_value={'a.txt': 'sync456'})
+    @mock.patch('git_p4son.sync.p4_fstat_file_info')
+    @mock.patch('git_p4son.sync.get_tracked_files',
+                side_effect=lambda paths, ws: set(paths))
+    def test_allwrite_keeps_unchanged_file_writable(
+            self, _tracked, mock_fstat, _find_base, _get_file, _oids):
+        """An allwrite workspace is writable by design, and p4 overwrites
+        an unchanged file regardless of clobber, so the write bit stays."""
+        from git_p4son.perforce import P4FileInfo
+        with tempfile.TemporaryDirectory() as ws:
+            path = self._make_file(ws, 'a.txt')
+            mock_fstat.return_value = {path: P4FileInfo(head_type='text')}
+
+            result = prepare_writable_files([_upd(path)], ws, 'head123',
+                                            self.temp_root, allwrite=True)
+
+            self.assertEqual(result.changed, [])
+            mode = os.stat(path).st_mode
+            self.assertTrue(mode & stat.S_IWUSR)
+
+    @mock.patch('git_p4son.sync.get_blob_oids')
+    @mock.patch('git_p4son.sync.get_file_at_commit',
+                return_value=b'head content')
+    @mock.patch('git_p4son.sync.find_base_commits',
+                return_value={'a.txt': 'sync456'})
+    @mock.patch('git_p4son.sync.p4_fstat_file_info')
+    @mock.patch('git_p4son.sync.get_tracked_files',
+                side_effect=lambda paths, ws: set(paths))
+    def test_allwrite_makes_changed_file_read_only(
+            self, _tracked, mock_fstat, _find_base, _get_file, mock_oids):
+        """With allwrite plus noclobber p4 digest-compares and would refuse
+        on exactly the modified files, so those still go read-only."""
+        from git_p4son.perforce import P4FileInfo
+        with tempfile.TemporaryDirectory() as ws:
+            path = self._make_file(ws, 'a.txt')
+            mock_fstat.return_value = {path: P4FileInfo(head_type='text')}
+            mock_oids.return_value = {('head123', 'a.txt'): 'oid_head',
+                                      ('sync456', 'a.txt'): 'oid_base'}
+
+            result = prepare_writable_files([_upd(path)], ws, 'head123',
+                                            self.temp_root, allwrite=True)
+
+            self.assertEqual([cf.filepath for cf in result.changed], [path])
+            mode = os.stat(path).st_mode
+            self.assertFalse(mode & stat.S_IWUSR)
+
     @mock.patch('git_p4son.sync.get_file_at_commit',
                 return_value=b'head content')
     @mock.patch('git_p4son.sync.find_base_commits',
@@ -726,33 +784,86 @@ class TestPrepareWritableFiles(unittest.TestCase):
             path = self._make_file(ws, 'build.log')
 
             with mock.patch('git_p4son.sync.get_tracked_files',
-                            return_value=set()):
+                            return_value=set()), \
+                    mock.patch('git_p4son.sync.p4_fstat_file_info',
+                               return_value={}):
                 result = prepare_writable_files([_upd(path)], ws, 'head123',
                                                 self.temp_root)
 
             self.assertEqual(result.changed, [])
             self.assertEqual(result.ignored, [path])
+            self.assertEqual(result.always_writable, [])
             mode = os.stat(path).st_mode
             self.assertTrue(mode & stat.S_IWUSR)
 
-    def _run_with_tracked_and_ignored(self, ws, clobber):
+    def test_always_writable_ignored_file_not_reported_as_unsynced(self):
+        """A git-ignored file whose Perforce type is +w is meant to be
+        writable; p4 overwrites it on sync, so no warning is due."""
+        from git_p4son.perforce import P4FileInfo
+        with tempfile.TemporaryDirectory() as ws:
+            path = self._make_file(ws, 'Tool.exe')
+
+            with mock.patch('git_p4son.sync.get_tracked_files',
+                            return_value=set()), \
+                    mock.patch(
+                        'git_p4son.sync.p4_fstat_file_info',
+                        return_value={
+                            path: P4FileInfo(head_type='binary+w')}), \
+                    mock.patch('git_p4son.sync.log') as mock_log:
+                result = prepare_writable_files([_upd(path)], ws, 'head123',
+                                                self.temp_root)
+
+            self.assertEqual(result.ignored, [])
+            self.assertEqual(result.always_writable, [path])
+            warnings = ' '.join(
+                str(c.args[0]) for c in mock_log.warning.call_args_list)
+            self.assertNotIn('will not be synced', warnings)
+            mode = os.stat(path).st_mode
+            self.assertTrue(mode & stat.S_IWUSR)
+
+    def test_always_writable_files_excluded_from_expected_clobber(self):
+        """+w files must not be classified as ignored: a clobber error on
+        one is unexpected and should still surface."""
+        from git_p4son.perforce import P4FileInfo
+        with tempfile.TemporaryDirectory() as ws:
+            always = self._make_file(ws, 'Tool.exe')
+            ignored = self._make_file(ws, 'build.log')
+
+            with mock.patch('git_p4son.sync.get_tracked_files',
+                            return_value=set()), \
+                    mock.patch(
+                        'git_p4son.sync.p4_fstat_file_info',
+                        return_value={
+                            always: P4FileInfo(head_type='binary+w'),
+                            ignored: P4FileInfo(head_type='text')}):
+                result = prepare_writable_files(
+                    [_upd(always), _upd(ignored)], ws, 'head123',
+                    self.temp_root)
+
+            self.assertEqual(result.ignored, [ignored])
+            self.assertEqual(result.always_writable, [always])
+
+    def _run_with_tracked_and_ignored(self, ws, clobber, allwrite=False,
+                                      level='warning'):
         """Prepare one unchanged tracked file plus one ignored file so the
         summary block (which reports ignored files) is reached, and return
-        the concatenated warning messages."""
+        the concatenated messages logged at level."""
         tracked = self._make_file(ws, 'a.txt')
         ignored = self._make_file(ws, 'build.log')
         with mock.patch('git_p4son.sync.get_tracked_files',
                         return_value={tracked}), \
+                mock.patch('git_p4son.sync.p4_fstat_file_info',
+                           return_value={}), \
                 mock.patch('git_p4son.sync.find_base_commits',
                            return_value={'a.txt': 'head123'}), \
                 mock.patch('git_p4son.sync.get_blob_oids', return_value={}), \
                 mock.patch('git_p4son.sync.log') as mock_log:
             result = prepare_writable_files(
                 [_upd(tracked), _upd(ignored)], ws, 'head123',
-                self.temp_root, clobber=clobber)
+                self.temp_root, clobber=clobber, allwrite=allwrite)
         self.assertEqual(result.ignored, [ignored])
-        return ' '.join(
-            str(c.args[0]) for c in mock_log.warning.call_args_list)
+        return ' '.join(str(c.args[0]) for c in
+                        getattr(mock_log, level).call_args_list)
 
     def test_ignored_message_without_clobber(self):
         with tempfile.TemporaryDirectory() as ws:
@@ -768,6 +879,26 @@ class TestPrepareWritableFiles(unittest.TestCase):
             self.assertIn('overwritten', warnings)
             self.assertNotIn('will not be synced', warnings)
 
+    def test_ignored_message_with_allwrite(self):
+        """With allwrite p4 digest-compares before refusing to clobber, so
+        unchanged ignored files do sync: the summary must not claim none
+        will, and cannot yet say which will not."""
+        with tempfile.TemporaryDirectory() as ws:
+            warnings = self._run_with_tracked_and_ignored(
+                ws, clobber=False, allwrite=True)
+            self.assertNotIn('will not be synced', warnings)
+            infos = self._run_with_tracked_and_ignored(
+                ws, clobber=False, allwrite=True, level='info')
+            self.assertIn('unless modified locally', infos)
+            self.assertNotIn('build.log', infos)
+
+    def test_ignored_message_with_allwrite_and_clobber(self):
+        """clobber overwrites regardless, so it wins over allwrite."""
+        with tempfile.TemporaryDirectory() as ws:
+            warnings = self._run_with_tracked_and_ignored(
+                ws, clobber=True, allwrite=True)
+            self.assertIn('overwritten', warnings)
+
     def test_nonexistent_files_skipped(self):
         result = prepare_writable_files(
             [_upd('/ws/noexist.txt')], '/ws', 'head123', self.temp_root)
@@ -816,6 +947,43 @@ class TestSyncCommand(unittest.TestCase):
         rc = sync_command(args)
         self.assertEqual(rc, 0)
 
+    @mock.patch('git_p4son.sync.log')
+    @mock.patch('git_p4son.sync._merge_changed_files')
+    @mock.patch('git_p4son.sync.commit')
+    @mock.patch('git_p4son.sync.add_all_files')
+    @mock.patch('git_p4son.sync.get_dirty_files', return_value=[])
+    @mock.patch('git_p4son.sync.p4_sync', return_value=['/ws/edited.log'])
+    @mock.patch('git_p4son.sync.prepare_writable_files')
+    @mock.patch('git_p4son.sync.p4_sync_preview',
+                return_value=[_upd('/ws/edited.log')])
+    @mock.patch('git_p4son.sync.get_head_commit', return_value='def456')
+    @mock.patch('git_p4son.sync.git_last_sync')
+    @mock.patch('git_p4son.sync.p4_get_opened_files', return_value=[])
+    @mock.patch('git_p4son.sync.get_client_spec')
+    @mock.patch('git_p4son.sync.get_depot_root', return_value='//myclient')
+    def test_allwrite_reports_only_refused_ignored_files(
+            self, _depot, mock_spec, _p4clean, mock_last_sync, _head,
+            _preview, mock_prep, _p4sync, _git_clean, _add, _commit, _merge,
+            mock_log):
+        """With allwrite p4 syncs unchanged ignored files and refuses only
+        the modified ones, so the report lists what it actually skipped."""
+        spec = mock.Mock(uses_crlf=False, clobber=False, allwrite=True)
+        spec.name = 'myclient'
+        mock_spec.return_value = spec
+        mock_last_sync.return_value = self._last_sync
+        mock_prep.return_value = WritableSyncFileSet(
+            ignored=['/ws/pristine.log', '/ws/edited.log'])
+        args = mock.Mock(changelist=['12345'], force=False,
+                         workspace_dir='/ws')
+        self.assertEqual(sync_command(args), 0)
+
+        headings = [str(c.args[0]) for c in mock_log.heading.call_args_list]
+        self.assertIn('Files not synced (git-ignored and locally modified)',
+                      headings)
+        infos = [str(c.args[0]) for c in mock_log.info.call_args_list]
+        self.assertIn('edited.log', infos)
+        self.assertNotIn('pristine.log', infos)
+
     @mock.patch('git_p4son.sync.get_depot_root', return_value=None)
     def test_no_depot_root_aborts(self, _depot):
         args = mock.Mock(changelist=['100'], force=False, workspace_dir='/ws')
@@ -843,6 +1011,7 @@ class TestSyncCommand(unittest.TestCase):
         spec.name = 'real-client'
         spec.uses_crlf = False
         spec.clobber = False
+        spec.allwrite = False
         mock_spec.return_value = spec
         mock_last_sync.return_value = self._last_sync
         mock_prep.return_value = self._empty_prep()