ruflet_server 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5c44fadc8aa766bbfe16e6dc94afb0503a03408ee5bb8108fc9064cb10adf84
-  data.tar.gz: 81a8de81cf0cbbfee1deb8a3fdea5b448a9ba3a8b417ffc942d33fb5dc2d8d2f
+  metadata.gz: c8ce7c65f8922fb96c632f08c3fbbfbe5ab4d2f51ef010aca2938dada94bbb06
+  data.tar.gz: '09a16364d80b69210248753a9eeb062a8d895be2cfa02844bd7850a96c4392d4'
 SHA512:
-  metadata.gz: 04c82e1accf25203c93e3fc987166453cec277b5e29b380c7539d3f32dd0e777843d1f084485513437108bda6cc8047a80c141a890ec926a0c63f8ef7b8ae688
-  data.tar.gz: 0013bf2ab8f22d327df1f48ced0d956148c495e310bcc7ac0230b0ba2344ebb97d5f744a26cafe23ce4969fa9776da17acdc66f64aacfbb5dcb1772e1826daf6
+  metadata.gz: 0efb74cd09d74eb058e0cfbdaa3027483fb809552e15109070a80e3bad364f9d9d297173249033df16029c2f6c366ee24db3e40848d1adf7fa583927b4fe7a83
+  data.tar.gz: 908da326003ca5cfff54b1a608148afaf0f557c8d9871c602e8234abe6710b6e79c27f0f0de0b9bcda78368ec67735d62ba31b41f84af9f6b551791bde15a889

data/README.md

@@ -7,9 +7,9 @@ It is installed automatically in projects created with `ruflet new`. Start an
 application through the Ruflet CLI:
 
 ```bash
-bundle exec ruflet run
-bundle exec ruflet run --web
-bundle exec ruflet run --desktop
+ruflet run
+ruflet run --web
+ruflet run --desktop
 ```
 
 Application code uses the public `Ruflet.run` API supplied by `ruflet_core`.

data/lib/ruflet/server.rb

@@ -124,21 +124,50 @@ module Ruflet
         ws = @connections_mutex.synchronize { @connections[session_key] }
         next unless ws
 
-        refreshed_page = Page.new(
-          session_id: current_page.session_id,
-          client_details: current_page.client_details,
-          sender: lambda do |action, payload|
-            send_message(ws, action, payload)
+        # Open dialogs, sheets, and snack bars are Navigator routes on the
+        # client; replacing the control tree does not pop them. Close them
+        # first, otherwise a reload while an overlay is open leaves it on
+        # screen wired to control ids the reloaded page cannot resolve.
+        begin
+          nil while current_page.respond_to?(:close_dialog) && current_page.close_dialog
+        rescue StandardError
+          nil
+        end
+
+        if current_page.respond_to?(:reset_for_reload!)
+          # Re-render on the live page. The client's overlay/service/dialogs
+          # containers stay mounted; a recreated Page would re-send them,
+          # replacing their client-side instances and detaching them — after
+          # which dialog and service patches are silently ignored.
+          current_page.reset_for_reload!
+          @app_block.call(current_page)
+          # Clear page-level chrome the reloaded block dropped and flush the
+          # overlay (appbar/drawer/FAB live in the view and rebuild wholesale;
+          # page props and the mounted overlay need explicit updates).
+          current_page.finalize_reload! if current_page.respond_to?(:finalize_reload!)
+          # Keeps route-driven apps on their current route: replays the
+          # route_change event when the block did not route itself.
+          current_page.replay_route_after_reload! if current_page.respond_to?(:replay_route_after_reload!)
+          current_page.update
+        else
+          # Older ruflet_core without reset_for_reload!: fall back to a fresh
+          # page (loses client-side container bindings until reconnect).
+          refreshed_page = Page.new(
+            session_id: current_page.session_id,
+            client_details: current_page.client_details,
+            sender: lambda do |action, payload|
+              send_message(ws, action, payload)
+            end
+          )
+          refreshed_page.title = "Ruflet App"
+
+          @sessions_mutex.synchronize do
+            @sessions[session_key] = refreshed_page
           end
-        )
-        refreshed_page.title = "Ruflet App"
 
-        @sessions_mutex.synchronize do
-          @sessions[session_key] = refreshed_page
+          @app_block.call(refreshed_page)
+          refreshed_page.update
         end
-
-        @app_block.call(refreshed_page)
-        refreshed_page.update
       rescue StandardError => e
         warn "reload error: #{e.class}: #{e.message}"
       end
@@ -155,7 +184,10 @@ module Ruflet
 
     def trap_signal(signal_name)
       Signal.trap(signal_name) do
-        stop
+        # Trap context restricts Mutex use, so calling stop here raises
+        # ThreadError and the signal is silently swallowed. Only unwind the
+        # main thread; start's ensure performs the actual stop outside the
+        # trap context.
         Thread.main.raise(Interrupt)
       rescue StandardError
         nil
@@ -324,14 +356,17 @@ module Ruflet
     end
 
     def handle_http_request(socket, path)
