vulcan 0.0.1 → 0.0.2

data/server/node_modules/express/node_modules/connect/lib/http.js

@@ -0,0 +1,215 @@
+
+/*!
+ * Connect - HTTPServer
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var http = require('http')
+  , parse = require('url').parse
+  , assert = require('assert');
+
+// environment
+
+var env = process.env.NODE_ENV || 'development';
+
+/**
+ * Initialize a new `Server` with the given `middleware`.
+ *
+ * Examples:
+ *
+ *     var server = connect.createServer(
+ *         connect.favicon()
+ *       , connect.logger()
+ *       , connect.static(__dirname + '/public')
+ *     );
+ *
+ * @params {Array} middleware 
+ * @return {Server}
+ * @api public
+ */
+
+var Server = exports.Server = function HTTPServer(middleware) {
+  this.stack = [];
+  middleware.forEach(function(fn){
+    this.use(fn);
+  }, this);
+  http.Server.call(this, this.handle);
+};
+
+/**
+ * Inherit from `http.Server.prototype`.
+ */
+
+Server.prototype.__proto__ = http.Server.prototype;
+
+/**
+ * Utilize the given middleware `handle` to the given `route`,
+ * defaulting to _/_. This "route" is the mount-point for the
+ * middleware, when given a value other than _/_ the middleware
+ * is only effective when that segment is present in the request's
+ * pathname.
+ *
+ * For example if we were to mount a function at _/admin_, it would
+ * be invoked on _/admin_, and _/admin/settings_, however it would
+ * not be invoked for _/_, or _/posts_.
+ *
+ * This is effectively the same as passing middleware to `connect.createServer()`,
+ * however provides a progressive api.
+ *
+ * Examples:
+ *
+ *      var server = connect.createServer();
+ *      server.use(connect.favicon());
+ *      server.use(connect.logger());
+ *      server.use(connect.static(__dirname + '/public'));
+ *
+ * If we wanted to prefix static files with _/public_, we could
+ * "mount" the `static()` middleware:
+ *
+ *      server.use('/public', connect.static(__dirname + '/public'));
+ *
+ * This api is chainable, meaning the following is valid:
+ *
+ *      connect.createServer()
+ *        .use(connect.favicon())
+ *        .use(connect.logger())
+ *        .use(connect.static(__dirname + '/public'))
+ *        .listen(3000);
+ *
+ * @param {String|Function} route or handle
+ * @param {Function} handle
+ * @return {Server}
+ * @api public
+ */
+
+Server.prototype.use = function(route, handle){
+  this.route = '/';
+
+  // default route to '/'
+  if ('string' != typeof route) {
+    handle = route;
+    route = '/';
+  }
+
+  // wrap sub-apps
+  if ('function' == typeof handle.handle) {
+    var server = handle;
+    server.route = route;
+    handle = function(req, res, next) {
+      server.handle(req, res, next);
+    };
+  }
+
+  // wrap vanilla http.Servers
+  if (handle instanceof http.Server) {
+    handle = handle.listeners('request')[0];
+  }
+
+  // normalize route to not trail with slash
+  if ('/' == route[route.length - 1]) {
+    route = route.substr(0, route.length - 1);
+  }
+
+  // add the middleware
+  this.stack.push({ route: route, handle: handle });
+
+  // allow chaining
+  return this;
+};
+
+/**
+ * Handle server requests, punting them down
+ * the middleware stack.
+ *
+ * @api private
+ */
+
+Server.prototype.handle = function(req, res, out) {
+  var writeHead = res.writeHead
+    , stack = this.stack
+    , removed = ''
+    , index = 0;
+
+  function next(err) {
+    var layer, path, c;
+    req.url = removed + req.url;
+    req.originalUrl = req.originalUrl || req.url;
+    removed = '';
+
+    layer = stack[index++];
+
+    // all done
+    if (!layer || res.headerSent) {
+      // but wait! we have a parent
+      if (out) return out(err);
+
+      // error
+      if (err) {
+        var msg = 'production' == env
+          ? 'Internal Server Error'
+          : err.stack || err.toString();
+
+        // output to stderr in a non-test env
+        if ('test' != env) console.error(err.stack || err.toString());
+
+        // unable to respond
+        if (res.headerSent) return req.socket.destroy();
+
+        res.statusCode = 500;
+        res.setHeader('Content-Type', 'text/plain');
+        res.end(msg);
+      } else {
+        res.statusCode = 404;
+        res.setHeader('Content-Type', 'text/plain');
+        res.end('Cannot ' + req.method + ' ' + req.url);
+      }
+      return;
+    }
+
+    try {
+      path = parse(req.url).pathname;
+      if (undefined == path) path = '/';
+
+      // skip this layer if the route doesn't match.
+      if (0 != path.indexOf(layer.route)) return next(err);
+
+      c = path[layer.route.length];
+      if (c && '/' != c && '.' != c) return next(err);
+
+      // Call the layer handler
+      // 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) {
+        console.error(e.stack + '\n');
+        next(e);
+      } else {
+        next(e);
+      }
+    }
+  }
+  next();
+};

