ruflet_rails 0.0.7 → 0.0.8

data/lib/ruflet/rails/protocol/endpoint.rb

@@ -8,13 +8,13 @@ module Ruflet
       class Endpoint
         WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
 
-        def initialize(server:, path: "/ws")
+        def initialize(server:, path: nil)
           @server = server
           @path = path
         end
 
         def call(env)
-          return not_found unless env["PATH_INFO"] == @path
+          return not_found if @path && env["PATH_INFO"] != @path
           return bad_request("Expected WebSocket upgrade") unless websocket_upgrade_request?(env)
 
           hijack = env["rack.hijack"]
@@ -30,9 +30,7 @@ module Ruflet
           captured_env = env.dup
           Thread.new(io, captured_env) do |socket, ws_env|
             Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
-            Context.with_env(ws_env) do
-              @server.handle_upgraded_socket(socket)
-            end
+            rails_executor_wrap { handle_socket(socket, ws_env) }
           end
 
           [-1, {}, []]
@@ -42,6 +40,24 @@ module Ruflet
 
         private
 
+        def handle_socket(socket, env)
+          Context.with_env(env) do
+            @server.handle_upgraded_socket(socket)
+          end
+        end
+
+        def rails_executor_wrap(&block)
+          executor = if defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+                       ::Rails.application.executor
+                     end
+
+          if executor.respond_to?(:wrap)
+            executor.wrap(&block)
+          else
+            yield
+          end
+        end
+
         def websocket_upgrade_request?(env)
           return false unless env["REQUEST_METHOD"] == "GET"
 

data/lib/ruflet/rails/protocol/local_server.rb

@@ -4,8 +4,9 @@ module Ruflet
   module Rails
     module Protocol
       class LocalServer
-        def initialize(&app_block)
+        def initialize(session_registry: Ruflet::Rails.sessions, &app_block)
           @app_block = app_block
+          @session_registry = session_registry
           @sessions = {}
           @sessions_mutex = Mutex.new
         end
@@ -22,6 +23,7 @@ module Ruflet
             handle_message(ws, raw)
           end
         rescue StandardError => e
+          Rails.logger.error("RUFLET CRASH: #{e.class}: #{e.message}\n#{e.backtrace.first(10).join("\n")}") if defined?(Rails)
           send_message(ws, Ruflet::Protocol::ACTIONS[:session_crashed], { "message" => e.message.to_s.dup.force_encoding("UTF-8") })
         ensure
           close_connection(ws)
@@ -35,7 +37,8 @@ module Ruflet
         end
 
         def remove_session(ws)
-          @sessions_mutex.synchronize { @sessions.delete(ws.session_key) }
+          page = @sessions_mutex.synchronize { @sessions.delete(ws.session_key) }
+          @session_registry.remove(page.session_id, connection_key: ws.session_key) if page
         end
 
         def handle_message(ws, raw)
@@ -98,17 +101,29 @@ module Ruflet
         def on_register_client(ws, payload)
           normalized = Ruflet::Protocol.normalize_register_payload(payload)
           session_id = normalized["session_id"].to_s.empty? ? pseudo_uuid : normalized["session_id"]
+          existing_session = @session_registry[session_id]
+          page = existing_session&.page
+          first_registration = page.nil?
 
-          page = Ruflet::Page.new(
-            session_id: session_id,
-            client_details: normalized,
-            sender: lambda do |action, msg_payload|
-              send_message(ws, action, msg_payload)
-            end
-          )
-          page.title = "Ruflet App"
+          if page
+            attach_sender(page, ws)
+            reset_mount_state(page)
+          else
+            page = Ruflet::Page.new(
+              session_id: session_id,
+              client_details: normalized,
+              sender: sender_for(ws)
+            )
+            page.title = "Ruflet App"
+          end
 
           @sessions_mutex.synchronize { @sessions[ws.session_key] = page }
+          @session_registry.add(
+            key: page.session_id,
+            page: page,
+            env: Context.current_env,
+            connection_key: ws.session_key
+          )
 
           initial_response = [
             Ruflet::Protocol::ACTIONS[:register_client],
@@ -116,19 +131,20 @@ module Ruflet
           ]
           ws.send_binary(WireCodec.pack(initial_response))
 
-          @app_block.call(page)
+          @app_block.call(page) if first_registration
           page.update
         rescue StandardError => e
           send_message(ws, Ruflet::Protocol::ACTIONS[:session_crashed], { "message" => e.message.to_s })
           raise
         end
 
