vulcan 0.0.1 → 0.0.2

data/server/node_modules/connect-form/support/connect/lib/connect/middleware/lint.js

@@ -0,0 +1,136 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('./../index'),
+    sys = require('sys');
+
+/**
+ * Output the given warning message.
+ *
+ * @param  {String} msg
+ * @api private
+ */
+
+function warn(msg) {
+    sys.error('Warning: ' + msg);
+}
+
+/**
+ * Setup lint for the given `server`.
+ *
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function lint(server){
+
+    // Ensure a server is passed
+    if (!server) {
+        throw new Error('lint "server" must be passed.');
+    }
+
+    // Warn unless in development mode
+    if (process.connectEnv.name !== 'development') {
+        warn('"lint" middleware should never be enabled outside of the development environment');
+    }
+
+    // Check the stack
+    checkStack(server.stack);
+
+    // Do nothing
+    return function(req, res, next){
+        next();
+    }
+};
+
+/**
+ * Validate middleware in the stack.
+ *
+ * @param  {Array} stack
+ * @api private
+ */
+
+function checkStack(stack) {
+    var layers = [];
+    stack.forEach(function(layer, i){
+        if (layer.name !== 'lint') {
+            var handle = layer.handle,
+                handleParams = params(handle),
+                handleBody = contents(handle);
+
+            function warn(msg) {
+                layers[i] = layer;
+                sys.error('Warning: layer \x1B[1m' + layer.handle.name
+                    + '\x1B[0m:' + i + ' '
+                    + msg.replace(/\{(.*?)\}/g, '\x1B[1m$1\x1B[0m'));
+            }
+
+            // Param names
+
+            if (handleParams[0] !== 'req' &&
+                handleParams[0] !== 'request') {
+                warn('First parameter should be named {req} or {request}, but is {' + handleParams[0] + '}');
+            }
+            if (handleParams[1] !== 'res' &&
+                handleParams[1] !== 'response') {
+                warn('Second parameter should be named {res} or {response}, but is {' + handleParams[1] + '}');
+            }
+            if (handleParams[2] !== 'next') {
+                warn('Third parameter should be named {next}, but is {' + handleParams[2] + '}');
+            }
+
+            // Respond or call next()
+
+            if (handleBody.indexOf('next(') === -1 &&
+                handleBody.indexOf('writeHead') === -1) {
+                warn('Does not seem to call {next()}, or respond to the request');
+            }
+
+            // Check for request headers gotcha
+
+            if (/req(uest)?\.headers\[("|')[A-Z]/.test(handleBody)) {
+                 warn('Request headers are {lowercased}, seems to be accessed with {capitals}');
+            }
+        }
+    });
+
+    // Output potentially problematic handlers
+    layers.forEach(function(layer, i){
+        var str = layer.handle.toString(),
+            indents = str.match(/( *)\}$/)[1].length;
+        str = str.replace(new RegExp('^ {0,' + indents + '}', 'gm'), '    ');
+        sys.puts('\n' + i + ') \x1B[1m' + layer.handle.name + '\x1B[0m:', str);
+    });
+}
+
+/**
+ * Return the function body as a string.
+ *
+ * @param  {Function} fn
+ * @return {String}
+ * @api private
+ */
+
+function contents(fn){
+    return fn.toString().match(/^[^\{]*{((.*\n*)*)}/m)[1];
+}
+
+/**
+ * Return array of function parameter names.
+ *
+ * @param  {Function} fn
+ * @return {String}
+ * @api private
+ */
+
+function params(fn){
+    return fn.toString().match(/\((.*?)\)/)[1].match(/[\w]+/g) || [];
+}

data/server/node_modules/connect-form/support/connect/lib/connect/middleware/logger.js

@@ -0,0 +1,107 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Log requests with the given `options`.
+ *
+ * Options:
+ *
+ *   - `format`  Format string, see below for tokens
+ *   - `stream`  Output stream, defaults to _stdout_
+ *
+ * Tokens:
+ *
+ *   - `:req[header]` ex: `:req[Accept]`
+ *   - `:res[header]` ex: `:res[Content-Length]`
+ *   - `:http-version`
+ *   - `:response-time`
+ *   - `:remote-addr`
+ *   - `:date`
+ *   - `:method`
+ *   - `:url`
+ *   - `:referrer`
+ *   - `:user-agent`
+ *   - `:status`
+ *
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function logger(options) {
+    options = options || {};
+
+    var fmt = process.connectEnv.logFormat || options.format,
+        stream = options.stream || process.stdout;
+
+    return function logger(req, res, next) {
+        var start = +new Date,
+            statusCode,
+            resHeaders,
+            writeHead = res.writeHead,
+            end = res.end,
+            url = req.url;
+
+        // Proxy for statusCode.
+        res.writeHead = function(code, headers){
+            res.writeHead = writeHead;
+            res.writeHead(code, headers);
+            res.statusCode = statusCode = code;
+            res.headers = resHeaders = headers;
+        };
+
+        // Proxy end to output a line to the provided logger.
+        if (fmt) {
+            res.end = function(chunk, encoding) {
+                res.end = end;
+                res.end(chunk, encoding);
+                res.responseTime = +new Date - start;
+                stream.write(format(fmt, req, res) + '\n', 'ascii');
+            };
+        } else {
+            res.end = function(chunk, encoding) {
+                res.end = end;
+                res.end(chunk, encoding);
+
+                stream.write((req.socket && req.socket.remoteAddress)
+                 + ' - - [' + (new Date).toUTCString() + ']'
+                 + ' "' + req.method + ' ' + url
+                 + ' HTTP/' + req.httpVersionMajor + '.' + req.httpVersionMinor + '" '
+                 + statusCode + ' ' + (resHeaders['Content-Length'] || '-')
+                 + ' "' + (req.headers['referer'] || req.headers['referrer'] || '')
+                 + '" "' + (req.headers['user-agent'] || '') + '"\n', 'ascii');
+            };
+        }
+
+        // Fall through to the next layer.
+        next();
+    };
+
+};
+
+/**
+ * Return formatted log line.
+ *
+ * @param  {String} str
+ * @param  {IncomingMessage} req
+ * @param  {ServerResponse} res
+ * @return {String}
+ * @api private
+ */
+function format(str, req, res) {
+    return str
+        .replace(':url', req.url)
+        .replace(':method', req.method)
+        .replace(':status', res.statusCode)
+        .replace(':response-time', res.responseTime)
+        .replace(':date', new Date().toUTCString())
+        .replace(':referrer', req.headers['referer'] || req.headers['referrer'] || '')
+        .replace(':http-version', req.httpVersionMajor + '.' + req.httpVersionMinor)
+        .replace(':remote-addr', req.socket && req.socket.remoteAddress)
+        .replace(':user-agent', req.headers['user-agent'] || '')
+        .replace(/:req\[([^\]]+)\]/g, function(_, header){ return req.headers[header]; })
+        .replace(/:res\[([^\]]+)\]/g, function(_, header){ return res.headers[header]; });
+}