data/server/node_modules/express/node_modules/connect/lib/https.js

@@ -0,0 +1,47 @@
+
+/*!
+ * Connect - HTTPServer
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var HTTPServer = require('./http').Server
+  , https = require('https');
+
+/**
+ * Initialize a new `Server` with the given
+ *`options` and `middleware`. The HTTPS api
+ * is identical to the [HTTP](http.html) server,
+ * however TLS `options` must be provided before
+ * passing in the optional middleware.
+ *
+ * @params {Object} options
+ * @params {Array} middleawre
+ * @return {Server}
+ * @api public
+ */
+
+var Server = exports.Server = function HTTPSServer(options, middleware) {
+  this.stack = [];
+  middleware.forEach(function(fn){
+    this.use(fn);
+  }, this);
+  https.Server.call(this, options, this.handle);
+};
+
+/**
+ * Inherit from `http.Server.prototype`.
+ */
+
+Server.prototype.__proto__ = https.Server.prototype;
+
+// mixin HTTPServer methods
+
+Object.keys(HTTPServer.prototype).forEach(function(method){
+  Server.prototype[method] = HTTPServer.prototype[method];
+});

data/server/node_modules/express/node_modules/connect/lib/index.js

@@ -0,0 +1,46 @@
+
+/**
+ * # Connect
+ *
+ * Connect is a middleware framework for node,
+ * shipping with over 11 bundled middleware and a rich choice of
+ * [3rd-party middleware](https://github.com/senchalabs/connect/wiki).
+ *
+ * Installation:
+ * 
+ *     $ npm install connect
+ * 
+ * API:
+ *
+ *  - [connect](connect.html) general
+ *  - [http](http.html) http server
+ *  - [https](https.html) https server
+ *
+ * Middleware:
+ *
+ *  - [logger](middleware-logger.html) request logger with custom format support
+ *  - [csrf](middleware-csrf.html) Cross-site request forgery protection
+ *  - [basicAuth](middleware-basicAuth.html) basic http authentication
+ *  - [bodyParser](middleware-bodyParser.html) extensible request body parser
+ *  - [cookieParser](middleware-cookieParser.html) cookie parser
+ *  - [session](middleware-session.html) session management support with bundled [MemoryStore](middleware-session-memory.html)
+ *  - [compiler](middleware-compiler.html) static asset compiler (sass, less, coffee-script, etc)
+ *  - [methodOverride](middleware-methodOverride.html) faux HTTP method support
+ *  - [responseTime](middleware-responseTime.html) calculates response-time and exposes via X-Response-Time
+ *  - [router](middleware-router.html) provides rich Sinatra / Express-like routing
+ *  - [staticCache](middleware-staticCache.html) memory cache layer for the static() middleware
+ *  - [static](middleware-static.html) streaming static file server supporting `Range` and more
+ *  - [directory](middleware-directory.html) directory listing middleware
+ *  - [vhost](middleware-vhost.html) virtual host sub-domain mapping middleware
+ *  - [favicon](middleware-favicon.html) efficient favicon server (with default icon)
+ *  - [limit](middleware-limit.html) limit the bytesize of request bodies
+ *  - [profiler](middleware-profiler.html) request profiler reporting response-time, memory usage, etc
+ *  - [query](middleware-query.html) automatic querystring parser, populating `req.query`
+ *  - [errorHandler](middleware-errorHandler.html) flexible error handler
+ *
+ * Internals:
+ *
+ *  - connect [utilities](utils.html)
+ *  - node monkey [patches](patch.html)
+ *
+ */

data/server/node_modules/express/node_modules/connect/lib/middleware/basicAuth.js

