ruflet 0.0.20 → 0.0.22

data/lib/ruflet/cli/run_command.rb

@@ -11,23 +11,25 @@ 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"
+      EXPERIMENTAL_IOS_SIMULATOR_ASSET = "#{ASSET_PREFIX}-ios-experimental-simulator.zip"
+      EXPERIMENTAL_MACOS_ASSET = "#{ASSET_PREFIX}-macos-experimental-universal.zip"
       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)
@@ -37,6 +39,9 @@ module Ruflet
           return 1
         end
 
+        experimental_client = prepare_experimental_run_client(options)
+        return 1 if options[:experimental] && !experimental_client
+
         selected_port = resolve_backend_port(options[:target], requested_port: options[:requested_port])
         return 1 unless selected_port
         env = {
@@ -70,7 +75,10 @@ module Ruflet
 
         run_state = { child_pid: Process.spawn(env, *cmd, pgroup: true), restart: false }
         reload_input_thread = options[:reload] ? start_reload_input_thread(run_state) : nil
-        launched_client_pids = launch_target_client(options[:target], selected_port)
+        launched_client_pids = launch_target_client(
+          options[:target], selected_port,
+          experimental_client: experimental_client
+        )
         forward_signal = lambda do |signal|
           begin
             Process.kill(signal, -run_state[:child_pid])
@@ -87,7 +95,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 +133,72 @@ module Ruflet
 
       private
 
+      def parse_run_options(args)
+        options = { target: "mobile", requested_port: 8550, reload: true, experimental: false }
+        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 }
+          o.on("--experimental", "--exp") { options[:experimental] = true }
+        end
+        parser.parse!(args)
+        options
+      end
+
+      def prepare_experimental_run_client(options)
+        return nil unless options[:experimental]
+
+        if options[:target] == "web"
+          warn "run config error: --experimental/--exp is supported only for iOS and macOS"
+          return nil
+        end
+        unless host_platform_name == "macos"
+          warn "run config error: the experimental Apple client requires macOS"
+          return nil
+        end
+
+        if options[:target] == "desktop"
+          root = ensure_prebuilt_client(desktop_experimental: true, platform: "macos")
+          unless root
+            warn "Experimental macOS client is unavailable."
+            warn "The release must contain #{EXPERIMENTAL_MACOS_ASSET}."
+            return nil
+          end
+
+          return { kind: :desktop, root: root }
+        end
+
+        root = ensure_prebuilt_client(ios_experimental: true, platform: "macos")
+        unless root
+          warn "Experimental iOS Simulator client is unavailable."
+          warn "The release must contain #{EXPERIMENTAL_IOS_SIMULATOR_ASSET}."
+          return nil
+        end
+
+        app_bundle = experimental_ios_app_bundle(root)
+        simulator = booted_ios_simulator
+        unless simulator
+          warn "No booted iOS Simulator was found."
+          warn "Start the simulator you want to use, then run the command again."
+          return nil
+        end
+
+        bundle_identifier = ios_bundle_identifier(app_bundle)
+        if bundle_identifier.to_s.empty?
+          warn "Experimental client has no CFBundleIdentifier: #{app_bundle}"
+          return nil
+        end
+
+        {
+          kind: :ios_simulator,
+          app_bundle: app_bundle,
+          bundle_identifier: bundle_identifier,
+          simulator_udid: simulator.fetch("udid"),
+          simulator_name: simulator.fetch("name", simulator.fetch("udid"))
+        }
+      end
+
       def build_runtime_command(script_path, gemfile_path:, env:, reload: false)
         entry_script = script_path
         if reload
@@ -287,9 +361,20 @@ module Ruflet
         end
       end
 
-      def launch_target_client(target, port)
+      def launch_target_client(target, port, experimental_client: nil)
         wait_for_server_boot(port)
 
+        if experimental_client
+          if experimental_client[:kind] == :desktop
+            return launch_desktop_client(
+              "http://localhost:#{port}",
+              root: experimental_client.fetch(:root), experimental: true)
+          end
+
+          return launch_experimental_mobile_client(
+            "http://#{best_lan_host}:#{port}", client: experimental_client)
+        end
+
         case target
         when "web"
           launch_web_client(port)
