jrl-cmakemodules-scripts 2.3.0__tar.gz → 2.4.0__tar.gz

{jrl_cmakemodules_scripts-2.3.0 → jrl_cmakemodules_scripts-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jrl-cmakemodules-scripts
-Version: 2.3.0
+Version: 2.4.0
 Summary: Release scripting tools for JRL CMake modules
 License: BSD-3-Clause
 Project-URL: homepage, https://github.com/jrl-umi3218/jrl-cmakemodules
@@ -79,12 +79,15 @@ jrl-release --bump patch --git-commit --git-tag
 | `package.xml` | `<version>` tag |
 | `pyproject.toml` | `project.version` |
 | `CHANGELOG.md` | First `## [X.Y.Z]` section (not Unreleased) |
-| `pixi.toml` | `[workspace] version` |
+| `pixi.toml` | `[workspace] version` and `[package] version` (pixi-build) |
 | `pixi.lock` | Regenerated via `pixi list` |
+| `Cargo.toml` | `[package] version` and `[workspace.package] version` |
+| `Cargo.lock` | Regenerated via `cargo update --workspace` |
 | `CITATION.cff` | `version` key |
 | `CMakeLists.txt` | `project(... VERSION X.Y.Z ...)` |
 
-> Requires `pixi` CLI if `pixi.lock` exists in the project root.
+> Requires `pixi` CLI if `pixi.lock` exists in the project root, and `cargo`
+> if `Cargo.lock` does.
 
 ## Testing
 

{jrl_cmakemodules_scripts-2.3.0 → jrl_cmakemodules_scripts-2.4.0}/README.md

@@ -61,12 +61,15 @@ jrl-release --bump patch --git-commit --git-tag
 | `package.xml` | `<version>` tag |
 | `pyproject.toml` | `project.version` |
 | `CHANGELOG.md` | First `## [X.Y.Z]` section (not Unreleased) |
-| `pixi.toml` | `[workspace] version` |
+| `pixi.toml` | `[workspace] version` and `[package] version` (pixi-build) |
 | `pixi.lock` | Regenerated via `pixi list` |
+| `Cargo.toml` | `[package] version` and `[workspace.package] version` |
+| `Cargo.lock` | Regenerated via `cargo update --workspace` |
 | `CITATION.cff` | `version` key |
 | `CMakeLists.txt` | `project(... VERSION X.Y.Z ...)` |
 
-> Requires `pixi` CLI if `pixi.lock` exists in the project root.
+> Requires `pixi` CLI if `pixi.lock` exists in the project root, and `cargo`
+> if `Cargo.lock` does.
 
 ## Testing
 

{jrl_cmakemodules_scripts-2.3.0 → jrl_cmakemodules_scripts-2.4.0}/jrl_cmakemodules_scripts.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jrl-cmakemodules-scripts
-Version: 2.3.0
+Version: 2.4.0
 Summary: Release scripting tools for JRL CMake modules
 License: BSD-3-Clause
 Project-URL: homepage, https://github.com/jrl-umi3218/jrl-cmakemodules
@@ -79,12 +79,15 @@ jrl-release --bump patch --git-commit --git-tag
 | `package.xml` | `<version>` tag |
 | `pyproject.toml` | `project.version` |
 | `CHANGELOG.md` | First `## [X.Y.Z]` section (not Unreleased) |
-| `pixi.toml` | `[workspace] version` |
+| `pixi.toml` | `[workspace] version` and `[package] version` (pixi-build) |
 | `pixi.lock` | Regenerated via `pixi list` |
+| `Cargo.toml` | `[package] version` and `[workspace.package] version` |
+| `Cargo.lock` | Regenerated via `cargo update --workspace` |
 | `CITATION.cff` | `version` key |
 | `CMakeLists.txt` | `project(... VERSION X.Y.Z ...)` |
 
-> Requires `pixi` CLI if `pixi.lock` exists in the project root.
+> Requires `pixi` CLI if `pixi.lock` exists in the project root, and `cargo`
+> if `Cargo.lock` does.
 
 ## Testing
 

{jrl_cmakemodules_scripts-2.3.0 → jrl_cmakemodules_scripts-2.4.0}/jrl_release.py

@@ -71,21 +71,24 @@ uv run --no-project jrl_release.py --bump patch --git-commit --git-tag
 | `package.xml` | `<version> and <url>` tag |
 | `pyproject.toml` | `project.version` and `project.urls` |
 | `CHANGELOG.md` | First `## [X.Y.Z]` section (not Unreleased) |
-| `pixi.toml` | `[workspace] version` |
+| `pixi.toml` | `[workspace] version` and `[package] version` (pixi-build) |
 | `pixi.lock` | Regenerated via `pixi list` |
+| `Cargo.toml` | `[package] version` and `[workspace.package] version` |
+| `Cargo.lock` | Regenerated via `cargo update --workspace` |
 | `CITATION.cff` | `version` key |
 | `CMakeLists.txt` | `project(... VERSION X.Y.Z ... HOMEPAGE_URL ...)` |
 | `debian/changelog` | `version = ...` |
 | `conanfile.py` | `version = ...` |
 
-> Requires `pixi` CLI if `pixi.lock` exists in the project root.
+> Requires `pixi` CLI if `pixi.lock` exists in the project root, and `cargo`
+> if `Cargo.lock` does.
 
 ## Meta-packages
 
 ROS meta-packages are handled automatically: every nested directory with a
 `package.xml` is treated like the repository root — the full set of
 supported files (`package.xml`, `pyproject.toml`, `CHANGELOG.md`, `pixi.toml`,
-`CITATION.cff`, `CMakeLists.txt`, `debian/changelog`) is checked there too,
+`Cargo.toml`, `CITATION.cff`, `CMakeLists.txt`, `debian/changelog`) is checked there too,
 skipping any that don't exist in that nested directory.
 Discovery skips hidden directories (`.git`, `.pixi`, `.venv`, …), git submodules,
 and — honoring your `.gitignore` via `git check-ignore` — ignored dirs like
