flutter-setup 2.1.0__py3-none-any.whl

flutter_setup/config.py

@@ -0,0 +1,135 @@
+"""Configuration and data models for Flutter Setup."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Literal
+
+# Type aliases
+FlutterChannel = Literal["stable", "beta"]
+TemplateType = Literal["app", "plugin"]
+IosLanguage = Literal["swift", "objc"]
+AndroidLanguage = Literal["kotlin", "java"]
+UpdateMode = Literal["reset", "reclone", "skip"]
+Platform = Literal["ios", "android", "macos", "linux", "windows", "web"]
+Architecture = Literal["basic", "clean"]
+Database = Literal["none", "sqlite"]
+Testing = Literal["standard", "mocktail"]
+AuthProvider = Literal["none", "firebase"]
+CloudDatabase = Literal["none", "firestore"]
+NotificationsProvider = Literal["none", "firebase"]
+
+
+@dataclass
+class Config:
+    """Configuration for Flutter setup."""
+
+    project_name: str
+    platforms: List[str]
+    org: str
+    channel: FlutterChannel
+    output_dir: Path
+    template: TemplateType
+    ios_language: IosLanguage
+    android_language: AndroidLanguage
+    flutter_update_mode: UpdateMode
+    dry_run: bool
+    verbose: bool
+    flutter_location: Path
+    architecture: Architecture = "basic"
+    database: Database = "none"
+    testing: Testing = "standard"
+    auth_provider: AuthProvider = "none"
+    cloud_database: CloudDatabase = "none"
+    notifications_provider: NotificationsProvider = "none"
+    flutter_version: str | None = None
+
+    def __post_init__(self) -> None:
+        """Validate configuration after initialization."""
+        self._validate()
+
+    def _validate(self) -> None:
+        """Validate configuration values."""
+        if not self.project_name:
+            raise ValueError("Project name cannot be empty")
+
+        if not self.platforms:
+            raise ValueError("At least one platform must be specified")
+
+        # Basic normalization
+        self.platforms = [p.strip().lower() for p in self.platforms if p.strip()]
+
+        # Validate platforms
+        valid_platforms = {"ios", "android", "macos", "linux", "windows", "web"}
+        for platform in self.platforms:
+            if platform not in valid_platforms:
+                raise ValueError(f"Invalid platform: {platform}")
+
+        # Validate template-specific options
+        if self.template == "plugin":
+            if self.ios_language not in ["swift", "objc"]:
+                raise ValueError(f"Invalid iOS language: {self.ios_language}")
+            if self.android_language not in ["kotlin", "java"]:
+                raise ValueError(f"Invalid Android language: {self.android_language}")
+
+        if self.architecture not in ["basic", "clean"]:
+            raise ValueError(f"Invalid architecture: {self.architecture}")
+
+        if self.database not in ["none", "sqlite"]:
+            raise ValueError(f"Invalid database: {self.database}")
+
+        if self.testing not in ["standard", "mocktail"]:
+            raise ValueError(f"Invalid testing framework: {self.testing}")
+
+        if self.auth_provider not in ["none", "firebase"]:
+            raise ValueError(f"Invalid auth provider: {self.auth_provider}")
+
+        if self.cloud_database not in ["none", "firestore"]:
+            raise ValueError(f"Invalid cloud database: {self.cloud_database}")
+
+        if self.notifications_provider not in ["none", "firebase"]:
+            raise ValueError(
+                f"Invalid notifications provider: {self.notifications_provider}"
+            )
+
+        if self.flutter_version is not None:
+            import re
+
+            if not re.fullmatch(r"\d+\.\d+\.\d+", self.flutter_version):
+                raise ValueError(
+                    f"Invalid flutter_version '{self.flutter_version}': must be X.Y.Z (e.g. 3.24.0)"
+                )
+
+    @property
+    def project_path(self) -> Path:
+        """Get the full project path."""
+        return self.output_dir / self.project_name
+
+    @property
+    def package_name(self) -> str:
+        """Get the sanitized package name."""
+        return self._sanitize_package_name(self.project_name)
+
+    @property
+    def platforms_csv(self) -> str:
+        """Get platforms as comma-separated string."""
+        return ",".join(self.platforms)
+
+    def _sanitize_package_name(self, name: str) -> str:
+        """Sanitize package name for Flutter."""
+        import re
+
+        # Convert to lowercase and replace non-alphanumeric with underscores
+        sanitized = re.sub(r"[^a-z0-9_]", "_", name.lower())
+
+        # Ensure it starts with a letter
+        if sanitized and not sanitized[0].isalpha():
+            sanitized = f"app_{sanitized}"
+
+        # Remove leading/trailing underscores
+        sanitized = sanitized.strip("_")
+
+        # Ensure it's not empty
+        if not sanitized:
+            sanitized = "app"
+
+        return sanitized

flutter_setup/config_manager.py

@@ -0,0 +1,159 @@
+"""Configuration file management with XDG Base Directory Specification support."""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+from rich.console import Console
+
+console = Console()
+
+
+class ConfigManager:
+    """Manages configuration file using XDG Base Directory Specification."""
+
+    def __init__(self) -> None:
+        """Initialize ConfigManager with XDG-compliant paths."""
+        self.config_dir = self._get_config_dir()
+        self.config_file = self.config_dir / "config.yaml"
+
+    def _get_config_dir(self) -> Path:
+        """Get config directory following XDG Base Directory Specification."""
+        # XDG_CONFIG_HOME takes precedence, fallback to ~/.config
+        xdg_config_home = os.getenv("XDG_CONFIG_HOME")
+        if xdg_config_home:
+            config_dir = Path(xdg_config_home) / "flutter-setup"
+        else:
+            config_dir = Path.home() / ".config" / "flutter-setup"
+
+        return config_dir
+
+    def ensure_config_dir(self) -> None:
+        """Ensure config directory exists, creating it if necessary."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+    def get_default_config(self) -> Dict[str, Any]:
+        """Get default configuration values."""
+        home = Path.home()
+        default_flutter_location = str(home / "development" / "flutter")
+
+        return {
+            "flutter": {
+                "location": default_flutter_location,
+                "channel": "stable",
+                "update_mode": "skip",
+            },
+            "project": {
+                "org": "com.example",
+                "template": "app",
+                "architecture": "basic",
+                "database": "none",
+                "testing": "standard",
+                "auth_provider": "none",
+                "cloud_database": "none",
+                "notifications_provider": "none",
+                "ios_language": "swift",
+                "android_language": "kotlin",
+            },
+        }
+
+    def create_default_config(self) -> None:
+        """Create default config file if it doesn't exist."""
+        if self.config_file.exists():
+            return
+
+        self.ensure_config_dir()
+
+        default_config = self.get_default_config()
+
+        try:
+            with open(self.config_file, "w") as f:
+                yaml.dump(default_config, f, default_flow_style=False, sort_keys=False)
+            console.print(
+                f"[dim]Created default config file at: {self.config_file}[/dim]"
+            )
+        except Exception as e:
+            console.print(
+                f"[yellow]Warning: Could not create config file: {e}[/yellow]"
+            )
+
+    def load_config(self) -> Dict[str, Any]:
+        """Load configuration from file, creating default if it doesn't exist."""
+        # Create default config if it doesn't exist
+        if not self.config_file.exists():
+            self.create_default_config()
+
+        if not self.config_file.exists():
+            # If we still can't create it, return defaults
+            return self.get_default_config()
+
+        try:
+            with open(self.config_file, "r") as f:
+                config = yaml.safe_load(f) or {}
+            return config
+        except Exception as e:
+            console.print(
+                f"[yellow]Warning: Could not load config file: {e}. Using defaults.[/yellow]"
+            )
+            return self.get_default_config()
+
+    def save_config(self, config: Dict[str, Any]) -> None:
+        """Save configuration to file."""
+        self.ensure_config_dir()
+
+        try:
+            with open(self.config_file, "w") as f:
+                yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not save config file: {e}[/yellow]")
+
+    def get_flutter_location(self) -> Optional[Path]:
+        """Get Flutter location from config file."""
+        config = self.load_config()
+        flutter_location = config.get("flutter", {}).get("location")
+        if flutter_location:
+            return Path(flutter_location)
+        return None
+
+    def set_flutter_location(self, location: Path) -> None:
+        """Set Flutter location in config file."""
+        config = self.load_config()
+        if "flutter" not in config:
+            config["flutter"] = {}
+        config["flutter"]["location"] = str(location)
+        self.save_config(config)
+
+    def detect_flutter_location(self) -> Optional[Path]:
+        """Detect Flutter location from environment variables or PATH."""
+        # Check FLUTTER_ROOT environment variable
+        flutter_root = os.getenv("FLUTTER_ROOT")
+        if flutter_root:
+            path = Path(flutter_root)
+            if path.exists() and (path / "bin" / "flutter").exists():
+                return path
+
+        # Check if flutter is in PATH
+        flutter_bin = shutil.which("flutter")
+        if flutter_bin:
+            # flutter_bin is something like /path/to/flutter/bin/flutter
+            flutter_path = Path(flutter_bin).parent.parent
+            if flutter_path.exists() and (flutter_path / ".git").exists():
+                return flutter_path
+
+        # Check common installation locations
+        home = Path.home()
+        common_paths = [
+            home / "development" / "flutter",
+            home / "flutter",
+            home / ".flutter",
+            Path("/usr/local/flutter"),
+            Path("/opt/flutter"),
+        ]
+
+        for path in common_paths:
+            if path.exists() and (path / "bin" / "flutter").exists():
+                return path
+
+        return None

