ruflet 0.0.21 → 0.0.23

data/lib/ruflet/cli/new_command.rb

@@ -13,23 +13,25 @@ module Ruflet
       RUNTIME_REPO_URL = ENV.fetch("RUFLET_RUNTIME_REPO_URL", "https://github.com/AdamMusa/ruflet.git")
 
       CLIENT_EXTENSION_MAP = {
-        "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" },
+        "ads" => { package: "ruflet_ads", alias: "ruflet_ads" },
+        "audio" => { package: "ruflet_audio", alias: "ruflet_audio" },
+        "audio_recorder" => { package: "ruflet_audio_recorder", alias: "ruflet_audio_recorder" },
+        "camera" => { package: "ruflet_camera", alias: "ruflet_camera" },
+        "charts" => { package: "ruflet_charts", alias: "ruflet_charts" },
+        "code_editor" => { package: "ruflet_code_editor", alias: "ruflet_code_editor" },
+        "color_pickers" => { package: "ruflet_color_pickers", alias: "ruflet_color_picker" },
+        "datatable2" => { package: "ruflet_datatable2", alias: "ruflet_datatable2" },
+        "flashlight" => { package: "ruflet_flashlight", alias: "ruflet_flashlight" },
+        "geolocator" => { package: "ruflet_geolocator", alias: "ruflet_geolocator" },
+        "lottie" => { package: "ruflet_lottie", alias: "ruflet_lottie" },
+        "map" => { package: "ruflet_map", alias: "ruflet_map" },
+        "permission_handler" => { package: "ruflet_permission_handler", alias: "ruflet_permission_handler" },
         "qrcode_scanner" => { package: "ruflet_qrcode_scanner", alias: "ruflet_qrcode_scanner" },
-        "rive" => { package: "flet_rive", alias: "ruflet_rive" },
-        "secure_storage" => { package: "flet_secure_storage", alias: "ruflet_secure_storage" },
-        "video" => { package: "flet_video", alias: "ruflet_video" },
-        "webview" => { package: "flet_webview", alias: "ruflet_webview" }
+        "rive" => { package: "ruflet_rive", alias: "ruflet_rive" },
+        "secure_storage" => { package: "ruflet_secure_storage", alias: "ruflet_secure_storage" },
+        "spinkit" => { package: "ruflet_spinkit", alias: "ruflet_spinkit" },
+        "video" => { package: "ruflet_video", alias: "ruflet_video" },
+        "webview" => { package: "ruflet_webview", alias: "ruflet_webview" }
       }.freeze
 
       def command_new(args)
@@ -72,7 +74,16 @@ module Ruflet
         target = hidden_flutter_client_dir(root)
         FileUtils.mkdir_p(File.dirname(target))
         FileUtils.rm_rf(target)
-        FileUtils.cp_r(template_root, target)
+        # `target` is the Flutter project root, not a directory that contains
+        # the template root. Copying a source directory onto a target that was
+        # already created by FileUtils can produce
+        # `build/client/ruflet_flutter_template/...`, leaving `build/client`
+        # without pubspec.yaml and making Flutter reject it as a project.
+        FileUtils.mkdir_p(target)
+        Dir.children(template_root).each do |entry|
+          copy_client_template_entry(
+            template_root, target, entry)
+        end
         prune_client_template(target)
         write_client_template_revision(target, installed_template_revision(template_root))
       end
@@ -261,6 +272,43 @@ module Ruflet
         end
       end
 
+      def copy_client_template_entry(template_root, target, relative)
+        return if generated_client_template_path?(relative)
+
+        source = File.join(template_root, relative)
+        destination = File.join(target, relative)
+        stat = File.lstat(source)
+        if stat.symlink?
+          FileUtils.mkdir_p(File.dirname(destination))
+          FileUtils.ln_s(File.readlink(source), destination)
+        elsif stat.directory?
+          FileUtils.mkdir_p(destination)
+          Dir.children(source).each do |entry|
+            copy_client_template_entry(
+              template_root, target, File.join(relative, entry))
+          end
+        else
+          FileUtils.mkdir_p(File.dirname(destination))
+          FileUtils.cp(source, destination, preserve: true)
+        end
+      end
+
+      def generated_client_template_path?(relative)
+        components = relative.split(File::SEPARATOR)
+        generated_components = %w[
+          .build .cache .claude .dart_tool .git .idea .swiftpm .symlinks
+          build DerivedData Pods xcuserdata
+        ]
+        return true if components.any? { |component| generated_components.include?(component) }
+        return true if components.any? { |component| component.start_with?(".build-") }
+
+        generated_files = %w[
+          .DS_Store Package.resolved Podfile.lock local.properties
+          pubspec_overrides.yaml
+        ]
+        generated_files.include?(components.last) || components.last.end_with?(".xcuserstate")
+      end
+
       def write_default_ruflet_config(root, app_name)
         File.write(File.join(root, "ruflet.yaml"), <<~YAML)
           app:

