faye 0.7.2 → 0.8.0

data/lib/faye/util/web_socket/api.rb

@@ -1,103 +0,0 @@
-module Faye
-  class WebSocket
-    
-    CONNECTING = 0
-    OPEN       = 1
-    CLOSING    = 2
-    CLOSED     = 3
-    
-    module API
-      attr_reader   :url, :ready_state, :buffered_amount
-      attr_accessor :onopen, :onmessage, :onerror, :onclose
-      
-      include Publisher
-      
-      def receive(data)
-        return false unless ready_state == OPEN
-        event = Event.new('message')
-        event.init_event('message', false, false)
-        event.data = data
-        dispatch_event(event)
-      end
-      
-      def send(data, type = nil, error_type = nil)
-        return false if ready_state == CLOSED
-        data = Faye.encode(data) if String === data
-        frame = @parser.frame(data, type, error_type)
-        @stream.write(frame) if frame
-      end
-      
-      def close(code = nil, reason = nil, ack = true)
-        return if [CLOSING, CLOSED].include?(ready_state)
-        
-        @ready_state = CLOSING
-        
-        close = lambda do
-          @ready_state = CLOSED
-          @stream.close_connection_after_writing
-          event = Event.new('close', :code => code || 1000, :reason => reason || '')
-          event.init_event('close', false, false)
-          dispatch_event(event)
-        end
-        
-        if ack
-          if @parser.respond_to?(:close)
-            @parser.close(code, reason, &close)
-          else
-            close.call
-          end
-        else
-          @parser.close(code, reason) if @parser.respond_to?(:close)
-          close.call
-        end
-      end
-      
-      def add_event_listener(type, listener, use_capture)
-        bind(type, listener)
-      end
-      
-      def remove_event_listener(type, listener, use_capture)
-        unbind(type, listener)
-      end
-      
-      def dispatch_event(event)
-        event.target = event.current_target = self
-        event.event_phase = Event::AT_TARGET
-        
-        trigger(event.type, event)
-        callback = __send__("on#{ event.type }")
-        callback.call(event) if callback
-      end
-    end
-    
-    class Event
-      attr_reader   :type, :bubbles, :cancelable
-      attr_accessor :target, :current_target, :event_phase, :data
-      
-      CAPTURING_PHASE = 1
-      AT_TARGET       = 2
-      BUBBLING_PHASE  = 3
-      
-      def initialize(event_type, options = {})
-        @type = event_type
-        metaclass = (class << self ; self ; end)
-        options.each do |key, value|
-          metaclass.__send__(:define_method, key) { value }
-        end
-      end
-      
-      def init_event(event_type, can_bubble, cancelable)
-        @type       = event_type
-        @bubbles    = can_bubble
-        @cancelable = cancelable
-      end
-      
-      def stop_propagation
-      end
-      
-      def prevent_default
-      end
-    end
-    
-  end
-end

data/lib/faye/util/web_socket/client.rb

@@ -1,82 +0,0 @@
-module Faye
-  class WebSocket
-    
-    class Client
-      include API
-      attr_reader :uri
-      
-      def initialize(url)
-        @parser = Protocol8Parser.new(self, :masking => true)
-        @url    = url
-        @uri    = URI.parse(url)
-        
-        @ready_state = CONNECTING
-        @buffered_amount = 0
-        
-        port = @uri.port || (@uri.scheme == 'wss' ? 443 : 80)
-        
-        EventMachine.connect(@uri.host, port, Connection) do |conn|
-          @stream = conn
-          conn.parent = self
-        end
-      end
-      
-    private
-      
-      def on_connect
-        @stream.start_tls if @uri.scheme == 'wss'
-        @handshake = @parser.create_handshake
-        @message = []
-        @stream.write(@handshake.request_data)
-      end
-      
-      def receive_data(data)
-        data = Faye.encode(data)
-        
-        case @ready_state
-          when CONNECTING then
-            @message += @handshake.parse(data)
-            return unless @handshake.complete?
-            
-            if @handshake.valid?
-              @ready_state = OPEN
-              event = Event.new('open')
-              event.init_event('open', false, false)
-              dispatch_event(event)
-              
-              receive_data(@message)
-            else
-              @ready_state = CLOSED
-              event = Event.new('error')
-              event.init_event('error', false, false)
-              dispatch_event(event)
-            end
-            
-          when OPEN, CLOSING then
-            @parser.parse(data)
-        end
-      end
-      
-      module Connection
-        attr_accessor :parent
-        
-        def connection_completed
-          parent.__send__(:on_connect)
-        end
-        
-        def receive_data(data)
-          parent.__send__(:receive_data, data)
-        end
-        
-        def unbind
-          parent.close(1006, '', false)
-        end
-        
-        def write(data)
-          send_data(data)
-        end
-      end
-    end
-    
-  end
-end

