isomorfeus-transport 1.0.0.delta8 → 1.0.0.delta9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cde5bb9a8184ee9449c57e97bf0fc1e1c30e1b9799a05abca1b7decee3638dd
-  data.tar.gz: cae8b98b3a0661bc72d5be62de219292bc5049933167ac9059accf8d9ded7975
+  metadata.gz: 1453febd89db3eba65151c490dacc155691317bced9a9f8bc00a6dff0b6500fb
+  data.tar.gz: 3b12ba839819d379f30be025154fdf44f57fd976af9c1c3cb8b3515483aabb2f
 SHA512:
-  metadata.gz: f77fe50f8e514237f814f3cb53052c04df023ad23956a4098b8266a1d7897abacc4e2e705fe2fb2b17192bc5ca5013341486262ba864f90f9ae411646254a2cd
-  data.tar.gz: 88aca3c427d3fa15473b46a21c92e11bdd82e00b2a98ec17faba8a0e2321077a2c08cfdc2495c68c6acaec8f2fa3eadd6e0e15e8fe7031e6ef2be77273a25bef
+  metadata.gz: 5b3cdb69387da257343607955a37ff372b154ea02a4af0ca528d716d357b0e0bb4bb24c62460e93da2db236c6d5554c4a6f7e0b26b3f1d53983c8df502acfa15
+  data.tar.gz: 6c8cc28a458254fd0e7ef5754d1daf90f658fa58f5e613cf898628cc57ee2b3b526f2a5ae795d8b74c3fbf9008f3328ef36e42de9f02ce52ea4c9a9816952474

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Jan Biedermann
+Copyright (c) 2018, 2019 Jan Biedermann
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/isomorfeus/transport/client_processor.rb

@@ -11,14 +11,16 @@ module Isomorfeus
 
       def self.process_notification(notification_hash)
         processor_class = "::#{notification_hash[:notification][:class]}".constantize
-        processor_class.process_message(notification_hash[:notification][:message])
+        processor_class.process_message(notification_hash[:notification][:channel], notification_hash[:notification][:message])
       end
 
       def self.process_response(response_hash)
         response_hash[:response][:agent_ids].keys.each do |agent_id|
           agent = Isomorfeus::Transport::RequestAgent.get!(agent_id)
           Isomorfeus::Transport.unregister_request_in_progress(agent_id)
-          agent.promise.resolve(agent_response: response_hash[:response][:agent_ids][agent_id], full_response: response_hash)
+          unless agent.promise.realized?
+            agent.promise.resolve(agent_response: response_hash[:response][:agent_ids][agent_id], full_response: response_hash)
+          end
         end
       end
     end

data/lib/isomorfeus/transport/config.rb

@@ -4,7 +4,6 @@ module Isomorfeus
   if RUBY_ENGINE == 'opal'
     add_client_option(:api_websocket_path)
   else
-    # defaults
     class << self
       attr_accessor :api_websocket_path
       attr_accessor :middlewares
@@ -34,9 +33,47 @@ module Isomorfeus
           end
         end
       end
+
+      def valid_channel_class_names
+        @valid_channel_class_names ||= Set.new
+      end
+
+      def valid_channel_class_name?(class_name)
+        valid_channel_class_names.include?(class_name)
+      end
+
+      def add_valid_channel_class(klass)
+        class_name = klass.name
+        class_name = class_name.split('>::').last if class_name.start_with?('#<')
+        valid_channel_class_names << class_name
+      end
+
+      def valid_handler_class_names
+        @valid_handler_class_names ||= Set.new
+      end
+
+      def valid_handler_class_name?(class_name)
+        valid_handler_class_names.include?(class_name)
+      end
+
+      def add_valid_handler_class(klass)
+        class_name = klass.name
+        class_name = class_name.split('>::').last if class_name.start_with?('#<')
+        valid_handler_class_names << class_name
+      end
+
+      def cached_handler_classes
+        @cached_handler_classes ||= {}
+      end
+
+      def cached_handler_class(class_name)
+        return cached_handler_classes[class_name] if cached_handler_classes.key?(class_name)
+        cached_handler_classes[class_name] = "::#{class_name}".constantize
+      end
     end
     self.middlewares = Set.new
   end
 
+  # defaults
   self.api_websocket_path = '/isomorfeus/api/websocket'
 end

data/lib/isomorfeus/transport/server_processor.rb

