websocket 1.1.4 → 1.2.0

data/lib/websocket/handshake/handler/base.rb

@@ -10,11 +10,11 @@ module WebSocket
 
         # @see WebSocket::Handshake::Base#to_s
         def to_s
-          result = [ header_line ]
+          result = [header_line]
           handshake_keys.each do |key|
             result << key.join(': ')
           end
-          result << ""
+          result << ''
           result << finishing_line
           result.join("\r\n")
         end
@@ -28,11 +28,11 @@ module WebSocket
         # Set first line of text representation according to specification.
         # @return [String] First line of HTTP header
         def header_line
-          ""
+          ''
         end
 
         # Set handshake headers. Provided as array because some protocol version require specific order of fields.
-        # @return [Array] List of headers as arrays [ key, value ]
+        # @return [Array] List of headers as arrays [key, value]
         def handshake_keys
           []
         end
@@ -40,7 +40,7 @@ module WebSocket
         # Set data to send after headers. In most cases it will be blank data.
         # @return [String] data
         def finishing_line
-          ""
+          ''
         end
 
       end

data/lib/websocket/handshake/handler/client.rb

@@ -8,10 +8,15 @@ module WebSocket
         # @see WebSocket::Handshake::Handler::Base#header_line
         def header_line
           path = @handshake.path
-          path += "?" + @handshake.query if @handshake.query
+          path += '?' + @handshake.query if @handshake.query
           "GET #{path} HTTP/1.1"
         end
 
+        # @see WebSocket::Handshake::Handler::Base#header_handshake_keys
+        def handshake_keys
+          super + @handshake.headers.to_a
+        end
+
       end
     end
   end

data/lib/websocket/handshake/handler/client04.rb

@@ -16,15 +16,16 @@ module WebSocket
         # @see WebSocket::Handshake::Handler::Base#handshake_keys
         def handshake_keys
           keys = [
-            ["Upgrade", "websocket"],
-            ["Connection", "Upgrade"]
+            ['Upgrade', 'websocket'],
+            ['Connection', 'Upgrade']
           ]
           host = @handshake.host
           host += ":#{@handshake.port}" if @handshake.port
-          keys << ["Host", host]
-          keys << ["Sec-WebSocket-Origin", @handshake.origin] if @handshake.origin
-          keys << ["Sec-WebSocket-Version", @handshake.version ]
-          keys << ["Sec-WebSocket-Key", key]
+          keys << ['Host', host]
+          keys += super
+          keys << ['Sec-WebSocket-Origin', @handshake.origin] if @handshake.origin
+          keys << ['Sec-WebSocket-Version', @handshake.version]
+          keys << ['Sec-WebSocket-Key', key]
           keys
         end
 

data/lib/websocket/handshake/handler/client75.rb

@@ -8,13 +8,14 @@ module WebSocket
         # @see WebSocket::Handshake::Handler::Base#handshake_keys
         def handshake_keys
           keys = [
-            ["Upgrade", "WebSocket"],
-            ["Connection", "Upgrade"]
+            ['Upgrade', 'WebSocket'],
+            ['Connection', 'Upgrade']
           ]
           host = @handshake.host
           host += ":#{@handshake.port}" if @handshake.port
-          keys << ["Host", host]
-          keys << ["Origin", @handshake.origin] if @handshake.origin
+          keys << ['Host', host]
+          keys << ['Origin', @handshake.origin] if @handshake.origin
+          keys += super
           keys
         end
 

data/lib/websocket/handshake/handler/client76.rb

@@ -53,8 +53,8 @@ module WebSocket
         def challenge
           return @challenge if defined?(@challenge)
           key1 && key2
-          sum = [@key1_number].pack("N*") +
-                [@key2_number].pack("N*") +
+          sum = [@key1_number].pack('N*') +
+                [@key2_number].pack('N*') +
                 key3
 
           @challenge = Digest::MD5.digest(sum)
@@ -63,7 +63,7 @@ module WebSocket
         # Verify if challenge sent by server match generated one
         # @return [Boolena] True if challenge matches, false otherwise(sets appropriate error)
         def verify_challenge
-          raise WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.instance_variable_get('@leftovers') == challenge
+          raise WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.leftovers == challenge
           true
         end
 
@@ -85,14 +85,14 @@ module WebSocket
           end
           spaces.times() do
             pos = 1 + rand(key.size - 1)
