faye-websocket 0.4.7 → 0.5.0

data/lib/faye/websocket/hybi_parser/handshake.rb

@@ -1,78 +0,0 @@
-module Faye
-  class WebSocket
-    class HybiParser
-
-      class Handshake
-        GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
-
-        attr_reader :protocol
-
-        def initialize(uri, protocols)
-          @uri       = uri
-          @protocols = protocols
-          @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}" : '')
-          path = (@uri.path == '') ? '/' : @uri.path
-          headers = [
-            "GET #{path}#{@uri.query ? '?' : ''}#{@uri.query} HTTP/1.1",
-            "Host: #{hostname}",
-            "Upgrade: websocket",
-            "Connection: Upgrade",
-            "Sec-WebSocket-Key: #{@key}",
-            "Sec-WebSocket-Version: 13"
-          ]
-
-          if @protocols
-            headers << "Sec-WebSocket-Protocol: #{@protocols * ', '}"
-          end
-
-          (headers + ['','']).join("\r\n")
-        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 = WebSocket.encode(@buffer)
-
-          response = Net::HTTPResponse.read_new(Net::BufferedIO.new(StringIO.new(data)))
-          return false unless response.code.to_i == 101
-
-          upgrade    = response['Upgrade']
-          connection = response['Connection']
-          protocol   = response['Sec-WebSocket-Protocol']
-
-          @protocol = @protocols && @protocols.include?(protocol) ?
-                      protocol :
-                      nil
-
-          upgrade and upgrade =~ /^websocket$/i and
-          connection and connection.split(/\s*,\s*/).include?('Upgrade') and
-          ((!@protocols and !protocol) or @protocol) and
-          response['Sec-WebSocket-Accept'] == @accept
-        end
-      end
-
-    end
-  end
-end

data/lib/faye/websocket/hybi_parser/stream_reader.rb

@@ -1,29 +0,0 @@
-module Faye
-  class WebSocket
-    class HybiParser
-
-      class StreamReader
-        def initialize
-          @queue = []
-        end
-
-        def read(length)
-          read_bytes(length)
-        end
-
-        def put(bytes)
-          return unless bytes and bytes.size > 0
-          @queue.concat(bytes)
-        end
-
-      private
-
-        def read_bytes(length)
-          return nil if length > @queue.size
-          @queue.shift(length)
-        end
-      end
-
-    end
-  end
-end

data/lib/faye/websocket/utf8_match.rb

@@ -1,8 +0,0 @@
-module Faye
-  class WebSocket
-
-    # http://www.w3.org/International/questions/qa-forms-utf-8.en.php
-    UTF8_MATCH = /^([\x00-\x7F]|[\xC2-\xDF][\x80-\xBF]|\xE0[\xA0-\xBF][\x80-\xBF]|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}|\xED[\x80-\x9F][\x80-\xBF]|\xF0[\x90-\xBF][\x80-\xBF]{2}|[\xF1-\xF3][\x80-\xBF]{3}|\xF4[\x80-\x8F][\x80-\xBF]{2})*$/
-
-  end
-end

data/spec/faye/websocket/client_spec.rb