@@ -4,45 +4,68 @@ module Isomorfeus
   module Transport
     module ServerProcessor
       def process_request(client, session_id, current_user, request)
+        Thread.current[:isomorfeus_pub_sub_client] = client
+
         response = { response: { agent_ids: {}} }
 
         if request.key?('request') && request['request'].key?('agent_ids')
           request['request']['agent_ids'].keys.each do |agent_id|
-            request['request']['agent_ids'][agent_id].keys.each do |key|
-              handler = "::#{key.underscore.camelize}Handler".constantize
-              if handler
-                response[:response][:agent_ids][agent_id] = handler.new.process_request(client, session_id, current_user, request['request']['agent_ids'][agent_id][key], response)
-              else
-                response[:response][:agent_ids][agent_id] = { error: { key => 'No such handler!'}}
+            request['request']['agent_ids'][agent_id].keys.each do |handler_class_name|
+              begin
+                handler = Isomorfeus.cached_handler_class(handler_class_name) if Isomorfeus.valid_handler_class_name?(handler_class_name)
+                if handler
+                  result = handler.new.process_request(client, session_id, current_user, request['request']['agent_ids'][agent_id][handler_class_name], response)
+                  response[:response][:agent_ids][agent_id] = result
+                else
+                  response[:response][:agent_ids][agent_id] = { error: { handler_class_name => 'No such handler!'}}
+                end
+              rescue
+                response[:response][:agent_ids][agent_id] = { error: { handler_class_name => 'No such handler!'}}
               end
             end
           end
         elsif request.key?('notification')
-          if request['notification'].key?('class')
-            client.publish(request['notification']['class'], Oj.dump({ 'notification' => request['notification'] }, mode: :strict))
-          else
+          begin
+            channel = request['notification']['channel']
+            class_name =  request['notification']['class']
+            if Isomorfeus.valid_channel_class_name?(class_name) && channel
+              client.publish(request['notification']['channel'], Oj.dump({ 'notification' => request['notification'] }, mode: :strict))
+            else
+              response[:response] = 'No such thing!'
+            end
+          rescue
             response[:response] = 'No such thing!'
           end
         elsif request.key?('subscribe') && request['subscribe'].key?('agent_ids')
-          agent_id = request['subscribe']['agent_ids'].keys.first
-          channel = request['subscribe']['agent_ids'][agent_id]['class']
-          if channel
-            client.subscribe(channel)
-            response[:response][:agent_ids][agent_id] = { success: channel }
-          else
-            response[:response][:agent_ids][agent_id] = { error: "No such thing!"}
+          begin
+            agent_id = request['subscribe']['agent_ids'].keys.first
+            channel = request['subscribe']['agent_ids'][agent_id]['channel']
+            class_name = request['subscribe']['agent_ids'][agent_id]['class']
+            if Isomorfeus.valid_channel_class_name?(class_name) && channel
+              client.subscribe(channel)
+              response[:response][:agent_ids][agent_id] = { success: channel }
+            else
+              response[:response][:agent_ids][agent_id] = { error: "No such thing!"}
+            end
+          rescue
+            response[:response][:agent_ids][agent_id] = { error: { key => 'No such handler!'}}
           end
         elsif request.key?('unsubscribe') && request['unsubscribe'].key?('agent_ids')
-          agent_id = request['unsubscribe']['agent_ids'].keys.first
-          channel = request['unsubscribe']['agent_ids'][agent_id]['class']
-          if channel
-            client.unsubscribe(channel)
-            response[:response][:agent_ids][agent_id] = { success: channel }
-          else
-            response[:response][:agent_ids][agent_id] = { error: 'No such thing!'}
+          begin
+            agent_id = request['unsubscribe']['agent_ids'].keys.first
+            channel = request['unsubscribe']['agent_ids'][agent_id]['channel']
+            class_name = request['unsubscribe']['agent_ids'][agent_id]['class']
+            if Isomorfeus.valid_channel_class_name?(class_name) && channel
+              client.unsubscribe(channel)
+              response[:response][:agent_ids][agent_id] = { success: channel }
+            else
+              response[:response][:agent_ids][agent_id] = { error: 'No such thing!'}
+            end
+          rescue
+            response[:response][:agent_ids][agent_id] = { error: { key => 'No such handler!'}}
           end
         else
