nio4r-websocket 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1d236ea0ed2486632c8d4deab40592bbc49d2e88
+  data.tar.gz: b13b3d9545f08e05f7387eb21f38d39245d21f57
+SHA512:
+  metadata.gz: 2e1b4039e7f6712d08be30096c3edce281c53b8b2768b5ac284bd779906ca129b39148b238edbd21b0bb149ea3e9b9988682fb6609114c2125ac270175dd7327
+  data.tar.gz: '0139edfb59b125dd4d8ba09c967d9e1f5a75da90d9bcfe22c1e619b0258be3fa1fb4c0a26b8f963ac97ca476f3126a3707c991a8e4136536c19a3249fe4cbb26'

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.vscode
+
+# rspec failure tracking
+.rspec_status
+
+.vagrant

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+

data/.travis.yml

@@ -0,0 +1,27 @@
+sudo: false
+language: ruby
+rvm:
+- 2.1.0
+- 2.2.2
+- 2.3.1
+- ruby-head
+matrix:
+  allow_failures:
+  - rvm: ruby-head
+before_script:
+- curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+- chmod +x ./cc-test-reporter
+- "./cc-test-reporter before-build"
+- ip a
+- cat /etc/hosts
+after_script:
+- cat Gemfile.lock
+- "./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT"
+deploy:
+  provider: rubygems
+  api_key:
+    secure: TcdJ+iGasCJJFqG9BqWBwsZrKKMTbvWJ+CNMeSYLLCuFOSW74m/A0DBkVddgaADlY1EYIkNkAAaFEaPgQsPunsll8wvAwbddXX5LOsrUaIk3gaYk3V8sudnn437HGsFIvMVQ8yg8fc25p2MMz/pCVPyb1JcMfRBHVDB4I39LUHthi24aGJJn2EZPgiarXYFbsiO/aMId22/Yxw32gG3+ULd2GAhxQ55zZzxfTzvwRian3U9kY4uO79a3rjKH9beSGXYfH3hecp0NEt65vEjwUnfohx7M4We9SHYLm3bEpPtLjUrI2eaaMbeY9bp3UkwVetsL3Ms4METU49sVbYwDrjt+H5s7GvSKdZt/ybmgJWu/Z7llUVrZzJLXRIpMTEGOYh2l+pgzOon+0fmKkcjSbveM6BCiQbMkt+kHHEGlm01VrZPlBeuhnl0ORAxTvAb9PZjs5/myrMrd7C+MAFp9xT+kJ3BodnhV8oPP8imHLqZiu3eAQBk6YtjEOJ3VPlk4VZzL2risXWdKpOeTXU/5WAJJLJmUWNFtfWDsd+EkxprTpNHzymNGUxR2m3OVdqlEwUELCggrkaSNVrYgBFVkrPz0Th23ALsd5YbN16p5eRVbozJP35SxHWQzmCj8Ye7vRgeIN9AyT6FSmuNTbJuPFFGPQaFDmpFkH/CreOXJFNU=
+  gem: nio4r-websocket
+  on:
+    tags: true
+    rvm: 2.3.1

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Sean Zachariasen
+
+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,84 @@
+# NIO::WebSocket [![Build Status](https://travis-ci.org/NexusSW/nio4r-websocket.svg?branch=master)](https://travis-ci.org/NexusSW/nio4r-websocket) [![Dependency Status](https://gemnasium.com/badges/github.com/NexusSW/nio4r-websocket.svg)](https://gemnasium.com/github.com/NexusSW/nio4r-websocket)
+
+[![Maintainability](https://api.codeclimate.com/v1/badges/cce01221d575804b09f5/maintainability)](https://codeclimate.com/github/NexusSW/nio4r-websocket/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/cce01221d575804b09f5/test_coverage)](https://codeclimate.com/github/NexusSW/nio4r-websocket/test_coverage) [![Gem Version](https://badge.fury.io/rb/nio4r-websocket.svg)](https://badge.fury.io/rb/nio4r-websocket)
+
+This gem ties websocket-driver, a transport agnostic WebSockets library, together with a nio4r driven socket implementation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nio4r-websocket'
+```
+
+And then execute:
+
+    bundle
+
+Or install it yourself as:
+
+    gem install nio4r-websocket
+
+## Usage
+
+[YARD Documentation](http://www.rubydoc.info/gems/nio4r-websocket/)
+
+The only usage patterns introduced by this module are in how to instantiate 'websocket-driver' objects.  Please refer to their documentation at <https://github.com/faye/websocket-driver-ruby#driver-api> on how to use them.
+
+Additionally, the WebSocket driver object will emit an `:io_error` event.  In the case that the underlying IO object gets disconnected, or otherwise closed without completing the `WebSocket::Driver#close` mechanism, you will be notified via subscribing to `:io_error` like:
+
+```ruby
+driver.on :io_error do
+  # some cleanup logic
+  # `driver.on :close` may or may not be called - likely not
+end
+```
+
+### Examples
+
+`require 'nio/websocket'`
+
+Client:
+
+```ruby
+NIO::WebSocket.connect 'wss://example.com/' do |driver|
+  driver.on :message do |event|
+    puts event.data
+  end
+  ... other wireup code (refer to 'websocket-driver' documentation)
+end
+```
+
+Server:
+
+```ruby
+NIO::WebSocket.listen port:443, ssl_context: { key: openssl_pkey_rsa_obj, cert: x509_cert_obj } do |driver|
+  driver.on :message do |event|
+    puts event.data
+  end
+  ... other wireup code (refer to 'websocket-driver' documentation)
+end
+```
+
+> Note: The above server block (`listen`) is executed on a per-connection basis
+
+### Options
+
+`NIO::WebSocket.listen` accepts `port:` and `address:` options.  Port is required, but address is optional for if you care to bind to a specific IP address on your host.
+
+Both `listen` and `NIO::WebSocket.connect` accept `websocket_options:` which is passed to the corresponding 'websocket-driver' calls.  Additionally, `ssl_context:` is available if you care to enable and customize your SSL experience.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/NexusSW/nio4r-websocket>.  Ensure that you sign off on all of your commits.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,5 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/Vagrantfile

@@ -0,0 +1,27 @@
+Vagrant.configure('2') do |config|
+  config.vm.box = 'ubuntu/trusty64'
+  config.vm.provider 'virtualbox' do |vb|
+    vb.memory = '512'
+  end
+  config.vm.provision 'chef_apply' do |chef|
+    chef.recipe = <<-RECIPE
+      apt_update 'update' do
+        action :nothing
+      end
+      apt_repository 'ruby-ng' do
+        uri 'ppa:brightbox/ruby-ng'
+        distribution node['lsb']['codename']
+        only_if { node['lsb']['codename'] == 'trusty' }
+        notifies :update, 'apt_update[update]', :immediately
+      end
+      package %w(git)
+      package %w(ruby2.1 ruby2.1-dev) do # raise/lower this if our minimum version ever changes - only affects local testing
+        only_if { node['lsb']['codename'] == 'trusty' }
+      end
+      gem_package 'bundler'
+      execute 'bundle install' do
+        cwd '/vagrant'
+      end
+    RECIPE
+  end
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'nio4r/websocket'
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/nio/websocket/adapter/client.rb

@@ -0,0 +1,18 @@
+require 'nio/websocket/adapter'
+
+module NIO
+  module WebSocket
+    class Adapter
+      class Client < Adapter
+        def initialize(url, io, options)
+          @url = url
+          driver = ::WebSocket::Driver.client(self, options[:websocket_options] || {})
+          super io, driver, options
+          WebSocket.logger.debug "Initiating handshake on #{io}"
+          driver.start
+        end
+        attr_reader :url
+      end
+    end
+  end
+end

data/lib/nio/websocket/adapter/server.rb

@@ -0,0 +1,20 @@
+require 'nio/websocket/adapter'
+
+module NIO
+  module WebSocket
+    class Adapter
+      class Server < Adapter
+        def initialize(io, options)
+          driver = ::WebSocket::Driver.server(self, options[:websocket_options] || {})
+          driver.on :connect do
+            if ::WebSocket::Driver.websocket? driver.env
+              driver.start
+              WebSocket.logger.debug 'driver connected'
+            end
+          end
+          super io, driver, options
+        end
+      end
+    end
+  end
+end

data/lib/nio/websocket/adapter.rb

@@ -0,0 +1,107 @@
+module NIO
+  module WebSocket
+    class Adapter
+      def initialize(io, driver, options)
+        @inner = io
+        @options = options
+        @driver = driver
+        @buffer = ''
+        @mutex = Mutex.new
+
+        driver.on :close do |ev|
+          WebSocket.logger.info "Driver initiated #{inner} close (code #{ev.code}): #{ev.reason}"
+          close :driver
+        end
+        driver.on :error do |ev|
+          WebSocket.logger.error "Driver reports error on #{inner}: #{ev.message}"
+          close :driver
+        end
+      end
+      attr_reader :inner, :options, :driver, :monitor
+
+      def teardown
+        @driver = nil # circular reference
+        monitor.close
+        inner.close
+      end
+
+      def close(from = nil)
+        return false if @closing
+
+        driver.close if from.nil?
+        @closing = true
+        monitor.interests = :rw
+        Reactor.selector.wakeup
+        true
+      end
+
+      def add_to_reactor
+        @monitor = Reactor.selector.register(inner, :rw) # This can block if this is the main thread and the reactor is busy
+        monitor.value = proc do
+          begin
+            read if monitor.readable?
+            pump_buffer if monitor.writable?
+          rescue Errno::ECONNRESET, EOFError
+            driver.force_state :closed
+            driver.emit :io_error
+            teardown
+            WebSocket.logger.info "#{inner} socket closed"
+          rescue IO::WaitReadable # rubocop:disable Lint/HandleExceptions
+          rescue IO::WaitWritable
+            monitor.interests = :rw
+          end
+          if @closing
+            if !monitor.readable? && @buffer.empty?
+              teardown
+              WebSocket.logger.info "#{inner} closed"
+            else
+              monitor.interests = :rw unless monitor.closed? # keep the :w interest so that our block runs each time
+              # edge case: if monitor was readable this time, and the write buffer is empty, if we emptied the read buffer this time our block wouldn't run again
+            end
+          end
+        end
+      end
+
+      def read
+        data = inner.read_nonblock(16384)
+        if data
+          WebSocket.logger.debug { "Incoming data on #{inner}:\n#{data}" } if WebSocket.log_traffic?
+          driver.parse data
+        end
+        data
+      end
+
+      def write(data)
+        @mutex.synchronize do
+          @buffer << data
+        end
+        return unless monitor
+        pump_buffer
+        Reactor.selector.wakeup unless monitor.interests == :r
+      end
+
+      def pump_buffer
+        @mutex.synchronize do
+          written = 0
+          begin
+            written = inner.write_nonblock @buffer unless @buffer.empty?
+            WebSocket.logger.debug { "Pumped #{written} bytes of data from buffer to #{inner}:\n#{@buffer}" } unless @buffer.empty? || !WebSocket.log_traffic?
+            @buffer = @buffer.byteslice(written..-1) if written > 0
+            WebSocket.logger.debug { "The buffer is now:\n#{@buffer}" } unless @buffer.empty? || !WebSocket.log_traffic?
+          rescue IO::WaitWritable, IO::WaitReadable
+            return written
+          ensure
+            monitor.interests = @buffer.empty? ? :r : :rw
+          end
+          written
+        end
+      end
+    end
+  end
+end
+
+class ::WebSocket::Driver
+  def force_state(newstate)
+    @ready_state = STATES.index newstate
+  end
+end

data/lib/nio/websocket/reactor.rb

@@ -0,0 +1,72 @@
+require 'nio'
+
+module NIO
+  module WebSocket
+    class Reactor
+      class << self
+        def queue_task(&blk)
+          return unless block_given?
+          task_mutex.synchronize do
+            @task_queue ||= []
+            @task_queue << blk
+          end
+          selector.wakeup
+        end
+
+        def selector
+          @selector ||= NIO::Selector.new
+        end
+
+        def reset
+          @reactor.exit if @reactor
+          @selector = nil
+          @reactor = nil
+          @task_queue = nil
+          @task_mutex = nil
+        end
+
+        def start
+          WebSocket.logger.debug 'Starting reactor' unless @reactor
+          @reactor ||= Thread.start do
+            Thread.current.abort_on_exception = true
+            WebSocket.logger.info 'Reactor started'
+            begin
+              loop do
+                queue = []
+                task_mutex.synchronize do
+                  queue = @task_queue || []
+                  @task_queue = []
+                end
+                # If something queues up while this runs, then the selector will also be awoken & won't block
+                queue.each(&:call)
+
+                selector.select 1 do |monitor|
+                  begin
+                    monitor.value.call if monitor.value.respond_to? :call
+                  rescue => e
+                    WebSocket.logger.error "Error occured in callback on socket #{monitor.io}.  No longer handling this connection."
+                    WebSocket.logger.error "#{e.class}: #{e.message}"
+                    e.backtrace.map { |s| WebSocket.logger.error "\t#{s}" }
+                    monitor.close # protect global loop from being crashed by a misbehaving driver, or a sloppy disconnect
+                  end
+                end
+                Thread.pass # give other threads a chance at manipulating our selector (e.g. a new connection on the main thread trying to register)
+              end
+            rescue => e
+              WebSocket.logger.fatal 'Error occured in reactor subsystem.'
+              WebSocket.logger.fatal "#{e.class}: #{e.message}"
+              e.backtrace.map { |s| WebSocket.logger.fatal "\t#{s}" }
+              raise
+            end
+          end
+        end
+
+        private
+
+        def task_mutex
+          @task_mutex ||= Mutex.new
+        end
+      end
+    end
+  end
+end

data/lib/nio/websocket/version.rb

@@ -0,0 +1,5 @@
+module NIO
+  module WebSocket
+    VERSION = '0.6.0'.freeze
+  end
+end

data/lib/nio/websocket.rb

@@ -0,0 +1,178 @@
+require 'nio/websocket/version'
+require 'websocket/driver'
+require 'nio'
+require 'socket'
+require 'uri'
+require 'openssl'
+require 'logger'
+require 'nio/websocket/reactor'
+require 'nio/websocket/adapter/client'
+require 'nio/websocket/adapter/server'
+
+module NIO
+  module WebSocket
+    class << self
+      # Returns the current logger, or creates one at level ERROR if one has not been assigned
+      # @return [Logger] the current logger instance
+      def logger
+        @logger ||= begin
+        logger = Logger.new(STDERR, progname: 'WebSocket', level: Logger::ERROR)
+        logger.level = Logger::ERROR
+        logger
+      end
+      end
+
+      attr_writer :logger
+
+      # Should raw traffic be logged through the logger?  Disabled by default for security reasons
+      # @param enable [Boolean]
+      def log_traffic=(enable)
+        @log_traffic = enable
+        logger.level = Logger::DEBUG if enable
+        enable
+      end
+
+      # Should raw traffic be logged through the logger?  Disabled by default for security reasons
+      def log_traffic?
+        @log_traffic
+      end
+
+      # Create and return a websocket client that communicates either over the given IO object (upgrades the connection),
+      # or we'll create a new connection to url if io is not supplied
+      # @param [String] url ws:// or wss:// location to connect
+      # @param [Hash] options
+      # @param [IO] io (DI) raw IO object to use in lieu of opening a new connection to url
+      # @option options [Hash] :websocket_options Hash to pass to the ::WebSocket::Driver.client
+      # @option options [Hash] :ssl_context Hash from which to create the OpenSSL::SSL::SSLContext object
+      # @yield [::WebSocket::Driver]
+      # @return [::WebSocket::Driver]
+      def connect(url, options = {}, io = nil)
+        io ||= open_socket(url, options)
+        adapter = CLIENT_ADAPTER.new(url, io, options)
+        yield(adapter.driver, adapter) if block_given?
+        Reactor.queue_task do
+          adapter.add_to_reactor
+        end
+        Reactor.start
+        logger.info "Client #{io} connected to #{url}"
+        adapter.driver
+      end
+
+      # Start handling new connections, passing each through the supplied block
+      # @param [Hash] options
+      # @param server [TCPServer] (DI) TCPServer-like object to use in lieu of starting a new server
+      # @option options [Integer] :port required: Port on which to listen for incoming connections
+      # @option options [String] :address optional: Specific Address on which to bind the TCPServer
+      # @option options [Hash] :websocket_options Hash to pass to the ::WebSocket::Driver.server
+      # @option options [Hash] :ssl_context Hash from which to create the OpenSSL::SSL::SSLContext object
+      # @yield [::WebSocket::Driver]
+      # @return server, as passed in, or a new TCPServer if no server was specified
+      def listen(options = {}, server = nil)
+        server ||= create_server(options)
+        Reactor.queue_task do
+          monitor = Reactor.selector.register(server, :r)
+          monitor.value = proc do
+            accept_socket server, options do |io| # this next block won't run until ssl (if enabled) has started
+              adapter = SERVER_ADAPTER.new(io, options)
+              yield(adapter.driver, adapter) if block_given?
+              Reactor.queue_task do
+                adapter.add_to_reactor
+              end
+              logger.info "Host accepted client connection #{io} on port #{options[:port]}"
+            end
+          end
+        end
+        Reactor.start
+        logger.info 'Host listening for new connections on port ' + options[:port].to_s
+        server
+      end
+
+      SERVER_ADAPTER = NIO::WebSocket::Adapter::Server
+      CLIENT_ADAPTER = NIO::WebSocket::Adapter::Client
+
+      # Resets this API to a fresh state
+      def reset
+        logger.info 'Resetting reactor subsystem'
+        Reactor.reset
+      end
+
+      # @!endgroup
+
+      private
+
+      # return an open socket given the url and options
+      def open_socket(url, options)
+        uri = URI(url)
+        port = uri.port || (uri.scheme == 'wss' ? 443 : 80) # redundant?  test uri.port if port is unspecified but because ws: & wss: aren't default protocols we'll maybe still need this(?)
+        logger.debug "Opening Connection to #{uri.hostname} on port #{port}"
+        io = TCPSocket.new uri.hostname, port
+        return io unless uri.scheme == 'wss'
+        logger.debug "Upgrading Connection #{io} to ssl"
+        ssl = upgrade_to_ssl(io, options).connect
+        logger.info "Connection #{io} upgraded to #{ssl}"
+        ssl
+      end
+
+      def create_server(options)
+        options[:address] ? TCPServer.new(options[:address], options[:port]) : TCPServer.new(options[:port])
+      end
+
+      # supply a block to run after protocol negotiation
+      def accept_socket(server, options)
+        waiting = accept_nonblock server
+        if [:r, :w].include? waiting
+          logger.warn 'Expected to receive new connection, but the server is not quite ready'
+          return
+        end
+        logger.debug "Receiving new connection #{waiting} on port #{options[:port]}"
+        if options[:ssl_context]
+          logger.debug "Upgrading Connection #{waiting} to ssl"
+          ssl = upgrade_to_ssl(waiting, options)
+          try_accept_nonblock ssl do
+            logger.info "Incoming connection #{waiting} upgraded to #{ssl}"
+            yield ssl
+          end
+        else
+          yield waiting
+        end
+      end
+
+      def try_accept_nonblock(io)
+        waiting = accept_nonblock io
+        if [:r, :w].include? waiting
+          # Only happens on server side ssl negotiation
+          Reactor.queue_task do
+            monitor = Reactor.selector.register(io, :rw)
+            monitor.value = proc do
+              waiting = accept_nonblock io
+              unless [:r, :w].include? waiting
+                monitor.close
+                yield waiting
+              end
+            end
+          end
+        else
+          yield waiting
+        end
+      end
+
+      def accept_nonblock(io)
+        return io.accept_nonblock
+      rescue IO::WaitReadable
+        return :r
+      rescue IO::WaitWritable
+        return :w
+      end
+
+      def upgrade_to_ssl(io, options)
+        store = OpenSSL::X509::Store.new
+        store.set_default_paths
+        ctx = OpenSSL::SSL::SSLContext.new
+        { cert_store: store, verify_mode: OpenSSL::SSL::VERIFY_PEER }.merge(options[:ssl_context] || {}).each do |k, v|
+          ctx.send "#{k}=", v if ctx.respond_to? k
+        end
+        OpenSSL::SSL::SSLSocket.new(io, ctx)
+      end
+    end
+  end
+end

data/nio4r-websocket.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nio/websocket/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'nio4r-websocket'
+  spec.version       = NIO::WebSocket::VERSION
+  spec.authors       = ['Sean Zachariasen']
+  spec.email         = ['thewyzard@hotmail.com']
+
+  spec.summary       = 'websocket-driver implementation built over nio4r'
+  spec.homepage      = 'https://github.com/nexussw/nio4r-websocket'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'nio4r', '>= 1.2.1', '< 3.0' # Allow older nio4r, if possible, so as to not lock our ruby version to 2.2.2
+  spec.add_dependency 'websocket-driver', '~> 0.7'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: nio4r-websocket
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Sean Zachariasen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-10-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nio4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: websocket-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- thewyzard@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- Vagrantfile
+- bin/console
+- bin/setup
+- lib/nio/websocket.rb
+- lib/nio/websocket/adapter.rb
+- lib/nio/websocket/adapter/client.rb
+- lib/nio/websocket/adapter/server.rb
+- lib/nio/websocket/reactor.rb
+- lib/nio/websocket/version.rb
+- nio4r-websocket.gemspec
+homepage: https://github.com/nexussw/nio4r-websocket
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: websocket-driver implementation built over nio4r
+test_files: []