websocket 1.0.7 → 1.1.0

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

@@ -3,9 +3,7 @@
 module WebSocket
   module Frame
     module Handler
-      module Handler04
-
-        include Handler03
+      class Handler04 < Handler03
 
         private
 

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

@@ -3,15 +3,11 @@
 module WebSocket
   module Frame
     module Handler
-      module Handler05
-
-        include Handler04
-
-        private
+      class Handler05 < Handler04
 
         def encode_frame
           if @code
-            @data = Data.new([@code].pack('n') + @data.to_s)
+            @frame.data = Data.new([@code].pack('n') + @frame.data.to_s)
             @code = nil
           end
           super

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

@@ -3,11 +3,7 @@
 module WebSocket
   module Frame
     module Handler
-      module Handler07
-
-        include Handler05
-
-        private
+      class Handler07 < Handler05
 
         # Hash of frame names and it's opcodes
         FRAME_TYPES = {
@@ -22,12 +18,14 @@ module WebSocket
         # Hash of frame opcodes and it's names
         FRAME_TYPES_INVERSE = FRAME_TYPES.invert
 
+        private
+
         # Convert frame type name to opcode
         # @param [Symbol] frame_type Frame type name
         # @return [Integer] opcode or nil
         # @raise [WebSocket::Error] if frame opcode is not known
         def type_to_opcode(frame_type)
-          FRAME_TYPES[frame_type] || raise(WebSocket::Error, :unknown_frame_type)
+          FRAME_TYPES[frame_type] || raise(WebSocket::Error::Frame::UnknownFrameType)
         end
 
         # Convert frame opcode to type name
@@ -35,7 +33,7 @@ module WebSocket
         # @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] || raise(WebSocket::Error, :unknown_opcode)
+          FRAME_TYPES_INVERSE[opcode] || raise(WebSocket::Error::Frame::UnknownOpcode)
         end
 
       end

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

@@ -3,23 +3,19 @@
 module WebSocket
   module Frame
     module Handler
-      module Handler75
-
-        include Base
+      class Handler75 < Base
 
         # @see WebSocket::Frame::Base#supported_frames
         def supported_frames
           [:text, :close]
         end
 
-        private
-
         # @see WebSocket::Frame::Handler::Base#encode_frame
         def encode_frame
-          case @type
+          case @frame.type
             when :close then "\xff\x00"
             when :text then
-              ary = ["\x00", @data, "\xff"]
+              ary = ["\x00", @frame.data, "\xff"]
               ary.collect{ |s| s.encode('UTF-8', 'UTF-8', :invalid => :replace) if s.respond_to?(:encode) }
               ary.join
           end
@@ -27,10 +23,10 @@ module WebSocket
 
         # @see WebSocket::Frame::Handler::Base#decode_frame
         def decode_frame
-          return if @data.size == 0
+          return if @frame.data.size == 0
 
           pointer = 0
-          frame_type = @data.getbyte(pointer)
+          frame_type = @frame.data.getbyte(pointer)
           pointer += 1
 
           if (frame_type & 0x80) == 0x80
@@ -38,40 +34,40 @@ module WebSocket
             length = 0
 
             loop do
-              return if !@data.getbyte(pointer)
-              b = @data.getbyte(pointer)
+              return if !@frame.data.getbyte(pointer)
+              b = @frame.data.getbyte(pointer)
               pointer += 1
               b_v = b & 0x7F
               length = length * 128 + b_v
               break unless (b & 0x80) == 0x80
             end
 
-            set_error(:frame_too_long) and return if length > ::WebSocket.max_frame_size
+            raise WebSocket::Error::Frame::TooLong if length > ::WebSocket.max_frame_size
 
-            unless @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.
-              @data = @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
-                self.class.new(:version => version, :type => :close, :decoded => true)
+                @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
 
-            set_error(:invalid_frame) and return if @data.getbyte(0) != 0x00
+            raise WebSocket::Error::Frame::Invalid if @frame.data.getbyte(0) != 0x00
 
             # Addition to the spec to protect against malicious requests
-            set_error(:frame_too_long) and return if @data.size > ::WebSocket.max_frame_size
+            raise WebSocket::Error::Frame::TooLong if @frame.data.size > ::WebSocket.max_frame_size
 
-            msg = @data.slice!(/\A\x00[^\xff]*\xff/)
+            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)
-              self.class.new(:version => version, :type => :text, :data => msg, :decoded => true)
+              @frame.class.new(:version => @frame.version, :type => :text, :data => msg, :decoded => true)
             end
           end
         end