data/lib/ruflet/cli/run_command.rb

@@ -11,23 +11,23 @@ require "net/http"
 require "uri"
 require "thread"
 require "io/console"
+require "open3"
 require "time"
 
 module Ruflet
   module CLI
     module RunCommand
-      CLIENT_CHANNEL_MANIFEST = "ruflet_client-manifest.json"
+      # Release assets were published as ruflet_client-* before the preview
+      # client became Ruflet Explorer. Ask for the current names, but keep
+      # recognising the old ones so an existing release still resolves.
+      ASSET_PREFIX = "ruflet_explorer"
+      LEGACY_ASSET_PREFIX = "ruflet_client"
+      CLIENT_CHANNEL_MANIFEST = "#{ASSET_PREFIX}-manifest.json"
+      LEGACY_CLIENT_CHANNEL_MANIFEST = "#{LEGACY_ASSET_PREFIX}-manifest.json"
       DEFAULT_CLIENT_UPDATE_INTERVAL = 6 * 60 * 60
 
       def command_run(args)
-        options = { target: "mobile", requested_port: 8550, reload: true }
-        parser = OptionParser.new do |o|
-          o.on("--web") { options[:target] = "web" }
-          o.on("--desktop") { options[:target] = "desktop" }
-          o.on("--port PORT", Integer) { |v| options[:requested_port] = v }
-          o.on("--no-reload") { options[:reload] = false }
-        end
-        parser.parse!(args)
+        options = parse_run_options(args)
 
         script_token = args.shift || "main"
         script_path = resolve_script(script_token)
@@ -87,7 +87,7 @@ module Ruflet
           return status.success? ? 0 : (status.exitstatus || 1) unless run_state[:restart]
 
           # Full restart requested ("R"): respawn the backend; connected
-          # clients reconnect and re-register on their own (Flet-style).
+          # clients reconnect and re-register on their own (Ruflet-style).
           run_state[:restart] = false
           puts "Restarting app..."
           started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -125,6 +125,18 @@ module Ruflet
 
       private
 
+      def parse_run_options(args)
+        options = { target: "mobile", requested_port: 8550, reload: true }
+        parser = OptionParser.new do |o|
+          o.on("--web") { options[:target] = "web" }
+          o.on("--desktop") { options[:target] = "desktop" }
+          o.on("--port PORT", Integer) { |v| options[:requested_port] = v }
+          o.on("--no-reload") { options[:reload] = false }
+        end
+        parser.parse!(args)
+        options
+      end
+
       def build_runtime_command(script_path, gemfile_path:, env:, reload: false)
         entry_script = script_path
         if reload
@@ -399,8 +411,8 @@ module Ruflet
         nil
       end
 
-      def launch_desktop_client(url)
-        cmd = detect_desktop_client_command(url)
+      def launch_desktop_client(url, root: nil)
+        cmd = detect_desktop_client_command(url, root: root)
         unless cmd
           warn "Desktop client executable not found."
           warn "Set RUFLET_CLIENT_DIR to your client path."
@@ -456,11 +468,13 @@ module Ruflet
           .find { |path| executable_file?(path) }
       end
 
-      def detect_desktop_client_command(url)
-        root = ENV["RUFLET_CLIENT_DIR"]
-        root = File.expand_path("ruflet_client", Dir.pwd) if root.to_s.strip.empty?
-        root = nil unless Dir.exist?(root)
-        root ||= ensure_prebuilt_client(desktop: true)
+      def detect_desktop_client_command(url, root: nil)
+        unless root
+          root = ENV["RUFLET_CLIENT_DIR"]
+          root = File.expand_path("ruflet_client", Dir.pwd) if root.to_s.strip.empty?
+          root = nil unless Dir.exist?(root)
+          root ||= ensure_prebuilt_client(desktop: true)
+        end
         return nil unless root && Dir.exist?(root)
 
         host_os = RbConfig::CONFIG["host_os"]