data/lib/faye/util/web_socket/draft75_parser.rb

@@ -1,53 +0,0 @@
-module Faye
-  class WebSocket
-    
-    class Draft75Parser
-      def initialize(web_socket)
-        @socket    = web_socket
-        @buffer    = []
-        @buffering = false
-      end
-      
-      def version
-        'draft-75'
-      end
-      
-      def handshake_response
-        upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
-        upgrade << "Upgrade: WebSocket\r\n"
-        upgrade << "Connection: Upgrade\r\n"
-        upgrade << "WebSocket-Origin: #{@socket.env['HTTP_ORIGIN']}\r\n"
-        upgrade << "WebSocket-Location: #{@socket.url}\r\n"
-        upgrade << "\r\n"
-        upgrade
-      end
-      
-      def parse(data)
-        data.each_byte(&method(:handle_byte))
-      end
-      
-      def frame(data, type = nil, error_type = nil)
-        ["\x00", data, "\xFF"].map(&Faye.method(:encode)) * ''
-      end
-      
-    private
-      
-      def handle_byte(data)
-        case data
-          when 0x00 then
-            @buffering = true
-            
-          when 0xFF then
-            @socket.receive(Faye.encode(@buffer))
-            @buffer = []
-            @buffering = false
-            
-          else
-            @buffer.push(data) if @buffering
-        end
-      end
-    end
-    
-  end
-end
-

data/lib/faye/util/web_socket/draft76_parser.rb

@@ -1,53 +0,0 @@
-module Faye
-  class WebSocket
-    
-    class Draft76Parser < Draft75Parser
-      def version
-        'draft-76'
-      end
-      
-      def handshake_response
-        env = @socket.env
-        
-        key1   = env['HTTP_SEC_WEBSOCKET_KEY1']
-        value1 = number_from_key(key1) / spaces_in_key(key1)
-        
-        key2   = env['HTTP_SEC_WEBSOCKET_KEY2']
-        value2 = number_from_key(key2) / spaces_in_key(key2)
-        
-        hash = Digest::MD5.digest(big_endian(value1) +
-                                  big_endian(value2) +
-                                  env['rack.input'].read)
-        
-        upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
-        upgrade << "Upgrade: WebSocket\r\n"
-        upgrade << "Connection: Upgrade\r\n"
-        upgrade << "Sec-WebSocket-Origin: #{env['HTTP_ORIGIN']}\r\n"
-        upgrade << "Sec-WebSocket-Location: #{@socket.url}\r\n"
-        upgrade << "\r\n"
-        upgrade << hash
-        upgrade
-      end
-      
-    private
-      
-      def number_from_key(key)
-        key.scan(/[0-9]/).join('').to_i(10)
-      end
-      
-      def spaces_in_key(key)
-        key.scan(/ /).size
-      end
-      
-      def big_endian(number)
-        string = ''
-        [24,16,8,0].each do |offset|
-          string << (number >> offset & 0xFF).chr
-        end
-        string
-      end
-    end
-    
-  end
-end
-

data/lib/faye/util/web_socket/protocol8_parser.rb