-            key[pos...pos] = " "
+            key[pos...pos] = ' '
           end
           return key
         end
 
         # Generate third key
         def generate_key3
-          [rand(0x100000000)].pack("N") + [rand(0x100000000)].pack("N")
+          [rand(0x100000000)].pack('N') + [rand(0x100000000)].pack('N')
         end
 
       end

data/lib/websocket/handshake/handler/server04.rb

@@ -15,28 +15,33 @@ module WebSocket
 
         # @see WebSocket::Handshake::Handler::Base#header_line
         def header_line
-          "HTTP/1.1 101 Switching Protocols"
+          'HTTP/1.1 101 Switching Protocols'
         end
 
         # @see WebSocket::Handshake::Handler::Base#handshake_keys
         def handshake_keys
           [
-            ["Upgrade", "websocket"],
-            ["Connection", "Upgrade"],
-            ["Sec-WebSocket-Accept", signature]
+            ['Upgrade', 'websocket'],
+            ['Connection', 'Upgrade'],
+            ['Sec-WebSocket-Accept', signature]
           ]
         end
 
         # Signature of response, created from client request Sec-WebSocket-Key
         # @return [String] signature
         def signature
-          return unless key = @handshake.headers['sec-websocket-key']
+          return unless key
           string_to_sign = "#{key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
           Base64.encode64(Digest::SHA1.digest(string_to_sign)).chomp
         end
 
         def verify_key
-          (@handshake.headers['sec-websocket-key'] ? true : raise(WebSocket::Error::Handshake::InvalidAuthentication))
+          raise WebSocket::Error::Handshake::InvalidAuthentication unless key
+          true
+        end
+
+        def key
+          @handshake.headers['sec-websocket-key']
         end
 
       end

data/lib/websocket/handshake/handler/server75.rb

@@ -7,16 +7,16 @@ module WebSocket
 
         # @see WebSocket::Handshake::Handler::Base#header_line
         def header_line
-          "HTTP/1.1 101 Web Socket Protocol Handshake"
+          'HTTP/1.1 101 Web Socket Protocol Handshake'
         end
 
         # @see WebSocket::Handshake::Handler::Base#handshake_keys
         def handshake_keys
           [
-            ["Upgrade", "WebSocket"],
-            ["Connection", "Upgrade"],
-            ["WebSocket-Origin", @handshake.headers['origin']],
-            ["WebSocket-Location", @handshake.uri]
+            ['Upgrade', 'WebSocket'],
+            ['Connection', 'Upgrade'],
+            ['WebSocket-Origin', @handshake.headers['origin']],
+            ['WebSocket-Location', @handshake.uri]
           ]
         end
 

data/lib/websocket/handshake/handler/server76.rb

@@ -19,16 +19,16 @@ module WebSocket
 
         # @see WebSocket::Handshake::Handler::Base#header_line
         def header_line
-          "HTTP/1.1 101 WebSocket Protocol Handshake"
+          'HTTP/1.1 101 WebSocket Protocol Handshake'
         end
 
         # @see WebSocket::Handshake::Handler::Base#handshake_keys
         def handshake_keys
           [
-            ["Upgrade", "WebSocket"],
-            ["Connection", "Upgrade"],
-            ["Sec-WebSocket-Origin", @handshake.headers['origin']],
-            ["Sec-WebSocket-Location", @handshake.uri]
+            ['Upgrade', 'WebSocket'],
+            ['Connection', 'Upgrade'],
+            ['Sec-WebSocket-Origin', @handshake.headers['origin']],
+            ['Sec-WebSocket-Location', @handshake.uri]
           ]
         end
 
@@ -45,10 +45,10 @@ module WebSocket
           # Refer to 5.2 4-9 of the draft 76
           first = numbers_over_spaces(@handshake.headers['sec-websocket-key1'].to_s)
           second = numbers_over_spaces(@handshake.headers['sec-websocket-key2'].to_s)
-          third = @handshake.instance_variable_get('@leftovers').strip
+          third = @handshake.leftovers.strip
 
-          sum = [first].pack("N*") +
-                [second].pack("N*") +
+          sum = [first].pack('N*') +
+                [second].pack('N*') +
                 third
           Digest::MD5.digest(sum)
         end