-      case path
+      request_path = path.to_s.split("?", 2).first.to_s
+      return if serve_web_client(socket, request_path)
+
+      case request_path
       when "/health"
         write_http_response(socket, 200, "text/plain", "ok")
       when "/"
         write_http_response(socket, 200, "text/plain", "ruflet server")
       else
-        if path.start_with?("/assets/")
-          serve_asset(socket, path)
+        if request_path.start_with?("/assets/")
+          serve_asset(socket, request_path)
         else
           write_http_response(socket, 404, "text/plain", "not found")
         end
@@ -341,6 +376,37 @@ module Ruflet
       write_http_response(socket, 500, "text/plain", "server error")
     end
 
+    # The Flutter web client is served from this same port so that it loads and
+    # opens its websocket on one origin. Without that the client cannot reach
+    # /ws at all.
+    def web_client_root
+      return @web_client_root if defined?(@web_client_root)
+
+      configured = ENV["RUFLET_WEB_CLIENT_DIR"].to_s.strip
+      @web_client_root =
+        if configured.empty? || !File.directory?(configured)
+          nil
+        else
+          File.expand_path(configured)
+        end
+    end
+
+    def serve_web_client(socket, request_path)
+      root = web_client_root
+      return false unless root
+
+      relative = request_path
+      relative = "/index.html" if relative.empty? || relative == "/"
+      candidate = File.expand_path(File.join(root, relative))
+      # Never serve outside the client bundle.
+      return false unless candidate == root || candidate.start_with?("#{root}#{File::SEPARATOR}")
+      return false unless File.file?(candidate)
+
+      content = read_binary_file(candidate)
+      write_http_response(socket, 200, content_type_for(candidate), content, binary: true)
+      true
+    end
+
     def serve_asset(socket, path)
       asset_path = resolve_asset_path(path)
       unless asset_path
@@ -392,6 +458,28 @@ module Ruflet
         "image/webp"
       when ".svg"
         "image/svg+xml"
+      when ".html", ".htm"
+        "text/html; charset=utf-8"
+      when ".js", ".mjs"
+        "text/javascript; charset=utf-8"
+      when ".css"
+        "text/css; charset=utf-8"
+      when ".json", ".map"
+        "application/json; charset=utf-8"
+      when ".wasm"
+        "application/wasm"
+      when ".ttf"
+        "font/ttf"
+      when ".otf"
+        "font/otf"
+      when ".woff"
+        "font/woff"
+      when ".woff2"
+        "font/woff2"
+      when ".ico"
+        "image/x-icon"
+      when ".txt", ".symbols"
+        "text/plain; charset=utf-8"
       else
         "application/octet-stream"
       end
@@ -533,11 +621,23 @@ module Ruflet
       normalized = Protocol.normalize_register_payload(payload)
       session_id = normalized["session_id"].to_s.empty? ? pseudo_uuid : normalized["session_id"]
 
+      # Run the app block BEFORE responding and ship the complete state in the
+      # register response (page_patch), like Flet. The client merges that map
+      # by control id, keeping existing instances alive — required for
+      # reconnecting clients (backend restarts) whose control store persists.
+      # Incremental op patches sent during the block are superseded by the
+      # full state and dropped; everything else is flushed afterwards.
+      registered = false
+      buffered = []
       page = Page.new(
         session_id: session_id,
         client_details: normalized,
         sender: lambda do |action, msg_payload|
-          send_message(ws, action, msg_payload)
+          if registered
+            send_message(ws, action, msg_payload)
+          else
+            buffered << [action, msg_payload]
+          end
         end
       )
 
@@ -547,14 +647,29 @@ module Ruflet
         @sessions[ws.session_key] = page
       end
 
+      @app_block.call(page)
+
+      page_patch = page.respond_to?(:register_page_patch) ? page.register_page_patch : {}
+      response = begin
+        Protocol.register_response(session_id: session_id, page_patch: page_patch)
+      rescue ArgumentError
+        # Older ruflet_core without the page_patch parameter.
+        page_patch = {}
+        Protocol.register_response(session_id: session_id)
+      end
       initial_response = [
         Protocol::ACTIONS[:register_client],
-        Protocol.register_response(session_id: session_id)
+        response
       ]
       ws.send_binary(Ruflet::WireCodec.pack(initial_response))
+      registered = true
 
-      @app_block.call(page)
-      page.update
+      buffered.each do |action, msg_payload|
+        next if action == Protocol::ACTIONS[:patch_control]
+
+        send_message(ws, action, msg_payload)
+      end
+      page.update if page_patch.empty?
     rescue StandardError => e
       send_message(ws, Protocol::ACTIONS[:session_crashed], { "message" => e.message })
       raise e

data/lib/ruflet/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet_server
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - AdamMusa
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.19
+        version: 0.0.20
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.19
+        version: 0.0.20
 description: Ruflet WebSocket server runtime compatible with Flet protocol.
 email:
 - adammusa2222@gmail.com