@@ -1,324 +0,0 @@
-module Faye
-  class WebSocket
-    
-    class Protocol8Parser
-      GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
-      
-      FIN = MASK = 0b10000000
-      RSV1       = 0b01000000
-      RSV2       = 0b00100000
-      RSV3       = 0b00010000
-      OPCODE     = 0b00001111
-      LENGTH     = 0b01111111
-      
-      OPCODES = {
-        :continuation => 0,
-        :text         => 1,
-        :binary       => 2,
-        :close        => 8,
-        :ping         => 9,
-        :pong         => 10
-      }
-      
-      FRAGMENTED_OPCODES = OPCODES.values_at(:continuation, :text, :binary)
-      OPENING_OPCODES = OPCODES.values_at(:text, :binary)
-      
-      ERRORS = {
-        :normal_closure   => 1000,
-        :going_away       => 1001,
-        :protocol_error   => 1002,
-        :unacceptable     => 1003,
-        :encoding_error   => 1007,
-        :policy_violation => 1008,
-        :too_large        => 1009,
-        :extension_error  => 1010
-      }
-      
-      ERROR_CODES = ERRORS.values
-      
-      class Handshake
-        def initialize(uri)
-          @uri    = uri
-          @key    = Base64.encode64((1..16).map { rand(255).chr } * '').strip
-          @accept = Base64.encode64(Digest::SHA1.digest(@key + GUID)).strip
-          @buffer = []
-        end
-        
-        def request_data
-          hostname = @uri.host + (@uri.port ? ":#{@uri.port}" : '')
-          
-          handshake  = "GET #{@uri.path}#{@uri.query ? '?' : ''}#{@uri.query} HTTP/1.1\r\n"
-          handshake << "Host: #{hostname}\r\n"
-          handshake << "Upgrade: websocket\r\n"
-          handshake << "Connection: Upgrade\r\n"
-          handshake << "Sec-WebSocket-Key: #{@key}\r\n"
-          handshake << "Sec-WebSocket-Version: 8\r\n"
-          handshake << "\r\n"
-          
-          handshake
-        end
-        
-        def parse(data)
-          message  = []
-          complete = false
-          data.each_byte do |byte|
-            if complete
-              message << byte
-            else
-              @buffer << byte
-              complete ||= complete?
-            end
-          end
-          message
-        end
-        
-        def complete?
-          @buffer[-4..-1] == [0x0D, 0x0A, 0x0D, 0x0A]
-        end
-        
-        def valid?
-          data = Faye.encode(@buffer)
-          response = Net::HTTPResponse.read_new(Net::BufferedIO.new(StringIO.new(data)))
-          return false unless response.code.to_i == 101
-          
-          upgrade, connection = response['Upgrade'], response['Connection']
-          
-          upgrade and upgrade =~ /^websocket$/i and
-          connection and connection.split(/\s*,\s*/).include?('Upgrade') and
-          response['Sec-WebSocket-Accept'] == @accept
-        end
-      end
-      
-      def initialize(web_socket, options = {})
-        reset
-        @socket  = web_socket
-        @stage   = 0
-        @masking = options[:masking]
-      end
-      
-      def version
-        'protocol-8'
-      end
-      
-      def handshake_response
-        sec_key = @socket.env['HTTP_SEC_WEBSOCKET_KEY']
-        return '' unless String === sec_key
-        
-        accept = Base64.encode64(Digest::SHA1.digest(sec_key + GUID)).strip
-        
-        upgrade =  "HTTP/1.1 101 Switching Protocols\r\n"
-        upgrade << "Upgrade: websocket\r\n"
-        upgrade << "Connection: Upgrade\r\n"
-        upgrade << "Sec-WebSocket-Accept: #{accept}\r\n"
-        upgrade << "\r\n"
-        upgrade
-      end
-      
-      def create_handshake
-        Handshake.new(@socket.uri)
-      end
-      
-      def parse(data)
-        data.each_byte do |byte|
-          case @stage
-          when 0 then parse_opcode(byte)
-          when 1 then parse_length(byte)
-          when 2 then parse_extended_length(byte)
-          when 3 then parse_mask(byte)
-          when 4 then parse_payload(byte)
-          end
-          emit_frame if @stage == 4 and @length == 0
-        end
-      end
-      
-      def frame(data, type = nil, code = nil)
-        return nil if @closed
-        
-        type ||= (String === data ? :text : :binary)
-        data   = data.bytes.to_a if data.respond_to?(:bytes)
-        
-        if code
-          data = [code].pack('n').bytes.to_a + data
-        end
-        
-        frame  = (FIN | OPCODES[type]).chr
-        length = data.size
-        masked = @masking ? MASK : 0
-        
-        case length
-          when 0..125 then
-            frame << (masked | length).chr
-          when 126..65535 then
-            frame << (masked | 126).chr
-            frame << [length].pack('n')
-          else
-            frame << (masked | 127).chr
-            frame << [length >> 32, length & 0xFFFFFFFF].pack('NN')
-        end
-        
-        if @masking
-          mask = (1..4).map { rand 256 }
-          data.each_with_index do |byte, i|
-            data[i] = byte ^ mask[i % 4]
-          end
-          frame << mask.pack('C*')
-        end
-        
-        Faye.encode(frame) + Faye.encode(data)
-      end
-      
-      def close(code = nil, reason = nil, &callback)
-        return if @closed
-        @closing_callback ||= callback
-        @socket.send(reason || '', :close, code || ERRORS[:normal_closure])
-        @closed = true
-      end
-      
-    private
-      
-      def parse_opcode(data)
-        if [RSV1, RSV2, RSV3].any? { |rsv| (data & rsv) == rsv }
-          return @socket.close(ERRORS[:protocol_error], nil, false)
-        end
-        
-        @final   = (data & FIN) == FIN
-        @opcode  = (data & OPCODE)
-        @mask    = []
-        @payload = []
-        
-        unless OPCODES.values.include?(@opcode)
-          return @socket.close(ERRORS[:protocol_error], nil, false)
-        end
-        
-        unless FRAGMENTED_OPCODES.include?(@opcode) or @final
-          return @socket.close(ERRORS[:protocol_error], nil, false)
-        end
-        
-        if @mode and OPENING_OPCODES.include?(@opcode)
-          return @socket.close(ERRORS[:protocol_error], nil, false)
-        end
-        
-        @stage = 1
-      end
-      
-      def parse_length(data)
-        @masked = (data & MASK) == MASK
-        @length = (data & LENGTH)
-        
-        if @length <= 125
-          @stage = @masked ? 3 : 4
-        else
-          @length_buffer = []
-          @length_size   = (@length == 126) ? 2 : 8
-          @stage         = 2
-        end
-      end
-      
-      def parse_extended_length(data)
-        @length_buffer << data
-        return unless @length_buffer.size == @length_size
-        @length = integer(@length_buffer)
-        @stage  = @masked ? 3 : 4
-      end
-      
-      def parse_mask(data)
-        @mask << data
-        return if @mask.size < 4
-        @stage = 4
-      end
-      
-      def parse_payload(data)
-        @payload << data
-        return if @payload.size < @length
-        emit_frame
-      end
-      
-      def emit_frame
-        payload = unmask(@payload, @mask)
-        
-        case @opcode
-          when OPCODES[:continuation] then
-            return @socket.close(ERRORS[:protocol_error], nil, false) unless @mode
-            @buffer += payload
-            if @final
-              message = @buffer
-              message = Faye.encode(message, true) if @mode == :text
-              reset
-              if message
-                @socket.receive(message)
-              else
-                @socket.close(ERRORS[:encoding_error], nil, false)
-              end
-            end
-
-          when OPCODES[:text] then
-            if @final
-              message = Faye.encode(payload, true)
-              if message
-                @socket.receive(message)
-              else
-                @socket.close(ERRORS[:encoding_error], nil, false)
-              end
-            else
-              @mode = :text
-              @buffer += payload
-            end
-
-          when OPCODES[:binary] then
-            if @final
-              @socket.receive(payload)
-            else
-              @mode = :binary
-              @buffer += payload
-            end
-
-          when OPCODES[:close] then
-            code = (payload.size >= 2) ? 256 * payload[0] + payload[1] : nil
-            
-            unless (payload.size == 0) or
-                   (code && code >= 3000 && code < 5000) or
-                   ERROR_CODES.include?(code)
-              code = ERRORS[:protocol_error]
-            end
-            
-            if payload.size > 125 or not Faye.valid_utf8?(payload[2..-1] || [])
-              code = ERRORS[:protocol_error]
-            end
-            
-            reason = (payload.size > 2) ? Faye.encode(payload[2..-1], true) : nil
-            @socket.close(code, reason, false)
-            @closing_callback.call if @closing_callback
-
-          when OPCODES[:ping] then
-            return @socket.close(ERRORS[:protocol_error], nil, false) if payload.size > 125
-            @socket.send(payload, :pong)
-        end
-        @stage = 0
-      end
-
-      def reset
-        @buffer = []
-        @mode   = nil
-      end
-      
-      def integer(bytes)
-        number = 0
-        bytes.each_with_index do |data, i|
-          number += data << (8 * (bytes.size - 1 - i))
-        end
-        number
-      end
-      
-      def unmask(payload, mask)
-        unmasked = []
-        payload.each_with_index do |byte, i|
-          byte = byte ^ mask[i % 4] if mask.size > 0
-          unmasked << byte
-        end
-        unmasked
-      end
-    end
-    
-  end
-end
-