-          response[:response] = 'No such thing!'
+          response[:response] = { error: 'No such thing!'}
         end
         response
       end

data/lib/isomorfeus/transport/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   module Transport
-    VERSION = '1.0.0.delta8'
+    VERSION = '1.0.0.delta9'
   end
 end

data/lib/isomorfeus/transport/websocket.rb

@@ -45,7 +45,6 @@ module Isomorfeus
           when CLOSED then raise SendError.new('Cant send, connection is closed!')
           end
         end
-        alias_method :write,  :send
 
         private
 
@@ -101,7 +100,6 @@ module Isomorfeus
         def send(data)
           @socket.write(data)
         end
-        alias_method :write,  :send
 
         private
 
@@ -110,6 +108,8 @@ module Isomorfeus
           @thread.kill
         end
       end
+
+      alias_method :write,  :send
     end
   end
 end

data/lib/isomorfeus/transport.rb

@@ -1,141 +1,167 @@
 module Isomorfeus
   module Transport
     class << self
-      attr_accessor :socket
-
-      def delay(ms = 1000, &block)
-        `setTimeout(#{block.to_n}, ms)`
-      end
-
-      def init!
-        @requests_in_progress = { requests: {}, agent_ids: {} }
-        @socket = nil
-        connect if Isomorfeus.on_browser?
-      end
-
-      def connect
-        return if @socket && @socket.ready_state < 2
-        if Isomorfeus.on_browser?
-          window_protocol = `window.location.protocol`
-          ws_protocol = window_protocol == 'https:' ? 'wss:' : 'ws:'
-          ws_url = "#{ws_protocol}#{`window.location.host`}#{Isomorfeus.api_websocket_path}"
-        else
-          ws_url = Isomorfeus::TopLevel.transport_ws_url
-        end
-        @socket = Isomorfeus::Transport::Websocket.new(ws_url)
-        @socket.on_error do
-          @socket.close
-          delay do
-            Isomorfeus::Transport.connect
+      if RUBY_ENGINE == 'opal'
+        attr_accessor :socket
+
+        def delay(ms = 1000, &block)
+          `setTimeout(#{block.to_n}, ms)`
+        end
+
+        def init!
+          @requests_in_progress = { requests: {}, agent_ids: {} }
+          @socket = nil
+          connect if Isomorfeus.on_browser?
+        end
+
+        def connect
+          return if @socket && @socket.ready_state < 2
+          if Isomorfeus.on_browser?
+            window_protocol = `window.location.protocol`
+            ws_protocol = window_protocol == 'https:' ? 'wss:' : 'ws:'
+            ws_url = "#{ws_protocol}#{`window.location.host`}#{Isomorfeus.api_websocket_path}"
+          else
+            ws_url = Isomorfeus::TopLevel.transport_ws_url
           end
+          @socket = Isomorfeus::Transport::Websocket.new(ws_url)
+          @socket.on_error do
+            @socket.close
+            delay do
+              Isomorfeus::Transport.connect
+            end
+          end
+          @socket.on_message do |event|
+            json_hash = `Opal.Hash.$new(JSON.parse(event.data))`
+            Isomorfeus::Transport::ClientProcessor.process(json_hash)
+          end
+          true
+        end
+
+        def disconnect
+          @socket.close if @socket
+          @socket = nil
         end
-        @socket.on_message do |event|
-          json_hash = `Opal.Hash.$new(JSON.parse(event.data))`
-          Isomorfeus::Transport::ClientProcessor.process(json_hash)
+
+        def promise_send_path(*path, &block)
+          request = {}
+          path.inject(request) do |memo, key|
+            memo[key] = {}
+          end
+          Isomorfeus::Transport.promise_send_request(request, &block)
         end
-        true
-      end
 
-      def disconnect
-        @socket.close if @socket
-        @socket = nil
-      end
+        def promise_send_request(request, &block)
+          if request_in_progress?(request)
+            agent = get_agent_for_request_in_progress(request)
+          else
+            agent = Isomorfeus::Transport::RequestAgent.new(request)
+            if block_given?
+              agent.promise.then do |response|
+                block.call(response)
+              end
+            end
+            register_request_in_progress(request, agent.id)
+            @socket.send(`JSON.stringify(#{{request: { agent_ids: { agent.id => request }}}.to_n})`)
+            delay(Isomorfeus.on_ssr? ? 8000 : 20000) do
+              unless agent.promise.realized?
+                agent.promise.reject({agent_response: { error: 'Request timeout!' }, full_response: {}})
+              end
+            end
+          end
+          agent.promise
+        end
 
