isomorfeus-transport 1.0.0.delta7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e31570f39250ea91f27fdc953fa0658868e4d56d7cd848483431863acf005d1a
+  data.tar.gz: 2d00bbef87e55ff8f5873f3faf603b55c48cb0ac874970f2fccd4bf8978b2dc0
+SHA512:
+  metadata.gz: cffbfe276aaf67746cb3f6ec0e8b47333169d0fc60b278cc034bef2ed3684d536dcfffd8038905aa2b97c16ac7bbf8cd6b9db25c9dfc25a4f063acc17be61dac
+  data.tar.gz: 667055f7067f7aef78ae133556e75d930ac4782c787b517e5db964834c2e8e0a6998c275de00687a6dbe0823a6463a6fd87d2131486a6a5a2963f7af9e436b9a

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+# isomorfeus-transport
+
+Transport and PubSub for isomorfeus.
+
+### Community and Support
+At the [Isomorfeus Framework Project](http://isomorfeus.com) 
+
+## Installation
+isomorfeus-transport is usually installed with the installer.
+Otherwise add to your Gemfile:
+```ruby
+gem 'isomorfeus-transport'
+```
+and bundle install/update
+
+## Server Side Rendering
+`yarn add ws`
+
+The 'ws' module then needs to be imported in application_ssr.js:
+```
+import WebSocket from 'ws';
+global.WebSocket = WebSocket;
+```
+
+## Configuration options
+
+Client and Server:
+- Isomorfeus.api_websocket_path - path for server side endpoint, default: `/isomorfeus/api/websocket`
+
+Server only:
+- Isomorfeus.middlewares - all the rack middlewares to load
+
+
+## LucidChannel
+
+Isomorfeus-transport provides the LucidChannel::Mixin and LucidChannel::Base class.
+These can be used for subscriptions and publishing messages.
+
+### Subscriptions
+```ruby
+class MyChannel < LucidChannel::Base
+end
+
+# subscribe to channel
+MyChannel.subscribe
+
+# unsubscribe
+MyChannel.unsubscribe
+```
+
+### Processing messages
+```ruby
+class MyChannel < LucidChannel::Base
+  on_message do |message|
+    puts "received: " + message
+  end
+end
+```
+
+### Sending mesages
+```ruby
+MyChannel.send_message('uiuiui')
+```

data/lib/isomorfeus-transport.rb

@@ -0,0 +1,44 @@
+if RUBY_ENGINE == 'opal'
+  require 'json'
+  require 'isomorfeus/config'
+  require 'isomorfeus/execution_environment'
+  require 'isomorfeus/transport/version'
+  require 'isomorfeus/transport/config'
+  require 'isomorfeus/transport/request_agent'
+  require 'isomorfeus/transport/client_processor'
+  require 'isomorfeus/transport/websocket'
+  require 'isomorfeus/transport'
+  require 'lucid_channel/mixin'
+  require 'lucid_channel/base'
+  Isomorfeus::Transport.init!
+else
+  require 'base64'
+  require 'digest'
+  require 'socket'
+  require 'oj'
+  require 'websocket/driver'
+  require 'active_support'
+  require 'iodine'
+  require 'isomorfeus/config'
+  require 'isomorfeus/promise'
+  require 'isomorfeus/transport/version'
+  require 'isomorfeus/transport/config'
+  require 'isomorfeus/transport/middlewares'
+  require 'isomorfeus/transport/request_agent'
+  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)
+
+  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')))
+  end
+end

data/lib/isomorfeus/handler.rb

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

data/lib/isomorfeus/transport.rb

