ruflet 0.0.8 → 0.0.9

data/lib/ruflet/cli/flutter_sdk.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "net/http"
+require "open3"
+require "rbconfig"
+require "tmpdir"
+require "uri"
+require "yaml"
+
+module Ruflet
+  module CLI
+    module FlutterSdk
+      RELEASES_BASE = "https://storage.googleapis.com/flutter_infra_release/releases".freeze
+      DEFAULT_FLUTTER_CHANNEL = "stable".freeze
+
+      def ensure_flutter!(command_name, client_dir: nil, auto_install: true)
+        tools = flutter_tools(client_dir: client_dir, auto_install: auto_install)
+        return tools if tools
+
+        warn "Flutter is required for `ruflet #{command_name}` and FVM bootstrap failed."
+        warn "Set RUFLET_FLUTTER_VERSION or add .fvmrc to the project."
+        exit 1
+      end
+
+      def flutter_version_summary(tools)
+        flutter_bin = tools[:flutter]
+        env = tools[:env] || {}
+
+        machine_output, status = Open3.capture2e(env, flutter_bin, "--version", "--machine")
+        if status.success?
+          parsed = JSON.parse(machine_output) rescue nil
+          version = parsed && parsed["frameworkVersion"].to_s.strip
+          channel = parsed && parsed["channel"].to_s.strip
+          return [version, channel].reject(&:empty?).join(" ") unless version.to_s.empty?
+        end
+
+        text_output, text_status = Open3.capture2e(env, flutter_bin, "--version")
+        return text_output.lines.first.to_s.strip if text_status.success?
+
+        File.basename(flutter_bin.to_s)
+      rescue StandardError
+        File.basename(flutter_bin.to_s)
+      end
+
+      private
+
+      def flutter_tools(client_dir: nil, auto_install: true)
+        # Always use FVM so Flutter/Dart match pinned SDK.
+        fvm_tools = flutter_tools_via_fvm(client_dir: client_dir, auto_install: auto_install)
+        return fvm_tools if fvm_tools
+
+        nil
+      end
+
+      def flutter_tools_via_fvm(client_dir: nil, auto_install: true)
+        version = desired_flutter_version(client_dir: client_dir)
+        return nil if version.to_s.strip.empty?
+
+        project_dir = fvm_project_dir(client_dir: client_dir)
+        flutter = existing_fvm_flutter_bin(project_dir)
+        return tools_from_flutter_bin(flutter) if flutter
+
+        return nil unless auto_install
+
+        fvm = ensure_fvm_available(client_dir: client_dir)
+        return nil unless fvm
+        FileUtils.mkdir_p(project_dir)
+        fvmrc_path = File.join(project_dir, ".fvmrc")
+        unless File.file?(fvmrc_path)
+          File.write(fvmrc_path, "{\"flutter\":\"#{version}\"}\n")
+        end
+
+        system(fvm_env, fvm, "install", version.to_s, chdir: project_dir, out: File::NULL, err: File::NULL)
+        system(fvm_env, fvm, "use", "--force", version.to_s, chdir: project_dir, out: File::NULL, err: File::NULL)
+
+        flutter = File.join(project_dir, ".fvm", "flutter_sdk", "bin", windows_host? ? "flutter.bat" : "flutter")
+        return nil unless File.executable?(flutter)
+
+        tools_from_flutter_bin(flutter)
+      rescue StandardError => e
+        warn "FVM bootstrap failed: #{e.class}: #{e.message}"
+        nil
+      end
+
+      def ensure_fvm_available(client_dir: nil)
+        fvm = which_command("fvm")
+        return fvm if fvm
+
+        dart = which_command("dart")
+        unless dart
+          sdk_root = ensure_flutter_sdk_downloaded(client_dir: client_dir)
+          dart = sdk_root ? File.join(sdk_root, "bin", windows_host? ? "dart.bat" : "dart") : nil
+        end
+        return nil unless dart && File.executable?(dart)
+
+        system(dart, "pub", "global", "activate", "fvm", out: File::NULL, err: File::NULL)
+        which_command("fvm")
+      end
+
+      def fvm_env
+        pub_bin = File.join(Dir.home, ".pub-cache", "bin")
+        { "PATH" => "#{pub_bin}#{File::PATH_SEPARATOR}#{ENV.fetch('PATH', '')}" }
+      end
+
+      def tools_from_flutter_bin(flutter_bin)
+        return nil unless File.executable?(flutter_bin)
+
+        bin_dir = File.dirname(flutter_bin)
+        dart = File.join(bin_dir, windows_host? ? "dart.bat" : "dart")
+        {
+          flutter: flutter_bin,
+          dart: (File.executable?(dart) ? dart : "dart"),
+          env: { "PATH" => "#{bin_dir}#{File::PATH_SEPARATOR}#{ENV.fetch('PATH', '')}" }
+        }
+      end
+
+      def ensure_flutter_sdk_downloaded(client_dir: nil)
+        release_info = resolve_flutter_release(client_dir: client_dir)
+        return nil unless release_info
+
+        release = release_info[:release]
+        host = release_info[:host]
+        archive = release.fetch("archive")
+        install_root = File.join(Dir.home, ".ruflet", "flutter", release.fetch("version"), host)
+        sdk_root = File.join(install_root, "flutter")
+        flutter_bin = File.join(sdk_root, "bin", windows_host? ? "flutter.bat" : "flutter")
+        return sdk_root if File.executable?(flutter_bin)
+
+        FileUtils.mkdir_p(install_root)
+        Dir.mktmpdir("ruflet-flutter-sdk-") do |tmpdir|
+          archive_path = File.join(tmpdir, File.basename(archive))
+          download_file("#{RELEASES_BASE}/#{archive}", archive_path)
+          extract_archive(archive_path, install_root)
+        end
+
+        return sdk_root if File.executable?(flutter_bin)
+
+        # Some archives may unpack into a different folder name.
+        guessed = Dir.glob(File.join(install_root, "**", windows_host? ? "flutter.bat" : "flutter"))
+          .map { |p| File.expand_path("../..", p) }
+          .find { |root| File.executable?(File.join(root, "bin", windows_host? ? "flutter.bat" : "flutter")) }
+        return guessed if guessed
+
+        nil
+      rescue StandardError => e
+        warn "Flutter auto-install failed: #{e.class}: #{e.message}"
+        nil
+      end
+
+      def resolve_flutter_release(client_dir: nil)
+        host = flutter_host
+        return nil unless host
+
+        manifest = fetch_releases_manifest(host)
+        return nil unless manifest
+
+        desired = desired_flutter_spec(client_dir: client_dir)
+        release = pick_release(
+          manifest,
+          version: desired[:version],
+          revision: desired[:revision],
+          channel: desired[:channel]
+        )
+        return nil unless release
+
+        { release: release, host: host }
+      end
+
+      def desired_flutter_version(client_dir: nil)
+        desired_flutter_spec(client_dir: client_dir)[:version] || DEFAULT_FLUTTER_CHANNEL
+      end
+
+      def desired_flutter_spec(client_dir: nil)
+        env = ENV["RUFLET_FLUTTER_VERSION"].to_s.strip
+        return { version: env, source: :env } unless env.empty?
+
+        fvm = parse_fvmrc(find_fvmrc(client_dir))
+        return { version: fvm, source: :fvmrc } if fvm
+
+        metadata = parse_flutter_metadata(find_flutter_metadata(client_dir))
+        return metadata.merge(source: :metadata) if metadata
+
+        { channel: DEFAULT_FLUTTER_CHANNEL, version: DEFAULT_FLUTTER_CHANNEL, source: :default }
+      end
+
+      def fvm_project_dir(client_dir: nil)
+        return client_dir if client_dir
+
+        cwd_fvmrc = find_fvmrc(nil)
+        return File.dirname(cwd_fvmrc) if cwd_fvmrc
+
+        File.join(Dir.home, ".ruflet", "fvm_project")
+      end
+
+      def existing_fvm_flutter_bin(project_dir)
+        flutter = File.join(project_dir, ".fvm", "flutter_sdk", "bin", windows_host? ? "flutter.bat" : "flutter")
+        return flutter if File.executable?(flutter)
+
+        nil
+      end
+
+      def find_fvmrc(client_dir)
+        candidates = []
+        candidates << File.join(client_dir, ".fvmrc") if client_dir
+        candidates << File.join(Dir.pwd, ".fvmrc")
+        candidates.find { |p| File.file?(p) }
+      end
+
+      def find_flutter_metadata(client_dir)
+        candidates = []
+        candidates << File.join(client_dir, ".metadata") if client_dir
+        repo_client = File.expand_path("../../../../../ruflet_client/.metadata", __dir__)
+        template_client = File.expand_path("../../../../../templates/ruflet_flutter_template/.metadata", __dir__)
+        candidates << repo_client
+        candidates << template_client
+        candidates.find { |path| File.file?(path) }
+      end
+
+      def parse_fvmrc(path)
+        return nil unless path && File.file?(path)
+
+        raw = File.read(path).strip
+        return nil if raw.empty?
+
+        if raw.start_with?("{")
+          json = JSON.parse(raw) rescue {}
+          val = json["flutter"] || json["flutterSdkVersion"] || json["flutter_version"]
+          return val.to_s.strip unless val.to_s.strip.empty?
+        end
+
+        raw
+      end
+
+      def parse_flutter_metadata(path)
+        return nil unless path && File.file?(path)
+
+        parsed = YAML.safe_load(File.read(path), aliases: true) || {}
+        version_info = parsed["version"]
+        return nil unless version_info.is_a?(Hash)
+
+        revision = version_info["revision"].to_s.strip
+        channel = version_info["channel"].to_s.strip
+        return nil if revision.empty?
+
+        {
+          revision: revision,
+          channel: channel.empty? ? DEFAULT_FLUTTER_CHANNEL : channel
+        }
+      rescue StandardError
+        nil
+      end
+
+      def fetch_releases_manifest(host)
+        url = "#{RELEASES_BASE}/releases_#{host}.json"
+        uri = URI(url)
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          req = Net::HTTP::Get.new(uri)
+          req["User-Agent"] = "ruflet-cli"
+          http.request(req)
+        end
+        return JSON.parse(response.body) if response.is_a?(Net::HTTPSuccess)
+
+        nil
+      end
+
+      def pick_release(manifest, version: nil, revision: nil, channel: nil)
+        releases = manifest.fetch("releases", [])
+        if revision
+          pinned = releases.find { |r| r["hash"] == revision }
+          return pinned if pinned
+          warn "Requested Flutter revision #{revision} not found for host #{flutter_host}; falling back."
+        end
+
+        if version
+          pinned = releases.find { |r| r["channel"] == "stable" && r["version"] == version }
+          return pinned if pinned
+          warn "Requested Flutter #{version} not found in stable releases; falling back to latest stable."
+        end
+
+        current = manifest.fetch("current_release", {})[(channel || "stable")]
+        if current
+          by_hash = releases.find { |r| r["hash"] == current }
+          return by_hash if by_hash
+        end
+
+        releases.reverse.find { |r| r["channel"] == (channel || "stable") } ||
+          releases.reverse.find { |r| r["channel"] == "stable" }
+      end
+
+      def flutter_host
+        os = RbConfig::CONFIG["host_os"]
+        if os.match?(/darwin/i)
+          return machine_arch.include?("arm") ? "macos_arm64" : "macos"
+        end
+        return "linux" if os.match?(/linux/i)
+        return "windows" if os.match?(/mswin|mingw|cygwin/i)
+
+        nil
+      end
+
+      def machine_arch
+        RbConfig::CONFIG["host_cpu"].to_s.downcase
+      end
+
+      def windows_host?
+        RbConfig::CONFIG["host_os"].match?(/mswin|mingw|cygwin/i)
+      end
+
+      def which_command(name)
+        exts = windows_host? ? ENV.fetch("PATHEXT", ".EXE;.BAT;.CMD").split(";") : [""]
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |dir|
+          exts.each do |ext|
+            candidate = File.join(dir, "#{name}#{ext}")
+            return candidate if File.file?(candidate) && File.executable?(candidate)
+          end
+        end
+        nil
+      end
+
+      def download_file(url, destination, limit: 5)
+        raise "Too many redirects while downloading #{url}" if limit <= 0
+
+        uri = URI(url)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          req = Net::HTTP::Get.new(uri)
+          req["User-Agent"] = "ruflet-cli"
+          http.request(req) do |res|
+            case res
+            when Net::HTTPSuccess
+              File.open(destination, "wb") { |f| res.read_body { |chunk| f.write(chunk) } }
+              return destination
+            when Net::HTTPRedirection
+              return download_file(res["location"], destination, limit: limit - 1)
+            else
+              raise "Download failed (#{res.code})"
+            end
+          end
+        end
+      end
+
+      def extract_archive(archive, destination)
+        if archive.end_with?(".zip")
+          if windows_host?
+            return system("powershell", "-NoProfile", "-Command", "Expand-Archive -Path '#{archive}' -DestinationPath '#{destination}' -Force")
+          end
+          return system("unzip", "-oq", archive, "-d", destination)
+        end
+
+        if archive.end_with?(".tar.xz") || archive.end_with?(".tar.gz") || archive.end_with?(".tgz")
+          return system("tar", "-xf", archive, "-C", destination)
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/ruflet/cli/new_command.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+
+module Ruflet
+  module CLI
+    module NewCommand
+      CLIENT_EXTENSION_MAP = {
+        "ads" => { package: "flet_ads", alias: "ruflet_ads" },
+        "audio" => { package: "flet_audio", alias: "ruflet_audio" },
+        "audio_recorder" => { package: "flet_audio_recorder", alias: "ruflet_audio_recorder" },
+        "camera" => { package: "flet_camera", alias: "ruflet_camera" },
+        "charts" => { package: "flet_charts", alias: "ruflet_charts" },
+        "code_editor" => { package: "flet_code_editor", alias: "ruflet_code_editor" },
+        "color_pickers" => { package: "flet_color_pickers", alias: "ruflet_color_picker" },
+        "datatable2" => { package: "flet_datatable2", alias: "ruflet_datatable2" },
+        "flashlight" => { package: "flet_flashlight", alias: "ruflet_flashlight" },
+        "geolocator" => { package: "flet_geolocator", alias: "ruflet_geolocator" },
+        "lottie" => { package: "flet_lottie", alias: "ruflet_lottie" },
+        "map" => { package: "flet_map", alias: "ruflet_map" },
+        "permission_handler" => { package: "flet_permission_handler", alias: "ruflet_permission_handler" },
+        "secure_storage" => { package: "flet_secure_storage", alias: "ruflet_secure_storage" },
+        "video" => { package: "flet_video", alias: "ruflet_video" },
+        "webview" => { package: "flet_webview", alias: "ruflet_webview" }
+      }.freeze
+
+      def command_new(args)
+        app_name = args.shift
+        if app_name.nil? || app_name.strip.empty?
+          warn "Usage: ruflet new <appname>"
+          return 1
+        end
+
+        root = File.expand_path(app_name, Dir.pwd)
+        if Dir.exist?(root)
+          warn "Directory already exists: #{root}"
+          return 1
+        end
+
+        FileUtils.mkdir_p(root)
+        File.write(File.join(root, "main.rb"), format(Ruflet::CLI::MAIN_TEMPLATE, app_title: humanize_name(File.basename(root))))
+        File.write(File.join(root, "Gemfile"), Ruflet::CLI::GEMFILE_TEMPLATE)
+        File.write(File.join(root, "README.md"), format(Ruflet::CLI::README_TEMPLATE, app_name: File.basename(root)))
+        write_default_ruflet_config(root, File.basename(root))
+        copy_ruflet_client_template(root)
+        configure_ruflet_client(root)
+
+        project_name = File.basename(root)
+        puts "Run:"
+        puts "  cd #{project_name}"
+        puts "  bundle install"
+        puts "  bundle exec ruflet run main.rb"
+        puts
+        puts "Client template:"
+        puts "  cd ruflet_client"
+        puts "  flutter pub get"
+        puts "  flutter run"
+        0
+      end
+
+      private
+
+      def copy_ruflet_client_template(root)
+        template_root = File.expand_path("../../../../../ruflet_client", __dir__)
+        return unless Dir.exist?(template_root)
+
+        target = File.join(root, "ruflet_client")
+        FileUtils.cp_r(template_root, target)
+        prune_client_template(target)
+      end
+
+      def prune_client_template(target)
+        paths = %w[
+          .dart_tool
+          .idea
+          build
+          ios/Pods
+          ios/.symlinks
+          ios/Podfile.lock
+          macos/Pods
+          macos/Podfile.lock
+          android/.gradle
+          android/.kotlin
+          android/local.properties
+        ]
+        paths.each do |path|
+          full = File.join(target, path)
+          FileUtils.rm_rf(full) if File.exist?(full)
+        end
+      end
+
+      def write_default_ruflet_config(root, app_name)
+        File.write(File.join(root, "ruflet.yaml"), <<~YAML)
+          app:
+            name: #{app_name}
+            # Optional production client endpoint used by `ruflet build`.
+            # Example: https://api.example.com
+            ruflet_client_url: ""
+
+          # Source of truth for Flutter client extensions/plugins.
+          # Examples: camera, video, audio, flashlight, webview, map
+          services: []
+
+          # Build assets configuration consumed by `ruflet build`.
+          # Paths are relative to this file unless absolute.
+          assets:
+            dir: assets
+            splash_screen: assets/splash.png
+            icon_launcher: assets/icon.png
+
+          build:
+            splash_color: "#FFFFFF"
+            splash_dark_color: "#0B0B0B"
+            icon_background: "#FFFFFF"
+            theme_color: "#FFFFFF"
+        YAML
+      end
+
+      def configure_ruflet_client(root)
+        config_path = File.join(root, "ruflet.yaml")
+        return unless File.file?(config_path)
+
+        config = YAML.safe_load(File.read(config_path), aliases: true) || {}
+        extension_keys = extract_extension_keys(config)
+        extension_packages = extension_keys.filter_map { |key| CLIENT_EXTENSION_MAP[key]&.fetch(:package) }.uniq
+        extension_aliases = extension_keys.filter_map { |key| CLIENT_EXTENSION_MAP[key]&.fetch(:alias) }.uniq
+
+        client_dir = File.join(root, "ruflet_client")
+        apply_client_manifest!(client_dir, extension_packages, extension_aliases)
+      rescue StandardError => e
+        warn "Failed to configure ruflet_client from ruflet.yaml: #{e.class}: #{e.message}"
+      end
+
+      def extract_extension_keys(config)
+        from_services = Array(config["services"])
+
+        from_services
+          .map { |v| normalize_extension_key(v) }
+          .compact
+          .uniq
+      end
+
+      def normalize_extension_key(value)
+        key = value.to_s.strip.downcase
+        return nil if key.empty?
+
+        key.tr!("-", "_")
+        key.gsub!(/\A(flet_)+/, "")
+        key.gsub!(/\Aservice_/, "")
+        key.gsub!(/\Acontrol_/, "")
+        key = "file_picker" if key == "filepicker"
+        key
+      end
+
+      def apply_client_manifest!(client_dir, extension_packages, extension_aliases)
+        return unless Dir.exist?(client_dir)
+
+        pubspec_path = File.join(client_dir, "pubspec.yaml")
+        main_path = File.join(client_dir, "lib", "main.dart")
+        prune_client_pubspec(pubspec_path, extension_packages) if File.file?(pubspec_path)
+        prune_client_main(main_path, extension_aliases) if File.file?(main_path)
+      end
+
+      def prune_client_pubspec(path, selected_packages)
+        data = YAML.safe_load(File.read(path), aliases: true) || {}
+        deps = (data["dependencies"] || {}).dup
+
+        deps.keys.each do |name|
+          next unless name.start_with?("flet_")
+          next if name == "flet"
+          next if selected_packages.include?(name)
+
+          deps.delete(name)
+        end
+
+        data["dependencies"] = deps
+        File.write(path, YAML.dump(data))
+      end
+
+      def prune_client_main(path, selected_aliases)
+        lines = File.readlines(path)
+        alias_to_package = {}
+
+        lines.each do |line|
+          match = line.match(%r{\Aimport 'package:(flet_[^/]+)/\1\.dart' as ([a-zA-Z0-9_]+);})
+          next unless match
+
+          alias_to_package[match[2]] = match[1]
+        end
+
+        kept = lines.select do |line|
+          import_match = line.match(%r{\Aimport 'package:(flet_[^/]+)/\1\.dart' as ([a-zA-Z0-9_]+);})
+          if import_match
+            package_name = import_match[1]
+            next true if package_name == "flet"
+            next true if selected_aliases.include?(import_match[2])
+            next false
+          end
+
+          extension_match = line.match(/\A\s*([a-zA-Z0-9_]+)\.Extension\(\),\s*\z/)
+          if extension_match
+            extension_alias = extension_match[1]
+            package_name = alias_to_package[extension_alias]
+            next true if package_name.nil? # non-Flet extension lines
+            next true if selected_aliases.include?(extension_alias)
+            next false
+          end
+
+          true
+        end
+
+        File.write(path, kept.join)
+      end
+
+      def humanize_name(name)
+        name.to_s.gsub(/[_-]+/, " ").split.map(&:capitalize).join(" ")
+      end
+    end
+  end
+end