isomorfeus-transport 1.0.0.zeta23 → 2.0.0.rc2

data/lib/isomorfeus/transport/server_socket_processor.rb

@@ -1,54 +1,54 @@
-module Isomorfeus
-  module Transport
-    class ServerSocketProcessor
-      include Isomorfeus::Transport::ServerProcessor
-
-      def on_message(client, data)
-        if Isomorfeus.development?
-          write_lock = Isomorfeus.zeitwerk_lock.try_write_lock
-          if write_lock
-            Isomorfeus.zeitwerk.reload
-            Isomorfeus.zeitwerk_lock.release_write_lock
-          end
-          Isomorfeus.zeitwerk_lock.acquire_read_lock
-        end
-        request_hash = Oj.load(data, mode: :strict)
-        handler_instance_cache = {}
-        response_agent_array = []
-        Thread.current[:isomorfeus_user] = user(client)
-        Thread.current[:isomorfeus_pub_sub_client] = client
-        process_request(request_hash, handler_instance_cache, response_agent_array)
-        handler_instance_cache.each_value do |handler|
-          handler.resolve if handler.resolving?
-        end
-        result = {}
-        response_agent_array.each do |response_agent|
-          result.deep_merge!(response_agent.result)
-        end
-        client.write Oj.dump(result, mode: :strict)
-      ensure
-        Thread.current[:isomorfeus_user] = nil
-        Thread.current[:isomorfeus_pub_sub_client] = nil
-        Isomorfeus.zeitwerk_lock.release_read_lock if Isomorfeus.development?
-      end
-
-      def on_close(client)
-        # nothing for now
-      end
-
-      def on_open(client)
-        # nothing for now
-      end
-
-      def on_shutdown(client)
-        # nothing for now
-      end
-
-      def user(client)
-        current_user = client.instance_variable_get(:@isomorfeus_user)
-        return current_user if current_user
-        Anonymous.new
-      end
-    end
-  end
-end
+module Isomorfeus
+  module Transport
+    class ServerSocketProcessor
+      include Isomorfeus::Transport::ServerProcessor
+
+      def on_message(client, data)
+        if Isomorfeus.development?
+          write_lock = Isomorfeus.zeitwerk_lock.try_write_lock
+          if write_lock
+            Isomorfeus.zeitwerk.reload
+            Isomorfeus.zeitwerk_lock.release_write_lock
+          end
+          Isomorfeus.zeitwerk_lock.acquire_read_lock
+        end
+        request_hash = Oj.load(data, mode: :strict)
+        handler_instance_cache = {}
+        response_agent_array = []
+        Thread.current[:isomorfeus_user] = user(client)
+        Thread.current[:isomorfeus_pub_sub_client] = client
+        process_request(request_hash, handler_instance_cache, response_agent_array)
+        handler_instance_cache.each_value do |handler|
+          handler.resolve if handler.resolving?
+        end
+        result = {}
+        response_agent_array.each do |response_agent|
+          result.deep_merge!(response_agent.result)
+        end
+        client.write Oj.dump(result, mode: :strict) unless result.empty?
+      ensure
+        Thread.current[:isomorfeus_user] = nil
+        Thread.current[:isomorfeus_pub_sub_client] = nil
+        Isomorfeus.zeitwerk_lock.release_read_lock if Isomorfeus.development?
+      end
+
+      def on_close(client)
+        # nothing for now
+      end
+
+      def on_open(client)
+        # nothing for now
+      end
+
+      def on_shutdown(client)
+        # nothing for now
+      end
+
+      def user(client)
+        current_user = client.instance_variable_get(:@isomorfeus_user)
+        return current_user if current_user
+        Anonymous.new
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/ssr_login.rb

