ruflet 0.0.8 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 383b294c6573d456634109721dbf8b8ba8394f45fa869e57e3114a6d74c883fe
-  data.tar.gz: b17888f9fe0d083f0ca0a008de04d486bbe483ef74213e09ab1cdbc626ceeba1
+  metadata.gz: 23cfe984101f494774c2ad9c91c4fd26e7e22b0041c3be62fe9d8b4ff952b865
+  data.tar.gz: 921d636ba6c5a1428ff5354772d255971a03f2dc2e2f635b95c6108c8fbcdefc
 SHA512:
-  metadata.gz: b1960be12808dcc6b7d36335e4fe1e59496017392efeb59af8135d2a25558f6b1c5dfedd31bd0b594a3cd445483ca5ba64fa7d59a250da8070e2401763c561fb
-  data.tar.gz: c0c09817075879c5ac9c767cdf5c9a6ef1725340961cc0488fb72bc76a8a405152c5b6e836e215a01063731c67740ba27cd769fe0145c17d5935b56386b927af
+  metadata.gz: 4d2344631fd97d318f6a8d10452cfec629302e79738fcce68f494f355383ed11f5d32a8b23c8988de3fb8646bd86296ac5cee8967a684e4674dafc4da20ad721
+  data.tar.gz: 050ffaebab43e40fdde94285bc991b7c5a566f5fb025a31290ca4c911659d2577f1e4ca8a3d8c8f12e89971e6221f14d685d9fd7c35f2bba9c1f16cfb15dc1c4

data/bin/ruflet

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/ruflet_cli"
+
+exit Ruflet::CLI.run(ARGV)

