Remove the websocket-driver submodule.

Refer to 3rd 'upgrade' argument as 'body' instead of 'head'.
Return a normal HTTP response if the request is not a WebSocket in the documentation.
2013-05-04 20:45:26 +01:00 · 2013-05-04 17:37:53 +01:00 · 2013-05-04 17:33:57 +01:00 · 2013-05-04 17:30:07 +01:00 · 2013-05-04 16:43:03 +01:00 · 2013-05-04 15:09:45 +01:00
41 changed files with 1091 additions and 3320 deletions
@@ -1,6 +1,6 @@
 .git
 .gitignore
 .npmignore
+.redcar
 .travis.yml
 node_modules
-spec
@@ -4,8 +4,5 @@ node_js:
  - "0.6"
  - "0.8"
  - "0.10"
-  - "0.12"
-  - "iojs"
+  - "0.11"

-before_install:
-  - '[ "${TRAVIS_NODE_VERSION}" = "0.6" ] && npm conf set strict-ssl false || true'
@@ -1,73 +1,62 @@
-### 0.5.3 / 2015-02-22
+### 0.4.4 / 2013-02-14

-* Don't treat incoming data as WebSocket frames if a client driver is closed
-  before receiving the server handshake
+* Emit the `close` event if TCP is closed before CLOSE frame is acked

-### 0.5.2 / 2015-02-19

-* Fix compatibility with the HTTP parser on io.js
-* Use `websocket-extensions` to make sure messages and close frames are kept in order
-* Don't emit multiple `error` events
+### 0.4.3 / 2012-07-09

-### 0.5.1 / 2014-12-18
+* Add `Connection: close` to EventSource response
+* Handle situations where `request.socket` is undefined

-* Don't allow drivers to be created with unrecognized options

-### 0.5.0 / 2014-12-13
+### 0.4.2 / 2012-04-06

-* Support protocol extensions via the websocket-extensions module
+* Add WebSocket error code `1011`.
+* Handle URLs with no path correctly by sending `GET /`

-### 0.4.0 / 2014-11-08

-* Support connection via HTTP proxies using `CONNECT`
+### 0.4.1 / 2012-02-26

-### 0.3.6 / 2014-10-04
+* Treat anything other than a `Buffer` as a string when calling `send()`

-* It is now possible to call `close()` before `start()` and close the driver

-### 0.3.5 / 2014-07-06
+### 0.4.0 / 2012-02-13

-* Don't hold references to frame buffers after a message has been emitted
-* Make sure that `protocol` and `version` are exposed properly by the TCP driver
+* Add `ping()` method to server-side `WebSocket` and `EventSource`
+* Buffer `send()` calls until the draft-76 handshake is complete
+* Fix HTTPS problems on Node 0.7

-### 0.3.4 / 2014-05-08

-* Don't hold memory-leaking references to I/O buffers after they have been parsed
+### 0.3.1 / 2012-01-16

-### 0.3.3 / 2014-04-24
+* Call `setNoDelay(true)` on `net.Socket` objects to reduce latency

-* Correct the draft-76 status line reason phrase

-### 0.3.2 / 2013-12-29
+### 0.3.0 / 2012-01-13

-* Expand `maxLength` to cover sequences of continuation frames and `draft-{75,76}`
-* Decrease default maximum frame buffer size to 64MB
-* Stop parsing when the protocol enters a failure mode, to save CPU cycles
+* Add support for `EventSource` connections

-### 0.3.1 / 2013-12-03

-* Add a `maxLength` option to limit allowed frame size
-* Don't pre-allocate a message buffer until the whole frame has arrived
-* Fix compatibility with Node v0.11 `HTTPParser`
+### 0.2.0 / 2011-12-21

-### 0.3.0 / 2013-09-09
+* Add support for `Sec-WebSocket-Protocol` negotiation
+* Support `hixie-76` close frames and 75/76 ignored segments
+* Improve performance of HyBi parsing/framing functions
+* Decouple parsers from TCP and reduce write volume

-* Support client URLs with Basic Auth credentials

-### 0.2.2 / 2013-07-05
+### 0.1.2 / 2011-12-05

-* No functional changes, just updates to package.json
+* Detect closed sockets on the server side when TCP connection breaks
+* Make `hixie-76` sockets work through HAProxy

-### 0.2.1 / 2013-05-17

-* Export the isSecureRequest() method since faye-websocket relies on it
-* Queue sent messages in the client's initial state
+### 0.1.1 / 2011-11-30

-### 0.2.0 / 2013-05-12
+* Fix `addEventListener()` interface methods

-* Add API for setting and reading headers
-* Add Driver.server() method for getting a driver for TCP servers

-### 0.1.0 / 2013-05-04
+### 0.1.0 / 2011-11-27
+
+* Initial release, based on WebSocket components from Faye

-* First stable release
@@ -1,374 +1,259 @@
-# websocket-driver [![Build Status](https://travis-ci.org/faye/websocket-driver-node.svg)](https://travis-ci.org/faye/websocket-driver-node)
+# faye-websocket

