ruflet_rails 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd72bcdef15f680ca9f3e5ed3b724a3219852751c258210f3618c150829c31aa
-  data.tar.gz: 2cf6ada0236c8d0d6d679d4da8b6388e9f4b6749328c7b02efc5914855c07a05
+  metadata.gz: 192d25ccff11cbfc7a31a638a77df68daf83d24103b9580b2586ef91a2a0f7d3
+  data.tar.gz: 2ea8a4bf2c663a5a50d6d5f64426aa0420c70cf6dbc556d1c836cd41e7274a90
 SHA512:
-  metadata.gz: dc67519a6c904b0d437d0408bde5726b7c352563a2d8b77dc01125d59c4cbc5a0295130db2f0151484c3b0a2458d254785dd1442d28d54f5fa78cc14b96508a5
-  data.tar.gz: 99ef46cba567384d33d9604471c4206e7598c142e4799f3f4e417ce53b6b44b07deebcf5768c59401833b75b4c2bdc9c578ad48949d199a658eaf530d3a86e37
+  metadata.gz: d3e91b9375cf0df47090c8f736e50c241df1dc60a0418bc0519dadb3994a1337aa3fcfa49fb40d4bb9e3fb6f5c39337da3c9042450995203b6011301ec54dc99
+  data.tar.gz: d7f7021df9efd74b0c235c2ca59682eaf5ba11894b88d4c6967338c76615c691808a0630cd7d5d674db065a16ae6b2806b50f1b7534c4ea6cd25fe3db0342b28

data/README.md

