vulcan 0.0.1 → 0.0.2

data/server/node_modules/connect-form/support/connect/examples/static/public/style.css

@@ -0,0 +1,3 @@
+body {
+    color: #fff;
+}

data/server/node_modules/connect-form/support/connect/examples/url-rewrite/app.js

@@ -0,0 +1,44 @@
+
+/**
+ * Module dependencies.
+ */
+
+var sys = require('sys'),
+    Connect = require('./../../lib/connect');
+
+/**
+ * Faux data.
+ */
+
+var data = [1,2,3,4,5];
+
+function format(req, res, next){
+    if (/\.(\w+)$/.exec(req.url)) {
+        req.format = RegExp.$1;
+        req.originalUrl = req.url;
+        req.url = req.url.replace('.' + req.format, '');
+    }
+    next();
+}
+
+function respond(req, res, next){
+    var body = (function(){
+        switch (req.format) {
+            case 'json':
+                return JSON.stringify(data);
+            case 'xml':
+                return '<items>' + data.map(function(n){
+                    return '<item>' + n + '</item>'
+                }) + '</items>';
+            default:
+                return data.join();
+        }
+    })();
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end(body);
+}
+
+module.exports = Connect.createServer(
+    format,
+    respond
+);

data/server/node_modules/connect-form/support/connect/examples/vhost/app.js

@@ -0,0 +1,25 @@
+
+/**
+ * Module dependencies.
+ */
+
+var Connect = require('./../../lib/connect');
+
+var localhost = Connect.vhost('localhost', Connect.createServer(function(req, res){
+    res.writeHead(200, {});
+    res.end('local vhost');
+}));
+
+var dev = Connect.vhost('dev', Connect.createServer(function(req, res){
+    res.writeHead(200, {});
+    res.end('dev vhost');
+}));
+
+module.exports = Connect.createServer(
+    // Shared middleware
+    Connect.logger(),
+    // http://localhost:3000 server with own middleware
+    localhost,
+    // http://dev:3000 server with own middleware
+    dev
+);

data/server/node_modules/connect-form/support/connect/install.sh

@@ -0,0 +1,6 @@
+mkdir /tmp/connect \
+  && cd /tmp/connect \
+  && curl -# -L http://github.com/senchalabs/connect/tarball/master \
+  | tar xz --strip 1 \
+  && make install \
+  && echo "Installation complete"

data/server/node_modules/connect-form/support/connect/lib/connect/index.js