-      def promise_send_path(*path, &block)
-        request = {}
-        path.inject(request) do |memo, key|
-          memo[key] = {}
+        def send_notification(channel_class, channel, message)
+          @socket.send(`JSON.stringify(#{{notification: { class: channel_class.name, channel: channel, message: message}}.to_n})`)
+          true
         end
-        Isomorfeus::Transport.promise_send_request(request, &block)
-      end
 
-      def promise_send_request(request, &block)
-        if request_in_progress?(request)
-          agent = get_agent_for_request_in_progress(request)
-        else
-          agent = Isomorfeus::Transport::RequestAgent.new(request)
+        def subscribe(channel_class, channel, &block)
+          request = { subscribe: true, class: channel_class.name, channel: channel }
+          if request_in_progress?(request)
+            agent = get_agent_for_request_in_progress(request)
+          else
+            agent = Isomorfeus::Transport::RequestAgent.new(request)
+            register_request_in_progress(request, agent.id)
+            @socket.send(`JSON.stringify(#{{subscribe: { agent_ids: { agent.id => request }}}.to_n})`)
+          end
+          result_promise = agent.promise.then do |response|
+            response[:agent_response]
+          end
           if block_given?
-            agent.promise.then do |response|
+            result_promise = result_promise.then do |response|
               block.call(response)
             end
           end
-          register_request_in_progress(request, agent.id)
-          @socket.send(`JSON.stringify(#{{request: { agent_ids: { agent.id => request }}}.to_n})`)
-        end
-        agent.promise
-      end
-
-      def send_notification(processor_class, message)
-        @socket.send(`JSON.stringify(#{{notification: { class: processor_class.to_s, message: message}}.to_n})`)
-        true
-      end
-
-      def subscribe(processor_class, &block)
-        request = { subscribe: true, class: processor_class.to_s }
-        if request_in_progress?(request)
-          agent = get_agent_for_request_in_progress(request)
-        else
-          agent = Isomorfeus::Transport::RequestAgent.new(request)
-          register_request_in_progress(request, agent.id)
-          @socket.send(`JSON.stringify(#{{subscribe: { agent_ids: { agent.id => request }}}.to_n})`)
-        end
-        result_promise = agent.promise.then do |response|
-          response[:agent_response]
-        end
-        if block_given?
-          result_promise = result_promise.then do |response|
-            block.call(response)
-          end
+          result_promise
         end
-        result_promise
-      end
 
-      def unsubscribe(processor_class, &block)
-        request = { unsubscribe: true, class: processor_class.to_s }
-        if request_in_progress?(request)
-          agent = get_agent_for_request_in_progress(request)
-        else
-          agent = Isomorfeus::Transport::RequestAgent.new(request)
-          register_request_in_progress(request, agent.id)
-          @socket.send(`JSON.stringify(#{{unsubscribe: { agent_ids: { agent.id => request }}}.to_n})`)
+        def unsubscribe(channel_class, channel, &block)
+          request = { unsubscribe: true, class: channel_class.name, channel: channel }
+          if request_in_progress?(request)
+            agent = get_agent_for_request_in_progress(request)
+          else
+            agent = Isomorfeus::Transport::RequestAgent.new(request)
+            register_request_in_progress(request, agent.id)
+            @socket.send(`JSON.stringify(#{{unsubscribe: { agent_ids: { agent.id => request }}}.to_n})`)
+          end
+          result_promise = agent.promise.then do |response|
+            response[:agent_response]
+          end
+          if block_given?
+            result_promise = result_promise.then do |response|
+              block.call(response)
+            end
+          end
+          result_promise
         end
-        result_promise = agent.promise.then do |response|
-          response[:agent_response]
+
+        def busy?
+          @requests_in_progress[:requests].size != 0
         end
-        if block_given?
-          result_promise = result_promise.then do |response|
-            block.call(response)
-          end
+
+        def requests_in_progress
+          @requests_in_progress
         end
-        result_promise
-      end
 
-      def busy?
-        @requests_in_progress.size != 0
-      end
+        def request_in_progress?(request)
+          @requests_in_progress[:requests].key?(request)
+        end
 
