flutter-setup 2.1.0__py3-none-any.whl

flutter_setup/prerequisites_linux.py

@@ -0,0 +1,140 @@
+"""Linux prerequisites management for Flutter setup."""
+
+import shutil
+import subprocess
+
+from rich.console import Console
+
+from .config import Config
+from .exceptions import PrerequisitesError
+
+console = Console()
+
+# Core system utilities
+CORE_PACKAGES = [
+    "git",
+    "curl",
+    "unzip",
+    "xz-utils",
+    "zip",
+]
+
+# Linux desktop development requirements
+LINUX_DESKTOP_PACKAGES = [
+    "libglu1-mesa",
+    "clang",
+    "cmake",
+    "ninja-build",
+    "pkg-config",
+    "libgtk-3-dev",
+    "libayatana-appindicator3-dev",
+    "liblzma-dev",
+]
+
+# Android development requirements
+ANDROID_PACKAGES = [
+    "openjdk-17-jdk",
+]
+
+
+class LinuxPrerequisites:
+    """Manages Linux prerequisites for Flutter development."""
+
+    def __init__(self, config: Config):
+        """Initialize Linux prerequisites manager."""
+        self.config = config
+        self._check_package_manager()
+
+    def _check_package_manager(self) -> None:
+        """Ensure we are on a supported Debian-based system with APT."""
+        if not shutil.which("apt-get") or not shutil.which("dpkg"):
+            raise PrerequisitesError(
+                "Unsupported Linux distribution. Only Debian-based distributions (using APT) are currently supported for automated prerequisite installation."
+            )
+
+    def check_and_install(self) -> None:
+        """Check and install Linux prerequisites."""
+        if self.config.dry_run:
+            console.print(
+                "[yellow]DRY RUN: Would check and install Linux prerequisites[/yellow]"
+            )
+            console.print(
+                f"[yellow]DRY RUN: Would run: {self.install_command()}[/yellow]"
+            )
+            return
+
+        missing = self._missing_packages()
+        if missing:
+            console.print(f"  📦 Missing Linux packages: {', '.join(missing)}")
+            console.print("  🔧 Installing Linux prerequisites via APT...")
+            try:
+                subprocess.run(["sudo", "apt-get", "update"], check=True)
+                subprocess.run(
+                    ["sudo", "apt-get", "install", "-y", *missing],
+                    check=True,
+                )
+                console.print("  ✅ Linux prerequisites installed")
+            except subprocess.CalledProcessError as e:
+                raise PrerequisitesError(f"Failed to install Linux prerequisites: {e}")
+        else:
+            console.print("  ✅ Linux prerequisites already installed")
+
+        if "android" in self.config.platforms:
+            self._setup_android_tools()
+
+    def _setup_android_tools(self) -> None:
+        """Additional Android toolchain setup instructions."""
+        console.print("  🤖 Android JDK installed (openjdk-17-jdk)")
+        console.print(
+            "  ℹ️  Note: You may still need to install Android Command Line Tools manually"
+        )
+        console.print(
+            "  ℹ️  Download from: https://developer.android.com/studio#command-tools"
+        )
+
+    def _get_required_packages(self) -> list[str]:
+        """Get the full list of required packages based on target platforms."""
+        packages = list(CORE_PACKAGES)
+
+        if "linux" in self.config.platforms:
+            packages.extend(LINUX_DESKTOP_PACKAGES)
+
+        if "android" in self.config.platforms:
+            packages.extend(ANDROID_PACKAGES)
+
+        return sorted(list(set(packages)))
+
+    def install_command(self) -> str:
+        """Return the APT command users can run manually."""
+        packages = self._get_required_packages()
+        return f"sudo apt-get update && sudo apt-get install -y {' '.join(packages)}"
+
+    def _missing_packages(self) -> list[str]:
+        """Return missing APT packages."""
+        required = self._get_required_packages()
+        missing: list[str] = []
+        for package in required:
+            if not self._is_package_installed(package):
+                missing.append(package)
+        return missing
+
+    def _is_package_installed(self, package: str) -> bool:
+        """Check whether a package is installed via dpkg."""
+        result = subprocess.run(
+            ["dpkg", "-s", package],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return result.returncode == 0
+
+    def check_only(self) -> bool:
+        """Check Linux prerequisites without installing."""
+        missing = self._missing_packages()
+        if not missing:
+            console.print("  ✅ Linux prerequisites found")
+            return True
+
+        console.print(f"  ❌ Missing Linux prerequisites: {', '.join(missing)}")
+        console.print(f"  ℹ️  Install with: {self.install_command()}")
+        return False

flutter_setup/prerequisites_macos.py

@@ -0,0 +1,226 @@
+"""macOS prerequisites management for Flutter setup."""
+
+import subprocess
+from pathlib import Path
+
+from rich.console import Console
+
+from .config import Config
+from .exceptions import PrerequisitesError
+
+console = Console()
+
+
+class MacOSPrerequisites:
+    """Manages macOS prerequisites for Flutter development."""
+
+    def __init__(self, config: Config):
+        """Initialize macOS prerequisites manager."""
+        self.config = config
+        self.home = Path.home()
+
+    def check_and_install(self) -> None:
+        """Check and install all required prerequisites."""
+        if self.config.dry_run:
+            console.print(
+                "[yellow]DRY RUN: Would check and install macOS prerequisites[/yellow]"
+            )
+            return
+
+        self._check_xcode_tools()
+        self._check_homebrew()
+        self._install_packages()
+        self._setup_platform_tools()
+
+    def _check_xcode_tools(self) -> None:
+        """Check and install Xcode Command Line Tools."""
+        console.print("  📱 Checking Xcode Command Line Tools...")
+
+        try:
+            result = subprocess.run(
+                ["xcode-select", "-p"], capture_output=True, text=True, check=False
+            )
+
+            if result.returncode != 0:
+                console.print("  ⚠️  Xcode Command Line Tools not found, installing...")
+                subprocess.run(["xcode-select", "--install"], check=True)
+                console.print("  ✅ Xcode Command Line Tools installation initiated")
+                console.print(
+                    "  ℹ️  Please complete the installation in the popup window"
+                )
+                console.print(
+                    "  ℹ️  You may need to restart the setup after installation"
+                )
+                raise PrerequisitesError(
+                    "Xcode Command Line Tools installation required"
+                )
+
+            console.print("  ✅ Xcode Command Line Tools found")
+        except subprocess.CalledProcessError as e:
+            raise PrerequisitesError(f"Failed to check Xcode tools: {e}")
+
+    def _check_homebrew(self) -> None:
+        """Check and install Homebrew."""
+        console.print("  🍺 Checking Homebrew...")
+
+        try:
+            result = subprocess.run(
+                ["brew", "--version"], capture_output=True, text=True, check=False
+            )
+
+            if result.returncode != 0:
+                console.print("  ⚠️  Homebrew not found, installing...")
+                self._install_homebrew()
+            else:
+                console.print("  ✅ Homebrew found")
+                self._ensure_homebrew_path()
+        except subprocess.CalledProcessError as e:
+            raise PrerequisitesError(f"Failed to check Homebrew: {e}")
+
+    def _install_homebrew(self) -> None:
+        """Install Homebrew."""
+        try:
+            install_script = (
+                "https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh"
+            )
+            subprocess.run(
+                ["/bin/bash", "-c", f'curl -fsSL "{install_script}" | bash'],
+                env={"NONINTERACTIVE": "1"},
+                check=True,
+            )
+            console.print("  ✅ Homebrew installed")
+            self._ensure_homebrew_path()
+        except subprocess.CalledProcessError as e:
+            raise PrerequisitesError(f"Failed to install Homebrew: {e}")
+
+    def _ensure_homebrew_path(self) -> None:
+        """Ensure Homebrew is in PATH."""
+        try:
+            if Path("/opt/homebrew/bin/brew").exists():
+                subprocess.run(["/opt/homebrew/bin/brew", "shellenv"], check=True)
+                console.print("  ✅ Homebrew path configured")
+        except subprocess.CalledProcessError:
+            console.print(
+                "  ⚠️  Homebrew path configuration failed (may need manual setup)"
+            )
+
+    def _install_packages(self) -> None:
+        """Install required packages via Homebrew."""
+        required_packages = ["git", "cocoapods"]
+
+        for package in required_packages:
+            console.print(f"  📦 Installing {package}...")
+            try:
+                subprocess.run(
+                    ["brew", "install", package], check=True, capture_output=True
+                )
+                console.print(f"  ✅ {package} installed")
+            except subprocess.CalledProcessError as e:
+                result = subprocess.run(
+                    ["brew", "list", package],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                if result.returncode == 0:
+                    console.print(f"  ✅ {package} already installed")
+                else:
+                    raise PrerequisitesError(f"Failed to install {package}: {e}")
+
+    def _setup_platform_tools(self) -> None:
+        """Setup platform-specific development tools."""
+        if "android" in self.config.platforms:
+            self._setup_android_tools()
+        if "ios" in self.config.platforms:
+            self._setup_ios_tools()
+
+    def _setup_android_tools(self) -> None:
+        """Setup Android development tools."""
+        console.print("  🤖 Setting up Android development tools...")
+
+        android_packages = [
+            ("--cask", "temurin"),
+            ("--cask", "android-commandlinetools"),
+        ]
+
+        for args in android_packages:
+            package = args[1]
+            try:
+                subprocess.run(
+                    ["brew", "install"] + list(args), check=True, capture_output=True
+                )
+                console.print(f"  ✅ {package} installed")
+            except subprocess.CalledProcessError as e:
+                result = subprocess.run(
+                    ["brew", "list", "--cask", package],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                if result.returncode == 0:
+                    console.print(f"  ✅ {package} already installed")
+                else:
+                    console.print(f"  ⚠️  Failed to install {package}: {e}")
+
+    def _setup_ios_tools(self) -> None:
+        """Setup iOS development tools."""
+        console.print("  🍎 Setting up iOS development tools...")
+
+        try:
+            subprocess.run(["pod", "repo", "update"], check=False, capture_output=True)
+            console.print("  ✅ iOS tools configured")
+        except Exception as e:
+            console.print(f"  ⚠️  iOS tools configuration warning: {e}")
+
+    def check_only(self) -> bool:
+        """Check prerequisites without installing."""
+        all_ok = True
+
+        console.print("  📱 Checking Xcode Command Line Tools...")
+        try:
+            result = subprocess.run(
+                ["xcode-select", "-p"], capture_output=True, text=True, check=False
+            )
+            if result.returncode == 0:
+                console.print("  ✅ Xcode Command Line Tools found")
+            else:
+                console.print("  ❌ Xcode Command Line Tools not found")
+                all_ok = False
+        except Exception as e:
+            console.print(f"  ❌ Failed to check Xcode tools: {e}")
+            all_ok = False
+
+        console.print("  🍺 Checking Homebrew...")
+        try:
+            result = subprocess.run(
+                ["brew", "--version"], capture_output=True, text=True, check=False
+            )
+            if result.returncode == 0:
+                console.print("  ✅ Homebrew found")
+            else:
+                console.print("  ❌ Homebrew not found")
+                all_ok = False
+        except Exception as e:
+            console.print(f"  ❌ Failed to check Homebrew: {e}")
+            all_ok = False
+
+        required_packages = ["git", "cocoapods"]
+        for package in required_packages:
+            console.print(f"  📦 Checking {package}...")
+            try:
+                result = subprocess.run(
+                    ["brew", "list", package],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                if result.returncode == 0:
+                    console.print(f"  ✅ {package} installed")
+                else:
+                    console.print(f"  ❌ {package} not installed")
+                    all_ok = False
+            except Exception as e:
+                console.print(f"  ❌ Failed to check {package}: {e}")
+                all_ok = False
+
+        return all_ok

flutter_setup/project_creator.py

@@ -0,0 +1,82 @@
+"""Project creation for Flutter setup."""
+
+import subprocess
+from typing import List
+
+from rich.console import Console
+
+from .config import Config
+from .exceptions import ProjectCreationError
+
+console = Console()
+
+
+class ProjectCreator:
+    """Creates Flutter projects with specified configuration."""
+
+    def __init__(self, config: Config):
+        """Initialize ProjectCreator."""
+        self.config = config
+        self.flutter_root = config.flutter_location
+
+    def create_project(self) -> None:
+        """Create the Flutter project."""
+        if self.config.dry_run:
+            console.print("[yellow]DRY RUN: Would create Flutter project[/yellow]")
+            return
+
+        # Check if project already exists
+        if self.config.project_path.exists():
+            console.print(
+                f"  ⚠️  Directory '{self.config.project_path}' exists—skipping create."
+            )
+            return
+
+        # Create output directory
+        self.config.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Build flutter create command
+        create_cmd = self._build_create_command()
+
+        # Execute flutter create
+        console.print(
+            f"  🏗️  Creating Flutter project at {self.config.project_path}..."
+        )
+
+        try:
+            subprocess.run(create_cmd, check=True, capture_output=True, text=True)
+            console.print(f"  ✅ Project created at: {self.config.project_path}")
+
+        except subprocess.CalledProcessError as e:
+            raise ProjectCreationError(f"Failed to create project: {e}")
+
+    def _build_create_command(self) -> List[str]:
+        """Build the flutter create command."""
+        cmd = [
+            str(self.flutter_root / "bin" / "flutter"),
+            "create",
+            "--org",
+            self.config.org,
+            "--project-name",
+            self.config.package_name,
+            "--platforms",
+            self.config.platforms_csv,
+            "--template",
+            self.config.template,
+        ]
+
+        # Add template-specific options
+        if self.config.template == "plugin":
+            cmd.extend(
+                [
+                    "--ios-language",
+                    self.config.ios_language,
+                    "--android-language",
+                    self.config.android_language,
+                ]
+            )
+
+        # Add output path
+        cmd.append(str(self.config.project_path))
+
+        return cmd