@@ -1,162 +0,0 @@
-# encoding=utf-8
-
-require "spec_helper"
-
-WebSocketSteps = EM::RSpec.async_steps do
-  def server(port, backend, secure, &callback)
-    @server = EchoServer.new
-    @server.listen(port, backend, secure)
-    @port = port
-    EM.add_timer(0.1, &callback)
-  end
-
-  def stop(&callback)
-    @server.stop
-    EM.next_tick(&callback)
-  end
-
-  def open_socket(url, protocols, &callback)
-    done = false
-
-    resume = lambda do |open|
-      unless done
-        done = true
-        @open = open
-        callback.call
-      end
-    end
-
-    @ws = Faye::WebSocket::Client.new(url, protocols)
-
-    @ws.onopen  = lambda { |e| resume.call(true) }
-    @ws.onclose = lambda { |e| resume.call(false) }
-  end
-
-  def close_socket(&callback)
-    @ws.onclose = lambda do |e|
-      @open = false
-      callback.call
-    end
-    @ws.close
-  end
-
-  def check_open(&callback)
-    @open.should == true
-    callback.call
-  end
-
-  def check_closed(&callback)
-    @open.should == false
-    callback.call
-  end
-
-  def check_protocol(protocol, &callback)
-    @ws.protocol.should == protocol
-    callback.call
-  end
-
-  def listen_for_message(&callback)
-    @ws.add_event_listener('message', lambda { |e| @message = e.data })
-    callback.call
-  end
-
-  def send_message(message, &callback)
-    @ws.send(message)
-    EM.add_timer(0.1, &callback)
-  end
-
-  def check_response(message, &callback)
-    @message.should == message
-    callback.call
-  end
-
-  def check_no_response(&callback)
-    @message.should == nil
-    callback.call
-  end
-end
-
-describe Faye::WebSocket::Client do
-  next if Faye::WebSocket.jruby?
-  include WebSocketSteps
-
-  let(:protocols)      { ["foo", "echo"]       }
-  let(:plain_text_url) { "ws://0.0.0.0:8000/"  }
-  let(:secure_url)     { "wss://0.0.0.0:8000/" }
-
-  shared_examples_for "socket client" do
-    it "can open a connection" do
-      open_socket(socket_url, protocols)
-      check_open
-      check_protocol("echo")
-    end
-
-    it "cannot open a connection to the wrong host" do
-      open_socket(blocked_url, protocols)
-      check_closed
-    end
-
-    it "cannot open a connection with unacceptable protocols" do
-      open_socket(socket_url, ["foo"])
-      check_closed
-    end
-
-    it "can close the connection" do
-      open_socket(socket_url, protocols)
-      close_socket
-      check_closed
-    end
-
-    describe "in the OPEN state" do
-      before { open_socket(socket_url, protocols) }
-
-      it "can send and receive messages" do
-        listen_for_message
-        send_message "I expect this to be echoed"
-        check_response "I expect this to be echoed"
-      end
-
-      it "sends numbers as strings" do
-        listen_for_message
-        send_message 13
-        check_response "13"
-      end
-    end
-
-    describe "in the CLOSED state" do
-      before do
-        open_socket(socket_url, protocols)
-        close_socket
-      end
-
-      it "cannot send and receive messages" do
-        listen_for_message
-        send_message "I expect this to be echoed"
-        check_no_response
-      end
-    end
-  end
-
-  describe "with a plain-text Thin server" do
-    let(:socket_url)  { plain_text_url }
-    let(:blocked_url) { secure_url }
-
-    before { server 8000, :thin, false }
-    after  { stop }
-
-    it_should_behave_like "socket client"
-  end
-
-  describe "with a secure Thin server" do
-    next if Faye::WebSocket.rbx?
-
-    let(:socket_url)  { secure_url }
-    let(:blocked_url) { plain_text_url }
-
-    before { server 8000, :thin, true }
-    after  { stop }
-
-    it_should_behave_like "socket client"
-  end
-end
-

data/spec/faye/websocket/draft75_parser_examples.rb