@@ -68,7 +68,7 @@ module WebSocket
 
           quotient = numbers / spaces
 
-          raise WebSocket::Error::Handshake::InvalidAuthentication if quotient > 2**32-1
+          raise WebSocket::Error::Handshake::InvalidAuthentication if quotient > 2**32 - 1
 
           return quotient
         end

data/lib/websocket/handshake/server.rb

@@ -38,7 +38,7 @@ module WebSocket
       # @option args [Boolean] :secure If true then server will use wss:// protocol
       #
       # @example
-      #   Websocket::Handshake::Server.new(:secure => true)
+      #   Websocket::Handshake::Server.new(secure: true)
       def initialize(args = {})
         super
         @secure = !!args[:secure]
@@ -61,9 +61,7 @@ module WebSocket
       #   EOF
       def <<(data)
         @data << data
-        if parse_data
-          set_version
-        end
+        set_version if parse_data
       end
       rescue_method :<<
 
@@ -73,31 +71,34 @@ module WebSocket
       # @example
       #   @handshake.from_rack(env)
       def from_rack(env)
-        @headers = env.select {|key, value|
+        @headers = env.select do |key, value|
           key =~ /\AHTTP_/
-        }.inject({}) {|memo, tuple|
+        end.reduce({}) do |memo, tuple|
           key, value = tuple
           memo[key.gsub(/\AHTTP_/, '').gsub('_', '-').downcase] = value
           memo
-        }
+        end
+
+        @path      = env['REQUEST_PATH']
+        @query     = env['QUERY_STRING']
 
-        @path      = env["REQUEST_PATH"]
-        @query     = env["QUERY_STRING"]
+        set_version
 
         # Passenger is blocking on read
         # Unicorn doesn't support readpartial
         # Maybe someone is providing even plain string?
         # Better safe than sorry...
-        input = env['rack.input']
-        @leftovers =  if input.respond_to?(:readpartial)
-                        input.readpartial
-                      elsif input.respond_to?(:read)
-                        input.read
-                      else
-                        input.to_s
-                      end
+        if @version == 76
+          input = env['rack.input']
+          @leftovers =  if input.respond_to?(:readpartial)
+                          input.readpartial
+                        elsif input.respond_to?(:read)
+                          input.read
+                        else
+                          input.to_s
+                        end
+        end
 
-        set_version
         @state = :finished
       end
 
@@ -112,8 +113,8 @@ module WebSocket
       #   @handshake.from_hash(hash)
       def from_hash(hash)
         @headers = hash[:headers] || {}
-        @path = hash[:path] || "/"
-        @query = hash[:query] || ""
+        @path = hash[:path] || '/'
+        @query = hash[:query] || ''
         @leftovers = hash[:body]
 
         set_version
@@ -129,13 +130,13 @@ module WebSocket
       # Host of server according to client header
       # @return [String] host
       def host
-        @headers["host"].to_s.split(":")[0].to_s
+        @headers['host'].to_s.split(':')[0].to_s
       end
 
       # Port of server according to client header
       # @return [String] port
       def port
-        @headers["host"].to_s.split(":")[1]
+        @headers['host'].to_s.split(':')[1]
       end
 
       private
@@ -144,7 +145,7 @@ module WebSocket
       def set_version
         @version = @headers['sec-websocket-version'].to_i if @headers['sec-websocket-version']
         @version ||= @headers['sec-websocket-draft'].to_i if @headers['sec-websocket-draft']
-        @version ||= 76 if @leftovers != ""
+        @version ||= 76 if @headers['sec-websocket-key1']
         @version ||= 75
         include_version
       end
@@ -169,7 +170,7 @@ module WebSocket
         line_parts = line.match(PATH)
         raise WebSocket::Error::Handshake::InvalidHeader unless line_parts
         method = line_parts[1].strip
-        raise WebSocket::Error::Handshake::GetRequestRequired unless method == "GET"
+        raise WebSocket::Error::Handshake::GetRequestRequired unless method == 'GET'
 
         resource_name = line_parts[2].strip
         @path, @query = resource_name.split('?', 2)

data/lib/websocket/version.rb

@@ -1,3 +1,3 @@
 module WebSocket
-  VERSION = '1.1.4'
+  VERSION = '1.2.0'
 end

data/spec/frame/incoming_03_spec.rb

@@ -1,9 +1,9 @@
 # encoding: binary
 require 'spec_helper'
 