data/lib/websocket/frame/incoming.rb

@@ -37,8 +37,9 @@ module WebSocket
       # Check #error if nil received to check for eventual parsing errors
       # @return [WebSocket::Frame::Incoming] Single incoming frame or nil if no complete frame is available.
       def next
-        decode_frame unless decoded?
+        @handler.decode_frame unless decoded?
       end
+      rescue_method :next
 
       # If decoded then this will return frame content. Otherwise it will return raw frame.
       # @return [String] Data of frame

data/lib/websocket/frame/incoming/client.rb

@@ -3,14 +3,12 @@ module WebSocket
     class Incoming
       class Client < Incoming
 
-        private
-
         def incoming_masking?
           false
         end
 
         def outgoing_masking?
-          masking?
+          @handler.masking?
         end
 
       end

data/lib/websocket/frame/incoming/server.rb

@@ -3,10 +3,8 @@ module WebSocket
     class Incoming
       class Server < Incoming
 
-        private
-
         def incoming_masking?
-          masking?
+          @handler.masking?
         end
 
         def outgoing_masking?

data/lib/websocket/frame/outgoing.rb

@@ -25,9 +25,10 @@ module WebSocket
 
       # Return raw frame formatted for sending.
       def to_s
-        set_error(:unknown_frame_type) and return unless supported?
-        encode_frame
+        raise WebSocket::Error::Frame::UnknownFrameType unless supported?
+        @handler.encode_frame
       end
+      rescue_method :to_s
 
     end
   end

data/lib/websocket/frame/outgoing/client.rb

@@ -3,14 +3,12 @@ module WebSocket
     class Outgoing
       class Client < Outgoing
 
-        private
-
         def incoming_masking?
           false
         end
 
         def outgoing_masking?
-          masking?
+          @handler.masking?
         end
 
       end

data/lib/websocket/frame/outgoing/server.rb

@@ -3,10 +3,8 @@ module WebSocket
     class Outgoing
       class Server < Outgoing
 
-        private
-
         def incoming_masking?
-          masking?
+          @handler.masking?
         end
 
         def outgoing_masking?

data/lib/websocket/handshake/base.rb

@@ -2,13 +2,15 @@ module WebSocket
   module Handshake
     # @abstract Subclass and override to implement custom handshakes
     class Base
+      include ExceptionHandler
 
       attr_reader :host, :port, :path, :query,
-                  :error, :state, :version, :secure
+                  :state, :version, :secure, :headers
 
       # Initialize new WebSocket Handshake and set it's state to :new
       def initialize(args = {})
         @state = :new
+        @handler = nil
 
         @data = ""
         @headers = {}
@@ -22,8 +24,9 @@ module WebSocket
       # Return textual representation of handshake request or response
       # @return [String] text of response
       def to_s
-        ""
+        @handler ? @handler.to_s : ""
       end
+      rescue_method :to_s, :return => ""
 
       # Recreate inspect as #to_s was overwritten
       def inspect
@@ -41,8 +44,9 @@ module WebSocket
       # Is parsed data valid?
       # @return [Boolean] False if some errors occured. Reason for error could be found in error method
       def valid?
-        finished? && @error == nil
+        finished? && @error == nil && @handler && @handler.valid?
       end
+      rescue_method :valid?, :return => false
 
       # @abstract Should send data after parsing is finished?
       def should_respond?
@@ -80,7 +84,7 @@ module WebSocket
       # @param [String] message Error message to set
       def set_error(message)
         @state = :error
-        @error = message
+        super
       end
 
       HEADER = /^([^:]+):\s*(.+)$/
@@ -94,7 +98,7 @@ module WebSocket
         lines = header.split("\r\n")
 
         first_line = lines.shift
-        return false unless parse_first_line(first_line)
+        parse_first_line(first_line)
 
         lines.each do |line|
           h = HEADER.match(line)

data/lib/websocket/handshake/client.rb

@@ -33,6 +33,8 @@ module WebSocket
     #
     class Client < Base
 
+      attr_reader :origin
+
       # Initialize new WebSocket Client
       #
       # @param [Hash] args Arguments for client
@@ -72,10 +74,11 @@ module WebSocket
 
         @path   = '/'           if @path.nil? || @path.empty?
 
-        set_error(:no_host_provided) unless @host
+        raise WebSocket::Error::Handshake::NoHostProvided unless @host
 
         include_version
       end