data/server/node_modules/connect-form/support/connect/lib/connect/middleware/methodOverride.js

@@ -0,0 +1,54 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var queryString = require('querystring');
+
+/**
+ * Valid http methods.
+ *
+ * @type Array
+ */
+
+var methods = ['GET', 'POST', 'PUT', 'HEAD', 'DELETE', 'OPTIONS'];
+
+/**
+ * Pass an optional `key` to use when checking for
+ * a method override, othewise defaults to __method_.
+ *
+ * @param {String} key
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function methodOverride(key){
+    key = key || "_method";
+    return function methodOverride(req, res, next) {
+        var method = req.method;
+
+        // Check req.body (bodyDecoder)
+        if (typeof req.body === 'object' && key in req.body) {
+            method = req.body[key];
+            delete req.body[key];
+        // Check X-HTTP-Method-Override
+        } else if (req.headers['x-http-method-override']) {
+            method = req.headers['x-http-method-override'];
+        }
+
+        // Ensure method is valid, and normalize
+        method = method.toUpperCase();
+        if (methods.indexOf(method) >= 0) {
+            req.method = method;
+        }
+        
+        next();
+    };
+};
+

data/server/node_modules/connect-form/support/connect/lib/connect/middleware/pubsub.js

@@ -0,0 +1,107 @@
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var sys = require('sys');
+
+/**
+ * Subscriber cache.
+ */
+
+var cache = {};
+
+/**
+ * Initialize subscriber with the given request / response objects.
+ *
+ * @param  {ServerRequest} req
+ * @param  {ServerResponse} res
+ * @api private
+ */
+
+function Subscriber(req, res) {
+    var id = req.socket.remoteAddress + req.socket.remotePort;
+    var me = this;
+    if (cache[id]) {
+        me = cache[id];
+    } else {
+        cache[id] = me;
+    }
+    me.req = req;
+    me.res = res;
+    me.queue = me.queue || [];
+    me.flush();
+    if (me !== this) {
+        return me;
+    }
+}
+
+Subscriber.prototype = {
+
+    /**
+     * Send the given message string.
+     *
+     * @param  {String} message
+     * @api private
+     */
+
+    send: function send(message) {
+        // Send as an array so we can later batch messages.
+        this.queue.push(message);
+        this.flush();
+    },
+
+    /**
+     * Flush the message queue.
+     *
+     * @api private
+     */
+
+    flush: function flush() {
+        if (this.res && this.queue.length > 0) {
+            this.res.simpleBody(200, this.queue);
+            this.res = null;
+            this.queue.length = 0;
+        }
+    }
+};
+
+module.exports = function pubsub(logic) {
+
+    if (typeof logic.subscribe !== 'function'
+        || typeof logic.unsubscribe !== 'function'
+        || typeof logic.publish !== 'function') {
+        throw new Error("Pubsub provider is missing a function, requires 'subscribe', 'unsubscribe', and 'publish'");
+    }
+
+    return function pubsub(req, res, next) {
+        if (req.method === "GET") {
+            logic.subscribe(new Subscriber(req, res));
+            return;
+        }
+        if (req.method === "POST") {
+            function callback(err, result) {
+                if (err) {
+                    next(err);
+                    return;
+                }
+                res.simpleBody(200, result || req.body);
+            }
+            try {
+                var result = logic.publish(req.body, callback);
+                if (result !== undefined) {
+                    callback(null, result);
+                }
+            } catch (err) {
+                next(err);
+            }
+            return;
+        }
+        next();
+    }
+};

data/server/node_modules/connect-form/support/connect/lib/connect/middleware/repl.js

@@ -0,0 +1,43 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var net = require('net'),
+    repl = require('repl');
+
+/**
+ * Start a **REPL** on the given unix domain `socket` path.
+ *
+ * Options:
+ *
+ *    - `sockect`     Unix domain socket path. Defaults to "/tmp/connect.sock"
+ *    - `prompt`      **REPL** prompt string. Defaults to "node> "
+ *
+ * Example:
+ *
+ *     $ rlwrap telnet /tmp/connect.sock
+ *
+ * @param {String} prompt
+ * @param {String} socket path
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function repl(prompt, socket){
+    prompt = process.connectEnv.replPrompt || prompt || 'node> ';
+    socket = process.connectEnv.replSocket || socket || '/tmp/connect.sock';
+    net.createServer(function (stream) {
+        repl.start(prompt, stream);
+    }).listen(socket);
+    return function repl(req, res, next){
+        // Pass through for now
+        next();
+    }
+};