-This module provides a complete implementation of the WebSocket protocols that
-can be hooked up to any I/O stream. It aims to simplify things by decoupling the
-protocol details from the I/O layer, such that users only need to implement code
-to stream data in and out of it without needing to know anything about how the
-protocol actually works. Think of it as a complete WebSocket system with
-pluggable I/O.
+* Travis CI build: [![Build
+  status](https://secure.travis-ci.org/faye/faye-websocket-node.png)](http://travis-ci.org/faye/faye-websocket-node)
+* Autobahn tests: [server](http://faye.jcoglan.com/autobahn/servers/),
+  [client](http://faye.jcoglan.com/autobahn/clients/)

-Due to this design, you get a lot of things for free. In particular, if you hook
-this module up to some I/O object, it will do all of this for you:
+This is a general-purpose WebSocket implementation extracted from the
+[Faye](http://faye.jcoglan.com) project. It provides classes for easily
+building WebSocket servers and clients in Node. It does not provide a server
+itself, but rather makes it easy to handle WebSocket connections within an
+existing [Node](http://nodejs.org/) application. It does not provide any
+abstraction other than the standard [WebSocket
+API](http://dev.w3.org/html5/websockets/).

-* Select the correct server-side driver to talk to the client
-* Generate and send both server- and client-side handshakes
-* Recognize when the handshake phase completes and the WS protocol begins
-* Negotiate subprotocol selection based on `Sec-WebSocket-Protocol`
-* Negotiate and use extensions via the
-  [websocket-extensions](https://github.com/faye/websocket-extensions-node)
-  module
-* Buffer sent messages until the handshake process is finished
-* Deal with proxies that defer delivery of the draft-76 handshake body
-* Notify you when the socket is open and closed and when messages arrive
-* Recombine fragmented messages
-* Dispatch text, binary, ping and close frames
-* Manage the socket-closing handshake process
-* Automatically reply to ping frames with a matching pong
-* Apply masking to messages sent by the client
-
-This library was originally extracted from the [Faye](http://faye.jcoglan.com)
-project but now aims to provide simple WebSocket support for any Node-based
-project.
+It also provides an abstraction for handling
+[EventSource](http://dev.w3.org/html5/eventsource/) connections, which are
+one-way connections that allow the server to push data to the client. They are
+based on streaming HTTP responses and can be easier to access via proxies than
+WebSockets.


 ## Installation

 ```
-$ npm install websocket-driver
+$ npm install faye-websocket
 ```


-## Usage
+## Handling WebSocket connections in Node

-This module provides protocol drivers that have the same interface on the server
-and on the client. A WebSocket driver is an object with two duplex streams
-attached; one for incoming/outgoing messages and one for managing the wire
-protocol over an I/O stream. The full API is described below.
-
-
-### Server-side with HTTP
-
-A Node webserver emits a special event for 'upgrade' requests, and this is where
-you should handle WebSockets. You first check whether the request is a
-WebSocket, and if so you can create a driver and attach the request's I/O stream
-to it.
+You can handle WebSockets on the server side by listening for HTTP Upgrade
+requests, and creating a new socket for the request. This socket object exposes
+the usual WebSocket methods for receiving and sending messages. For example this
+is how you'd implement an echo server:

 ```js
-var http = require('http'),
-    websocket = require('websocket-driver');
+var WebSocket = require('faye-websocket'),
+    http      = require('http');

 var server = http.createServer();

 server.on('upgrade', function(request, socket, body) {
-  if (!websocket.isWebSocket(request)) return;
+  if (WebSocket.isWebSocket(request)) {
+    var ws = new WebSocket(request, socket, body);
+    
+    ws.on('message', function(event) {
+      ws.send(event.data);
+    });
+    
+    ws.on('close', function(event) {
+      console.log('close', event.code, event.reason);
+      ws = null;
+    });

-  var driver = websocket.http(request);
-
-  driver.io.write(body);
-  socket.pipe(driver.io).pipe(socket);
-
-  driver.messages.on('data', function(message) {
-    console.log('Got a message', message);
-  });
-
-  driver.start();
+  }
 });
+
+server.listen(8000);
 ```

-Note the line `driver.io.write(body)` - you must pass the `body` buffer to the
-socket driver in order to make certain versions of the protocol work.
+Note that under certain circumstances (notably a draft-76 client connecting
+through an HTTP proxy), the WebSocket handshake will not be complete after you
+call `new WebSocket()` because the server will not have received the entire
+handshake from the client yet. In this case, calls to `ws.send()` will buffer
+the message in memory until the handshake is complete, at which point any
+buffered messages will be sent to the client.

+If you need to detect when the WebSocket handshake is complete, you can use the
+`onopen` event.

-### Server-side with TCP
-
-You can also handle WebSocket connections in a bare TCP server, if you're not
-using an HTTP server and don't want to implement HTTP parsing yourself.
-
-The driver will emit a `connect` event when a request is received, and at this
-point you can detect whether it's a WebSocket and handle it as such. Here's an
-example using the Node `net` module:
+If the connection's protocol version supports it, you can call `ws.ping()` to
+send a ping message and wait for the client's response. This method takes a
+message string, and an optional callback that fires when a matching pong
+message is received. It returns `true` iff a ping message was sent. If the
+client does not support ping/pong, this method sends no data and returns
+`false`.

 ```js
-var net = require('net'),
-    websocket = require('websocket-driver');
-
-var server = net.createServer(function(connection) {
-  var driver = websocket.server();
-
-  driver.on('connect', function() {
-    if (websocket.isWebSocket(driver)) {
-      driver.start();
-    } else {
-      // handle other HTTP requests
-    }
-  });
-
-  driver.on('close', function() { connection.end() });
-  connection.on('error', function() {});
-
-  connection.pipe(driver.io).pipe(connection);
-
-  driver.messages.pipe(driver.messages);
+ws.ping('Mic check, one, two', function() {
+  // fires when pong is received
 });
-
-server.listen(4180);
 ```

-In the `connect` event, the driver gains several properties to describe the
-request, similar to a Node request object, such as `method`, `url` and
-`headers`. However you should remember it's not a real request object; you
-cannot write data to it, it only tells you what request data we parsed from the
-input.

-If the request has a body, it will be in the `driver.body` buffer, but only as
-much of the body as has been piped into the driver when the `connect` event
-fires.
-
-
-### Client-side
-
-Similarly, to implement a WebSocket client you just need to make a driver by
-passing in a URL. After this you use the driver API as described below to
-process incoming data and send outgoing data.
+## Using the WebSocket client

+The client supports both the plain-text `ws` protocol and the encrypted `wss`
+protocol, and has exactly the same interface as a socket you would use in a web
+browser. On the wire it identifies itself as `hybi-13`.

 ```js
-var net = require('net'),
-    websocket = require('websocket-driver');
+var WebSocket = require('faye-websocket'),
+    ws        = new WebSocket.Client('ws://www.example.com/');

-var driver = websocket.client('ws://www.example.com/socket'),
-    tcp = net.connect(80, 'www.example.com');
-
-tcp.pipe(driver.io).pipe(tcp);
-
-tcp.on('connect', function() {
-  driver.start();
+ws.on('open', function(event) {
+  console.log('open');
+  ws.send('Hello, world!');
 });

-driver.messages.on('data', function(message) {
-  console.log('Got a message', message);
+ws.on('message', function(event) {
+  console.log('message', event.data);
+});
+
+ws.on('close', function(event) {
+  console.log('close', event.code, event.reason);
+  ws = null;
 });
 ```

-Client drivers have two additional properties for reading the HTTP data that was
-sent back by the server:

-* `driver.statusCode` - the integer value of the HTTP status code
-* `driver.headers` - an object containing the response headers
+## Subprotocol negotiation

-
-### HTTP Proxies
-
-The client driver supports connections via HTTP proxies using the `CONNECT`
-method. Instead of sending the WebSocket handshake immediately, it will send a
-`CONNECT` request, wait for a `200` response, and then proceed as normal.
-
-To use this feature, call `driver.proxy(url)` where `url` is the origin of the
-proxy, including a username and password if required. This produces a duplex
-stream that you should pipe in and out of your TCP connection to the proxy
-server. When the proxy emits `connect`, you can then pipe `driver.io` to your
-TCP stream and call `driver.start()`.
+The WebSocket protocol allows peers to select and identify the application
+protocol to use over the connection. On the client side, you can set which
+protocols the client accepts by passing a list of protocol names when you
+construct the socket:

 ```js
-var net = require('net'),
-    websocket = require('websocket-driver');
-
-var driver = websocket.client('ws://www.example.com/socket'),
-    proxy  = driver.proxy('http://username:password@proxy.example.com'),
-    tcp    = net.connect(80, 'proxy.example.com');
-
-tcp.pipe(proxy).pipe(tcp, {end: false});
-
-tcp.on('connect', function() {
-  proxy.start();
-});
-
-proxy.on('connect', function() {
-  driver.io.pipe(tcp).pipe(driver.io);
-  driver.start();
-});
-
-driver.messages.on('data', function(message) {
-  console.log('Got a message', message);
-});
+var ws = new WebSocket.Client('ws://www.example.com/', ['irc', 'amqp']);
 ```

-The proxy's `connect` event is also where you should perform a TLS handshake on
-your TCP stream, if you are connecting to a `wss:` endpoint.
-
-In the event that proxy connection fails, `proxy` will emit an `error`. You can
-inspect the proxy's response via `proxy.statusCode` and `proxy.headers`.
+On the server side, you can likewise pass in the list of protocols the server
+supports after the other constructor arguments:

 ```js
-proxy.on('error', function(error) {
-  console.error(error.message);
-  console.log(proxy.statusCode);
-  console.log(proxy.headers);
+var ws = new WebSocket(request, socket, body, ['irc', 'amqp']);
+```
+
+If the client and server agree on a protocol, both the client- and server-side
+socket objects expose the selected protocol through the `ws.protocol` property.
+
+
+## WebSocket API
+
+Both server- and client-side `WebSocket` objects support the following API:
+
+* <b>`on('open', function(event) {})`</b> fires when the socket connection is
+  established. Event has no attributes.
+* <b>`on('message', function(event) {})`</b> fires when the socket receives a
+  message. Event has one attribute, <b>`data`</b>, which is either a `String`
+  (for text frames) or a `Buffer` (for binary frames).
+* <b>`on('error', function(event) {})`</b> fires when there is a protocol error
+  due to bad data sent by the other peer. This event is purely informational,
+  you do not need to implement error recover.
+* <b>`on('close', function(event) {})`</b> fires when either the client or the
+  server closes the connection. Event has two optional attributes,
+  <b>`code`</b> and <b>`reason`</b>, that expose the status code and message
+  sent by the peer that closed the connection.
+* <b>`send(message)`</b> accepts either a `String` or a `Buffer` and sends a
+  text or binary message over the connection to the other peer.
+* <b>`ping(message = '', function() {})`</b> sends a ping frame with an
+  optional message and fires the callback when a matching pong is received.
+* <b>`close(code, reason)`</b> closes the connection, sending the given status
+  code and reason text, both of which are optional.
+* <b>`version`</b> is a string containing the version of the `WebSocket`
+  protocol the connection is using.
+* <b>`protocol`</b> is a string (which may be empty) identifying the
+  subprotocol the socket is using.
+
+
+## Handling EventSource connections in Node
+
+EventSource connections provide a very similar interface, although because they
+only allow the server to send data to the client, there is no `onmessage` API.
+EventSource allows the server to push text messages to the client, where each
+message has an optional event-type and ID.
+
+```js
+var WebSocket   = require('faye-websocket'),
+    EventSource = WebSocket.EventSource,
+    http        = require('http');
+
+var server = http.createServer();
+
+server.on('request', function(request, response) {
+  if (EventSource.isEventSource(request)) {
+    var es = new EventSource(request, response);
+    console.log('open', es.url, es.lastEventId);
+    
+    // Periodically send messages
+    var loop = setInterval(function() { es.send('Hello') }, 1000);
+    
+    es.on('close', function() {
+      clearInterval(loop);
+      es = null;
+    });
+  
+  } else {
+    // Normal HTTP request
+    response.writeHead(200, {'Content-Type': 'text/plain'});
+    response.end('Hello');
+  }
 });
+
+server.listen(8000);
 ```

-Before calling `proxy.start()` you can set custom headers using
-`proxy.setHeader()`:
+The `send` method takes two optional parameters, `event` and `id`. The default
+event-type is `'message'` with no ID. For example, to send a `notification`
+event with ID `99`:

 ```js
-proxy.setHeader('User-Agent', 'node');
-proxy.start();
+es.send('Breaking News!', {event: 'notification', id: '99'});
 ```

+The `EventSource` object exposes the following properties:

-### Driver API
+* <b>`url`</b> is a string containing the URL the client used to create the
+  EventSource.
+* <b>`lastEventId`</b> is a string containing the last event ID received by the
+  client. You can use this when the client reconnects after a dropped
+  connection to determine which messages need resending.

-Drivers are created using one of the following methods:
+When you initialize an EventSource with ` new EventSource()`, you can pass
+configuration options after the `response` parameter. Available options are:
+
+* <b>`retry`</b> is a number that tells the client how long (in seconds) it
+  should wait after a dropped connection before attempting to reconnect.
+* <b>`ping`</b> is a number that tells the server how often (in seconds) to
+  send 'ping' packets to the client to keep the connection open, to defeat
+  timeouts set by proxies. The client will ignore these messages.
+
+For example, this creates a connection that pings every 15 seconds and is
+retryable every 10 seconds if the connection is broken:

 ```js
-driver = websocket.http(request, options)
-driver = websocket.server(options)
-driver = websocket.client(url, options)
+var es = new EventSource(request, response, {ping: 15, retry: 10});
 ```

-The `http` method returns a driver chosen using the headers from a Node HTTP
-request object. The `server` method returns a driver that will parse an HTTP
-request and then decide which driver to use for it using the `http` method. The
-`client` method always returns a driver for the RFC version of the protocol with
-masking enabled on outgoing frames.
-
-The `options` argument is optional, and is an object. It may contain the
-following fields:
-
-* `maxLength` - the maximum allowed size of incoming message frames, in bytes.
-  The default value is `2^26 - 1`, or 1 byte short of 64 MiB.
-* `protocols` - an array of strings representing acceptable subprotocols for use
-  over the socket. The driver will negotiate one of these to use via the
-  `Sec-WebSocket-Protocol` header if supported by the other peer.
-
-A driver has two duplex streams attached to it:
-
-* <b>`driver.io`</b> - this stream should be attached to an I/O socket like a
-  TCP stream. Pipe incoming TCP chunks to this stream for them to be parsed, and
-  pipe this stream back into TCP to send outgoing frames.
-* <b>`driver.messages`</b> - this stream emits messages received over the
-  WebSocket.  Writing to it sends messages to the other peer by emitting frames
-  via the `driver.io` stream.
-
-All drivers respond to the following API methods, but some of them are no-ops
-depending on whether the client supports the behaviour.
-
-Note that most of these methods are commands: if they produce data that should
-be sent over the socket, they will give this to you by emitting `data` events on
-the `driver.io` stream.
-
-#### `driver.on('open', function(event) {})`
-
-Sets the callback to execute when the socket becomes open.
-
-#### `driver.on('message', function(event) {})`
-
-Sets the callback to execute when a message is received. `event` will have a
-`data` attribute containing either a string in the case of a text message or a
-`Buffer` in the case of a binary message.
-
-You can also listen for messages using the `driver.messages.on('data')` event,
-which emits strings for text messages and buffers for binary messages.
-
-#### `driver.on('error', function(event) {})`
-
-Sets the callback to execute when a protocol error occurs due to the other peer
-sending an invalid byte sequence. `event` will have a `message` attribute
-describing the error.
-
-#### `driver.on('close', function(event) {})`
-
-Sets the callback to execute when the socket becomes closed. The `event` object
-has `code` and `reason` attributes.
-
-#### `driver.addExtension(extension)`
-
-Registers a protocol extension whose operation will be negotiated via the
-`Sec-WebSocket-Extensions` header. `extension` is any extension compatible with
-the [websocket-extensions](https://github.com/faye/websocket-extensions-node)
-framework.
-
-#### `driver.setHeader(name, value)`
-
-Sets a custom header to be sent as part of the handshake response, either from
-the server or from the client. Must be called before `start()`, since this is
-when the headers are serialized and sent.
-
-#### `driver.start()`
-
-Initiates the protocol by sending the handshake - either the response for a
-server-side driver or the request for a client-side one. This should be the
-first method you invoke.  Returns `true` iff a handshake was sent.
-
-#### `driver.parse(string)`
-
-Takes a string and parses it, potentially resulting in message events being
-emitted (see `on('message')` above) or in data being sent to `driver.io`.  You
-should send all data you receive via I/O to this method by piping a stream into
-`driver.io`.
-
-#### `driver.text(string)`
-
-Sends a text message over the socket. If the socket handshake is not yet
-complete, the message will be queued until it is. Returns `true` if the message
-was sent or queued, and `false` if the socket can no longer send messages.
-
-This method is equivalent to `driver.messages.write(string)`.
-
-#### `driver.binary(buffer)`
-
-Takes a `Buffer` and sends it as a binary message. Will queue and return `true`
-or `false` the same way as the `text` method. It will also return `false` if the
-driver does not support binary messages.
-
-This method is equivalent to `driver.messages.write(buffer)`.
-
-#### `driver.ping(string = '', function() {})`
-
-Sends a ping frame over the socket, queueing it if necessary. `string` and the
-callback are both optional. If a callback is given, it will be invoked when the
-socket receives a pong frame whose content matches `string`. Returns `false` if
-frames can no longer be sent, or if the driver does not support ping/pong.
-
-#### `driver.close()`
-
-Initiates the closing handshake if the socket is still open. For drivers with no
-closing handshake, this will result in the immediate execution of the
-`on('close')` driver. For drivers with a closing handshake, this sends a closing
-frame and `emit('close')` will execute when a response is received or a protocol
-error occurs.
-
-#### `driver.version`
-
-Returns the WebSocket version in use as a string. Will either be `hixie-75`,
-`hixie-76` or `hybi-$version`.
-
-#### `driver.protocol`
-
-Returns a string containing the selected subprotocol, if any was agreed upon
-using the `Sec-WebSocket-Protocol` mechanism. This value becomes available after
-`emit('open')` has fired.
+You can send a ping message at any time by calling `es.ping()`. Unlike
+WebSocket, the client does not send a response to this; it is merely to send
+some data over the wire to keep the connection alive.


 ## License

 (The MIT License)

-Copyright (c) 2010-2015 James Coglan
+Copyright (c) 2010-2013 James Coglan

 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the 'Software'), to deal in
 the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
@@ -0,0 +1,44 @@
+var WebSocket = require('../lib/faye/websocket'),
+    pace      = require('pace');
+
+var host  = 'ws://localhost:9001',
+    agent = 'Node ' + process.version,
+    cases = 0,
+    skip  = [];
+
+var socket = new WebSocket.Client(host + '/getCaseCount'),
+    progress;
+
+socket.onmessage = function(event) {
+  console.log('Total cases to run: ' + event.data);
+  cases = parseInt(event.data);
+  progress = pace(cases);
+};
+
+socket.onclose = function() {
+  var runCase = function(n) {
+    progress.op();
+
+    if (n > cases) {
+      socket = new WebSocket.Client(host + '/updateReports?agent=' + encodeURIComponent(agent));
+      socket.onclose = process.exit;
+
+    } else if (skip.indexOf(n) >= 0) {
+      runCase(n + 1);
+
+    } else {
+      socket = new WebSocket.Client(host + '/runCase?case=' + n + '&agent=' + encodeURIComponent(agent));
+
+      socket.onmessage = function(event) {
+        socket.send(event.data);
+      };
+
+      socket.onclose = function() {
+        runCase(n + 1);
+      };
+    }
+  };
+
+  runCase(1);
+};
+
@@ -0,0 +1,22 @@
+var WebSocket = require('../lib/faye/websocket'),
+    port      = process.argv[2] || 7000,
+    secure    = process.argv[3] === 'ssl',
+    scheme    = secure ? 'wss' : 'ws',
+    ws        = new WebSocket.Client(scheme + '://localhost:' + port + '/');
+
+console.log('Connecting to ' + ws.url);
+
+ws.onopen = function(event) {
+  console.log('open');
+  ws.send('Hello, WebSocket!');
+};
+
+ws.onmessage = function(event) {
+  console.log('message', event.data);
+  // ws.close(1002, 'Going away');
+};
+
+ws.onclose = function(event) {
+  console.log('close', event.code, event.reason);
+};
+
@@ -0,0 +1,21 @@
+defaults
+   mode http
+   timeout client  5s
+   timeout connect 5s
+   timeout server  5s
+
+frontend all 0.0.0.0:3000
+   mode http
+   timeout client 120s
+
+   option forwardfor
+   option http-server-close
+   option http-pretend-keepalive
+
+   default_backend sockets
+
+backend sockets
+   balance uri depth 2
+   timeout server  120s
+   server socket1 127.0.0.1:7000
+
@@ -0,0 +1,68 @@
+var WebSocket = require('../lib/faye/websocket'),
+    fs        = require('fs'),
+    http      = require('http'),
+    https     = require('https');
+
+var port   = process.argv[2] || 7000,
+    secure = process.argv[3] === 'ssl';
+
+var upgradeHandler = function(request, socket, head) {
+  var ws = new WebSocket(request, socket, head, ['irc', 'xmpp'], {ping: 5});
+  console.log('open', ws.url, ws.version, ws.protocol);
+
+  ws.pipe(ws);
+
+  ws.onclose = function(event) {
+    console.log('close', event.code, event.reason);
+    ws = null;
+  };
+};
+
+var requestHandler = function(request, response) {
+  if (!WebSocket.EventSource.isEventSource(request))
+    return staticHandler(request, response);
+
+  var es   = new WebSocket.EventSource(request, response),
+      time = parseInt(es.lastEventId, 10) || 0;
+
+  console.log('open', es.url, es.lastEventId);
+
+  var loop = setInterval(function() {
+    time += 1;
+    es.send('Time: ' + time);
+    setTimeout(function() {
+      if (es) es.send('Update!!', {event: 'update', id: time});
+    }, 1000);
+  }, 2000);
+
+  fs.createReadStream(__dirname + '/haproxy.conf').pipe(es);
+
+  es.onclose = function() {
+    clearInterval(loop);
+    console.log('close', es.url);
+    es = null;
+  };
+};
+
+var staticHandler = function(request, response) {
+  var path = request.url;
+
+  fs.readFile(__dirname + path, function(err, content) {
+    var status = err ? 404 : 200;
+    response.writeHead(status, {'Content-Type': 'text/html'});
+    response.write(content || 'Not found');
+    response.end();
+  });
+};
+
+var server = secure
+           ? https.createServer({
+               key:  fs.readFileSync(__dirname + '/../spec/server.key'),
+               cert: fs.readFileSync(__dirname + '/../spec/server.crt')
+             })
+           : http.createServer();
+
+server.on('request', requestHandler);
+server.on('upgrade', upgradeHandler);
+server.listen(port);
+
@@ -0,0 +1,39 @@
+<!doctype html>
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+    <title>EventSource test</title>
+  </head>
+  <body>
+
+    <h1>EventSource test</h1>
+    <ul></ul>
+
+    <script type="text/javascript">
+      var logger = document.getElementsByTagName('ul')[0],
+          socket = new EventSource('/');
+
+      var log = function(text) {
+        logger.innerHTML += '<li>' + text + '</li>';
+      };
+
+      socket.onopen = function() {
+        log('OPEN');
+      };
+
+      socket.onmessage = function(event) {
+        log('MESSAGE: ' + event.data);
+      };
+
+      socket.addEventListener('update', function(event) {
+        log('UPDATE(' + event.lastEventId + '): ' + event.data);
+      });
+
+      socket.onerror = function(event) {
+        log('ERROR: ' + event.message);
+      };
+    </script>
+
+  </body>
+</html>
+
@@ -1,22 +0,0 @@
-var net       = require('net'),
-    websocket = require('../lib/websocket/driver'),
-    deflate   = require('permessage-deflate');
-
-var server = net.createServer(function(connection) {
-  var driver = websocket.server();
-  driver.addExtension(deflate);
-
-  driver.on('connect', function() {
-    if (websocket.isWebSocket(driver)) driver.start();
-  });
-
-  driver.on('close', function() { connection.end() });
-  connection.on('error', function() {});
-
-  connection.pipe(driver.io);
-  driver.io.pipe(connection);
-
-  driver.messages.pipe(driver.messages);
-});
-
-server.listen(process.argv[2]);
@@ -0,0 +1,44 @@
+<!doctype html>
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+    <title>WebSocket test</title>
+  </head>
+  <body>
+
+    <h1>WebSocket test</h1>
+    <ul></ul>
+
+    <script type="text/javascript">
+      var logger = document.getElementsByTagName('ul')[0],
+          Socket = window.MozWebSocket || window.WebSocket,
+          protos = ['foo', 'bar', 'xmpp'],
+          socket = new Socket('ws://' + location.hostname + ':' + location.port + '/', protos),
+          index  = 0;
+
+      var log = function(text) {
+        logger.innerHTML += '<li>' + text + '</li>';
+      };
+
+      socket.addEventListener('open', function() {
+        log('OPEN: ' + socket.protocol);
+        socket.send('Hello, world');
+      });
+
+      socket.onerror = function(event) {
+        log('ERROR: ' + event.message);
+      };
+
+      socket.onmessage = function(event) {
+        log('MESSAGE: ' + event.data);
+        setTimeout(function() { socket.send(++index + ' ' + event.data) }, 2000);
+      };
+
+      socket.onclose = function(event) {
+        log('CLOSE: ' + event.code + ', ' + event.reason);
+      };
+    </script>
+
+  </body>
+</html>
+
@@ -0,0 +1,125 @@
+var Stream      = require('stream').Stream,
+    util        = require('util'),
+    driver      = require('websocket-driver'),
+    API         = require('./websocket/api'),
+    EventTarget = require('./websocket/api/event_target'),
+    Event       = require('./websocket/api/event');
+
+var EventSource = function(request, response, options) {
+  this.writable = true;
+  options = options || {};
+
+  this._stream = response.socket;
+  this._ping   = options.ping  || this.DEFAULT_PING;
+  this._retry  = options.retry || this.DEFAULT_RETRY;
+
+  var scheme       = driver.isSecureRequest(request) ? 'https:' : 'http:';
+  this.url         = scheme + '//' + request.headers.host + request.url;
+  this.lastEventId = request.headers['last-event-id'] || '';
+  this.readyState  = API.CONNECTING;
+
+  var self = this;
+
+  if (!this._stream || !this._stream.writable) return;
+  process.nextTick(function() { self._open() });
+
+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
+
+  var handshake = 'HTTP/1.1 200 OK\r\n' +
+                  'Content-Type: text/event-stream\r\n' +
+                  'Cache-Control: no-cache, no-store\r\n' +
+                  'Connection: close\r\n' +
+                  '\r\n\r\n' +
+                  'retry: ' + Math.floor(this._retry * 1000) + '\r\n\r\n';
+
+  this._write(handshake);
+
+  this._stream.on('drain', function() { self.emit('drain') });
+
+  if (this._ping)
+    this._pingTimer = setInterval(function() { self.ping() }, this._ping * 1000);
+
+  ['error', 'end'].forEach(function(event) {
+    self._stream.on(event, function() { self.close() });
+  });
+};
+util.inherits(EventSource, Stream);
+
+EventSource.isEventSource = function(request) {
+  if (request.method !== 'GET') return false;
+  var accept = (request.headers.accept || '').split(/\s*,\s*/);
+  return accept.indexOf('text/event-stream') >= 0;
+};
+
+var instance = {
+  DEFAULT_PING:   10,
+  DEFAULT_RETRY:  5,
+
+  _write: function(chunk) {
+    if (!this.writable) return false;
+    try {
+      return this._stream.write(chunk, 'utf8');
+    } catch (e) {
+      return false;
+    }
+  },
+
+  _open: function() {
+    if (this.readyState !== API.CONNECTING) return;
+
+    this.readyState = API.OPEN;
+
+    var event = new Event('open');
+    event.initEvent('open', false, false);
+    this.dispatchEvent(event);
+  },
+
+  write: function(message) {
+    return this.send(message);
+  },
+
+  end: function(message) {
+    if (message !== undefined) this.write(message);
+    this.close();
+  },
+
+  send: function(message, options) {
+    if (this.readyState > API.OPEN) return false;
+
+    message = String(message).replace(/(\r\n|\r|\n)/g, '$1data: ');
+    options = options || {};
+
+    var frame = '';
+    if (options.event) frame += 'event: ' + options.event + '\r\n';
+    if (options.id)    frame += 'id: '    + options.id    + '\r\n';
+    frame += 'data: ' + message + '\r\n\r\n';
+
+    return this._write(frame);
+  },
+
+  ping: function() {
+    return this._write(':\r\n\r\n');
+  },
+
+  close: function() {
+    if (this.readyState > API.OPEN) return false;
+
+    this.readyState = API.CLOSED;
+    this.writable = false;
+    if (this._pingTimer) clearInterval(this._pingTimer);
+    if (this._stream) this._stream.end();
+
+    var event = new Event('close');
+    event.initEvent('close', false, false);
+    this.dispatchEvent(event);
+
+    return true;
+  }
+};
+
+for (var method in instance) EventSource.prototype[method] = instance[method];
+for (var key in EventTarget) EventSource.prototype[key] = EventTarget[key];
+
+module.exports = EventSource;
+
@@ -0,0 +1,46 @@
+// API references:
+// 
+// * http://dev.w3.org/html5/websockets/
+// * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-eventtarget
+// * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-event
+
+var util   = require('util'),
+    driver = require('websocket-driver'),
+    API    = require('./websocket/api');
+
+var WebSocket = function(request, socket, body, protocols, options) {
+  this._stream  = socket;
+  this._ping    = options && options.ping;
+  this._pingId  = 0;
+  this._driver  = driver.http(request, {protocols: protocols});
+
+  var self = this;
+  if (!this._stream || !this._stream.writable) return;
+
+  var catchup = function() { self._stream.removeListener('data', catchup) };
+  this._stream.on('data', catchup);
+
+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
+
+  this._driver.io.write(body);
+  API.call(this);
+
+  ['error', 'end'].forEach(function(event) {
+    this._stream.on(event, function() { self._finalize('', 1006) });
+  }, this);
+
+  this._driver.start();
+};
+util.inherits(WebSocket, API);
+
+WebSocket.isWebSocket = function(request) {
+  return driver.isWebSocket(request);
+};
+
+WebSocket.WebSocket   = WebSocket;
+WebSocket.Client      = require('./websocket/client');
+WebSocket.EventSource = require('./eventsource');
+
+module.exports        = WebSocket;
+
@@ -0,0 +1,123 @@
+var Stream      = require('stream').Stream,
+    util        = require('util'),
+    EventTarget = require('./api/event_target'),
+    Event       = require('./api/event');
+
+var API = function() {
+  this.readable = this.writable = true;
+
+  this.readyState     = API.CONNECTING;
+  this.bufferedAmount = 0;
+  this.protocol       = '';
+  this.url            = this._driver.url;
+  this.version        = this._driver.version;
+
+  var self = this;
+
+  this._driver.on('open',    function(e) { self._open() });
+  this._driver.on('message', function(e) { self._receiveMessage(e.data) });
+  this._driver.on('close',   function(e) { self._finalize(e.reason, e.code) });
+
+  this._driver.on('error', function(error) {
+    var event = new Event('error', {message: error.message});
+    event.initEvent('error', false, false);
+    self.dispatchEvent(event);
+  });
+  this.on('error', function() {});
+
+  this._driver.messages.on('drain', function() {
+    self.emit('drain');
+  });
+
+  if (this._ping)
+    this._pingTimer = setInterval(function() {
+      self._pingId += 1;
+      self.ping(self._pingId.toString());
+    }, this._ping * 1000);
+
+  this._stream.pipe(this._driver.io);
+  this._driver.io.pipe(this._stream);
+};
+util.inherits(API, Stream);
+
+API.CONNECTING = 0;
+API.OPEN       = 1;
+API.CLOSING    = 2;
+API.CLOSED     = 3;
+
+var instance = {
+  write: function(data) {
+    return this.send(data);
+  },
+
+  end: function(data) {
+    if (data !== undefined) this.send(data);
+    this.close();
+  },
+
+  pause: function() {
+    return this._driver.messages.pause();
+  },
+
+  resume: function() {
+    return this._driver.messages.resume();
+  },
+
+  send: function(data) {
+    if (this.readyState > API.OPEN) return false;
+    if (!(data instanceof Buffer)) data = String(data);
+    return this._driver.messages.write(data);
+  },
+
+  ping: function(message, callback) {
+    if (this.readyState > API.OPEN) return false;
+    return this._driver.ping(message, callback);
+  },
+
+  close: function() {
+    if (this.readyState === API.OPEN) this.readyState = API.CLOSING;
+    this._driver.close();
+  },
+
+ _open: function() {
+    if (this.readyState !== API.CONNECTING) return;
+
+    this.readyState = API.OPEN;
+    this.protocol = this._driver.protocol || '';
+
+    var event = new Event('open');
+    event.initEvent('open', false, false);
+    this.dispatchEvent(event);
+  },
+
+  _receiveMessage: function(data) {
+    if (this.readyState > API.OPEN) return false;
+
+    if (this.readable) this.emit('data', data);
+
+    var event = new Event('message', {data: data});
+    event.initEvent('message', false, false);
+    this.dispatchEvent(event);
+  },
+
+  _finalize: function(reason, code) {
+    if (this.readyState === API.CLOSED) return;
+
+    if (this._pingTimer) clearInterval(this._pingTimer);
+    if (this._stream) this._stream.end();
+
+    if (this.readable) this.emit('end');
+    this.readable = this.writable = false;
+
+    this.readyState = API.CLOSED;
+    var event = new Event('close', {code: code || 1000, reason: reason || ''});
+    event.initEvent('close', false, false);
+    this.dispatchEvent(event);
+  }
+};
+
+for (var method in instance) API.prototype[method] = instance[method];
+for (var key in EventTarget) API.prototype[key] = EventTarget[key];
+
+module.exports = API;
+
@@ -0,0 +1,21 @@
+var Event = function(eventType, options) {
+  this.type = eventType;
+  for (var key in options)
+    this[key] = options[key];
+};
+
+Event.prototype.initEvent = function(eventType, canBubble, cancelable) {
+  this.type       = eventType;
+  this.bubbles    = canBubble;
+  this.cancelable = cancelable;
+};
+
+Event.prototype.stopPropagation = function() {};
+Event.prototype.preventDefault  = function() {};
+
+Event.CAPTURING_PHASE = 1;
+Event.AT_TARGET       = 2;
+Event.BUBBLING_PHASE  = 3;
+
+module.exports = Event;
+
@@ -0,0 +1,29 @@
+var Event = require('./event');
+
+var EventTarget = {
+  onopen:     null,
+  onmessage:  null,
+  onerror:    null,
+  onclose:    null,
+
+  addEventListener: function(eventType, listener, useCapture) {
+    this.on(eventType, listener);
+  },
+
+  removeEventListener: function(eventType, listener, useCapture) {
+    this.removeListener(eventType, listener);
+  },
+
+  dispatchEvent: function(event) {
+    event.target = event.currentTarget = this;
+    event.eventPhase = Event.AT_TARGET;
+
+    if (this['on' + event.type])
+      this['on' + event.type](event);
+
+    this.emit(event.type, event);
+  }
+};
+
+module.exports = EventTarget;
+
@@ -0,0 +1,40 @@
+var util   = require('util'),
+    net    = require('net'),
+    tls    = require('tls'),
+    driver = require('websocket-driver'),
+    API    = require('./api');
+
+var Client = function(url, protocols, options) {
+  this.url     = url;
+  this._uri    = require('url').parse(url);
+  this._ping   = options && options.ping;
+  this._pingId = 0;
+  this._driver = driver.client(url, {protocols: protocols});
+
+  var secure     = (this._uri.protocol === 'wss:'),
+      onConnect  = function() { self._driver.start() },
+      tlsOptions = {},
+      self       = this;
+
+  if (options && options.verify === false) tlsOptions.rejectUnauthorized = false;
+
+  var connection = secure
+                 ? tls.connect(this._uri.port || 443, this._uri.hostname, tlsOptions, onConnect)
+                 : net.createConnection(this._uri.port || 80, this._uri.hostname);
+
+  this._stream = connection;
+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
+
+  if (!secure) this._stream.on('connect', onConnect);
+
+  API.call(this);
+
+  ['error', 'end'].forEach(function(event) {
+    this._stream.on(event, function() { self._finalize('', 1006) });
+  }, this);
+};
+util.inherits(Client, API);
+
+module.exports = Client;
+
@@ -1,50 +0,0 @@
-'use strict';
-
-// Protocol references:
-// 
-// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
-// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
-// * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
-
-var Base   = require('./driver/base'),
-    Client = require('./driver/client'),
-    Server = require('./driver/server');
-
-var Driver = {
-  client: function(url, options) {
-    options = options || {};
-    if (options.masking === undefined) options.masking = true;
-    return new Client(url, options);
-  },
-
-  server: function(options) {
-    options = options || {};
-    if (options.requireMasking === undefined) options.requireMasking = true;
-    return new Server(options);
-  },
-
-  http: function() {
-    return Server.http.apply(Server, arguments);
-  },
-
-  isSecureRequest: function(request) {
-    return Server.isSecureRequest(request);
-  },
-
-  isWebSocket: function(request) {
-    if (request.method !== 'GET') return false;
-
-    var connection = request.headers.connection || '',
-        upgrade    = request.headers.upgrade || '';
-
-    return request.method === 'GET' &&
-           connection.toLowerCase().split(/ *, */).indexOf('upgrade') >= 0 &&
-           upgrade.toLowerCase() === 'websocket';
-  },
-
-  validateOptions: function(options, validKeys) {
-    Base.validateOptions(options, validKeys);
-  }
-};
-
-module.exports = Driver;
@@ -1,139 +0,0 @@
-'use strict';
-
-var Emitter = require('events').EventEmitter,
-    util    = require('util'),
-    streams = require('../streams'),
-    Headers = require('./headers');
-
-var Base = function(request, url, options) {
-  Emitter.call(this);
-  Base.validateOptions(options || {}, ['maxLength', 'masking', 'requireMasking', 'protocols']);
-
-  this._request   = request;
-  this._options   = options || {};
-  this._maxLength = this._options.maxLength || this.MAX_LENGTH;
-  this._headers   = new Headers();
-  this.__queue    = [];
-  this.readyState = 0;
-  this.url        = url;
-
-  this.io = new streams.IO(this);
-  this.messages = new streams.Messages(this);
-  this._bindEventListeners();
-};
-util.inherits(Base, Emitter);
-
-Base.validateOptions = function(options, validKeys) {
-  for (var key in options) {
-    if (validKeys.indexOf(key) < 0)
-      throw new Error('Unrecognized option: ' + key);
-  }
-};
-
-var instance = {
-  // This is 64MB, small enough for an average VPS to handle without
-  // crashing from process out of memory
-  MAX_LENGTH: 0x3ffffff,
-
-  STATES: ['connecting', 'open', 'closing', 'closed'],
-
-  _bindEventListeners: function() {
-    var self = this;
-
-    // Protocol errors are informational and do not have to be handled
-    this.messages.on('error', function() {});
-
-    this.on('message', function(event) {
-      var messages = self.messages;
-      if (messages.readable) messages.emit('data', event.data);
-    });
-
-    this.on('error', function(error) {
-      var messages = self.messages;
-      if (messages.readable) messages.emit('error', error);
-    });
-
-    this.on('close', function() {
-      var messages = self.messages;
-      if (!messages.readable) return;
-      messages.readable = messages.writable = false;
-      messages.emit('end');
-    });
-  },
-
-  getState: function() {
-    return this.STATES[this.readyState] || null;
-  },
-
-  addExtension: function(extension) {
-    return false;
-  },
-
-  setHeader: function(name, value) {
-    if (this.readyState > 0) return false;
-    this._headers.set(name, value);
-    return true;
-  },
-
-  start: function() {
-    if (this.readyState !== 0) return false;
-    this._write(this._handshakeResponse());
-    if (this._stage !== -1) this._open();
-    return true;
-  },
-
-  text: function(message) {
-    return this.frame(message);
-  },
-
-  binary: function(message) {
-    return false;
-  },
-
-  ping: function() {
-    return false;
-  },
-
-  close: function(reason, code) {
-    if (this.readyState !== 1) return false;
-    this.readyState = 3;
-    this.emit('close', new Base.CloseEvent(null, null));
-    return true;
-  },
-
-  _open: function() {
-    this.readyState = 1;
-    this.__queue.forEach(function(args) { this.frame.apply(this, args) }, this);
-    this.__queue = [];
-    this.emit('open', new Base.OpenEvent());
-  },
-
-  _queue: function(message) {
-    this.__queue.push(message);
-    return true;
-  },
-
-  _write: function(chunk) {
-    var io = this.io;
-    if (io.readable) io.emit('data', chunk);
-  }
-};
-
-for (var key in instance)
-  Base.prototype[key] = instance[key];
-
-
-Base.ConnectEvent = function() {};
-
-Base.OpenEvent = function() {};
-
-Base.CloseEvent = function(code, reason) {
-  this.code   = code;
-  this.reason = reason;
-};
-
-Base.MessageEvent = function(data) {
-  this.data = data;
-};
-
-module.exports = Base;
@@ -1,133 +0,0 @@
-'use strict';
-
-var crypto     = require('crypto'),
-    url        = require('url'),
-    util       = require('util'),
-    HttpParser = require('../http_parser'),
-    Base       = require('./base'),
-    Hybi       = require('./hybi'),
-    Proxy      = require('./proxy');
-
-var Client = function(_url, options) {
-  this.version = 'hybi-13';
-  Hybi.call(this, null, _url, options);
-
-  this.readyState = -1;
-  this._key       = Client.generateKey();
-  this._accept    = Hybi.generateAccept(this._key);
-  this._http      = new HttpParser('response');
-
-  var uri  = url.parse(this.url),
-      auth = uri.auth && new Buffer(uri.auth, 'utf8').toString('base64');
-
-  this._pathname = (uri.pathname || '/') + (uri.search || '');
-
-  this._headers.set('Host', uri.host);
-  this._headers.set('Upgrade', 'websocket');
-  this._headers.set('Connection', 'Upgrade');
-  this._headers.set('Sec-WebSocket-Key', this._key);
-  this._headers.set('Sec-WebSocket-Version', '13');
-
-  if (this._protocols.length > 0)
-    this._headers.set('Sec-WebSocket-Protocol', this._protocols.join(', '));
-
-  if (auth)
-    this._headers.set('Authorization', 'Basic ' + auth);
-};
-util.inherits(Client, Hybi);
-
-Client.generateKey = function() {
-  return crypto.randomBytes(16).toString('base64');
-};
-
-var instance = {
-  proxy: function(origin, options) {
-    return new Proxy(this, origin, options);
-  },
-
-  start: function() {
-    if (this.readyState !== -1) return false;
-    this._write(this._handshakeRequest());
-    this.readyState = 0;
-    return true;
-  },
-
-  parse: function(data) {
-    if (this.readyState === 3) return;
-    if (this.readyState > 0) return Hybi.prototype.parse.call(this, data);
-
-    this._http.parse(data);
-    if (!this._http.isComplete()) return;
-
-    this._validateHandshake();
-    if (this.readyState === 3) return;
-
-    this._open();
-    this.parse(this._http.body);
-  },
-
-  _handshakeRequest: function() {
-    var extensions = this._extensions.generateOffer();
-    if (extensions)
-      this._headers.set('Sec-WebSocket-Extensions', extensions);
-
-    var start   = 'GET ' + this._pathname + ' HTTP/1.1',
-        headers = [start, this._headers.toString(), ''];
-
-    return new Buffer(headers.join('\r\n'), 'utf8');
-  },
-
-  _failHandshake: function(message) {
-    message = 'Error during WebSocket handshake: ' + message;
-    this.emit('error', new Error(message));
-    this.readyState = 3;
-    this.emit('close', new Base.CloseEvent(this.ERRORS.protocol_error, message));
-  },
-
-  _validateHandshake: function() {
-    this.statusCode = this._http.statusCode;
-    this.headers    = this._http.headers;
-
-    if (this._http.statusCode !== 101)
-      return this._failHandshake('Unexpected response code: ' + this._http.statusCode);
-
-    var headers    = this._http.headers,
-        upgrade    = headers['upgrade'] || '',
-        connection = headers['connection'] || '',
-        accept     = headers['sec-websocket-accept'] || '',
-        protocol   = headers['sec-websocket-protocol'] || '';
-
-    if (upgrade === '')
-      return this._failHandshake("'Upgrade' header is missing");
-    if (upgrade.toLowerCase() !== 'websocket')
-      return this._failHandshake("'Upgrade' header value is not 'WebSocket'");
-
-    if (connection === '')
-      return this._failHandshake("'Connection' header is missing");
-    if (connection.toLowerCase() !== 'upgrade')
-      return this._failHandshake("'Connection' header value is not 'Upgrade'");
-
-    if (accept !== this._accept)
-      return this._failHandshake('Sec-WebSocket-Accept mismatch');
-
-    this.protocol = null;
-
-    if (protocol !== '') {
-      if (this._protocols.indexOf(protocol) < 0)
-        return this._failHandshake('Sec-WebSocket-Protocol mismatch');
-      else
-        this.protocol = protocol;
-    }
-
-    try {
-      this._extensions.activate(this.headers['sec-websocket-extensions']);
-    } catch (e) {
-      return this._failHandshake(e.message);
-    }
-  }
-};
-
-for (var key in instance)
-  Client.prototype[key] = instance[key];
-
-module.exports = Client;
@@ -1,120 +0,0 @@
-'use strict';
-
-var Base = require('./base'),
-    util = require('util');
-
-var Draft75 = function(request, url, options) {
-  Base.apply(this, arguments);
-  this._stage = 0;
-  this.version = 'hixie-75';
-
-  this._headers.set('Upgrade', 'WebSocket');
-  this._headers.set('Connection', 'Upgrade');
-  this._headers.set('WebSocket-Origin', this._request.headers.origin);
-  this._headers.set('WebSocket-Location', this.url);
-};
-util.inherits(Draft75, Base);
-
-var instance = {
-  close: function() {
-    if (this.readyState === 3) return false;
-    this.readyState = 3;
-    this.emit('close', new Base.CloseEvent(null, null));
-    return true;
-  },
-
-  parse: function(buffer) {
-    if (this.readyState > 1) return;
-
-    var data, message, value;
-    for (var i = 0, n = buffer.length; i < n; i++) {
-      data = buffer[i];
-
-      switch (this._stage) {
-        case -1:
-          this._body.push(data);
-          this._sendHandshakeBody();
-          break;
-
-        case 0:
-          this._parseLeadingByte(data);
-          break;
-
-        case 1:
-          value = (data & 0x7F);
-          this._length = value + 128 * this._length;
-
-          if (this._closing && this._length === 0) {
-            return this.close();
-          }
-          else if ((0x80 & data) !== 0x80) {
-            if (this._length === 0) {
-              this._stage = 0;
-            }
-            else {
-              this._skipped = 0;
-              this._stage = 2;
-            }
-          }
-          break;
-
-        case 2:
-          if (data === 0xFF) {
-            message = new Buffer(this._buffer).toString('utf8', 0, this._buffer.length);
-            this.emit('message', new Base.MessageEvent(message));
-            this._stage = 0;
-          }
-          else {
-            if (this._length) {
-              this._skipped += 1;
-              if (this._skipped === this._length)
-                this._stage = 0;
-            } else {
-              this._buffer.push(data);
-              if (this._buffer.length > this._maxLength) return this.close();
-            }
-          }
-          break;
-      }
-    }
-  },
-
-  frame: function(data) {
-    if (this.readyState === 0) return this._queue([data]);
-    if (this.readyState > 1) return false;
-
-    var buffer = new Buffer(data, 'utf8'),
-        frame  = new Buffer(buffer.length + 2);
-
-    frame[0] = 0x00;
-    frame[buffer.length + 1] = 0xFF;
-    buffer.copy(frame, 1);
-
-    this._write(frame);
-    return true;
-  },
-
-  _handshakeResponse: function() {
-    var start   = 'HTTP/1.1 101 Web Socket Protocol Handshake',
-        headers = [start, this._headers.toString(), ''];
-
-    return new Buffer(headers.join('\r\n'), 'utf8');
-  },
-
-  _parseLeadingByte: function(data) {
-    if ((0x80 & data) === 0x80) {
-      this._length = 0;
-      this._stage = 1;
-    } else {
-      delete this._length;
-      delete this._skipped;
-      this._buffer = [];
-      this._stage = 2;
-    }
-  }
-};
-
-for (var key in instance)
-  Draft75.prototype[key] = instance[key];
-
-module.exports = Draft75;
@@ -1,110 +0,0 @@
-'use strict';
-
-var Base    = require('./base'),
-    Draft75 = require('./draft75'),
-    crypto  = require('crypto'),
-    util    = require('util');
-
-
-var numberFromKey = function(key) {
-  return parseInt(key.match(/[0-9]/g).join(''), 10);
-};
-
-var spacesInKey = function(key) {
-  return key.match(/ /g).length;
-};
-
-var bigEndian = function(number) {
-  var string = '';
-  [24, 16, 8, 0].forEach(function(offset) {
-    string += String.fromCharCode(number >> offset & 0xFF);
-  });
-  return string;
-};
-
-
-var Draft76 = function(request, url, options) {
-  Draft75.apply(this, arguments);
-  this._stage  = -1;
-  this._body   = [];
-  this.version = 'hixie-76';
-
-  this._headers.clear();
-
-  this._headers.set('Upgrade', 'WebSocket');
-  this._headers.set('Connection', 'Upgrade');
-  this._headers.set('Sec-WebSocket-Origin', this._request.headers.origin);
-  this._headers.set('Sec-WebSocket-Location', this.url);
-};
-util.inherits(Draft76, Draft75);
-
-var instance = {
-  BODY_SIZE: 8,
-
-  start: function() {
-    if (!Draft75.prototype.start.call(this)) return false;
-    this._started = true;
-    this._sendHandshakeBody();
-    return true;
-  },
-
-  close: function() {
-    if (this.readyState === 3) return false;
-    this._write(new Buffer([0xFF, 0x00]));
-    this.readyState = 3;
-    this.emit('close', new Base.CloseEvent(null, null));
-    return true;
-  },
-
-  _handshakeResponse: function() {
-    var start   = 'HTTP/1.1 101 WebSocket Protocol Handshake',
-        headers = [start, this._headers.toString(), ''];
-
-    return new Buffer(headers.join('\r\n'), 'binary');
-  },
-
-  _handshakeSignature: function() {
-    if (this._body.length < this.BODY_SIZE) return null;
-    var body = new Buffer(this._body.slice(0, this.BODY_SIZE));
-
-    var headers = this._request.headers,
-        key1    = headers['sec-websocket-key1'],
-        value1  = numberFromKey(key1) / spacesInKey(key1),
-        key2    = headers['sec-websocket-key2'],
-        value2  = numberFromKey(key2) / spacesInKey(key2),
-        md5     = crypto.createHash('md5');
-
-    md5.update(bigEndian(value1));
-    md5.update(bigEndian(value2));
-    md5.update(body.toString('binary'));
-
-    return new Buffer(md5.digest('binary'), 'binary');
-  },
-
-  _sendHandshakeBody: function() {
-    if (!this._started) return;
-    var signature = this._handshakeSignature();
-    if (!signature) return;
-
-    this._write(signature);
-    this._stage = 0;
-    this._open();
-
-    if (this._body.length > this.BODY_SIZE)
-      this.parse(this._body.slice(this.BODY_SIZE));
-  },
-
-  _parseLeadingByte: function(data) {
-    if (data !== 0xFF)
-      return Draft75.prototype._parseLeadingByte.call(this, data);
-
-    this._closing = true;
-    this._length  = 0;
-    this._stage   = 1;
-  }
-};
-
-for (var key in instance)
-  Draft76.prototype[key] = instance[key];
-
-module.exports = Draft76;
@@ -1,35 +0,0 @@
-'use strict';
-
-var Headers = function() {
-  this.clear();
-};
-
-Headers.prototype.ALLOWED_DUPLICATES = ['set-cookie', 'set-cookie2', 'warning', 'www-authenticate'];
-
-Headers.prototype.clear = function() {
-  this._sent  = {};
-  this._lines = [];
-};
-
-Headers.prototype.set = function(name, value) {
-  if (value === undefined) return;
-
-  name = this._strip(name);
-  value = this._strip(value);
-
-  var key = name.toLowerCase();
-  if (!this._sent.hasOwnProperty(key) || this.ALLOWED_DUPLICATES.indexOf(key) >= 0) {
-    this._sent[key] = true;
-    this._lines.push(name + ': ' + value + '\r\n');
-  }
-};
-
-Headers.prototype.toString = function() {
-  return this._lines.join('');
-};
-
-Headers.prototype._strip = function(string) {
-  return string.toString().replace(/^ */, '').replace(/ *$/, '');
-};
-
-module.exports = Headers;
@@ -1,474 +0,0 @@
-'use strict';
-
-var crypto     = require('crypto'),
-    util       = require('util'),
-    Extensions = require('websocket-extensions'),
-    Base       = require('./base'),
-    Frame      = require('./hybi/frame'),
-    Message    = require('./hybi/message'),
-    Reader     = require('./hybi/stream_reader');
-
-var Hybi = function(request, url, options) {
-  Base.apply(this, arguments);
-
-  this._extensions     = new Extensions();
-  this._reader         = new Reader();
-  this._stage          = 0;
-  this._masking        = this._options.masking;
-  this._protocols      = this._options.protocols || [];
-  this._requireMasking = this._options.requireMasking;
-  this._pingCallbacks  = {};
-
-  if (typeof this._protocols === 'string')
-    this._protocols = this._protocols.split(/ *, */);
-
-  if (!this._request) return;
-
-  var secKey    = this._request.headers['sec-websocket-key'],
-      protos    = this._request.headers['sec-websocket-protocol'],
-      version   = this._request.headers['sec-websocket-version'],
-      supported = this._protocols;
-
-  this._headers.set('Upgrade', 'websocket');
-  this._headers.set('Connection', 'Upgrade');
-  this._headers.set('Sec-WebSocket-Accept', Hybi.generateAccept(secKey));
-
-  if (protos !== undefined) {
-    if (typeof protos === 'string') protos = protos.split(/ *, */);
-    this.protocol = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
-    if (this.protocol) this._headers.set('Sec-WebSocket-Protocol', this.protocol);
-  }
-
-  this.version = 'hybi-' + version;
-};
-util.inherits(Hybi, Base);
-
-Hybi.mask = function(payload, mask, offset) {
-  if (!mask || mask.length === 0) return payload;
-  offset = offset || 0;
-
-  for (var i = 0, n = payload.length - offset; i < n; i++) {
-    payload[offset + i] = payload[offset + i] ^ mask[i % 4];
-  }
-  return payload;
-};
-
-Hybi.generateAccept = function(key) {
-  var sha1 = crypto.createHash('sha1');
-  sha1.update(key + Hybi.GUID);
-  return sha1.digest('base64');
-};
-
-Hybi.GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
-
-var instance = {
-  BYTE:   255,
-  FIN:    128,
-  MASK:   128,
-  RSV1:   64,
-  RSV2:   32,
-  RSV3:   16,
-  OPCODE: 15,
-  LENGTH: 127,
-
-  OPCODES: {
-    continuation: 0,
-    text:         1,
-    binary:       2,
-    close:        8,
-    ping:         9,
-    pong:         10
-  },
-
-  OPCODE_CODES:    [0, 1, 2, 8, 9, 10],
-  MESSAGE_OPCODES: [0, 1, 2],
-  OPENING_OPCODES: [1, 2],
-
-  TWO_POWERS: [0, 1, 2, 3, 4, 5, 6, 7].map(function(n) { return Math.pow(2, 8 * n) }),
-
-  ERRORS: {
-    normal_closure:       1000,
-    going_away:           1001,
-    protocol_error:       1002,
-    unacceptable:         1003,
-    encoding_error:       1007,
-    policy_violation:     1008,
-    too_large:            1009,
-    extension_error:      1010,
-    unexpected_condition: 1011
-  },
-
-  ERROR_CODES:        [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011],
-  MIN_RESERVED_ERROR: 3000,
-  MAX_RESERVED_ERROR: 4999,
-
-  // 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})*$/,
-
-  addExtension: function(extension) {
-    this._extensions.add(extension);
-    return true;
-  },
-
-  parse: function(data) {
-    this._reader.put(data);
-    var buffer = true;
-    while (buffer) {
-      switch (this._stage) {
-        case 0:
-          buffer = this._reader.read(1);
-          if (buffer) this._parseOpcode(buffer[0]);
-          break;
-
-        case 1:
-          buffer = this._reader.read(1);
-          if (buffer) this._parseLength(buffer[0]);
-          break;
-
-        case 2:
-          buffer = this._reader.read(this._frame.lengthBytes);
-          if (buffer) this._parseExtendedLength(buffer);
-          break;
-
-        case 3:
-          buffer = this._reader.read(4);
-          if (buffer) {
-            this._frame.maskingKey = buffer;
-            this._stage = 4;
-          }
-          break;
-
-        case 4:
-          buffer = this._reader.read(this._frame.length);
-          if (buffer) {
-            this._emitFrame(buffer);
-            this._stage = 0;
-          }
-          break;
-
-        default:
-          buffer = null;
-      }
-    }
-  },
-
-  text: function(message) {
-    if (this.readyState > 1) return false;
-    return this.frame(message, 'text');
-  },
-
-  binary: function(message) {
-    if (this.readyState > 1) return false;
-    return this.frame(message, 'binary');
-  },
-
-  ping: function(message, callback) {
-    if (this.readyState > 1) return false;
-    message = message || '';
-    if (callback) this._pingCallbacks[message] = callback;
-    return this.frame(message, 'ping');
-  },
-
-  close: function(reason, code) {
-    reason = reason || '';
-    code   = code   || this.ERRORS.normal_closure;
-
-    if (this.readyState <= 0) {
-      this.readyState = 3;
-      this.emit('close', new Base.CloseEvent(code, reason));
-      return true;
-    } else if (this.readyState === 1) {
-      this.readyState = 2;
-      this._extensions.close(function() { this.frame(reason, 'close', code) }, this);
-      return true;
-    } else {
-      return false;
-    }
-  },
-
-  frame: function(data, type, code) {
-    if (this.readyState <= 0) return this._queue([data, type, code]);
-    if (this.readyState > 2) return false;
-
-    if (data instanceof Array) data = new Buffer(data);
-
-    var message = new Message(),
-        isText  = (typeof data === 'string'),
-        payload, buffer;
-
-    message.rsv1   = message.rsv2 = message.rsv3 = false;
-    message.opcode = this.OPCODES[type || (isText ? 'text' : 'binary')];
-
-    payload = isText ? new Buffer(data, 'utf8') : data;
-
-    if (code) {
-      buffer = payload;
-      payload = new Buffer(2 + buffer.length);
-      payload[0] = ~~(code / 256) & this.BYTE;
-      payload[1] = code & this.BYTE;
-      buffer.copy(payload, 2);
-    }
-    message.data = payload;
-
-    var onMessageReady = function(message) {
-      var frame = new Frame();
-
-      frame.final   = true;
-      frame.rsv1    = message.rsv1;
-      frame.rsv2    = message.rsv2;
-      frame.rsv3    = message.rsv3;
-      frame.opcode  = message.opcode;
-      frame.masked  = !!this._masking;
-      frame.length  = message.data.length;
-      frame.payload = message.data;
-
-      if (frame.masked) frame.maskingKey = crypto.randomBytes(4);
-
-      this._sendFrame(frame);
-    };
-
-    if (this.MESSAGE_OPCODES.indexOf(message.opcode) >= 0)
-      this._extensions.processOutgoingMessage(message, function(error, message) {
-        if (error) return this._fail('extension_error', error.message);
-        onMessageReady.call(this, message);
-      }, this);
-    else
-      onMessageReady.call(this, message);
-
-    return true;
-  },
-
-  _sendFrame: function(frame) {
-    var length = frame.length,
-        header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
-        offset = header + (frame.masked ? 4 : 0),
-        buffer = new Buffer(offset + length),
-        BYTE   = this.BYTE,
-        masked = frame.masked ? this.MASK : 0;
-
-    buffer[0] = (frame.final ? this.FIN : 0) |
-                (frame.rsv1 ? this.RSV1 : 0) |
-                (frame.rsv2 ? this.RSV2 : 0) |
-                (frame.rsv3 ? this.RSV3 : 0) |
-                frame.opcode;
-
-    if (length <= 125) {
-      buffer[1] = masked | length;
-    } else if (length <= 65535) {
-      buffer[1] = masked | 126;
-      buffer[2] = ~~(length / 256);
-      buffer[3] = length & BYTE;
-    } else {
-      buffer[1] = masked | 127;
-      buffer[2] = ~~(length / Math.pow(2, 56)) & BYTE;
-      buffer[3] = ~~(length / Math.pow(2, 48)) & BYTE;
-      buffer[4] = ~~(length / Math.pow(2, 40)) & BYTE;
-      buffer[5] = ~~(length / Math.pow(2, 32)) & BYTE;
-      buffer[6] = ~~(length / Math.pow(2, 24)) & BYTE;
-      buffer[7] = ~~(length / Math.pow(2, 16)) & BYTE;
-      buffer[8] = ~~(length / Math.pow(2, 8))  & BYTE;
-      buffer[9] = length & BYTE;
-    }
-
-    if (frame.masked) {
-      frame.maskingKey.copy(buffer, header);
-      Hybi.mask(frame.payload, frame.maskingKey).copy(buffer, offset);
-    } else {
-      frame.payload.copy(buffer, offset);
-    }
-
-    this._write(buffer);
-  },
-
-  _handshakeResponse: function() {
-    var extensions = this._extensions.generateResponse(this._request.headers['sec-websocket-extensions']);
-    if (extensions) this._headers.set('Sec-WebSocket-Extensions', extensions);
-
-    var start   = 'HTTP/1.1 101 Switching Protocols',
-        headers = [start, this._headers.toString(), ''];
-
-    return new Buffer(headers.join('\r\n'), 'utf8');
-  },
-
-  _shutdown: function(code, reason) {
-    delete this._frame;
-    delete this._message;
-    this.readyState = 2;
-    this._stage = 5;
-
-    this._extensions.close(function() {
-      this.frame(reason, 'close', code);
-      this.readyState = 3;
-      this.emit('close', new Base.CloseEvent(code, reason));
-    }, this);
-  },
-
-  _fail: function(type, message) {
-    if (this.readyState > 1) return;
-    this.emit('error', new Error(message));
-    this._shutdown(this.ERRORS[type], message);
-  },
-
-  _parseOpcode: function(data) {
-    var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) {
-      return (data & rsv) === rsv;
-    });
-
-    var frame = this._frame = new Frame();
-
-    frame.final  = (data & this.FIN) === this.FIN;
-    frame.rsv1   = rsvs[0];
-    frame.rsv2   = rsvs[1];
-    frame.rsv3   = rsvs[2];
-    frame.opcode = (data & this.OPCODE);
-
-    if (!this._extensions.validFrameRsv(frame))
-      return this._fail('protocol_error',
-          'One or more reserved bits are on: reserved1 = ' + (frame.rsv1 ? 1 : 0) +
-          ', reserved2 = ' + (frame.rsv2 ? 1 : 0) +
-          ', reserved3 = ' + (frame.rsv3 ? 1 : 0));
-
-    if (this.OPCODE_CODES.indexOf(frame.opcode) < 0)
-      return this._fail('protocol_error', 'Unrecognized frame opcode: ' + frame.opcode);
-
-    if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && !frame.final)
-      return this._fail('protocol_error', 'Received fragmented control frame: opcode = ' + frame.opcode);
-
-    if (this._message && this.OPENING_OPCODES.indexOf(frame.opcode) >= 0)
-      return this._fail('protocol_error', 'Received new data frame but previous continuous frame is unfinished');
-
-    this._stage = 1;
-  },
-
-  _parseLength: function(data) {
-    var frame = this._frame;
-
-    frame.masked = (data & this.MASK) === this.MASK;
-    if (this._requireMasking && !frame.masked)
-      return this._fail('unacceptable', 'Received unmasked frame but masking is required');
-
-    frame.length = (data & this.LENGTH);
-
-    if (frame.length >= 0 && frame.length <= 125) {
-      if (!this._checkFrameLength()) return;
-      this._stage = frame.masked ? 3 : 4;
-    } else {
-      frame.lengthBytes = (frame.length === 126 ? 2 : 8);
-      this._stage = 2;
-    }
-  },
-
-  _parseExtendedLength: function(buffer) {
-    var frame = this._frame;
-    frame.length = this._getInteger(buffer);
-
-    if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && frame.length > 125)
-      return this._fail('protocol_error', 'Received control frame having too long payload: ' + frame.length);
-
-    if (!this._checkFrameLength()) return;
-
-    this._stage  = frame.masked ? 3 : 4;
-  },
-
-  _checkFrameLength: function() {
-    var length = this._message ? this._message.length : 0;
-
-    if (length + this._frame.length > this._maxLength) {
-      this._fail('too_large', 'WebSocket frame length too large');
-      return false;
-    } else {
-      return true;
-    }
-  },
-
-  _emitFrame: function(buffer) {
-    var frame   = this._frame,
-        payload = frame.payload = Hybi.mask(buffer, frame.maskingKey),
-        opcode  = frame.opcode,
-        message,
-        code, reason,
-        callbacks, callback;
-
-    delete this._frame;
-
-    if (opcode === this.OPCODES.continuation) {
-      if (!this._message) return this._fail('protocol_error', 'Received unexpected continuation frame');
-      this._message.pushFrame(frame);
-    }
-
-    if (opcode === this.OPCODES.text || opcode === this.OPCODES.binary) {
-      this._message = new Message();
-      this._message.pushFrame(frame);
-    }
-
-    if (frame.final && this.MESSAGE_OPCODES.indexOf(opcode) >= 0)
-      return this._emitMessage(this._message);
-
-    if (opcode === this.OPCODES.close) {
-      code   = (payload.length >= 2) ? 256 * payload[0] + payload[1] : null;
-      reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
-
-      if (!(payload.length === 0) &&
-          !(code !== null && code >= this.MIN_RESERVED_ERROR && code <= this.MAX_RESERVED_ERROR) &&
-          this.ERROR_CODES.indexOf(code) < 0)
-        code = this.ERRORS.protocol_error;
-
-      if (payload.length > 125 || (payload.length > 2 && !reason))
-        code = this.ERRORS.protocol_error;
-
-      this._shutdown(code, reason || '');
-    }
-
-    if (opcode === this.OPCODES.ping) {
-      this.frame(payload, 'pong');
-    }
-
-    if (opcode === this.OPCODES.pong) {
-      callbacks = this._pingCallbacks;
-      message   = this._encode(payload);
-      callback  = callbacks[message];
-
-      delete callbacks[message];
-      if (callback) callback()
-    }
-  },
-
-  _emitMessage: function(message) {
-    var message = this._message;
-    message.read();
-
-    delete this._message;
-
-    this._extensions.processIncomingMessage(message, function(error, message) {
-      if (error) return this._fail('extension_error', error.message);
-
-      var payload = message.data;
-      if (message.opcode === this.OPCODES.text) payload = this._encode(payload);
-
-      if (payload === null)
-        return this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
-      else
-        this.emit('message', new Base.MessageEvent(payload));
-    }, this);
-  },
-
-  _encode: function(buffer) {
-    try {
-      var string = buffer.toString('binary', 0, buffer.length);
-      if (!this.UTF8_MATCH.test(string)) return null;
-    } catch (e) {}
-    return buffer.toString('utf8', 0, buffer.length);
-  },
-
-  _getInteger: function(bytes) {
-    var number = 0;
-    for (var i = 0, n = bytes.length; i < n; i++)
-      number += bytes[i] * this.TWO_POWERS[n - 1 - i];
-    return number;
-  }
-};
-
-for (var key in instance)
-  Hybi.prototype[key] = instance[key];
-
-module.exports = Hybi;
@@ -1,21 +0,0 @@
-'use strict';
-
-var Frame = function() {};
-
-var instance = {
-  final:        false,
-  rsv1:         false,
-  rsv2:         false,
-  rsv3:         false,
-  opcode:       null,
-  masked:       false,
-  maskingKey:   null,
-  lengthBytes:  1,
-  length:       0,
-  payload:      null
-};
-
-for (var key in instance)
-  Frame.prototype[key] = instance[key];
-
-module.exports = Frame;
@@ -1,41 +0,0 @@
-'use strict';
-
-var Message = function() {
-  this.rsv1    = false;
-  this.rsv2    = false;
-  this.rsv3    = false;
-  this.opcode  = null
-  this.length  = 0;
-  this._chunks = [];
-};
-
-var instance = {
-  read: function() {
-    if (this.data) return this.data;
-
-    this.data  = new Buffer(this.length);
-    var offset = 0;
-
-    for (var i = 0, n = this._chunks.length; i < n; i++) {
-      this._chunks[i].copy(this.data, offset);
-      offset += this._chunks[i].length;
-    }
-    return this.data;
-  },
-
-  pushFrame: function(frame) {
-    this.rsv1 = this.rsv1 || frame.rsv1;
-    this.rsv2 = this.rsv2 || frame.rsv2;
-    this.rsv3 = this.rsv3 || frame.rsv3;
-
-    if (this.opcode === null) this.opcode = frame.opcode;
-
-    this._chunks.push(frame.payload);
-    this.length += frame.length;
-  }
-};
-
-for (var key in instance)
-  Message.prototype[key] = instance[key];
-
-module.exports = Message;
@@ -1,63 +0,0 @@
-'use strict';
-
-var StreamReader = function() {
-  this._queue     = [];
-  this._queueSize = 0;
-};
-
-StreamReader.prototype.put = function(buffer) {
-  if (!buffer || buffer.length === 0) return;
-  if (!buffer.copy) buffer = new Buffer(buffer);
-  this._queue.push(buffer);
-  this._queueSize += buffer.length;
-};
-
-StreamReader.prototype.read = function(length) {
-  if (length > this._queueSize) return null;
-  if (length === 0) return new Buffer(0);
-  
-  var queue = this._queue,
-      first = queue[0],
-      buffer;
-  
-  if (first.length >= length) {
-    this._queueSize -= length;
-    if (first.length === length) {
-      return queue.shift();
-    } else {
-      buffer = first.slice(0, length);
-      queue[0] = first.slice(length);
-      return buffer;
-    }
-  }
-  
-  var remain = length, buffers;
-
-  for (var i=0, n = queue.length; i < n; i++) {
-    if (remain < queue[i].length) break;
-    remain -= queue[i].length;
-  }
-  buffers = queue.splice(0, i);
-
-  if (remain > 0 && queue.length > 0) {
-    buffers.push(queue[0].slice(0, remain));
-    queue[0] = queue[0].slice(remain);
-  }
-  this._queueSize -= length;
-  return this._concat(buffers, length);
-};
-
-StreamReader.prototype._concat = function(buffers, length) {
-  if (Buffer.concat) return Buffer.concat(buffers, length);
-
-  var buffer = new Buffer(length),
-      offset = 0;
-
-  for (var i = 0, n = buffers.length; i < n; i++) {
-    buffers[i].copy(buffer, offset);
-    offset += buffers[i].length;
-  }
-  return buffer;
-};
-
-module.exports = StreamReader;
@@ -1,97 +0,0 @@
-'use strict';
-
-var Stream     = require('stream').Stream,
-    url        = require('url'),
-    util       = require('util'),
-    Headers    = require('./headers'),
-    HttpParser = require('../http_parser');
-
-var PORTS = {'ws:': 80, 'wss:': 443};
-
-var Proxy = function(client, origin, options) {
-  this._client  = client;
-  this._http    = new HttpParser('response');
-  this._origin  = (typeof client.url === 'object') ? client.url : url.parse(client.url);
-  this._url     = (typeof origin === 'object') ? origin : url.parse(origin);
-  this._options = options || {};
-  this._state   = 0;
-
-  this.readable = this.writable = true;
-  this._paused  = false;
-
-  this._headers = new Headers();
-  this._headers.set('Host', this._origin.host);
-  this._headers.set('Connection', 'keep-alive');
-  this._headers.set('Proxy-Connection', 'keep-alive');
-
-  var auth = this._url.auth && new Buffer(this._url.auth, 'utf8').toString('base64');
-  if (auth) this._headers.set('Proxy-Authorization', 'Basic ' + auth);
-};
-util.inherits(Proxy, Stream);
-
-var instance = {
-  setHeader: function(name, value) {
-    if (this._state !== 0) return false;
-    this._headers.set(name, value);
-    return true;
-  },
-
-  start: function() {
-    if (this._state !== 0) return false;
-    this._state = 1;
-
-    var origin = this._origin,
-        port   = origin.port || PORTS[origin.protocol],
-        start  = 'CONNECT ' + origin.hostname + ':' + port + ' HTTP/1.1';
-
-    var headers = [start, this._headers.toString(), ''];
-
-    this.emit('data', new Buffer(headers.join('\r\n'), 'utf8'));
-    return true;
-  },
-
-  pause: function() {
-    this._paused = true;
-  },
-
-  resume: function() {
-    this._paused = false;
-    this.emit('drain');
-  },
-
-  write: function(chunk) {
-    if (!this.writable) return false;
-
-    this._http.parse(chunk);
-    if (!this._http.isComplete()) return !this._paused;
-
-    this.statusCode = this._http.statusCode;
-    this.headers    = this._http.headers;
-
-    if (this.statusCode === 200) {
-      this.emit('connect');
-    } else {
-      var message = "Can't establish a connection to the server at " + this._origin.href;
-      this.emit('error', new Error(message));
-    }
-    this.end();
-    return !this._paused;
-  },
-
-  end: function(chunk) {
-    if (!this.writable) return;
-    if (chunk !== undefined) this.write(chunk);
-    this.readable = this.writable = false;
-    this.emit('close');
-    this.emit('end');
-  },
-
-  destroy: function() {
-    this.end();
-  }
-};
-
-for (var key in instance)
-  Proxy.prototype[key] = instance[key];
-
-module.exports = Proxy;
@@ -1,108 +0,0 @@
-'use strict';
-
-var util       = require('util'),
-    HttpParser = require('../http_parser'),
-    Base       = require('./base'),
-    Draft75    = require('./draft75'),
-    Draft76    = require('./draft76'),
-    Hybi       = require('./hybi');
-
-var Server = function(options) {
-  Base.call(this, null, null, options);
-  this._http = new HttpParser('request');
-};
-util.inherits(Server, Base);
-
-var instance = {
-  EVENTS: ['open', 'message', 'error', 'close'],
-
-  _bindEventListeners: function() {
-    this.messages.on('error', function() {});
-    this.on('error', function() {});
-  },
-
-  parse: function(data) {
-    if (this._delegate) return this._delegate.parse(data);
-
-    this._http.parse(data);
-    if (!this._http.isComplete()) return;
-
-    this.method  = this._http.method;
-    this.url     = this._http.url;
-    this.headers = this._http.headers;
-    this.body    = this._http.body;
-
-    var self = this;
-    this._delegate = Server.http(this, this._options);
-    this._delegate.messages = this.messages;
-    this._delegate.io = this.io;
-    this._open();
-
-    this.EVENTS.forEach(function(event) {
-      this._delegate.on(event, function(e) { self.emit(event, e) });
-    }, this);
-
-    this.protocol = this._delegate.protocol;
-    this.version  = this._delegate.version;
-
-    this.parse(this._http.body);
-    this.emit('connect', new Base.ConnectEvent());
-  },
-
-  _open: function() {
-    this.__queue.forEach(function(msg) {
-      this._delegate[msg[0]].apply(this._delegate, msg[1]);
-    }, this);
-    this.__queue = [];
-  }
-};
-
-['addExtension', 'setHeader', 'start', 'frame', 'text', 'binary', 'ping', 'close'].forEach(function(method) {
-  instance[method] = function() {
-    if (this._delegate) {
-      return this._delegate[method].apply(this._delegate, arguments);
-    } else {
-      this.__queue.push([method, arguments]);
-      return true;
-    }
-  };
-});
-
-for (var key in instance)
-  Server.prototype[key] = instance[key];
-
-Server.isSecureRequest = function(request) {
-  if (request.connection && request.connection.authorized !== undefined) return true;
-  if (request.socket && request.socket.secure) return true;
-
-  var headers = request.headers;
-  if (!headers) return false;
-  if (headers['https'] === 'on') return true;
-  if (headers['x-forwarded-ssl'] === 'on') return true;
-  if (headers['x-forwarded-scheme'] === 'https') return true;
-  if (headers['x-forwarded-proto'] === 'https') return true;
-
-  return false;
-};
-
-Server.determineUrl = function(request) {
-  var scheme = this.isSecureRequest(request) ? 'wss:' : 'ws:';
-  return scheme + '//' + request.headers.host + request.url;
-};
-
-Server.http = function(request, options) {
-  options = options || {};
-  if (options.requireMasking === undefined) options.requireMasking = true;
-
-  var headers = request.headers,
-      url     = this.determineUrl(request);
-
-  if (headers['sec-websocket-version'])
-    return new Hybi(request, url, options);
-  else if (headers['sec-websocket-key1'])
-    return new Draft76(request, url, options);
-  else
-    return new Draft75(request, url, options);
-};
-
-module.exports = Server;
@@ -1,100 +0,0 @@
-'use strict';
-
-var NodeHTTPParser = process.binding('http_parser').HTTPParser,
-    version        = NodeHTTPParser.RESPONSE ? 6 : 4;
-
-var HttpParser = function(type) {
-  if (type === 'request')
-    this._parser = new NodeHTTPParser(NodeHTTPParser.REQUEST || 'request');
-  else
-    this._parser = new NodeHTTPParser(NodeHTTPParser.RESPONSE || 'response');
-
-  this._type     = type;
-  this._complete = false;
-  this.headers   = {};
-
-  var current = null,
-      self    = this;
-
-  this._parser.onHeaderField = function(b, start, length) {
-    current = b.toString('utf8', start, start + length).toLowerCase();
-  };
-
-  this._parser.onHeaderValue = function(b, start, length) {
-    var value = b.toString('utf8', start, start + length);
-
-    if (self.headers.hasOwnProperty(current))
-      self.headers[current] += ', ' + value;
-    else
-      self.headers[current] = value;
-  };
-
-  this._parser.onHeadersComplete = this._parser[NodeHTTPParser.kOnHeadersComplete] =
-  function(majorVersion, minorVersion, headers, method, pathname, statusCode) {
-    var info = arguments[0];
-
-    if (typeof info === 'object') {
-      method     = info.method;
-      pathname   = info.url;
-      statusCode = info.statusCode;
-      headers    = info.headers;
-    }
-
-    self.method     = (typeof method === 'number') ? HttpParser.METHODS[method] : method;
-    self.statusCode = statusCode;
-    self.url        = pathname;
-
-    if (!headers) return;
-
-    for (var i = 0, n = headers.length, key, value; i < n; i += 2) {
-      key   = headers[i].toLowerCase();
-      value = headers[i+1];
-      if (self.headers.hasOwnProperty(key))
-        self.headers[key] += ', ' + value;
-      else
-        self.headers[key] = value;
-    }
-
-    self._complete = true;
-  };
-};
-
-HttpParser.METHODS = {
-  0:  'DELETE',
-  1:  'GET',
-  2:  'HEAD',
-  3:  'POST',
-  4:  'PUT',
-  5:  'CONNECT',
-  6:  'OPTIONS',
-  7:  'TRACE',
-  8:  'COPY',
-  9:  'LOCK',
-  10: 'MKCOL',
-  11: 'MOVE',
-  12: 'PROPFIND',
-  13: 'PROPPATCH',
-  14: 'SEARCH',
-  15: 'UNLOCK',
-  16: 'REPORT',
-  17: 'MKACTIVITY',
-  18: 'CHECKOUT',
-  19: 'MERGE',
-  24: 'PATCH'
-};
-
-HttpParser.prototype.isComplete = function() {
-  return this._complete;
-};
-
-HttpParser.prototype.parse = function(data) {
-  var offset   = (version < 6) ? 1 : 0,
-      consumed = this._parser.execute(data, 0, data.length) + offset;
-
-  if (this._complete)
-    this.body = (consumed < data.length)
-              ? data.slice(consumed)
-              : new Buffer(0);
-};
-
-module.exports = HttpParser;
@@ -1,146 +0,0 @@
-'use strict';
-
-/**
-
-Streams in a WebSocket connection
---------------------------------
-
-We model a WebSocket as two duplex streams: one stream is for the wire protocol
-over an I/O socket, and the other is for incoming/outgoing messages.
-
-
-                        +----------+      +---------+      +----------+
-    [1] write(chunk) -->| ~~~~~~~~ +----->| parse() +----->| ~~~~~~~~ +--> emit('data') [2]
-                        |          |      +----+----+      |          |
-                        |          |           |           |          |
-                        |    IO    |           | [5]       | Messages |
-                        |          |           V           |          |
-                        |          |      +---------+      |          |
-    [4] emit('data') <--+ ~~~~~~~~ |<-----+ frame() |<-----+ ~~~~~~~~ |<-- write(chunk) [3]
-                        +----------+      +---------+      +----------+
-
-
-Message transfer in each direction is simple: IO receives a byte stream [1] and
-sends this stream for parsing. The parser will periodically emit a complete
-message text on the Messages stream [2]. Similarly, when messages are written
-to the Messages stream [3], they are framed using the WebSocket wire format and
-emitted via IO [4].
-
-There is a feedback loop via [5] since some input from [1] will be things like
-ping, pong and close frames. In these cases the protocol responds by emitting
-responses directly back to [4] rather than emitting messages via [2].
-
-For the purposes of flow control, we consider the sources of each Readable
-stream to be as follows:
-
-* [2] receives input from [1]
-* [4] receives input from [1] and [3]
-
-The classes below express the relationships described above without prescribing
-anything about how parse() and frame() work, other than assuming they emit
-'data' events to the IO and Messages streams. They will work with any protocol
-driver having these two methods.
-**/
-
-
-var Stream = require('stream').Stream,
-    util   = require('util');
-
-
-var IO = function(driver) {
-  this.readable = this.writable = true;
-  this._paused  = false;
-  this._driver  = driver;
-};
-util.inherits(IO, Stream);
-
-// The IO pause() and resume() methods will be called when the socket we are
-// piping to gets backed up and drains. Since IO output [4] comes from IO input
-// [1] and Messages input [3], we need to tell both of those to return false
-// from write() when this stream is paused.
-
-IO.prototype.pause = function() {
-  this._paused = true;
-  this._driver.messages._paused = true;
-};
-
-IO.prototype.resume = function() {
-  this._paused = false;
-  this.emit('drain');
-
-  var messages = this._driver.messages;
-  messages._paused = false;
-  messages.emit('drain');
-};
-
-// When we receive input from a socket, send it to the parser and tell the
-// source whether to back off.
-IO.prototype.write = function(chunk) {
-  if (!this.writable) return false;
-  this._driver.parse(chunk);
-  return !this._paused;
-};
-
-// The IO end() method will be called when the socket piping into it emits
-// 'close' or 'end', i.e. the socket is closed. In this situation the Messages
-// stream will not emit any more data so we emit 'end'.
-IO.prototype.end = function(chunk) {
-  if (!this.writable) return;
-  if (chunk !== undefined) this.write(chunk);
-  this.writable = false;
-
-  var messages = this._driver.messages;
-  if (messages.readable) {
-    messages.readable = messages.writable = false;
-    messages.emit('end');
-  }
-};
-
-IO.prototype.destroy = function() {
-  this.end();
-};
-
-
-var Messages = function(driver) {
-  this.readable = this.writable = true;
-  this._paused  = false;
-  this._driver  = driver;
-};
-util.inherits(Messages, Stream);
-
-// The Messages pause() and resume() methods will be called when the app that's
-// processing the messages gets backed up and drains. If we're emitting
-// messages too fast we should tell the source to slow down. Message output [2]
-// comes from IO input [1].
-
-Messages.prototype.pause = function() {
-  this._driver.io._paused = true;
-};
-
-Messages.prototype.resume = function() {
-  this._driver.io._paused = false;
-  this._driver.io.emit('drain');
-};
-
-// When we receive messages from the user, send them to the formatter and tell
-// the source whether to back off.
-Messages.prototype.write = function(message) {
-  if (!this.writable) return false;
-  if (typeof message === 'string') this._driver.text(message);
-  else this._driver.binary(message);
-  return !this._paused;
-};
-
-// The Messages end() method will be called when a stream piping into it emits
-// 'end'. Many streams may be piped into the WebSocket and one of them ending
-// does not mean the whole socket is done, so just process the input and move
-// on leaving the socket open.
-Messages.prototype.end = function(message) {
-  if (message !== undefined) this.write(message);
-};
-
-Messages.prototype.destroy = function() {};
-
-
-exports.IO = IO;
-exports.Messages = Messages;
@@ -1,21 +1,27 @@
-{ "name"            : "websocket-driver"
-, "description"     : "WebSocket protocol handler with pluggable I/O"
-, "homepage"        : "http://github.com/faye/websocket-driver-node"
+{ "name"            : "faye-websocket"
+, "description"     : "Standards-compliant WebSocket server and client"
+, "homepage"        : "http://github.com/faye/faye-websocket-node"
 , "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
-, "keywords"        : ["websocket"]
-, "license"         : "MIT"
+, "keywords"        : ["websocket", "eventsource"]

-, "version"         : "0.5.3"
-, "engines"         : {"node": ">=0.6.0"}
-, "main"            : "./lib/websocket/driver"
-, "dependencies"    : {"websocket-extensions": ">=0.1.1"}
-, "devDependencies" : {"jstest": "", "permessage-deflate": ""}
+, "version"         : "0.4.4"
+, "engines"         : {"node": ">=0.4.0"}
+, "main"            : "./lib/faye/websocket"
+, "dependencies"    : {"websocket-driver": ""}
+, "devDependencies" : {"jsclass": "", "pace": ""}

-, "scripts"         : {"test": "jstest spec/runner.js"}
+, "scripts"         : {"test": "node spec/runner.js"}

-, "repository"      : { "type"  : "git"
-                      , "url"   : "git://github.com/faye/websocket-driver-node.git"
-                      }
+, "bugs"            : "http://github.com/faye/faye-websocket-node/issues"

-, "bugs"            : "http://github.com/faye/websocket-driver-node/issues"
+, "licenses"        : [ { "type"  : "MIT"
+                        , "url"   : "http://www.opensource.org/licenses/mit-license.php"
+                        }
+                      ]
+
+, "repositories"    : [ { "type"  : "git"
+                        , "url"   : "git://github.com/faye/faye-websocket-node.git"
+                        }
+                      ]
 }
+
@@ -0,0 +1,171 @@
+var Client = require('../../../lib/faye/websocket/client')
+
+JS.ENV.WebSocketSteps = JS.Test.asyncSteps({
+  server: function(port, secure, callback) {
+    this._adapter = new EchoServer()
+    this._adapter.listen(port, secure)
+    this._port = port
+    setTimeout(callback, 100)
+  },
+
+  stop: function(callback) {
+    this._adapter.stop()
+    setTimeout(callback, 100)
+  },
+
+  open_socket: function(url, protocols, callback) {
+    var done = false,
+        self = this,
+
+        resume = function(open) {
+                   if (done) return
+                   done = true
+                   self._open = open
+                   callback()
+                 }
+
+    this._ws = new Client(url, protocols, {verify: false})
+
+    this._ws.onopen  = function() { resume(true)  }
+    this._ws.onclose = function() { resume(false) }
+  },
+
+  close_socket: function(callback) {
+    var self = this
+    this._ws.onclose = function() {
+      self._open = false
+      callback()
+    }
+    this._ws.close()
+  },
+
+  check_open: function(callback) {
+    this.assert( this._open )
+    callback()
+  },
+
+  check_closed: function(callback) {
+    this.assert( !this._open )
+    callback()
+  },
+
+  check_protocol: function(protocol, callback) {
+    this.assertEqual( protocol, this._ws.protocol )
+    callback()
+  },
+
+  listen_for_message: function(callback) {
+    var self = this
+    this._ws.addEventListener('message', function(message) { self._message = message.data })
+    callback()
+  },
+
+  send_message: function(message, callback) {
+    this._ws.send(message)
+    setTimeout(callback, 100)
+  },
+
+  check_response: function(message, callback) {
+    this.assertEqual( message, this._message )
+    callback()
+  },
+
+  check_no_response: function(callback) {
+    this.assert( !this._message )
+    callback()
+  }
+})
+
+
+JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
+  include(WebSocketSteps)
+
+  before(function() {
+    this.protocols       = ["foo", "echo"]
+    this.plain_text_url  = "ws://localhost:4180/bayeux"
+    this.secure_url      = "wss://localhost:4180/bayeux"
+    this.port            = 4180
+  })
+
+  sharedBehavior("socket client", function() { with(this) {
+    it("can open a connection", function() { with(this) {
+      open_socket(socket_url, protocols)
+      check_open()
+      check_protocol("echo")
+    }})
+
+    it("can close the connection", function() { with(this) {
+      open_socket(socket_url, protocols)
+      close_socket()
+      check_closed()
+    }})
+
+    describe("in the OPEN state", function() { with(this) {
+      before(function() { with(this) {
+        open_socket(socket_url, protocols)
+      }})
+
+      it("can send and receive messages", function() { with(this) {
+        listen_for_message()
+        send_message("I expect this to be echoed")
+        check_response("I expect this to be echoed")
+      }})
+
+      it("sends numbers as strings", function() { with(this) {
+        listen_for_message()
+        send_message(13)
+        check_response("13")
+      }})
+
+      it("sends booleans as strings", function() { with(this) {
+        listen_for_message()
+        send_message(false)
+        check_response("false")
+      }})
+
+      it("sends arrays as strings", function() { with(this) {
+        listen_for_message()
+        send_message([13,14,15])
+        check_response("13,14,15")
+      }})
+    }})
+
+    describe("in the CLOSED state", function() { with(this) {
+      before(function() { with(this) {
+        open_socket(socket_url, protocols)
+        close_socket()
+      }})
+
+      it("cannot send and receive messages", function() { with(this) {
+        listen_for_message()
+        send_message("I expect this to be echoed")
+        check_no_response()
+      }})
+    }})
+  }})
+
+  describe("with a plain-text server", function() { with(this) {
+    before(function() {
+      this.socket_url  = this.plain_text_url
+      this.blocked_url = this.secure_url
+    })
+
+    before(function() { this.server(4180, false) })
+    after (function() { this.stop() })
+
+    behavesLike("socket client")
+  }})
+
+  describe("with a secure server", function() { with(this) {
+    before(function() {
+      this.socket_url  = this.secure_url
+      this.blocked_url = this.plain_text_url
+    })
+
+    before(function() { this.server(4180, true) })
+    after (function() { this.stop() })
+
+    behavesLike("socket client")
+  }})
+}})
+
@@ -1,44 +1,37 @@
-var test   = require('jstest').Test,
-    Stream = require('stream').Stream,
-    util   = require('util')
+require('jsclass')

-var BufferMatcher = function(data) {
-  this._data = (typeof data === 'string')
-             ? new Buffer(data, 'utf8')
-             : new Buffer(data)
+var WebSocket = require('../lib/faye/websocket'),
+    fs        = require('fs'),
+    http      = require('http'),
+    https     = require('https')
+
+
+JS.ENV.EchoServer = function() {}
+EchoServer.prototype.listen = function(port, ssl) {
+  var server = ssl
+             ? https.createServer({
+                 key:  fs.readFileSync(__dirname + '/server.key'),
+                 cert: fs.readFileSync(__dirname + '/server.crt')
+               })
+             : http.createServer()
+
+  server.on('upgrade', function(request, socket, head) {
+    var ws = new WebSocket(request, socket, head, ["echo"])
+    ws.pipe(ws)
+  })
+  this._httpServer = server
+  server.listen(port)
 }
-BufferMatcher.prototype.equals = function(other) {
-  if (this._data.length !== other.length) return false;
-  for (var i = 0, n = other.length; i < n; i++) {
-    if (other[i] !== this._data[i]) return false;
-  }
-  return true;
+EchoServer.prototype.stop = function(callback, scope) {
+  this._httpServer.on('close', function() {
+    if (callback) callback.call(scope);
+  });
+  this._httpServer.close();
 }

-var Collector = function() {
-  this.bytes = []
-  this.writable = true
-}
-util.inherits(Collector, Stream)
-Collector.prototype.write = function(buffer) {
-  this.bytes = []
-  for (var i = 0, n = buffer.length; i < n; i++) {
-    this.bytes[i] = buffer[i]
-  }
-  return true
-}

-test.Unit.TestCase.include({
-  buffer: function(data) {
-    return new BufferMatcher(data)
-  },
-  collector: function() {
-    return this._collector = this._collector || new Collector()
-  }
+JS.require('JS.Test', function() {
+  require('./faye/websocket/client_spec')
+  JS.Test.autorun()
 })

-require('./websocket/driver/draft75_examples')
-require('./websocket/driver/draft75_spec')
-require('./websocket/driver/draft76_spec')
-require('./websocket/driver/hybi_spec')
-require('./websocket/driver/client_spec')
@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICZTCCAc4CCQDxyrJZrFA0vjANBgkqhkiG9w0BAQUFADB3MQswCQYDVQQGEwJV
+SzEPMA0GA1UECBMGTG9uZG9uMQ8wDQYDVQQHEwZMb25kb24xDTALBgNVBAoTBEZh
+eWUxFTATBgNVBAMTDEphbWVzIENvZ2xhbjEgMB4GCSqGSIb3DQEJARYRamNvZ2xh
+bkBnbWFpbC5jb20wHhcNMTEwODMwMTIzOTM2WhcNMTIwODI5MTIzOTM2WjB3MQsw
+CQYDVQQGEwJVSzEPMA0GA1UECBMGTG9uZG9uMQ8wDQYDVQQHEwZMb25kb24xDTAL
+BgNVBAoTBEZheWUxFTATBgNVBAMTDEphbWVzIENvZ2xhbjEgMB4GCSqGSIb3DQEJ
+ARYRamNvZ2xhbkBnbWFpbC5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGB
+AMDjU5fAK7fvUCZIYHcGXDZD/m9bY+B/UcwGcowk0hMQGYNlLKrpiK7xXBmZpDb6
+r8n+7L/epBeSumbRIm4TDzeNHhuQGYLIeGQy7JNLoPBr6GxubjuJhKOOBnCqcupR
+CLGG7Zw5oL4UvtZVH6kL9XnjyokQQbxxeoV9DqtqOaHHAgMBAAEwDQYJKoZIhvcN
+AQEFBQADgYEAvQjSpzE1ahaeH1CmbLwckTxvWMZfxcZOrxTruK1po3cNnDOjGqFQ
+KEkNj3K5WfwTBD4QgUdYDykhDX2m6HaMz4JEbgrwQv8M8FiswIA3dyGsbOifOk8H
+r3GPNKMzm4o6vrn6RGOpt9q6bsWUBUHfNpP93uU2C9QEwDua3cFjDA0=
+-----END CERTIFICATE-----
@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQDA41OXwCu371AmSGB3Blw2Q/5vW2Pgf1HMBnKMJNITEBmDZSyq
+6Yiu8VwZmaQ2+q/J/uy/3qQXkrpm0SJuEw83jR4bkBmCyHhkMuyTS6Dwa+hsbm47
+iYSjjgZwqnLqUQixhu2cOaC+FL7WVR+pC/V548qJEEG8cXqFfQ6rajmhxwIDAQAB
+AoGABlk1DiCQD8y7mZb2PdSiwlJ4lFewsNnf6lQn/v7TPzdfb5ir4LAxBHkDLACH
+jBuyH3bZefMs+W2l3u5xMKhF7uJqYcUlJdH2UwRfNG54Hn4SGAjQOK3ONer99sUf
+USlsWSX1HjAAFMCBwUfKxMZA3VNQfYKTPdm0jSVf85kHO1ECQQD3s6ksm3QpfD0L
+eG9EoDrqmwnEfpKoWPpz1O0i5tY9VcmhmLwS5Zpd7lB1qjTqzZk4RygU73T/BseJ
+azehIHK5AkEAx1mSXt+ec8RfzVi/io6oqi2vOcACXRbOG4NQmqUWPnumdwsJjsjR
+RzEoDFC2lu6448p9sgEq+CkbmgVeiyp4fwJAQnmgySve/NMuvslPcyddKGD7OhSN
+30ghzrwx98/jZwqC1i9bKeccimDOjwVitjD/Ea9m/ldVGqwDGMoBX+iJYQJAEIOO
+CYfyw1pQKV2huGOq+zX/nwQV7go2lrbhFX55gkGR/6iNaSOfmosq6yJAje5GqLAc
+i4NnQNl+7NpnA5ZIFwJBAI1+OsZyjbRI99pYkTdOpa5IPlIb3j3JbSfjAWHLxlRY
+0HLvN3Q1mE9kbB+uKH6syF/S7nALgsLgq7eHYvIaE/A=
+-----END RSA PRIVATE KEY-----
@@ -1,323 +0,0 @@
-var Client = require("../../../lib/websocket/driver/client"),
-    test   = require('jstest').Test
-
-test.describe("Client", function() { with(this) {
-    define("options", function() {
-    return this._options = this._options || {protocols: this.protocols()}
-  })
-
-  define("protocols", function() {
-    null
-  })
-
-  define("url", function() {
-    return "ws://www.example.com/socket"
-  })
-
-  define("driver", function() {
-    if (this._driver) return this._driver
-    this._driver = new Client(this.url(), this.options())
-    var self = this
-    this._driver.on('open',    function(e) { self.open = true })
-    this._driver.on('message', function(e) { self.message += e.data })
-    this._driver.on('error',   function(e) { self.error = e })
-    this._driver.on('close',   function(e) { self.close = [e.code, e.reason] })
-    var collector = this.collector()
-    this._driver.io.on("data", function(d) { collector.write(d) })
-    return this._driver
-  })
-
-  define("key", function() {
-    return "2vBVWg4Qyk3ZoM/5d3QD9Q=="
-  })
-
-  define("response", function() {
-    return "HTTP/1.1 101 Switching Protocols\r\n" +
-           "Upgrade: websocket\r\n" +
-           "Connection: Upgrade\r\n" +
-           "Sec-WebSocket-Accept: QV3I5XUXU2CdhtjixE7QCkCcMZM=\r\n" +
-           "\r\n"
-  })
-
-  before(function() {
-    this.stub(Client, "generateKey").returns(this.key())
-    this.open = this.error = this.close = false
-    this.message = ""
-  })
-
-  describe("in the beginning state", function() { with(this) {
-    it("starts in no state", function() { with(this) {
-      assertEqual( null, driver().getState() )
-    }})
-
-    describe("close", function() { with(this) {
-      it("changes the state to closed", function() { with(this) {
-        driver().close()
-        assertEqual( "closed", driver().getState() )
-        assertEqual( [1000, ''], close )
-      }})
-    }})
-
-    describe("start", function() { with(this) {
-      it("writes the handshake request to the socket", function() { with(this) {
-        expect(driver().io, "emit").given("data", buffer(
-            "GET /socket HTTP/1.1\r\n" +
-            "Host: www.example.com\r\n" +
-            "Upgrade: websocket\r\n" +
-            "Connection: Upgrade\r\n" +
-            "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" +
-            "Sec-WebSocket-Version: 13\r\n" +
-            "\r\n"))
-        driver().start()
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().start() )
-      }})
-
-      describe("with subprotocols", function() { with(this) {
-        define("protocols", function() { return ["foo", "bar", "xmpp"] })
-
-        it("writes the handshake with Sec-WebSocket-Protocol", function() { with(this) {
-          expect(driver().io, "emit").given("data", buffer(
-              "GET /socket HTTP/1.1\r\n" +
-              "Host: www.example.com\r\n" +
-              "Upgrade: websocket\r\n" +
-              "Connection: Upgrade\r\n" +
-              "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" +
-              "Sec-WebSocket-Version: 13\r\n" +
-              "Sec-WebSocket-Protocol: foo, bar, xmpp\r\n" +
-              "\r\n"))
-          driver().start()
-        }})
-      }})
-
-      describe("with basic auth", function() { with(this) {
-        define("url", function() { return "ws://user:pass@www.example.com/socket" })
-
-        it("writes the handshake with Authorization", function() { with(this) {
-          expect(driver().io, "emit").given("data", buffer(
-              "GET /socket HTTP/1.1\r\n" +
-              "Host: www.example.com\r\n" +
-              "Upgrade: websocket\r\n" +
-              "Connection: Upgrade\r\n" +
-              "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" +
-              "Sec-WebSocket-Version: 13\r\n" +
-              "Authorization: Basic dXNlcjpwYXNz\r\n" +
-              "\r\n"))
-          driver().start()
-        }})
-      }})
-
-      describe("with custom headers", function() { with(this) {
-        before(function() { with(this) {
-          driver().setHeader("User-Agent", "Chrome")
-        }})
-
-        it("writes the handshake with custom headers", function() { with(this) {
-          expect(driver().io, "emit").given("data", buffer(
-              "GET /socket HTTP/1.1\r\n" +
-              "Host: www.example.com\r\n" +
-              "Upgrade: websocket\r\n" +
-              "Connection: Upgrade\r\n" +
-              "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" +
-              "Sec-WebSocket-Version: 13\r\n" +
-              "User-Agent: Chrome\r\n" +
-              "\r\n"))
-          driver().start()
-        }})
-      }})
-
-      it("changes the state to connecting", function() { with(this) {
-        driver().start()
-        assertEqual( "connecting", driver().getState() )
-      }})
-    }})
-  }})
-
-  describe("using a proxy", function() { with(this) {
-    it("sends a CONNECT request", function() { with(this) {
-      var proxy = driver().proxy("http://proxy.example.com")
-      expect(proxy, "emit").given("data", buffer(
-          "CONNECT www.example.com:80 HTTP/1.1\r\n" +
-          "Host: www.example.com\r\n" +
-          "Connection: keep-alive\r\n" +
-          "Proxy-Connection: keep-alive\r\n" +
-          "\r\n"))
-      proxy.start()
-    }})
-
-    it("sends an authenticated CONNECT request", function() { with(this) {
-      var proxy = driver().proxy("http://user:pass@proxy.example.com")
-      expect(proxy, "emit").given("data", buffer(
-          "CONNECT www.example.com:80 HTTP/1.1\r\n" +
-          "Host: www.example.com\r\n" +
-          "Connection: keep-alive\r\n" +
-          "Proxy-Connection: keep-alive\r\n" +
-          "Proxy-Authorization: Basic dXNlcjpwYXNz\r\n" +
-          "\r\n"))
-      proxy.start()
-    }})
-
-    it("sends a CONNECT request with custom headers", function() { with(this) {
-      var proxy = driver().proxy("http://user:pass@proxy.example.com")
-      proxy.setHeader("User-Agent", "Chrome")
-      expect(proxy, "emit").given("data", buffer(
-          "CONNECT www.example.com:80 HTTP/1.1\r\n" +
-          "Host: www.example.com\r\n" +
-          "Connection: keep-alive\r\n" +
-          "Proxy-Connection: keep-alive\r\n" +
-          "Proxy-Authorization: Basic dXNlcjpwYXNz\r\n" +
-          "User-Agent: Chrome\r\n" +
-          "\r\n"))
-      proxy.start()
-    }})
-
-    describe("receiving a response", function() { with(this) {
-      before(function() { with(this) {
-        this.proxy = driver().proxy("http://proxy.example.com")
-      }})
-
-      it("returns true when the response is written", function() { with(this) {
-        // this prevents downstream connections suddenly closing for no reason
-        assertEqual( true, proxy.write(new Buffer("HTTP/1.1 200 OK\r\n\r\n")) )
-      }})
-
-      it("emits a 'connect' event when the proxy connects", function() { with(this) {
-        expect(proxy, "emit").given("connect")
-        expect(proxy, "emit").given("close")
-        expect(proxy, "emit").given("end")
-        proxy.write(new Buffer("HTTP/1.1 200 OK\r\n\r\n"))
-      }})
-
-      it("emits an 'error' event if the proxy does not connect", function() { with(this) {
-        expect(proxy, "emit").given("error", objectIncluding({message: "Can't establish a connection to the server at ws://www.example.com/socket"}))
-        expect(proxy, "emit").given("close")
-        expect(proxy, "emit").given("end")
-        proxy.write(new Buffer("HTTP/1.1 403 Forbidden\r\n\r\n"))
-      }})
-    }})
-  }})
-
-  describe("in the connecting state", function() { with(this) {
-    before(function() { this.driver().start() })
-
-    describe("with a valid response", function() { with(this) {
-      before(function() { this.driver().parse(new Buffer(this.response())) })
-
-      it("changes the state to open", function() { with(this) {
-        assertEqual( true, open )
-        assertEqual( false, close )
-        assertEqual( "open", driver().getState() )
-      }})
-
-      it("makes the response status available", function() { with(this) {
-        assertEqual( 101, driver().statusCode )
-      }})
-
-      it("makes the response headers available", function() { with(this) {
-        assertEqual( "websocket", driver().headers.upgrade )
-      }})
-    }})
-
-    describe("with a valid response followed by a frame", function() { with(this) {
-      before(function() { with(this) {
-        var resp = new Buffer(response().length + 4)
-        new Buffer(response()).copy(resp)
-        new Buffer([0x81, 0x02, 72, 105]).copy(resp, resp.length - 4)
-        driver().parse(resp)
-      }})
-
-      it("changes the state to open", function() { with(this) {
-        assertEqual( true, open )
-        assertEqual( false, close )
-        assertEqual( "open", driver().getState() )
-      }})
-
-      it("parses the frame", function() { with(this) {
-        assertEqual( "Hi", message )
-      }})
-    }})
-
-    describe("with a bad status line", function() { with(this) {
-      before(function() {
-        var resp = this.response().replace(/101/g, "4")
-        this.driver().parse(new Buffer(resp))
-      })
-
-      it("changes the state to closed", function() { with(this) {
-        assertEqual( false, open )
-        assertEqual( "Error during WebSocket handshake: Unexpected response code: 4", error.message )
-        assertEqual( [1002, "Error during WebSocket handshake: Unexpected response code: 4"], close )
-        assertEqual( "closed", driver().getState() )
-      }})
-    }})
-
-    describe("with a bad Upgrade header", function() { with(this) {
-      before(function() {
-        var resp = this.response().replace(/websocket/g, "wrong")
-        this.driver().parse(new Buffer(resp))
-      })
-
-      it("changes the state to closed", function() { with(this) {
-        assertEqual( false, open )
-        assertEqual( "Error during WebSocket handshake: 'Upgrade' header value is not 'WebSocket'", error.message )
-        assertEqual( [1002, "Error during WebSocket handshake: 'Upgrade' header value is not 'WebSocket'"], close )
-        assertEqual( "closed", driver().getState() )
-      }})
-    }})
-
-    describe("with a bad Accept header", function() { with(this) {
-      before(function() {
-        var resp = this.response().replace(/QV3/g, "wrong")
-        this.driver().parse(new Buffer(resp))
-      })
-
-      it("changes the state to closed", function() { with(this) {
-        assertEqual( false, open )
-        assertEqual( "Error during WebSocket handshake: Sec-WebSocket-Accept mismatch", error.message )
-        assertEqual( [1002, "Error during WebSocket handshake: Sec-WebSocket-Accept mismatch"], close )
-        assertEqual( "closed", driver().getState() )
-      }})
-    }})
-
-    describe("with valid subprotocols", function() { with(this) {
-      define("protocols", function() { return ["foo", "xmpp"] })
-
-      before(function() {
-        var resp = this.response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: xmpp\r\n\r\n")
-        this.driver().parse(new Buffer(resp))
-      })
-
-      it("changs the state to open", function() { with(this) {
-        assertEqual( true, open )
-        assertEqual( false, close )
-        assertEqual( "open", driver().getState() )
-      }})
-
-      it("selects the subprotocol", function() { with(this) {
-        assertEqual( "xmpp", driver().protocol )
-      }})
-    }})
-
-    describe("with invalid subprotocols", function() { with(this) {
-      define("protocols", function() { return ["foo", "xmpp"] })
-
-      before(function() {
-        var resp = this.response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: irc\r\n\r\n")
-        this.driver().parse(new Buffer(resp))
-      })
-
-      it("changs the state to closed", function() { with(this) {
-        assertEqual( false, open )
-        assertEqual( "Error during WebSocket handshake: Sec-WebSocket-Protocol mismatch", error.message )
-        assertEqual( [1002, "Error during WebSocket handshake: Sec-WebSocket-Protocol mismatch"], close )
-        assertEqual( "closed", driver().getState() )
-      }})
-
-      it("selects no subprotocol", function() { with(this) {
-        assertEqual( null, driver().protocol )
-      }})
-    }})
-  }})
-}})
@@ -1,114 +0,0 @@
-var test = require('jstest').Test
-
-test.describe("draft-75", function() { with(this) {
-  sharedExamplesFor("draft-75 protocol", function() { with(this) {
-    describe("in the open state", function() { with(this) {
-      before(function() { this.driver().start() })
-
-      describe("parse", function() { with(this) {
-        it("parses text frames", function() { with(this) {
-          driver().parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
-          assertEqual( "Hello", message )
-        }})
-
-        it("parses multiple frames from the same packet", function() { with(this) {
-          driver().parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
-          assertEqual( "HelloHello", message )
-        }})
-
-        it("parses text frames beginning 0x00-0x7F", function() { with(this) {
-          driver().parse([0x66, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
-          assertEqual( "Hello", message )
-        }})
-
-        it("ignores frames with a length header", function() { with(this) {
-          driver().parse([0x80, 0x02, 0x48, 0x65, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
-          assertEqual( "Hello", message )
-        }})
-
-        it("parses multibyte text frames", function() { with(this) {
-          driver().parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff])
-          assertEqual( "Apple = ", message )
-        }})
-
-        it("parses frames received in several packets", function() { with(this) {
-          driver().parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65])
-          driver().parse([0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff])
-          assertEqual( "Apple = ", message )
-        }})
-
-        it("parses fragmented frames", function() { with(this) {
-          driver().parse([0x00, 0x48, 0x65, 0x6c])
-          driver().parse([0x6c, 0x6f, 0xff])
-          assertEqual( "Hello", message )
-        }})
-      }})
-
-      describe("frame", function() { with(this) {
-        it("formats the given string as a WebSocket frame", function() { with(this) {
-          driver().frame("Hello")
-          assertEqual( [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff], collector().bytes )
-        }})
-
-        it("encodes multibyte characters correctly", function() { with(this) {
-          driver().frame("Apple = ")
-          assertEqual( [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff], collector().bytes )
-        }})
-
-        it("returns true", function() { with(this) {
-          assertEqual( true, driver().frame("lol") )
-        }})
-      }})
-
-      describe("ping", function() { with(this) {
-        it("does not write to the socket", function() { with(this) {
-          expect(driver().io, "emit").exactly(0)
-          driver().ping()
-        }})
-
-        it("returns false", function() { with(this) {
-          assertEqual( false, driver().ping() )
-        }})
-      }})
-
-      describe("close", function() { with(this) {
-        it("triggers the onclose event", function() { with(this) {
-          driver().close()
-          assertEqual( true, close )
-        }})
-
-        it("returns true", function() { with(this) {
-          assertEqual( true, driver().close() )
-        }})
-
-        it("changes the state to closed", function() { with(this) {
-          driver().close()
-          assertEqual( "closed", driver().getState() )
-        }})
-      }})
-    }})
-
-    describe("in the closed state", function() { with(this) {
-      before(function() {
-        this.driver().start()
-        this.driver().close()
-      })
-
-      describe("close", function() { with(this) {
-        it("does not write to the socket", function() { with(this) {
-          expect(driver().io, "emit").exactly(0)
-          driver().close()
-        }})
-
-        it("returns false", function() { with(this) {
-          assertEqual( false, driver().close() )
-        }})
-
-        it("leaves the protocol in the closed state", function() { with(this) {
-          driver().close()
-          assertEqual( "closed", driver().getState() )
-        }})
-      }})
-    }})
-  }})
-}})
@@ -1,99 +0,0 @@
-var Draft75 = require("../../../lib/websocket/driver/draft75"),
-    test    = require('jstest').Test
-
-test.describe("Draft75", function() { with(this) {
-  define("request", function() {
-    return this._request = this._request || {
-      headers: {
-        "connection": "Upgrade",
-        "upgrade":    "WebSocket",
-        "origin":     "http://www.example.com"
-      }
-    }
-  })
-
-  define("options", function() {
-    return this._options = this._options || {masking: false}
-  })
-
-  define("driver", function() {
-    if (this._driver) return this._driver
-    this._driver = new Draft75(this.request(), "ws://www.example.com/socket", this.options())
-    var self = this
-    this._driver.on('open',    function(e) { self.open = true })
-    this._driver.on('message', function(e) { self.message += e.data })
-    this._driver.on('close',   function(e) { self.close = true })
-    this._driver.io.pipe(this.collector())
-    return this._driver
-  })
-
-  before(function() {
-    this.open = this.close = false
-    this.message = ""
-  })
-
-  describe("in the connecting state", function() { with(this) {
-    it("starts in the connecting state", function() { with(this) {
-      assertEqual( "connecting", driver().getState() )
-    }})
-
-    describe("start", function() { with(this) {
-      it("writes the handshake response to the socket", function() { with(this) {
-        expect(driver().io, "emit").given("data", buffer(
-            "HTTP/1.1 101 Web Socket Protocol Handshake\r\n" +
-            "Upgrade: WebSocket\r\n" +
-            "Connection: Upgrade\r\n" +
-            "WebSocket-Origin: http://www.example.com\r\n" +
-            "WebSocket-Location: ws://www.example.com/socket\r\n" +
-            "\r\n"))
-        driver().start()
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().start() )
-      }})
-
-      it("triggers the onopen event", function() { with(this) {
-        driver().start()
-        assertEqual( true, open )
-      }})
-
-      it("changes the state to open", function() { with(this) {
-        driver().start()
-        assertEqual( "open", driver().getState() )
-      }})
-
-      it("sets the protocol version", function() { with(this) {
-        driver().start()
-        assertEqual( "hixie-75", driver().version )
-      }})
-    }})
-
-    describe("frame", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().frame("Hello, world")
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().frame("whatever") )
-      }})
-
-      it("queues the frames until the handshake has been sent", function() { with(this) {
-        expect(driver().io, "emit").given("data", buffer(
-            "HTTP/1.1 101 Web Socket Protocol Handshake\r\n" +
-            "Upgrade: WebSocket\r\n" +
-            "Connection: Upgrade\r\n" +
-            "WebSocket-Origin: http://www.example.com\r\n" +
-            "WebSocket-Location: ws://www.example.com/socket\r\n" +
-            "\r\n"))
-        expect(driver().io, "emit").given("data", buffer([0x00, 0x48, 0x69, 0xff]))
-
-        driver().frame("Hi")
-        driver().start()
-      }})
-    }})
-  }})
-
-  itShouldBehaveLike("draft-75 protocol")
-}})
@@ -1,186 +0,0 @@
-var Draft76 = require("../../../lib/websocket/driver/draft76"),
-    test    = require('jstest').Test
-
-test.describe("Draft76", function() { with(this) {
-  BODY = new Buffer([0x91, 0x25, 0x3e, 0xd3, 0xa9, 0xe7, 0x6a, 0x88])
-
-  define("body", function() {
-    return BODY
-  })
-
-  define("response", function() {
-    return [0xb4, 0x9c, 0x6e, 0x40, 0x53, 0x04, 0x04, 0x26, 0xe5, 0x1b, 0xbf, 0x6c, 0xb7, 0x9f, 0x1d, 0xf9]
-  })
-
-  define("request", function() {
-    return this._request = this._request || {
-      headers: {
-        "connection":         "Upgrade",
-        "upgrade":            "WebSocket",
-        "origin":             "http://www.example.com",
-        "sec-websocket-key1": "1   38 wZ3f9 23O0 3l 0r",
-        "sec-websocket-key2": "27   0E 6 2  1665:< ;U 1H"
-      }
-    }
-  })
-
-  define("options", function() {
-    return this._options = this._options || {masking: false}
-  })
-
-  define("driver", function() {
-    if (this._driver) return this._driver
-    this._driver = new Draft76(this.request(), "ws://www.example.com/socket", this.options())
-    var self = this
-    this._driver.on('open',    function(e) { self.open = true })
-    this._driver.on('message', function(e) { self.message += e.data })
-    this._driver.on('close',   function(e) { self.close = true })
-    this._driver.io.pipe(this.collector())
-    this._driver.io.write(this.body())
-    return this._driver
-  })
-
-  before(function() {
-    this.open = this.close = false
-    this.message = ""
-  })
-
-  describe("in the connecting state", function() { with(this) {
-    it("starts in the connecting state", function() { with(this) {
-      assertEqual( "connecting", driver().getState() )
-    }})
-
-    describe("start", function() { with(this) {
-      it("writes the handshake response to the socket", function() { with(this) {
-        expect(driver().io, "emit").given("data", buffer(
-            "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" +
-            "Upgrade: WebSocket\r\n" +
-            "Connection: Upgrade\r\n" +
-            "Sec-WebSocket-Origin: http://www.example.com\r\n" +
-            "Sec-WebSocket-Location: ws://www.example.com/socket\r\n" +
-            "\r\n"))
-        expect(driver().io, "emit").given("data", buffer(response()))
-        driver().start()
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().start() )
-      }})
-
-      it("triggers the onopen event", function() { with(this) {
-        driver().start()
-        assertEqual( true, open )
-      }})
-
-      it("changes the state to open", function() { with(this) {
-        driver().start()
-        assertEqual( "open", driver().getState() )
-      }})
-
-      it("sets the protocol version", function() { with(this) {
-        driver().start()
-        assertEqual( "hixie-76", driver().version )
-      }})
-    }})
-
-    describe("frame", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().frame("Hello, world")
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().frame("whatever") )
-      }})
-
-      it("queues the frames until the handshake has been sent", function() { with(this) {
-        expect(driver().io, "emit").given("data", buffer(
-            "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" +
-            "Upgrade: WebSocket\r\n" +
-            "Connection: Upgrade\r\n" +
-            "Sec-WebSocket-Origin: http://www.example.com\r\n" +
-            "Sec-WebSocket-Location: ws://www.example.com/socket\r\n" +
-            "\r\n"))
-        expect(driver().io, "emit").given("data", buffer(response()))
-        expect(driver().io, "emit").given("data", buffer([0x00, 72, 105, 0xff]))
-
-        driver().frame("Hi")
-        driver().start()
-      }})
-    }})
-
-    describe("with no request body", function() { with(this) {
-      define("body", function() {
-        return new Buffer([])
-      })
-
-      it("writes the handshake response with no body", function() { with(this) {
-        expect(driver().io, "emit").given("data", buffer(
-            "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" +
-            "Upgrade: WebSocket\r\n" +
-            "Connection: Upgrade\r\n" +
-            "Sec-WebSocket-Origin: http://www.example.com\r\n" +
-            "Sec-WebSocket-Location: ws://www.example.com/socket\r\n" +
-            "\r\n"))
-        driver().start()
-      }})
-
-      it("does not trigger the onopen event", function() { with(this) {
-        driver().start()
-        assertEqual( false, open )
-      }})
-
-      it("leaves the protocol in the connecting state", function() { with(this) {
-        driver().start()
-        assertEqual( "connecting", driver().getState() )
-      }})
-
-      describe("when the request body is received", function() { with(this) {
-        before(function() { this.driver().start() })
-
-        it("sends the response body", function() { with(this) {
-          expect(driver().io, "emit").given("data", buffer(response()))
-          driver().parse(BODY)
-        }})
-
-        it("triggers the onopen event", function() { with(this) {
-          driver().parse(BODY)
-          assertEqual( true, open )
-        }})
-
-        it("changes the state to open", function() { with(this) {
-          driver().parse(BODY)
-          assertEqual( "open", driver().getState() )
-        }})
-
-        it("sends any frames queued before the handshake was complete", function() { with(this) {
-          expect(driver().io, "emit").given("data", buffer(response()))
-          expect(driver().io, "emit").given("data", buffer([0x00, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xff]))
-          driver().frame("hello")
-          driver().parse(BODY)
-        }})
-      }})
-    }})
-  }})
-
-  itShouldBehaveLike("draft-75 protocol")
-
-  describe("in the open state", function() { with(this) {
-    before(function() { this.driver().start() })
-
-    describe("parse", function() { with(this) {
-      it("closes the socket if a close frame is received", function() { with(this) {
-        driver().parse([0xff, 0x00])
-        assertEqual( true, close )
-        assertEqual( "closed", driver().getState() )
-      }})
-    }})
-
-    describe("close", function() { with(this) {
-      it("writes a close message to the socket", function() { with(this) {
-        expect(driver().io, "emit").given("data", buffer([0xff, 0x00]))
-        driver().close()
-      }})
-    }})
-  }})
-}})
@@ -1,541 +0,0 @@
-var Hybi = require("../../../lib/websocket/driver/hybi"),
-    test = require('jstest').Test
-
-test.describe("Hybi", function() { with(this) {
-  define("request", function() {
-    return this._request = this._request || {
-      headers: {
-        "connection":             "Upgrade",
-        "upgrade":                "websocket",
-        "origin":                 "http://www.example.com",
-//        "sec-websocket-extensions": "x-webkit-deflate-frame",
-        "sec-websocket-key":      "JFBCWHksyIpXV+6Wlq/9pw==",
-        "sec-websocket-version":  "13"
-      }
-    }
-  })
-
-  define("options", function() {
-    return this._options = this._options || {masking: false}
-  })
-
-  define("driver", function() {
-    if (this._driver) return this._driver
-    this._driver = new Hybi(this.request(), "ws://www.example.com/socket", this.options())
-    var self = this
-    this._driver.on('open',    function(e) { self.open = true })
-    this._driver.on('message', function(e) { self.message += e.data })
-    this._driver.on('error',   function(e) { self.error = e })
-    this._driver.on('close',   function(e) { self.close = [e.code, e.reason] })
-    this._driver.io.pipe(this.collector())
-    return this._driver
-  })
-
-  before(function() {
-    this.open = this.error = this.close = false
-    this.message = ""
-  })
-
-  describe("in the connecting state", function() { with(this) {
-    it("starts in the connecting state", function() { with(this) {
-      assertEqual( "connecting", driver().getState() )
-    }})
-
-    describe("start", function() { with(this) {
-      it("writes the handshake response to the socket", function() { with(this) {
-        expect(driver().io, "emit").given("data", buffer(
-            "HTTP/1.1 101 Switching Protocols\r\n" +
-            "Upgrade: websocket\r\n" +
-            "Connection: Upgrade\r\n" +
-            "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
-            "\r\n"))
-        driver().start()
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().start() )
-      }})
-
-      describe("with subprotocols", function() { with(this) {
-        before(function() { with(this) {
-          request().headers["sec-websocket-protocol"] = "foo, bar, xmpp"
-          options().protocols = ["xmpp"]
-        }})
-
-        it("writes the handshake with Sec-WebSocket-Protocol", function() { with(this) {
-          expect(driver().io, "emit").given("data", buffer(
-              "HTTP/1.1 101 Switching Protocols\r\n" +
-              "Upgrade: websocket\r\n" +
-              "Connection: Upgrade\r\n" +
-              "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
-              "Sec-WebSocket-Protocol: xmpp\r\n" +
-              "\r\n"))
-          driver().start()
-        }})
-
-        it("sets the subprotocol", function() { with(this) {
-          driver().start()
-          assertEqual( "xmpp", driver().protocol )
-        }})
-      }})
-
-      describe("with custom headers", function() { with(this) {
-        before(function() { with(this) {
-          driver().setHeader("Authorization", "Bearer WAT")
-        }})
-
-        it("writes the handshake with Sec-WebSocket-Protocol", function() { with(this) {
-          expect(driver().io, "emit").given("data", buffer(
-              "HTTP/1.1 101 Switching Protocols\r\n" +
-              "Upgrade: websocket\r\n" +
-              "Connection: Upgrade\r\n" +
-              "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
-              "Authorization: Bearer WAT\r\n" +
-              "\r\n"))
-          driver().start()
-        }})
-      }})
-
-      it("triggers the onopen event", function() { with(this) {
-        driver().start()
-        assertEqual( true, open )
-      }})
-
-      it("changes the state to open", function() { with(this) {
-        driver().start()
-        assertEqual( "open", driver().getState() )
-      }})
-
-      it("sets the protocol version", function() { with(this) {
-        driver().start()
-        assertEqual( "hybi-13", driver().version )
-      }})
-    }})
-
-    describe("frame", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().frame("Hello, world")
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().frame("whatever") )
-      }})
-
-      it("queues the frames until the handshake has been send", function() { with(this) {
-        expect(driver().io, "emit").given("data", buffer(
-            "HTTP/1.1 101 Switching Protocols\r\n" +
-            "Upgrade: websocket\r\n" +
-            "Connection: Upgrade\r\n" +
-            "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
-            "\r\n"))
-        expect(driver().io, "emit").given("data", buffer([0x81, 0x02, 72, 105]))
-
-        driver().frame("Hi")
-        driver().start()
-      }})
-    }})
-
-    describe("ping", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().ping()
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().ping() )
-      }})
-
-      it("queues the ping until the handshake has been send", function() { with(this) {
-        expect(driver().io, "emit").given("data", buffer(
-            "HTTP/1.1 101 Switching Protocols\r\n" +
-            "Upgrade: websocket\r\n" +
-            "Connection: Upgrade\r\n" +
-            "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
-            "\r\n"))
-        expect(driver().io, "emit").given("data", buffer([0x89, 0]))
-
-        driver().ping()
-        driver().start()
-      }})
-    }})
-
-    describe("close", function() { with(this) {
-      it("does not write anything to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().close()
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().close() )
-      }})
-
-      it("triggers the onclose event", function() { with(this) {
-        driver().close()
-        assertEqual( [1000, ""], close )
-      }})
-
-      it("changes the state to closed", function() { with(this) {
-        driver().close()
-        assertEqual( "closed", driver().getState() )
-      }})
-    }})
-  }})
-
-  describe("in the open state", function() { with(this) {
-    before(function() { this.driver().start() })
-
-    describe("parse", function() { with(this) {
-      define("mask", function() {
-        return this._mask = this._mask ||
-               [1,2,3,4].map(function() { return Math.floor(Math.random() * 256) })
-      })
-
-      define("maskMessage", function(bytes) {
-        var output = []
-        for (var i = 0, n = bytes.length; i < n; i++) {
-          output[i] = bytes[i] ^ this.mask()[i % 4]
-        }
-        return output
-      })
-
-      it("parses unmasked text frames", function() { with(this) {
-        driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-        assertEqual( "Hello", message )
-      }})
-
-      it("parses multiple frames from the same packet", function() { with(this) {
-        driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-        assertEqual( "HelloHello", message )
-      }})
-
-      it("parses empty text frames", function() { with(this) {
-        driver().parse([0x81, 0x00])
-        assertEqual( "", message )
-      }})
-
-      it("parses fragmented text frames", function() { with(this) {
-        driver().parse([0x01, 0x03, 0x48, 0x65, 0x6c])
-        driver().parse([0x80, 0x02, 0x6c, 0x6f])
-        assertEqual( "Hello", message )
-      }})
-
-      it("parses masked text frames", function() { with(this) {
-        driver().parse([0x81, 0x85])
-        driver().parse(mask())
-        driver().parse(maskMessage([0x48, 0x65, 0x6c, 0x6c, 0x6f]))
-        assertEqual( "Hello", message )
-      }})
-
-      it("parses masked empty text frames", function() { with(this) {
-        driver().parse([0x81, 0x80])
-        driver().parse(mask())
-        driver().parse(maskMessage([]))
-        assertEqual( "", message )
-      }})
-
-      it("parses masked fragmented text frames", function() { with(this) {
-        driver().parse([0x01, 0x81])
-        driver().parse(mask())
-        driver().parse(maskMessage([0x48]))
-
-        driver().parse([0x80, 0x84])
-        driver().parse(mask())
-        driver().parse(maskMessage([0x65, 0x6c, 0x6c, 0x6f]))
-
-        assertEqual( "Hello", message )
-      }})
-
-      it("closes the socket if the frame has an unrecognized opcode", function() { with(this) {
-        driver().parse([0x83, 0x00])
-        assertEqual( [0x88, 0x1e, 0x03, 0xea], collector().bytes.slice(0,4) )
-        assertEqual( "Unrecognized frame opcode: 3", error.message )
-        assertEqual( [1002, "Unrecognized frame opcode: 3"], close )
-        assertEqual( "closed", driver().getState() )
-      }})
-
-      it("closes the socket if a close frame is received", function() { with(this) {
-        driver().parse([0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-        assertEqual( [0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes )
-        assertEqual( [1000, "Hello"], close )
-        assertEqual( "closed", driver().getState() )
-      }})
-
-      it("parses unmasked multibyte text frames", function() { with(this) {
-        driver().parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
-        assertEqual( "Apple = ", message )
-      }})
-
-      it("parses frames received in several packets", function() { with(this) {
-        driver().parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c])
-        driver().parse([0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
-        assertEqual( "Apple = ", message )
-      }})
-
-      it("parses fragmented multibyte text frames", function() { with(this) {
-        driver().parse([0x01, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3])
-        driver().parse([0x80, 0x01, 0xbf])
-        assertEqual( "Apple = ", message )
-      }})
-
-      it("parse masked multibyte text frames", function() { with(this) {
-        driver().parse([0x81, 0x8b])
-        driver().parse(mask())
-        driver().parse(maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]))
-        assertEqual( "Apple = ", message )
-      }})
-
-      it("parses masked fragmented multibyte text frames", function() { with(this) {
-        driver().parse([0x01, 0x8a])
-        driver().parse(mask())
-        driver().parse(maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3]))
-
-        driver().parse([0x80, 0x81])
-        driver().parse(mask())
-        driver().parse(maskMessage([0xbf]))
-
-        assertEqual( "Apple = ", message )
-      }})
-
-      it("parses unmasked medium-length text frames", function() { with(this) {
-        driver().parse([0x81, 0x7e, 0x00, 0xc8])
-        var i = 40, result = ""
-        while (i--) {
-          driver().parse([0x48, 0x65, 0x6c, 0x6c, 0x6f])
-          result += "Hello"
-        }
-        assertEqual( result, message )
-      }})
-
-      it("returns an error for too-large frames", function() { with(this) {
-        driver().parse([0x81, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00])
-        assertEqual( "WebSocket frame length too large", error.message )
-        assertEqual( [1009, "WebSocket frame length too large"], close )
-        assertEqual( "closed", driver().getState() )
-      }})
-
-      it("parses masked medium-length text frames", function() { with(this) {
-        driver().parse([0x81, 0xfe, 0x00, 0xc8])
-        driver().parse(mask())
-        var i = 40, result = "", packet = []
-        while (i--) {
-          packet = packet.concat([0x48, 0x65, 0x6c, 0x6c, 0x6f])
-          result += "Hello"
-        }
-        driver().parse(maskMessage(packet))
-        assertEqual( result, message )
-      }})
-
-      it("replies to pings with a pong", function() { with(this) {
-        driver().parse([0x89, 0x04, 0x4f, 0x48, 0x41, 0x49])
-        assertEqual( [0x8a, 0x04, 0x4f, 0x48, 0x41, 0x49], collector().bytes )
-      }})
-    }})
-
-    describe("frame", function() { with(this) {
-      it("formats the given string as a WebSocket frame", function() { with(this) {
-        driver().frame("Hello")
-        assertEqual( [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes )
-      }})
-
-      it("formats a byte array as a binary WebSocket frame", function() { with(this) {
-        driver().frame([0x48, 0x65, 0x6c])
-        assertEqual( [0x82, 0x03, 0x48, 0x65, 0x6c], collector().bytes )
-      }})
-
-      it("encodes multibyte characters correctly", function() { with(this) {
-        driver().frame("Apple = ")
-        assertEqual( [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf], collector().bytes )
-      }})
-
-      it("encodes medium-length strings using extra length bytes", function() { with(this) {
-        var i = 40, frame = [0x81, 0x7e, 0x00, 0xc8], string = ""
-        while (i--) {
-          string += "Hello"
-          frame = frame.concat([0x48, 0x65, 0x6c, 0x6c, 0x6f])
-        }
-        driver().frame(string)
-        assertEqual( frame, collector(). bytes )
-      }})
-
-      it("encodes close frames with an error code", function() { with(this) {
-        driver().frame("Hello", "close", 1002)
-        assertEqual( [0x88, 0x07, 0x03, 0xea, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes )
-      }})
-
-      it("encodes pong frames", function() { with(this) {
-        driver().frame("", "pong")
-        assertEqual( [0x8a, 0x00], collector().bytes )
-      }})
-    }})
-
-    describe("ping", function() { with(this) {
-      it("writes a ping frame to the socket", function() { with(this) {
-        driver().ping("mic check")
-        assertEqual( [0x89, 0x09, 0x6d, 0x69, 0x63, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b], collector().bytes )
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().ping() )
-      }})
-
-      it("runs the given callback on mathing pong", function() { with(this) {
-        var reply = null
-        driver().ping("Hi", function() { reply = true })
-        driver().parse([0x8a, 0x02, 72, 105])
-        assert( reply )
-      }})
-
-      it("does not run the callback on non-matching pong", function() { with(this) {
-        var reply = null
-        driver().ping("Hi", function() { reply = true })
-        driver().parse([0x8a, 0x03, 119, 97, 116])
-        assert( !reply )
-      }})
-    }})
-
-    describe("close", function() { with(this) {
-      it("writes a close frame to the socket", function() { with(this) {
-        driver().close("<%= reasons %>", 1003)
-        assertEqual( [0x88, 0x10, 0x03, 0xeb, 0x3c, 0x25, 0x3d, 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x20, 0x25, 0x3e], collector().bytes )
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().close() )
-      }})
-
-      it("does not trigger the close event", function() { with(this) {
-        driver().close()
-        assertEqual( false, close )
-      }})
-
-      it("does not trigger the onerror event", function() { with(this) {
-        driver().close()
-        assertEqual( false, error )
-      }})
-
-      it("changes the state to closing", function() { with(this) {
-        driver().close()
-        assertEqual( "closing", driver().getState() )
-      }})
-    }})
-  }})
-
-  describe("when masking is required", function() { with(this) {
-    before(function() {
-      this.options().requireMasking = true
-      this.driver().start()
-    })
-
-    it("does not emit a message", function() { with(this) {
-      driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-      assertEqual( "", message )
-    }})
-
-    it("returns an error", function() { with(this) {
-      driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-      assertEqual( "Received unmasked frame but masking is required", error.message )
-      assertEqual( [1003, "Received unmasked frame but masking is required"], close )
-    }})
-  }})
-
-  describe("in the closing state", function() { with(this) {
-    before(function() {
-      this.driver().start()
-      this.driver().close()
-    })
-
-    describe("frame", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().frame("dropped")
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().frame("wut") )
-      }})
-    }})
-
-    describe("ping", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().ping()
-      }})
-
-      it("returns false", function() { with(this) {
-        assertEqual( false, driver().ping() )
-      }})
-    }})
-
-    describe("close", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().close()
-      }})
-
-      it("returns false", function() { with(this) {
-        assertEqual( false, driver().close() )
-      }})
-    }})
-
-    describe("receiving a close frame", function() { with(this) {
-      before(function() {
-        this.driver().parse([0x88, 0x04, 0x03, 0xe9, 0x4f, 0x4b])
-      })
-
-      it("triggers the onclose event", function() { with(this) {
-        assertEqual( [1001, "OK"], close )
-      }})
-
-      it("changes the state to closed", function() { with(this) {
-        assertEqual( "closed", driver().getState() )
-      }})
-    }})
-  }})
-
-  describe("in the closed state", function() { with(this) {
-    before(function() {
-      this.driver().start()
-      this.driver().close()
-      this.driver().parse([0x88, 0x02, 0x03, 0xea])
-    })
-
-    describe("frame", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().frame("dropped")
-      }})
-
-      it("returns false", function() { with(this) {
-        assertEqual( false, driver().frame("wut") )
-      }})
-    }})
-
-    describe("ping", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().ping()
-      }})
-
-      it("returns false", function() { with(this) {
-        assertEqual( false, driver().ping() )
-      }})
-    }})
-
-    describe("close", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().close()
-      }})
-
-      it("returns false", function() { with(this) {
-        assertEqual( false, driver().close() )
-      }})
-
-      it("leaves the state as closed", function() { with(this) {
-        driver().close()
-        assertEqual( "closed", driver().getState() )
-      }})
-    }})
-  }})
-}})
Author	SHA1	Message	Date
James Coglan	c68b3fdc46	Remove the websocket-driver submodule.	2013-05-04 20:45:26 +01:00
James Coglan	827af89809	Refer to 3rd 'upgrade' argument as 'body' instead of 'head'.	2013-05-04 17:37:53 +01:00
James Coglan	0d503a31e3	Return a normal HTTP response if the request is not a WebSocket in the documentation.	2013-05-04 17:33:57 +01:00
James Coglan	99fa7a57ca	Various bits of stream-related refactoring.	2013-05-04 17:30:07 +01:00
James Coglan	b0b39b8325	websocket-protocol is now websocket-driver.	2013-05-04 16:43:03 +01:00
James Coglan	77ee71c678	A few updates to the readme.	2013-05-04 15:09:45 +01:00
James Coglan	fc759a66e9	s/this/self/ because otherwise error dispatching doesn't work.	2013-05-02 01:26:16 +01:00
James Coglan	459499d6d6	Expose parser error events to the user.	2013-05-02 00:12:56 +01:00
James Coglan	30d3eda575	Don't return anything from EventTarget methods.	2013-05-01 09:07:55 +01:00
James Coglan	699c023286	Turn EventTarget into a proxy to EventEmitter since classes are now Streams.	2013-05-01 08:57:53 +01:00
James Coglan	9ff5d28799	Implement EventSource as a writable stream.	2013-05-01 08:50:27 +01:00
James Coglan	43bd4dceb3	Change port used for tests.	2013-05-01 01:14:51 +01:00
James Coglan	971968be85	Rename supportedProtos to protocols.	2013-05-01 01:03:27 +01:00
James Coglan	2a2b7dfb11	Bump websocket-protocol.	2013-05-01 01:00:14 +01:00
James Coglan	83925f68d3	The protocol library now uses a version property instead of a getVersion() method.	2013-05-01 00:56:23 +01:00
James Coglan	ee3212fada	Implement the read/write stream interface on the API class.	2013-05-01 00:32:14 +01:00
James Coglan	789759bf07	Move most WebSocket logic into the API class so that the server and client classes just deal with getting a parser and setting up an IO stream.	2013-05-01 00:14:05 +01:00
James Coglan	3baa12600a	Write the request body to the IO stream before piping the request socket in.	2013-04-30 23:48:11 +01:00
James Coglan	339cc7ad1c	Bump websocket-protocol module and support legacy stream interface.	2013-04-30 23:36:54 +01:00
James Coglan	fdd5cc6db2	Migrate to new protocol event API.	2013-04-30 09:07:06 +01:00
James Coglan	36d4e053d8	Bump the websocket-protocol submodule.	2013-04-29 22:35:28 +01:00
James Coglan	347e5df9a2	Bump the websocket-protocol submodule.	2013-04-29 21:51:58 +01:00
James Coglan	96d31cf694	Remove the hixie protocol handlers, they're now in websocket-protocol.	2013-04-29 21:45:03 +01:00
James Coglan	4ccd6f5a59	Bump the websocket-protocol submodule.	2013-04-29 21:36:46 +01:00
James Coglan	56f9b8ec4d	Write the head to the handler so that draft-76 works.	2013-04-29 20:47:03 +01:00
James Coglan	217b32c383	Bump the websocket-protocol submodule.	2013-04-29 20:28:05 +01:00
James Coglan	6571e070a0	Remove some unneeded test code.	2013-04-29 19:08:38 +01:00
James Coglan	7e5d85278d	Fix TCP error-catching. We should probably fix this in websocket-protocol instead, maybe.	2013-04-29 00:59:42 +01:00
James Coglan	178b2eebde	Reinstate the exported Client.	2013-04-29 00:46:16 +01:00
James Coglan	e6dd7b0749	Remove old Hybi parsers and update websocket-protocol submodule.	2013-04-29 00:20:01 +01:00
James Coglan	ad4ca36a8c	Move protocol handlers into a submodule.	2013-04-28 19:08:10 +01:00