data/lib/ruflet/cli/build_command.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "uri"
+require "yaml"
+
+module Ruflet
+  module CLI
+    module BuildCommand
+      include FlutterSdk
+      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_build(args)
+        platform = (args.shift || "").downcase
+        if platform.empty?
+          warn "Usage: ruflet build <apk|android|ios|aab|web|macos|windows|linux>"
+          return 1
+        end
+
+        flutter_cmd = flutter_build_command(platform)
+        unless flutter_cmd
+          warn "Unsupported build target: #{platform}"
+          return 1
+        end
+
+        client_dir = detect_flutter_client_dir
+        unless client_dir
+          warn "Could not find Flutter client directory."
+          warn "Set RUFLET_CLIENT_DIR or place client at ./ruflet_client"
+          return 1
+        end
+
+        config = load_ruflet_config
+        tools = ensure_flutter!("build", client_dir: client_dir)
+        ok = prepare_flutter_client(client_dir, tools: tools, config: config)
+        return 1 unless ok
+
+        build_args = [*flutter_cmd, *args]
+        client_url = configured_client_url(config)
+        if client_url
+          build_args += ["--dart-define", "RUFLET_CLIENT_URL=#{client_url}"]
+        end
+
+        ok = system(tools[:env], tools[:flutter], *build_args, chdir: client_dir)
+        ok ? 0 : 1
+      end
+
+      private
+
+      def detect_flutter_client_dir
+        env_dir = ENV["RUFLET_CLIENT_DIR"]
+        return env_dir if env_dir && Dir.exist?(env_dir)
+
+        local = File.expand_path("ruflet_client", Dir.pwd)
+        return local if Dir.exist?(local)
+
+        template = File.expand_path("templates/ruflet_flutter_template", Dir.pwd)
+        return template if Dir.exist?(template)
+
+        nil
+      end
+
+      def prepare_flutter_client(client_dir, tools:, config:)
+        apply_service_extension_config(client_dir, config)
+        asset_flags = apply_build_config(client_dir, config)
+        if asset_flags[:error]
+          warn asset_flags[:error]
+          return false
+        end
+        unless system(tools[:env], tools[:flutter], "pub", "get", chdir: client_dir)
+          warn "flutter pub get failed"
+          return false
+        end
+
+        if asset_flags[:has_splash]
+          unless system(tools[:env], tools[:dart], "run", "flutter_native_splash:create", chdir: client_dir)
+            warn "flutter_native_splash failed"
+            return false
+          end
+        end
+
+        if asset_flags[:has_icon]
+          unless system(tools[:env], tools[:dart], "run", "flutter_launcher_icons", chdir: client_dir)
+            warn "flutter_launcher_icons failed"
+            return false
+          end
+        end
+
+        true
+      end
+
+      def configured_client_url(config)
+        candidates = [
+          config["ruflet_client_url"],
+          (config["app"].is_a?(Hash) ? config["app"]["ruflet_client_url"] : nil)
+        ]
+        raw = candidates.find { |v| !v.to_s.strip.empty? }
+        return nil if raw.nil?
+
+        value = raw.to_s.strip
+        uri = URI.parse(value)
+        return nil unless %w[http https ws wss].include?(uri.scheme)
+        return nil if uri.host.to_s.strip.empty?
+
+        value
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def load_ruflet_config
+        config_path = ENV["RUFLET_CONFIG"] || "ruflet.yaml"
+        unless File.file?(config_path)
+          alt = "ruflet.yml"
+          config_path = alt if File.file?(alt)
+        end
+        return {} unless File.file?(config_path)
+
+        YAML.safe_load(File.read(config_path), aliases: true) || {}
+      rescue StandardError => e
+        warn "Failed to load ruflet config: #{e.class}: #{e.message}"
+        {}
+      end
+
+      def apply_build_config(client_dir, config = {})
+        config_path = ENV["RUFLET_CONFIG"] || (File.file?("ruflet.yaml") ? "ruflet.yaml" : "ruflet.yml")
+        config_present = File.file?(config_path)
+        build = config["build"] || {}
+        assets = config["assets"] || {}
+        config_dir = config_present ? File.dirname(File.expand_path(config_path)) : Dir.pwd
+
+        assets_root = build["assets_dir"] || assets["dir"] || config["assets_dir"] || "assets"
+        assets_root = File.expand_path(assets_root, config_dir)
+
+        resolve_asset = lambda do |path|
+          return nil if path.nil? || path.to_s.strip.empty?
+          full = File.expand_path(path.to_s, config_dir)
+          return full if File.file?(full)
+
+          rails_full = File.expand_path(File.join("app", path.to_s), config_dir)
+          return rails_full if File.file?(rails_full)
+
+          nil
+        end
+
+        splash_defined = key_defined?(build, "splash_screen") || key_defined?(assets, "splash_screen") || key_defined?(config, "splash_screen")
+        icon_defined = key_defined?(build, "icon_launcher") || key_defined?(assets, "icon_launcher") || key_defined?(config, "icon_launcher")
+
+        splash = resolve_asset.call(build["splash_screen"] || assets["splash_screen"] || config["splash_screen"])
+        splash_dark = resolve_asset.call(build["splash_dark"] || build["splash_dark_image"] || assets["splash_dark"])
+        icon = resolve_asset.call(build["icon_launcher"] || assets["icon_launcher"] || config["icon_launcher"])
+        icon_android = resolve_asset.call(build["icon_android"] || assets["icon_android"])
+        icon_ios = resolve_asset.call(build["icon_ios"] || assets["icon_ios"])
+        icon_web = resolve_asset.call(build["icon_web"] || assets["icon_web"])
+        icon_windows = resolve_asset.call(build["icon_windows"] || assets["icon_windows"])
+        icon_macos = resolve_asset.call(build["icon_macos"] || assets["icon_macos"])
+
+        splash_color = build["splash_color"]
+        splash_dark_color = build["splash_dark_color"] || build["splash_color_dark"]
+        icon_background = build["icon_background"]
+        theme_color = build["theme_color"]
+
+        assets_dir = File.join(client_dir, "assets")
+        FileUtils.mkdir_p(assets_dir)
+
+        copy_asset = lambda do |src, dest|
+          return unless src
+          FileUtils.cp(src, File.join(assets_dir, dest))
+        end
+
+        copy_asset.call(splash, "splash.png")
+        copy_asset.call(splash_dark, "splash_dark.png")
+        copy_asset.call(icon, "icon.png")
+        copy_asset.call(icon_android, "icon_android.png")
+        copy_asset.call(icon_ios, "icon_ios.png")
+        copy_asset.call(icon_web, "icon_web.png")
+        if icon_windows
+          ext = File.extname(icon_windows).downcase
+          copy_asset.call(icon_windows, ext == ".ico" ? "icon_windows.ico" : "icon_windows.png")
+        end
+        copy_asset.call(icon_macos, "icon_macos.png")
+
+        if splash_defined && splash.nil?
+          return { has_icon: false, has_splash: false, error: "build config error: splash_screen is set but file was not found" }
+        end
+        if icon_defined && icon.nil?
+          return { has_icon: false, has_splash: false, error: "build config error: icon_launcher is set but file was not found" }
+        end
+
+        pubspec_path = File.join(client_dir, "pubspec.yaml")
+        unless File.file?(pubspec_path)
+          return { has_icon: icon_defined && !icon.nil?, has_splash: splash_defined && !splash.nil?, error: nil }
+        end
+
+        if icon_defined && icon
+          update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path", "\"assets/icon.png\"", multiple: true)
+        end
+        update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path_android", "\"assets/icon_android.png\"", multiple: true) if icon_android
+        update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path_ios", "\"assets/icon_ios.png\"", multiple: true) if icon_ios
+        update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path_web", "\"assets/icon_web.png\"", multiple: true) if icon_web
+        if icon_windows
+          ext = File.extname(icon_windows).downcase
+          value = ext == ".ico" ? "\"assets/icon_windows.ico\"" : "\"assets/icon_windows.png\""
+          update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path_windows", value, multiple: true)
+        end
+        update_pubspec_value(pubspec_path, "flutter_launcher_icons", "image_path_macos", "\"assets/icon_macos.png\"", multiple: true) if icon_macos
+        update_pubspec_value(pubspec_path, "flutter_launcher_icons", "background_color", "\"#{icon_background}\"") if icon_background
+        update_pubspec_value(pubspec_path, "flutter_launcher_icons", "theme_color", "\"#{theme_color}\"") if theme_color
+
+        update_pubspec_value(pubspec_path, "flutter_native_splash", "image", "\"assets/splash.png\"") if splash_defined && splash
+        update_pubspec_value(pubspec_path, "flutter_native_splash", "image_dark", "\"assets/splash_dark.png\"") if splash_dark
+        update_pubspec_value(pubspec_path, "flutter_native_splash", "color", "\"#{splash_color}\"") if splash_color
+        update_pubspec_value(pubspec_path, "flutter_native_splash", "color_dark", "\"#{splash_dark_color}\"") if splash_dark_color
+
+        { has_icon: icon_defined && !icon.nil?, has_splash: splash_defined && !splash.nil?, error: nil }
+      end
+
+      def key_defined?(hash, key)
+        hash.is_a?(Hash) && (hash.key?(key) || hash.key?(key.to_sym))
+      end
+
+      def apply_service_extension_config(client_dir, config = {})
+        services = Array(config["services"])
+        extension_keys = services.map { |v| normalize_extension_key(v) }.compact.uniq
+        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
+
+        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 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
+      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?
+            next true if selected_aliases.include?(extension_alias)
+            next false
+          end
+
+          true
+        end
+
+        File.write(path, kept.join)
+      end
+
+      def update_pubspec_value(path, block, key, value, multiple: false)
+        lines = File.read(path).split("\n", -1)
+        out = []
+        in_block = false
+        replaced = false
+        block_indent = nil
+        lines.each do |line|
+          if line.start_with?("#{block}:")
+            in_block = true
+            block_indent = line[/^\s*/] + "  "
+            out << line
+            next
+          end
+
+          if in_block
+            if line =~ /^\S/ && !line.start_with?("#{block}:")
+              unless replaced
+                out << "#{block_indent}#{key}: #{value}"
+                replaced = true
+              end
+              in_block = false
+            else
+              if line.strip.start_with?("#{key}:")
+                indent = line[/^\s*/]
+                out << "#{indent}#{key}: #{value}"
+                replaced = true
+                next
+              end
+            end
+          end
+
+          out << line
+        end
+        if in_block && !replaced
+          out << "#{block_indent}#{key}: #{value}"
+        end
+        File.write(path, out.join("\n"))
+      end
+
+      def flutter_build_command(platform)
+        case platform
+        when "apk", "android"
+          ["build", "apk"]
+        when "aab", "appbundle"
+          ["build", "appbundle"]
+        when "ios"
+          ["build", "ios", "--no-codesign"]
+        when "web"
+          ["build", "web"]
+        when "macos"
+          ["build", "macos"]
+        when "windows"
+          ["build", "windows"]
+        when "linux"
+          ["build", "linux"]
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ruflet/cli/extra_command.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Ruflet
+  module CLI
+    module ExtraCommand
+      include FlutterSdk
+
+      def command_create(args)
+        command_new(args)
+      end
+
+      def command_doctor(args)
+        verbose = args.delete("--verbose") || args.delete("-v")
+        fix = args.delete("--fix")
+        client_dir = detect_client_dir
+        puts "Ruflet doctor"
+        puts "  Ruby: #{RUBY_VERSION}"
+        puts "  Flutter host target: #{flutter_host || 'unsupported'}"
+        if fix
+          tools = ensure_flutter!("doctor", client_dir: client_dir, auto_install: true)
+        else
+          tools = flutter_tools(client_dir: client_dir, auto_install: false)
+          unless tools
+            warn "  Flutter: missing"
+            warn "Run `ruflet doctor --fix` to install the host-platform Flutter SDK from .fvmrc."
+            return 1
+          end
+        end
+        puts "  Flutter: #{flutter_version_summary(tools)}"
+        ok = system(tools[:env], tools[:flutter], "doctor", *(verbose ? ["-v"] : []))
+        status = $?.exitstatus if $?
+        status ||= ok ? 0 : 1
+        status
+      end
+
+      def command_devices(args)
+        tools = ensure_flutter!("devices")
+        system(tools[:env], tools[:flutter], "devices", *args)
+        $?.exitstatus || 1
+      end
+
+      def command_emulators(args)
+        tools = ensure_flutter!("emulators")
+        action = nil
+        emulator_id = nil
+        verbose = false
+        parser = OptionParser.new do |o|
+          o.on("--create") { action = "create" }
+          o.on("--delete") { action = "delete" }
+          o.on("--start") { action = "start" }
+          o.on("--emulator ID") { |v| emulator_id = v }
+          o.on("-v", "--verbose") { verbose = true }
+        end
+        parser.parse!(args)
+
+        case action
+        when "start"
+          unless emulator_id
+            warn "Missing --emulator for start"
+            return 1
+          end
+          cmd = [tools[:flutter], "emulators", "--launch", emulator_id]
+          cmd << "-v" if verbose
+          system(tools[:env], *cmd)
+          $?.exitstatus || 1
+        when "create", "delete"
+          warn "ruflet emulators --#{action} is not implemented yet. Use your platform tools."
+          1
+        else
+          cmd = [tools[:flutter], "emulators"]
+          cmd << "-v" if verbose
+          system(tools[:env], *cmd)
+          $?.exitstatus || 1
+        end
+      end
+
+      def command_debug(args)
+        options = {
+          platform: nil,
+          device_id: nil,
+          release: false,
+          verbose: false,
+          web_renderer: nil
+        }
+        parser = OptionParser.new do |o|
+          o.on("--platform NAME") { |v| options[:platform] = v }
+          o.on("--device-id ID") { |v| options[:device_id] = v }
+          o.on("--release") { options[:release] = true }
+          o.on("-v", "--verbose") { options[:verbose] = true }
+          o.on("--web-renderer NAME") { |v| options[:web_renderer] = v }
+        end
+        parser.parse!(args)
+
+        options[:platform] ||= args.shift
+        client_dir = detect_client_dir
+        unless client_dir
+          warn "Could not find Flutter client directory."
+          warn "Set RUFLET_CLIENT_DIR or place client at ./ruflet_client"
+          warn "`ruflet debug` requires Flutter client source code."
+          warn "For prebuilt clients, use: `ruflet run --web` or `ruflet run --desktop`."
+          return 1
+        end
+
+        tools = ensure_flutter!("debug", client_dir: client_dir)
+        cmd = [tools[:flutter], "run"]
+        cmd << "--release" if options[:release]
+        cmd << "-v" if options[:verbose]
+        cmd += ["--web-renderer", options[:web_renderer]] if options[:web_renderer]
+
+        if options[:device_id]
+          cmd += ["-d", options[:device_id]]
+        else
+          case options[:platform]
+          when "web"
+            cmd += ["-d", "chrome"]
+          when "macos", "windows", "linux"
+            cmd += ["-d", options[:platform]]
+          when "ios", "android"
+            # let flutter pick the default device
+          end
+        end
+
+        system(tools[:env], *cmd, chdir: client_dir)
+        $?.exitstatus || 1
+      end
+
+      private
+
+      def detect_client_dir
+        env_dir = ENV["RUFLET_CLIENT_DIR"]
+        return env_dir if env_dir && Dir.exist?(env_dir)
+
+        local = File.expand_path("ruflet_client", Dir.pwd)
+        return local if Dir.exist?(local)
+
+        template = File.expand_path("templates/ruflet_flutter_template", Dir.pwd)
+        return template if Dir.exist?(template)
+
+        nil
+      end
+
+    end
+  end
+end