py-wlcli 0.8.0__py3-none-any.whl

wl_cli/utils/version/version_updater.py

@@ -0,0 +1,198 @@
+"""
+Version updating utilities for publish command.
+"""
+
+import re
+from pathlib import Path
+
+from ...exceptions import CommandError
+from ..logging import log_info, log_info_pair
+
+
+class VersionUpdater:
+    """Update versions in project files."""
+
+    def __init__(self, project_root: Path | None = None):
+        """Initialize VersionUpdater with optional project root."""
+        self.project_root = project_root or self._resolve_project_root()
+
+    @staticmethod
+    def _resolve_project_root() -> Path:
+        current_path = Path.cwd().resolve()
+        for path in (current_path, *current_path.parents):
+            if (path / "pyproject.toml").is_file() or (path / "VERSION").is_file():
+                return path
+
+        package_path = Path(__file__).resolve()
+        for path in package_path.parents:
+            if (path / "pyproject.toml").is_file() or (path / "VERSION").is_file():
+                return path
+
+        return current_path
+
+    @staticmethod
+    def _safe_replace(content, pattern, new_version):
+        """Safely replace version in content without interpreting numbers as group references."""
+
+        def replace_match(match):
+            return f"{match.group(1)}{new_version}{match.group(3)}"
+
+        return re.sub(pattern, replace_match, content)
+
+    def _update_version_file(self, new_version: str) -> None:
+        """Update the VERSION file with a specific version."""
+        version_file = self.project_root / "VERSION"
+        try:
+            version_file.write_text(f"{new_version}\n", encoding="utf-8")
+            log_info(f"Updated VERSION file to {new_version}")
+        except Exception as e:
+            raise CommandError(f"Failed to update VERSION file: {e}")
+
+    def _update_python_version(self, new_version: str) -> None:
+        """Update the Python __init__.py file with a specific version."""
+        python_version_file = self.project_root / "src" / "wl_cli" / "__init__.py"
+        if python_version_file.exists():
+            try:
+                content = python_version_file.read_text(encoding="utf-8")
+                # Check if the file uses the new VERSION file pattern (which it should)
+                # We don't need to modify it since it reads from VERSION file
+                # But we'll maintain backward compatibility for old format
+                if "__version__ = " in content:
+                    if "_read_version_from_file" not in content:
+                        # Old format: directly replace the version string
+                        version_pattern = (
+                            r'(__version__\s*=\s*["\'])(\d+\.\d+\.\d+(?:\.\d+)?)(["\'])'
+                        )
+                        if re.search(version_pattern, content):
+                            updated_content = self._safe_replace(
+                                content, version_pattern, new_version
+                            )
+                            python_version_file.write_text(
+                                updated_content, encoding="utf-8"
+                            )
+                            log_info(f"Updated Python version to {new_version}")
+                        # else: no valid version pattern found, do nothing silently
+                    else:
+                        # New format: no need to modify, reads from VERSION file
+                        log_info(
+                            "Python __init__.py uses VERSION file, skipping update"
+                        )
+                # else: no __version__ line found, do nothing silently
+            except Exception as e:
+                raise CommandError(f"Failed to update Python version: {e}")
+
+    @staticmethod
+    def _to_rust_version(version: str) -> str:
+        """Convert a version string to Rust-compatible 3-part semver.
+
+        Rust/Cargo only supports MAJOR.MINOR.PATCH (3-part) semver.
+        If the input has 4 parts (e.g. 0.6.0.1), only the first 3 are used.
+        """
+        parts = version.split(".")
+        return ".".join(parts[:3])
+
+    def _update_rust_version(self, new_version: str) -> None:
+        """Update the Rust Cargo.toml file with a specific version.
+
+        Cargo.toml only supports 3-part semver (MAJOR.MINOR.PATCH),
+        so if new_version has 4 parts, only the first 3 are written.
+        """
+        rust_version = self._to_rust_version(new_version)
+        rust_version_file = self.project_root / "rust" / "Cargo.toml"
+        if rust_version_file.exists():
+            try:
+                content = rust_version_file.read_text(encoding="utf-8")
+                # Find version pattern in [package] section and replace with Rust-compatible version
+                package_section_pattern = r'(\[package\][^\[]*version\s*=\s*["\'])(\d+\.\d+\.\d+(?:\.\d+)?)(["\'])'
+                updated_content = re.sub(
+                    package_section_pattern,
+                    lambda m: f"{m.group(1)}{rust_version}{m.group(3)}",
+                    content,
+                    flags=re.DOTALL,
+                )
+                rust_version_file.write_text(updated_content, encoding="utf-8")
+                log_info(f"Updated Rust version to {rust_version}")
+                if rust_version != new_version:
+                    log_info(
+                        f"  (truncated from {new_version} for Cargo semver compatibility)"
+                    )
+            except Exception as e:
+                raise CommandError(f"Failed to update Rust version: {e}")
+
+    def increment_version(
+        self, detector, comparator, pypi_checker=None, dry_run: bool = False
+    ) -> None:
+        """Increment the version to be greater than both local and PyPI versions.
+
+        Args:
+            detector: Version detector to get current version.
+            comparator: Version comparator to compare and increment versions.
+            pypi_checker: PyPI version checker (optional).
+            dry_run: Whether to perform a dry run without modifying files.
+        """
+        log_info_pair(
+            "Checking versions and incrementing as needed...",
+            "正在检查版本并根据需要递增...",
+        )
+
+        # Get current PyPI version
+        pypi_version = None
+        if pypi_checker:
+            try:
+                pypi_version = pypi_checker._get_pypi_version()
+            except Exception:
+                # If getting PyPI version fails, use current version as base
+                pass
+        else:
+            # Backward compatibility: try to get PyPI version from detector
+            try:
+                if hasattr(detector, "_get_pypi_version"):
+                    pypi_version = detector._get_pypi_version()
+            except Exception:
+                pass
+        if pypi_version:
+            log_info_pair(
+                f"Latest version on PyPI: {pypi_version}",
+                f"PyPI 上的最新版本: {pypi_version}",
+            )
+
+        # Get current local version
+        current_version = detector.get_current_version(comparator)
+        log_info_pair(
+            f"Current local version: {current_version}",
+            f"当前本地版本: {current_version}",
+        )
+
+        # Determine which version to use as base for incrementing
+        if pypi_version:
+            # Compare versions and use the greater one as base
+            greater_version = comparator.get_greater_version(
+                pypi_version, current_version
+            )
+            log_info_pair(
+                f"Greater version between local and PyPI: {greater_version}",
+                f"本地和 PyPI 之间较大的版本: {greater_version}",
+            )
+
+            # Always increment the version regardless of whether they are equal or not
+            new_version = comparator.increment_version_from_base(greater_version)
+        else:
+            # If we can't get PyPI version, increment local version
+            new_version = comparator.increment_version_from_base(current_version)
+
+        log_info_pair(
+            f"New version to be set: {new_version}",
+            f"将要设置的新版本: {new_version}",
+        )
+
+        if dry_run:
+            log_info_pair(
+                "Dry run mode: Would update version files",
+                "Dry run mode: 将更新版本文件",
+            )
+        else:
+            # Update VERSION file first (highest priority)
+            self._update_version_file(new_version)
+            # Then update Python and Rust versions
+            self._update_python_version(new_version)
+            self._update_rust_version(new_version)