@@ -530,13 +544,15 @@ module Ruflet
         FileUtils.mkdir_p(cache_root)
 
         wanted_assets = []
-        wanted_assets << { kind: :web, name: "ruflet_client-web.tar.gz" } if web
+        wanted_assets << { kind: :web, name: "#{ASSET_PREFIX}-web.tar.gz" } if web
         if desktop
           desktop_asset = desktop_asset_name_for(platform)
           return nil if desktop_asset.nil?
           wanted_assets << { kind: :desktop, name: desktop_asset, platform: platform }
         end
-        cache_ready = wanted_assets.empty? || prebuilt_assets_present?(cache_root, web: web, desktop: desktop, platform: platform)
+        cache_ready = wanted_assets.empty? || prebuilt_assets_present?(
+          cache_root, web: web, desktop: desktop, platform: platform
+        )
         release = nil
         if !force && cache_ready
           ensure_client_manifest(cache_root, platform: platform)
@@ -573,7 +589,10 @@ module Ruflet
             puts "Downloading prebuilt client asset: #{resolved_name}"
             archive_path = File.join(tmpdir, resolved_name)
             download_file(asset.fetch("browser_download_url"), archive_path)
-            subdir = wanted[:kind] == :web ? "web" : "desktop"
+            subdir = case wanted[:kind]
+            when :web then "web"
+            when :desktop then "desktop"
+            end
             target = File.join(cache_root, subdir)
             FileUtils.rm_rf(target) if force && Dir.exist?(target)
             FileUtils.mkdir_p(target)
@@ -591,7 +610,9 @@ module Ruflet
           end
         end
 
-        if prebuilt_assets_present?(cache_root, web: web, desktop: desktop, platform: platform)
+        if prebuilt_assets_present?(
+          cache_root, web: web, desktop: desktop, platform: platform
+        )
           write_client_manifest(cache_root, platform: platform, release: release, assets: installed_assets)
           return cache_root
         end
@@ -647,9 +668,9 @@ module Ruflet
 
       def desktop_asset_name_for(platform)
         case platform
-        when "macos" then "ruflet_client-macos-universal.zip"
-        when "linux" then "ruflet_client-linux-x64.tar.gz"
-        when "windows" then "ruflet_client-windows-x64.zip"
+        when "macos" then "#{ASSET_PREFIX}-macos-universal.zip"
+        when "linux" then "#{ASSET_PREFIX}-linux-x64.tar.gz"
+        when "windows" then "#{ASSET_PREFIX}-windows-x64.zip"
         end
       end
 
@@ -659,7 +680,7 @@ module Ruflet
 
       def fetch_release_for_version(wanted_assets: [])
         releases = []
-        channel = client_release_channel
+        channel = client_release_channel(wanted_assets: wanted_assets)
         if channel != "stable"
           rolling = release_by_tag(channel)
           releases << rolling if rolling && rolling_release_complete?(rolling)
@@ -670,13 +691,22 @@ module Ruflet
         releases.compact.find { |release| release_has_wanted_assets?(release, wanted_assets) }
       end
 
-      def client_release_channel
-        value = ENV.fetch("RUFLET_CLIENT_CHANNEL", "prebuild-main").to_s.strip
-        value.empty? ? "prebuild-main" : value
+      def client_release_channel(wanted_assets: [])
+        default_channel = "prebuild-main"
+        value = ENV.fetch("RUFLET_CLIENT_CHANNEL", default_channel).to_s.strip
+        value.empty? ? default_channel : value
       end
 
       def rolling_release_complete?(release)
-        release.fetch("assets", []).any? { |asset| asset["name"] == CLIENT_CHANNEL_MANIFEST }
+        !channel_manifest_asset(release).nil?
+      end
+
+      # The manifest is written last, so its presence means the run finished
+      # uploading every platform. Accept either naming for releases published
+      # before the assets were renamed.
+      def channel_manifest_asset(release)
+        names = [CLIENT_CHANNEL_MANIFEST, LEGACY_CLIENT_CHANNEL_MANIFEST]
+        release.fetch("assets", []).find { |asset| names.include?(asset["name"]) }
       end
 
       def release_has_wanted_assets?(release, wanted_assets)