-
         def on_control_event(ws, payload)
           event = Ruflet::Protocol.normalize_control_event_payload(payload)
           page = fetch_page(ws)
           return if event["target"].nil? || event["name"].to_s.empty?
 
+          attach_sender(page, ws)
+          debug_event(ws, event)
           page.dispatch_event(
             target: event["target"],
             name: event["name"],
@@ -141,11 +157,13 @@ module Ruflet
           page = fetch_page(ws)
           return if update["id"].nil?
 
+          attach_sender(page, ws)
           page.apply_client_update(update["id"], update["props"] || {})
         end
 
         def on_invoke_control_method(ws, payload)
           page = fetch_page(ws)
+          attach_sender(page, ws)
           page.handle_invoke_method_result(Ruflet::Protocol.normalize_invoke_method_result_payload(payload))
         end
 
@@ -173,6 +191,31 @@ module Ruflet
           nil
         end
 
+        def sender_for(ws)
+          lambda do |action, msg_payload|
+            send_message(ws, action, msg_payload)
+          end
+        end
+
+        def attach_sender(page, ws)
+          page.instance_variable_set(:@sender, sender_for(ws))
+        end
+
+        def debug_event(ws, event)
+          return unless ENV["RUFLET_RAILS_DEBUG_EVENTS"] == "true"
+
+          warn(
+            "[ruflet_rails] event socket=#{ws.session_key} " \
+            "target=#{event["target"].inspect} name=#{event["name"].inspect} data=#{event["data"].inspect}"
+          )
+        end
+
+        def reset_mount_state(page)
+          page.instance_variable_set(:@overlay_container_mounted, false)
+          page.instance_variable_set(:@dialogs_container_mounted, false)
+          page.instance_variable_set(:@services_container_mounted, false)
+        end
+
         def pseudo_uuid
           now = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
           rnd = rand(0..0xffff_ffff)

data/lib/ruflet/rails/protocol/runner.rb

@@ -8,27 +8,40 @@ module Ruflet
           @entrypoint = entrypoint
         end
 
-        def build_endpoint(path: "/")
+        def build_endpoint(path: nil)
           raise ArgumentError, "Ruflet::Rails::Protocol endpoint requires a block" unless @entrypoint.respond_to?(:call)
 
           Endpoint.new(server: build_server(@entrypoint), path: path)
         end
 
-        def build_mobile_endpoint(file_path:, path: "/")
-          loaded = MobileLoader.new(file_path).load!
-          Endpoint.new(server: build_server(loaded[:entrypoint]), path: path)
+        def build_app_endpoint(file_path:, path: nil)
+          absolute = File.expand_path(file_path)
+          entrypoint = lambda do |page, env|
+            loaded = MobileLoader.new(absolute).load!
+            run_entrypoint(loaded[:entrypoint], page, env)
+          end
+
+          Endpoint.new(
+            server: build_server(entrypoint),
+            path: path
+          )
         end
+        alias build_mobile_endpoint build_app_endpoint
 
         private
 
         def build_server(entrypoint)
           LocalServer.new do |page|
             env = Context.current_env
-            if entrypoint.arity == 1
-              entrypoint.call(page)
-            else
-              entrypoint.call(page, env)
-            end
+            run_entrypoint(entrypoint, page, env)
+          end
+        end
+
+        def run_entrypoint(entrypoint, page, env)
+          if entrypoint.arity == 1
+            entrypoint.call(page)
+          else
+            entrypoint.call(page, env)
           end
         end
       end

data/lib/ruflet/rails/protocol/web_socket_connection.rb

@@ -1,126 +1,11 @@
 # frozen_string_literal: true
 
+require "ruflet_server"
+
 module Ruflet
   module Rails
     module Protocol
-      class WebSocketConnection
-        def initialize(socket)
-          @socket = socket
-          @write_mutex = Mutex.new
-        end
-
-        def session_key
-          @socket.object_id
-        end
-
-        def closed?
-          @socket.closed?
-        rescue IOError
-          true
-        end
-
-        def send_binary(payload)
-          send_frame(0x2, payload.to_s.b)
-        end
-
-        def read_message
-          frame = read_frame
-          return nil if frame.nil?
-
-          opcode = frame[:opcode]
-          payload = frame[:payload]
-
-          case opcode
-          when 0x8
-            close
-            nil
-          when 0x9
-            send_frame(0xA, payload)
-            read_message
-          when 0xA
-            read_message
-          when 0x1, 0x2
-            payload
-          else
-            read_message
-          end
-        end
-
-        def close
-          return if closed?
-
-          @socket.close
-        rescue IOError
-          nil
-        end
-
-        private
-
-        def read_frame
-          header = read_exact(2)
-          return nil if header.nil?
-
-          b1 = header.getbyte(0)
-          b2 = header.getbyte(1)
-
-          masked = (b2 & 0x80) != 0
-          payload_len = b2 & 0x7f
-
-          payload_len = read_exact(2).unpack1("n") if payload_len == 126
-          payload_len = read_exact(8).unpack1("Q>") if payload_len == 127
-
-          masking_key = masked ? read_exact(4) : nil
-          payload = payload_len.zero? ? "".b : read_exact(payload_len)
-          return nil if payload.nil?
-
-          payload = unmask(payload, masking_key) if masked
-
-          { opcode: b1 & 0x0f, payload: payload }
-        end
-
-        def send_frame(opcode, payload)
-          bytes = payload.to_s.b
-          len = bytes.bytesize
-          header = [0x80 | (opcode & 0x0f)].pack("C")
-
-          header <<
-            if len <= 125
-              [len].pack("C")
-            elsif len <= 0xffff
-              [126].pack("C") + [len].pack("n")
-            else
-              [127].pack("C") + [len].pack("Q>")
-            end
-
-          @write_mutex.synchronize do
-            @socket.write(header)
-            @socket.write(bytes) unless bytes.empty?
-          end
-        end
-
-        def unmask(payload, mask)
-          out = +""
-          out.force_encoding(Encoding::BINARY)
-          payload.bytes.each_with_index do |byte, idx|
-            out << (byte ^ mask.getbyte(idx % 4))
-          end
-          out
-        end
-
-        def read_exact(length)
-          chunk = +""
-          chunk.force_encoding(Encoding::BINARY)
-
-          while chunk.bytesize < length
-            part = @socket.read(length - chunk.bytesize)
-            return nil if part.nil? || part.empty?
-
-            chunk << part
-          end
-
-          chunk
-        end
-      end
+      WebSocketConnection = ::Ruflet::WebSocketConnection unless const_defined?(:WebSocketConnection, false)
     end
   end
 end

data/lib/ruflet/rails/protocol/wire_codec.rb

@@ -1,251 +1,11 @@
 # frozen_string_literal: true
 
+require "ruflet_server"
+
 module Ruflet
   module Rails
     module Protocol
-      class WireCodec
-        class << self
-          def pack(value)
-            case value
-            when NilClass
-              "\xc0".b
-            when TrueClass
-              "\xc3".b
-            when FalseClass
-              "\xc2".b
-            when Integer
-              pack_integer(value)
-            when Float
-              "\xcb".b + [value].pack("G")
-            when String
-              binary_string?(value) ? pack_binary(value) : pack_string(value)
-            when Symbol
-              pack_string(value.to_s)
-            when Array
-              pack_array(value)
-            when Hash
-              pack_map(value)
-            else
-              pack_string(value.to_s)
-            end
-          end
-
-          def unpack(bytes)
-            reader = ByteReader.new(bytes)
-            read_value(reader)
-          end
-
-          private
-
-          def pack_integer(value)
-            if value >= 0
-              return [value].pack("C") if value <= 0x7f
-              return "\xcc".b + [value].pack("C") if value <= 0xff
-              return "\xcd".b + [value].pack("n") if value <= 0xffff
-              return "\xce".b + [value].pack("N") if value <= 0xffff_ffff
-
-              "\xcf".b + [value].pack("Q>")
-            else
-              return [value & 0xff].pack("C") if value >= -32
-              return "\xd0".b + [value].pack("c") if value >= -128
-              return "\xd1".b + [value].pack("s>") if value >= -32_768
-              return "\xd2".b + [value].pack("l>") if value >= -2_147_483_648
-
-              "\xd3".b + [value].pack("q>")
-            end
-          end
-
-          def pack_string(value)
-            str = value.to_s.dup.force_encoding("UTF-8")
-            bytes = str.b
-            len = bytes.bytesize
-
-            if len <= 31
-              [0xA0 | len].pack("C") + bytes
-            elsif len <= 0xff
-              "\xd9".b + [len].pack("C") + bytes
-            elsif len <= 0xffff
-              "\xda".b + [len].pack("n") + bytes
-            else
-              "\xdb".b + [len].pack("N") + bytes
-            end
-          end
-
-          def pack_binary(value)
-            bytes = value.to_s.b
-            len = bytes.bytesize
-
-            if len <= 0xff
-              "\xc4".b + [len].pack("C") + bytes
-            elsif len <= 0xffff
-              "\xc5".b + [len].pack("n") + bytes
-            else
-              "\xc6".b + [len].pack("N") + bytes
-            end
-          end
-
-          def binary_string?(value)
-            value.encoding == Encoding::BINARY || !value.valid_encoding?
-          end
-
-          def pack_array(value)
-            len = value.length
-            head =
-              if len <= 15
-                [0x90 | len].pack("C")
-              elsif len <= 0xffff
-                "\xdc".b + [len].pack("n")
-              else
-                "\xdd".b + [len].pack("N")
-              end
-
-            body = +"".b
-            value.each { |item| body << pack(item) }
-            head + body
-          end
-
-          def pack_map(value)
-            pairs = value.each_with_object({}) { |(k, v), out| out[k.to_s] = v }
-            len = pairs.length
-            head =
-              if len <= 15
-                [0x80 | len].pack("C")
-              elsif len <= 0xffff
-                "\xde".b + [len].pack("n")
-              else
-                "\xdf".b + [len].pack("N")
-              end
-
-            body = +"".b
-            pairs.each do |k, v|
-              body << pack(k)
-              body << pack(v)
-            end
-            head + body
-          end
-
-          def read_value(reader)
-            marker = reader.read_u8
-
-            return marker if marker <= 0x7f
-            return marker - 256 if marker >= 0xe0
-
-            case marker
-            when 0xc0 then nil
-            when 0xc2 then false
-            when 0xc3 then true
-            when 0xcc then reader.read_u8
-            when 0xcd then reader.read_u16
-            when 0xce then reader.read_u32
-            when 0xcf then reader.read_u64
-            when 0xd0 then reader.read_i8
-            when 0xd1 then reader.read_i16
-            when 0xd2 then reader.read_i32
-            when 0xd3 then reader.read_i64
-            when 0xca then reader.read_f32
-            when 0xcb then reader.read_f64
-            when 0xd9 then reader.read_string(reader.read_u8)
-            when 0xda then reader.read_string(reader.read_u16)
-            when 0xdb then reader.read_string(reader.read_u32)
-            when 0xc4 then reader.read_binary(reader.read_u8)
-            when 0xc5 then reader.read_binary(reader.read_u16)
-            when 0xc6 then reader.read_binary(reader.read_u32)
-            when 0xdc then read_array(reader, reader.read_u16)
-            when 0xdd then read_array(reader, reader.read_u32)
-            when 0xde then read_map(reader, reader.read_u16)
-            when 0xdf then read_map(reader, reader.read_u32)
-            when 0xd4
-              read_ext(reader, 1)
-            when 0xd5
-              read_ext(reader, 2)
-            when 0xd6
-              read_ext(reader, 4)
-            when 0xd7
-              read_ext(reader, 8)
-            when 0xd8
-              read_ext(reader, 16)
-            when 0xc7
-              read_ext(reader, reader.read_u8)
-            when 0xc8
-              read_ext(reader, reader.read_u16)
-            when 0xc9
-              read_ext(reader, reader.read_u32)
-            else
-              if (marker & 0xf0) == 0x90
-                read_array(reader, marker & 0x0f)
-              elsif (marker & 0xf0) == 0x80
-                read_map(reader, marker & 0x0f)
-              elsif (marker & 0xe0) == 0xa0
-                reader.read_string(marker & 0x1f)
-              else
-                raise "Unsupported MessagePack marker: 0x#{marker.to_s(16)}"
-              end
-            end
-          end
-
-          def read_array(reader, size)
-            Array.new(size) { read_value(reader) }
-          end
-
-          def read_map(reader, size)
-            out = {}
-            size.times do
-              key = read_value(reader)
-              out[key.to_s] = read_value(reader)
-            end
-            out
-          end
-
-          def read_ext(reader, size)
-            type = reader.read_i8
-            data = reader.read_exact(size)
-
-            case type
-            when 1, 2, 4
-              data.dup.force_encoding("UTF-8")
-            when 3
-              data.to_i
-            else
-              data
-            end
-          end
-        end
-
-        class ByteReader
-          def initialize(bytes)
-            @data = bytes.to_s.b
-            @offset = 0
-          end
-
-          def read_u8
-            value = @data.getbyte(@offset)
-            raise "Unexpected EOF" if value.nil?
-
-            @offset += 1
-            value
-          end
-
-          def read_exact(size)
-            chunk = @data.byteslice(@offset, size)
-            raise "Unexpected EOF" if chunk.nil? || chunk.bytesize != size
-
-            @offset += size
-            chunk
-          end
-
-          def read_u16 = read_exact(2).unpack1("n")
-          def read_u32 = read_exact(4).unpack1("N")
-          def read_u64 = read_exact(8).unpack1("Q>")
-          def read_i8 = read_exact(1).unpack1("c")
-          def read_i16 = read_exact(2).unpack1("s>")
-          def read_i32 = read_exact(4).unpack1("l>")
-          def read_i64 = read_exact(8).unpack1("q>")
-          def read_f32 = read_exact(4).unpack1("g")
-          def read_f64 = read_exact(8).unpack1("G")
-          def read_string(size) = read_exact(size).force_encoding("UTF-8")
-          def read_binary(size) = read_exact(size)
-        end
-      end
+      WireCodec = ::Ruflet::WireCodec unless const_defined?(:WireCodec, false)
     end
   end
 end

data/lib/ruflet/rails/railtie.rb

@@ -7,19 +7,78 @@ module Ruflet
         app.middleware.use Ruflet::Rails::Protocol::Middleware
       end
 
+      initializer "ruflet_rails.desktop_launcher", after: :load_config_initializers do |_app|
+        next unless defined?(::Rails.root)
+
+        Ruflet::Rails::DesktopLauncher.launch_once(root: ::Rails.root)
+      end
+
       rake_tasks do
         namespace :ruflet do
           desc "Build Ruflet client for this Rails app. Usage: rake ruflet:build[web]"
           task :build, [:platform] do |_task, args|
-            platform = args[:platform].to_s.strip
-            if platform.empty?
-              warn "Usage: rake ruflet:build[apk|android|ios|aab|web|macos|windows|linux]"
+            requested_platform = args[:platform].to_s.strip.downcase
+            build_args = Ruflet::Rails::InstallSupport.build_args_for_platform(requested_platform)
+            platform = build_args.first
+            if platform.to_s.empty?
+              warn "Usage: rake ruflet:build[apk|android|ios|aab|web|desktop|macos|windows|linux]"
               next
             end
 
             require "ruflet/cli"
             exit_code = Dir.chdir(::Rails.root) do
-              Ruflet::CLI.command_build([platform])
+              Ruflet::CLI.command_build(build_args)
+            end
+            raise SystemExit, exit_code unless exit_code.to_i.zero?
+
+            if platform == "web"
+              published = Ruflet::Rails::InstallSupport.publish_web_build(::Rails.root.to_s)
+              if published
+                puts "Ruflet web client published at /#{Ruflet::Rails::InstallSupport.default_web_public_path}/"
+              else
+                warn "Ruflet web build completed, but build/web was not found to publish."
+              end
+            end
+          end
+
+          desc "Download/update prebuilt Ruflet clients from GitHub releases. Usage: rake ruflet:update[web|desktop|all]"
+          task :update, [:target] do |_task, args|
+            target = args[:target].to_s.strip
+            if target.empty?
+              warn "Usage: rake ruflet:update[web|desktop|all]"
+              next
+            end
+            normalized_target = target.downcase
+            platform = Ruflet::Rails::InstallSupport.host_desktop_platform
+
+            require "ruflet/cli"
+            exit_code = Dir.chdir(::Rails.root) do
+              Ruflet::CLI.command_update([target])
+            end
+            raise SystemExit, exit_code unless exit_code.to_i.zero?
+
+            if %w[web all].include?(normalized_target)
+              published = Ruflet::Rails::InstallSupport.publish_prebuilt_web_client(
+                ::Rails.root.to_s,
+                platform: platform
+              )
+              if published
+                puts "Ruflet web client published at /#{Ruflet::Rails::InstallSupport.default_web_public_path}/"
+              else
+                warn "Ruflet web client downloaded, but no prebuilt web index.html was found to publish."
+              end
+            end
+          end
+
+          desc "Install the last built Ruflet mobile app onto a device. Usage: rake ruflet:install[DEVICE_ID]"
+          task :install, [:device] do |_task, args|
+            argv = []
+            device = args[:device].to_s.strip
+            argv += ["--device", device] unless device.empty?
+
+            require "ruflet/cli"
+            exit_code = Dir.chdir(::Rails.root) do
+              Ruflet::CLI.command_install(argv)
             end
             raise SystemExit, exit_code unless exit_code.to_i.zero?
           end