@@ -103,6 +106,7 @@ import json
 import subprocess
 import shutil
 import tempfile
+from collections import Counter
 from pathlib import Path
 from abc import ABC, abstractmethod
 from typing import List, Optional, Tuple, Dict
@@ -168,6 +172,11 @@ class VersionExtractor(ABC):
     def check_file_exists(self) -> bool:
         return self.file_path.exists()
 
+    @property
+    def id(self) -> tuple:
+        """Unique identity of the tracked version field."""
+        return (self.file_path,)
+
     @property
     def name(self) -> str:
         return self.file_path.name
@@ -229,6 +238,11 @@ class TomlVersionExtractor(VersionExtractor):
         super().__init__(file_path)
         self.keys = keys
 
+    @property
+    def id(self) -> tuple:
+        # Several keys can be tracked in the same file (e.g. pixi.toml, Cargo.toml).
+        return (self.file_path, tuple(self.keys))
+
     def get_version(self) -> str:
         with open(self.file_path, "r", encoding="utf-8") as f:
             data = tomlkit.load(f)
@@ -242,6 +256,13 @@ class TomlVersionExtractor(VersionExtractor):
                     f"Key '{'.'.join(self.keys)}' not found in {self.name}"
                 )
 
+        # e.g. pixi-build `[package] version = { workspace = true }`,
+        # or Cargo `version.workspace = true`
+        if isinstance(value, dict):
+            raise VersionNotPresent(
+                f"Key '{'.'.join(self.keys)}' in {self.name} is not a version string"
+            )
+
         return str(value)
 
     def update_version(self, new_version: str) -> None:
@@ -782,6 +803,11 @@ def build_root_checks(root_dir: Path) -> List[VersionExtractor]:
         TomlVersionExtractor(root_dir / "pyproject.toml", ["project", "version"]),
         ChangelogVersionExtractor(root_dir / "CHANGELOG.md", r""),
         TomlVersionExtractor(root_dir / "pixi.toml", ["workspace", "version"]),
+        TomlVersionExtractor(root_dir / "pixi.toml", ["package", "version"]),
+        TomlVersionExtractor(root_dir / "Cargo.toml", ["package", "version"]),
+        TomlVersionExtractor(
+            root_dir / "Cargo.toml", ["workspace", "package", "version"]
+        ),
         YamlVersionExtractor(root_dir / "CITATION.cff", ["version"]),
         CMakeListsVersionExtractor(root_dir / "CMakeLists.txt"),
         DebianChangelogVersionExtractor(root_dir / "debian/changelog"),