@@ -300,13 +385,39 @@ module Ruflet
         end
       end
 
-      # The backend serves the web client on its own port, so the client loads
-      # and opens its websocket on the same origin. The explicit url parameter
-      # is kept because prebuilt production clients have no default URL and use
-      # it to select the websocket transport.
+      def launch_experimental_mobile_client(url, client:)
+        udid = client.fetch(:simulator_udid)
+        app_bundle = client.fetch(:app_bundle)
+        bundle_identifier = client.fetch(:bundle_identifier)
+
+        unless system("xcrun", "simctl", "install", udid, app_bundle)
+          warn "Failed to install the experimental client on #{client[:simulator_name] || udid}."
+          return []
+        end
+
+        launched = system(
+          { "SIMCTL_CHILD_RUFLET_URL" => url },
+          "xcrun", "simctl", "launch", "--terminate-running-process", udid, bundle_identifier
+        )
+        unless launched
+          warn "Failed to launch the experimental client on #{client[:simulator_name] || udid}."
+          return []
+        end
+
+        puts "Ruflet experimental client: #{client[:simulator_name] || udid}"
+        puts "Ruflet experimental backend: #{url}"
+        []
+      rescue StandardError => e
+        warn "Failed to launch experimental client: #{e.class}: #{e.message}"
+        []
+      end
+
+      # The backend serves the web client on its own port, so the client reads
+      # the origin it was loaded from and opens its websocket there. No URL is
+      # passed in the query string: nothing in the client parses one.
       def launch_web_client(port)
         backend_url = "http://localhost:#{port}"
-        web_url = "#{backend_url}/?#{URI.encode_www_form(url: backend_url)}"
+        web_url = "#{backend_url}/"
         browser_pid = open_in_browser_app_mode(web_url)
         open_in_browser(web_url) if browser_pid.nil?
         puts "Ruflet web client: #{web_url}"
@@ -400,8 +511,8 @@ module Ruflet
         nil
       end
 
-      def launch_desktop_client(url)
-        cmd = detect_desktop_client_command(url)
+      def launch_desktop_client(url, root: nil, experimental: false)
+        cmd = detect_desktop_client_command(url, root: root, experimental: experimental)
         unless cmd
           warn "Desktop client executable not found."
           warn "Set RUFLET_CLIENT_DIR to your client path."
@@ -457,18 +568,20 @@ 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, experimental: false)
+        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"]
         client_build_roots(root).each do |base|
           if host_os.match?(/darwin/i)
             search = %w[Release Debug].map { |config| File.join(base, "build", "macos", "Build", "Products", config) }
-            search << File.join(base, "desktop")
+            search << File.join(base, experimental ? "desktop-experimental" : "desktop")
             search.each do |dir|
               next unless Dir.exist?(dir)
 
@@ -523,7 +636,10 @@ module Ruflet
         nil
       end
 
-      def ensure_prebuilt_client(web: false, desktop: false, platform: nil, force: false)
+      def ensure_prebuilt_client(
+        web: false, desktop: false, desktop_experimental: false,
+        ios_experimental: false, platform: nil, force: false
+      )
         platform ||= host_platform_name
         return nil if platform.nil?
 
@@ -531,13 +647,38 @@ 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)
+        if desktop_experimental
+          return nil unless platform == "macos"
+
+          wanted_assets << {
+            kind: :desktop_experimental,
+            name: EXPERIMENTAL_MACOS_ASSET,
+            platform: platform
+          }
+        end
+        if ios_experimental
+          return nil unless platform == "macos"
+
+          wanted_assets << {
+            kind: :ios_experimental,
+            name: EXPERIMENTAL_IOS_SIMULATOR_ASSET,
+            platform: platform
+          }
+        end
+        cache_ready = wanted_assets.empty? || prebuilt_assets_present?(
+          cache_root,
+          web: web,
+          desktop: desktop,
+          desktop_experimental: desktop_experimental,
+          ios_experimental: ios_experimental,
+          platform: platform
+        )
         release = nil
         if !force && cache_ready
           ensure_client_manifest(cache_root, platform: platform)
