ruflet_cli 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83772c8986411d4680455374f1f350c015183318e3c090426ea53edfb4ed2a89
-  data.tar.gz: 45f42f969bc487714f24c0833ca8fdbf2236e789622deb604a231d1a254ea483
+  metadata.gz: bd07971461f7a7a4f8f61df41b51b4a6537de8b0dfe152fd71c52148a344c15e
+  data.tar.gz: 65b0952b26820338f5a4f4115440aac955c0ab09bac94fb3fcc94d19e302eff1
 SHA512:
-  metadata.gz: 412a6524bff1cdf335256193390aca08c71b299f517da00af1da6efada84c7fc0ebd0d399be9e92235d6713ebcfbd8c8f9695695b68e3465242ed998deecf1bb
-  data.tar.gz: 0f77d2ee780f5d443e58d356ac02382ae0e5a53144ac64d9df5bf8d4e9bec2fcf51646f8d92fdc69e527259a7100e772fafcd26861c2d63ba829606531b03824
+  metadata.gz: 28b45040c5f0f3b0901d48bedfdd995e644983e3d4e3748696442f21288175722d3b13688f646f4b1cbea662405213b0e6dedf970aa4614b57d9f2000a5e65a8
+  data.tar.gz: 891b2e7de50d432d0922f7f8aa0e2d28e764d4c8c02def6a7de5c58fbc26c86b9421687516427c84efd0a431e79d546c698962d8d421a54ddf97cb2f246b99ed

data/lib/ruflet/cli/run_command.rb

@@ -9,16 +9,19 @@ require "fileutils"
 require "json"
 require "net/http"
 require "uri"
+require "thread"
+require "io/console"
 
 module Ruflet
   module CLI
     module RunCommand
       def command_run(args)
-        options = { target: "mobile" }
+        options = { target: "mobile", hot_reload: true }
         parser = OptionParser.new do |o|
           o.on("--web") { options[:target] = "web" }
-          o.on("--mobile") { options[:target] = "mobile" }
           o.on("--desktop") { options[:target] = "desktop" }
+          o.on("--hot-reload", "--hot") { options[:hot_reload] = true }
+          o.on("--no-hot-reload") { options[:hot_reload] = false }
         end
         parser.parse!(args)
 
@@ -44,16 +47,8 @@ module Ruflet
         print_mobile_qr_hint(port: selected_port) if options[:target] == "mobile"
 
         gemfile_path = find_nearest_gemfile(Dir.pwd)
-        cmd =
-          if gemfile_path
-            env["BUNDLE_GEMFILE"] = gemfile_path
-            bundle_ready = system(env, "bundle", "check", out: File::NULL, err: File::NULL)
-            return 1 unless bundle_ready || system(env, "bundle", "install")
-
-            ["bundle", "exec", RbConfig.ruby, script_path]
-          else
-            [RbConfig.ruby, script_path]
-          end
+        cmd = build_runtime_command(script_path, gemfile_path: gemfile_path, env: env, hot_reload: options[:hot_reload])
+        return 1 unless cmd
 
         child_pid = Process.spawn(env, *cmd, pgroup: true)
         launched_client_pids = launch_target_client(options[:target], selected_port)
@@ -68,8 +63,22 @@ module Ruflet
         previous_int = Signal.trap("INT") { forward_signal.call("INT") }
         previous_term = Signal.trap("TERM") { forward_signal.call("TERM") }
 
-        _pid, status = Process.wait2(child_pid)
-        status.success? ? 0 : (status.exitstatus || 1)
+        if options[:hot_reload]
+          puts "Hot reload enabled. Press 'r' to reload backend or 'R' for hot restart."
+          run_hot_reload_loop(
+            child_pid: child_pid,
+            env: env,
+            cmd: cmd,
+            script_path: script_path,
+            gemfile_path: gemfile_path,
+            target: options[:target],
+            port: selected_port,
+            launched_client_pids: launched_client_pids
+          )
+        else
+          _pid, status = Process.wait2(child_pid)
+          status.success? ? 0 : (status.exitstatus || 1)
+        end
       ensure
         Signal.trap("INT", previous_int) if defined?(previous_int) && previous_int
         Signal.trap("TERM", previous_term) if defined?(previous_term) && previous_term
@@ -93,10 +102,186 @@ module Ruflet
             end
           end
         end
+
       end
 
       private
 
