vulcan 0.0.1 → 0.0.2

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

@@ -0,0 +1,91 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('./../utils'),
+    sys = require('sys'),
+    fs = require('fs');
+
+/**
+ * Setup error handler with the given `options`.
+ *
+ * Options:
+ *
+ *   - `showStack`       respond with both the error message and stack trace. Defaults to `false`
+ *   - `showMessage`     respond with the exception message only. Defaults to `false`
+ *   - `dumpExceptions`  dump exceptions to stderr (without terminating the process). Defaults to `false`
+ *
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function errorHandler(options){
+    options = options || {};
+
+    // Defaults
+    var showStack = options.showStack,
+        showMessage = options.showMessage,
+        dumpExceptions = options.dumpExceptions;
+
+    // --showErrorStack
+    if (process.connectEnv.showErrorStack !== undefined) {
+        showStack = utils.toBoolean(process.connectEnv.showErrorStack);
+    }
+
+    // --showErrorMessage
+    if (process.connectEnv.showErrorMessage !== undefined) {
+        showMessage = utils.toBoolean(process.connectEnv.showErrorMessage);
+    }
+
+    // --dumpExceptions
+    if (process.connectEnv.dumpExceptions !== undefined) {
+        dumpExceptions = utils.toBoolean(process.connectEnv.dumpExceptions);
+    }
+
+    return function errorHandler(err, req, res, next){
+        if (dumpExceptions) {
+            sys.error(err.stack);
+        }
+        if (showStack) {
+            var accept = req.headers.accept || '';
+            if (accept.indexOf('html') !== -1) {
+                fs.readFile(__dirname + '/../public/style.css', function(e, style){
+                    style = style.toString('ascii');
+                    fs.readFile(__dirname + '/../public/error.html', function(e, html){
+                        var stack = err.stack
+                            .split('\n').slice(1)
+                            .map(function(v){ return '<li>' + v + '</li>'; }).join('');
+                        html = html
+                            .toString('utf8')
+                            .replace('{style}', style)
+                            .replace('{stack}', stack)
+                            .replace(/\{error\}/g, err.toString());
+                        res.writeHead(500, { 'Content-Type': 'text/html' });
+                        res.end(html);
+                    });
+                });
+            } else if (accept.indexOf('json') !== -1) {
+                var json = JSON.stringify({ error: err });
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(json);
+            } else {
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(err.stack);
+            }
+        } else {
+            var body = showMessage
+                ? err.toString()
+                : 'Internal Server Error';
+            res.writeHead(500, { 'Content-Type': 'text/plain' });
+            res.end(body);
+        }
+    };
+};

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

@@ -0,0 +1,46 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var connect = require('./../index'),
+    sys = require('sys');
+
+/**
+ * Extract url "formats" aka extensions from the request
+ * url, and assigns req.`format`.
+ *
+ * Examples:
+ *
+ *      // curl http://localhost:3000/users.json
+ *      handle: function(req, res, next){
+ *         switch (req.format) {
+ *             case 'json':
+ *                 sys.puts(req.url);
+ *                 // => "users"
+ *                 // respond with json
+ *                 break;
+ *             default:
+ *                 // respond with your default format
+ *         }
+ *      }
+ *
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function format(){
+    return function format(req, res, next) {
+        if (/\.(\w+)($|#|\?)/.exec(req.url)) {
+            req.format = RegExp.$1;
+            req.url = req.url.replace('.' + req.format, '');
+        }
+        next();
+    };
+};

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

@@ -0,0 +1,79 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var child_process = require('child_process'),
+    sys = require('sys'),
+    compress = require('compress');
+
+/**
+ * Provides gzip compression via the node-compress library.
+ *
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function gzip(){
+    return function gzip(req, res, next) {
+        var writeHead = res.writeHead,
+            write = res.write,
+            end = res.end;
+
+        res.writeHead = function (code, headers) {
+            var type = headers["Content-Type"],
+                accept = req.headers["accept-encoding"];
+
+            if (!(code === 200 && accept && accept.indexOf('gzip') >= 0
+                  && type && (/(text|javascript|json)/).test(type)
+                  && headers["Content-Encoding"] === undefined)) {
+                res.writeHead = writeHead;
+                res.writeHead(code, headers);
+                return;
+            }
+
+            headers["Content-Encoding"] = "gzip";
+            delete headers["Content-Length"];
+
+            var gzip = new compress.GzipStream();
+
+            res.write = function (chunk, encoding) {
+                gzip.setInputEncoding(encoding);
+                gzip.write(chunk);
+            };
+
+            res.end = function (chunk, encoding) {
+                if (chunk) {
+                    res.write(chunk, encoding);
+                }
+                gzip.close();
+            };
+
+            gzip.addListener('data', function (chunk) {
+                write.call(res, chunk);
+            });
+            gzip.addListener('error', function(err) {
+                res.write = write;
+                res.end = end;
+                next(err);
+            });
+            gzip.addListener('end', function (code) {
+                res.write = write;
+                res.end = end;
+                res.end();
+            });
+
+            res.writeHead = writeHead;
+            res.writeHead(code, headers);
+
+        };
+
+        next();
+    };
+};

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

@@ -0,0 +1,73 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var child_process = require('child_process'),
+    sys = require('sys');
+
+/**
+ * Provides gzip compression via the `gzip` executable.
+ *
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function gzip(){
+    return function gzip(req, res, next) {
+        var writeHead = res.writeHead,
+            write = res.write,
+            end = res.end;
+
+        res.writeHead = function (code, headers) {
+            var type = headers["Content-Type"],
+                accept = req.headers["accept-encoding"];
+
+            if (!(code === 200 && accept && accept.indexOf('gzip') >= 0
+                  && type && (/(text|javascript|json)/).test(type)
+                  && headers["Content-Encoding"] === undefined)) {
+                res.writeHead = writeHead;
+                res.writeHead(code, headers);
+                return;
+            }
+
+            headers["Content-Encoding"] = "gzip";
+            delete headers["Content-Length"];
+
+            var gzip = child_process.spawn("gzip", ["-9"]);
+
+            res.write = function (chunk, encoding) {
+                gzip.stdin.write(chunk, encoding);
+            };
+
+            res.end = function (chunk, encoding) {
+                if (chunk) {
+                    res.write(chunk, encoding);
+                }
+                gzip.stdin.end();
+            };
+
+            gzip.stdout.addListener('data', function (chunk) {
+                write.call(res, chunk);
+            });
+
+            gzip.addListener("exit", function (code) {
+                res.write = write;
+                res.end = end;
+                res.end();
+            });
+
+            res.writeHead = writeHead;
+            res.writeHead(code, headers);
+
+        };
+
+        next();
+    };
+};

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

@@ -0,0 +1,8 @@
+try {
+    module.exports = require('./gzip-compress');
+} catch (e) {
+    if (/^Cannot find module /.test(e.message))
+        module.exports = require('./gzip-proc');
+    else
+        throw e;
+}

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

@@ -0,0 +1,235 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var sys = require('sys'),
+    parse = require('url').parse,
+    Buffer = require('buffer').Buffer,
+    http = require('http');
+
+/**
+ * Export the `setup()` function.
+ */
+
+exports = module.exports = jsonrpc;
+
+/**
+ * JSON-RPC version.
+ */
+
+var VERSION = exports.VERSION = '2.0';
+
+/**
+ * JSON parse error.
+ */
+
+var PARSE_ERROR = exports.PARSE_ERROR = -32700;
+
+/**
+ * Invalid request due to invalid or missing properties.
+ */
+
+var INVALID_REQUEST = exports.INVALID_REQUEST = -32600;
+
+/**
+ * Service method does not exist.
+ */
+
+var METHOD_NOT_FOUND = exports.METHOD_NOT_FOUND = -32601;
+
+/**
+ * Invalid parameters.
+ */
+
+var INVALID_PARAMS = exports.INVALID_PARAMS = -32602;
+
+/**
+ * Internal JSON-RPC error.
+ */
+
+var INTERNAL_ERROR = exports.INTERNAL_ERROR = -32603;
+
+/**
+ * Default error messages.
+ */
+
+var errorMessages = exports.errorMessages = {};
+errorMessages[PARSE_ERROR] = 'Parse Error.';
+errorMessages[INVALID_REQUEST] = 'Invalid Request.';
+errorMessages[METHOD_NOT_FOUND] = 'Method Not Found.';
+errorMessages[INVALID_PARAMS] = 'Invalid Params.';
+errorMessages[INTERNAL_ERROR] = 'Internal Error.';
+
+/**
+ * Accepts any number of objects, exposing their methods.
+ *
+ * @param {Object} ...
+ * @return {Function}
+ * @api public
+ */
+
+function jsonrpc(services) {
+    services = services || {};
+
+    // Merge methods
+    for (var i = 0, len = arguments.length; i < len; ++i) {
+        arguments[i].forEach(function(val, key){
+            services[key] = val;
+        });
+    }
+
+    /**
+     * Handle JSON-RPC request.
+     *
+     * @param  {Object} rpc
+     * @param  {Function} respond
+     */
+
+    function handleRequest(rpc, respond){
+        if (validRequest(rpc)) {
+            var method = services[rpc.method];
+            if (typeof method === 'function') {
+                var params = [];
+                if (rpc.params instanceof Array) {
+                    params = rpc.params;
+                } else if (typeof rpc.params === 'object') {
+                    var names = method.toString().match(/\((.*?)\)/)[1].match(/[\w]+/g);
+                    if (names) {
+                        for (var i = 0, len = names.length; i < len; ++i) {
+                            params.push(rpc.params[names[i]]);
+                        }
+                    } else {
+                        // Function does not have named parameters
+                        return respond({ error: { code: INVALID_PARAMS, message: 'This service does not support named parameters.' }});
+                    }
+                }
+                function reply(err, result){
+                    if (err) {
+                        if (typeof err === 'number') {
+                            respond({
+                                error: {
+                                    code: err
+                                }
+                            });
+                        } else {
+                            respond({
+                                error: {
+                                    code: err.code || INTERNAL_ERROR,
+                                    message: err.message
+                                }
+                            });
+                        }
+                    } else {
+                        respond({
+                            result: result
+                        });
+                    }
+                }
+                method.apply(reply, params);
+            } else {
+                respond({ error: { code: METHOD_NOT_FOUND }});
+            }
+        } else {
+            respond({ error: { code: INVALID_REQUEST }});
+        }
+    }
+
+    return function jsonrpc(req, res, next) {
+        var me = this,
+            contentType = req.headers['content-type'] || '';
+        if (req.method === 'POST' && contentType.indexOf('application/json') >= 0) {
+            var data = '';
+            req.setEncoding('utf8');
+            req.addListener('data', function(chunk) { data += chunk; });
+            req.addListener('end', function() {
+
+                // Attempt to parse incoming JSON string
+
+                try {
+                    var rpc = JSON.parse(data),
+                        batch = rpc instanceof Array;
+                } catch (err) {
+                    return respond(normalize(rpc, { error: { code: PARSE_ERROR }}));
+                }
+
+                /**
+                 * Normalize response object.
+                 */
+
+                function normalize(rpc, obj) {
+                    obj.id = rpc && typeof rpc.id === 'number'
+                        ? rpc.id
+                        : null;
+                    obj.jsonrpc = VERSION;
+                    if (obj.error && !obj.error.message) {
+                        obj.error.message = errorMessages[obj.error.code];
+                    }
+                    return obj;
+                }
+
+                /**
+                 * Respond with the given response object.
+                 */
+
+                function respond(obj) {
+                    var body = JSON.stringify(obj);
+                    res.writeHead(200, {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(body)
+                    });
+                    res.end(body);
+                }
+
+                // Handle requests
+
+                if (batch) {
+                    var responses = [],
+                        len = rpc.length,
+                        pending = len;
+                    for (var i = 0; i < len; ++i) {
+                        (function(rpc){
+                            handleRequest.call(me, rpc, function(obj){
+                                responses.push(normalize(rpc, obj));
+                                if (!--pending) {
+                                    respond(responses);
+                                }
+                            });
+                        })(rpc[i]);
+                    }
+                } else {
+                    handleRequest.call(me, rpc, function(obj){
+                        respond(normalize(rpc, obj));
+                    });
+                }
+            });
+        } else {
+            next();
+        }
+    };
+};
+
+/**
+ * Check if the given request is a valid
+ * JSON remote procedure call.
+ *
+ *   - "jsonrpc" must match the supported version ('2.0')
+ *   - "id" must be numeric
+ *   - "method" must be a string
+ *
+ * @param  {Object} rpc
+ * @return {Boolean}
+ * @api private
+ */
+
+function validRequest(rpc){
+    return rpc.jsonrpc === VERSION
+        && typeof rpc.id === 'number'
+        && typeof rpc.method === 'string';
+}