@@ -574,7 +715,12 @@ 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"
+            when :desktop_experimental then "desktop-experimental"
+            when :ios_experimental then "ios-experimental"
+            end
             target = File.join(cache_root, subdir)
             FileUtils.rm_rf(target) if force && Dir.exist?(target)
             FileUtils.mkdir_p(target)
@@ -592,7 +738,14 @@ 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,
+          desktop_experimental: desktop_experimental,
+          ios_experimental: ios_experimental,
+          platform: platform
+        )
           write_client_manifest(cache_root, platform: platform, release: release, assets: installed_assets)
           return cache_root
         end
@@ -603,28 +756,102 @@ module Ruflet
         nil
       end
 
-      def prebuilt_assets_present?(root, web:, desktop:, platform: nil)
-        ok_web = !web || File.file?(File.join(root, "web", "index.html"))
+      # This decides both "the download installed correctly" and "the cache is
+      # still usable, skip the network". It has to agree with what `ruflet run`
+      # will actually accept later, or a half-extracted cache reports success
+      # here and then fails to launch -- and, because a present cache short
+      # circuits the download, never repairs itself without --force.
+      def prebuilt_assets_present?(
+        root, web:, desktop:, desktop_experimental: false,
+        ios_experimental: false, platform: nil
+      )
+        ok_web = !web || built_web_client_dir?(File.join(root, "web"))
         ok_desktop = !desktop || prebuilt_desktop_present?(root, platform: platform)
-        ok_web && ok_desktop
+        ok_desktop_experimental = !desktop_experimental ||
+          prebuilt_experimental_desktop_present?(root, platform: platform)
+        ok_ios_experimental = !ios_experimental || !experimental_ios_app_bundle(root).nil?
+        ok_web && ok_desktop && ok_desktop_experimental && ok_ios_experimental
       end
 
+      def experimental_ios_app_bundle(root)
+        ios_root = File.join(root, "ios-experimental")
+        return nil unless Dir.exist?(ios_root)
+
+        Dir.glob(File.join(ios_root, "*.app")).sort.find do |app_bundle|
+          File.file?(File.join(app_bundle, "Info.plist")) && ios_app_executable(app_bundle)
+        end
+      end
+
+      def ios_app_executable(app_bundle)
+        return nil unless Dir.exist?(app_bundle)
+
+        Dir.children(app_bundle)
+          .map { |entry| File.join(app_bundle, entry) }
+          .find { |path| executable_file?(path) }
+      end
+
+      def booted_ios_simulator
+        output, status = Open3.capture2e("xcrun", "simctl", "list", "devices", "booted", "--json")
+        return nil unless status.success?
+
+        devices = JSON.parse(output).fetch("devices", {})
+        devices.each do |runtime, candidates|
+          next unless runtime.to_s.include?("SimRuntime.iOS")
+
+          match = Array(candidates).find do |device|
+            device["state"] == "Booted" && device.fetch("isAvailable", true)
+          end
+          return match if match
+        end
+        nil
+      rescue StandardError
+        nil
+      end
+
+      def ios_bundle_identifier(app_bundle)
+        plist = File.join(app_bundle, "Info.plist")
+        output, status = Open3.capture2e(
+          "/usr/bin/plutil", "-extract", "CFBundleIdentifier", "raw", "-o", "-", plist
+        )
+        status.success? ? output.strip : nil
+      rescue StandardError
+        nil
+      end
+
+      # The prebuilt client is whatever `ruflet build` produced from Ruflet
+      # Explorer, so its bundle and binary carry that project's app name --
+      # "Ruflet Explorer.app", not the old "ruflet_client.app". Match on shape
+      # the way detect_desktop_client_command does rather than on a fixed name.
       def prebuilt_desktop_present?(root, platform: nil)
         platform ||= host_platform_name
         return false if platform.nil?
 
+        desktop = File.join(root, "desktop")
+        return false unless Dir.exist?(desktop)
+
         case platform
         when "macos"
