Hello community, here is the log from the commit of package rubygem-websocket for openSUSE:Factory checked in at 2017-04-11 09:31:37 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rubygem-websocket (Old) and /work/SRC/openSUSE:Factory/.rubygem-websocket.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-websocket" Tue Apr 11 09:31:37 2017 rev:14 rq:456612 version:1.2.4 Changes: -------- --- /work/SRC/openSUSE:Factory/rubygem-websocket/rubygem-websocket.changes 2016-04-14 13:06:28.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.rubygem-websocket.new/rubygem-websocket.changes 2017-04-11 09:31:40.271435049 +0200 @@ -1,0 +2,10 @@ +Wed Feb 1 05:50:47 UTC 2017 - [email protected] + +- updated to version 1.2.4 + see installed CHANGELOG.md + + ## 1.2.4 + + - add subprotocol handling for both server and client + +------------------------------------------------------------------- Old: ---- websocket-1.2.3.gem New: ---- websocket-1.2.4.gem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rubygem-websocket.spec ++++++ --- /var/tmp/diff_new_pack.qZH5R0/_old 2017-04-11 09:31:41.091319255 +0200 +++ /var/tmp/diff_new_pack.qZH5R0/_new 2017-04-11 09:31:41.095318690 +0200 @@ -1,7 +1,7 @@ # # spec file for package rubygem-websocket # -# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -24,7 +24,7 @@ # Name: rubygem-websocket -Version: 1.2.3 +Version: 1.2.4 Release: 0 %define mod_name websocket %define mod_full_name %{mod_name}-%{version} ++++++ websocket-1.2.3.gem -> websocket-1.2.4.gem ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/.rubocop.yml new/.rubocop.yml --- old/.rubocop.yml 2016-04-05 12:57:30.000000000 +0200 +++ new/.rubocop.yml 2017-01-31 19:34:39.000000000 +0100 @@ -1,3 +1,6 @@ +AllCops: + DisplayCopNames: true + # Target: 15 Metrics/AbcSize: Max: 24 @@ -5,6 +8,10 @@ - lib/websocket/frame/handler/handler75.rb - spec/**/* +Metrics/BlockLength: + Exclude: + - spec/**/* + Metrics/ClassLength: Enabled: false diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/.travis.yml new/.travis.yml --- old/.travis.yml 2016-04-05 12:57:30.000000000 +0200 +++ new/.travis.yml 2017-01-31 19:34:39.000000000 +0100 @@ -1,12 +1,23 @@ language: ruby -script: "bundle exec rake spec" +script: "bundle exec rake" rvm: - 1.9.3 - 2.0 - 2.1 - 2.2 - - rbx-2 - - jruby-19mode + - 2.3 - ruby-head + - jruby + - jruby-head + - rbx + - rbx-head + +matrix: + allow_failures: + - rvm: ruby-head + - rvm: jruby-head + - rvm: rbx + - rvm: rbx-head + before_install: - gem install bundler diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/CHANGELOG.md new/CHANGELOG.md --- old/CHANGELOG.md 2016-04-05 12:57:30.000000000 +0200 +++ new/CHANGELOG.md 2017-01-31 19:34:39.000000000 +0100 @@ -1,5 +1,9 @@ # Changelog +## 1.2.4 + +- add subprotocol handling for both server and client + ## 1.2.3 - fix for draft 76 when challenge might sometimes fail diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Gemfile new/Gemfile --- old/Gemfile 2016-04-05 12:57:30.000000000 +0200 +++ new/Gemfile 2017-01-31 19:34:39.000000000 +0100 @@ -1,7 +1,3 @@ source 'http://rubygems.org' gemspec - -gem 'rake' -gem 'rspec', '~> 3.0.0' -gem 'rspec-its' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/README.md new/README.md --- old/README.md 2016-04-05 12:57:30.000000000 +0200 +++ new/README.md 2017-01-31 19:34:39.000000000 +0100 @@ -3,6 +3,7 @@ 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. [](http://badge.fury.io/rb/websocket) +[](https://rubygems.org/gems/websocket) [](http://travis-ci.org/imanel/websocket-ruby) [](https://codeclimate.com/github/imanel/websocket-ruby) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/Rakefile new/Rakefile --- old/Rakefile 2016-04-05 12:57:30.000000000 +0200 +++ new/Rakefile 2017-01-31 19:34:39.000000000 +0100 @@ -1,14 +1,17 @@ require 'bundler' -Bundler::GemHelper.install_tasks - require 'rspec/core/rake_task' +require 'rubocop/rake_task' + +Bundler::GemHelper.install_tasks RSpec::Core::RakeTask.new do |t| t.rspec_opts = ['-c', '-f progress'] t.pattern = 'spec/**/*_spec.rb' end -task default: :spec +RuboCop::RakeTask.new + +task default: [:spec, :rubocop] namespace :autobahn do desc 'Run autobahn tests for client' Binary files old/checksums.yaml.gz and new/checksums.yaml.gz differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/error.rb new/lib/websocket/error.rb --- old/lib/websocket/error.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/error.rb 2017-01-31 19:34:39.000000000 +0100 @@ -99,6 +99,12 @@ end end + class UnsupportedProtocol < ::WebSocket::Error::Handshake + def message + :unsupported_protocol + end + end + class InvalidStatusCode < ::WebSocket::Error::Handshake def message :invalid_status_code diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/frame/base.rb new/lib/websocket/frame/base.rb --- old/lib/websocket/frame/base.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/frame/base.rb 2017-01-31 19:34:39.000000000 +0100 @@ -36,7 +36,7 @@ # Implement in submodules def supported_frames - fail NotImplementedError + raise NotImplementedError end # Recreate inspect as #to_s was overwritten @@ -58,7 +58,7 @@ when 4 then Handler::Handler04.new(self) when 5..6 then Handler::Handler05.new(self) when 7..13 then Handler::Handler07.new(self) - else fail WebSocket::Error::Frame::UnknownVersion + else raise WebSocket::Error::Frame::UnknownVersion end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/frame/data.rb new/lib/websocket/frame/data.rb --- old/lib/websocket/frame/data.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/frame/data.rb 2017-01-31 19:34:39.000000000 +0100 @@ -16,7 +16,7 @@ # Extract mask from 4 first bytes according to spec def set_mask - fail WebSocket::Error::Frame::MaskTooShort if bytesize < 4 + raise WebSocket::Error::Frame::MaskTooShort if bytesize < 4 @masking_key = self[0..3].bytes.to_a end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/frame/handler/base.rb new/lib/websocket/frame/handler/base.rb --- old/lib/websocket/frame/handler/base.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/frame/handler/base.rb 2017-01-31 19:34:39.000000000 +0100 @@ -9,13 +9,13 @@ # Convert data to raw frame ready to send to client # @return [String] Encoded frame def encode_frame - fail NotImplementedError + raise NotImplementedError end # Convert raw data to decoded frame # @return [WebSocket::Frame::Incoming] Frame if found, nil otherwise def decode_frame - fail NotImplementedError + raise NotImplementedError end private diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/frame/handler/handler03.rb new/lib/websocket/frame/handler/handler03.rb --- old/lib/websocket/frame/handler/handler03.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/frame/handler/handler03.rb 2017-01-31 19:34:39.000000000 +0100 @@ -13,10 +13,10 @@ pong: 3, text: 4, binary: 5 - } + }.freeze # Hash of frame opcodes and it's names - FRAME_TYPES_INVERSE = FRAME_TYPES.invert + FRAME_TYPES_INVERSE = FRAME_TYPES.invert.freeze # @see WebSocket::Frame::Base#supported_frames def supported_frames @@ -50,7 +50,7 @@ elsif frame_type == :continuation return decode_finish_continuation_frame(application_data) else - fail(WebSocket::Error::Frame::InvalidPayloadEncoding) if frame_type == :text && !application_data.valid_encoding? + 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 @@ -74,7 +74,7 @@ # @return [Integer] opcode or nil # @raise [WebSocket::Error] if frame opcode is not known def type_to_opcode(frame_type) - FRAME_TYPES[frame_type] || fail(WebSocket::Error::Frame::UnknownFrameType) + FRAME_TYPES[frame_type] || raise(WebSocket::Error::Frame::UnknownFrameType) end # Convert frame opcode to type name @@ -82,7 +82,7 @@ # @return [Symbol] Frame type name or nil # @raise [WebSocket::Error] if frame type name is not known def opcode_to_type(opcode) - FRAME_TYPES_INVERSE[opcode] || fail(WebSocket::Error::Frame::UnknownOpcode) + FRAME_TYPES_INVERSE[opcode] || raise(WebSocket::Error::Frame::UnknownOpcode) end def encode_header @@ -117,7 +117,7 @@ frame_length = header_length + payload_length frame_length += 4 if mask - fail(WebSocket::Error::Frame::TooLong) if frame_length > WebSocket.max_frame_size + raise(WebSocket::Error::Frame::TooLong) if frame_length > WebSocket.max_frame_size # Check buffer size return unless buffer_exists?(frame_length) # Buffer incomplete @@ -135,13 +135,13 @@ def decode_first_byte first_byte = @frame.data.getbyte(0) - fail(WebSocket::Error::Frame::ReservedBitUsed) if first_byte & 0b01110000 != 0b00000000 + raise(WebSocket::Error::Frame::ReservedBitUsed) if first_byte & 0b01110000 != 0b00000000 more = ((first_byte & 0b10000000) == 0b10000000) ^ fin frame_type = opcode_to_type first_byte & 0b00001111 - fail(WebSocket::Error::Frame::FragmentedControlFrame) if more && control_frame?(frame_type) - fail(WebSocket::Error::Frame::DataFrameInsteadContinuation) if data_frame?(frame_type) && !@application_data_buffer.nil? + raise(WebSocket::Error::Frame::FragmentedControlFrame) if more && control_frame?(frame_type) + raise(WebSocket::Error::Frame::DataFrameInsteadContinuation) if data_frame?(frame_type) && !@application_data_buffer.nil? [more, frame_type] end @@ -152,7 +152,7 @@ mask = @frame.incoming_masking? && (second_byte & 0b10000000) == 0b10000000 length = second_byte & 0b01111111 - fail(WebSocket::Error::Frame::ControlFramePayloadTooLong) if length > 125 && control_frame?(frame_type) + raise(WebSocket::Error::Frame::ControlFramePayloadTooLong) if length > 125 && control_frame?(frame_type) header_length, payload_length = decode_payload_length(length) @@ -202,10 +202,10 @@ end def decode_finish_continuation_frame(application_data) - fail(WebSocket::Error::Frame::UnexpectedContinuationFrame) unless @frame_type + raise(WebSocket::Error::Frame::UnexpectedContinuationFrame) unless @frame_type @application_data_buffer << application_data # Test valid UTF-8 encoding - fail(WebSocket::Error::Frame::InvalidPayloadEncoding) if @frame_type == :text && !@application_data_buffer.valid_encoding? + 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/frame/handler/handler07.rb new/lib/websocket/frame/handler/handler07.rb --- old/lib/websocket/frame/handler/handler07.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/frame/handler/handler07.rb 2017-01-31 19:34:39.000000000 +0100 @@ -12,15 +12,15 @@ close: 8, ping: 9, pong: 10 - } + }.freeze # Hash of frame opcodes and it's names - FRAME_TYPES_INVERSE = FRAME_TYPES.invert + FRAME_TYPES_INVERSE = FRAME_TYPES.invert.freeze def encode_frame if @frame.type == :close code = @frame.code || 1000 - fail WebSocket::Error::Frame::UnknownCloseCode unless valid_code?(code) + raise WebSocket::Error::Frame::UnknownCloseCode unless valid_code?(code) @frame.data = Data.new([code].pack('n') + @frame.data.to_s) @frame.code = nil end @@ -32,8 +32,8 @@ if close_code?(result) code = result.data.slice!(0..1) result.code = code.unpack('n').first - fail WebSocket::Error::Frame::UnknownCloseCode unless valid_code?(result.code) - fail WebSocket::Error::Frame::InvalidPayloadEncoding unless valid_encoding?(result.data) + raise WebSocket::Error::Frame::UnknownCloseCode unless valid_code?(result.code) + raise WebSocket::Error::Frame::InvalidPayloadEncoding unless valid_encoding?(result.data) end result end @@ -41,7 +41,7 @@ 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).cover?(code) end def valid_encoding?(data) @@ -61,7 +61,7 @@ # @return [Integer] opcode or nil # @raise [WebSocket::Error] if frame opcode is not known def type_to_opcode(frame_type) - FRAME_TYPES[frame_type] || fail(WebSocket::Error::Frame::UnknownFrameType) + FRAME_TYPES[frame_type] || raise(WebSocket::Error::Frame::UnknownFrameType) end # Convert frame opcode to type name @@ -69,7 +69,7 @@ # @return [Symbol] Frame type name or nil # @raise [WebSocket::Error] if frame type name is not known def opcode_to_type(opcode) - FRAME_TYPES_INVERSE[opcode] || fail(WebSocket::Error::Frame::UnknownOpcode) + FRAME_TYPES_INVERSE[opcode] || raise(WebSocket::Error::Frame::UnknownOpcode) end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/frame/handler/handler75.rb new/lib/websocket/frame/handler/handler75.rb --- old/lib/websocket/frame/handler/handler75.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/frame/handler/handler75.rb 2017-01-31 19:34:39.000000000 +0100 @@ -17,13 +17,13 @@ ary = ["\x00", @frame.data, "\xff"] ary.map { |s| s.encode('UTF-8', 'UTF-8', invalid: :replace) } ary.join - else fail WebSocket::Error::Frame::UnknownFrameType + else raise WebSocket::Error::Frame::UnknownFrameType end end # @see WebSocket::Frame::Handler::Base#decode_frame def decode_frame - return if @frame.data.size == 0 + return if @frame.data.size.zero? pointer = 0 frame_type = @frame.data.getbyte(pointer) @@ -42,7 +42,7 @@ break unless (b & 0x80) == 0x80 end - fail WebSocket::Error::Frame::TooLong if length > ::WebSocket.max_frame_size + raise WebSocket::Error::Frame::TooLong if length > ::WebSocket.max_frame_size unless @frame.data.getbyte(pointer + length - 1).nil? # Straight from spec - I'm sure this isn't crazy... @@ -51,17 +51,17 @@ @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 + if length.zero? @frame.class.new(version: @frame.version, type: :close, decoded: true) end end else # If the high-order bit of the /frame type/ byte is _not_ set - fail WebSocket::Error::Frame::Invalid if @frame.data.getbyte(0) != 0x00 + raise WebSocket::Error::Frame::Invalid if @frame.data.getbyte(0) != 0x00 # Addition to the spec to protect against malicious requests - fail WebSocket::Error::Frame::TooLong if @frame.data.size > ::WebSocket.max_frame_size + raise WebSocket::Error::Frame::TooLong if @frame.data.size > ::WebSocket.max_frame_size msg = @frame.data.slice!(/\A\x00[^\xff]*\xff/) if msg diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/frame/outgoing.rb new/lib/websocket/frame/outgoing.rb --- old/lib/websocket/frame/outgoing.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/frame/outgoing.rb 2017-01-31 19:34:39.000000000 +0100 @@ -24,7 +24,7 @@ # Return raw frame formatted for sending. def to_s - fail WebSocket::Error::Frame::UnknownFrameType unless supported? + raise WebSocket::Error::Frame::UnknownFrameType unless supported? @handler.encode_frame end rescue_method :to_s diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/handshake/base.rb new/lib/websocket/handshake/base.rb --- old/lib/websocket/handshake/base.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/handshake/base.rb 2017-01-31 19:34:39.000000000 +0100 @@ -5,7 +5,8 @@ include ExceptionHandler attr_reader :host, :port, :path, :query, - :state, :version, :secure, :headers + :state, :version, :secure, + :headers, :protocols # Initialize new WebSocket Handshake and set it's state to :new def initialize(args = {}) @@ -16,6 +17,7 @@ @data = '' @headers ||= {} + @protocols ||= [] end # @abstract Add data to handshake @@ -52,7 +54,7 @@ # @abstract Should send data after parsing is finished? def should_respond? - fail NotImplementedError + raise NotImplementedError end # Data left from parsing. Sometimes data that doesn't belong to handshake are added - use this method to retrieve them. @@ -104,7 +106,15 @@ lines.each do |line| h = HEADER.match(line) - @headers[h[1].strip.downcase] = h[2].strip if h + next unless h # Skip any invalid headers + key = h[1].strip.downcase + val = h[2].strip + # If the header is already set and refers to the websocket protocol, append the new value + if @headers.key?(key) && key =~ /^(sec-)?websocket-protocol$/ + @headers[key] << ", #{val}" + else + @headers[key] = val + end end @state = :finished diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/handshake/client.rb new/lib/websocket/handshake/client.rb --- old/lib/websocket/handshake/client.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/handshake/client.rb 2017-01-31 19:34:39.000000000 +0100 @@ -38,16 +38,17 @@ # # @param [Hash] args Arguments for client # - # @option args [String] :host Host of request. Required if no :url param was provided. - # @option args [String] :origin Origin of request. Optional, should be used mostly by browsers. Default: nil - # @option args [String] :path Path of request. Should start with '/'. Default: '/' - # @option args [Integer] :port Port of request. Default: nil - # @option args [String] :query. Query for request. Should be in format "aaa=bbb&ccc=ddd" - # @option args [Boolean] :secure Defines protocol to use. If true then wss://, otherwise ws://. This option will not change default port - it should be handled by programmer. - # @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 + # @option args [String] :host Host of request. Required if no :url param was provided. + # @option args [String] :origin Origin of request. Optional, should be used mostly by browsers. Default: nil + # @option args [String] :path Path of request. Should start with '/'. Default: '/' + # @option args [Integer] :port Port of request. Default: nil + # @option args [String] :query. Query for request. Should be in format "aaa=bbb&ccc=ddd" + # @option args [Boolean] :secure Defines protocol to use. If true then wss://, otherwise ws://. This option will not change default port - it should be handled by programmer. + # @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 [Array<String>] :protocols An array of supported sub-protocols + # @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") @@ -66,7 +67,7 @@ @path = '/' if @path.nil? || @path.empty? @version ||= DEFAULT_VERSION - fail WebSocket::Error::Handshake::NoHostProvided unless @host + raise WebSocket::Error::Handshake::NoHostProvided unless @host include_version end @@ -107,7 +108,7 @@ when 1..3 then Handler::Client01.new(self) when 4..10 then Handler::Client04.new(self) when 11..17 then Handler::Client11.new(self) - else fail WebSocket::Error::Handshake::UnknownVersion + else raise WebSocket::Error::Handshake::UnknownVersion end end @@ -118,9 +119,9 @@ # @return [Boolean] True if parsed correctly. False otherwise def parse_first_line(line) line_parts = line.match(FIRST_LINE) - fail WebSocket::Error::Handshake::InvalidHeader unless line_parts + raise WebSocket::Error::Handshake::InvalidHeader unless line_parts status = line_parts[1] - fail WebSocket::Error::Handshake::InvalidStatusCode unless status == '101' + raise WebSocket::Error::Handshake::InvalidStatusCode unless status == '101' end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/handshake/handler/client04.rb new/lib/websocket/handshake/handler/client04.rb --- old/lib/websocket/handshake/handler/client04.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/handshake/handler/client04.rb 2017-01-31 19:34:39.000000000 +0100 @@ -7,7 +7,7 @@ class Client04 < Client # @see WebSocket::Handshake::Base#valid? def valid? - super && verify_accept + super && verify_accept && verify_protocol end private @@ -25,6 +25,7 @@ keys << ['Sec-WebSocket-Origin', @handshake.origin] if @handshake.origin keys << ['Sec-WebSocket-Version', @handshake.version] keys << ['Sec-WebSocket-Key', key] + keys << ['Sec-WebSocket-Protocol', @handshake.protocols.join(', ')] if @handshake.protocols.any? keys end @@ -43,7 +44,16 @@ # Verify if received header Sec-WebSocket-Accept matches generated one. # @return [Boolean] True if accept is matching. False otherwise(appropriate error is set) def verify_accept - fail WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.headers['sec-websocket-accept'] == accept + raise WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.headers['sec-websocket-accept'] == accept + true + end + + # Verify if received header Sec-WebSocket-Protocol matches with one of the sent ones + # @return [Boolean] True if matching. False otherwise(appropriate error is set) + def verify_protocol + return true if @handshake.protocols.empty? + protos = @handshake.headers['sec-websocket-protocol'].split(/ *, */) & @handshake.protocols + raise WebSocket::Error::Handshake::UnsupportedProtocol if protos.empty? true end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/handshake/handler/client75.rb new/lib/websocket/handshake/handler/client75.rb --- old/lib/websocket/handshake/handler/client75.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/handshake/handler/client75.rb 2017-01-31 19:34:39.000000000 +0100 @@ -2,6 +2,11 @@ module Handshake module Handler class Client75 < Client + # @see WebSocket::Handshake::Base#valid? + def valid? + super && verify_protocol + end + private # @see WebSocket::Handshake::Handler::Base#handshake_keys @@ -14,9 +19,19 @@ host += ":#{@handshake.port}" if @handshake.port keys << ['Host', host] keys << ['Origin', @handshake.origin] if @handshake.origin + keys << ['WebSocket-Protocol', @handshake.protocols.first] if @handshake.protocols.any? keys += super keys end + + # Verify if received header WebSocket-Protocol matches with the sent one + # @return [Boolean] True if matching. False otherwise(appropriate error is set) + def verify_protocol + return true if @handshake.protocols.empty? + invalid = @handshake.headers['websocket-protocol'].strip != @handshake.protocols.first + raise WebSocket::Error::Handshake::UnsupportedProtocol if invalid + true + end end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/handshake/handler/client76.rb new/lib/websocket/handshake/handler/client76.rb --- old/lib/websocket/handshake/handler/client76.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/handshake/handler/client76.rb 2017-01-31 19:34:39.000000000 +0100 @@ -6,7 +6,7 @@ class Client76 < Client75 # @see WebSocket::Handshake::Base#valid? def valid? - super && verify_challenge + super && verify_challenge && verify_protocol end private @@ -62,7 +62,7 @@ # Verify if challenge sent by server match generated one # @return [Boolena] True if challenge matches, false otherwise(sets appropriate error) def verify_challenge - fail WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.leftovers == challenge + raise WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.leftovers == challenge true end @@ -93,6 +93,15 @@ def generate_key3 [rand(0x100000000)].pack('N') + [rand(0x100000000)].pack('N') end + + # Verify if received header Sec-WebSocket-Protocol matches with the sent one + # @return [Boolean] True if matching. False otherwise(appropriate error is set) + def verify_protocol + return true if @handshake.protocols.empty? + invalid = @handshake.headers['sec-websocket-protocol'].strip != @handshake.protocols.first + raise WebSocket::Error::Handshake::UnsupportedProtocol if invalid + true + end end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/handshake/handler/server04.rb new/lib/websocket/handshake/handler/server04.rb --- old/lib/websocket/handshake/handler/server04.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/handshake/handler/server04.rb 2017-01-31 19:34:39.000000000 +0100 @@ -23,7 +23,7 @@ %w(Upgrade websocket), %w(Connection Upgrade), ['Sec-WebSocket-Accept', signature] - ] + ] + protocol end # Signature of response, created from client request Sec-WebSocket-Key @@ -35,13 +35,19 @@ end def verify_key - fail WebSocket::Error::Handshake::InvalidAuthentication unless key + raise WebSocket::Error::Handshake::InvalidAuthentication unless key true end def key @handshake.headers['sec-websocket-key'] end + + def protocol + return [] unless @handshake.headers.key?('sec-websocket-protocol') + protos = @handshake.headers['sec-websocket-protocol'].split(/ *, */) & @handshake.protocols + [['Sec-WebSocket-Protocol', protos.first]] + end end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/handshake/handler/server75.rb new/lib/websocket/handshake/handler/server75.rb --- old/lib/websocket/handshake/handler/server75.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/handshake/handler/server75.rb 2017-01-31 19:34:39.000000000 +0100 @@ -16,7 +16,13 @@ %w(Connection Upgrade), ['WebSocket-Origin', @handshake.headers['origin']], ['WebSocket-Location', @handshake.uri] - ] + ] + protocol + end + + def protocol + return [] unless @handshake.headers.key?('websocket-protocol') + proto = @handshake.headers['websocket-protocol'] + [['WebSocket-Protocol', @handshake.protocols.include?(proto) ? proto : nil]] end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/handshake/handler/server76.rb new/lib/websocket/handshake/handler/server76.rb --- old/lib/websocket/handshake/handler/server76.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/handshake/handler/server76.rb 2017-01-31 19:34:39.000000000 +0100 @@ -28,7 +28,7 @@ %w(Connection Upgrade), ['Sec-WebSocket-Origin', @handshake.headers['origin']], ['Sec-WebSocket-Location', @handshake.uri] - ] + ] + protocol end # @see WebSocket::Handshake::Handler::Base#finishing_line @@ -36,8 +36,6 @@ @finishing_line ||= challenge_response end - private - # Response to client challenge from request Sec-WebSocket-Key1, Sec-WebSocket-Key2 and leftovers # @return [String] Challenge response or nil if error occured def challenge_response @@ -60,17 +58,23 @@ spaces = string.scan(/ /).size # As per 5.2.5, abort the connection if spaces are zero. - fail WebSocket::Error::Handshake::InvalidAuthentication if spaces == 0 + raise WebSocket::Error::Handshake::InvalidAuthentication if spaces.zero? # As per 5.2.6, abort if numbers is not an integral multiple of spaces - fail WebSocket::Error::Handshake::InvalidAuthentication if numbers % spaces != 0 + raise WebSocket::Error::Handshake::InvalidAuthentication if numbers % spaces != 0 quotient = numbers / spaces - fail WebSocket::Error::Handshake::InvalidAuthentication if quotient > 2**32 - 1 + raise WebSocket::Error::Handshake::InvalidAuthentication if quotient > 2**32 - 1 quotient end + + def protocol + return [] unless @handshake.headers.key?('sec-websocket-protocol') + proto = @handshake.headers['sec-websocket-protocol'] + [['Sec-WebSocket-Protocol', @handshake.protocols.include?(proto) ? proto : nil]] + end end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/handshake/server.rb new/lib/websocket/handshake/server.rb --- old/lib/websocket/handshake/server.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/handshake/server.rb 2017-01-31 19:34:39.000000000 +0100 @@ -35,6 +35,7 @@ # @param [Hash] args Arguments for server # # @option args [Boolean] :secure If true then server will use wss:// protocol + # @option args [Array<String>] :protocols an array of supported sub-protocols # # @example # Websocket::Handshake::Server.new(secure: true) @@ -70,7 +71,7 @@ # @example # @handshake.from_rack(env) def from_rack(env) - @headers = env.select { |key, _value| key =~ /\AHTTP_/ }.each_with_object({}) do |tuple, memo| + @headers = env.select { |key, _value| key.start_with? 'HTTP_' }.each_with_object({}) do |tuple, memo| key, value = tuple memo[key.gsub(/\AHTTP_/, '').tr('_', '-').downcase] = value end @@ -153,7 +154,7 @@ when 75 then Handler::Server75.new(self) when 76, 0..3 then Handler::Server76.new(self) when 4..17 then Handler::Server04.new(self) - else fail WebSocket::Error::Handshake::UnknownVersion + else raise WebSocket::Error::Handshake::UnknownVersion end end @@ -164,9 +165,9 @@ # @return [Boolean] True if parsed correctly. False otherwise def parse_first_line(line) line_parts = line.match(PATH) - fail WebSocket::Error::Handshake::InvalidHeader unless line_parts + raise WebSocket::Error::Handshake::InvalidHeader unless line_parts method = line_parts[1].strip - fail 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) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/websocket/version.rb new/lib/websocket/version.rb --- old/lib/websocket/version.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/lib/websocket/version.rb 2017-01-31 19:34:39.000000000 +0100 @@ -1,3 +1,3 @@ module WebSocket - VERSION = '1.2.3' + VERSION = '1.2.4'.freeze end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata --- old/metadata 2016-04-05 12:57:30.000000000 +0200 +++ new/metadata 2017-01-31 19:34:39.000000000 +0100 @@ -1,15 +1,71 @@ --- !ruby/object:Gem::Specification name: websocket version: !ruby/object:Gem::Version - version: 1.2.3 + version: 1.2.4 platform: ruby authors: - Bernard Potocki autorequire: bindir: bin cert_chain: [] -date: 2016-04-05 00:00:00.000000000 Z -dependencies: [] +date: 2017-01-31 00:00:00.000000000 Z +dependencies: +- !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: '3.0' + type: :development + prerelease: false + version_requirements: !ruby/object:Gem::Requirement + requirements: + - - "~>" + - !ruby/object:Gem::Version + version: '3.0' +- !ruby/object:Gem::Dependency + name: rspec-its + 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: rubocop + 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: Universal Ruby library to handle WebSocket protocol email: - [email protected] @@ -109,7 +165,7 @@ version: '0' requirements: [] rubyforge_project: -rubygems_version: 2.5.1 +rubygems_version: 2.5.2 signing_key: specification_version: 4 summary: Universal Ruby library to handle WebSocket protocol diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/frame/outgoing_03_spec.rb new/spec/frame/outgoing_03_spec.rb --- old/spec/frame/outgoing_03_spec.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/spec/frame/outgoing_03_spec.rb 2017-01-31 19:34:39.000000000 +0100 @@ -2,7 +2,7 @@ require 'spec_helper' RSpec.describe 'Outgoing frame draft 03' do - let(:version) { 03 } + let(:version) { 3 } let(:frame) { WebSocket::Frame::Outgoing.new(version: version, data: decoded_text, type: frame_type) } let(:decoded_text) { '' } let(:encoded_text) { "\x04\x00" } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/frame/outgoing_04_spec.rb new/spec/frame/outgoing_04_spec.rb --- old/spec/frame/outgoing_04_spec.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/spec/frame/outgoing_04_spec.rb 2017-01-31 19:34:39.000000000 +0100 @@ -2,7 +2,7 @@ require 'spec_helper' RSpec.describe 'Outgoing frame draft 04' do - let(:version) { 04 } + let(:version) { 4 } let(:frame) { WebSocket::Frame::Outgoing.new(version: version, data: decoded_text, type: frame_type) } let(:decoded_text) { '' } let(:encoded_text) { "\x84\x00" } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/handshake/client_04_spec.rb new/spec/handshake/client_04_spec.rb --- old/spec/handshake/client_04_spec.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/spec/handshake/client_04_spec.rb 2017-01-31 19:34:39.000000000 +0100 @@ -17,4 +17,45 @@ expect(handshake).not_to be_valid expect(handshake.error).to eql(:invalid_handshake_authentication) end + + context 'protocol header specified' do + let(:handshake) { WebSocket::Handshake::Client.new(uri: 'ws://example.com/demo', origin: 'http://example.com', version: version, protocols: protocols) } + + context 'single protocol requested' do + let(:protocols) { %w(binary) } + + it 'returns a valid handshake' do + @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'binary' } } + handshake << server_response + + expect(handshake).to be_finished + expect(handshake).to be_valid + end + end + + context 'multiple protocols requested' do + let(:protocols) { %w(binary xmpp) } + + it 'returns with a valid handshake' do + @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'xmpp' } } + handshake << server_response + + expect(handshake).to be_finished + expect(handshake).to be_valid + end + end + + context 'unsupported protocol requested' do + let(:protocols) { %w(binary xmpp) } + + it 'fails with an unsupported protocol error' do + @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'generic' } } + handshake << server_response + + expect(handshake).to be_finished + expect(handshake).not_to be_valid + expect(handshake.error).to eql(:unsupported_protocol) + end + end + end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/handshake/client_75_spec.rb new/spec/handshake/client_75_spec.rb --- old/spec/handshake/client_75_spec.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/spec/handshake/client_75_spec.rb 2017-01-31 19:34:39.000000000 +0100 @@ -8,4 +8,29 @@ let(:server_response) { server_handshake_75(@request_params || {}) } it_should_behave_like 'all client drafts' + + context 'protocol header specified' do + let(:handshake) { WebSocket::Handshake::Client.new(uri: 'ws://example.com/demo', origin: 'http://example.com', version: version, protocols: %w(binary)) } + + context 'supported' do + it 'returns a valid handshake' do + @request_params = { headers: { 'WebSocket-Protocol' => 'binary' } } + handshake << server_response + + expect(handshake).to be_finished + expect(handshake).to be_valid + end + end + + context 'unsupported' do + it 'fails with an unsupported protocol error' do + @request_params = { headers: { 'WebSocket-Protocol' => 'xmpp' } } + handshake << server_response + + expect(handshake).to be_finished + expect(handshake).not_to be_valid + expect(handshake.error).to eql(:unsupported_protocol) + end + end + end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/handshake/client_76_spec.rb new/spec/handshake/client_76_spec.rb --- old/spec/handshake/client_76_spec.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/spec/handshake/client_76_spec.rb 2017-01-31 19:34:39.000000000 +0100 @@ -17,4 +17,29 @@ expect(handshake).not_to be_valid expect(handshake.error).to eql(:invalid_handshake_authentication) end + + context 'protocol header specified' do + let(:handshake) { WebSocket::Handshake::Client.new(uri: 'ws://example.com/demo', origin: 'http://example.com', version: version, protocols: %w(binary)) } + + context 'supported' do + it 'returns a valid handshake' do + @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'binary' } } + handshake << server_response + + expect(handshake).to be_finished + expect(handshake).to be_valid + end + end + + context 'unsupported' do + it 'fails with an unsupported protocol error' do + @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'xmpp' } } + handshake << server_response + + expect(handshake).to be_finished + expect(handshake).not_to be_valid + expect(handshake.error).to eql(:unsupported_protocol) + end + end + end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/handshake/server_04_spec.rb new/spec/handshake/server_04_spec.rb --- old/spec/handshake/server_04_spec.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/spec/handshake/server_04_spec.rb 2017-01-31 19:34:39.000000000 +0100 @@ -2,7 +2,7 @@ RSpec.describe 'Server draft 04 handshake' do let(:handshake) { WebSocket::Handshake::Server.new } - let(:version) { 04 } + let(:version) { 4 } let(:client_request) { client_handshake_04(@request_params || {}) } let(:server_response) { server_handshake_04(@request_params || {}) } @@ -15,4 +15,35 @@ expect(handshake).not_to be_valid expect(handshake.error).to eql(:invalid_handshake_authentication) end + + context 'protocol header specified' do + let(:handshake) { WebSocket::Handshake::Server.new(protocols: %w(binary xmpp)) } + + context 'single protocol requested' do + it 'returns with the same protocol' do + @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'binary' } } + handshake << client_request + + expect(handshake.to_s).to match('Sec-WebSocket-Protocol: binary') + end + end + + context 'multiple protocols requested' do + it 'returns with the first supported protocol' do + @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'xmpp, binary' } } + handshake << client_request + + expect(handshake.to_s).to match('Sec-WebSocket-Protocol: xmpp') + end + end + + context 'unsupported protocol requested' do + it 'reutrns with an empty protocol header' do + @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'generic' } } + handshake << client_request + + expect(handshake.to_s).to match("Sec-WebSocket-Protocol: \r\n") + end + end + end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/handshake/server_75_spec.rb new/spec/handshake/server_75_spec.rb --- old/spec/handshake/server_75_spec.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/spec/handshake/server_75_spec.rb 2017-01-31 19:34:39.000000000 +0100 @@ -8,4 +8,26 @@ let(:server_response) { server_handshake_75(@request_params || {}) } it_should_behave_like 'all server drafts' + + context 'protocol header specified' do + let(:handshake) { WebSocket::Handshake::Server.new(protocols: %w(binary)) } + + context 'supported' do + it 'returns with the same protocol' do + @request_params = { headers: { 'WebSocket-Protocol' => 'binary' } } + handshake << client_request + + expect(handshake.to_s).to match('WebSocket-Protocol: binary') + end + end + + context 'unsupported' do + it 'returns with an empty protocol header' do + @request_params = { headers: { 'WebSocket-Protocol' => 'xmpp' } } + handshake << client_request + + expect(handshake.to_s).to match("WebSocket-Protocol: \r\n") + end + end + end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/handshake/server_76_spec.rb new/spec/handshake/server_76_spec.rb --- old/spec/handshake/server_76_spec.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/spec/handshake/server_76_spec.rb 2017-01-31 19:34:39.000000000 +0100 @@ -43,4 +43,26 @@ expect(handshake).not_to be_valid expect(handshake.error).to eql(:invalid_handshake_authentication) end + + context 'protocol header specified' do + let(:handshake) { WebSocket::Handshake::Server.new(protocols: %w(binary)) } + + context 'supported' do + it 'returns with the same protocol' do + @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'binary' } } + handshake << client_request + + expect(handshake.to_s).to match('Sec-WebSocket-Protocol: binary') + end + end + + context 'unsupported' do + it 'returns with an empty protocol header' do + @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'xmpp' } } + handshake << client_request + + expect(handshake.to_s).to match("Sec-WebSocket-Protocol: \r\n") + end + end + end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/support/handshake_requests.rb new/spec/support/handshake_requests.rb --- old/spec/support/handshake_requests.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/spec/support/handshake_requests.rb 2017-01-31 19:34:39.000000000 +0100 @@ -14,7 +14,7 @@ HTTP/1.1 101 Web Socket Protocol Handshake\r Upgrade: WebSocket\r Connection: Upgrade\r -WebSocket-Origin: http://example.com\r +#{(args[:headers] || {}).map { |key, value| "#{key}: #{value}\r\n" }.join('')}WebSocket-Origin: http://example.com\r WebSocket-Location: ws#{args[:secure] ? 's' : ''}://#{args[:host] || 'example.com'}#{":#{args[:port]}" if args[:port]}#{args[:path] || '/demo'}\r \r EOF @@ -40,7 +40,7 @@ HTTP/1.1 101 WebSocket Protocol Handshake\r Upgrade: WebSocket\r Connection: Upgrade\r -Sec-WebSocket-Origin: http://example.com\r +#{(args[:headers] || {}).map { |key, value| "#{key}: #{value}\r\n" }.join('')}Sec-WebSocket-Origin: http://example.com\r Sec-WebSocket-Location: ws#{args[:secure] ? 's' : ''}://#{args[:host] || 'example.com'}#{":#{args[:port]}" if args[:port]}#{args[:path] || '/demo'}\r \r #{args[:challenge] || "8jKS'y:G*Co,Wxa-"} @@ -66,7 +66,7 @@ HTTP/1.1 101 Switching Protocols\r Upgrade: websocket\r Connection: Upgrade\r -Sec-WebSocket-Accept: #{args[:accept] || 's3pPLMBiTxaQ9kYGzzhZRbK+xOo='}\r +#{(args[:headers] || {}).map { |key, value| "#{key}: #{value}\r\n" }.join('')}Sec-WebSocket-Accept: #{args[:accept] || 's3pPLMBiTxaQ9kYGzzhZRbK+xOo='}\r \r EOF end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/spec/support/incoming_frames.rb new/spec/support/incoming_frames.rb --- old/spec/support/incoming_frames.rb 2016-04-05 12:57:30.000000000 +0200 +++ new/spec/support/incoming_frames.rb 2017-01-31 19:34:39.000000000 +0100 @@ -38,19 +38,21 @@ after(:each) { WebSocket.should_raise = false } it 'should have specified number of returned frames' do - expect do - decoded_text_array.each_with_index do |da, index| - n = subject.next - expect(n).not_to be_nil, "Should return frame for #{da}, #{frame_type_array[index]}" - expect(n.class).to eql(WebSocket::Frame::Incoming), "Should be WebSocket::Frame::Incoming, #{n} received instead" - end - expect(subject.next).to be_nil - if error.is_a?(Class) - expect(subject.error).to eql(error.new.message) - else - expect(subject.error).to eql(error) - end - end.to raise_error(error) if error + if error + expect do + decoded_text_array.each_with_index do |da, index| + n = subject.next + expect(n).not_to be_nil, "Should return frame for #{da}, #{frame_type_array[index]}" + expect(n.class).to eql(WebSocket::Frame::Incoming), "Should be WebSocket::Frame::Incoming, #{n} received instead" + end + expect(subject.next).to be_nil + if error.is_a?(Class) + expect(subject.error).to eql(error.new.message) + else + expect(subject.error).to eql(error) + end + end.to raise_error(error) + end end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/websocket.gemspec new/websocket.gemspec --- old/websocket.gemspec 2016-04-05 12:57:30.000000000 +0200 +++ new/websocket.gemspec 2017-01-31 19:34:39.000000000 +0100 @@ -17,4 +17,9 @@ s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n") s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) } s.require_paths = ['lib'] + + s.add_development_dependency 'rake' + s.add_development_dependency 'rspec', '~> 3.0' + s.add_development_dependency 'rspec-its' + s.add_development_dependency 'rubocop' end