@@ -687,8 +717,7 @@ module Ruflet
       end
 
       def client_release_revision(release)
-        marker = release.fetch("assets", []).find { |asset| asset["name"] == CLIENT_CHANNEL_MANIFEST }
-        source = marker || release
+        source = channel_manifest_asset(release) || release
         [source["id"], source["updated_at"] || source["published_at"], source["size"]].compact.join(":")
       end
 
@@ -750,7 +779,7 @@ module Ruflet
 
       def release_asset_matches?(name, kind, platform)
         n = name.to_s.downcase
-        return false unless n.include?("ruflet_client")
+        return false unless n.include?(ASSET_PREFIX) || n.include?(LEGACY_ASSET_PREFIX)
 
         if kind == :web
           return n.include?("web") && (n.end_with?(".tar.gz") || n.end_with?(".zip"))
@@ -758,7 +787,10 @@ module Ruflet
 
         case platform
         when "macos"
-          n.include?("macos") && n.end_with?(".zip")
+          # Releases cut before the experimental channel was retired still carry
+          # ruflet_explorer-macos-experimental-universal.zip. Installing that as
+          # the desktop client would hand back the wrong app, so skip it.
+          n.include?("macos") && !n.include?("experimental") && n.end_with?(".zip")
         when "linux"
           n.include?("linux") && (n.end_with?(".tar.gz") || n.end_with?(".tgz"))
         when "windows"

data/lib/ruflet/cli.rb

@@ -69,11 +69,16 @@ module Ruflet
           ruflet run [scriptname|path] [--web|--desktop] [--port PORT] [--no-reload]
           ruflet update [web|desktop|all] [--check] [--force] [--platform PLATFORM]
           ruflet debug [scriptname|path]
-          ruflet build <apk|android|ios|aab|web|macos|windows|linux> [--self] [--verbose]
+          ruflet build <apk|android|ios|ipa|aab|web|macos|windows|linux> [--lite|--full|--self] [--verbose]
           ruflet install [--device DEVICE_ID] [--verbose]
           ruflet devices
           ruflet emulators
           ruflet doctor [--fix] [--verbose]
+
+        Build profiles:
+          --self           Self-contained lite build (default profile)
+          --self --full    Self-contained full CRuby build with locked project gems
+          --full           Also implies --self
       HELP
     end
 

data/lib/ruflet/hot_reload.rb

@@ -111,7 +111,29 @@ module Ruflet
       end
 
       def watched_files
-        files = Dir.glob(File.join(@watch_root, "**", "*.rb")).reject { |path| excluded_path?(path) }
+        files = []
+        directories = [@watch_root]
+        until directories.empty?
+          directory = directories.pop
+          begin
+            Dir.each_child(directory) do |name|
+              # Prune before descending: generated Flutter/build trees can
+              # contain thousands of files and are never reload inputs.
+              next if name.start_with?(".") || EXCLUDED_DIRECTORIES.include?(name)
+
+              path = File.join(directory, name)
+              if File.directory?(path)
+                directories << path unless File.symlink?(path)
+              elsif name.end_with?(".rb") && File.file?(path)
+                files << path
+              end
+            end
+          rescue Errno::ENOENT, Errno::ENOTDIR, Errno::EACCES
+            # Editors/build tools may remove a directory during a snapshot.
+            next
+          end
+        end
+        files.sort!
         files << @script unless files.include?(@script) || !File.file?(@script)
         files
       end
@@ -158,15 +180,6 @@ module Ruflet
         $LOADED_FEATURES.reject! { |feature| watched.key?(feature) }
       end
 
-      def excluded_path?(path)
-        relative = path.delete_prefix("#{@watch_root}#{File::SEPARATOR}")
-        return false if relative == path
-
-        relative.split(File::SEPARATOR).any? do |component|
-          component.start_with?(".") || EXCLUDED_DIRECTORIES.include?(component)
-        end
-      end
-
       def file_snapshot
         snapshot = {}
         watched_files.each do |path|

data/lib/ruflet/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruflet
-  VERSION = "0.0.21" unless const_defined?(:VERSION)
+  VERSION = "0.0.23" unless const_defined?(:VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.0.23
 platform: ruby
 authors:
 - AdamMusa