-          File.file?(File.join(root, "desktop", "ruflet_client.app", "Contents", "MacOS", "ruflet_client"))
+          Dir.glob(File.join(desktop, "*.app")).any? { |app_bundle| macos_app_executable(app_bundle) }
         when "linux"
-          File.file?(File.join(root, "desktop", "ruflet_client"))
+          Dir.children(desktop).any? { |entry| executable_file?(File.join(desktop, entry)) }
         when "windows"
-          File.file?(File.join(root, "desktop", "ruflet_client.exe"))
+          Dir.glob(File.join(desktop, "*.exe")).any? { |path| File.file?(path) }
         else
           false
         end
       end
 
+      def prebuilt_experimental_desktop_present?(root, platform: nil)
+        return false unless (platform || host_platform_name) == "macos"
+
+        desktop = File.join(root, "desktop-experimental")
+        return false unless Dir.exist?(desktop)
+
+        Dir.glob(File.join(desktop, "*.app")).any? do |app_bundle|
+          macos_app_executable(app_bundle)
+        end
+      end
+
       def host_platform_name
         host_os = RbConfig::CONFIG["host_os"]
         return "macos" if host_os.match?(/darwin/i)
@@ -636,9 +863,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
 
@@ -648,7 +875,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)
@@ -659,13 +886,24 @@ 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 = wanted_assets.any? do |wanted|
+          %i[desktop_experimental ios_experimental].include?(wanted[:kind])
+        end ? "prebuild-experimental" : "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)
@@ -676,8 +914,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
 
@@ -739,15 +976,23 @@ 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"))
         end
 
+        if kind == :ios_experimental
+          return n.include?("ios") && n.include?("experimental") && n.include?("simulator") && n.end_with?(".zip")
+        end
+
+        if kind == :desktop_experimental
+          return n.include?("macos") && n.include?("experimental") && n.end_with?(".zip")
+        end
+
         case platform
         when "macos"
-          n.include?("macos") && n.end_with?(".zip")
+          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"
@@ -823,10 +1068,16 @@ module Ruflet
         return if read_client_manifest(root)
 
         assets = []
-        assets << { "kind" => "web", "platform" => platform, "asset_name" => nil } if File.file?(File.join(root, "web", "index.html"))
+        assets << { "kind" => "web", "platform" => platform, "asset_name" => nil } if built_web_client_dir?(File.join(root, "web"))
         if prebuilt_desktop_present?(root, platform: platform)
           assets << { "kind" => "desktop", "platform" => platform, "asset_name" => nil }
         end
+        if prebuilt_experimental_desktop_present?(root, platform: platform)
+          assets << { "kind" => "desktop_experimental", "platform" => platform, "asset_name" => nil }
+        end
+        if experimental_ios_app_bundle(root)
+          assets << { "kind" => "ios_experimental", "platform" => platform, "asset_name" => nil }
+        end
         return if assets.empty?
 
         write_client_manifest(root, platform: platform, release: nil, assets: assets)

data/lib/ruflet/cli/update_command.rb

@@ -108,12 +108,12 @@ module Ruflet
 
         installed = true
         targets.each do |target|
-          present =
-            if target == :web
-              File.file?(File.join(root, "web", "index.html"))
-            else
-              prebuilt_desktop_present?(root, platform: platform)
-            end
+          present = prebuilt_assets_present?(
+            root,
+            web: target == :web,
+            desktop: target == :desktop,
+            platform: platform
+          )
           installed &&= present
           puts "#{target}: #{present ? 'installed' : 'missing'}"
         end

data/lib/ruflet/cli.rb

@@ -66,14 +66,19 @@ module Ruflet
           ruflet --version
           ruflet create <appname>
           ruflet new <appname>
-          ruflet run [scriptname|path] [--web|--desktop] [--port PORT] [--no-reload]
+          ruflet run [scriptname|path] [--web|--desktop] [--experimental|--exp] [--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] [--experimental|--exp] [--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.20" unless const_defined?(:VERSION)
+  VERSION = "0.0.22" unless const_defined?(:VERSION)
 end

metadata

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