@@ -0,0 +1,309 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Framework version.
+ */
+
+exports.version = '0.2.1';
+
+/**
+ * Module dependencies.
+ */
+
+var sys = require('sys'),
+    fs = require('fs'),
+    Url = require('url'),
+    Path = require('path'),
+    http = require('http'),
+    assert = require('assert'),
+    utils = require('./utils');
+
+/**
+ * Default env for those who do not use _bin/connect_.
+ *
+ * @type Object
+ */
+
+process.connectEnv = process.connectEnv || {
+    name: process.env.CONNECT_ENV || 'development',
+    port: 3000,
+    host: null
+};
+
+/**
+ * Auto-require response extensions.
+ */
+
+require('./response');
+
+/**
+ * TODO: remove?
+ * @ignore
+ */
+
+if (typeof Object.prototype.forEach !== 'function') {
+    Object.defineProperty(Object.prototype, 'forEach', {
+        value: function(fn, scope){
+            var keys = Object.keys(this);
+            for (var i = 0, len = keys.length; i < len; ++i) {
+                fn.call(scope, this[keys[i]], keys[i], this);
+            }
+        }
+    });
+}
+
+/**
+ * TODO: remove?
+ * @ignore
+ */
+
+if (typeof Object.prototype.map !== 'function') {
+  Object.defineProperty(Object.prototype, "map", {value: function (callback, thisObject) {
+      var accum = [];
+      var keys = Object.keys(this);
+      var length = keys.length;
+      for (var i = 0; i < length; i++) {
+          var key = keys[i];
+          accum[i] = callback.call(thisObject, this[key], key, this);
+      }
+      return accum;
+  }});
+}
+
+/**
+ * Setup the given middleware layer callbacks.
+ *
+ * Examples:
+ *
+ *     connect.createServer(
+ *        connect.log(),
+ *        connect.static(__dirname + '/public')
+ *     );
+ *
+ *     var server = connect.createServer();
+ *     server.use('/', connect.log());
+ *     server.use('/', connect.static(__dirname + '/public'));
+ *
+ * @params {Function} ...
+ * @return {Server}
+ * @api public
+ */
+
+var Server = exports.Server = function Server(layers) {
+    this.stack = [];
+
+    // Stack layers
+    layers.forEach(function(layer){
+        this.use("/", layer);
+    }, this);
+
+    // Set up the request handler using the parent's constructor
+    http.Server.call(this, this.handle);
+};
+
+// Server is a subclass of http.Server
+sys.inherits(Server, http.Server);
+
+/**
+ * Stack the given middleware `handle` to the given `route`.
+ *
+ * @param {String|Function} route or handle
+ * @param {Function} handle
+ * @return {Server}
+ * @api public
+ */
+
+Server.prototype.use = function(route, handle){
+    if (typeof route === 'function') {
+        handle = route, route = '/';
+    }
+
+    // Allow for more than one handle function to be added at a time
+    if (arguments.length > 2) {
+        Array.prototype.slice.call(arguments, 1).forEach(function (handle) {
+            this.use(route, handle);
+        }, this);
+        return this;
+    }
+
+    // Make sure the route always ends in a slash
+    if (route[route.length - 1] !== "/") {
+        route += "/";
+    }
+
+    // Wrap sub-apps
+    if (handle instanceof Server) {
+        var server = handle;
+        handle = function(req, res, next) {
+            server.handle(req, res, next);
+        };
+    }
+
+    // Validate the input
+    if (!(typeof route === 'string' && typeof handle === 'function')) {
+        throw new Error("Each layer must have a route and a handle function");
+    }
+
+    // Normalize route to not trail with slash
+    if (route[route.length - 1] === '/') {
+        route = route.substr(0, route.length - 1);
+    }
+
+    // Add the route, handle pair to the stack
+    this.stack.push({ route: route, handle: handle });
+
+    // Allow chaining
+    return this;
+};
+
+
+/**
+ * Listen on the given `port` number,
+ * defaults to the current environment's port,
+ * or _3000_ when neither are present.
+ *
+ * @param  {Number} port
+ * @param  {String} host
+ * @return {Server}
+ * @api public
+ */
+
+Server.prototype.listen = function(port, host) {
+    http.Server.prototype.listen.call(this,
+				      port || process.connectEnv.port || 3000,
+				      host || process.connectEnv.host);
+    return this;
+};
+
+/**
+ * Handle server requests, punting them down
+ * the middleware stack.
+ *
+ * @api private
+ */
+
+Server.prototype.handle = function(req, res, outerNext) {
+    var removed = "",
+        stack = this.stack,
+        index = 0,
+        missingMessage = req.method + ' ' + req.url + ' does not match any known handlers\n';
+
+
+    function next(err) {
+        if (err && err.errno === process.ENOENT) {
+            missingMessage = err.stack
+            err = null;
+        }
+        // Put the prefix back on if it was removed
+        req.url = req.originalUrl = removed + req.url;
+        removed = "";
+
+        var layer = stack[index++];
+
+        // If we reached the end of the chain...
+        if (!layer) {
+            // ... and we're part of a bigger chain then forward to it.
+            if (outerNext) {
+                outerNext();
+                return;
+            }
+
+            // Otherwise send a proper error message to the browser.
+            if (err) {
+                var msg = process.connectEnv.name === 'production'
+                    ? 'Internal Server Error'
+                    : err.stack || err.toString();
+                if (process.connectEnv.name !== 'test') {
+                  sys.error(err.stack || err.toString());
+                }
+                res.writeHead(500, { 'Content-Type': 'text/plain' });
+                res.end(msg);
+            } else {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                var msg = process.connectEnv.name === 'development'
+                    ? missingMessage
+                    : 'Cannot ' + req.method + ' ' + req.url;
+                res.end(msg);
+            }
+            return;
+        }
+
+        var pathname = Url.parse(req.url).pathname;
+
+        // Skip this layer if the route doesn't match.
+        if (pathname.indexOf(layer.route) !== 0) {
+            next(err);
+            return;
+        }
+
+        var nextChar = pathname[layer.route.length];
+        if (nextChar && nextChar !== '/' && nextChar !== '.') {
+            next(err);
+            return;
+        }
+
+        // Call the layer handler
+        try {
+            // Trim off the part of the url that matches the route
+            removed = layer.route;
+            req.url = req.url.substr(removed.length);
+
+            // Ensure leading slash
+            if (req.url[0] !== "/") {
+                req.url = "/" + req.url;
+            }
+
+            var arity = layer.handle.length;
+            if (err) {
+                if (arity === 4) {
+                    layer.handle(err, req, res, next);
+                } else {
+                    next(err);
+                }
+            } else if (arity < 4) {
+                layer.handle(req, res, next);
+            } else {
+                next();
+            }
+        } catch (e) {
+            if (e instanceof assert.AssertionError) {
+                sys.error(e.stack);
+                next(e);
+            } else {
+                next(e);
+            }
+        }
+    }
+    next();
+};
+
+/**
+ * Shortcut for `new connect.Server([ ... ])`.
+ *
+ * @param  {Function} ...
+ * @param  {Object} env
+ * @return {Server}
+ * @api public
+ */
+
+exports.createServer = function() {
+    return new Server(Array.prototype.slice.call(arguments));
+};
+
+/**
+ * Auto-load bundled middleware with getters.
+ */
+
+fs.readdirSync(__dirname + '/middleware').forEach(function(filename){
+    if (/\.js$/.test(filename)) {
+        var name = filename.substr(0, filename.lastIndexOf('.'));
+        Object.defineProperty(exports, name, { get: function(){
+            return require('./middleware/' + name);
+        }});
+    }
+});

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