@@ -1,48 +0,0 @@
-# encoding=utf-8
-
-require "spec_helper"
-
-shared_examples_for "draft-75 parser" do
-  it "parses text frames" do
-    @web_socket.should_receive(:receive).with("Hello")
-    parse [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
-  end
-
-  it "parses multiple frames from the same packet" do
-    @web_socket.should_receive(:receive).with("Hello").exactly(2)
-    parse [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
-  end
-
-  it "parses text frames beginning 0x00-0x7F" do
-    @web_socket.should_receive(:receive).with("Hello")
-    parse [0x66, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
-  end
-
-  it "ignores frames with a length header" do
-    @web_socket.should_not_receive(:receive)
-    parse [0x80, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
-  end
-
-  it "parses text following an ignored block" do
-    @web_socket.should_receive(:receive).with("Hello")
-    parse [0x80, 0x02, 0x48, 0x65, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
-  end
-
-  it "parses multibyte text frames" do
-    @web_socket.should_receive(:receive).with(encode "Apple = ")
-    parse [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]
-  end
-
-  it "parses frames received in several packets" do
-    @web_socket.should_receive(:receive).with(encode "Apple = ")
-    parse [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65]
-    parse [0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]
-  end
-
-  it "parses fragmented frames" do
-    @web_socket.should_receive(:receive).with("Hello")
-    parse [0x00, 0x48, 0x65, 0x6c]
-    parse [0x6c, 0x6f, 0xff]
-  end
-end
-

data/spec/faye/websocket/draft75_parser_spec.rb

@@ -1,27 +0,0 @@
-# encoding=utf-8
-
-require "spec_helper"
-
-describe Faye::WebSocket::Draft75Parser do
-  include EncodingHelper
-
-  before do
-    @web_socket = mock Faye::WebSocket
-    @parser = Faye::WebSocket::Draft75Parser.new(@web_socket)
-  end
-
-  describe :parse do
-    it_should_behave_like "draft-75 parser"
-  end
-
-  describe :frame do
-    it "returns the given string formatted as a WebSocket frame" do
-      bytes(@parser.frame "Hello").should == [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
-    end
-
-    it "encodes multibyte characters correctly" do
-      message = encode "Apple = "
-      bytes(@parser.frame message).should == [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]
-    end
-  end
-end

data/spec/faye/websocket/draft76_parser_spec.rb

@@ -1,34 +0,0 @@
-# encoding=utf-8
-
-require "spec_helper"
-
-describe Faye::WebSocket::Draft76Parser do
-  include EncodingHelper
-
-  before do
-    @web_socket = mock Faye::WebSocket
-    @parser = Faye::WebSocket::Draft76Parser.new(@web_socket)
-    @parser.instance_eval { @handshake_complete = true }
-  end
-
-  describe :parse do
-    it_should_behave_like "draft-75 parser"
-
-    it "closes the socket if a close frame is received" do
-      @web_socket.should_receive(:close)
-      parse [0xFF, 0x00]
-    end
-  end
-
-  describe :frame do
-    it "returns the given string formatted as a WebSocket frame" do
-      bytes(@parser.frame "Hello").should == [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
-    end
-
-    it "encodes multibyte characters correctly" do
-      message = encode "Apple = "
-      bytes(@parser.frame message).should == [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]
-    end
-  end
-end
-

data/spec/faye/websocket/hybi_parser_spec.rb

@@ -1,149 +0,0 @@
-# encoding=utf-8
-
-require "spec_helper"
-
-describe Faye::WebSocket::HybiParser do
-  include EncodingHelper
-
-  before do
-    @web_socket = mock Faye::WebSocket
-    @parser = Faye::WebSocket::HybiParser.new(@web_socket)
-  end
-
-  describe :parse do
-    let(:mask) { (1..4).map { rand 255 } }
-
-    def mask_message(*bytes)
-      output = []
-      bytes.each_with_index do |byte, i|
-        output[i] = byte ^ mask[i % 4]
-      end
-      output
-    end
-
-    it "parses unmasked text frames" do
-      @web_socket.should_receive(:receive).with("Hello")
-      parse [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
-    end
-
-    it "parses multiple frames from the same packet" do
-      @web_socket.should_receive(:receive).with("Hello").exactly(2)
-      parse [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
-    end
-
-    it "parses empty text frames" do
-      @web_socket.should_receive(:receive).with("")
-      parse [0x81, 0x00]
-    end
-
-    it "parses fragmented text frames" do
-      @web_socket.should_receive(:receive).with("Hello")
-      parse [0x01, 0x03, 0x48, 0x65, 0x6c]
-      parse [0x80, 0x02, 0x6c, 0x6f]
-    end
-
-    it "parses masked text frames" do
-      @web_socket.should_receive(:receive).with("Hello")
-      parse [0x81, 0x85] + mask + mask_message(0x48, 0x65, 0x6c, 0x6c, 0x6f)
-    end
-
-    it "parses masked empty text frames" do
-      @web_socket.should_receive(:receive).with("")
-      parse [0x81, 0x80] + mask + mask_message()
-    end
-
-    it "parses masked fragmented text frames" do
-      @web_socket.should_receive(:receive).with("Hello")
-      parse [0x01, 0x81] + mask + mask_message(0x48)
-      parse [0x80, 0x84] + mask + mask_message(0x65, 0x6c, 0x6c, 0x6f)
-    end
-
-    it "closes the socket if the frame has an unrecognized opcode" do
-      @web_socket.should_receive(:close).with(1002, nil, false)
-      parse [0x83, 0x00]
-    end
-
-    it "closes the socket if a close frame is received" do
-      @web_socket.should_receive(:close).with(1000, "Hello", false)
-      parse [0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
-    end
-
-    it "parses unmasked multibyte text frames" do
-      @web_socket.should_receive(:receive).with(encode "Apple = ")
-      parse [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]
-    end
-
-    it "parses frames received in several packets" do
-      @web_socket.should_receive(:receive).with(encode "Apple = ")
-      parse [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c]
-      parse [0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]
-    end
-
-    it "parses fragmented multibyte text frames" do
-      @web_socket.should_receive(:receive).with(encode "Apple = ")
-      parse [0x01, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3]
-      parse [0x80, 0x01, 0xbf]
-    end
-
-    it "parses masked multibyte text frames" do
-      @web_socket.should_receive(:receive).with(encode "Apple = ")
-      parse [0x81, 0x8b] + mask + mask_message(0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf)
-    end
-
-    it "parses masked fragmented multibyte text frames" do
-      @web_socket.should_receive(:receive).with(encode "Apple = ")
-      parse [0x01, 0x8a] + mask + mask_message(0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3)
-      parse [0x80, 0x81] + mask + mask_message(0xbf)
-    end
-
-    it "parses unmasked medium-length text frames" do
-      @web_socket.should_receive(:receive).with("Hello" * 40)
-      parse [0x81, 0x7e, 0x00, 0xc8] + [0x48, 0x65, 0x6c, 0x6c, 0x6f] * 40
-    end
-
-    it "parses masked medium-length text frames" do
-      @web_socket.should_receive(:receive).with("Hello" * 40)
-      parse [0x81, 0xfe, 0x00, 0xc8] + mask + mask_message(*([0x48, 0x65, 0x6c, 0x6c, 0x6f] * 40))
-    end
-
-    it "replies to pings with a pong" do
-      @web_socket.should_receive(:send).with([0x4f, 0x48, 0x41, 0x49], :pong)
-      parse [0x89, 0x04, 0x4f, 0x48, 0x41, 0x49]
-    end
-  end
-
-  describe :frame do
-    it "returns the given string formatted as a WebSocket frame" do
-      bytes(@parser.frame "Hello").should == [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
-    end
-
-    it "encodes multibyte characters correctly" do
-      message = encode "Apple = "
-      bytes(@parser.frame message).should == [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]
-    end
-
-    it "encodes medium-length strings using extra length bytes" do
-      message = "Hello" * 40
-      bytes(@parser.frame message).should == [0x81, 0x7e, 0x00, 0xc8] + [0x48, 0x65, 0x6c, 0x6c, 0x6f] * 40
-    end
-
-    it "encodes close frames with an error code" do
-      frame = @parser.frame "Hello", :close, 1002
-      bytes(frame).should == [0x88, 0x07, 0x03, 0xea, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
-    end
-
-    it "encodes pong frames" do
-      bytes(@parser.frame '', :pong).should == [0x8a, 0x00]
-    end
-  end
-
-  describe :utf8 do
-    it "detects valid UTF-8" do
-      Faye::WebSocket.valid_utf8?( [72, 101, 108, 108, 111, 45, 194, 181, 64, 195, 159, 195, 182, 195, 164, 195, 188, 195, 160, 195, 161, 45, 85, 84, 70, 45, 56, 33, 33] ).should be_true
-    end
-
-    it "detects invalid UTF-8" do
-      Faye::WebSocket.valid_utf8?( [206, 186, 225, 189, 185, 207, 131, 206, 188, 206, 181, 237, 160, 128, 101, 100, 105, 116, 101, 100] ).should be_false
-    end
-  end
-end