-      def requests_in_progress
-        @requests_in_progress
-      end
+        def get_agent_for_request_in_progress(request)
+          agent_id = @requests_in_progress[:requests][request]
+          Isomorfeus::Transport::RequestAgent.get(agent_id)
+        end
 
-      def request_in_progress?(request)
-        @requests_in_progress[:requests].key?(request)
-      end
+        def register_request_in_progress(request, agent_id)
+          @requests_in_progress[:requests][request] = agent_id
+          @requests_in_progress[:agent_ids][agent_id] = request
+        end
 
-      def get_agent_for_request_in_progress(request)
-        agent_id = @requests_in_progress[:requests][request]
-        Isomorfeus::Transport::RequestAgent.get(agent_id)
-      end
+        def unregister_request_in_progress(agent_id)
+          request = @requests_in_progress[:agent_ids].delete(agent_id)
+          @requests_in_progress[:requests].delete(request)
+        end
+      else # RUBY_ENGINE
+        def send_notification(channel_class, channel, message)
+          Thread.current[:isomorfeus_pub_sub_client].publish(Oj.dump({notification: { class: channel_class.name, channel: channel, message: message}}, mode: :strict))
+          true
+        end
 
-      def register_request_in_progress(request, agent_id)
-        @requests_in_progress[:requests][request] = agent_id
-        @requests_in_progress[:agent_ids][agent_id] = request
-      end
+        def subscribe(channel_class, channel, &block)
+          Thread.current[:isomorfeus_pub_sub_client].subscribe(channel)
+          result_promise = Promise.new
+          result_promise.resolve({ success: channel })
+          result_promise
+        end
 
-      def unregister_request_in_progress(agent_id)
-        request = @requests_in_progress[:agent_ids].delete(agent_id)
-        @requests_in_progress[:requests].delete(request)
-      end
+        def unsubscribe(channel_class, channel, &block)
+          Thread.current[:isomorfeus_pub_sub_client].unsubscribe(channel)
+          result_promise = Promise.new
+          result_promise.resolve({ success: channel })
+          result_promise
+        end
+      end # RUBY_ENGINE
     end
   end
 end

data/lib/isomorfeus-transport.rb

@@ -1,3 +1,6 @@
+require 'opal'
+require 'opal-autoloader'
+require 'opal-activesupport'
 if RUBY_ENGINE == 'opal'
   require 'json'
   require 'isomorfeus/config'
@@ -10,6 +13,7 @@ if RUBY_ENGINE == 'opal'
   require 'isomorfeus/transport'
   require 'lucid_channel/mixin'
   require 'lucid_channel/base'
+  Opal::Autoloader.add_load_path('channels')
   Isomorfeus::Transport.init!
 else
   require 'base64'
@@ -28,17 +32,32 @@ else
   require 'isomorfeus/transport/server_processor'
   require 'isomorfeus/transport/server_socket_processor'
   require 'isomorfeus/transport/websocket'
-  require 'isomorfeus/handler'
   require 'isomorfeus/transport/rack_middleware'
-  Opal.append_path(__dir__.untaint) unless Opal.paths.include?(__dir__.untaint)
-
   require 'isomorfeus/transport/middlewares'
 
   Isomorfeus.add_middleware(Isomorfeus::Transport::RackMiddleware)
+  Isomorfeus.valid_channel_class_names
+
+  require 'lucid_handler/mixin'
+  require 'lucid_handler/base'
+  require 'lucid_channel/mixin'
+  require 'lucid_channel/base'
+
+  Opal.append_path(__dir__.untaint) unless Opal.paths.include?(__dir__.untaint)
+
+  require 'active_support'
+  require 'active_support/dependencies'
 
-  if Dir.exist?(File.join('app', 'isomorfeus'))
-    $LOAD_PATH.unshift(File.expand_path(File.join('app', 'isomorfeus', 'handlers')))
-  elsif Dir.exist?(File.join('isomorfeus'))
-    $LOAD_PATH.unshift(File.expand_path(File.join('isomorfeus', 'handlers')))
+  %w[channels handlers].each do |dir|
+    path = if Dir.exist?(File.join('app', 'isomorfeus'))
+             File.expand_path(File.join('app', 'isomorfeus', dir))
+           elsif Dir.exist?(File.join('isomorfeus'))
+             File.expand_path(File.join('isomorfeus', dir))
+           end
+    ActiveSupport::Dependencies.autoload_paths << path if path
+    # we also need to require them all, so classes are registered accordingly
+    Dir.glob("#{path}/**/*.rb").each do |file|
+      require file
+    end
   end
 end

