coffeecake 0.0.1

data/node_modules/jasmine-runner/node_modules/webworker/.gitignore

@@ -0,0 +1,2 @@
+README.html
+docs/design.html

data/node_modules/jasmine-runner/node_modules/webworker/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2010, Peter Griess <pg@std.in>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+
+    * Neither the name of node-webworkers nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/node_modules/jasmine-runner/node_modules/webworker/Makefile

@@ -0,0 +1,15 @@
+# Simple makefile is simple. See README.md.
+
+INSTALL_DIR ?= /opt/local/share/node
+
+.PHONY: test install
+
+test:
+	for f in `ls ./test/test-*.js` ; do \
+		node $$f ; \
+	done
+
+install:
+	install -m 755 -d $(INSTALL_DIR)
+	install -m 444 lib/webworker.js lib/webworker-util.js \
+		lib/webworker-child.js $(INSTALL_DIR)

data/node_modules/jasmine-runner/node_modules/webworker/README.md

@@ -0,0 +1,74 @@
+`node-webworkers` is an implementation of the [Web Workers
+API](http://www.whatwg.org/specs/web-workers/current-work/) for
+[node.js](http://nodejs.org).
+
+See the design document
+[here](http://blog.std.in/2010/07/08/nodejs-webworker-design/).
+
+### Example
+
+#### Master source
+
+    var sys = require('sys');
+    var Worker = require('webworker').Worker;
+    
+    var w = new Worker('foo.js');
+    
+    w.onmessage = function(e) {
+        sys.debug('Received mesage: ' + sys.inspect(e));
+        w.terminate();
+    };
+    
+    w.postMessage({ foo : 'bar' });
+
+#### Worker source
+
+    onmessage = function(e) {
+        postMessage({ test : 'this is a test' });
+    };
+    
+    onclose = function() {
+        sys.debug('Worker shuttting down.');
+    };
+
+### API
+
+Supported API methods are
+
+   * `postMessage(e)` in both workers and the parent; messages are in the
+     parent if this is invoked before the child is fully initialized
+   * `onmessage(e)` in both workers and the parent
+   * `onerror(e)`in both workers and the parent
+   * `terminate()` in the parent
+
+In addition, some nonstandard APIs are provided
+
+   * `onclose()` in the worker (allows for graceful shutdown)
+   * The `postMessage()` method takes an additional optional file descriptor parameter, which
+     will be sent with the message. This descriptor will be passed to
+     `onmessage` handlers as an optional `fd` field. Handlers receiving
+     messages posted without file descriptors will not see an `fd` field. Both
+     the parent and child can send file descriptors using this mechanism.
+   * `Worker.onexit(code, signal)` in the master, which is invoked on the
+     master `Worker` object when the worker process exits.
+   * The `Worker` constructor takes an additional optional object argument,
+     `opts`, which is used as a dictionary of options with the following keys
+      * `args` : A string or array of strings to pass to the executable before the filename to invoke. This can be used to request that the worker start up in debug mode (e.g. `{ 'args' : '--debug-brk' }`). By default this is empty.
+      * `path` : A string naming the executable to invoke for workers. By default this is the value of `process.execPath` (e.g. `node` or similar).
+
+### Installation
+
+This package can be installed via [npm](http://npmjs.org/) as follows
+
+    % npm install websocket
+
+Note that this requires
+[node-websocket-client](http://github.com/pgriess/node-websocket-client) v0.9.3
+or later. This dependency will be handled automatically by `npm`, but must be
+dealt with manually if installing using another procedure.
+
+### Credits
+
+This package contains a static snapshot of Micheil Smith's excellent
+[node-websocket-server](http://github.com/miksago/node-websocket-server) with
+some fixes applied to handle UNIX sockets.

data/node_modules/jasmine-runner/node_modules/webworker/docs/design.md

@@ -0,0 +1,103 @@
+## Overview and Motivation
+
+`node-webworkers` aims to implement as much of the [HTML5 Web
+Workers](http://www.whatwg.org/specs/web-workers/current-work/) API as is
+practical and useful in the context of NodeJS. Extensions to the HTML5 API
+are provided where it makes sense (e.g. to allow file descriptor passing).
+
+The motivation for providing this API to NodeJS is as follows
+
+*   A set of standard (well, emerging standard anyway) platform-independency
+    concurrency APIs is a useful abstraction. Particularly as HTML5 gains
+    wider adoption and JavaScript developers are likely to familiar with Web
+    Workers from doing browser development. The set of Node.JS primitives
+    for managing processes, `child_process` provides a lot of utility, but
+    is easily misunderstood by developers who have not developed for a UNIX
+    platofrm before (e.g. "why does `kill()` not kill my process?").
+    
+    In addition, the error reporting APIs in the Web Workers spec are more
+    full-featured and JavaScript-specific than that provided natively by
+    `child_process` (e.g. one can get a stack trace, etc).
+
+*   Existing communicaiton mechanisms with child processes involve
+    communicating over `stdin`/`stdout`. These are opaque byte streams and
+    require the application to implement their own framing logic to discern
+    message boundaries. Further, use of these built-in streams prevents
+    `sys.puts()` and friends from working.
+
+*   [Shared Workers](http://dev.w3.org/html5/workers/#shared-workers-and-the-sharedworker-interface)
+    provide a useful naming service for communicating with other workers by
+    name. Without this, the application must maintain its own routing
+    structure.
+    
+    Note that shared workers are *not* implemented yet.
+
+## Design
+
+The design that follows for Web Workers is motivated by a handful of
+underlying assumptions / philosophies:
+
+*   Worker instances should be relatively long-lived. That is, it is not
+    considered an important workload to be able to create and destroy
+    thousands of workers as quickly as possible. Passing messages to
+    existing workers to dispatch work items is favored over creating a new
+    worker for each work item.
+    
+*   In the future, it will be desirable to run workers off-box, and to
+    implement workers in other application frameworks / languages. This is
+    particularly relevant in the choice of communication medium.
+
+In addition, there is a general preference to embracing standards and
+existing building blocks, particularly those that are geared towards
+JavaScript and/or HTTP.
+
+### Worker Processes
+
+Each worker executes in its own self-contained `node` process rather than as
+a separate thread and V8 context within the master process.
+
+Benefits of this approach include fault isolation (any worker running out of
+memory or triggering some buggy C++ code will not take down other workers);
+avoiding the complexity of managing multiple event loops in a single
+process; and typical OSes are more likely to schedule different processes on
+different CPUs (this may not always happen for multiple threads within the
+same process), allowing the application to utilize multiple CPUs.
+
+Drawbkacks include the cost of context switching between workers being more
+expensive when using a process-per-worker model than it would be in a
+thread-per-worker model; passing messages between processes typically
+requires a data copy and always requires serializing data; and overhead of
+spawning a new process.
+
+### Worker Context
+
+Each worker is launched by `webworker-child.js`.
+
+This script is passed to `node` as the entry point for the process and is
+responsible for constructing a V8 script context populated with bits
+relevant to the Web Worker API (e.g. the `postMessage()`, `close()` and
+`location` primitives, etc).
+
+### Inter-worker Communication
+
+The Web Workers spec provides a simple message passing API.
+
+Under the covers, this is implemented by connecting each dedicated worker to
+its parent process with a UNIX domain socket. This is lower overhead than
+TCP, and allows for UNIX goodies like file descriptor passing.
+
+Message passing is done over this UNIX socket by negotiating an HTML5 Web
+Socket connection over this transport. This is done to provide a
+reasonably-performant standards-based message framing implementation and to
+lay the groundwork or communicating with off-box workers via HTTP over TCP,
+which may be implemented in another application stack entirely (e.g. Java,
+etc). The overhead of negotiating and maintaining the Web Socket connection
+is 1 round trip for handshaking and the overhead of maintaining HTTP state
+objects (`http_parser` and such). The handshaking overhead is not considered
+an undue burden given that workers are expected to be relatively long-lived
+and the HTTP state overhead considered small.
+
+The format of the messages themselves is JSON, serialized using
+`JSON.stringify()` and de-serialized using `JSON.parse()`. Significantly,
+the use of a framing protocol allows the Web Workers implementation to wait
+for an entire, complete JSON blob to arrive before invoking `JSON.parse()`.

data/node_modules/jasmine-runner/node_modules/webworker/examples/prefork/README.md

@@ -0,0 +1 @@
+An example of using Web Workers to implement a preforking HTTP server.

data/node_modules/jasmine-runner/node_modules/webworker/examples/prefork/master.js

@@ -0,0 +1,12 @@
+var path = require('path');
+var netBindings = process.binding('net');
+var Worker = require('../lib/webworker').Worker;
+
+var fd = netBindings.socket('tcp4');
+netBindings.bind(fd, 80);
+netBindings.listen(fd, 128);
+
+for (var i = 0; i < 8; i++) {
+    var w = new Worker(path.join(__dirname, 'worker.js'));
+    w.postMessage({ 'banner' : 'Hello, world!' }, fd);
+}

data/node_modules/jasmine-runner/node_modules/webworker/examples/prefork/worker.js

@@ -0,0 +1,20 @@
+var assert = require('assert');
+var http = require('http');
+
+process.setuid('nobody');
+
+var banner = undefined;
+
+var srv = http.createServer(function(req, resp) {
+    resp.writeHead(200, {'Content-Type' : 'text/plain'});
+    resp.write(banner + ' (pid ' + process.pid + ')\n');
+    resp.end();
+});
+
+onmessage = function(msg) {
+    assert.ok(msg.fd && msg.fd > 0);
+
+    banner = msg.data.banner;
+
+    srv.listenFD(msg.fd);
+};

data/node_modules/jasmine-runner/node_modules/webworker/lib/webworker-child.js

@@ -0,0 +1,173 @@
+// Launcher script for WebWorkers.
+//
+// Sets up context and runs a worker script. This is not intended to be
+// invoked directly. Rather, it is invoked automatically when constructing a
+// new Worker() object.
+//
+//      usage: node worker.js <sock> <script>
+//
+//      The <sock> parameter is the filesystem path to a UNIX domain socket
+//      that is listening for connections. The <script> parameter is the
+//      path to the JavaScript source to be executed as the body of the
+//      worker.
+
+var assert = require('assert');
+var fs = require('fs');
+var net = require('net');
+var path = require('path');
+var script = process.binding('evals');
+var sys = require('sys');
+var wwutil = require('./webworker-util');
+var WebSocketServer = require('./ws').WebSocketServer;
+
+try {
+    var WebSocket = require('websocket-client').WebSocket;
+} catch (e) {
+    throw new Error(
+        'pgriess/node-websocket-client must be installed'
+    );
+}
+
+var writeError = process.binding('stdio').writeError;
+
+// Catch exceptions
+//
+// This implements the Runtime Script Errors section fo the Web Workers API
+// specification at
+//
+//  http://www.whatwg.org/specs/web-workers/current-work/#runtime-script-errors
+//
+// XXX: There are all sorts of pieces of the error handling spec that are not
+//      being done correctly. Pick a clause, any clause.
+var inErrorHandler = false;
+var exceptionHandler = function(e) {
+    if (!inErrorHandler && workerCtx.onerror) {
+        inErrorHandler = true;
+        workerCtx.onerror(e);
+        inErrorHandler = false;
+
+        return;
+    }
+
+    // Don't bother setting inErrorHandler here, as we're already delivering
+    // the event to the master anyway
+    ms.send([wwutil.MSGTYPE_ERROR, {
+        'message' : wwutil.getErrorMessage(e),
+        'filename' : wwutil.getErrorFilename(e),
+        'lineno' : wwutil.getErrorLine(e)
+    }]);
+};
+
+// Message handling function for messages from the master
+var handleMessage = function(msg, fd) {
+    if (!wwutil.isValidMessage(msg)) {
+        wwutil.debug('Received invalid message: ' + sys.inspect(msg));
+        return;
+    }
+
+    switch(msg[0]) {
+    case wwutil.MSGTYPE_NOOP:
+        break;
+
+    case wwutil.MSGTYPE_CLOSE:
+        // Conform to the Web Workers API for termination
+        workerCtx.closing = true;
+
+        // Close down the event sources that we know about
+        ws.close();
+
+        // Request that the worker perform any application-level shutdown
+        if (workerCtx.onclose) {
+            workerCtx.onclose();
+        }
+
+        break;
+
+    case wwutil.MSGTYPE_USER:
+        // XXX: I have no idea what the event object here should really look
+        //      like. I do know that it needs a 'data' elements, though.
+        if (workerCtx.onmessage) {
+            e = { data : msg[1] };
+
+            if (fd) {
+                e.fd = fd;
+            }
+
+            workerCtx.onmessage(e);
+        }
+
+        break;
+
+    default:
+        wwutil.debug('Received unexpected message: ' + sys.inspect(msg));
+        break;
+    }
+};
+
+if (process.argv.length < 4) {
+    throw new Error('usage: node worker.js <sock> <script>');
+}
+
+var sockPath = process.argv[2];
+var scriptLoc = new wwutil.WorkerLocation(process.argv[3]);
+
+// Connect to the parent process
+var ws = new WebSocket('ws+unix://' + sockPath);
+var ms = new wwutil.MsgStream(ws);
+
+// Once we connect successfully, set up the rest of the world
+ws.addListener('open', function() {
+    // When we receive a message from the master, react and possibly
+    // dispatch it to the worker context
+    ms.addListener('msg', handleMessage);
+
+    // Register for uncaught events for delivery to workerCtx.onerror
+    process.addListener('uncaughtException', exceptionHandler);
+
+    // Execute the worker
+    scriptObj.runInNewContext(workerCtx);
+});
+
+// Construt the Script object to host the worker's code
+var scriptObj = undefined;
+switch (scriptLoc.protocol) {
+case 'file':
+    scriptObj = new script.Script(
+        fs.readFileSync(scriptLoc.pathname),
+        scriptLoc.href
+    );
+    break;
+
+default:
+    writeError('Cannot load script from unknown protocol \'' + 
+        scriptLoc.protocol);
+    process.exit(1);
+}
+
+// Set up the context for the worker instance
+var workerCtx = {};
+
+// Context elements required for node.js
+//
+// XXX: There must be a better way to do this.
+workerCtx.global = workerCtx;
+workerCtx.process = process;
+workerCtx.require = require;
+workerCtx.console = console;
+workerCtx.__filename = scriptLoc.pathname;
+workerCtx.__dirname = path.dirname(scriptLoc.pathname);
+workerCtx.setTimeout = setTimeout;
+workerCtx.clearTimeout = clearTimeout;
+workerCtx.setInterval = setInterval;
+workerCtx.clearInterval = clearInterval;
+
+// Context elements required by the WebWorkers API spec
+workerCtx.postMessage = function(msg, fd) {
+    ms.send([wwutil.MSGTYPE_USER, msg], fd);
+};
+workerCtx.self = workerCtx;
+workerCtx.location = scriptLoc;
+workerCtx.closing = false;
+workerCtx.close = function() {
+    process.exit(0);
+};

data/node_modules/jasmine-runner/node_modules/webworker/lib/webworker-util.js

@@ -0,0 +1,185 @@
+// Utilies and other common gook shared between the WebWorker master and
+// its constituent Workers.
+
+var events = require('events');
+var path = require('path');
+var sys = require('sys');
+var urllib = require('url');
+
+// Some debugging functions
+var debugLevel = parseInt(process.env.NODE_DEBUG, 16);
+var debug = (debugLevel & 0x8) ?
+    function() { sys.error.apply(this, arguments); } :
+    function() {};
+exports.debug = debug;
+
+// Extract meaning from stack traces
+var STACK_FRAME_RE = /.* \(?(.+:\d+:\d+)\)?$/;
+
+// Symbolic names for our messages types
+exports.MSGTYPE_NOOP = 0;
+exports.MSGTYPE_ERROR = 1;
+exports.MSGTYPE_CLOSE = 2;
+exports.MSGTYPE_USER = 100;
+
+// Is the given message well-formed?
+var isValidMessage = function(msg) {
+    return (Array.isArray(msg) && msg.length == 2);
+}
+exports.isValidMessage = isValidMessage;
+
+// A simple messaging stream.
+//
+// This class is constructed around an existing stream net.Stream. This class
+// emits 'msg' events when a message is received. Each emitted 'msg' event
+// may come with a second 'fd' parameter if the message was sent with  file
+// descriptor. A sent file descriptor is guaranteed to be received with the
+// message with which it was sent.
+//
+// Sending messages is done with the send() method.
+var MsgStream = function(s) {
+    var self = this;
+
+    events.EventEmitter.call(self);
+
+    // Sequence numbers for outgoing and incoming FDs
+    var fds_seqno_sent = 0;
+    var fds_seqno_recvd = 0;
+
+    // Collections of messages waiting for FDs and vice-versa. These
+    // are keyed by FD seqno.
+    var msg_waiting_for_fd = {};
+    var fd_waiting_for_msg = {};
+
+    // Get the JS object representing message 'v' with fd 'fd'.
+    var getMsgObj = function(v, fd) {
+        return [(fd != undefined) ? ++fds_seqno_sent : 0, v];
+    };
+
+    self.send = function(v, fd) {
+        var ms = getMsgObj(v, fd);
+        debug('Process ' + process.pid + ' sending message: ' + sys.inspect(ms));
+
+        s.write(JSON.stringify(ms), fd)
+    };
+
+    s.addListener('message', function(ms) {
+        debug('Process ' + process.pid + ' received message: ' + ms);
+
+        var mo = JSON.parse(ms);
+
+        // Ignore invalid messages; this is probably worth an error, though
+        if (!isValidMessage(mo)) {
+            return;
+        }
+
+        var fd = undefined;
+
+        var fd_seq = mo[0];
+        var msg = mo[1];
+
+        // If our message has an associated file descriptor that we
+        // have not yet received, queue it for later delivery.
+        if (fd_seq) {
+            if (!(fd = fd_waiting_for_msg[fd_seq])) {
+                msg_waiting_for_fd[fd_seq] = msg;
+                return;
+            }
+
+            delete fd_waiting_for_msg[fd_seq];
+        }
+
+        // We're complete; emit
+        self.emit('msg', msg, fd);
+    });
+
+    s.addListener('fd', function(fd) {
+        // Look for a message that's waiting for our arrival. If we don't
+        // have one, enqueu the received FD for later delivery.
+        var msg = msg_waiting_for_fd[++fds_seqno_recvd];
+        if (!msg) {
+            fd_waiting_for_msg[fds_seqno_recvd] = fd;
+            return;
+        }
+
+        // There was a message waiting for us; emit
+        delete msg_waiting_for_fd[fds_seqno_recvd];
+        self.emit('msg', msg, fd);
+    });
+};
+
+sys.inherits(MsgStream, events.EventEmitter);
+exports.MsgStream = MsgStream;
+
+// Implement the WorkerLocation interface described in
+// http://www.whatwg.org/specs/web-workers/current-work/#dom-workerlocation-href
+//
+// XXX: None of these properties are readonly as required by the spec.
+var WorkerLocation = function(url) {
+    var u = urllib.parse(url);
+
+    var portForProto = function(proto) {
+        switch (proto) {
+        case 'http':
+            return 80;
+
+        case 'https':
+            return 443;
+
+        case 'file':
+            return undefined;
+
+        default:
+            sys.debug(
+                'Unknown protocol \'' + proto + '\'; returning undefined'
+            );
+            return undefined;
+        };
+    };
+
+    this.href = u.href;
+    this.protocol = u.protocol.substring(0, u.protocol.length - 1);
+    this.host = u.host;
+    this.hostname = u.hostname;
+    this.port = (u.port) ? u.port : portForProto(this.protocol);
+    this.pathname = (u.pathname) ? path.normalize(u.pathname) : '/';
+    this.search = (u.search) ? u.search : '';
+    this.hash = (u.hash) ? u.hash : '';
+};
+
+exports.WorkerLocation = WorkerLocation;
+
+// Get the error message for a given exception
+//
+// The first line of the stack trace seems to always be the message itself.
+exports.getErrorMessage = function(e) {
+    try {
+        return e.message || e.stack.split('\n')[0].trim();
+    } catch (e) {
+        return 'WebWorkers: failed to get error message';
+    }
+};
+
+// Get the filename for a given exception
+exports.getErrorFilename = function(e) {
+    try {
+        var m = e.stack.split('\n')[1].match(STACK_FRAME_RE);
+        return m[1].substring(
+            0,
+            m[1].lastIndexOf(':', m[1].lastIndexOf(':') - 1)
+        );
+    } catch (e) {
+        return 'WebWorkers: failed to get error filename';
+    }
+};
+
+// Get the line number for a given exception
+exports.getErrorLine = function(e) {
+    try {
+        var m = e.stack.split('\n')[1].match(STACK_FRAME_RE);
+        var parts = m[1].split(':');
+        return parseInt(parts[parts.length - 2]);
+    } catch (e) {
+        return -1;
+    }
+};