git-p4son 0.2.7__tar.gz → 0.2.9__tar.gz

{git_p4son-0.2.7 → git_p4son-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.2.7
+Version: 0.2.9
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT

{git_p4son-0.2.7 → git_p4son-0.2.9}/git_p4son/__init__.py

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

{git_p4son-0.2.7 → git_p4son-0.2.9}/git_p4son/changelist_store.py

@@ -5,6 +5,7 @@ Stores named aliases for changelist numbers in .git-p4son/changelists/<name>.
 """
 
 import os
+import re
 
 from . import CONFIG_DIR
 from .log import log
@@ -12,6 +13,25 @@ from .log import log
 
 RESERVED_KEYWORDS = frozenset({'last-synced', 'branch'})
 
+# Allowed characters: ASCII letters, digits, hyphen, underscore, dot.
+# Must not start or end with a dot, so "." and ".." are rejected and the
+# filename does not collide with hidden files or platform-specific quirks
+# (Windows disallows trailing dots).
+_ALIAS_NAME_RE = re.compile(r'^[A-Za-z0-9_-]([A-Za-z0-9._-]*[A-Za-z0-9_-])?$')
+
+
+def validate_alias_name(name: str) -> str | None:
+    """Return an error message if alias name is invalid, else None."""
+    if not name:
+        return 'Alias name cannot be empty'
+    if name in RESERVED_KEYWORDS:
+        return f'Alias name "{name}" is a reserved keyword'
+    if not _ALIAS_NAME_RE.match(name):
+        return (
+            f'Invalid alias name "{name}": must contain only letters, digits, '
+            'hyphens, underscores, and dots, and must not start or end with a dot')
+    return None
+
 
 def _changelists_dir(workspace_dir: str) -> str:
     """Return the path to the changelists alias directory."""
@@ -26,8 +46,9 @@ def alias_exists(name: str, workspace_dir: str) -> bool:
 
 def save_changelist_alias(name: str, changelist: str, workspace_dir: str, force: bool = False) -> bool:
     """Save a changelist number under a named alias."""
-    if name in RESERVED_KEYWORDS:
-        log.error(f'Alias name "{name}" is a reserved keyword')
+    error = validate_alias_name(name)
+    if error:
+        log.error(error)
         return False
 
     changelists_dir = _changelists_dir(workspace_dir)

{git_p4son-0.2.7 → git_p4son-0.2.9}/git_p4son/common.py

@@ -2,6 +2,7 @@
 Common utilities shared between sync and edit commands.
 """
 
+import os
 import queue
 import subprocess
 import sys
@@ -13,6 +14,19 @@ from typing import IO, Callable
 from .log import log
 
 
+def _env_with_pwd(cwd: str) -> dict[str, str]:
+    """Return a copy of os.environ with PWD set to abspath(cwd).
+
+    subprocess only changes the child's kernel cwd; PWD is inherited from
+    the parent. Tools that read PWD for relative-path resolution (notably
+    'p4 add') would otherwise resolve paths against the wrong directory
+    when git-p4son is invoked from a subdirectory of the workspace.
+    """
+    env = os.environ.copy()
+    env['PWD'] = os.path.abspath(cwd)
+    return env
+
+
 def branch_to_alias(branch_name: str) -> str:
     """Sanitize a branch name for use as an alias filename."""
     return branch_name.replace('/', '-')
@@ -85,6 +99,7 @@ def run(command: list[str], cwd: str = '.', dry_run: bool = False,
 
     result = subprocess.run(command,
                             cwd=cwd,
+                            env=_env_with_pwd(cwd),
                             capture_output=True,
                             text=True,
                             input=input)
@@ -136,6 +151,7 @@ def run_with_output(command: list[str], cwd: str = '.', on_output: Callable[...,
 
     with subprocess.Popen(command,
                           cwd=cwd,
+                          env=_env_with_pwd(cwd),
                           stdout=subprocess.PIPE,
                           stderr=subprocess.PIPE,
                           text=True) as process:

{git_p4son-0.2.7 → git_p4son-0.2.9}/git_p4son/new.py

@@ -6,7 +6,11 @@ creates a Swarm review.
 """
 
 import argparse
-from .changelist_store import alias_exists, save_changelist_alias
+from .changelist_store import (
+    alias_exists,
+    save_changelist_alias,
+    validate_alias_name,
+)
 from .lib import create_changelist, open_changes_for_edit
 from .perforce import add_review_keyword_to_changelist, p4_shelve_changelist
 from .log import log
@@ -16,8 +20,12 @@ def new_command(args: argparse.Namespace) -> int:
     """Execute the new command."""
     workspace_dir = args.workspace_dir
 
-    # Check alias availability before creating the changelist
+    # Validate alias name and availability before creating the changelist
     if args.alias and not args.dry_run:
+        error = validate_alias_name(args.alias)
+        if error:
+            log.error(error)
+            return 1
         if alias_exists(args.alias, workspace_dir) and not args.force:
             log.error(
                 f'Alias "{args.alias}" already exists '

{git_p4son-0.2.7 → git_p4son-0.2.9}/git_p4son/perforce.py

@@ -207,6 +207,15 @@ def _ensure_in_changelist(filename: str, p4_action: str, changelist: str,
         # Action mismatch - revert first, then reopen with correct action.
         # p4 revert overwrites the file on disk with the depot version,
         # so we need git restore afterwards to get the git content back.
+
+        # add -> edit: the file is new to the depot, so it must stay as add.
+        # This happens when a file is added in one commit and modified in the next.
+        if current_action == 'add' and p4_action == 'edit':
+            if current_cl != changelist:
+                run(['p4', 'reopen', '-c', changelist, filename],
+                    cwd=workspace_dir, dry_run=dry_run)
+            return
+
         run(['p4', 'revert', filename], cwd=workspace_dir, dry_run=dry_run)
         # For add -> delete: the file never existed in the depot, so just revert.
         if current_action == 'add' and p4_action == 'delete':
@@ -297,9 +306,8 @@ def parse_p4_sync_line(line: str) -> tuple[str | None, str | None]:
 class P4SyncOutputProcessor:
     """Process p4 sync output in real-time."""
 
-    def __init__(self, file_count_to_sync: int) -> None:
+    def __init__(self) -> None:
         self.synced_file_count: int = 0
-        self.file_count_to_sync: int = file_count_to_sync
         self.stats: dict[str, int] = {
             mode: 0 for mode in ['add', 'del', 'upd', 'clb']}
 
@@ -310,18 +318,12 @@ class P4SyncOutputProcessor:
 
         mode, filename = parse_p4_sync_line(line)
         if not mode or not filename:
-            log.verbose(f'Unparsable line: {line}')
+            log.warning(f'Unparsable line: {line}')
             return
 
         self.stats[mode] += 1
         self.synced_file_count += 1
 
-        if self.file_count_to_sync >= 0:
-            log.verbose(
-                f'{mode}: {filename}  ({self.synced_file_count}/{self.file_count_to_sync})')
-        else:
-            log.verbose(f'{mode}: {filename}')
-
     def get_summary(self) -> str:
         """Get a one-line sync summary."""
         synced_count = self.stats['add'] + \
@@ -343,18 +345,10 @@ class P4SyncOutputProcessor:
 
 def p4_force_sync_file(changelist: int, filename: str, workspace_dir: str) -> None:
     """Force sync a single file."""
-    output_processor = P4SyncOutputProcessor(-1)
+    output_processor = P4SyncOutputProcessor()
     result = run_with_output(
         ['p4', 'sync', '-f', f'{filename}@{changelist}'],
         cwd=workspace_dir, on_output=output_processor)
     log.info(output_processor.get_summary())
     if result.elapsed:
         log.elapsed(result.elapsed)
-
-
-def get_file_count_to_sync(changelist: int, depot_root: str,
-                           workspace_dir: str) -> int:
-    """Get the number of files that need to be synced."""
-    res = run(['p4', 'sync', '-n', f'{depot_root}/...@{changelist}'],
-              cwd=workspace_dir)
-    return len(res.stdout)

{git_p4son-0.2.7 → git_p4son-0.2.9}/git_p4son/review.py

@@ -10,7 +10,7 @@ import os
 import shlex
 import subprocess
 from . import CONFIG_DIR
-from .changelist_store import alias_exists
+from .changelist_store import alias_exists, validate_alias_name
 from .git import get_commit_lines_since, resolve_editor
 from .log import log
 
@@ -58,6 +58,14 @@ def review_command(args: argparse.Namespace) -> int:
     """Execute the review command."""
     workspace_dir = args.workspace_dir
 
+    # Validate alias name before starting
+    log.heading(f'Validating alias "{args.alias}"')
+    error = validate_alias_name(args.alias)
+    if error:
+        log.error(error)
+        return 1
+    log.success('Done')
+
     # Check alias availability before starting
     if not args.force:
         log.heading(f'Checking alias "{args.alias}" is available')

{git_p4son-0.2.7 → git_p4son-0.2.9}/git_p4son/sync.py

@@ -11,7 +11,6 @@ from .config import get_depot_root
 from .git import add_all_files, commit, get_dirty_files
 from .log import log
 from .perforce import (
-    get_file_count_to_sync,
     get_latest_changelist,
     p4_force_sync_file,
     p4_get_opened_files,
@@ -62,9 +61,8 @@ def parse_p4_sync_line(line: str) -> tuple[str | None, str | None]:
 class P4SyncOutputProcessor:
     """Process p4 sync output in real-time."""
 
-    def __init__(self, file_count_to_sync: int) -> None:
+    def __init__(self) -> None:
         self.synced_file_count: int = 0
-        self.file_count_to_sync: int = file_count_to_sync
         self.stats: dict[str, int] = {
             mode: 0 for mode in ['add', 'del', 'upd', 'clb']}
 
@@ -75,18 +73,12 @@ class P4SyncOutputProcessor:
 
         mode, filename = parse_p4_sync_line(line)
         if not mode or not filename:
-            log.verbose(f'Unparsable line: {line}')
+            log.warning(f'Unparsable line: {line}')
             return
 
         self.stats[mode] += 1
         self.synced_file_count += 1
 
-        if self.file_count_to_sync >= 0:
-            log.verbose(
-                f'{mode}: {filename}  ({self.synced_file_count}/{self.file_count_to_sync})')
-        else:
-            log.verbose(f'{mode}: {filename}')
-
     def get_summary(self) -> str:
         """Get a one-line sync summary."""
         synced_count = self.stats['add'] + \
@@ -114,14 +106,8 @@ def p4_sync(changelist: int, label: str, force: bool, depot_root: str,
     Raises CommandError on actual command failures.
     """
     log.heading(f'Syncing to {label} CL ({changelist})')
-    file_count_to_sync = get_file_count_to_sync(changelist, depot_root,
-                                                workspace_dir)
-    if file_count_to_sync == 0:
-        log.success('All files up to date')
-        return True
-    log.info(f'{file_count_to_sync} files to sync')
 
-    output_processor = P4SyncOutputProcessor(file_count_to_sync)
+    output_processor = P4SyncOutputProcessor()
     try:
         result = run_with_output(
             ['p4', 'sync', f'{depot_root}/...@{changelist}'],

{git_p4son-0.2.7 → git_p4son-0.2.9}/git_p4son.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-p4son
-Version: 0.2.7
+Version: 0.2.9
 Summary: Utility for keeping a Perforce workspace and local git repo in sync
 Author-email: Andreas Andersson <andreas@neoboid.com>
 License-Expression: MIT

{git_p4son-0.2.7 → git_p4son-0.2.9}/git_p4son.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ git_p4son.egg-info/top_level.txt
 git_p4son/completions/_git-p4son
 git_p4son/completions/git-p4son.bash
 git_p4son/completions/git-p4son.ps1
+tests/test_changelist_store.py
 tests/test_cli.py
 tests/test_common.py
 tests/test_complete.py

{git_p4son-0.2.7 → git_p4son-0.2.9}/pyproject.toml

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

git_p4son-0.2.9/tests/test_changelist_store.py

@@ -0,0 +1,76 @@
+"""Tests for git_p4son.changelist_store module."""
+
+import unittest
+
+from git_p4son.changelist_store import validate_alias_name
+
+
+class TestValidateAliasName(unittest.TestCase):
+    def test_simple_name(self):
+        self.assertIsNone(validate_alias_name('my-feature'))
+
+    def test_alphanumeric(self):
+        self.assertIsNone(validate_alias_name('feat123'))
+
+    def test_underscores(self):
+        self.assertIsNone(validate_alias_name('my_feature'))
+
+    def test_dots_in_middle(self):
+        self.assertIsNone(validate_alias_name('feat.v1.0'))
+
+    def test_single_char(self):
+        self.assertIsNone(validate_alias_name('a'))
+
+    def test_leading_hyphen_allowed(self):
+        self.assertIsNone(validate_alias_name('-foo'))
+
+    def test_empty_rejected(self):
+        error = validate_alias_name('')
+        self.assertIsNotNone(error)
+        self.assertIn('empty', error)
+
+    def test_reserved_branch_rejected(self):
+        error = validate_alias_name('branch')
+        self.assertIsNotNone(error)
+        self.assertIn('reserved', error)
+
+    def test_reserved_last_synced_rejected(self):
+        error = validate_alias_name('last-synced')
+        self.assertIsNotNone(error)
+        self.assertIn('reserved', error)
+
+    def test_spaces_rejected(self):
+        error = validate_alias_name('Fix a couple of small bugs')
+        self.assertIsNotNone(error)
+        self.assertIn('Invalid alias name', error)
+
+    def test_slash_rejected(self):
+        error = validate_alias_name('feat/foo')
+        self.assertIsNotNone(error)
+
+    def test_backslash_rejected(self):
+        error = validate_alias_name('feat\\foo')
+        self.assertIsNotNone(error)
+
+    def test_leading_dot_rejected(self):
+        error = validate_alias_name('.hidden')
+        self.assertIsNotNone(error)
+
+    def test_trailing_dot_rejected(self):
+        error = validate_alias_name('foo.')
+        self.assertIsNotNone(error)
+
+    def test_dot_alone_rejected(self):
+        self.assertIsNotNone(validate_alias_name('.'))
+
+    def test_double_dot_rejected(self):
+        self.assertIsNotNone(validate_alias_name('..'))
+
+    def test_special_chars_rejected(self):
+        for ch in ['*', '?', ':', '"', '|', '<', '>', '\'', '(', ')', '!']:
+            with self.subTest(ch=ch):
+                self.assertIsNotNone(validate_alias_name(f'foo{ch}bar'))
+
+
+if __name__ == '__main__':
+    unittest.main()

{git_p4son-0.2.7 → git_p4son-0.2.9}/tests/test_common.py

@@ -141,6 +141,25 @@ class TestBranchToAlias(unittest.TestCase):
         self.assertEqual(branch_to_alias('a/b/c'), 'a-b-c')
 
 
+class TestRunSetsPWD(unittest.TestCase):
+    @mock.patch('subprocess.run')
+    def test_pwd_overrides_inherited_value(self, mock_subprocess_run):
+        mock_subprocess_run.return_value = mock.Mock(
+            returncode=0, stdout='', stderr='')
+        with mock.patch.dict(os.environ, {'PWD': '/some/other/dir'}):
+            run(['p4', 'add', 'foo.txt'], cwd='/workspace')
+        env = mock_subprocess_run.call_args.kwargs['env']
+        self.assertEqual(env['PWD'], '/workspace')
+
+    @mock.patch('subprocess.run')
+    def test_pwd_uses_absolute_path(self, mock_subprocess_run):
+        mock_subprocess_run.return_value = mock.Mock(
+            returncode=0, stdout='', stderr='')
+        run(['p4', 'add', 'foo.txt'], cwd='.')
+        env = mock_subprocess_run.call_args.kwargs['env']
+        self.assertEqual(env['PWD'], os.path.abspath('.'))
+
+
 class TestJoinCommandLine(unittest.TestCase):
     def test_simple_command(self):
         result = join_command_line(['git', 'status'])
@@ -210,13 +229,13 @@ class TestRun(unittest.TestCase):
             stderr='',
         )
         result = run(['git', 'status'], cwd='/tmp')
-        mock_subprocess_run.assert_called_once_with(
-            ['git', 'status'],
-            cwd='/tmp',
-            capture_output=True,
-            text=True,
-            input=None,
-        )
+        call = mock_subprocess_run.call_args
+        self.assertEqual(call.args, (['git', 'status'],))
+        self.assertEqual(call.kwargs['cwd'], '/tmp')
+        self.assertEqual(call.kwargs['capture_output'], True)
+        self.assertEqual(call.kwargs['text'], True)
+        self.assertEqual(call.kwargs['input'], None)
+        self.assertEqual(call.kwargs['env']['PWD'], '/tmp')
         self.assertEqual(result.returncode, 0)
         self.assertEqual(result.stdout, ['line1', 'line2'])
         self.assertEqual(result.stderr, [])
@@ -254,13 +273,13 @@ class TestRunWithOutput(unittest.TestCase):
         mock_popen_cls.return_value = mock_process
 
         result = run_with_output(['git', 'status'], cwd='/tmp')
-        mock_popen_cls.assert_called_once_with(
-            ['git', 'status'],
-            cwd='/tmp',
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
+        call = mock_popen_cls.call_args
+        self.assertEqual(call.args, (['git', 'status'],))
+        self.assertEqual(call.kwargs['cwd'], '/tmp')
+        self.assertEqual(call.kwargs['stdout'], subprocess.PIPE)
+        self.assertEqual(call.kwargs['stderr'], subprocess.PIPE)
+        self.assertEqual(call.kwargs['text'], True)
+        self.assertEqual(call.kwargs['env']['PWD'], '/tmp')
         self.assertEqual(result.returncode, 0)
 
     @mock.patch('subprocess.Popen')

{git_p4son-0.2.7 → git_p4son-0.2.9}/tests/test_lib_edit.py

@@ -350,6 +350,28 @@ class TestActionMismatch(unittest.TestCase):
         self.assertEqual(calls[2][0][0],
                          ['git', 'restore', 'file.txt'])
 
+    # --- add -> edit (keep as add, file is new to depot) ---
+    @mock.patch('git_p4son.perforce.get_changelist_for_file', return_value=('100', 'add'))
+    @mock.patch('git_p4son.perforce.run')
+    def test_add_to_edit_same_cl_keeps_add(self, mock_run, mock_check):
+        mock_run.return_value = make_run_result()
+        changes = LocalChanges()
+        changes.mods = ['file.txt']
+        include_changes_in_changelist(changes, '100', '/ws')
+        mock_run.assert_not_called()
+
+    @mock.patch('git_p4son.perforce.get_changelist_for_file', return_value=('200', 'add'))
+    @mock.patch('git_p4son.perforce.run')
+    def test_add_to_edit_different_cl_reopens(self, mock_run, mock_check):
+        mock_run.return_value = make_run_result()
+        changes = LocalChanges()
+        changes.mods = ['file.txt']
+        include_changes_in_changelist(changes, '100', '/ws')
+        mock_run.assert_called_once_with(
+            ['p4', 'reopen', '-c', '100', 'file.txt'],
+            cwd='/ws', dry_run=False,
+        )
+
     # --- add -> delete (revert only, no reopen) ---
     @mock.patch('git_p4son.perforce.get_changelist_for_file', return_value=('100', 'add'))
     @mock.patch('git_p4son.perforce.run')

{git_p4son-0.2.7 → git_p4son-0.2.9}/tests/test_sync.py

@@ -7,7 +7,6 @@ from unittest import mock
 from git_p4son.common import CommandError, RunError
 from git_p4son.perforce import (
     P4SyncOutputProcessor,
-    get_file_count_to_sync,
     get_latest_changelist,
     get_writable_files,
     p4_get_opened_files,
@@ -317,62 +316,31 @@ class TestGetLatestChangelist(unittest.TestCase):
             get_latest_changelist('//myclient', '/ws')
 
 
-class TestGetFileCountToSync(unittest.TestCase):
-    @mock.patch('git_p4son.perforce.run')
-    def test_returns_count(self, mock_run):
-        mock_run.return_value = make_run_result(stdout=[
-            '//depot/a.txt - added',
-            '//depot/b.txt - updating',
-        ])
-        count = get_file_count_to_sync(12345, '//myclient', '/ws')
-        self.assertEqual(count, 2)
-
-    @mock.patch('git_p4son.perforce.run')
-    def test_failure(self, mock_run):
-        mock_run.side_effect = RunError('p4 sync -n failed')
-        with self.assertRaises(RunError):
-            get_file_count_to_sync(12345, '//myclient', '/ws')
-
-
 class TestP4SyncOutputProcessor(unittest.TestCase):
     def test_tracks_added_file(self):
-        processor = P4SyncOutputProcessor(10)
+        processor = P4SyncOutputProcessor()
         processor('//depot/foo.txt#1 - added as /ws/foo.txt', sys.stdout)
         self.assertEqual(processor.stats['add'], 1)
         self.assertEqual(processor.synced_file_count, 1)
 
     def test_tracks_deleted_file(self):
-        processor = P4SyncOutputProcessor(10)
+        processor = P4SyncOutputProcessor()
         processor('//depot/foo.txt#2 - deleted as /ws/foo.txt', sys.stdout)
         self.assertEqual(processor.stats['del'], 1)
 
     def test_up_to_date_message(self):
-        processor = P4SyncOutputProcessor(10)
+        processor = P4SyncOutputProcessor()
         processor('//...@12345 - file(s) up-to-date.', sys.stdout)
         self.assertEqual(processor.synced_file_count, 0)
 
 
 class TestP4Sync(unittest.TestCase):
     @mock.patch('git_p4son.sync.run_with_output')
-    @mock.patch('git_p4son.sync.get_file_count_to_sync')
-    def test_success(self, mock_count, mock_rwo):
-        mock_count.return_value = 2
+    def test_success(self, mock_rwo):
         mock_rwo.return_value = make_run_result()
         result = p4_sync(12345, 'test', False, '//myclient', '/ws')
         self.assertTrue(result)
 
-    @mock.patch('git_p4son.sync.get_file_count_to_sync')
-    def test_up_to_date(self, mock_count):
-        mock_count.return_value = 0
-        result = p4_sync(12345, 'test', False, '//myclient', '/ws')
-        self.assertTrue(result)
-
-    @mock.patch('git_p4son.sync.get_file_count_to_sync')
-    def test_count_failure(self, mock_count):
-        mock_count.side_effect = RunError('p4 sync -n failed')
-        with self.assertRaises(RunError):
-            p4_sync(12345, 'test', False, '//myclient', '/ws')
-
 
 class TestSyncCommand(unittest.TestCase):
     @mock.patch('git_p4son.sync.commit')