ruflet_rails 0.0.14 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '097cfb74aac7af1e15b8bcb49135851595cbd7a1856eef1b4df39672c95ebab8'
-  data.tar.gz: 27d2e764c20535ebc41befd5672741500cb78387ee74f56ea284a60de9d8d721
+  metadata.gz: 92fa7112149cede7ab3ba1dfc0f0c235c662513f83c27a3bea423ef3f68a6664
+  data.tar.gz: 9903778b68c3b7fd3596509fd91036b3fc4775308b4d3728fafa93269a5d3bcc
 SHA512:
-  metadata.gz: ad4c0ab96a6741c9ff4339590e854abf2e72648a0b10c85bdf371ff7aaaee005e394f5063eecf9395756e1d9260d021a4d6c54737a8ad6326e811e63dca9d75a
-  data.tar.gz: c5aa7b3df32bedad4122d379739e05f770b8caa359e3ac01b114a29ee9c89bc7c5a3ecd175857dc79eaccb737b33bcd007d977086061b9ad25c9187872a2f994
+  metadata.gz: 81f65d75640995d5471a8fcfcb0c7fa99792a9de754978f0dee7f43d7dfb14e8db7a24bb3ff1bc826a060981c114c7caab138f50ba16cb6bcef52514ea56c03d
+  data.tar.gz: da622f66688a2f49208b13e5be0290e3fc8e19ed7c150bb135ac5f57b8c0f97ebc4e3de5db2f9901af1e87b96d2650cc1a730745a5535ee52738e1065fd055e0

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

@@ -155,7 +155,7 @@ module Ruflet
           html.include?("</head>") ? html.sub("</head>", "#{script}</head>") : "#{script}#{html}"
         end
 
-        # Pins Flet-style clients to <mount>/ws (derived from the rewritten
+        # Pins Ruflet clients to <mount>/ws (derived from the rewritten
         # <base href>) instead of the origin's /ws. The Ruflet client itself
         # uses the mounted page URL, so Rails needs no separate backend URL.
         def mount_websocket_bootstrap

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,268 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    module Protocol
+      class WireCodec
+        class << self
+          def pack(value)
+            case value
+            when ::Ruflet::Protocol::DateTimeValue
+              pack_extension(1, value)
+            when ::Ruflet::Protocol::TimeOfDayValue
+              pack_extension(2, value)
+            when ::Ruflet::Protocol::DurationValue
+              pack_extension(3, 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_extension(type, value)
+            bytes = value.to_s.b
+            length = bytes.bytesize
+            header =
+              if length <= 0xff
+                "\xc7".b + [length].pack("C")
+              elsif length <= 0xffff
+                "\xc8".b + [length].pack("n")
+              else
+                "\xc9".b + [length].pack("N")
+              end
+            header + [type].pack("c") + bytes
+          end
+
+          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
+            value = reader.read_exact(size).force_encoding("UTF-8")
+            case type
+            when 1 then ::Ruflet::Protocol.date_time(value)
+            when 2 then ::Ruflet::Protocol.time_of_day(value)
+            when 3 then ::Ruflet::Protocol.duration(value)
+            else value
+            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
+    end
+  end
+end

data/lib/ruflet/rails/railtie.rb

@@ -100,6 +100,25 @@ module Ruflet
           end
         end
       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]"
+              next
+            end
+
+            require "ruflet/cli"
+            exit_code = Dir.chdir(::Rails.root) do
+              Ruflet::CLI.command_build([platform])
+            end
+            raise SystemExit, exit_code unless exit_code.to_i.zero?
+          end
+        end
+      end
     end
   end
 end

data/lib/ruflet/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet_rails
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.16
 platform: ruby
 authors:
 - Adam Moussa Ali
@@ -29,42 +29,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.17
+        version: 0.0.19
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.17
+        version: 0.0.19
 - !ruby/object:Gem::Dependency
   name: ruflet_core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.17
+        version: 0.0.19
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.17
+        version: 0.0.19
 - !ruby/object:Gem::Dependency
   name: ruflet_server
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.17
+        version: 0.0.19
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.17
+        version: 0.0.19
 description: Build cross-platform mobile and desktop apps with Ruby on Rails using
   Ruflet.
 email:
@@ -94,7 +94,9 @@ files:
 - lib/ruflet/rails/protocol/mobile_loader.rb
 - lib/ruflet/rails/protocol/runner.rb
 - lib/ruflet/rails/protocol/web_app.rb
+- lib/ruflet/rails/protocol/web_socket_connection.rb
 - lib/ruflet/rails/protocol/websocket_detection.rb
+- lib/ruflet/rails/protocol/wire_codec.rb
 - lib/ruflet/rails/railtie.rb
 - lib/ruflet/rails/session_registry.rb
 - lib/ruflet/rails/view_helpers.rb