+      rescue_method :initialize
 
       # Add text of response from Server. This method will parse content immediately and update state and error(if neccessary)
       #
@@ -95,6 +98,7 @@ module WebSocket
 
         end
       end
+      rescue_method :<<
 
       # Should send content to server after finished parsing?
       # @return [Boolean] false
@@ -107,14 +111,13 @@ module WebSocket
       # Include set of methods for selected protocol version
       # @return [Boolean] false if protocol number is unknown, otherwise true
       def include_version
-        case @version
-          when 75 then extend Handler::Client75
-          when 76, 0 then extend Handler::Client76
-          when 1..3  then extend Handler::Client01
-          when 4..13 then extend Handler::Client04
-          else set_error(:unknown_protocol_version) and return false
+        @handler = case @version
+          when 75 then Handler::Client75.new(self)
+          when 76, 0 then Handler::Client76.new(self)
+          when 1..3  then Handler::Client01.new(self)
+          when 4..13 then Handler::Client04.new(self)
+          else raise WebSocket::Error::Handshake::UnknownVersion
         end
-        return true
       end
 
       FIRST_LINE = /^HTTP\/1\.1 (\d{3})[\w\s]*$/
@@ -124,11 +127,9 @@ module WebSocket
       # @return [Boolean] True if parsed correctly. False otherwise
       def parse_first_line(line)
         line_parts = line.match(FIRST_LINE)
-        set_error(:invalid_header) and return false unless line_parts
+        raise WebSocket::Error::Handshake::InvalidHeader unless line_parts
         status = line_parts[1]
-        set_error(:invalid_status_code) and return false unless status == '101'
-
-        return true
+        raise WebSocket::Error::Handshake::InvalidStatusCode unless status == '101'
       end
 
     end

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

@@ -1,8 +1,12 @@
 module WebSocket
   module Handshake
     module Handler
-      # This module and it's descendants are included in client or server handshake in order to extend basic functionality
-      module Base
+      # This class and it's descendants are included in client or server handshake in order to extend basic functionality
+      class Base
+
+        def initialize(handshake)
+          @handshake = handshake
+        end
 
         # @see WebSocket::Handshake::Base#to_s
         def to_s
@@ -15,6 +19,10 @@ module WebSocket
           result.join("\r\n")
         end
 
+        def valid?
+          true
+        end
+
         private
 
         # Set first line of text representation according to specification.

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

@@ -1,16 +1,14 @@
 module WebSocket
   module Handshake
     module Handler
-      module Client
-
-        include Base
+      class Client < Base
 
         private
 
         # @see WebSocket::Handshake::Handler::Base#header_line
         def header_line
-          path = @path
-          path += "?" + @query if @query
+          path = @handshake.path
+          path += "?" + @handshake.query if @handshake.query
           "GET #{path} HTTP/1.1"
         end
 

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

@@ -3,16 +3,14 @@ require 'digest/md5'
 module WebSocket
   module Handshake
     module Handler
-      module Client01
-
-        include Client76
+      class Client01 < Client76
 
         private
 
         # @see WebSocket::Handshake::Handler::Base#handshake_keys
         def handshake_keys
           keys = super
-          keys << ['Sec-WebSocket-Draft', @version]
+          keys << ['Sec-WebSocket-Draft', @handshake.version]
           keys
         end
 

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

@@ -4,9 +4,7 @@ require 'base64'
 module WebSocket
   module Handshake
     module Handler
-      module Client04
-
-        include Client
+      class Client04 < Client
 
         # @see WebSocket::Handshake::Base#valid?
         def valid?
@@ -21,11 +19,11 @@ module WebSocket
             ["Upgrade", "websocket"],
             ["Connection", "Upgrade"]
           ]
-          host = @host
-          host += ":#{@port}" if @port
+          host = @handshake.host
+          host += ":#{@handshake.port}" if @handshake.port
           keys << ["Host", host]
-          keys << ["Sec-WebSocket-Origin", @origin] if @origin
-          keys << ["Sec-WebSocket-Version", @version ]
+          keys << ["Sec-WebSocket-Origin", @handshake.origin] if @handshake.origin
+          keys << ["Sec-WebSocket-Version", @handshake.version ]
           keys << ["Sec-WebSocket-Key", key]
           keys
         end
@@ -45,7 +43,7 @@ module WebSocket
         # 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
-          set_error(:invalid_accept) and return false unless @headers['sec-websocket-accept'] == accept
+          raise WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.headers['sec-websocket-accept'] == accept
           true
         end