@@ -0,0 +1,93 @@
+
+/*!
+ * Connect - basicAuth
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('../utils')
+  , unauthorized = utils.unauthorized
+  , badRequest = utils.badRequest;
+
+/**
+ * Enfore basic authentication by providing a `callback(user, pass)`,
+ * which must return `true` in order to gain access. Alternatively an async
+ * method is provided as well, invoking `callback(user, pass, callback)`. Populates
+ * `req.remoteUser`. The final alternative is simply passing username / password
+ * strings.
+ *
+ * Examples:
+ *
+ *     connect(connect.basicAuth('username', 'password'));
+ *
+ *     connect(
+ *       connect.basicAuth(function(user, pass){
+ *         return 'tj' == user & 'wahoo' == pass;
+ *       })
+ *     );
+ *
+ *     connect(
+ *       connect.basicAuth(function(user, pass, fn){
+ *         User.authenticate({ user: user, pass: pass }, fn);
+ *       })
+ *     );
+ *
+ * @param {Function|String} callback or username
+ * @param {String} realm
+ * @api public
+ */
+
+module.exports = function basicAuth(callback, realm) {
+  var username, password;
+
+  // user / pass strings
+  if ('string' == typeof callback) {
+    username = callback;
+    password = realm;
+    if ('string' != typeof password) throw new Error('password argument required');
+    realm = arguments[2];
+    callback = function(user, pass){
+      return user == username && pass == password;
+    }
+  }
+
+  realm = realm || 'Authorization Required';
+
+  return function(req, res, next) {
+    var authorization = req.headers.authorization;
+
+    if (req.remoteUser) return next();
+    if (!authorization) return unauthorized(res, realm);
+
+    var parts = authorization.split(' ')
+      , scheme = parts[0]
+      , credentials = new Buffer(parts[1], 'base64').toString().split(':');
+
+    if ('Basic' != scheme) return badRequest(res);
+
+    // async
+    if (callback.length >= 3) {
+      var pause = utils.pause(req);
+      callback(credentials[0], credentials[1], function(err, user){
+        if (err || !user)  return unauthorized(res, realm);
+        req.remoteUser = user;
+        next();
+        pause.resume();
+      });
+    // sync
+    } else {
+      if (callback(credentials[0], credentials[1])) {
+        req.remoteUser = credentials[0];
+        next();
+      } else {
+        unauthorized(res, realm);
+      }
+    }
+  }
+};
+

data/server/node_modules/express/node_modules/connect/lib/middleware/bodyParser.js

@@ -0,0 +1,92 @@
+
+/*!
+ * Connect - bodyParser
+ * Copyright(c) 2010 Sencha Inc.
+ * Copyright(c) 2011 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var qs = require('qs');
+
+/**
+ * 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];
+}
+
+/**
+ * Parse request bodies.
+ *
+ * By default _application/json_ and _application/x-www-form-urlencoded_
+ * are supported, however you may map `connect.bodyParser.parse[contentType]`
+ * to a function of your choice to replace existing parsers, or implement
+ * one for other content-types.
+ *
+ * Examples:
+ *
+ *      connect.createServer(
+ *          connect.bodyParser()
+ *        , function(req, res) {
+ *          res.end('viewing user ' + req.body.user.name);
+ *        }
+ *      );
+ *
+ * Since both _json_ and _x-www-form-urlencoded_ are supported by
+ * default, either of the following requests would result in the response
+ * of "viewing user tj".
+ *
+ *      $ curl -d 'user[name]=tj' http://localhost/
+ *      $ curl -d '{"user":{"name":"tj"}}' -H "Content-Type: application/json" http://localhost/
+ *
+ * @return {Function}
+ * @api public
+ */
+
+exports = module.exports = function bodyParser(){
+  return function bodyParser(req, res, next) {
+    if ('GET' == req.method || 'HEAD' == req.method) return next();
+    var parser = exports.parse[mime(req)];
+    if (parser && !req.body) {
+      var data = '';
+      req.setEncoding('utf8');
+      req.on('data', function(chunk) { data += chunk; });
+      req.on('end', function(){
+        req.rawBody = data;
+        try {
+          req.body = data
+            ? parser(data)
+            : {};
+        } catch (err) {
+          return next(err);
+        }
+        next();
+      });
+    } else {
+      next();
+    }
+  }
+};
+
+/**
+ * Supported decoders.
+ *
+ *  - application/x-www-form-urlencoded
+ *  - application/json
+ */
+
+exports.parse = {
+    'application/x-www-form-urlencoded': qs.parse
+  , 'application/json': JSON.parse
+};