@@ -0,0 +1,141 @@
+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
+          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
+
+      def promise_send_path(*path, &block)
+        request = {}
+        path.inject(request) do |memo, key|
+          memo[key] = {}
+        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)
+          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})`)
+        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
+        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})`)
+        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
+
+      def busy?
+        @requests_in_progress.size != 0
+      end
+
+      def requests_in_progress
+        @requests_in_progress
+      end
+
+      def request_in_progress?(request)
+        @requests_in_progress[:requests].key?(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 register_request_in_progress(request, agent_id)
+        @requests_in_progress[:requests][request] = agent_id
+        @requests_in_progress[:agent_ids][agent_id] = request
+      end
+
+      def unregister_request_in_progress(agent_id)
+        request = @requests_in_progress[:agent_ids].delete(agent_id)
+        @requests_in_progress[:requests].delete(request)
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/client_processor.rb

@@ -0,0 +1,26 @@
+module Isomorfeus
+  module Transport
+    class ClientProcessor
+      def self.process(json_hash)
+        if json_hash.key?(:response)
+          process_response(json_hash)
+        elsif json_hash.key?(:notification)
+          process_notification(json_hash)
+        end
+      end
+
+      def self.process_notification(notification_hash)
+        processor_class = "::#{notification_hash[:notification][:class]}".constantize
+        processor_class.process_message(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)
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/config.rb

@@ -0,0 +1,42 @@
+module Isomorfeus
+  # available settings
+
+  if RUBY_ENGINE == 'opal'
+    add_client_option(:api_websocket_path)
+  else
+    # defaults
+    class << self
+      attr_accessor :api_websocket_path
+      attr_accessor :middlewares
+
+      def add_middleware(middleware)
+        Isomorfeus.middlewares << middleware unless Isomorfeus.middlewares.include?(middleware)
+      end
+
+      def insert_middleware_after(existing_middleware, new_middleware)
+        index_of_existing = Isomorfeus.middlewares.index(existing_middleware)
+        unless Isomorfeus.middlewares.include?(new_middleware)
+          if index_of_existing
+            Isomorfeus.middlewares.insert(index_of_existing + 1, new_middleware)
+          else
+            Isomorfeus.middlewares << new_middleware
+          end
+        end
+      end
+
+      def insert_middleware_before(existing_middleware, new_middleware)
+        index_of_existing = Isomorfeus.middlewares.index(existing_middleware)
+        unless Isomorfeus.middlewares.include?(new_middleware)
+          if index_of_existing
+            Isomorfeus.middlewares.insert(index_of_existing, new_middleware)
+          else
+            Isomorfeus.middlewares << new_middleware
+          end
+        end
+      end
+    end
+    self.middlewares = Set.new
+  end
+
+  self.api_websocket_path = '/isomorfeus/api/websocket'
+end

data/lib/isomorfeus/transport/middlewares.rb

@@ -0,0 +1,11 @@
+module Isomorfeus
+  module Transport
+    module Middlewares
+      def use_isomorfeus_middlewares
+        Isomorfeus.middlewares.each do |isomorfeus_middleware|
+          use isomorfeus_middleware
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/rack_middleware.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Isomorfeus
+  module Transport
+    class RackMiddleware
+      include Isomorfeus::Transport::ServerProcessor
+
+      WS_RESPONSE = [0, {}, []]
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if env['PATH_INFO'] == Isomorfeus.api_websocket_path
+          user = defined?(Warden::Manager) ? env['warden'].user : nil
+          if env['rack.upgrade?'] == :websocket
+            env['rack.upgrade'] = Isomorfeus::Transport::ServerSocketProcessor.new(env['rack.session'], user)
+          end
+          WS_RESPONSE
+        else
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/request_agent.rb

@@ -0,0 +1,28 @@
+module Isomorfeus
+  module Transport
+    class RequestAgent
+      def self.agents
+        @_agents ||= {}
+      end
+
+      def self.get(object_id)
+        agents[object_id]
+      end
+
+      def self.get!(object_id)
+        agents.delete(object_id.to_s)
+      end
+
+      attr_reader :id
+      attr_reader :promise
+      attr_reader :request
+
+      def initialize(request = nil)
+        @id = object_id.to_s
+        self.class.agents[@id] = self
+        @promise = Promise.new
+        @request = request
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/server_processor.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Isomorfeus
+  module Transport
+    module ServerProcessor
+      def process_request(client, session_id, current_user, request)
+        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!'}}
+              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
+            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!"}
+          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!'}
+          end
+        else
+          response[:response] = 'No such thing!'
+        end
+        response
+      end
+    end
+  end
+end

data/lib/isomorfeus/transport/server_socket_processor.rb

@@ -0,0 +1,30 @@
+module Isomorfeus
+  module Transport
+    class ServerSocketProcessor
+      include Isomorfeus::Transport::ServerProcessor
+
+      def initialize(session_id, user)
+        @session_id = session_id
+        @user = user
+      end
+
+      def on_message(client, data)
+        request_hash = Oj.load(data, mode: :strict)
+        result = process_request(client, @session_id, @user, request_hash)
+        client.write Oj.dump(result, mode: :strict)
+      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
+    end
+  end
+end

data/lib/isomorfeus/transport/version.rb

@@ -0,0 +1,5 @@
+module Isomorfeus
+  module Transport
+    VERSION = '1.0.0.delta7'
+  end
+end

data/lib/isomorfeus/transport/websocket.rb

@@ -0,0 +1,115 @@
+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 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 raise SendError.new('Cant send, connection is closing!')
+          when CLOSED then raise SendError.new('Cant send, connection is closed!')
+          end
+        end
+        alias_method :write,  :send
+
+        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
+        alias_method :write,  :send
+
+        private
+
+        def internal_on_close(event)
+          @on_close_block.call(event)
+          @thread.kill
+        end
+      end
+    end
+  end
+end

data/lib/lucid_channel/base.rb

@@ -0,0 +1,5 @@
+module LucidChannel
+  class Base
+    include LucidChannel::Mixin
+  end
+end

data/lib/lucid_channel/mixin.rb

@@ -0,0 +1,31 @@
+module LucidChannel
+  module Mixin
+    def self.included(base)
+      base.instance_exec do
+        def process_message(message)
+          if @message_processor
+            @message_processor.call(message)
+          else
+            puts "#{self} received: #{message}, but no processor defined!"
+          end
+        end
+
+        def on_message(&block)
+          @message_processor = block
+        end
+
+        def send_message(message)
+          Isomorfeus::Transport.send_notification(self, message)
+        end
+
+        def subscribe
+          Isomorfeus::Transport.subscribe(self)
+        end
+
+        def unsubscribe
+          Isomorfeus::Transport.unsubscribe(self)
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: isomorfeus-transport
+version: !ruby/object:Gem::Version
+  version: 1.0.0.delta7
+platform: ruby
+authors:
+- Jan Biedermann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: iodine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.32
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.32
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-redux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.7
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-react
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 16.8.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 16.8.7
+- !ruby/object:Gem::Dependency
+  name: websocket-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+description: Various transport options for Isomorfeus.
+email: jan@kursator.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+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
+- lib/isomorfeus/transport/middlewares.rb
+- lib/isomorfeus/transport/rack_middleware.rb
+- lib/isomorfeus/transport/request_agent.rb
+- lib/isomorfeus/transport/server_processor.rb
+- lib/isomorfeus/transport/server_socket_processor.rb
+- lib/isomorfeus/transport/version.rb
+- lib/isomorfeus/transport/websocket.rb
+- lib/lucid_channel/base.rb
+- lib/lucid_channel/mixin.rb
+homepage: http://isomorfeus.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Various transport options for Isomorfeus.
+test_files: []