@@ -0,0 +1,69 @@
+
+/*!
+ * Ext JS Connect
+ * Copyright(c) 2010 Sencha Inc.
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var queryString = require('querystring');
+
+/**
+ * Extract the mime type from the given request's
+ * _Content-Type_ header.
+ *
+ * @param  {IncomingMessage} req
+ * @return {String}
+ * @api private
+ */
+
+function mime(req) {
+    var str = req.headers['content-type'] || '';
+    return str.split(';')[0];
+}
+
+/**
+ * Supported decoders.
+ *
+ *  - application/x-www-form-urlencoded
+ *  - application/json
+ */
+
+exports.decode = {
+    'application/x-www-form-urlencoded': queryString.parse,
+    'application/json': JSON.parse
+};
+
+/**
+ * Decode request bodies.
+ *
+ * @return {Function}
+ * @api public
+ */
+
+module.exports = function bodyDecoder(){
+    return function bodyDecoder(req, res, next) {
+        var decoder = exports.decode[mime(req)];
+        if (decoder) {
+            var data = '';
+            req.setEncoding('utf8');
+            req.addListener('data', function(chunk) { data += chunk; });
+            req.addListener('end', function() {
+                req.rawBody = data;
+                try {
+                    req.body = data
+                        ? decoder(data)
+                        : {};
+                } catch (err) {
+                    return next(err);
+                }
+                next();
+            });
+        } else {
+            next();
+        }
+    }
+};