@@ -1,28 +1,28 @@
-module Isomorfeus
-  module Transport
-    class SsrLogin
-      def self.init
-        session_id = `global.IsomorfeusSessionId`
-        if session_id && session_id.size > 0
-          Isomorfeus::Transport.promise_send_path('Isomorfeus::Transport::Handler::AuthenticationHandler', 'ssr_login', session_id).then do |agent|
-            if agent.processed
-              agent.result
-            else
-              agent.processed = true
-              if agent.response.key?(:success)
-                Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.response[:data])
-                class_name = agent.response[:data].keys.first
-                key = agent.response[:data][class_name].keys.first
-                logged_in_user = Isomorfeus.cached_data_class(class_name).new(key: key)
-                Isomorfeus.set_current_user(logged_in_user)
-              else
-                error = agent.response[:error]
-                Isomorfeus.raise_error(message: "SSR Login failed, #{error}!") # triggers .fail
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module Isomorfeus
+  module Transport
+    class SsrLogin
+      def self.init
+        session_id = `global.IsomorfeusSessionId`
+        if session_id && session_id.size > 0
+          Isomorfeus::Transport.promise_send_path('Isomorfeus::Transport::Handler::AuthenticationHandler', 'ssr_login', session_id).then do |agent|
+            if agent.processed
+              agent.result
+            else
+              agent.processed = true
+              if agent.response.key?(:success)
+                Isomorfeus.store.dispatch(type: 'DATA_LOAD', data: agent.response[:data])
+                class_name = agent.response[:data].keys.first
+                key = agent.response[:data][class_name].keys.first
+                logged_in_user = Isomorfeus.cached_data_class(class_name).new(key: key)
+                Isomorfeus.set_current_user(logged_in_user)
+              else
+                error = agent.response[:error]
+                Isomorfeus.raise_error(message: "SSR Login failed, #{error}!") # triggers .fail
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/version.rb

@@ -1,5 +1,5 @@
-module Isomorfeus
-  module Transport
-    VERSION = '1.0.0.zeta23'
-  end
-end
+module Isomorfeus
+  module Transport
+    VERSION = '2.0.0.rc2'
+  end
+end

data/lib/isomorfeus/transport/{websocket.rb → websocket_client.rb}