-describe 'Incoming frame draft 03' do
+RSpec.describe 'Incoming frame draft 03' do
   let(:version) { 3 }
-  let(:frame) { WebSocket::Frame::Incoming.new(:version => version, :data => encoded_text) }
+  let(:frame) { WebSocket::Frame::Incoming.new(version: version, data: encoded_text) }
   let(:encoded_text) { nil }
   let(:decoded_text) { nil }
   let(:frame_type) { nil }
@@ -12,86 +12,86 @@ describe 'Incoming frame draft 03' do
 
   it_should_behave_like 'valid_incoming_frame'
 
-  context "should properly decode close frame" do
+  context 'should properly decode close frame' do
     let(:encoded_text) { "\x01\x05" + decoded_text }
     let(:frame_type) { :close }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should properly decode ping frame" do
+  context 'should properly decode ping frame' do
     let(:encoded_text) { "\x02\x05" + decoded_text }
     let(:frame_type) { :ping }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should properly decode pong frame" do
+  context 'should properly decode pong frame' do
     let(:encoded_text) { "\x03\x05" + decoded_text }
     let(:frame_type) { :pong }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should properly decode text frame" do
+  context 'should properly decode text frame' do
     let(:encoded_text) { "\x04\x05" + decoded_text }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
     let(:frame_type) { :text }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should properly decode text frame with continuation" do
+  context 'should properly decode text frame with continuation' do
     let(:encoded_text) { "\x84\x03Hel\x00\x02lo" }
     let(:frame_type)   { :text }
-    let(:decoded_text) { "Hello" }
+    let(:decoded_text) { 'Hello' }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should properly decode text frame in between of continuation" do
+  context 'should properly decode text frame in between of continuation' do
     let(:encoded_text) { "\x84\x03Hel\x03\x03abc\x00\x02lo" }
     let(:frame_type)   { [:pong, :text] }
-    let(:decoded_text) { ["abc", "Hello"] }
+    let(:decoded_text) { ['abc', 'Hello'] }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should not return unfinished more frame" do
+  context 'should not return unfinished more frame' do
     let(:encoded_text) { "\x84\x03Hel\x03\x03abc" }
     let(:frame_type)   { :pong }
-    let(:decoded_text) { "abc" }
+    let(:decoded_text) { 'abc' }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should properly decode 256 bytes binary frame" do
+  context 'should properly decode 256 bytes binary frame' do
     let(:encoded_text) { "\x05\x7E\x01\x00" + decoded_text }
     let(:frame_type) { :binary }
-    let(:decoded_text) { "a" * 256 }
+    let(:decoded_text) { 'a' * 256 }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should properly decode 64KiB binary frame" do
+  context 'should properly decode 64KiB binary frame' do
     let(:encoded_text) { "\x05\x7F\x00\x00\x00\x00\x00\x01\x00\x00" + decoded_text }
     let(:frame_type) { :binary }
-    let(:decoded_text) { "a" * 65536 }
+    let(:decoded_text) { 'a' * 65_536 }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should wait with incomplete frame" do
+  context 'should wait with incomplete frame' do
     let(:encoded_text) { "\x04\x06Hello" }
     let(:decoded_text) { nil }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should raise error with invalid opcode" do
+  context 'should raise error with invalid opcode' do
     let(:encoded_text) { "\x09\x05Hello" }
     let(:decoded_text) { nil }
     let(:error) { WebSocket::Error::Frame::UnknownOpcode }
@@ -99,15 +99,15 @@ describe 'Incoming frame draft 03' do
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should raise error with too long frame" do
-    let(:encoded_text) { "\x04\x7F" + "a" * WebSocket.max_frame_size }
+  context 'should raise error with too long frame' do
+    let(:encoded_text) { "\x04\x7F" + 'a' * WebSocket.max_frame_size }
     let(:decoded_text) { nil }
     let(:error) { WebSocket::Error::Frame::TooLong }
 
     it_should_behave_like 'valid_incoming_frame'
   end
 
-  context "should raise error with continuation frame without more frame earlier" do
+  context 'should raise error with continuation frame without more frame earlier' do
     let(:encoded_text) { "\x00\x05Hello" }
     let(:decoded_text) { nil }
     let(:error) { WebSocket::Error::Frame::UnexpectedContinuationFrame }