flutter_setup/core.py

@@ -0,0 +1,204 @@
+"""Core Flutter setup functionality."""
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.panel import Panel
+
+from .config import Config
+from .exceptions import (
+    FlutterSetupError,
+    PrerequisitesError,
+    FlutterInstallationError,
+    ProjectCreationError,
+)
+from .prerequisites import PrerequisitesManager
+from .flutter_manager import FlutterManager
+from .project_creator import ProjectCreator
+from .bootstrap import ProjectBootstrap
+from .platform import detect_runtime_platform
+
+console = Console()
+
+
+class FlutterSetup:
+    """Main class for orchestrating Flutter development environment setup."""
+
+    def __init__(self, config: Config):
+        """Initialize FlutterSetup with configuration."""
+        self.config = config
+        self.platform = detect_runtime_platform()
+        self.prerequisites = PrerequisitesManager(config)
+        self.flutter_manager = FlutterManager(config)
+        self.project_creator = ProjectCreator(config)
+        self.bootstrap = ProjectBootstrap(config)
+
+    def run(self) -> None:
+        """Run the complete Flutter setup process."""
+        console.print(
+            f"\n[bold blue]🚀 Starting Flutter setup for: {self.config.project_name}[/bold blue]"
+        )
+        console.print(
+            f"[dim]Template: {self.config.template} | Org: {self.config.org} | Channel: {self.config.channel}[/dim]"
+        )
+        console.print(
+            f"[dim]Architecture: {self.config.architecture} | Database: {self.config.database}[/dim]"
+        )
+        console.print(
+            f"[dim]Testing: {self.config.testing} | Auth: {self.config.auth_provider} | Cloud DB: {self.config.cloud_database} | Notifications: {self.config.notifications_provider}[/dim]"
+        )
+        console.print(
+            f"[dim]Platforms: {', '.join(self.config.platforms)} | Package: {self.config.package_name}[/dim]"
+        )
+        console.print(f"[dim]Host OS: {self.platform}[/dim]")
+        console.print(f"[dim]Output: {self.config.project_path}[/dim]")
+
+        if self.config.dry_run:
+            console.print(
+                "[yellow]⚠️  DRY RUN MODE - No actual changes will be made[/yellow]"
+            )
+
+        try:
+            # Step 1: Check and install prerequisites
+            self._run_prerequisites()
+
+            # Step 2: Install/update Flutter SDK
+            self._run_flutter_installation()
+
+            # Step 3: Create Flutter project
+            self._run_project_creation()
+
+            # Step 4: Bootstrap development environment
+            self._run_bootstrap()
+
+            # Step 5: Display next steps
+            self._show_next_steps()
+
+        except Exception as e:
+            console.print(f"\n[red]❌ Setup failed: {e}[/red]")
+            raise
+
+    def _run_prerequisites(self) -> None:
+        """Run prerequisites check and installation."""
+        console.print("\n[bold]📋 Checking prerequisites...[/bold]")
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Checking system requirements...", total=None)
+
+            try:
+                self.prerequisites.check_and_install()
+                progress.update(task, description="✅ Prerequisites satisfied")
+            except Exception as e:
+                progress.update(task, description="❌ Prerequisites failed")
+                raise PrerequisitesError(f"Failed to install prerequisites: {e}")
+
+    def _run_flutter_installation(self) -> None:
+        """Run Flutter SDK installation/update."""
+        console.print("\n[bold]🦋 Installing/updating Flutter SDK...[/bold]")
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Setting up Flutter SDK...", total=None)
+
+            try:
+                self.flutter_manager.ensure_flutter()
+                progress.update(task, description="✅ Flutter SDK ready")
+            except Exception as e:
+                progress.update(task, description="❌ Flutter installation failed")
+                raise FlutterInstallationError(f"Failed to install Flutter: {e}")
+
+    def _run_project_creation(self) -> None:
+        """Run Flutter project creation."""
+        console.print("\n[bold]🏗️  Creating Flutter project...[/bold]")
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Creating project structure...", total=None)
+
+            try:
+                self.project_creator.create_project()
+                progress.update(task, description="✅ Project created")
+            except Exception as e:
+                progress.update(task, description="❌ Project creation failed")
+                raise ProjectCreationError(f"Failed to create project: {e}")
+
+    def _run_bootstrap(self) -> None:
+        """Run project bootstrapping."""
+        console.print("\n[bold]🔧 Bootstrapping development environment...[/bold]")
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Setting up development tools...", total=None)
+
+            try:
+                self.bootstrap.bootstrap_project()
+                progress.update(task, description="✅ Development environment ready")
+            except Exception as e:
+                progress.update(task, description="❌ Bootstrap failed")
+                raise FlutterSetupError(f"Failed to bootstrap project: {e}")
+
+    def _show_next_steps(self) -> None:
+        """Display next steps for the user."""
+        console.print("\n[bold green]🎉 Setup completed successfully![/bold green]")
+
+        if self.platform == "darwin":
+            shell_profile_steps = (
+                "   [code]source ~/.zprofile[/code]    # zsh login shells\n"
+                "   [code]source ~/.zshrc[/code]       # zsh interactive shells"
+            )
+        else:
+            shell_profile_steps = (
+                "   [code]source ~/.bashrc[/code]      # bash\n"
+                "   [code]source ~/.zshrc[/code]       # zsh"
+            )
+        platform_run_labels = {
+            "web": ("make run-chrome", "runs on Chrome"),
+            "ios": ("make run-ios", "runs on iOS simulator"),
+            "android": ("make run-android", "runs on Android emulator"),
+        }
+        run_steps = "\n".join(
+            f"   [code]{cmd}[/code]   # {label}"
+            for p in self.config.platforms
+            if (entry := platform_run_labels.get(p))
+            for cmd, label in [entry]
+        )
+        if not run_steps:
+            run_steps = "   [code]flutter run[/code]"
+
+        next_steps = f"""
+[bold]Next steps:[/bold]
+
+1. [blue]Activate Flutter in your shell:[/blue]
+{shell_profile_steps}
+
+2. [blue]Navigate to your project:[/blue]
+   [code]cd "{self.config.project_path}"[/code]
+
+3. [blue]Run your Flutter app:[/blue]
+{run_steps}
+
+4. [blue]Test your setup:[/blue]
+   [code]make test[/code]          # run unit + widget tests
+   [code]make analyze[/code]       # check lints
+
+5. [blue]Open in Cursor/VS Code:[/blue]
+   Hit F5 ("Flutter Debug") to start debugging
+
+[dim]Your project is located at: {self.config.project_path}[/dim]
+        """
+
+        console.print(
+            Panel(next_steps, title="🚀 Ready to Code!", border_style="green")
+        )

flutter_setup/exceptions.py

@@ -0,0 +1,37 @@
+"""Custom exceptions for Flutter Setup."""
+
+
+class FlutterSetupError(Exception):
+    """Base exception for Flutter setup errors."""
+
+    pass
+
+
+class PrerequisitesError(FlutterSetupError):
+    """Raised when prerequisites are not met."""
+
+    pass
+
+
+class FlutterInstallationError(FlutterSetupError):
+    """Raised when Flutter installation fails."""
+
+    pass
+
+
+class ProjectCreationError(FlutterSetupError):
+    """Raised when project creation fails."""
+
+    pass
+
+
+class ConfigurationError(FlutterSetupError):
+    """Raised when configuration is invalid."""
+
+    pass
+
+
+class SystemError(FlutterSetupError):
+    """Raised when system-level operations fail."""
+
+    pass