@@ -797,21 +823,26 @@ def collect_version_checks(root_dir: Path) -> List[VersionExtractor]:
     package directory are simply skipped (VersionExtractor.check_file_exists()).
     """
     checks = list(build_root_checks(root_dir))
-    seen_paths = {check.file_path for check in checks}
+    seen_ids = {check.id for check in checks}
 
     for package_root in discover_package_roots(root_dir):
         for check in build_root_checks(package_root):
-            if check.file_path in seen_paths:
+            if check.id in seen_ids:
                 continue
             checks.append(check)
-            seen_paths.add(check.file_path)
+            seen_ids.add(check.id)
 
     # Label nested files by their relative path so identical basenames stay distinct.
+    checks_per_file = Counter(check.file_path for check in checks)
     for check in checks:
         try:
             check.label = str(check.file_path.relative_to(root_dir))
         except ValueError:
             check.label = check.file_path.name
+        # A file tracking several version fields (e.g. pixi.toml, Cargo.toml)
+        # gets its table appended so each field stays distinct.
+        if checks_per_file[check.file_path] > 1:
+            check.label += f" [{'.'.join(check.keys[:-1])}]"
 
     return checks
 
@@ -1242,63 +1273,113 @@ def gh_release(
         return False, e.stderr or ""
 
 
-def update_pixi_lock(root_dir: Path, dry_run: bool = False) -> Optional[str]:
-    """Update pixi.lock file by running 'pixi list'.
+def update_lock_file(
+    root_dir: Path,
+    lock_name: str,
+    command: List[str],
+    install_url: str,
+    dry_run: bool = False,
+    backups: Optional[Dict[Path, Path]] = None,
+) -> Optional[str]:
+    """Regenerate a lock file by running `command` in root_dir.
 
-    Returns the path to pixi.lock if updated, None otherwise.
+    The lock file is added to `backups` before being rewritten, so a later
+    failure restores it. Returns the path to the lock file if it exists (and
+    so is, or in dry run would be, regenerated), None otherwise.
     """
-    pixi_lock_path = root_dir / "pixi.lock"
+    lock_path = root_dir / lock_name
+    tool = command[0]
+    cmd_str = " ".join(command)
 
-    if not pixi_lock_path.exists():
+    if not lock_path.exists():
         return None
 
     if dry_run:
-        return None
+        return str(lock_path)
+
+    if backups is not None:
+        backup_file(backups, lock_path)
 
     console.print(
-        f"[{STYLE_INFO}]Running 'pixi list' to update pixi.lock...[/{STYLE_INFO}]"
+        f"[{STYLE_INFO}]Running '{cmd_str}' to update {lock_name}...[/{STYLE_INFO}]"
     )
     try:
         result = subprocess.run(
-            ["pixi", "list"],
+            command,
             cwd=root_dir,
             timeout=60,
         )
 
         if result.returncode != 0:
             console.print(
-                f"[{STYLE_ERROR}]Error: 'pixi list' returned non-zero exit code: {result.returncode}[/{STYLE_ERROR}]"
+                f"[{STYLE_ERROR}]Error: '{cmd_str}' returned non-zero exit code: {result.returncode}[/{STYLE_ERROR}]"
             )
             console.print(
-                f"[{STYLE_ERROR}]Failed to update pixi.lock. Please ensure 'pixi' is installed.[/{STYLE_ERROR}]"
+                f"[{STYLE_ERROR}]Failed to update {lock_name}. Please ensure '{tool}' is installed.[/{STYLE_ERROR}]"
             )
-            raise RuntimeError(f"'pixi list' failed with exit code {result.returncode}")
+            raise RuntimeError(f"'{cmd_str}' failed with exit code {result.returncode}")
 
     except subprocess.TimeoutExpired:
         console.print(
-            f"[{STYLE_ERROR}]Error: 'pixi list' command timed out[/{STYLE_ERROR}]"
+            f"[{STYLE_ERROR}]Error: '{cmd_str}' command timed out[/{STYLE_ERROR}]"
         )
-        raise RuntimeError("'pixi list' command timed out after 30 seconds")
+        raise RuntimeError(f"'{cmd_str}' command timed out after 60 seconds")
     except FileNotFoundError:
-        console.print(f"[{STYLE_ERROR}]Error: 'pixi' command not found[/{STYLE_ERROR}]")
         console.print(
-            f"[{STYLE_ERROR}]pixi.lock exists but 'pixi' executable is not available.[/{STYLE_ERROR}]"
+            f"[{STYLE_ERROR}]Error: '{tool}' command not found[/{STYLE_ERROR}]"
         )
         console.print(
-            f"[{STYLE_INFO}]Please install pixi: https://pixi.sh[/{STYLE_INFO}]"
+            f"[{STYLE_ERROR}]{lock_name} exists but '{tool}' executable is not available.[/{STYLE_ERROR}]"
         )
