upgraded to express 3.x, converted jade templates, and worked out array notation for articles/exercises

test/node_modules/express/lib/router/index.js

@@ -1,19 +1,12 @@
-
-/*!
- * Express - Router
- * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
- * MIT Licensed
- */
-
 /**
  * Module dependencies.
  */
 
 var Route = require('./route')
-  , Collection = require('./collection')
   , utils = require('../utils')
-  , parse = require('url').parse
-  , toArray = utils.toArray;
+  , methods = require('methods')
+  , debug = require('debug')('express:router')
+  , parse = require('connect').utils.parseUrl;
 
 /**
  * Expose `Router` constructor.
@@ -22,26 +15,21 @@ var Route = require('./route')
 exports = module.exports = Router;
 
 /**
- * Expose HTTP methods.
- */
-
-var methods = exports.methods = require('./methods');
-
-/**
- * Initialize a new `Router` with the given `app`.
- * 
- * @param {express.HTTPServer} app
+ * Initialize a new `Router` with the given `options`.
+ *
+ * @param {Object} options
  * @api private
  */
 
-function Router(app) {
+function Router(options) {
+  options = options || {};
   var self = this;
-  this.app = app;
-  this.routes = {};
+  this.map = {};
   this.params = {};
   this._params = [];
-
-  this.middleware = function(req, res, next){
+  this.caseSensitive = options.caseSensitive;
+  this.strict = options.strict;
+  this.middleware = function router(req, res, next){
     self._dispatch(req, res, next);
   };
 }
@@ -83,104 +71,6 @@ Router.prototype.param = function(name, fn){
   return this;
 };
 
-/**
- * Return a `Collection` of all routes defined.
- *
- * @return {Collection}
- * @api public
- */
-
-Router.prototype.all = function(){
-  return this.find(function(){
-    return true;
-  });
-};
-
-/**
- * Remove the given `route`, returns
- * a bool indicating if the route was present
- * or not.
- *
- * @param {Route} route
- * @return {Boolean}
- * @api public
- */
-
-Router.prototype.remove = function(route){
-  var routes = this.routes[route.method]
-    , len = routes.length;
-
-  for (var i = 0; i < len; ++i) {
-    if (route == routes[i]) {
-      routes.splice(i, 1);
-      return true;
-    }
-  }
-};
-
-/**
- * Return routes with route paths matching `path`.
- *
- * @param {String} method
- * @param {String} path
- * @return {Collection}
- * @api public
- */
-
-Router.prototype.lookup = function(method, path){
-  return this.find(function(route){
-    return path == route.path
-      && (route.method == method
-      || method == 'all');
-  });
-};
-
-/**
- * Return routes with regexps that match the given `url`.
- *
- * @param {String} method
- * @param {String} url
- * @return {Collection}
- * @api public
- */
-
-Router.prototype.match = function(method, url){
-  return this.find(function(route){
-    return route.match(url)
-      && (route.method == method
-      || method == 'all');
-  });
-};
-
-/**
- * Find routes based on the return value of `fn`
- * which is invoked once per route.
- *
- * @param {Function} fn
- * @return {Collection}
- * @api public
- */
-
-Router.prototype.find = function(fn){
-  var len = methods.length
-    , ret = new Collection(this)
-    , method
-    , routes
-    , route;
-
-  for (var i = 0; i < len; ++i) {
-    method = methods[i];
-    routes = this.routes[method];
-    if (!routes) continue;
-    for (var j = 0, jlen = routes.length; j < jlen; ++j) {
-      route = routes[j];
-      if (fn(route)) ret.push(route);
-    }
-  }
-
-  return ret;
-};
-
 /**
  * Route dispatcher aka the route "middleware".
  *
@@ -194,6 +84,8 @@ Router.prototype._dispatch = function(req, res, next){
   var params = this.params
     , self = this;
 
+  debug('dispatching %s %s (%s)', req.method, req.url, req.originalUrl);
+
   // route dispatch
   (function pass(i, err){
     var paramCallbacks
@@ -201,8 +93,7 @@ Router.prototype._dispatch = function(req, res, next){
       , paramVal
       , route
       , keys
-      , key
-      , ret;
+      , key;
 
     // match next route
     function nextRoute(err) {
@@ -210,13 +101,11 @@ Router.prototype._dispatch = function(req, res, next){
     }
 
     // match route
-    req.route = route = self._match(req, i);
-
-    // implied OPTIONS
-    if (!route && 'OPTIONS' == req.method) return self._options(req, res);
+    req.route = route = self.matchRequest(req, i);
 
     // no route
     if (!route) return next(err);
+    debug('matched %s %s', route.method, route.path);
 
     // we have a route
     // start at param 0
@@ -251,7 +140,7 @@ Router.prototype._dispatch = function(req, res, next){
     };
 
     param(err);
-    
+
     // single param callbacks
     function paramCallback(err) {
       var fn = paramCallbacks[paramIndex++];
@@ -269,7 +158,8 @@ Router.prototype._dispatch = function(req, res, next){
           if (fn.length < 4) return callbacks(err);
           fn(err, req, res, callbacks);
         } else if (fn) {
-          fn(req, res, callbacks);
+          if (fn.length < 4) return fn(req, res, callbacks);
+          callbacks();
         } else {
           nextRoute(err);
         }
@@ -280,44 +170,10 @@ Router.prototype._dispatch = function(req, res, next){
   })(0);
 };
 
-/**
- * Respond to __OPTIONS__ method.
- *
- * @param {IncomingMessage} req
- * @param {ServerResponse} res
- * @api private
- */
-
-Router.prototype._options = function(req, res){
-  var path = parse(req.url).pathname
-    , body = this._optionsFor(path).join(',');
-  res.send(body, { Allow: body });
-};
-
-/**
- * Return an array of HTTP verbs or "options" for `path`.
- *
- * @param {String} path
- * @return {Array}
- * @api private
- */
-
-Router.prototype._optionsFor = function(path){
-  var self = this;
-  return methods.filter(function(method){
-    var routes = self.routes[method];
-    if (!routes || 'options' == method) return;
-    for (var i = 0, len = routes.length; i < len; ++i) {
-      if (routes[i].match(path)) return true;
-    }
-  }).map(function(method){
-    return method.toUpperCase();
-  });
-};
-
 /**
  * Attempt to match a route for `req`
- * starting from offset `i`.
+ * with optional starting index of `i`
+ * defaulting to 0.
  *
  * @param {IncomingMessage} req
  * @param {Number} i
@@ -325,17 +181,20 @@ Router.prototype._optionsFor = function(path){
  * @api private
  */
 
-Router.prototype._match = function(req, i){
+Router.prototype.matchRequest = function(req, i, head){
   var method = req.method.toLowerCase()
-    , url = parse(req.url)
+    , url = parse(req)
     , path = url.pathname
-    , routes = this.routes
-    , captures
-    , route
-    , keys;
+    , routes = this.map
+    , i = i || 0
+    , route;
 
-  // pass HEAD to GET routes
-  if ('head' == method) method = 'get';
+  // HEAD support
+  if (!head && 'head' == method) {
+    route = this.matchRequest(req, i, true);
+    if (route) return route;
+     method = 'get';
+  }
 
   // routes for this method
   if (routes = routes[method]) {
@@ -343,24 +202,7 @@ Router.prototype._match = function(req, i){
     // matching routes
     for (var len = routes.length; i < len; ++i) {
       route = routes[i];
-      if (captures = route.match(path)) {
-        keys = route.keys;
-        route.params = [];
-
-        // params from capture groups
-        for (var j = 1, jlen = captures.length; j < jlen; ++j) {
-          var key = keys[j-1]
-            , val = 'string' == typeof captures[j]
-              ? decodeURIComponent(captures[j])
-              : captures[j];
-          if (key) {
-            route.params[key.name] = val;
-          } else {
-            route.params.push(val);
-          }
-        }
-
-        // all done
+      if (route.match(path)) {
         req._route_index = i;
         return route;
       }
@@ -368,6 +210,23 @@ Router.prototype._match = function(req, i){
   }
 };
 
+/**
+ * Attempt to match a route for `method`
+ * and `url` with optional starting
+ * index of `i` defaulting to 0.
+ *
+ * @param {String} method
+ * @param {String} url
+ * @param {Number} i
+ * @return {Route}
+ * @api private
+ */
+
+Router.prototype.match = function(method, url, i, head){
+  var req = { method: method, url: url };
+  return  this.matchRequest(req, i, head);
+};
+
 /**
  * Route `method`, `path`, and one or more callbacks.
  *
@@ -378,21 +237,37 @@ Router.prototype._match = function(req, i){
  * @api private
  */
 
-Router.prototype._route = function(method, path, callbacks){
-  var app = this.app
-    , callbacks = utils.flatten(toArray(arguments, 2));
+Router.prototype.route = function(method, path, callbacks){
+  var method = method.toLowerCase()
+    , callbacks = utils.flatten([].slice.call(arguments, 2));
 
   // ensure path was given
-  if (!path) throw new Error('app.' + method + '() requires a path');
+  if (!path) throw new Error('Router#' + method + '() requires a path');
+
+  // ensure all callbacks are functions
+  callbacks.forEach(function(fn, i){
+    if ('function' == typeof fn) return;
+    var type = {}.toString.call(fn);
+    var msg = '.' + method + '() requires callback functions but got a ' + type;
+    throw new Error(msg);
+  });
 
   // create the route
+  debug('defined %s %s', method, path);
   var route = new Route(method, path, callbacks, {
-      sensitive: app.enabled('case sensitive routes')
-    , strict: app.enabled('strict routing')
+    sensitive: this.caseSensitive,
+    strict: this.strict
   });
 
   // add it
-  (this.routes[method] = this.routes[method] || [])
-    .push(route);
+  (this.map[method] = this.map[method] || []).push(route);
   return this;
 };
+
+methods.forEach(function(method){
+  Router.prototype[method] = function(path){
+    var args = [method].concat([].slice.call(arguments));
+    this.route.apply(this, args);
+    return this;
+  };
+});