+      def run_hot_reload_loop(child_pid:, env:, cmd:, script_path:, gemfile_path:, target:, port:, launched_client_pids:)
+        hot_queue = Queue.new
+        hot_listener = start_hotkey_listener(hot_queue)
+        watch_roots = watch_roots_for_script(script_path, gemfile_path)
+        watch_snapshot = build_watch_snapshot(watch_roots)
+        puts "Watching #{watch_snapshot.size} Ruby files for hot reload."
+
+        loop do
+          exited = Process.waitpid(child_pid, Process::WNOHANG)
+          if exited
+            status = $?
+            return status&.success? ? 0 : (status&.exitstatus || 1)
+          end
+
+          latest_snapshot = build_watch_snapshot(watch_roots)
+          if latest_snapshot != watch_snapshot
+            changed = changed_paths(watch_snapshot, latest_snapshot)
+            sample = changed.first(3).map { |p| File.basename(p) }.join(", ")
+            suffix = changed.size > 3 ? ", ..." : ""
+            puts "Detected change in #{changed.size} file(s): #{sample}#{suffix}"
+            hot_queue << :reload
+            watch_snapshot = latest_snapshot
+          end
+
+          process_hot_reload_actions(
+            queue: hot_queue,
+            child_pid: child_pid,
+            launched_client_pids: launched_client_pids,
+            env: env,
+            cmd: cmd,
+            target: target,
+            port: port
+          ) do |new_child_pid, new_client_pids|
+            child_pid = new_child_pid
+            launched_client_pids = new_client_pids
+          end
+
+          sleep 0.25
+        end
+      ensure
+        hot_listener&.kill
+      end
+
+      def process_hot_reload_actions(queue:, child_pid:, launched_client_pids:, env:, cmd:, target:, port:)
+        until queue.empty?
+          action = queue.pop(true)
+          case action
+          when :interrupt
+            Process.kill("INT", Process.pid)
+          when :reload
+            puts "Reloading backend..."
+            child_pid = restart_backend(child_pid, env, cmd)
+          when :restart
+            puts "Hot restarting backend and client..."
+            child_pid = restart_backend(child_pid, env, cmd)
+            launched_client_pids = restart_clients(launched_client_pids, target, port)
+          end
+          yield child_pid, launched_client_pids if block_given?
+        end
+      rescue ThreadError
+        nil
+      end
+
+      def start_hotkey_listener(queue)
+        return nil unless $stdin.tty?
+
+        Thread.new do
+          $stdin.raw do |stdin|
+            loop do
+              key = stdin.getc
+              break if key.nil?
+
+              action = hot_action_for_key(key)
+              queue << action if action
+            end
+          end
+        rescue StandardError
+          nil
+        end
+      end
+
+      def hot_action_for_key(key)
+        return :interrupt if key == "\u0003" # Ctrl+C in raw mode
+        return :reload if key == "r"
+        return :restart if key == "R"
+
+        nil
+      end
+
+      def restart_backend(child_pid, env, cmd)
+        terminate_process(child_pid)
+        new_pid = Process.spawn(env, *cmd, pgroup: true)
+        puts "Hot reload applied."
+        new_pid
+      end
+
+      def build_runtime_command(script_path, gemfile_path:, env:, hot_reload:)
+        if gemfile_path
+          env["BUNDLE_GEMFILE"] = gemfile_path
+          bundle_ready = system(env, RbConfig.ruby, "-S", "bundle", "check", out: File::NULL, err: File::NULL)
+          return nil unless bundle_ready || system(env, RbConfig.ruby, "-S", "bundle", "install")
+
+          return [RbConfig.ruby, "-rbundler/setup", script_path]
+        end
+
+        [RbConfig.ruby, script_path]
+      end
+
+      def restart_clients(launched_client_pids, target, port)
+        Array(launched_client_pids).compact.each { |pid| terminate_process(pid) }
+        launch_target_client(target, port)
+      end
+
+      def terminate_process(pid)
+        return unless pid
+
+        begin
+          Process.kill("TERM", -pid)
+        rescue Errno::ESRCH
+          begin
+            Process.kill("TERM", pid)
+          rescue Errno::ESRCH
+            nil
+          end
+        end
+
+        begin
+          Timeout.timeout(2) { Process.wait(pid) }
+        rescue StandardError
+          nil
+        end
+      end
+
+      def watch_roots_for_script(script_path, gemfile_path)
+        roots = [Dir.pwd, File.dirname(script_path)]
+        if gemfile_path
+          roots << File.dirname(gemfile_path)
+          roots.concat(extra_watch_roots_from_gemfile(gemfile_path))
+        end
+        roots.uniq.select { |root| File.directory?(root) }
+      end
+
+      def extra_watch_roots_from_gemfile(gemfile_path)
+        base_dir = File.dirname(gemfile_path)
+        content = File.read(gemfile_path)
+        content.scan(/path:\s*["']([^"']+)["']/).flatten.map do |path|
+          File.expand_path(path, base_dir)
+        end.select { |path| File.directory?(path) }
+      rescue StandardError
+        []
+      end
+
+      def build_watch_snapshot(roots)
+        snapshot = {}
+        roots.each do |root|
+          Dir.glob(File.join(root, "**", "*.rb")).each do |path|
+            next if path.include?("/.git/")
+            next if path.include?("/tmp/")
+            next if path.include?("/log/")
+            next unless File.file?(path)
+
+            snapshot[path] = File.mtime(path).to_f
+          rescue Errno::ENOENT
+            nil
+          end
+        end
+        snapshot
+      end
+
+      def changed_paths(old_snapshot, new_snapshot)
+        (old_snapshot.keys | new_snapshot.keys).select do |path|
+          old_snapshot[path] != new_snapshot[path]
+        end
+      end
+
       def resolve_script(token)
         path = File.expand_path(token, Dir.pwd)
         return path if File.file?(path)
