vulcan 0.0.1 → 0.0.2

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

@@ -0,0 +1,28 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Responds with the _X-Response-Time_ header in milliseconds.
+ *
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function responseTime(){
+    return function responseTime(req, res, next){
+        var start = new Date,
+            writeHead = res.writeHead;
+
+        res.writeHead = function(code, headers){
+            res.writeHead = writeHead;
+            headers['X-Response-Time'] = (new Date - start) + "ms";
+            res.writeHead(code, headers);
+        };
+
+        next();
+    };
+};

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

@@ -0,0 +1,158 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var parse = require('url').parse;
+
+/**
+ * Provides Sinatra and Express like routing capabilities.
+ *
+ * Examples:
+ *
+ *     connect.router(function(app){
+ *         app.get('/user/:id', function(req, res, params){
+ *             // populates params.id
+ *         });
+ *     })
+ *
+ * @param {Function} fn
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function router(fn){
+    var routes;
+
+    if (fn) {
+        routes = {};
+        fn.call(this, {
+            post: method.call(this, 'post'),
+            get: method.call(this, 'get'),
+            put: method.call(this, 'put'),
+            del: method.call(this, 'del')
+        });
+    } else {
+        throw new Error('router provider requires a callback function');
+    }
+
+    function method(name) {
+        var self = this,
+            localRoutes = routes[name] = routes[name] || [];
+        return function(path, fn){
+            var keys = [];
+            path = path instanceof RegExp
+                ? path
+                : normalizePath(path, keys);
+            localRoutes.push(fn, path, keys);
+            return self;
+        };
+    }
+
+    return function router(req, res, next){
+        var route,
+            self = this;
+        (function pass(i){
+            if (route = match(req, routes, i)) {
+                req.params = req.params || {};
+                req.params.path = route._params;
+                try { 
+                    route.call(self, req, res, route._params, function(err){
+                        if (err) {
+                            next(err);
+                        } else {
+                            pass(++route._index);
+                        }
+                    });
+                } catch (err) {
+                    next(err);
+                }
+            } else {
+                next();
+            }
+        })();
+    };
+}
+
+/**
+ * Normalize the given path string,
+ * returning a regular expression.
+ *
+ * An empty array should be passed,
+ * which will contain the placeholder
+ * key names. For example "/user/:id" will
+ * then contain ["id"].
+ *
+ * @param  {String} path
+ * @param  {Array} keys
+ * @return {RegExp}
+ * @api private
+ */
+
+function normalizePath(path, keys) {
+    path = path
+        .concat('/?')
+        .replace(/\/\(/g, '(?:/')
+        .replace(/(\/)?(\.)?:(\w+)(\?)?/g, function(_, slash, format, key, optional){
+            keys.push(key);
+            slash = slash || '';
+            return ''
+                + (optional ? '' : slash)
+                + '(?:'
+                + (optional ? slash : '')
+                + (format || '') + '([^/]+))'
+                + (optional || '');
+        })
+        .replace(/([\/.-])/g, '\\$1')
+        .replace(/\*/g, '(.+)');
+    return new RegExp('^' + path + '$', 'i');
+}
+
+
+/**
+ * Attempt to match the given request to
+ * one of the routes. When successful
+ * a route function is returned.
+ *
+ * @param  {ServerRequest} req
+ * @param  {Object} routes
+ * @return {Function}
+ * @api private
+ */
+
+function match(req, routes, i) {
+    var captures,
+        method = req.method.toLowerCase(),
+        i = i || 0;
+    if (method === 'delete') {
+        method = 'del';
+    }
+    if (routes = routes[method]) {
+        var url = parse(req.url),
+            pathname = url.pathname;
+        for (var len = routes.length; i < len; ++i) {
+            var fn = routes[i++],
+                path = routes[i++],
+                keys = routes[i];
+            if (captures = path.exec(pathname)) {
+                fn._params = { splat: [] };
+                for (var j = 1, len = captures.length; j < len; ++j) {
+                    var key = keys[j-1];
+                    if (key) {
+                        fn._params[keys[j-1]] = captures[j];
+                    } else {
+                        fn._params.splat.push(captures[j]);
+                    }
+                }
+                fn._index = i;
+                return fn;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,129 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+var Session = require('./session/session'),
+    utils = require('./../utils');
+
+/**
+ * Setup session store with the given `options`.
+ *
+ * Options:
+ *
+ *   - `store`         Session store instance
+ *   - `fingerprint`   Custom fingerprint generating function
+ *
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+module.exports = function sessionSetup(options){
+    options = options || {};
+
+    // The cookie key to store the session id in.
+    var key = options.key || 'connect.sid';
+
+    // Default memory store
+    var store = options.store || new (require('./session/memory'));
+
+    // Used to verify session ids / defaults to user agent
+    var fingerprint = options.fingerprint || function fingerprint(req) {
+        return req.headers['user-agent'] || '';
+    };
+
+    // This should be set by the app to make the session key tamper proof
+    var secret = options.secret || "hackme";
+
+    return function sessionHandle(req, res, next) {
+
+        if (!req.cookies) {
+            next(new Error("session requires cookieDecoder to work properly"));
+            return;
+        }
+
+        // Wrap writeHead as a hook to save the session and send the cookie
+        var writeHead = res.writeHead;
+        res.writeHead = function(status, headers){
+
+            // Update the session in the store if there is one
+            if (req.session) {
+                req.session.touch();
+                store.set(req.sessionID, req.session);
+            }
+
+            // Send an updated cookie to the browser
+            store.cookie.expires = new Date(Date.now() + store.maxAge);
+            headers = headers || {};
+            headers['Set-Cookie'] = utils.serializeCookie(key, req.sessionID, store.cookie);
+
+            // Pass through the writeHead call
+            res.writeHead = writeHead;
+            return res.writeHead(status, headers);
+        };
+
+        // Calculates the security hash to prevent session hijacking
+        // Uses information on the user-agent that created the session as it's fingerprint
+        function hash(base) {
+          return utils.md5(base + fingerprint(req) + secret);
+        }
+
+        // Generates the new session
+        function generate() {
+            var base = utils.uid();
+            var sessionID = base + "." + hash(base);
+            req.session = new Session(req, sessionID);
+            req.sessionID = sessionID;
+            next();
+        }
+
+        // Expose store
+        req.sessionStore = store;
+
+        // Get the sessionID from the cookie
+        req.sessionID = req.cookies[key];
+
+        // Make a new session if the browser doesn't send a sessionID
+        if (!req.sessionID) {
+            generate();
+            return;
+        }
+
+        // Check the fingerprint
+        var parts = req.sessionID.split('.');
+        if (parts[1] !== hash(parts[0])) {
+            // Make a new session if it doesn't check out
+            generate();
+            return;
+        }
+
+        // Generate the session object
+        store.get(req.sessionID, function (err, sess) {
+            // Error/missing handling
+            if (err) {
+                if (err.errno === process.ENOENT) {
+                    // If the session ID is invalid, generate a new session
+                    generate();
+                } else {
+                    // Otherwise pass the exception along
+                    next(err);
+                }
+                return;
+            }
+            if (!sess) {
+              // Some stores use a falsy result to signify no result
+              generate();
+              return;
+            }
+
+            // Load the session into the request
+            req.session = new Session(req, sess);
+            next();
+        });
+    };
+};

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

@@ -0,0 +1,141 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var sys = require('sys'),
+    Store = require('./store'),
+    utils = require('./../../utils'),
+    Session = require('./session');
+
+/**
+ * Initialize MemoryStore with the given options.
+ *
+ * @param {Object} options
+ * @api public
+ */
+
+var MemoryStore = module.exports = function MemoryStore(options) {
+    options = options || {};
+    Store.call(this, options);
+    this.sessions = {};
+
+    // Default reapInterval to 10 minutes
+    this.reapInterval = options.reapInterval || 600000;
+
+    // Reap stale sessions
+    if (this.reapInterval !== -1) {
+        setInterval(function(self){
+            self.reap(self.maxAge);
+        }, this.reapInterval, this);
+    }
+};
+
+sys.inherits(MemoryStore, Store);
+
+/**
+ * Reap sessions older than the give milliseconds.
+ *
+ * @param {Number} ms
+ * @api private
+ */
+
+MemoryStore.prototype.reap = function(ms){
+    var threshold = +new Date - ms,
+        keys = Object.keys(this.sessions);
+    for (var i = 0, len = keys.length; i < len; ++i) {
+        var key = keys[i],
+            sess = this.sessions[key];
+        if (sess.lastAccess < threshold) {
+            delete this.sessions[key];
+        }
+    }
+};
+
+/**
+ * Attempt to fetch session by the given `hash`.
+ *
+ * @param {String} hash
+ * @param {Function} fn
+ * @api public
+ */
+
+MemoryStore.prototype.get = function(hash, fn){
+    if (hash in this.sessions) {
+        fn(null, this.sessions[hash]);
+    } else {
+        fn();
+    }
+};
+
+/**
+ * Commit the given `sess` object associated with the given `hash`.
+ *
+ * @param {String} hash
+ * @param {Session} sess
+ * @param {Function} fn
+ * @api public
+ */
+
+MemoryStore.prototype.set = function(hash, sess, fn){
+    this.sessions[hash] = sess;
+    fn && fn();
+};
+
+/**
+ * Destroy the session associated with the given `hash`.
+ *
+ * @param {String} hash
+ * @api public
+ */
+
+MemoryStore.prototype.destroy = function(hash, fn){
+    delete this.sessions[hash];
+    fn && fn();
+};
+
+
+/**
+ * Invoke the given callback `fn` with all active sessions.
+ *
+ * @param {Function} fn
+ * @api public
+ */
+
+MemoryStore.prototype.all = function(fn){
+    var arr = [],
+        keys = Object.keys(this.sessions);
+    for (var i = 0, len = keys.length; i < len; ++i) {
+        arr.push(this.sessions[keys[i]]);
+    }
+    fn(null, arr);
+};
+
+/**
+ * Clear all sessions.
+ *
+ * @param {Function} fn
+ * @api public
+ */
+
+MemoryStore.prototype.clear = function(fn){
+    this.sessions = {};
+    fn && fn();
+};
+
+/**
+ * Fetch number of sessions.
+ *
+ * @param {Function} fn
+ * @api public
+ */
+
+MemoryStore.prototype.length = function(fn){
+    fn(null, Object.keys(this.sessions).length);
+};