@@ -9,9 +9,7 @@ No separate protocol gem is required.
 
 ```ruby
 # Gemfile
-path "/path/to/ruflet/packages" do
-  gem "ruflet_rails"
-end
+gem "ruflet_rails", ">= 0.0.2"
 ```
 
 ```ruby

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    module Protocol
+      class LocalServer
+        def initialize(&app_block)
+          @app_block = app_block
+          @sessions = {}
+          @sessions_mutex = Mutex.new
+        end
+
+        def handle_upgraded_socket(io)
+          ws = WebSocketConnection.new(io)
+          run_connection(ws)
+        end
+
+        private
+
+        def run_connection(ws)
+          while (raw = ws.read_message)
+            handle_message(ws, raw)
+          end
+        rescue StandardError => e
+          send_message(ws, Ruflet::Protocol::ACTIONS[:session_crashed], { "message" => e.message.to_s.dup.force_encoding("UTF-8") })
+        ensure
+          close_connection(ws)
+        end
+
+        def close_connection(ws)
+          return unless ws
+
+          remove_session(ws)
+          ws.close
+        end
+
+        def remove_session(ws)
+          @sessions_mutex.synchronize { @sessions.delete(ws.session_key) }
+        end
+
+        def handle_message(ws, raw)
+          action, payload = decode_incoming(raw)
+          payload ||= {}
+
+          case action
+          when Ruflet::Protocol::ACTIONS[:register_client], Ruflet::Protocol::ACTIONS[:register_web_client]
+            on_register_client(ws, payload)
+          when Ruflet::Protocol::ACTIONS[:control_event], Ruflet::Protocol::ACTIONS[:page_event_from_web]
+            on_control_event(ws, payload)
+          when Ruflet::Protocol::ACTIONS[:update_control], Ruflet::Protocol::ACTIONS[:update_control_props]
+            on_update_control(ws, payload)
+          when Ruflet::Protocol::ACTIONS[:invoke_control_method]
+            nil
+          else
+            raise "Unknown action: #{action.inspect}"
+          end
+        end
+
+        def decode_incoming(raw)
+          parsed = normalize_incoming(WireCodec.unpack(raw.to_s.b))
+
+          if parsed.is_a?(Array) && parsed.length >= 2
+            return [parsed[0], parsed[1]]
+          end
+
+          if parsed.is_a?(Hash)
+            action = parsed["action"] || parsed[:action]
+            payload = parsed["payload"] || parsed[:payload]
+            return [action, payload] unless action.nil?
+
+            if (parsed.key?("target") || parsed.key?(:target)) && (parsed.key?("name") || parsed.key?(:name))
+              return [Ruflet::Protocol::ACTIONS[:control_event], parsed]
+            end
+          end
+
+          raise "Unsupported payload format"
+        end
+
+        def normalize_incoming(value)
+          case value
+          when String
+            value.dup.force_encoding("UTF-8")
+          when Integer, Float, TrueClass, FalseClass, NilClass
+            value
+          when Symbol
+            value.to_s
+          when Array
+            value.map { |v| normalize_incoming(v) }
+          when Hash
+            value.each_with_object({}) do |(k, v), out|
+              out[k.to_s] = normalize_incoming(v)
+            end
+          else
+            value.to_s
+          end
+        end
+
+        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"]
+
+          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"
+
+          @sessions_mutex.synchronize { @sessions[ws.session_key] = page }
+
+          initial_response = [
+            Ruflet::Protocol::ACTIONS[:register_client],
+            Ruflet::Protocol.register_response(session_id: session_id)
+          ]
+          ws.send_binary(WireCodec.pack(initial_response))
+
+          @app_block.call(page)
+          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?
+
+          page.dispatch_event(
+            target: event["target"],
+            name: event["name"],
+            data: normalize_event_data(event["data"])
+          )
+        end
+
+        def on_update_control(ws, payload)
+          update = Ruflet::Protocol.normalize_update_control_payload(payload)
+          page = fetch_page(ws)
+          return if update["id"].nil?
+
+          page.apply_client_update(update["id"], update["props"] || {})
+        end
+
+        def fetch_page(ws)
+          page = @sessions_mutex.synchronize { @sessions[ws.session_key] }
+          raise "Session not found" unless page
+
+          page
+        end
+
+        def normalize_event_data(value)
+          case value
+          when Hash
+            value.each_with_object({}) { |(k, v), out| out[k.to_sym] = normalize_event_data(v) }
+          when Array
+            value.map { |entry| normalize_event_data(entry) }
+          else
+            value
+          end
+        end
+
+        def send_message(ws, action, payload)
+          ws.send_binary(WireCodec.pack([action, payload]))
+        rescue StandardError
+          nil
+        end
+
+        def pseudo_uuid
+          now = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+          rnd = rand(0..0xffff_ffff)
+          "%08x-%04x-%04x-%04x-%012x" % [
+            rnd,
+            now & 0xffff,
+            (now >> 16) & 0xffff,
+            (now >> 32) & 0xffff,
+            (now >> 48) & 0xffff_ffff_ffff
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module Ruflet
         private
 
         def build_server(entrypoint)
-          Ruflet::Server.new do |page|
+          LocalServer.new do |page|
             env = Context.current_env
             if entrypoint.arity == 1
               entrypoint.call(page)

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+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
+    end
+  end
+end

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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+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
+              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_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 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 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)
+            reader.read_i8
+            reader.read_exact(size)
+          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")
+        end
+      end
+    end
+  end
+end

data/lib/ruflet/rails/protocol.rb

@@ -2,7 +2,9 @@
 
 require_relative "protocol/context"
 require_relative "protocol/middleware"
+require_relative "protocol/wire_codec"
+require_relative "protocol/web_socket_connection"
+require_relative "protocol/local_server"
 require_relative "protocol/endpoint"
 require_relative "protocol/mobile_loader"
 require_relative "protocol/runner"
-require_relative "protocol/mount"

data/lib/ruflet/version.rb

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

data/lib/ruflet_rails.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+local_ruflet_lib = File.expand_path("../../ruflet/lib", __dir__)
+if File.directory?(local_ruflet_lib) && !$LOAD_PATH.include?(local_ruflet_lib)
+  $LOAD_PATH.unshift(local_ruflet_lib)
+end
+
 require "ruflet"
 require_relative "ruflet/rails/protocol"
 require_relative "ruflet/rails"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet_rails
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - AdamMusa
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: 0.0.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.2
+        version: 0.0.4
 description: Rails-first integration package for mounting Ruflet mobile apps in Rails
   routes.
 email:
@@ -50,14 +50,16 @@ files:
 - lib/ruflet/rails/protocol.rb
 - lib/ruflet/rails/protocol/context.rb
 - lib/ruflet/rails/protocol/endpoint.rb
+- lib/ruflet/rails/protocol/local_server.rb
 - lib/ruflet/rails/protocol/middleware.rb
 - lib/ruflet/rails/protocol/mobile_loader.rb
-- lib/ruflet/rails/protocol/mount.rb
 - lib/ruflet/rails/protocol/runner.rb
+- lib/ruflet/rails/protocol/web_socket_connection.rb
+- lib/ruflet/rails/protocol/wire_codec.rb
 - lib/ruflet/rails/railtie.rb
 - lib/ruflet/version.rb
 - lib/ruflet_rails.rb
-homepage: https://github.com/AdamMusa/Ruflet
+homepage: https://github.com/AdamMusa/ruflet/tree/main/packages/ruflet_rails
 licenses: []
 metadata: {}
 rdoc_options: []

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Ruflet
-  module Rails
-    module Protocol
-      class Mount
-        def initialize(app, file_path:, path: "/ws")
-          @app = app
-          @path = path
-          @endpoint = Runner.new.build_mobile_endpoint(file_path: file_path, path: "/")
-        end
-
-        def call(env)
-          return @app.call(env) unless env["PATH_INFO"] == @path
-
-          mounted_env = env.dup
-          mounted_env["PATH_INFO"] = "/"
-          @endpoint.call(mounted_env)
-        end
-      end
-    end
-  end
-end