tgit 0.34.1__tar.gz → 0.34.2__tar.gz

{tgit-0.34.1 → tgit-0.34.2}/CHANGELOG.md

@@ -1,3 +1,15 @@
+## v0.34.2
+
+[v0.34.1...v0.34.2](https://github.com/Jannchie/tgit/compare/v0.34.1...v0.34.2)
+
+### :adhesive_bandage: Fixes
+
+- **version**: replace utf-8 errors handling in version file reads - By [Jannchie](mailto:jannchie@gmail.com) in [27dd1f8](https://github.com/Jannchie/tgit/commit/27dd1f8)
+
+### :test_tube: Tests
+
+- **cargo**: add unit tests for cargo version updates - By [Jianqi Pan](mailto:jannchie@gmail.com) in [bce5042](https://github.com/Jannchie/tgit/commit/bce5042)
+
 ## v0.34.1
 
 [v0.34.0...v0.34.1](https://github.com/Jannchie/tgit/compare/v0.34.0...v0.34.1)

{tgit-0.34.1 → tgit-0.34.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tgit
-Version: 0.34.1
+Version: 0.34.2
 Summary: AI-powered Git CLI for commits, changelogs, and semantic versioning.
 Project-URL: Homepage, https://github.com/Jannchie/tgit
 Project-URL: Repository, https://github.com/Jannchie/tgit

{tgit-0.34.1 → tgit-0.34.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tgit"
-version = "0.34.1"
+version = "0.34.2"
 description = "AI-powered Git CLI for commits, changelogs, and semantic versioning."
 authors = [{ name = "Jannchie", email = "jannchie@gmail.com" }]
 dependencies = [

{tgit-0.34.1 → tgit-0.34.2}/tests/unit/test_version.py

@@ -10,6 +10,8 @@ from tgit.version import (
     VersionArgs,
     VersionChoice,
     _apply_version_choice,
+    _find_cargo_lock_for,
+    _get_cargo_package_name,
     _get_default_bump_from_commits,
     _handle_explicit_version_args,
     _handle_interactive_version_selection,
@@ -37,6 +39,7 @@ from tgit.version import (
     get_version_from_version_txt,
     handle_version,
     show_file_diff,
+    update_cargo_lock_version,
     update_cargo_toml_version,
     update_file,
     update_version_files,
@@ -941,6 +944,239 @@ members = ["other-crate"]
         update_cargo_toml_version(non_existent_file, "1.0.0", 0, show_diff=False)
 
 
+class TestGetCargoPackageName:
+    """Test cases for _get_cargo_package_name."""
+
+    def test_basic(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[package]\nname = "arthash"\nversion = "0.2.0"\n')
+        assert _get_cargo_package_name(cargo_toml) == "arthash"
+
+    def test_missing_file(self, tmp_path):
+        assert _get_cargo_package_name(tmp_path / "Cargo.toml") is None
+
+    def test_missing_package_section(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[workspace]\nmembers = ["a"]\n')
+        assert _get_cargo_package_name(cargo_toml) is None
+
+    def test_missing_name_key(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[package]\nversion = "0.1.0"\n')
+        assert _get_cargo_package_name(cargo_toml) is None
+
+    def test_empty_name(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[package]\nname = ""\nversion = "0.1.0"\n')
+        assert _get_cargo_package_name(cargo_toml) is None
+
+    def test_invalid_toml(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text("this is not valid toml [[[")
+        assert _get_cargo_package_name(cargo_toml) is None
+
+
+class TestFindCargoLockFor:
+    """Test cases for _find_cargo_lock_for."""
+
+    def test_same_directory(self, tmp_path):
+        """Single-crate layout: Cargo.toml and Cargo.lock side-by-side."""
+        (tmp_path / "Cargo.toml").write_text('[package]\nname = "x"\nversion = "0.1.0"\n')
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text("# lock\n")
+        assert _find_cargo_lock_for(tmp_path) == lockfile
+
+    def test_parent_directory(self, tmp_path):
+        """Workspace layout: lockfile lives at workspace root."""
+        (tmp_path / ".git").mkdir()
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text("# lock\n")
+        member = tmp_path / "crates" / "alpha"
+        member.mkdir(parents=True)
+        (member / "Cargo.toml").write_text('[package]\nname = "alpha"\nversion = "0.1.0"\n')
+        assert _find_cargo_lock_for(member) == lockfile
+
+    def test_no_lockfile_returns_none(self, tmp_path):
+        (tmp_path / ".git").mkdir()
+        crate = tmp_path / "crate"
+        crate.mkdir()
+        (crate / "Cargo.toml").write_text('[package]\nname = "x"\nversion = "0.1.0"\n')
+        assert _find_cargo_lock_for(crate) is None
+
+    def test_stops_at_git_root(self, tmp_path):
+        """Must not escape the current repo, even if an outer Cargo.lock exists."""
+        outer_lock = tmp_path / "Cargo.lock"
+        outer_lock.write_text("# outer\n")
+        repo = tmp_path / "inner_repo"
+        repo.mkdir()
+        (repo / ".git").mkdir()
+        crate = repo / "crate"
+        crate.mkdir()
+        (crate / "Cargo.toml").write_text('[package]\nname = "x"\nversion = "0.1.0"\n')
+        # Should NOT find the outer Cargo.lock — that's in a different repo.
+        assert _find_cargo_lock_for(crate) is None
+
+
+class TestUpdateCargoLockVersion:
+    """Test cases for update_cargo_lock_version."""
+
+    @staticmethod
+    def _make_lockfile(tmp_path: Path, content: str) -> Path:
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text(content, encoding="utf-8")
+        return lockfile
+
+    def test_local_crate_version_updated(self, tmp_path):
+        """Workspace member (no source field) gets its version rewritten."""
+        content = (
+            "# This file is automatically @generated by Cargo.\n"
+            "version = 4\n\n"
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n'
+            "dependencies = [\n"
+            ' "matrixmultiply",\n'
+            "]\n"
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        new_content = lockfile.read_text()
+        assert 'version = "0.3.0"' in new_content
+        assert 'version = "0.2.0"' not in new_content
+
+    def test_registry_dep_with_same_name_not_touched(self, tmp_path):
+        """A registry dep named identically to the local crate must NOT be hit.
+
+        Registry entries have `source = "registry+..."` between `name` and
+        `version`, so they fail the "name immediately followed by version"
+        anchor. Local crates fit the anchor exactly.
+        """
+        content = (
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'source = "registry+https://github.com/rust-lang/crates.io-index"\n'
+            'version = "9.9.9"\n'
+            'checksum = "deadbeef"\n\n'
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n'
+            "dependencies = [\n"
+            ' "matrixmultiply",\n'
+            "]\n"
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        new_content = lockfile.read_text()
+        # registry entry untouched
+        assert 'version = "9.9.9"' in new_content
+        # local entry bumped
+        assert 'version = "0.3.0"' in new_content
+        # only one occurrence of the new version (didn't accidentally double-write)
+        assert new_content.count('version = "0.3.0"') == 1
+
+    def test_crate_not_in_lockfile_is_noop(self, tmp_path):
+        """If the crate isn't recorded, nothing changes."""
+        content = (
+            "[[package]]\n"
+            'name = "other"\n'
+            'version = "1.0.0"\n'
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        assert lockfile.read_text() == content
+
+    def test_missing_lockfile_is_noop(self, tmp_path):
+        """Pure non-Rust projects don't have a Cargo.lock — must not error."""
+        lockfile = tmp_path / "Cargo.lock"
+        # Should not raise.
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        assert not lockfile.exists()
+
+    def test_already_in_sync_is_noop(self, tmp_path):
+        """Idempotent: same version in -> file unchanged."""
+        content = (
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.3.0"\n'
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        before = lockfile.stat().st_mtime_ns
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        # Content identical; we explicitly skip the write in that case.
+        assert lockfile.read_text() == content
+        # And the file was not rewritten (mtime preserved). Some filesystems
+        # have coarse mtime resolution, so this guard is a tightening only —
+        # the content check above is the real assertion.
+        assert lockfile.stat().st_mtime_ns == before
+
+
+class TestUpdateVersionInFileCargoIntegration:
+    """update_version_in_file should sync Cargo.lock when it sees Cargo.toml."""
+
+    def test_cargo_toml_branch_syncs_sibling_lockfile(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text(
+            "[package]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n'
+            "\n"
+            "[dependencies]\n"
+            'matrixmultiply = "0.3"\n',
+            encoding="utf-8",
+        )
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text(
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n'
+            "dependencies = [\n"
+            ' "matrixmultiply",\n'
+            "]\n",
+            encoding="utf-8",
+        )
+        update_version_in_file(0, "0.3.0", "Cargo.toml", cargo_toml, show_diff=False)
+        # Both files should now report 0.3.0.
+        assert 'version = "0.3.0"' in cargo_toml.read_text()
+        assert 'version = "0.3.0"' in lockfile.read_text()
+
+    def test_cargo_toml_branch_syncs_workspace_root_lockfile(self, tmp_path):
+        """Lockfile in workspace root, Cargo.toml in a member directory."""
+        (tmp_path / ".git").mkdir()
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text(
+            "[[package]]\n"
+            'name = "alpha"\n'
+            'version = "0.2.0"\n',
+            encoding="utf-8",
+        )
+        member_dir = tmp_path / "crates" / "alpha"
+        member_dir.mkdir(parents=True)
+        cargo_toml = member_dir / "Cargo.toml"
+        cargo_toml.write_text(
+            "[package]\n"
+            'name = "alpha"\n'
+            'version = "0.2.0"\n',
+            encoding="utf-8",
+        )
+        update_version_in_file(0, "0.3.0", "Cargo.toml", cargo_toml, show_diff=False)
+        assert 'version = "0.3.0"' in cargo_toml.read_text()
+        assert 'version = "0.3.0"' in lockfile.read_text()
+
+    def test_cargo_toml_branch_no_lockfile_present(self, tmp_path):
+        """When there's no lockfile at all, the manifest update still proceeds."""
+        (tmp_path / ".git").mkdir()
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text(
+            "[package]\n"
+            'name = "alpha"\n'
+            'version = "0.2.0"\n',
+            encoding="utf-8",
+        )
+        # Should not raise.
+        update_version_in_file(0, "0.3.0", "Cargo.toml", cargo_toml, show_diff=False)
+        assert 'version = "0.3.0"' in cargo_toml.read_text()
+
+
 class TestParseGitignore:
     """Test cases for _parse_gitignore function."""
 

{tgit-0.34.1 → tgit-0.34.2}/tgit/version.py

@@ -354,7 +354,7 @@ def get_version_from_chart_yaml(path: Path) -> Version | None:
 def get_version_from_setup_py(path: Path) -> Version | None:
     setup_py_path = path / "setup.py"
     if setup_py_path.exists():
-        with setup_py_path.open(encoding="utf-8") as f:
+        with setup_py_path.open(encoding="utf-8", errors="replace") as f:
             setup_data = f.read()
             if res := re.search(r"version=['\"]([^'\"]+)['\"]", setup_data):
                 try:
@@ -413,7 +413,7 @@ def get_version_from_cargo_toml(directory_path: Path) -> Version | None:
 def get_version_from_version_file(path: Path) -> Version | None:
     version_path = path / "VERSION"
     if version_path.exists():
-        with version_path.open(encoding="utf-8") as f:
+        with version_path.open(encoding="utf-8", errors="replace") as f:
             version = f.read().strip()
             try:
                 return Version.from_str(version)
@@ -425,7 +425,7 @@ def get_version_from_version_file(path: Path) -> Version | None:
 def get_version_from_version_txt(path: Path) -> Version | None:
     version_txt_path = path / "VERSION.txt"
     if version_txt_path.exists():
-        with version_txt_path.open(encoding="utf-8") as f:
+        with version_txt_path.open(encoding="utf-8", errors="replace") as f:
             version = f.read().strip()
             try:
                 return Version.from_str(version)
@@ -437,7 +437,7 @@ def get_version_from_version_txt(path: Path) -> Version | None:
 def get_version_from_build_gradle_kts(path: Path) -> Version | None:
     build_gradle_kts_path = path / "build.gradle.kts"
     if build_gradle_kts_path.exists():
-        with build_gradle_kts_path.open(encoding="utf-8") as f:
+        with build_gradle_kts_path.open(encoding="utf-8", errors="replace") as f:
             content = f.read()
             if res := re.search(r'version\s*=\s*"([^"]+)"', content):
                 try:
@@ -875,7 +875,18 @@ def update_version_in_file(verbose: int, next_version_str: str, file: str, file_
     elif file == "setup.py":
         update_file(str(file_path), r"version=['\"].*?['\"]", f"version='{next_version_str}'", verbose, show_diff=show_diff)
     elif file == "Cargo.toml":
+        crate_name = _get_cargo_package_name(file_path)
         update_cargo_toml_version(str(file_path), next_version_str, verbose, show_diff=show_diff)
+        # Cargo.lock pins every workspace member's version. Without
+        # syncing it here, `cargo publish` and `cargo build --locked`
+        # refuse to run against a manifest that disagrees with the
+        # lockfile — the most common reason a release tag gets bumped
+        # but the publish CI step fails on "working directory contains
+        # changes". Idempotent / no-op for pure non-Rust projects.
+        if crate_name:
+            lockfile = _find_cargo_lock_for(file_path.parent)
+            if lockfile is not None:
+                update_cargo_lock_version(crate_name, next_version_str, lockfile, verbose, show_diff=show_diff)
     elif file in ("VERSION", "VERSION.txt"):
         update_file(str(file_path), None, next_version_str, verbose, show_diff=show_diff)
     elif file in ("__about__.py", "__init__.py"):
@@ -918,7 +929,7 @@ def update_file(filename: str, search_pattern: str | None, replace_text: str, ve
         return
     if verbose > 0:
         console.print(f"Updating {file_path}")
-    with file_path.open(encoding="utf-8") as f:
+    with file_path.open(encoding="utf-8", errors="replace") as f:
         content = f.read()
     new_content = re.sub(search_pattern, replace_text, content) if search_pattern else replace_text
     if show_diff:
@@ -935,7 +946,7 @@ def update_cargo_toml_version(filename: str, next_version_str: str, verbose: int
     if verbose > 0:
         console.print(f"Updating {file_path}")
 
-    with file_path.open(encoding="utf-8") as f:
+    with file_path.open(encoding="utf-8", errors="replace") as f:
         content = f.read()
 
     # Use regex to match version in [package] section only
@@ -958,6 +969,82 @@ def update_cargo_toml_version(filename: str, next_version_str: str, verbose: int
         f.write(new_content)
 
 
+def _get_cargo_package_name(cargo_toml_path: Path) -> str | None:
+    """Read [package].name from a Cargo.toml. Returns None if missing/invalid.
+
+    Used to anchor lockfile rewrites — we need the crate's own name to
+    find its entry in Cargo.lock.
+    """
+    if not cargo_toml_path.is_file():
+        return None
+    try:
+        with cargo_toml_path.open("rb") as f:
+            data = tomllib.load(f)
+    except (OSError, tomllib.TOMLDecodeError):
+        return None
+    package = data.get("package")
+    if not isinstance(package, dict):
+        return None
+    name = package.get("name")
+    return name if isinstance(name, str) and name else None
+
+
+def _find_cargo_lock_for(cargo_toml_dir: Path) -> Path | None:
+    """Walk up from a Cargo.toml's directory looking for a Cargo.lock.
+
+    Covers both layouts:
+      * single crate with its own Cargo.lock (lockfile in same dir)
+      * cargo workspace where members share a root-level Cargo.lock
+
+    Stops at the directory containing .git (we never escape the current
+    repo) or at the filesystem root.
+    """
+    current = cargo_toml_dir.resolve()
+    while True:
+        candidate = current / "Cargo.lock"
+        if candidate.is_file():
+            return candidate
+        if (current / ".git").exists():
+            return None
+        if current.parent == current:
+            return None
+        current = current.parent
+
+
+def update_cargo_lock_version(
+    crate_name: str,
+    next_version_str: str,
+    lockfile_path: Path,
+    verbose: int,
+    *,
+    show_diff: bool = True,
+) -> None:
+    """Sync a local crate's version in Cargo.lock.
+
+    Cargo.lock records every dep, but registry deps carry a
+    `source = "registry+..."` line between `name` and `version`.
+    Workspace members / path deps do NOT — their `version` is on the
+    line immediately after `name`. We anchor on that two-line shape so
+    registry deps with the same name as a local crate can't be hit by
+    mistake. No-op if the crate isn't in this lockfile or is already
+    in sync.
+    """
+    if not lockfile_path.is_file():
+        return
+    if verbose > 0:
+        console.print(f"Updating {lockfile_path}")
+    content = lockfile_path.read_text(encoding="utf-8")
+    pattern = re.compile(
+        rf'(\[\[package\]\]\nname = "{re.escape(crate_name)}"\nversion = ")[^"]+(")',
+    )
+    new_content, n = pattern.subn(rf"\g<1>{next_version_str}\g<2>", content, count=1)
+    if n == 0 or new_content == content:
+        return
+    if show_diff:
+        show_file_diff(content, new_content, str(lockfile_path))
+    lockfile_path.write_text(new_content, encoding="utf-8")
+
+
 def show_file_diff(old_content: str, new_content: str, filename: str) -> None:
     old_lines = old_content.splitlines()
     new_lines = new_content.splitlines()

{tgit-0.34.1 → tgit-0.34.2}/uv.lock

@@ -1873,7 +1873,7 @@ wheels = [
 
 [[package]]
 name = "tgit"
-version = "0.34.0"
+version = "0.34.2"
 source = { editable = "." }
 dependencies = [
     { name = "beautifulsoup4" },

tgit-0.34.1/.claude/settings.local.json

@@ -1,17 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(ruff check:*)",
-      "Bash(mkdir:*)",
-      "Bash(rg:*)",
-      "Bash(uv sync:*)",
-      "Bash(python:*)",
-      "Bash(pytest:*)",
-      "Bash(uv run pytest:*)",
-      "Bash(uv run ruff check:*)",
-      "Bash(ls:*)",
-      "Bash(./scripts/test.sh:*)"
-    ],
-    "deny": []
-  }
-}