git-p4son 0.2.11__tar.gz → 0.3.0__tar.gz

{git_p4son-0.2.11 → git_p4son-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.2.11
+Version: 0.3.0
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT
@@ -156,41 +156,37 @@ cloning.
 
 These steps set up git-p4son in an existing Perforce workspace. You only need to do this once.
 
-1. **Enable clobber on your Perforce workspace.** Edit the workspace in
-   P4V to set the clobber flag, or run `p4 client` and change `noclobber` to `clobber` in the Options line.
-   See [Why clobber?](#why-clobber) for rationale.
-
-2. **Set a git editor** if you don't have one already. The `review` command opens an interactive rebase in your
+1. **Set a git editor** if you don't have one already. The `review` command opens an interactive rebase in your
    editor. If you haven't configured one, set it with:
    ```sh
    git config --global core.editor <editor>   # e.g. vim, nano, code --wait
    ```
 
-3. **Sync your workspace to a known changelist.** Pick a changelist to use as the starting point for your git
+2. **Sync your workspace to a known changelist.** Pick a changelist to use as the starting point for your git
    history:
    ```sh
    p4 sync //...@12345
    ```
 
-4. **Run `git p4son init`.** This can be anywhere inside your Perforce workspace — it doesn't have to be at the
+3. **Run `git p4son init`.** This can be anywhere inside your Perforce workspace - it doesn't have to be at the
    root:
    ```sh
    cd /path/to/your/workspace    # or a subdirectory of it
    git p4son init
    ```
-   The command verifies that you are inside a P4 workspace with clobber enabled, prompts you to select a depot
+   The command verifies that you are inside a P4 workspace, prompts you to select a depot
    root (entire workspace or current directory subtree), runs `git init`, sets up `.gitignore` (copying from
    `.p4ignore` if available), and creates an initial commit.
 
-5. **Review `.gitignore`.** Edit the file to ensure build artifacts and other unwanted files are excluded.
+4. **Review `.gitignore`.** Edit the file to ensure build artifacts and other unwanted files are excluded.
 
-6. **Add and commit all files manually the first time**
+5. **Add and commit all files manually the first time**
    ```sh
    git add .
    git commit -m "Initial submit all files"
    ```
 
-7. **Run `git p4son sync`** to get your first official sync commit
+6. **Run `git p4son sync`** to get your first official sync commit
    ```sh
    git p4son sync
    ```
@@ -199,19 +195,41 @@ These steps set up git-p4son in an existing Perforce workspace. You only need to
 From here, branch off `main` for local development. See the [Usage Example](#usage-example) for a typical
 workflow.
 
-### Why clobber?
+### How sync handles writable files
+
+When you switch branches with `git checkout`, git removes the read-only flag on every file it writes. This means
+that when you switch back to `main` for a sync, Perforce may report "Can't clobber writable file" errors. git-p4son
+handles these automatically by classifying each writable file:
+
+**writable-unchanged** - The file on disk is identical to the last sync (only the read-only flag was removed
+by git). This is the common case after switching branches. git-p4son detects this by comparing git blob IDs against
+the last sync commit that touched the file, restores the read-only flag, and lets the sync overwrite the file.
+
+**writable-changed** - The file on disk differs from the last sync. This happens when you manually edit a file
+on `main` and commit it to git without submitting to Perforce. git-p4son lets the sync overwrite the file and
+includes it in the sync commit (so the commit reflects pure Perforce state), then three-way merges your local
+changes on top of the new Perforce content - similar to a `git rebase`. If the merge is clean, the result appears
+as an unstaged change. If there are conflicts, standard conflict markers are inserted for you to resolve.
+
+**added both locally and in Perforce** - A file you committed to git is also being added by Perforce (p4 has never
+synced it to your workspace). There is no common baseline, so git-p4son merges the two versions against an empty
+base: identical content merges cleanly, otherwise the file gets a single conflict block containing both full
+versions for you to resolve.
+
+**binary files** - Binary files that have local changes cannot be three-way merged. git-p4son restores your local
+version to disk after the sync commit so it shows up in `git status` for you to handle manually.
+
+**added locally, deleted upstream** - A file with local changes in git was deleted in Perforce. git-p4son lets the
+delete stand and warns you - your version remains available in git history.
 
-When you switch branches with `git checkout`, git overwrites the files that differ between the source and target branch.
-In doing so, it always removes the read-only flag - this is just how git works.
+**deleted locally, added upstream** - A file you deleted from git was modified in Perforce. The Perforce version is
+kept in the sync commit. You can delete it again if you want.
 
-Now imagine one of those files has also been modified in Perforce. The next time `p4 sync` runs, Perforce will complain
-that a file was changed outside its control. At that point you have two options: either force-sync the individual file
-with `p4 sync -f //path/to/file`, or enable the `clobber` flag on your workspace so that Perforce silently overwrites
-writable files.
+**ignored** - Files ignored by `.gitignore` are skipped with a warning. These are outside git's domain and should
+be managed manually or via Perforce directly.
 
-This is not specific to git-p4son - any workflow that combines git and Perforce in the same workspace will run into it.
-And in practice it is harmless: your local changes live on feature branches in git, so when you rebase onto `main` after
-a sync, your changes are reapplied on top of the latest Perforce state.
+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.
 
 ## Usage
 
@@ -241,7 +259,7 @@ Initialize a git repository inside a Perforce workspace:
 git p4son init
 ```
 
-This command checks preconditions (Perforce workspace, clobber flag), configures the depot root, runs `git init`,
+This command checks preconditions (Perforce workspace), configures the depot root, runs `git init`,
 sets up `.gitignore`, and creates an initial commit.
 
 The depot root determines which part of the Perforce workspace git-p4son syncs. You can choose to sync the entire
@@ -266,7 +284,7 @@ git p4son sync [changelist] [--force]
   sync to the latest changelist affecting the workspace.
 
 **Options:**
-- `-f, --force`: Force sync encountered writable files and allow syncing to older changelists.
+- `-f, --force`: Allow syncing to changelists older than the current one.
 
 **Examples:**
 ```sh

{git_p4son-0.2.11 → git_p4son-0.3.0}/README.md

@@ -133,41 +133,37 @@ cloning.
 
 These steps set up git-p4son in an existing Perforce workspace. You only need to do this once.
 
-1. **Enable clobber on your Perforce workspace.** Edit the workspace in
-   P4V to set the clobber flag, or run `p4 client` and change `noclobber` to `clobber` in the Options line.
-   See [Why clobber?](#why-clobber) for rationale.
-
-2. **Set a git editor** if you don't have one already. The `review` command opens an interactive rebase in your
+1. **Set a git editor** if you don't have one already. The `review` command opens an interactive rebase in your
    editor. If you haven't configured one, set it with:
    ```sh
    git config --global core.editor <editor>   # e.g. vim, nano, code --wait
    ```
 
-3. **Sync your workspace to a known changelist.** Pick a changelist to use as the starting point for your git
+2. **Sync your workspace to a known changelist.** Pick a changelist to use as the starting point for your git
    history:
    ```sh
    p4 sync //...@12345
    ```
 
-4. **Run `git p4son init`.** This can be anywhere inside your Perforce workspace — it doesn't have to be at the
+3. **Run `git p4son init`.** This can be anywhere inside your Perforce workspace - it doesn't have to be at the
    root:
    ```sh
    cd /path/to/your/workspace    # or a subdirectory of it
    git p4son init
    ```
-   The command verifies that you are inside a P4 workspace with clobber enabled, prompts you to select a depot
+   The command verifies that you are inside a P4 workspace, prompts you to select a depot
    root (entire workspace or current directory subtree), runs `git init`, sets up `.gitignore` (copying from
    `.p4ignore` if available), and creates an initial commit.
 
-5. **Review `.gitignore`.** Edit the file to ensure build artifacts and other unwanted files are excluded.
+4. **Review `.gitignore`.** Edit the file to ensure build artifacts and other unwanted files are excluded.
 
-6. **Add and commit all files manually the first time**
+5. **Add and commit all files manually the first time**
    ```sh
    git add .
    git commit -m "Initial submit all files"
    ```
 
-7. **Run `git p4son sync`** to get your first official sync commit
+6. **Run `git p4son sync`** to get your first official sync commit
    ```sh
    git p4son sync
    ```
@@ -176,19 +172,41 @@ These steps set up git-p4son in an existing Perforce workspace. You only need to
 From here, branch off `main` for local development. See the [Usage Example](#usage-example) for a typical
 workflow.
 
-### Why clobber?
+### How sync handles writable files
+
+When you switch branches with `git checkout`, git removes the read-only flag on every file it writes. This means
+that when you switch back to `main` for a sync, Perforce may report "Can't clobber writable file" errors. git-p4son
+handles these automatically by classifying each writable file:
+
+**writable-unchanged** - The file on disk is identical to the last sync (only the read-only flag was removed
+by git). This is the common case after switching branches. git-p4son detects this by comparing git blob IDs against
+the last sync commit that touched the file, restores the read-only flag, and lets the sync overwrite the file.
+
+**writable-changed** - The file on disk differs from the last sync. This happens when you manually edit a file
+on `main` and commit it to git without submitting to Perforce. git-p4son lets the sync overwrite the file and
+includes it in the sync commit (so the commit reflects pure Perforce state), then three-way merges your local
+changes on top of the new Perforce content - similar to a `git rebase`. If the merge is clean, the result appears
+as an unstaged change. If there are conflicts, standard conflict markers are inserted for you to resolve.
+
+**added both locally and in Perforce** - A file you committed to git is also being added by Perforce (p4 has never
+synced it to your workspace). There is no common baseline, so git-p4son merges the two versions against an empty
+base: identical content merges cleanly, otherwise the file gets a single conflict block containing both full
+versions for you to resolve.
+
+**binary files** - Binary files that have local changes cannot be three-way merged. git-p4son restores your local
+version to disk after the sync commit so it shows up in `git status` for you to handle manually.
+
+**added locally, deleted upstream** - A file with local changes in git was deleted in Perforce. git-p4son lets the
+delete stand and warns you - your version remains available in git history.
 
-When you switch branches with `git checkout`, git overwrites the files that differ between the source and target branch.
-In doing so, it always removes the read-only flag - this is just how git works.
+**deleted locally, added upstream** - A file you deleted from git was modified in Perforce. The Perforce version is
+kept in the sync commit. You can delete it again if you want.
 
-Now imagine one of those files has also been modified in Perforce. The next time `p4 sync` runs, Perforce will complain
-that a file was changed outside its control. At that point you have two options: either force-sync the individual file
-with `p4 sync -f //path/to/file`, or enable the `clobber` flag on your workspace so that Perforce silently overwrites
-writable files.
+**ignored** - Files ignored by `.gitignore` are skipped with a warning. These are outside git's domain and should
+be managed manually or via Perforce directly.
 
-This is not specific to git-p4son - any workflow that combines git and Perforce in the same workspace will run into it.
-And in practice it is harmless: your local changes live on feature branches in git, so when you rebase onto `main` after
-a sync, your changes are reapplied on top of the latest Perforce state.
+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.
 
 ## Usage
 
@@ -218,7 +236,7 @@ Initialize a git repository inside a Perforce workspace:
 git p4son init
 ```
 
-This command checks preconditions (Perforce workspace, clobber flag), configures the depot root, runs `git init`,
+This command checks preconditions (Perforce workspace), configures the depot root, runs `git init`,
 sets up `.gitignore`, and creates an initial commit.
 
 The depot root determines which part of the Perforce workspace git-p4son syncs. You can choose to sync the entire
@@ -243,7 +261,7 @@ git p4son sync [changelist] [--force]
   sync to the latest changelist affecting the workspace.
 
 **Options:**
-- `-f, --force`: Force sync encountered writable files and allow syncing to older changelists.
+- `-f, --force`: Allow syncing to changelists older than the current one.
 
 **Examples:**
 ```sh

{git_p4son-0.2.11 → git_p4son-0.3.0}/git_p4son/__init__.py

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

{git_p4son-0.2.11 → git_p4son-0.3.0}/git_p4son/alias.py

@@ -8,6 +8,7 @@ from .changelist_store import (
     list_changelist_aliases,
     delete_changelist_alias,
 )
+from .common import prompt_choice
 from .log import log
 
 
@@ -54,31 +55,6 @@ def alias_delete_command(args: argparse.Namespace) -> int:
     return 0
 
 
-def _prompt_choice(prefix: str, options: list[str]) -> str | None:
-    """Prompt until the response matches an option or its first letter.
-
-    The choices are rendered from the options, e.g. "[y]es / [n]o", so the
-    prompt and the accepted keys cannot drift apart. Options must have
-    unique first letters. Returns the chosen option, or None on EOF.
-    """
-    shorthands = {option[0]: option for option in options}
-    rendered = ' / '.join(f'[{option[0]}]{option[1:]}' for option in options)
-    keys = list(shorthands)
-    while True:
-        try:
-            response = input(f'{prefix} {rendered}: ').strip().lower()
-        except EOFError:
-            print()
-            return None
-
-        if response in shorthands:
-            return shorthands[response]
-        elif response in options:
-            return response
-        else:
-            print('Please enter ' + ', '.join(keys[:-1]) + f' or {keys[-1]}')
-
-
 def _clean_all(aliases: list[tuple[str, str]], workspace_dir: str) -> None:
     """Delete every alias without further prompting."""
     for name, _changelist in aliases:
@@ -98,7 +74,7 @@ def _clean_interactive(aliases: list[tuple[str, str]],
         log.heading(f'{name} -> CL {changelist}')
 
         if response != 'all':
-            response = _prompt_choice(
+            response = prompt_choice(
                 'Delete?', ['yes', 'no', 'all', 'quit'])
 
         if response is None or response == 'quit':
@@ -125,7 +101,7 @@ def alias_clean_command(args: argparse.Namespace) -> int:
     for name, changelist in aliases:
         log.info(f'{name} -> {changelist}')
 
-    mode = _prompt_choice('Delete?', ['all', 'interactive', 'quit'])
+    mode = prompt_choice('Delete?', ['all', 'interactive', 'quit'])
     if mode is None or mode == 'quit':
         log.info('Aborting')
         return 0

{git_p4son-0.2.11 → git_p4son-0.3.0}/git_p4son/cli.py

@@ -66,7 +66,7 @@ Examples:
         'init',
         help='Initialize a git repository inside a Perforce workspace',
         description='Set up a new git repository inside a Perforce workspace. '
-        'Checks preconditions (P4 workspace, clobber flag), initializes git, '
+        'Checks preconditions (P4 workspace), initializes git, '
         'sets up .gitignore, and creates an initial commit.'
     )
 
@@ -86,10 +86,7 @@ Examples:
     sync_parser.add_argument(
         '-f', '--force',
         action='store_true',
-        help='Force sync encountered writable files and allow syncing to older changelists. '
-             'When clobber is not enabled on your workspace, p4 will fail to sync files that '
-             'are read-only. git removes the readonly flag on touched files. Also allows '
-             'syncing to changelists older than the current one.'
+        help='Allow syncing to changelists older than the current one.'
     )
 
     # New subcommand

{git_p4son-0.2.11 → git_p4son-0.3.0}/git_p4son/common.py

@@ -36,6 +36,31 @@ def branch_to_alias(branch_name: str) -> str:
     return branch_name.replace('/', '-')
 
 
+def prompt_choice(prefix: str, options: list[str]) -> str | None:
+    """Prompt until the response matches an option or its first letter.
+
+    The choices are rendered from the options, e.g. "[y]es / [n]o", so the
+    prompt and the accepted keys cannot drift apart. Options must have
+    unique first letters. Returns the chosen option, or None on EOF.
+    """
+    shorthands = {option[0]: option for option in options}
+    rendered = ' / '.join(f'[{option[0]}]{option[1:]}' for option in options)
+    keys = list(shorthands)
+    while True:
+        try:
+            response = input(f'{prefix} {rendered}: ').strip().lower()
+        except EOFError:
+            print()
+            return None
+
+        if response in shorthands:
+            return shorthands[response]
+        elif response in options:
+            return response
+        else:
+            print('Please enter ' + ', '.join(keys[:-1]) + f' or {keys[-1]}')
+
+
 def _path_module_for(*paths: str):
     """Choose a path module that matches the given path strings."""
     if any('\\' in path or re.match(r'^[A-Za-z]:', path) for path in paths):

{git_p4son-0.2.11 → git_p4son-0.3.0}/git_p4son/config.py

@@ -18,15 +18,28 @@ def config_path(workspace_dir: str) -> str:
     return os.path.join(workspace_dir, CONFIG_DIR, 'config.toml')
 
 
-def load_config(workspace_dir: str) -> dict:
-    """Read and parse the config file. Returns empty dict if missing."""
-    path = config_path(workspace_dir)
+def load_toml(path: str) -> dict:
+    """Read and parse a TOML file. Returns empty dict if missing."""
     if not os.path.exists(path):
         return {}
     with open(path, 'rb') as f:
         return tomllib.load(f)
 
 
+def write_toml(path: str, data: dict) -> None:
+    """Write data to a TOML file, creating parent directories as needed."""
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    # tomllib reads strict UTF-8, so write UTF-8 explicitly.
+    with open(path, 'w', encoding='utf-8') as f:
+        for section, values in data.items():
+            _write_table(f, _format_key(section), values)
+
+
+def load_config(workspace_dir: str) -> dict:
+    """Read and parse the config file. Returns empty dict if missing."""
+    return load_toml(config_path(workspace_dir))
+
+
 def save_config(workspace_dir: str, config: dict) -> None:
     """Merge config into the config file, section by section.
 
@@ -36,13 +49,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)
-
-    path = config_path(workspace_dir)
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    # tomllib reads strict UTF-8, so write UTF-8 explicitly.
-    with open(path, 'w', encoding='utf-8') as f:
-        for section, values in merged.items():
-            _write_table(f, _format_key(section), values)
+    write_toml(config_path(workspace_dir), merged)
 
 
 def _format_string(value: str) -> str:

{git_p4son-0.2.11 → git_p4son-0.3.0}/git_p4son/git.py

@@ -234,6 +234,199 @@ def get_commit_subjects_since(base_branch: str, workspace_dir: str) -> list[str]
     return subjects
 
 
+# --- tracking ---
+
+def get_tracked_files(filepaths: list[str], workspace_dir: str) -> set[str]:
+    """Return the subset of filepaths that are tracked by git, batched.
+
+    Tracking status decides whether a file is git's to manage: a tracked
+    file matching a .gitignore pattern (common when .gitignore was copied
+    from .p4ignore) is still tracked. Returned paths are the input paths."""
+    if not filepaths:
+        return set()
+    by_git_path: dict[str, str] = {}
+    for filepath in filepaths:
+        git_path = normalize_workspace_path(filepath, workspace_dir)
+        if git_path is not None:
+            by_git_path[git_path] = filepath
+    tracked: set[str] = set()
+    chunks = _chunk_paths_by_length(
+        list(by_git_path), _PATHSPEC_LENGTH_BUDGET)
+    for chunk in chunks:
+        # -z output is NUL-separated and verbatim; without it paths with
+        # non-ASCII characters are C-quoted and would never match.
+        result = run(['git', 'ls-files', '-z', '--'] + chunk,
+                     cwd=workspace_dir)
+        for line in result.stdout:
+            for git_path in line.split('\0'):
+                if git_path in by_git_path:
+                    tracked.add(by_git_path[git_path])
+    return tracked
+
+
+# --- file retrieval ---
+
+def get_file_at_commit(filepath: str, commit: str,
+                       workspace_dir: str) -> bytes | None:
+    """Retrieve file content at a specific commit. Returns None if the file doesn't exist."""
+    # Git uses forward slashes in tree paths, even on Windows
+    git_path = filepath.replace('\\', '/')
+    result = run(['git', 'show', f'{commit}:{git_path}'],
+                 cwd=workspace_dir, text=False, fail_on_returncode=False)
+    if result.returncode != 0:
+        return None
+    return result.stdout
+
+
+def get_blob_oids(items: list[tuple[str, str]],
+                  workspace_dir: str) -> dict[tuple[str, str], str | None]:
+    """Blob OIDs for (commit, filepath) pairs, resolved in one git call.
+
+    Returns a mapping of (commit, filepath) to OID, or None when the file
+    doesn't exist at that commit. Equal OIDs mean byte-identical content
+    (git content-addresses blobs), so this answers "did the content change?"
+    without transferring the blobs."""
+    if not items:
+        return {}
+    queries = []
+    for commit, filepath in items:
+        # Git uses forward slashes in tree paths, even on Windows
+        git_path = filepath.replace('\\', '/')
+        queries.append(f'{commit}:{git_path}')
+    # cat-file --batch-check reads object names from stdin and emits exactly
+    # one line per input line, so results map back to items by position.
+    result = run(['git', 'cat-file', '--batch-check'], cwd=workspace_dir,
+                 input='\n'.join(queries) + '\n')
+    oids: dict[tuple[str, str], str | None] = {}
+    for item, line in zip(items, result.stdout):
+        # Found objects print "<oid> <type> <size>"; anything else
+        # (missing, ambiguous) means no blob at that commit.
+        parts = line.split()
+        if len(parts) == 3 and parts[2].isdigit():
+            oids[item] = parts[0]
+        else:
+            oids[item] = None
+    return oids
+
+
+def get_head_commit(workspace_dir: str) -> str:
+    """Return the SHA of HEAD."""
+    result = run(['git', 'rev-parse', 'HEAD'], cwd=workspace_dir)
+    return result.stdout[0].strip()
+
+
+# Substring identifying git-p4son sync commit subjects.
+SYNC_SUBJECT_MARKER = ': p4 sync //'
+
+# Conservative limit for pathspec arguments per git invocation; Windows
+# caps the whole command line at 32767 characters.
+_PATHSPEC_LENGTH_BUDGET = 20000
+
+
+def _chunk_paths_by_length(paths: list[str], budget: int) -> list[list[str]]:
+    """Split paths into chunks whose total argument length stays in budget."""
+    chunks: list[list[str]] = []
+    chunk: list[str] = []
+    used = 0
+    for path in paths:
+        cost = len(path) + 1
+        if chunk and used + cost > budget:
+            chunks.append(chunk)
+            chunk = []
+            used = 0
+        chunk.append(path)
+        used += cost
+    if chunk:
+        chunks.append(chunk)
+    return chunks
+
+
+def find_base_commits(filepaths: list[str], before_commit: str,
+                      workspace_dir: str) -> dict[str, str | None]:
+    """Baseline commit for each repo-relative path, batched.
+
+    The baseline is the most recent sync commit reachable from before_commit
+    (inclusive) that touched the file, falling back to the most recent commit
+    that added it when no sync commit ever touched it (e.g. files brought in
+    via an initial bulk import committed with a non-sync subject; if the file
+    was deleted and re-added, the most recent add starts the current
+    lineage), or None when neither exists.
+
+    All paths are resolved in a single history walk per pathspec chunk
+    instead of one git log per file."""
+    result: dict[str, str | None] = {}
+    if not filepaths:
+        return result
+    # Git uses forward slashes in tree paths, even on Windows
+    by_git_path = {fp.replace('\\', '/'): fp for fp in filepaths}
+    chunks = _chunk_paths_by_length(
+        list(by_git_path), _PATHSPEC_LENGTH_BUDGET)
+    for chunk in chunks:
+        chunk_result = _find_base_commits_chunk(
+            chunk, before_commit, workspace_dir)
+        for git_path, sha in chunk_result.items():
+            result[by_git_path[git_path]] = sha
+    return result
+
+
+def _find_base_commits_chunk(git_paths: list[str], before_commit: str,
+                             workspace_dir: str) -> dict[str, str | None]:
+    """One newest-first history walk resolving baselines for git_paths.
+
+    The first sync commit seen touching a path is its baseline (the most
+    recent one). The first add seen is remembered as the fallback for paths
+    no sync commit ever touched. core.quotePath is disabled so non-ASCII
+    paths in --name-status output match the input verbatim."""
+    result: dict[str, str | None] = dict.fromkeys(git_paths)
+    res = run(
+        ['git', '-c', 'core.quotePath=false', 'log', '--no-renames',
+         '--name-status', '--pretty=format:%x01%H%x01%s',
+         before_commit, '--'] + git_paths,
+        cwd=workspace_dir, fail_on_returncode=False)
+    if res.returncode != 0:
+        return result
+
+    remaining = set(git_paths)
+    fallback_add: dict[str, str] = {}
+    current_sha = ''
+    current_is_sync = False
+    for line in res.stdout:
+        if line.startswith('\x01'):
+            _, current_sha, subject = line.split('\x01', 2)
+            current_is_sync = SYNC_SUBJECT_MARKER in subject
+            continue
+        status, sep, path = line.partition('\t')
+        if not sep or path not in remaining:
+            continue
+        if current_is_sync:
+            result[path] = current_sha
+            remaining.discard(path)
+        elif status.startswith('A') and path not in fallback_add:
+            fallback_add[path] = current_sha
+    for path in remaining:
+        result[path] = fallback_add.get(path)
+    return result
+
+
+# --- merge ---
+
+def merge_file(current_path: str, base_path: str,
+               other_path: str) -> tuple[bool, bytes]:
+    """Three-way merge using git merge-file.
+
+    All three inputs are file paths read by git directly. Returns
+    (clean, merged_content) where clean is True if no conflicts.
+    """
+    result = run(
+        ['git', 'merge-file', '-p',
+         '--marker-size=7',
+         '-L', 'Perforce', '-L', 'base', '-L', 'local',
+         current_path, base_path, other_path],
+        text=False, fail_on_returncode=False)
+    # git merge-file -p: exit 0 = clean, >0 = conflicts (count), <0 = error
+    return (result.returncode == 0, result.stdout)
+
+
 # --- editor ---
 
 def resolve_editor(workspace_dir: str) -> str | None:

{git_p4son-0.2.11 → git_p4son-0.3.0}/git_p4son/init.py

@@ -145,17 +145,6 @@ def init_command(args: argparse.Namespace) -> int:
         return 1
     log.success(spec.name)
 
-    log.heading('Checking clobber flag')
-    if spec.clobber:
-        log.success('clobber is enabled')
-    else:
-        log.error(
-            f'clobber is not enabled on workspace "{spec.name}".\n'
-            '  Git removes read-only flags when switching branches, so p4 sync\n'
-            '  will fail to overwrite those files unless clobber is enabled.\n'
-            f'  Edit "{spec.name}" in P4V to set the clobber flag.')
-        return 1
-
     if not _configure_depot_root(spec.name, cwd, spec.root):
         return 1