@@ -547,7 +732,7 @@ module Ruflet
             end
             probe.close
             return port
-          rescue Errno::EADDRINUSE
+          rescue Errno::EADDRINUSE, Errno::EACCES, Errno::EPERM
             port += 1
           end
         end
@@ -556,13 +741,7 @@ module Ruflet
       end
 
       def resolve_backend_port(target)
-        return find_available_port(8550) if target == "mobile"
-
-        return 8550 if port_available?(8550)
-
-        warn "Port 8550 is required for `ruflet run --#{target}`."
-        warn "Stop the process using 8550 and run again."
-        nil
+        find_available_port(8550)
       end
 
       def port_available?(port)

data/lib/ruflet/cli/templates.rb

@@ -3,58 +3,42 @@
 module Ruflet
   module CLI
     MAIN_TEMPLATE = <<~RUBY
-      require "ruflet"
-
-      class MainApp < Ruflet::App
-        def initialize
-          super
-          @count = 0
-        end
-
-        def view(page)
-          page.title = "Counter Demo"
-          page.vertical_alignment = Ruflet::MainAxisAlignment::CENTER
-          page.horizontal_alignment = Ruflet::CrossAxisAlignment::CENTER
-          count_text = text(value: @count.to_s, size: 40)
-
-          page.add(
-            container(
-              expand: true,
-              padding: 24,
-              content: column(
-                expand: true,
-                alignment: Ruflet::MainAxisAlignment::CENTER,
-                horizontal_alignment: Ruflet::CrossAxisAlignment::CENTER,
-                spacing: 12,
-                controls: [
-                  text(value: "You have pushed the button this many times:"),
-                  count_text
-                ]
-              )
-            ),
-            appbar: app_bar(
-              title: text(value: "Counter Demo")
-            ),
-            floating_action_button: fab(
-              icon(icon: Ruflet::MaterialIcons::ADD),
-              on_click: ->(_e) {
-                @count += 1
-                page.update(count_text, value: @count.to_s)
-              }
-            )
+    require "ruflet"
+    Ruflet.run do |page|
+      page.title = "Counter Demo"
+      count = 0
+      count_text = nil
+      count_text ||= text(value: count.to_s, size: 40)
+      page.add(
+        container(
+          expand: true,
+          alignment: Ruflet::MainAxisAlignment::CENTER,
+          content: column(
+            alignment: Ruflet::MainAxisAlignment::CENTER,
+            horizontal_alignment: Ruflet::CrossAxisAlignment::CENTER,
+            children: [
+              text(value: "You have pushed the button this many times:"),
+              count_text
+            ]
           )
-        end
-      end
-
-      MainApp.new.run
+        ),
+        floating_action_button: fab(
+          icon(icon: Ruflet::MaterialIcons::ADD),
+          on_click: ->(_e) do
+            count += 1
+            page.update(count_text, value: count.to_s)
+          end
+        )
+      )
+    end
 
     RUBY
 
     GEMFILE_TEMPLATE = <<~GEMFILE
       source "https://rubygems.org"
 
-      gem "ruflet", ">= 0.0.3"
-      gem "ruflet_server", ">= 0.0.3"
+      gem "ruflet", ">= 0.0.7"
+      gem "ruflet_server", ">= 0.0.7"
     GEMFILE
 
     README_TEMPLATE = <<~MD

data/lib/ruflet/cli.rb

@@ -54,7 +54,7 @@ module Ruflet
         Commands:
           ruflet create <appname>
           ruflet new <appname>
-          ruflet run [scriptname|path] [--web|--mobile|--desktop]
+          ruflet run [scriptname|path] [--web|--desktop] [--no-hot-reload]
           ruflet debug [scriptname|path]
           ruflet build <apk|ios|aab|web|macos|windows|linux>
           ruflet devices

data/lib/ruflet/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet_cli
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - AdamMusa