-        raise RuntimeError("'pixi' executable not found. Install from https://pixi.sh")
+        console.print(
+            f"[{STYLE_INFO}]Please install {tool}: {install_url}[/{STYLE_INFO}]"
+        )
+        raise RuntimeError(f"'{tool}' executable not found. Install from {install_url}")
     except Exception as e:
         console.print(
-            f"[{STYLE_ERROR}]Error: Failed to run 'pixi list': {e}[/{STYLE_ERROR}]"
+            f"[{STYLE_ERROR}]Error: Failed to run '{cmd_str}': {e}[/{STYLE_ERROR}]"
         )
-        raise RuntimeError(f"Failed to run 'pixi list': {e}") from e
+        raise RuntimeError(f"Failed to run '{cmd_str}': {e}") from e
 
     console.print(
-        f"[{STYLE_SUCCESS}]✓ Updated pixi.lock via 'pixi list'[/{STYLE_SUCCESS}]"
+        f"[{STYLE_SUCCESS}]✓ Updated {lock_name} via '{cmd_str}'[/{STYLE_SUCCESS}]"
     )
 
-    return str(pixi_lock_path)
+    return str(lock_path)
+
+
+def update_pixi_lock(
+    root_dir: Path,
+    dry_run: bool = False,
+    backups: Optional[Dict[Path, Path]] = None,
+) -> Optional[str]:
+    """Update pixi.lock file by running 'pixi list'.
+
+    Returns the path to pixi.lock if it exists, None otherwise.
+    """
+    return update_lock_file(
+        root_dir, "pixi.lock", ["pixi", "list"], "https://pixi.sh", dry_run, backups
+    )
+
+
+def update_cargo_lock(
+    root_dir: Path,
+    dry_run: bool = False,
+    backups: Optional[Dict[Path, Path]] = None,
+) -> Optional[str]:
+    """Update Cargo.lock file by running 'cargo update --workspace'.
+
+    Only the workspace crates' own versions are refreshed, not dependencies.
+    Returns the path to Cargo.lock if it exists, None otherwise.
+    """
+    return update_lock_file(
+        root_dir,
+        "Cargo.lock",
+        ["cargo", "update", "--workspace"],
+        "https://rustup.rs",
+        dry_run,
+        backups,
+    )
 
 
 def create_backups(file_paths: List[Path]) -> Dict[Path, Path]:
@@ -1306,17 +1387,27 @@ def create_backups(file_paths: List[Path]) -> Dict[Path, Path]:
 
     Returns a mapping of original paths to backup paths.
     """
-    backups = {}
-    temp_dir = Path(tempfile.mkdtemp(prefix="release_backup_"))
+    backups: Dict[Path, Path] = {}
+    for file_path in file_paths:
+        backup_file(backups, file_path)
+    return backups
 
-    # Index-prefix the name so files sharing a basename don't collide.
-    for index, file_path in enumerate(file_paths):
-        if file_path.exists():
-            backup_path = temp_dir / f"{index:04d}_{file_path.name}"
-            shutil.copy2(file_path, backup_path)
-            backups[file_path] = backup_path
 
-    return backups
+def backup_file(backups: Dict[Path, Path], file_path: Path) -> None:
+    """Add a backup copy of file_path to backups (no-op if missing or already there)."""
+    # Deduplicate: a file may carry several tracked version fields.
+    if file_path in backups or not file_path.exists():
+        return
+
+    if backups:
+        temp_dir = next(iter(backups.values())).parent
+    else:
+        temp_dir = Path(tempfile.mkdtemp(prefix="release_backup_"))
+
+    # Index-prefix the name so files sharing a basename don't collide.
+    backup_path = temp_dir / f"{len(backups):04d}_{file_path.name}"
+    shutil.copy2(file_path, backup_path)
+    backups[file_path] = backup_path
 
 
 def restore_backups(backups: Dict[Path, Path]) -> None:
@@ -1548,13 +1639,14 @@ def perform_version_updates(
                     check.update_version(target_version)
                     dry_run_rows.append((check.label, old_version, target_version))
                     line = Text()
-                    line.append(f"  {check.label:<28}", style="cyan")
+                    line.append(f"  {check.label:<28} ", style="cyan")
                     line.append(old_version, style=STYLE_OLD_VALUE)
                     line.append("  →  ", style="dim")
                     line.append(target_version, style=STYLE_NEW_VALUE)
                     console.print(line)
                 updated_files.append(check.label)
-                updated_file_paths.append(str(check.file_path))
+                if str(check.file_path) not in updated_file_paths:
+                    updated_file_paths.append(str(check.file_path))
             except VersionNotPresent:
                 pass  # file exists but has no version configured; skip
             except Exception as e:
@@ -1567,9 +1659,17 @@ def perform_version_updates(
     return updated_files, updated_file_paths, failed, dry_run_rows
 
 
+def print_lock_rows(lock_paths: List[str]) -> None:
+    for lock_path in lock_paths:
+        line = Text()
+        line.append(f"  {Path(lock_path).name:<28}", style="cyan")
+        line.append("regenerated", style="dim")
+        console.print(line)
+
+
 def show_dry_run_panel(
     dry_run_rows: List[Tuple[str, str, str]],
-    pixi_lock_would_update: bool,
+    lock_paths: List[str],
     git_lines: List[str],
 ) -> None:
     """Display a unified dry-run preview."""
@@ -1587,11 +1687,7 @@ def show_dry_run_panel(
         line.append("  →  ", style="dim")
         line.append(new, style=STYLE_NEW_VALUE)
         console.print(line)
-    if pixi_lock_would_update:
-        line = Text()
-        line.append(f"  {'pixi.lock':<28}", style="cyan")
-        line.append("regenerated via pixi list", style="dim")
-        console.print(line)
+    print_lock_rows(lock_paths)
 
     if git_lines:
         console.print()
@@ -1603,14 +1699,10 @@ def show_dry_run_panel(
 
 
 def show_result_panel(
-    pixi_lock_updated: bool,
+    lock_paths: List[str],
 ) -> None:
     """Display a polished summary of completed version updates."""
-    if pixi_lock_updated:
-        line = Text()
-        line.append(f"  {'pixi.lock':<28}", style="cyan")
-        line.append("regenerated via pixi list", style="dim")
-        console.print(line)
+    print_lock_rows(lock_paths)
     console.print()
     console.print(
         f"[{STYLE_SUCCESS_STRONG}]✓ Version updated successfully[/{STYLE_SUCCESS_STRONG}]"
@@ -1899,13 +1991,17 @@ def main():
             sys.exit(1)
 
         try:
-            pixi_lock_path = update_pixi_lock(root_dir, args.dry_run)
-            if pixi_lock_path:
-                updated_files.append("pixi.lock")
-                updated_file_paths.append(pixi_lock_path)
+            lock_paths: List[str] = []
+            if lock_path := update_pixi_lock(root_dir, args.dry_run, backups):
+                lock_paths.append(lock_path)
+            if lock_path := update_cargo_lock(root_dir, args.dry_run, backups):
+                lock_paths.append(lock_path)
+            for lock_path in lock_paths:
+                updated_files.append(Path(lock_path).name)
+                updated_file_paths.append(lock_path)
         except RuntimeError as e:
             console.print(
-                f"[{STYLE_ERROR}]Pixi lock update failed: {e}[/{STYLE_ERROR}]"
+                f"[{STYLE_ERROR}]Lock file update failed: {e}[/{STYLE_ERROR}]"
             )
             if backups:
                 console.print(
@@ -1960,8 +2056,6 @@ def main():
             archive_name = f"{project_url.split('/')[-1]}-{target_version}.tar.gz"
 
     if args.dry_run:
-        pixi_lock_would_update = (root_dir / "pixi.lock").exists()
-
         git_lines: List[str] = []
         if args.git_commit is not None:
             custom_message = None if args.git_commit is True else args.git_commit
@@ -2017,11 +2111,11 @@ def main():
             )
             git_lines.append(call)
 
-        show_dry_run_panel(dry_run_rows, pixi_lock_would_update, git_lines)
+        show_dry_run_panel(dry_run_rows, lock_paths, git_lines)
         sys.exit(0)
     else:
         if not args.short and args.output_format == "text":
-            show_result_panel(pixi_lock_path is not None)
+            show_result_panel(lock_paths)
 
         # Git operations - only perform if explicitly requested
         if args.git_tag is not None and args.git_commit is None:

{jrl_cmakemodules_scripts-2.3.0 → jrl_cmakemodules_scripts-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jrl-cmakemodules-scripts"
-version = "2.3.0"
+version = "2.4.0"
 description = "Release scripting tools for JRL CMake modules"
 readme = "README.md"
 requires-python = ">=3.10"