data/lib/lucid_channel/base.rb

@@ -1,5 +1,11 @@
 module LucidChannel
   class Base
+    if RUBY_ENGINE != 'opal'
+      def self.inherited(base)
+        Isomorfeus.add_valid_channel_class(base)
+      end
+    end
+
     include LucidChannel::Mixin
   end
 end

data/lib/lucid_channel/mixin.rb

@@ -1,12 +1,21 @@
 module LucidChannel
   module Mixin
     def self.included(base)
+
+      if RUBY_ENGINE != 'opal'
+        Isomorfeus.add_valid_channel_class(base) unless base == LucidChannel::Base
+      end
+
       base.instance_exec do
-        def process_message(message)
+        def process_message(channel, message = nil)
           if @message_processor
-            @message_processor.call(message)
+            if channel == self.name
+              @message_processor.call(message)
+            else
+              @message_processor.call(channel, message)
+            end
           else
-            puts "#{self} received: #{message}, but no processor defined!"
+            puts "#{self} received: #{channel} #{message}, but no 'on_message' block defined!"
           end
         end
 
@@ -14,18 +23,24 @@ module LucidChannel
           @message_processor = block
         end
 
-        def send_message(message)
-          Isomorfeus::Transport.send_notification(self, message)
+        def send_message(channel, message = nil)
+          unless message
+            message = channel
+            channel = self.name
+          end
+          Isomorfeus::Transport.send_notification(self, channel, message)
         end
 
-        def subscribe
-          Isomorfeus::Transport.subscribe(self)
+        def subscribe(channel = nil)
+          channel = channel ? channel : self.name
+          Isomorfeus::Transport.subscribe(self, channel)
         end
 
-        def unsubscribe
-          Isomorfeus::Transport.unsubscribe(self)
+        def unsubscribe(channel = nil)
+          channel = channel ? channel : self.name
+          Isomorfeus::Transport.unsubscribe(self, channel)
         end
       end
     end
   end
-end
+end

data/lib/lucid_handler/base.rb

@@ -0,0 +1,9 @@
+module LucidHandler
+  class Base
+    def self.inherited(base)
+      Isomorfeus.add_valid_handler_class(base)
+    end
+
+    include LucidHandler::Mixin
+  end
+end

data/lib/lucid_handler/mixin.rb

@@ -0,0 +1,15 @@
+module LucidHandler
+  module Mixin
+    def self.included(base)
+      Isomorfeus.add_valid_handler_class(base) unless base == LucidHandler::Base
+
+      base.instance_exec do
+        def on_request(&block)
+          define_method :process_request do |*args|
+            block.call(*args)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-transport
 version: !ruby/object:Gem::Version
-  version: 1.0.0.delta8
+  version: 1.0.0.delta9
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-27 00:00:00.000000000 Z
+date: 2019-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: iodine
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.32
+        version: 0.7.33
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.32
+        version: 0.7.33
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -72,28 +72,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.7
+        version: 4.0.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.7
+        version: 4.0.8
 - !ruby/object:Gem::Dependency
   name: isomorfeus-react
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 16.8.7
+        version: 16.8.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 16.8.7
+        version: 16.8.8
 - !ruby/object:Gem::Dependency
   name: websocket-driver
   requirement: !ruby/object:Gem::Requirement
@@ -117,7 +117,6 @@ files:
 - LICENSE
 - README.md
 - lib/isomorfeus-transport.rb
-- lib/isomorfeus/handler.rb
 - lib/isomorfeus/transport.rb
 - lib/isomorfeus/transport/client_processor.rb
 - lib/isomorfeus/transport/config.rb
@@ -130,6 +129,8 @@ files:
 - lib/isomorfeus/transport/websocket.rb
 - lib/lucid_channel/base.rb
 - lib/lucid_channel/mixin.rb
+- lib/lucid_handler/base.rb
+- lib/lucid_handler/mixin.rb
 homepage: http://isomorfeus.com
 licenses:
 - MIT

data/lib/isomorfeus/handler.rb

@@ -1,5 +0,0 @@
-module Isomorfeus
-  module Handler
-    # for autoloader
-  end
-end