ruflet 0.0.17 → 0.0.18

data/lib/ruflet/cli/android_sdk.rb

@@ -1,306 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "open3"
-require "rbconfig"
-require "tmpdir"
-
-module Ruflet
-  module CLI
-    # Provisions the Android toolchain so `ruflet build apk|aab|android`
-    # works on a fresh machine:
-    #
-    #   * a JDK (Gradle itself is bootstrapped by the project's Gradle
-    #     wrapper, but the wrapper needs Java)
-    #   * the Android SDK command-line tools
-    #   * platform-tools / a platform / build-tools via sdkmanager
-    #   * accepted SDK licenses
-    #
-    # An existing SDK (ANDROID_HOME, ANDROID_SDK_ROOT, or the standard
-    # per-OS install location) is always preferred; otherwise a Ruflet-managed
-    # SDK is created under ~/.ruflet/android-sdk.
-    module AndroidSdk
-      CMDLINE_TOOLS_VERSION = "11076708"
-      CMDLINE_TOOLS_BASE = "https://dl.google.com/android/repository".freeze
-      ANDROID_PLATFORM = "android-35"
-      ANDROID_BUILD_TOOLS = "35.0.0"
-      MINIMUM_JAVA_MAJOR = 17
-
-      JDK_PACKAGES = {
-        apt: "openjdk-17-jdk",
-        dnf: "java-17-openjdk-devel",
-        pacman: "jdk17-openjdk",
-        zypper: "java-17-openjdk-devel",
-        apk: "openjdk17",
-        brew: "openjdk@17",
-        winget: "EclipseAdoptium.Temurin.17.JDK",
-        choco: "temurin17"
-      }.freeze
-
-      def android_environment_setup!(fix: false, verbose: false)
-        issues = []
-
-        java = ensure_java!(fix: fix, verbose: verbose)
-        if java
-          puts "  Java: #{java[:version]} (#{java[:path]})"
-        else
-          issues << "missing JDK #{MINIMUM_JAVA_MAJOR}+"
-          warn "  Java: missing — Android builds need a JDK (Gradle wrapper requirement)."
-          warn "    #{jdk_install_hint}"
-          return issues unless fix
-        end
-
-        sdk_root = detect_android_sdk_root
-        if sdk_root
-          puts "  Android SDK: #{sdk_root}"
-        elsif fix
-          unless java
-            warn "  Android SDK: skipped (sdkmanager needs Java)"
-            return issues
-          end
-          sdk_root = install_managed_android_sdk(java, verbose: verbose)
-          unless sdk_root
-            issues << "Android SDK install failed"
-            warn "  Android SDK: install failed"
-            return issues
-          end
-          puts "  Android SDK: #{sdk_root} (installed)"
-        else
-          issues << "missing Android SDK"
-          warn "  Android SDK: missing — run `ruflet doctor --fix` to install it under #{managed_android_sdk_root}."
-          return issues
-        end
-
-        if fix && java
-          ensure_android_packages(sdk_root, java, verbose: verbose)
-          accept_android_licenses(sdk_root, java, verbose: verbose)
-        end
-
-        issues
-      end
-
-      # Environment for invoking Flutter/Gradle Android builds.
-      def android_build_env(env)
-        merged = env.dup
-        sdk_root = detect_android_sdk_root
-        if sdk_root
-          merged["ANDROID_HOME"] ||= sdk_root
-          merged["ANDROID_SDK_ROOT"] ||= sdk_root
-          platform_tools = File.join(sdk_root, "platform-tools")
-          if Dir.exist?(platform_tools)
-            merged["PATH"] = "#{platform_tools}#{File::PATH_SEPARATOR}#{merged.fetch('PATH', ENV.fetch('PATH', ''))}"
-          end
-        end
-        java_home = detect_java_home
-        merged["JAVA_HOME"] ||= java_home if java_home
-        merged
-      end
-
-      def detect_android_sdk_root
-        candidates = [
-          ENV["ANDROID_HOME"],
-          ENV["ANDROID_SDK_ROOT"],
-          default_android_sdk_location,
-          managed_android_sdk_root
-        ]
-        candidates.compact.find { |root| android_sdk_present?(root) }
-      end
-
-      def managed_android_sdk_root
-        File.join(Dir.home, ".ruflet", "android-sdk")
-      end
-
-      private
-
-      def android_sdk_present?(root)
-        return false if root.to_s.strip.empty?
-
-        Dir.exist?(File.join(root, "platform-tools")) ||
-          Dir.exist?(File.join(root, "cmdline-tools")) ||
-          Dir.exist?(File.join(root, "platforms"))
-      end
-
-      def default_android_sdk_location
-        if windows_host?
-          local = ENV["LOCALAPPDATA"].to_s
-          return File.join(local, "Android", "Sdk") unless local.empty?
-
-          nil
-        elsif macos_host?
-          File.join(Dir.home, "Library", "Android", "sdk")
-        else
-          File.join(Dir.home, "Android", "Sdk")
-        end
-      end
-
-      def ensure_java!(fix:, verbose: false)
-        java = current_java_info
-        return java if java && java[:major] >= MINIMUM_JAVA_MAJOR
-
-        return nil unless fix
-
-        manager = system_package_manager
-        package = manager && JDK_PACKAGES[manager[:id]]
-        return nil unless package
-
-        if manager[:id] == :winget
-          run_privileged_command(*manager[:install], package, verbose: verbose)
-        else
-          run_privileged_command(*manager[:install], package, verbose: verbose)
-        end
-        current_java_info
-      end
-
-      def current_java_info
-        java = which_command("java") || bundled_java_candidate
-        return nil unless java
-
-        output, status = Open3.capture2e(java, "-version")
-        return nil unless status.success?
-
-        major = parse_java_major(output)
-        return nil unless major
-
-        { path: java, major: major, version: output.lines.first.to_s.strip }
-      rescue StandardError
-        nil
-      end
-
-      def bundled_java_candidate
-        if macos_host?
-          brew_java = "/opt/homebrew/opt/openjdk@17/bin/java"
-          return brew_java if File.executable?(brew_java)
-        end
-        nil
-      end
-
-      def parse_java_major(output)
-        match = output[/version "(\d+)(?:\.(\d+))?/, 1]
-        return nil unless match
-
-        major = match.to_i
-        # "1.8" style versions report the major in the second group.
-        major = output[/version "1\.(\d+)/, 1].to_i if major == 1
-        major
-      end
-
-      def detect_java_home
-        if macos_host?
-          output, status = Open3.capture2e("/usr/libexec/java_home", "-v", MINIMUM_JAVA_MAJOR.to_s)
-          return output.strip if status.success? && !output.strip.empty?
-        end
-
-        java = which_command("java")
-        return nil unless java
-
-        resolved = File.realpath(java) rescue java
-        home = File.expand_path("../..", resolved)
-        File.directory?(File.join(home, "bin")) ? home : nil
-      end
-
-      def install_managed_android_sdk(java, verbose: false)
-        sdk_root = managed_android_sdk_root
-        tools_dir = File.join(sdk_root, "cmdline-tools", "latest")
-        return sdk_root if File.executable?(sdkmanager_bin(sdk_root))
-
-        archive_name = "commandlinetools-#{cmdline_tools_os}-#{CMDLINE_TOOLS_VERSION}_latest.zip"
-        FileUtils.mkdir_p(sdk_root)
-        Dir.mktmpdir("ruflet-android-") do |tmp|
-          archive = File.join(tmp, archive_name)
-          puts "  Downloading Android command-line tools (#{archive_name})"
-          download_file("#{CMDLINE_TOOLS_BASE}/#{archive_name}", archive)
-          extract_archive(archive, tmp)
-          extracted = File.join(tmp, "cmdline-tools")
-          raise "cmdline-tools missing from archive" unless Dir.exist?(extracted)
-
-          FileUtils.rm_rf(tools_dir)
-          FileUtils.mkdir_p(File.dirname(tools_dir))
-          FileUtils.mv(extracted, tools_dir)
-        end
-
-        File.executable?(sdkmanager_bin(sdk_root)) ? sdk_root : nil
-      rescue StandardError => e
-        warn "  Android SDK download failed: #{e.class}: #{e.message}"
-        nil
-      end
-
-      def cmdline_tools_os
-        return "win" if windows_host?
-        return "mac" if macos_host?
-
-        "linux"
-      end
-
-      def sdkmanager_bin(sdk_root)
-        name = windows_host? ? "sdkmanager.bat" : "sdkmanager"
-        File.join(sdk_root, "cmdline-tools", "latest", "bin", name)
-      end
-
-      def ensure_android_packages(sdk_root, java, verbose: false)
-        sdkmanager = sdkmanager_bin(sdk_root)
-        return unless File.executable?(sdkmanager)
-
-        packages = ["platform-tools", "platforms;#{ANDROID_PLATFORM}", "build-tools;#{ANDROID_BUILD_TOOLS}"]
-        missing = packages.reject { |package| android_package_installed?(sdk_root, package) }
-        return if missing.empty?
-
-        puts "  Installing Android packages: #{missing.join(', ')}"
-        env = sdkmanager_env(java)
-        # sdkmanager downloads sizeable platform/build-tool archives; stream so
-        # the install reports progress instead of appearing to hang.
-        system(env, sdkmanager, "--sdk_root=#{sdk_root}", *missing, out: $stdout, err: $stderr)
-      end
-
-      def android_package_installed?(sdk_root, package)
-        case package
-        when "platform-tools"
-          Dir.exist?(File.join(sdk_root, "platform-tools"))
-        when /\Aplatforms;(.+)\z/
-          Dir.exist?(File.join(sdk_root, "platforms", Regexp.last_match(1)))
-        when /\Abuild-tools;(.+)\z/
-          Dir.exist?(File.join(sdk_root, "build-tools", Regexp.last_match(1)))
-        else
-          false
-        end
-      end
-
-      def accept_android_licenses(sdk_root, java, verbose: false)
-        sdkmanager = sdkmanager_bin(sdk_root)
-        return unless File.executable?(sdkmanager)
-
-        puts "  Accepting Android SDK licenses"
-        env = sdkmanager_env(java)
-        Open3.popen2e(env, sdkmanager, "--sdk_root=#{sdk_root}", "--licenses") do |stdin, stdout, wait|
-          begin
-            stdin.write("y\n" * 64)
-            stdin.close
-          rescue Errno::EPIPE
-            nil
-          end
-          stdout.each_line { |line| puts line if verbose }
-          wait.value
-        end
-      rescue StandardError => e
-        warn "  License acceptance failed: #{e.class}: #{e.message}"
-      end
-
-      def sdkmanager_env(java)
-        env = {}
-        java_home = detect_java_home
-        env["JAVA_HOME"] = java_home if java_home
-        if java && java[:path]
-          env["PATH"] = "#{File.dirname(java[:path])}#{File::PATH_SEPARATOR}#{ENV.fetch('PATH', '')}"
-        end
-        env
-      end
-
-      def jdk_install_hint
-        manager = system_package_manager
-        package = manager && JDK_PACKAGES[manager[:id]]
-        return "#{(sudo_prefix + manager[:install]).join(' ')} #{package}" if package
-
-        "install a JDK #{MINIMUM_JAVA_MAJOR}+ (e.g. Temurin: https://adoptium.net)"
-      end
-    end
-  end
-end

data/lib/ruflet/cli/environment_setup.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-require "rbconfig"
-
-module Ruflet
-  module CLI
-    # Provisions the host so `ruflet build` can run: checks (and with
-    # `ruflet doctor --fix`, installs) the system tools Flutter requires.
-    #
-    # Coverage:
-    #   Linux   apt (Ubuntu, Debian, Kali, Mint), dnf (Fedora, RHEL),
-    #           pacman (Arch, Omarchy, Manjaro), zypper (openSUSE)
-    #   macOS   Homebrew where available, plus Xcode Command Line Tools and
-    #           CocoaPods guidance
-    #   Windows winget or Chocolatey
-    #
-    # Anything that cannot be installed unattended (Xcode CLT, Visual Studio
-    # Build Tools) is reported with the exact command the developer must run.
-    module EnvironmentSetup
-      Tool = Struct.new(:name, :probe, :purpose, :packages, :manual_hint, keyword_init: true)
-
-      LINUX_PACKAGE_MANAGERS = [
-        { id: :apt, probe: "apt-get", install: %w[apt-get install -y], update: %w[apt-get update] },
-        { id: :dnf, probe: "dnf", install: %w[dnf install -y], update: nil },
-        { id: :pacman, probe: "pacman", install: %w[pacman -S --noconfirm --needed], update: nil },
-        { id: :zypper, probe: "zypper", install: %w[zypper --non-interactive install], update: nil },
-        { id: :apk, probe: "apk", install: %w[apk add], update: nil }
-      ].freeze
-
-      def environment_setup!(fix: false, verbose: false)
-        issues = []
-        tools = required_system_tools
-
-        unless flutter_host
-          issues << unsupported_host_message
-          warn "  System: #{unsupported_host_message}"
-          return issues
-        end
-
-        manager = system_package_manager
-        missing = tools.reject { |tool| tool_present?(tool) }
-
-        if missing.empty?
-          puts "  System tools: ok (#{tools.map(&:name).join(', ')})"
-          return issues
-        end
-
-        puts "  System tools missing: #{missing.map(&:name).join(', ')}"
-
-        unless fix
-          missing.each { |tool| warn "    #{tool.name}: #{manual_hint_for(tool, manager)}" }
-          warn "  Run `ruflet doctor --fix` to install them."
-          return missing.map { |tool| "missing #{tool.name}" }
-        end
-
-        auto, manual = missing.partition { |tool| installable?(tool, manager) }
-
-        if auto.any?
-          if manager
-            install_system_packages(manager, auto, verbose: verbose)
-          end
-          still_missing = auto.reject { |tool| tool_present?(tool) }
-          still_missing.each do |tool|
-            issues << "missing #{tool.name}"
-            warn "    #{tool.name}: install failed — #{manual_hint_for(tool, manager)}"
-          end
-          installed = auto - still_missing
-          puts "  Installed: #{installed.map(&:name).join(', ')}" if installed.any?
-        end
-
-        manual.each do |tool|
-          issues << "missing #{tool.name}"
-          warn "    #{tool.name}: requires a manual step — #{manual_hint_for(tool, manager)}"
-        end
-
-        issues
-      end
-
-      def required_system_tools
-        case flutter_host
-        when "linux" then linux_required_tools
-        when "macos", "macos_arm64" then macos_required_tools
-        when "windows" then windows_required_tools
-        else []
-        end
-      end
-
-      def system_package_manager
-        if windows_host?
-          return { id: :winget, install: %w[winget install --accept-source-agreements --accept-package-agreements -e --id] } if which_command("winget")
-          return { id: :choco, install: %w[choco install -y] } if which_command("choco")
-          return nil
-        end
-
-        if macos_host?
-          return { id: :brew, install: %w[brew install] } if which_command("brew")
-          return nil
-        end
-
-        LINUX_PACKAGE_MANAGERS.each do |manager|
-          next unless which_command(manager[:probe])
-
-          return manager
-        end
-        nil
-      end
-
-      private
-
-      def macos_host?
-        RbConfig::CONFIG["host_os"].match?(/darwin/i)
-      end
-
-      def linux_required_tools
-        [
-          Tool.new(name: "git", probe: "git", purpose: "required by the Flutter tool itself",
-                   packages: { apt: "git", dnf: "git", pacman: "git", zypper: "git", apk: "git" }),
-          Tool.new(name: "curl", probe: "curl", purpose: "SDK downloads",
-                   packages: { apt: "curl", dnf: "curl", pacman: "curl", zypper: "curl", apk: "curl" }),
-          Tool.new(name: "unzip", probe: "unzip", purpose: "extracting Flutter artifacts",
-                   packages: { apt: "unzip", dnf: "unzip", pacman: "unzip", zypper: "unzip", apk: "unzip" }),
-          Tool.new(name: "xz", probe: "xz", purpose: "extracting the Flutter SDK (.tar.xz)",
-                   packages: { apt: "xz-utils", dnf: "xz", pacman: "xz", zypper: "xz", apk: "xz" }),
-          Tool.new(name: "zip", probe: "zip", purpose: "packaging app bundles",
-                   packages: { apt: "zip", dnf: "zip", pacman: "zip", zypper: "zip", apk: "zip" }),
-          Tool.new(name: "clang", probe: "clang", purpose: "Linux desktop builds",
-                   packages: { apt: "clang", dnf: "clang", pacman: "clang", zypper: "clang", apk: "clang" }),
-          Tool.new(name: "cmake", probe: "cmake", purpose: "Linux desktop builds",
-                   packages: { apt: "cmake", dnf: "cmake", pacman: "cmake", zypper: "cmake", apk: "cmake" }),
-          Tool.new(name: "ninja", probe: "ninja", purpose: "Linux desktop builds",
-                   packages: { apt: "ninja-build", dnf: "ninja-build", pacman: "ninja", zypper: "ninja", apk: "ninja" }),
-          Tool.new(name: "pkg-config", probe: "pkg-config", purpose: "Linux desktop builds",
-                   packages: { apt: "pkg-config", dnf: "pkgconf-pkg-config", pacman: "pkgconf", zypper: "pkg-config", apk: "pkgconf" }),
-          Tool.new(name: "GTK 3 headers", probe: nil, purpose: "Linux desktop builds",
-                   packages: { apt: "libgtk-3-dev", dnf: "gtk3-devel", pacman: "gtk3", zypper: "gtk3-devel", apk: "gtk+3.0-dev" })
-        ]
-      end
-
-      def macos_required_tools
-        [
-          Tool.new(name: "git", probe: "git", purpose: "required by the Flutter tool itself",
-                   packages: { brew: "git" },
-                   manual_hint: "install Xcode Command Line Tools: xcode-select --install"),
-          Tool.new(name: "curl", probe: "curl", purpose: "SDK downloads", packages: { brew: "curl" }),
-          Tool.new(name: "unzip", probe: "unzip", purpose: "extracting Flutter artifacts", packages: { brew: "unzip" }),
-          Tool.new(name: "Xcode Command Line Tools", probe: nil, purpose: "macOS/iOS builds",
-                   packages: {},
-                   manual_hint: "run `xcode-select --install` (or install Xcode from the App Store)"),
-          Tool.new(name: "CocoaPods", probe: "pod", purpose: "macOS/iOS plugin dependencies",
-                   packages: { brew: "cocoapods" },
-                   manual_hint: "run `brew install cocoapods` or `sudo gem install cocoapods`")
-        ]
-      end
-
-      def windows_required_tools
-        [
-          Tool.new(name: "git", probe: "git", purpose: "required by the Flutter tool itself",
-                   packages: { winget: "Git.Git", choco: "git" }),
-          Tool.new(name: "Visual Studio Build Tools", probe: nil, purpose: "Windows desktop builds",
-                   packages: {},
-                   manual_hint: "winget install --id Microsoft.VisualStudio.2022.BuildTools (select the " \
-                                "\"Desktop development with C++\" workload)")
-        ]
-      end
-
-      def tool_present?(tool)
-        case tool.name
-        when "GTK 3 headers"
-          return true if which_command("pkg-config") &&
-                         system("pkg-config", "--exists", "gtk+-3.0", out: File::NULL, err: File::NULL)
-
-          false
-        when "Xcode Command Line Tools"
-          system("xcode-select", "-p", out: File::NULL, err: File::NULL)
-        else
-          tool.probe ? !which_command(tool.probe).nil? : false
-        end
-      end
-
-      def installable?(tool, manager)
-        return false unless manager
-
-        tool.packages.key?(manager[:id])
-      end
-
-      def manual_hint_for(tool, manager)
-        return tool.manual_hint if tool.manual_hint && !installable?(tool, manager)
-        return "no supported package manager found; install #{tool.name} manually" unless manager
-
-        package = tool.packages[manager[:id]]
-        return tool.manual_hint || "install #{tool.name} manually" unless package
-
-        "#{(sudo_prefix + manager[:install]).join(' ')} #{package}"
-      end
-
-      def install_system_packages(manager, tools, verbose: false)
-        packages = tools.map { |tool| tool.packages[manager[:id]] }.compact.uniq
-        return if packages.empty?
-
-        if manager[:update]
-          run_privileged_command(*manager[:update], verbose: verbose)
-        end
-
-        if manager[:id] == :winget
-          # winget installs one id at a time.
-          packages.each { |package| run_privileged_command(*manager[:install], package, verbose: verbose) }
-        else
-          run_privileged_command(*manager[:install], *packages, verbose: verbose)
-        end
-      end
-
-      def run_privileged_command(*command, verbose: false)
-        full = sudo_prefix + command
-        puts "  $ #{full.join(' ')}"
-        # Package installs (apt/dnf/pacman...) routinely download hundreds of
-        # megabytes and take minutes. Always stream their output so the user
-        # can see progress instead of a frozen-looking prompt; `verbose` is
-        # left for callers that want to add their own detail elsewhere.
-        system(*full, out: $stdout, err: $stderr)
-      end
-
-      def sudo_prefix
-        return [] if windows_host? || macos_host?
-        return [] if Process.respond_to?(:uid) && Process.uid.zero?
-        return ["sudo"] if which_command("sudo")
-
-        []
-      end
-
-      def unsupported_host_message
-        os = RbConfig::CONFIG["host_os"]
-        if os.match?(/linux/i) && machine_arch.match?(/arm|aarch64/)
-          "Flutter publishes no official Linux #{machine_arch} build; use an x64 machine " \
-            "or build Flutter from source (https://github.com/flutter/flutter)."
-        else
-          "unsupported host platform: #{os}"
-        end
-      end
-    end
-  end
-end