half-orm-dev 0.17.2a4__tar.gz → 0.17.2a6__tar.gz

{half_orm_dev-0.17.2a4/half_orm_dev.egg-info → half_orm_dev-0.17.2a6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.2a4
+Version: 0.17.2a6
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later

{half_orm_dev-0.17.2a4 → half_orm_dev-0.17.2a6}/half_orm_dev/cli/commands/__init__.py

@@ -13,6 +13,7 @@ from .release import release
 from .update import update
 from .upgrade import upgrade
 from .check import check
+from .migrate import migrate
 from .todo import apply_release
 from .todo import rollback
 
@@ -30,6 +31,7 @@ ALL_COMMANDS = {
     'update': update,          # Adapted for production
     'upgrade': upgrade,          # Adapted for production
     'check': check,            # Project health check and updates
+    'migrate': migrate,        # Repository migration after upgrade
     # 🚧 (stubs)
     'apply_release': apply_release,
 
@@ -49,6 +51,7 @@ __all__ = [
     'release',
     'upgrade',
     'check',
+    'migrate',
     'rollback',
     # Adapted commands
     'sync_package',

half_orm_dev-0.17.2a6/half_orm_dev/cli/commands/migrate.py

@@ -0,0 +1,125 @@
+"""
+Migrate command - Apply repository migrations after half_orm_dev upgrade.
+
+This command runs pending migrations when the installed half_orm_dev version
+is newer than the repository's hop_version in .hop/config.
+"""
+
+import click
+from half_orm_dev.repo import Repo, RepoError
+from half_orm import utils
+
+
+@click.command()
+@click.option(
+    '--verbose', '-v',
+    is_flag=True,
+    help='Show detailed migration information'
+)
+def migrate(verbose: bool) -> None:
+    """
+    Apply repository migrations after half_orm_dev upgrade.
+
+    This command updates the repository structure and configuration files
+    when you upgrade to a newer version of half_orm_dev.
+
+    Requirements:
+      • Must be on ho-prod branch
+      • Repository must be clean (no uncommitted changes)
+
+    Process:
+      1. Detects version mismatch between installed half_orm_dev and repository
+      2. Applies any migration scripts for intermediate versions
+      3. Updates hop_version in .hop/config
+      4. Creates migration commit on ho-prod
+      5. Syncs .hop/ directory to all active branches
+
+    Examples:
+        # After upgrading half_orm_dev
+        $ pip install --upgrade half_orm_dev
+        $ half_orm dev migrate
+        ⚠️  Migration needed: half_orm_dev 0.17.2 → 0.18.0
+          Current branch: ho-prod
+
+          Running migrations...
+          ✓ Applied migration: 0.17.2 → 0.18.0
+          ✓ Updated .hop/config: hop_version = 0.18.0
+          ✓ Synced .hop/ to active branches
+
+        # View detailed migration info
+        $ half_orm dev migrate --verbose
+    """
+    try:
+        repo = Repo()
+
+        # Check if we're in a repository
+        if not repo.checked:
+            click.echo(utils.Color.red("❌ Not in a hop repository"), err=True)
+            raise click.Abort()
+
+        # Get current versions
+        from half_orm_dev.utils import hop_version
+        installed_version = hop_version()
+        config_version = repo._Repo__config.hop_version if hasattr(repo, '_Repo__config') else '0.0.0'
+
+        # Check if migration is needed
+        comparison = repo.compare_versions(installed_version, config_version)
+
+        if comparison == 0:
+            # Versions are equal - no migration needed
+            click.echo(f"✓ {utils.Color.green('Repository is up to date')}")
+            click.echo(f"  Repository version: {config_version}")
+            click.echo(f"  Installed version:  {installed_version}")
+            return
+
+        elif comparison < 0:
+            # Installed version is OLDER than repository version
+            click.echo(f"⚠️  {utils.Color.red('Installed half_orm_dev is older than repository version')}", err=True)
+            click.echo(f"\n  Repository version: {config_version}", err=True)
+            click.echo(f"  Installed version:  {installed_version}", err=True)
+            click.echo(f"\n  Please upgrade half_orm_dev:", err=True)
+            click.echo(f"    pip install --upgrade half_orm_dev\n", err=True)
+            raise click.Abort()
+
+        # Migration needed (comparison > 0)
+        click.echo(f"⚠️  {utils.Color.bold('Migration needed:')}")
+        click.echo(f"  half_orm_dev {config_version} → {installed_version}")
+
+        # Check current branch
+        current_branch = repo.hgit.branch if repo.hgit else 'unknown'
+        click.echo(f"  Current branch: {current_branch}")
+        click.echo()
+
+        # Run migrations
+        click.echo(f"  Running migrations...")
+
+        try:
+            result = repo.run_migrations_if_needed(silent=False)
+
+            if result['migration_run']:
+                click.echo(f"\n✓ {utils.Color.green('Migration completed successfully')}")
+                click.echo(f"  Updated .hop/config: hop_version = {installed_version}")
+
+                if verbose and result.get('errors'):
+                    click.echo(f"\n⚠️  Warnings during migration:")
+                    for error in result['errors']:
+                        click.echo(f"  • {error}")
+
+                click.echo(f"\n✓ Synced .hop/ to active branches")
+            else:
+                click.echo(f"✓ {utils.Color.green('Repository is up to date')}")
+
+        except RepoError as e:
+            # Migration failed or branch check failed
+            click.echo(utils.Color.red(f"\n❌ {e}"), err=True)
+            raise click.Abort()
+
+    except RepoError as e:
+        click.echo(utils.Color.red(f"❌ Error: {e}"), err=True)
+        raise click.Abort()
+    except Exception as e:
+        click.echo(utils.Color.red(f"❌ Unexpected error: {e}"), err=True)
+        if verbose:
+            import traceback
+            traceback.print_exc()
+        raise click.Abort()

{half_orm_dev-0.17.2a4 → half_orm_dev-0.17.2a6}/half_orm_dev/cli/main.py

@@ -28,6 +28,9 @@ class Hop:
             # Outside hop repository - commands for project initialization
             return ['init', 'clone']
 
+        if self.__repo.needs_migration():
+            return ['migrate']
+
         # Inside hop repository
         if not self.__repo.devel:
             # Sync-only mode (no metadata)
@@ -73,21 +76,41 @@ def create_cli_group():
         if ctx.invoked_subcommand is None:
             # Show repo state when no subcommand is provided
             if hop.repo_checked:
-                click.echo(hop.state)
-                click.echo(f"\n{utils.Color.bold('Available commands:')}")
-
-                # Adapt displayed commands based on environment
-                if hop.__repo.database.production:
-                    # Production commands
-                    click.echo(f"  • {utils.Color.bold('update')} - Fetch and list available releases")
-                    click.echo(f"  • {utils.Color.bold('upgrade [--to-release=X.Y.Z]')} - Apply releases to production")
+                # Check if migration is needed
+                if hop._Hop__repo.needs_migration():
+                    # Display migration warning
+                    from half_orm_dev.utils import hop_version
+                    installed_version = hop_version()
+                    config_version = hop._Hop__repo._Repo__config.hop_version
+                    current_branch = hop._Hop__repo.hgit.branch if hop._Hop__repo.hgit else 'unknown'
+
+                    click.echo(f"\n{'='*70}")
+                    click.echo(f"⚠️  {utils.Color.bold(utils.Color.red('REPOSITORY MIGRATION REQUIRED'))} ⚠️")
+                    click.echo(f"{'='*70}")
+                    click.echo(f"\n  Repository version: {utils.Color.red(config_version)}")
+                    click.echo(f"  Installed version:  {utils.Color.green(installed_version)}")
+                    click.echo(f"  Current branch:     {current_branch}")
+                    click.echo(f"\n  {utils.Color.bold('All commands are blocked until migration is complete.')}")
+                    click.echo(f"\n  To apply migration, run:")
+                    click.echo(f"    {utils.Color.bold('half_orm dev migrate')}")
+                    click.echo(f"\n{'='*70}\n")
                 else:
-                    # Development commands
-                    click.echo(f"  • {utils.Color.bold('patch')}")
-                    click.echo(f"  • {utils.Color.bold('prepare-release <level>')} - Prepare next release stage file (patch/minor/major)")
-                    click.echo(f"  • {utils.Color.bold('promote-to <target>')} - Promote stage to rc or prod")
-
-                click.echo(f"\nTry {utils.Color.bold('half_orm dev <command> --help')} for more information.\n")
+                    # Normal display
+                    click.echo(hop.state)
+                    click.echo(f"\n{utils.Color.bold('Available commands:')}")
+
+                    # Adapt displayed commands based on environment
+                    if hop._Hop__repo.database.production:
+                        # Production commands
+                        click.echo(f"  • {utils.Color.bold('update')} - Fetch and list available releases")
+                        click.echo(f"  • {utils.Color.bold('upgrade [--to-release=X.Y.Z]')} - Apply releases to production")
+                    else:
+                        # Development commands
+                        click.echo(f"  • {utils.Color.bold('patch')}")
+                        click.echo(f"  • {utils.Color.bold('prepare-release <level>')} - Prepare next release stage file (patch/minor/major)")
+                        click.echo(f"  • {utils.Color.bold('promote-to <target>')} - Promote stage to rc or prod")
+
+                    click.echo(f"\nTry {utils.Color.bold('half_orm dev <command> --help')} for more information.\n")
             else:
                 click.echo(hop.state)
                 click.echo("\nNot in a hop repository.")

{half_orm_dev-0.17.2a4 → half_orm_dev-0.17.2a6}/half_orm_dev/migration_manager.py

@@ -25,6 +25,7 @@ import re
 import subprocess
 import sys
 import importlib.util
+from packaging import version
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple
 from half_orm import utils
@@ -58,38 +59,6 @@ class MigrationManager:
         # Path to migrations directory (in half_orm_dev package)
         self._migrations_root = Path(__file__).parent / 'migrations'
 
-    def _parse_version(self, version_str: str) -> Tuple[int, int, int]:
-        """
-        Parse version string to tuple.
-
-        Supports version formats:
-        - "0.17.1"
-        - "0.1.0a1" (ignores suffix)
-        - "0.17.1-a1" (ignores suffix)
-        - "0.17.1-rc2" (ignores suffix)
-
-        Args:
-            version_str: Version string like "0.17.1" or "0.17.1-a1"
-
-        Returns:
-            Tuple of (major, minor, patch)
-        """
-        # Strip any pre-release suffix (e.g., "-a1", "-rc2")
-        base_version = version_str.split('-')[0]
-        if not re.match(r"^\d+\.\d+\.\d+$", base_version):
-            match = re.match(r"^(\d+\.\d+\.\d+)", base_version)
-            if match:
-                base_version = match.group(1)
-
-        parts = base_version.split('.')
-        if len(parts) != 3:
-            raise MigrationManagerError(f"Invalid version format: {version_str}")
-
-        try:
-            return (int(parts[0]), int(parts[1]), int(parts[2]))
-        except ValueError as e:
-            raise MigrationManagerError(f"Invalid version format: {version_str}") from e
-
     def _version_to_path(self, version: Tuple[int, int, int]) -> Path:
         """
         Convert version tuple to migration directory path.
@@ -117,8 +86,8 @@ class MigrationManager:
         Returns:
             List of (version_str, migration_dir_path) tuples in order
         """
-        current = self._parse_version(current_version)
-        target = self._parse_version(target_version)
+        current = version.parse(current_version).release
+        target = version.parse(target_version).release
 
         pending = []
 
@@ -298,8 +267,19 @@ class MigrationManager:
         ) else "0.0.0"
 
         # If already at target version, nothing to do
-        if current_version == target_version:
-            return result
+        try:
+            comparison = self._repo.compare_versions(current_version, target_version)
+
+            if comparison >= 0:
+                # Already at or past target version (0 = equal, 1 = higher)
+                return result
+        except Exception as e:
+            # If version comparison fails (invalid format), log and continue
+            # This allows migration to proceed even if version format is unexpected
+            result['errors'].append(
+                f"Could not compare versions {current_version} and {target_version}: {e}. "
+                f"Continuing with migration attempt."
+            )
 
         # Get pending migrations
         pending = self.get_pending_migrations(current_version, target_version)
@@ -392,21 +372,39 @@ class MigrationManager:
         Check if migration is needed.
 
         Compares current tool version with hop_version in .hop/config.
+        Properly handles pre-release versions (alpha, beta, rc).
 
         Args:
-            current_tool_version: Current half_orm_dev version
+            current_tool_version: Current half_orm_dev version (e.g., "0.17.2-a5")
 
         Returns:
-            True if migration is needed
+            True if migration/update is needed
         """
         if not hasattr(self._repo, '_Repo__config'):
             return False
 
         config_version = self._repo._Repo__config.hop_version
 
-        # Parse versions
-        current = self._parse_version(current_tool_version)
-        config = self._parse_version(config_version)
+        # If no hop_version is configured, no migration needed
+        if not config_version:
+            return False
 
-        # Migration needed if current version is higher
-        return current > config
+        try:
+            # Use Repo's centralized comparison method
+            # Returns: 1 if current > config, 0 if equal, -1 if current < config
+            comparison = self._repo.compare_versions(current_tool_version, config_version)
+
+            # Migration needed if current version is higher
+            # This now properly compares: 0.17.2a5 > 0.17.2a3 → returns 1 ✓
+            return comparison > 0
+
+        except Exception as e:
+            # If version parsing fails, log warning and don't block
+            import warnings
+            warnings.warn(
+                f"Could not parse versions for migration check: "
+                f"current={current_tool_version}, config={config_version}. "
+                f"Error: {e}",
+                UserWarning
+            )
+            return False

{half_orm_dev-0.17.2a4 → half_orm_dev-0.17.2a6}/half_orm_dev/repo.py

@@ -250,15 +250,16 @@ class Repo:
         This method is called when no hop config file is provided.
         Returns True if we are in a repo, False otherwise.
         """
-        base_dir = os.path.abspath(os.path.curdir)
+        base_dir = self._find_base_dir()
         while base_dir:
             if self.__set_base_dir(base_dir):
                 self.database = Database(self)
                 if self.devel:
                     self.hgit = HGit(self)
                 self.__checked = True
-                # Perform automatic migration if needed (after hgit is initialized)
-                self._run_pending_migrations()
+                # NOTE: Migration is no longer automatic - user must run `half_orm dev migrate`
+                # This prevents implicit changes and gives user control over when migration happens
+                return
             par_dir = os.path.split(base_dir)[0]
             if par_dir == base_dir:
                 break
@@ -270,64 +271,216 @@ class Repo:
             self.__base_dir = base_dir
             self.__config = Config(base_dir)
             self.__local_config = LocalConfig(base_dir)
+            self._validate_version()
             return True
         return False
 
-    def _run_pending_migrations(self):
+    def _validate_version(self):
+        """
+        Validate that installed half_orm_dev version meets repository requirement.
+
+        Raises:
+            RepoError: If installed version is lower than required hop_version
+        """
+        required_version = self.__config.hop_version
+        if not required_version:
+            # No version requirement in .hop/config, skip validation
+            return
+
+        installed_version = hop_version()
+
+        try:
+            # Use centralized comparison method
+            if self.compare_versions(installed_version, required_version) < 0:
+                raise RepoError(
+                    f"Repository requires half_orm_dev >= {required_version} "
+                    f"but {installed_version} is installed.\n"
+                    f"Please upgrade: pip install --upgrade half_orm_dev"
+                )
+        except RepoError as e:
+            # If it's a version validation error (not comparison error), re-raise it
+            if "requires half_orm_dev" in str(e):
+                raise
+            # If version parsing fails, log warning but don't block
+            warnings.warn(
+                f"Could not parse version: installed={installed_version}, "
+                f"required={required_version}. Error: {e}",
+                UserWarning
+            )
+
+    def compare_versions(self, version1: str, version2: str) -> int:
+        """
+        Compare two version strings using packaging.version.
+
+        Properly handles pre-release versions (alpha, beta, rc) according to PEP 440.
+
+        Args:
+            version1: First version string (e.g., "0.17.2-a5")
+            version2: Second version string (e.g., "0.17.2-a3")
+
+        Returns:
+            -1 if version1 < version2
+             0 if version1 == version2
+             1 if version1 > version2
+
+        Raises:
+            RepoError: If either version string is invalid
+
+        Examples:
+            >>> repo.compare_versions("0.17.2-a5", "0.17.2-a3")
+            1  # 0.17.2a5 > 0.17.2a3
+            >>> repo.compare_versions("0.17.2", "0.17.2-a5")
+            1  # 0.17.2 > 0.17.2a5 (release > pre-release)
+            >>> repo.compare_versions("0.17.1", "0.17.2")
+            -1  # 0.17.1 < 0.17.2
+            >>> repo.compare_versions("0.17.2", "0.17.2")
+            0  # Equal
+        """
+        try:
+            v1 = version.parse(version1)
+            v2 = version.parse(version2)
+
+            if v1 < v2:
+                return -1
+            elif v1 > v2:
+                return 1
+            else:
+                return 0
+
+        except version.InvalidVersion as e:
+            raise RepoError(
+                f"Invalid version format: {e}"
+            ) from e
+
+    def needs_migration(self) -> bool:
+        """
+        Check if repository needs migration.
+
+        Compares installed half_orm_dev version with repository's hop_version.
+
+        Returns:
+            True if installed version > repository version (migration needed)
+            False otherwise
+
+        Examples:
+            >>> repo.needs_migration()
+            True  # Installed 0.18.0, repo at 0.17.2
+        """
+        if not hasattr(self, '_Repo__config') or not self.__config:
+            return False
+
+        installed_version = hop_version()
+        config_version = self.__config.hop_version
+
+        if not config_version:
+            return False
+
+        try:
+            return self.compare_versions(installed_version, config_version) > 0
+        except RepoError:
+            # If version comparison fails, assume no migration needed
+            return False
+
+    def run_migrations_if_needed(self, silent: bool = False) -> dict:
         """
         Run pending migrations using MigrationManager.
 
-        Automatically detects and runs migrations based on current
-        half_orm_dev version vs hop_version in .hop/config.
+        Detects and runs migrations based on current half_orm_dev version
+        vs hop_version in .hop/config.
 
         Behavior:
-        - On ho-prod: Runs migration with lock, creates commit, notifies active branches
-        - On other branches: Warns user to merge ho-prod to get migration
+        - On ho-prod: Runs migration with lock, creates commit, syncs to active branches
+        - On other branches: Raises RepoError directing user to checkout ho-prod
+
+        Args:
+            silent: If True, suppress informational messages (only show errors)
 
-        Silent by default - only logs errors.
+        Returns:
+            dict with keys:
+                - migration_needed: bool - True if migration was needed
+                - migration_run: bool - True if migration was executed
+                - target_version: str - Target version migrated to
+                - errors: list - Any errors encountered
+
+        Raises:
+            RepoError: If not on ho-prod branch and migration is needed
+
+        Examples:
+            # Run migration (raises if not on ho-prod)
+            result = repo.run_migrations_if_needed()
+
+            # Check result
+            if result['migration_run']:
+                print(f"Migrated to {result['target_version']}")
         """
+        result = {
+            'migration_needed': False,
+            'migration_run': False,
+            'target_version': None,
+            'errors': []
+        }
+
         try:
             # Create migration manager
             migration_mgr = MigrationManager(self)
 
             # Get current half_orm_dev version
             current_version = hop_version()
+            result['target_version'] = current_version
 
             # Check if migration is needed
             if not migration_mgr.check_migration_needed(current_version):
-                return
+                return result
+
+            result['migration_needed'] = True
 
             # Only run migrations on ho-prod branch
             if not self.hgit or self.hgit.branch != 'ho-prod':
-                # Warn user to switch to ho-prod to run migration
+                # Raise error directing user to checkout ho-prod
                 current_branch = self.hgit.branch if self.hgit else 'unknown'
                 config_version = self.__config.hop_version if hasattr(self, '_Repo__config') else '0.0.0'
-                print(f"\n{utils.Color.bold('⚠️  Migration needed:')}", file=sys.stderr)
-                print(f"  half_orm_dev {config_version} → {current_version}", file=sys.stderr)
-                print(f"  Current branch: {current_branch}", file=sys.stderr)
-                print(f"\n  To apply migration, checkout to ho-prod branch and rerun:", file=sys.stderr)
-                print(f"    git checkout ho-prod", file=sys.stderr)
-                print(f"    half_orm dev check\n", file=sys.stderr)
-                return
+                raise RepoError(
+                    f"Repository migration required\n\n"
+                    f"  Repository version: {config_version}\n"
+                    f"  Installed version:  {current_version}\n"
+                    f"  Current branch:     {current_branch}\n\n"
+                    f"  Please checkout to ho-prod branch and run:\n"
+                    f"    git checkout ho-prod\n"
+                    f"    half_orm dev migrate\n"
+                )
 
             # Run migrations on ho-prod
             # Branch sync is handled automatically by the decorator
-            result = migration_mgr.run_migrations(
+            migration_result = migration_mgr.run_migrations(
                 target_version=current_version,
                 create_commit=True
             )
 
-            # Log errors if any
-            if result.get('errors'):
-                for error in result['errors']:
-                    print(f"Migration error: {error}", file=sys.stderr)
+            result['migration_run'] = True
+            result['errors'] = migration_result.get('errors', [])
+
+            # Log success if not silent
+            if not silent:
+                if migration_result.get('migrations_applied'):
+                    print(f"✓ Applied {len(migration_result['migrations_applied'])} migration(s)")
+                else:
+                    print(f"✓ Updated repository version to {current_version}")
 
+        except RepoError:
+            # Re-raise RepoError (for branch check)
+            raise
         except MigrationManagerError as e:
-            # Log migration errors but don't fail repo initialization
-            print(f"Migration failed: {e}", file=sys.stderr)
+            # Log migration errors
+            error_msg = f"Migration failed: {e}"
+            result['errors'].append(error_msg)
+            raise RepoError(error_msg) from e
         except Exception as e:
             # Catch any unexpected errors
-            print(f"Unexpected migration error: {e}", file=sys.stderr)
+            error_msg = f"Unexpected migration error: {e}"
+            result['errors'].append(error_msg)
+            raise RepoError(error_msg) from e
+
+        return result
 
     def sync_hop_to_active_branches(self, reason: str = "update") -> dict:
         """

half_orm_dev-0.17.2a6/half_orm_dev/version.txt

@@ -0,0 +1 @@
+0.17.2-a6

{half_orm_dev-0.17.2a4 → half_orm_dev-0.17.2a6/half_orm_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.2a4
+Version: 0.17.2a6
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later

{half_orm_dev-0.17.2a4 → half_orm_dev-0.17.2a6}/half_orm_dev.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ half_orm_dev/cli/commands/apply.py
 half_orm_dev/cli/commands/check.py
 half_orm_dev/cli/commands/clone.py
 half_orm_dev/cli/commands/init.py
+half_orm_dev/cli/commands/migrate.py
 half_orm_dev/cli/commands/new.py
 half_orm_dev/cli/commands/patch.py
 half_orm_dev/cli/commands/release.py

half_orm_dev-0.17.2a4/half_orm_dev/version.txt

@@ -1 +0,0 @@
-0.17.2-a4