@@ -1,123 +1,123 @@
-module Isomorfeus
-  module Transport
-    class Websocket
-      attr_reader :url
-
-      if RUBY_ENGINE == 'opal'
-        CONNECTING  = 0
-        OPEN        = 1
-        CLOSING     = 2
-        CLOSED      = 3
-
-        class SendError < StandardError; end
-
-        def initialize(url, protocols = nil)
-          @url = url
-          @native_websocket = if protocols
-                                `new Opal.global.WebSocket(url, protocols)`
-                              else
-                                `new Opal.global.WebSocket(url)`
-                              end
-        end
-
-        def close
-          @native_websocket.JS.close
-          nil
-        end
-
-        def on_close(&block)
-          @native_websocket.JS[:onclose] = `function(event) { block.$call(event); }`
-        end
-
-        def on_error(&block)
-          @native_websocket.JS[:onerror] = `function(event) { block.$call(event); }`
-        end
-
-        def on_message(&block)
-          @native_websocket.JS[:onmessage] = `function(event) { block.$call(event); }`
-        end
-
-        def on_open(&block)
-          @native_websocket.JS[:onopen] = `function(event) { block.$call(event); }`
-        end
-
-        def protocol
-          @native_websocket.JS[:protocol]
-        end
-
-        def send(data)
-          case ready_state
-          when OPEN then @native_websocket.JS.send(data)
-          when CONNECTING then Isomorfeus::Transport.delay(50) { send(data) }
-          when CLOSING then Isomorfeus.raise_error(error_class: SendError, message: 'Cant send, connection is closing!')
-          when CLOSED then Isomorfeus.raise_error(error_class: SendError.new, message: 'Cant send, connection is closed!')
-          end
-        end
-
-        private
-
-        def ready_state
-          @native_websocket.JS[:readyState]
-        end
-      else
-        def initialize(url, protocols = nil)
-          @url = url
-          parsed_url = URI.parse(url)
-          host = parsed_url.host
-          port = parsed_url.port
-          @socket = TCPSocket.new(host, port)
-          @driver = ::WebSocket::Driver.client(self)
-          @driver.on(:close, &method(:internal_on_close))
-
-          @thread = Thread.new do
-            begin
-              while data = @sock.readpartial(512)
-                @driver.parse(data)
-              end
-            end
-          end
-
-          @driver.start
-        end
-
-        def close
-          @driver.close
-          @thread.kill
-        end
-
-        def on_close(&block)
-          @on_close_block = block
-        end
-
-        def on_error(&block)
-          @driver.on(:error, block)
-        end
-
-        def on_message(&block)
-          @on_message_block = block
-        end
-
-        def on_open(&block)
-          @driver.on(:open, block)
-        end
-
-        def protocol
-          @driver.protocol
-        end
-
-        def send(data)
-          @socket.write(data)
-        end
-
-        private
-
-        def internal_on_close(event)
-          @on_close_block.call(event)
-          @thread.kill
-        end
-      end
-
-      alias_method :write,  :send
-    end
-  end
-end
+module Isomorfeus
+  module Transport
+    class WebsocketClient
+      attr_reader :url
+
+      if RUBY_ENGINE == 'opal'
+        CONNECTING  = 0
+        OPEN        = 1
+        CLOSING     = 2
+        CLOSED      = 3
+
+        class SendError < StandardError; end
+
+        def initialize(url, protocols = nil)
+          @url = url
+          @native_websocket = if protocols
+                                `new Opal.global.WebSocket(url, protocols)`
+                              else
+                                `new Opal.global.WebSocket(url)`
+                              end
+        end
+
+        def close
+          @native_websocket.JS.close
+          nil
+        end
+
+        def on_close(&block)
+          @native_websocket.JS[:onclose] = `function(event) { block.$call(event); }`
+        end
+
+        def on_error(&block)
+          @native_websocket.JS[:onerror] = `function(event) { block.$call(event); }`
+        end
+
+        def on_message(&block)
+          @native_websocket.JS[:onmessage] = `function(event) { block.$call(event); }`
+        end
+
+        def on_open(&block)
+          @native_websocket.JS[:onopen] = `function(event) { block.$call(event); }`
+        end
+
+        def protocol
+          @native_websocket.JS[:protocol]
+        end
+
+        def send(data)
+          case ready_state
+          when OPEN then @native_websocket.JS.send(data)
+          when CONNECTING then after(50) { send(data) }
+          when CLOSING then Isomorfeus.raise_error(error_class: SendError, message: 'Cant send, connection is closing!')
+          when CLOSED then Isomorfeus.raise_error(error_class: SendError.new, message: 'Cant send, connection is closed!')
+          end
+        end
+
+        private
+
+        def ready_state
+          @native_websocket.JS[:readyState]
+        end
+      else
+        def initialize(url, protocols = nil)
+          @url = url
+          parsed_url = URI.parse(url)
+          host = parsed_url.host
+          port = parsed_url.port
+          @socket = TCPSocket.new(host, port)
+          @driver = ::WebSocket::Driver.client(self)
+          @driver.on(:close, &method(:internal_on_close))
+
+          @thread = Thread.new do
+            begin
+              while data = @sock.readpartial(512)
+                @driver.parse(data)
+              end
+            end
+          end
+
+          @driver.start
+        end
+
+        def close
+          @driver.close
+          @thread.kill
+        end
+
+        def on_close(&block)
+          @on_close_block = block
+        end
+
+        def on_error(&block)
+          @driver.on(:error, block)
+        end
+
+        def on_message(&block)
+          @on_message_block = block
+        end
+
+        def on_open(&block)
+          @driver.on(:open, block)
+        end
+
+        def protocol
+          @driver.protocol
+        end
+
+        def send(data)
+          @socket.write(data)
+        end
+
+        private
+
+        def internal_on_close(event)
+          @on_close_block.call(event)
+          @thread.kill
+        end
+      end
+
+      alias_method :write,  :send
+    end
+  end
+end