websocket 1.1.4 → 1.2.0

data/.travis.yml

@@ -1,14 +1,10 @@
 language: ruby
 script: "bundle exec rake spec"
 rvm:
-  - 1.8.7
-  - 1.9.2
   - 1.9.3
   - 2.0.0
   - 2.1.1
-  - ree
-  - rbx
-  - jruby-18mode
+  - 2.1.2
+  - rbx-2
   - jruby-19mode
   - ruby-head
-  - jruby-head

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.2.0
+
+- Remove support for Ruby 1.8
+- Add support for sending custom headers for Client
+- Better detection and handling of draft 76
+- Multiple small fixes and optimizations
+
 ## 1.1.4
 
 - verify valid close codes according to spec

data/Gemfile

@@ -3,4 +3,5 @@ source "http://rubygems.org"
 gemspec
 
 gem 'rake'
-gem 'rspec', '~> 2.11'
+gem 'rspec', '~> 3.0.0'
+gem 'rspec-its'

data/README.md

@@ -1,10 +1,13 @@
 # WebSocket Ruby
 
-- Travis CI build: [![](https://travis-ci.org/imanel/websocket-ruby.png)](http://travis-ci.org/imanel/websocket-ruby)
-- Autobahn tests: [server](http://imanel.github.com/websocket-ruby/autobahn/server/), [client](http://imanel.github.com/websocket-ruby/autobahn/client/)
-
 Universal Ruby library to handle WebSocket protocol. It focuses on providing abstraction layer over [WebSocket API](http://dev.w3.org/html5/websockets/) instead of providing server or client functionality.
 
+[![Gem Version](https://badge.fury.io/rb/websocket.svg)](http://badge.fury.io/rb/websocket)
+[![Travis CI](https://travis-ci.org/imanel/websocket-ruby.png)](http://travis-ci.org/imanel/websocket-ruby)
+[![Code Climate](https://codeclimate.com/github/imanel/websocket-ruby.png)](https://codeclimate.com/github/imanel/websocket-ruby)
+
+**Autobahn tests:** [server](http://imanel.github.com/websocket-ruby/autobahn/server/), [client](http://imanel.github.com/websocket-ruby/autobahn/client/)
+
 Currently WebSocket Ruby supports all existing drafts of WebSocket, which include:
 
 - [hixie-75](http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75)
@@ -59,13 +62,14 @@ EOF
 ## Client handshake
 
 ``` ruby
-@handshake = WebSocket::Handshake::Client.new(:url => 'ws://example.com')
+@handshake = WebSocket::Handshake::Client.new(url: 'ws://example.com', headers: { 'Cookie' => 'SESSIONID=1234' })
 
 # Create request
 @handshake.to_s # GET /demo HTTP/1.1
                 # Upgrade: websocket
                 # Connection: Upgrade
                 # Host: example.com
+                # Cookie: SESSIONID=1234
                 # Sec-WebSocket-Origin: http://example.com
                 # Sec-WebSocket-Version: 13
                 # Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
@@ -90,11 +94,11 @@ EOF
 
 ``` ruby
 # Prepare frame for sending
-frame = WebSocket::Frame::Outgoing::Server.new(:version => @handshake.version, :data => "Hello", :type => :text)
+frame = WebSocket::Frame::Outgoing::Server.new(version: @handshake.version, data: "Hello", type: :text)
 frame.to_s # "\x81\x05\x48\x65\x6c\x6c\x6f"
 
 # Parse incoming frames
-frame = WebSocket::Frame::Incoming::Server.new(:version => @handshake.version)
+frame = WebSocket::Frame::Incoming::Server.new(version: @handshake.version)
 frame << "\x81\x05\x48\x65\x6c\x6c\x6f\x81\x06\x77\x6f\x72\x6c\x64\x21"
 frame.next # "Hello"
 frame.next # "world!""

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new do |t|
   t.pattern = 'spec/**/*_spec.rb'
 end
 
-task :default => :spec
+task default: :spec
 
 namespace :autobahn do
   desc "Run autobahn tests for client"

data/lib/websocket.rb

@@ -39,6 +39,6 @@ end
 
 # Try loading websocket-native if available
 begin
-  require "websocket-native"
+  require 'websocket-native'
 rescue LoadError
 end

data/lib/websocket/exception_handler.rb

@@ -17,6 +17,12 @@ module WebSocket
 
     module ClassMethods
 
+      # Rescue from WebSocket::Error errors.
+      #
+      # @param [String] method_name Name of method that should be wrapped and rescued
+      # @param [Hash] options Options for rescue
+      #
+      # @options options [Any] :return Value that should be returned instead of raised error
       def rescue_method(method_name, options = {})
         define_method "#{method_name}_with_rescue" do |*args|
           begin

data/lib/websocket/frame/base.rb

@@ -41,7 +41,7 @@ module WebSocket
 
       # Recreate inspect as #to_s was overwritten
       def inspect
-        vars = self.instance_variables.map{|v| "#{v}=#{instance_variable_get(v).inspect}"}.join(", ")
+        vars = self.instance_variables.map { |v| "#{v}=#{instance_variable_get(v).inspect}" }.join(', ')
         insp = "#{self.class}:0x%08x" % (self.__id__ * 2)
         "<#{insp} #{vars}>"
       end

data/lib/websocket/frame/data.rb

@@ -3,35 +3,37 @@ module WebSocket
     class Data < String
 
       def initialize(*args)
-        super *args.each { |arg| arg.force_encoding('ASCII-8BIT') if respond_to?(:force_encoding) }
+        super(*convert_args(args))
       end
 
       def <<(*args)
-        super *args.each { |arg| arg.force_encoding('ASCII-8BIT') if respond_to?(:force_encoding) }
+        super(*convert_args(args))
       end
 
+      # Convert all arguments to ASCII-8BIT for easier traversing
+      def convert_args(args)
+        args.each { |arg| arg.force_encoding('ASCII-8BIT') }
+      end
+
+      # Extract mask from 4 first bytes according to spec
       def set_mask
         raise WebSocket::Error::Frame::MaskTooShort if bytesize < 4
         @masking_key = self[0..3].bytes.to_a
       end
 
+      # Remove mask flag - it will still be present in payload
       def unset_mask
         @masking_key = nil
       end
 
+      # Extract `count` bytes starting from `start_index` and unmask it if needed.
       def getbytes(start_index, count)
         data = self[start_index, count]
         data = mask(data.bytes.to_a, @masking_key).pack('C*') if @masking_key
         data
       end
 
-      # Required for support of Ruby 1.8
-      unless new.respond_to?(:getbyte)
-        def getbyte(index)
-          self[index]
-        end
-      end
-
+      # Mask whole payload using mask key
       def mask(payload, mask)
         return mask_native(payload, mask) if respond_to?(:mask_native)
         result = []

data/lib/websocket/frame/handler.rb

@@ -2,7 +2,7 @@ module WebSocket
   module Frame
     module Handler
 
-      autoload :Base,     "#{::WebSocket::ROOT}/websocket/frame/handler/base"
+      autoload :Base,      "#{::WebSocket::ROOT}/websocket/frame/handler/base"
 
       autoload :Handler03, "#{::WebSocket::ROOT}/websocket/frame/handler/handler03"
       autoload :Handler04, "#{::WebSocket::ROOT}/websocket/frame/handler/handler04"

data/lib/websocket/frame/handler/handler03.rb

@@ -7,12 +7,12 @@ module WebSocket
 
         # Hash of frame names and it's opcodes
         FRAME_TYPES = {
-          :continuation => 0,
-          :close => 1,
-          :ping => 2,
-          :pong => 3,
-          :text => 4,
-          :binary => 5
+          continuation: 0,
+          close: 1,
+          ping: 2,
+          pong: 3,
+          text: 4,
+          binary: 5
         }
 
         # Hash of frame opcodes and it's names
@@ -37,12 +37,12 @@ module WebSocket
           if length <= 125
             byte2 = length # since rsv4 is 0
             frame << (byte2 | mask)
-          elsif length < 65536 # write 2 byte length
+          elsif length < 65_536 # write 2 byte length
             frame << (126 | mask)
             frame << [length].pack('n')
           else # write 8 byte length
             frame << (127 | mask)
-            frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
+            frame << [length >> 32, length & 0xFFFFFFFF].pack('NN')
           end
 
           if @frame.outgoing_masking?
@@ -83,16 +83,16 @@ module WebSocket
             payload_length = case length
             when 127 # Length defined by 8 bytes
               # Check buffer size
-              return if @frame.data.getbyte(pointer+8-1) == nil # Buffer incomplete
+              return if @frame.data.getbyte(pointer + 8 - 1) == nil # Buffer incomplete
 
               # Only using the last 4 bytes for now, till I work out how to
               # unpack 8 bytes. I'm sure 4GB frames will do for now :)
-              l = @frame.data.getbytes(pointer+4, 4).unpack('N').first
+              l = @frame.data.getbytes(pointer + 4, 4).unpack('N').first
               pointer += 8
               l
             when 126 # Length defined by 2 bytes
               # Check buffer size
-              return if @frame.data.getbyte(pointer+2-1) == nil # Buffer incomplete
+              return if @frame.data.getbyte(pointer + 2 - 1) == nil # Buffer incomplete
 
               l = @frame.data.getbytes(pointer, 2).unpack('n').first
               pointer += 2
@@ -108,7 +108,7 @@ module WebSocket
             raise(WebSocket::Error::Frame::TooLong) if frame_length > WebSocket.max_frame_size
 
             # Check buffer size
-            return if @frame.data.getbyte(frame_length-1) == nil # Buffer incomplete
+            return if @frame.data.getbyte(frame_length - 1) == nil # Buffer incomplete
 
             # Remove frame header
             @frame.data.slice!(0...pointer)
@@ -118,7 +118,7 @@ module WebSocket
             @frame.data.set_mask if mask
             pointer += 4 if mask
             application_data = @frame.data.getbytes(pointer, payload_length)
-            application_data.force_encoding('UTF-8') if application_data.respond_to?(:force_encoding)
+            application_data.force_encoding('UTF-8')
             pointer += payload_length
             @frame.data.unset_mask if mask
 
@@ -136,14 +136,14 @@ module WebSocket
               if frame_type == :continuation
                 @application_data_buffer << application_data
                 # Test valid UTF-8 encoding
-                raise(WebSocket::Error::Frame::InvalidPayloadEncoding) if @frame_type == :text && @application_data_buffer.respond_to?(:valid_encoding?) && !@application_data_buffer.valid_encoding?
-                message = @frame.class.new(:version => @frame.version, :type => @frame_type, :data => @application_data_buffer, :decoded => true)
+                raise(WebSocket::Error::Frame::InvalidPayloadEncoding) if @frame_type == :text && !@application_data_buffer.valid_encoding?
+                message = @frame.class.new(version: @frame.version, type: @frame_type, data: @application_data_buffer, decoded: true)
                 @application_data_buffer = nil
                 @frame_type = nil
                 return message
               else
-                raise(WebSocket::Error::Frame::InvalidPayloadEncoding) if frame_type == :text && application_data.respond_to?(:valid_encoding?) && !application_data.valid_encoding?
-                return @frame.class.new(:version => @frame.version, :type => frame_type, :data => application_data, :decoded => true)
+                raise(WebSocket::Error::Frame::InvalidPayloadEncoding) if frame_type == :text && !application_data.valid_encoding?
+                return @frame.class.new(version: @frame.version, type: frame_type, data: application_data, decoded: true)
               end
             end
           end

data/lib/websocket/frame/handler/handler07.rb

@@ -7,12 +7,12 @@ module WebSocket
 
         # Hash of frame names and it's opcodes
         FRAME_TYPES = {
-          :continuation => 0,
-          :text => 1,
-          :binary => 2,
-          :close => 8,
-          :ping => 9,
-          :pong => 10,
+          continuation: 0,
+          text: 1,
+          binary: 2,
+          close: 8,
+          ping: 9,
+          pong: 10,
         }
 
         # Hash of frame opcodes and it's names
@@ -42,11 +42,11 @@ module WebSocket
         private
 
         def valid_code?(code)
-          [1000,1001,1002,1003,1007,1008,1009,1010,1011].include?(code) || (3000..4999).include?(code)
+          [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011].include?(code) || (3000..4999).include?(code)
         end
 
         def valid_encoding?(data)
-          return true if data.nil? || !data.respond_to?(:encode)
+          return true if data.nil?
           data.encode('UTF-8')
           true
         rescue

data/lib/websocket/frame/handler/handler75.rb

@@ -16,8 +16,9 @@ module WebSocket
             when :close then "\xff\x00"
             when :text then
               ary = ["\x00", @frame.data, "\xff"]
-              ary.collect{ |s| s.encode('UTF-8', 'UTF-8', :invalid => :replace) if s.respond_to?(:encode) }
+              ary.map { |s| s.encode('UTF-8', 'UTF-8', invalid: :replace) }
               ary.join
+            else raise WebSocket::Error::Frame::UnknownFrameType
           end
         end
 
@@ -34,7 +35,7 @@ module WebSocket
             length = 0
 
             loop do
-              return if !@frame.data.getbyte(pointer)
+              return unless @frame.data.getbyte(pointer)
               b = @frame.data.getbyte(pointer)
               pointer += 1
               b_v = b & 0x7F
@@ -44,15 +45,15 @@ module WebSocket
 
             raise WebSocket::Error::Frame::TooLong if length > ::WebSocket.max_frame_size
 
-            unless @frame.data.getbyte(pointer+length-1) == nil
+            unless @frame.data.getbyte(pointer + length - 1) == nil
               # Straight from spec - I'm sure this isn't crazy...
               # 6. Read /length/ bytes.
               # 7. Discard the read bytes.
-              @frame.instance_variable_set '@data', @frame.data[(pointer+length)..-1]
+              @frame.instance_variable_set '@data', @frame.data[(pointer + length)..-1]
 
               # If the /frame type/ is 0xFF and the /length/ was 0, then close
               if length == 0
-                @frame.class.new(:version => @frame.version, :type => :close, :decoded => true)
+                @frame.class.new(version: @frame.version, type: :close, decoded: true)
               end
             end
           else
@@ -66,8 +67,8 @@ module WebSocket
             msg = @frame.data.slice!(/\A\x00[^\xff]*\xff/)
             if msg
               msg.gsub!(/\A\x00|\xff\z/, '')
-              msg.force_encoding('UTF-8') if msg.respond_to?(:force_encoding)
-              @frame.class.new(:version => @frame.version, :type => :text, :data => msg, :decoded => true)
+              msg.force_encoding('UTF-8')
+              @frame.class.new(version: @frame.version, type: :text, data: msg, decoded: true)
             end
           end
         end

data/lib/websocket/frame/incoming.rb

@@ -4,7 +4,7 @@ module WebSocket
     # @note You should NEVER use this class directly - use Client or Server subclasses instead, as they contain additional frame options(i.e. Client-side masking in draft 04)
     #
     # @example
-    #   frame = WebSocket::Frame::Incoming::Server.new(:version => @handshake.version)
+    #   frame = WebSocket::Frame::Incoming::Server.new(version: @handshake.version)
     #   frame << "\x81\x05\x48\x65\x6c\x6c\x6f\x81\x06\x77\x6f\x72\x6c\x64\x21"
     #   frame.next # "Hello"
     #   frame.next # "world!""

data/lib/websocket/frame/outgoing.rb

@@ -4,7 +4,7 @@ module WebSocket
     # @note You should NEVER use this class directly - use Client or Server subclasses instead, as they contain additional frame options(i.e. Client-side masking in draft 04)
     #
     # @example
-    #   frame = WebSocket::Frame::Outgoing::Server.new(:version => @handshake.version, :data => "Hello", :type => :text)
+    #   frame = WebSocket::Frame::Outgoing::Server.new(version: @handshake.version, data: "Hello", type: :text)
     #   frame.to_s # "\x81\x05\x48\x65\x6c\x6c\x6f"
     class Outgoing < Base
 

data/lib/websocket/handshake/base.rb

@@ -12,7 +12,7 @@ module WebSocket
         @state = :new
         @handler = nil
 
-        @data = ""
+        @data = ''
         @headers = {}
       end
 
@@ -24,13 +24,13 @@ module WebSocket
       # Return textual representation of handshake request or response
       # @return [String] text of response
       def to_s
-        @handler ? @handler.to_s : ""
+        @handler ? @handler.to_s : ''
       end
-      rescue_method :to_s, :return => ""
+      rescue_method :to_s, return: ''
 
       # Recreate inspect as #to_s was overwritten
       def inspect
-        vars = self.instance_variables.map{|v| "#{v}=#{instance_variable_get(v).inspect}"}.join(", ")
+        vars = self.instance_variables.map { |v| "#{v}=#{instance_variable_get(v).inspect}" }.join(', ')
         insp = "#{self.class}:0x%08x" % (self.__id__ * 2)
         "<#{insp} #{vars}>"
       end
@@ -46,7 +46,7 @@ module WebSocket
       def valid?
         finished? && @error == nil && @handler && @handler.valid?
       end
-      rescue_method :valid?, :return => false
+      rescue_method :valid?, return: false
 
       # @abstract Should send data after parsing is finished?
       def should_respond?
@@ -56,7 +56,7 @@ module WebSocket
       # Data left from parsing. Sometimes data that doesn't belong to handshake are added - use this method to retrieve them.
       # @return [String] String if some data are available. Nil otherwise
       def leftovers
-        @leftovers.split("\n", reserved_leftover_lines + 1)[reserved_leftover_lines]
+        @leftovers.to_s.split("\n", reserved_leftover_lines + 1)[reserved_leftover_lines]
       end
 
       # URI of request.
@@ -64,7 +64,7 @@ module WebSocket
       # @example
       #   @handshake.uri #=> "ws://example.com/path?query=true"
       def uri
-        uri =  secure ? "wss://" : "ws://"
+        uri =  secure ? 'wss://' : 'ws://'
         uri << host
         uri << ":#{port}" if port
         uri << path

data/lib/websocket/handshake/client.rb

@@ -5,7 +5,7 @@ module WebSocket
     # Construct or parse a client WebSocket handshake.
     #
     # @example
-    #   @handshake = WebSocket::Handshake::Client.new(:url => 'ws://example.com')
+    #   @handshake = WebSocket::Handshake::Client.new(url: 'ws://example.com')
     #
     #   # Create request
     #   @handshake.to_s # GET /demo HTTP/1.1
@@ -33,7 +33,7 @@ module WebSocket
     #
     class Client < Base
 
-      attr_reader :origin
+      attr_reader :origin, :headers
 
       # Initialize new WebSocket Client
       #
@@ -48,14 +48,16 @@ module WebSocket
       # @option args [String]  :url URL of request. Must by in format like ws://example.com/path?query=true. Every part of this url will be overriden by more specific arguments.
       # @option args [String]  :uri Alias to :url
       # @option args [Integer] :version Version of WebSocket to use. Default: 13 (this is version from RFC)
+      # @option args [Hash]    :headers HTTP headers to use in the handshake
       #
       # @example
-      #   Websocket::Handshake::Client.new(:url => "ws://example.com/path?query=true")
+      #   Websocket::Handshake::Client.new(url: "ws://example.com/path?query=true")
       def initialize(args = {})
         super
 
         @version = args[:version] || DEFAULT_VERSION
         @origin = args[:origin]
+        @headers = args[:headers] || {}
 
         if args[:url] || args[:uri]
           uri     = URI.parse(args[:url] || args[:uri])