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

test/node_modules/express/lib/response.js

@@ -1,145 +1,29 @@
-
-/*!
- * Express - response
- * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
- * MIT Licensed
- */
-
 /**
  * Module dependencies.
  */
 
-var fs = require('fs')
-  , http = require('http')
+var http = require('http')
   , path = require('path')
   , connect = require('connect')
   , utils = connect.utils
-  , parseRange = require('./utils').parseRange
-  , res = http.ServerResponse.prototype
-  , send = connect.static.send
-  , mime = require('mime')
+  , sign = require('cookie-signature').sign
+  , normalizeType = require('./utils').normalizeType
+  , normalizeTypes = require('./utils').normalizeTypes
+  , etag = require('./utils').etag
+  , statusCodes = http.STATUS_CODES
+  , cookie = require('cookie')
+  , send = require('send')
+  , mime = connect.mime
   , basename = path.basename
+  , extname = path.extname
   , join = path.join;
 
 /**
- * Send a response with the given `body` and optional `headers` and `status` code.
- *
- * Examples:
- *
- *     res.send();
- *     res.send(new Buffer('wahoo'));
- *     res.send({ some: 'json' });
- *     res.send('<p>some html</p>');
- *     res.send('Sorry, cant find that', 404);
- *     res.send('text', { 'Content-Type': 'text/plain' }, 201);
- *     res.send(404);
- *
- * @param {String|Object|Number|Buffer} body or status
- * @param {Object|Number} headers or status
- * @param {Number} status
- * @return {ServerResponse}
- * @api public
+ * Response prototype.
  */
 
-res.send = function(body, headers, status){
-  // allow status as second arg
-  if ('number' == typeof headers) {
-    status = headers,
-    headers = null;
-  }
-
-  // default status
-  status = status || this.statusCode;
-
-  // allow 0 args as 204
-  if (!arguments.length || undefined === body) status = 204;
-
-  // determine content type
-  switch (typeof body) {
-    case 'number':
-      if (!this.header('Content-Type')) {
-        this.contentType('.txt');
-      }
-      body = http.STATUS_CODES[status = body];
-      break;
-    case 'string':
-      if (!this.header('Content-Type')) {
-        this.charset = this.charset || 'utf-8';
-        this.contentType('.html');
-      }
-      break;
-    case 'boolean':
-    case 'object':
-      if (Buffer.isBuffer(body)) {
-        if (!this.header('Content-Type')) {
-          this.contentType('.bin');
-        }
-      } else {
-        return this.json(body, headers, status);
-      }
-      break;
-  }
-
-  // populate Content-Length
-  if (undefined !== body && !this.header('Content-Length')) {
-    this.header('Content-Length', Buffer.isBuffer(body)
-      ? body.length
-      : Buffer.byteLength(body));
-  }
-
-  // merge headers passed
-  if (headers) {
-    var fields = Object.keys(headers);
-    for (var i = 0, len = fields.length; i < len; ++i) {
-      var field = fields[i];
-      this.header(field, headers[field]);
-    }
-  }
-
-  // strip irrelevant headers
-  if (204 == status || 304 == status) {
-    this.removeHeader('Content-Type');
-    this.removeHeader('Content-Length');
-    body = '';
-  }
-
-  // respond
-  this.statusCode = status;
-  this.end('HEAD' == this.req.method ? null : body);
-  return this;
-};
-
-/**
- * Send JSON response with `obj`, optional `headers`, and optional `status`.
- *
- * Examples:
- *
- *     res.json(null);
- *     res.json({ user: 'tj' });
- *     res.json('oh noes!', 500);
- *     res.json('I dont have that', 404);
- *
- * @param {Mixed} obj
- * @param {Object|Number} headers or status
- * @param {Number} status
- * @return {ServerResponse}
- * @api public
- */
-
-res.json = function(obj, headers, status){
-  var body = JSON.stringify(obj)
-    , callback = this.req.query.callback
-    , jsonp = this.app.enabled('jsonp callback');
-
-  this.charset = this.charset || 'utf-8';
-  this.header('Content-Type', 'application/json');
-
-  if (callback && jsonp) {
-    this.header('Content-Type', 'text/javascript');
-    body = callback.replace(/[^\w$.]/g, '') + '(' + body + ');';
-  }
-
-  return this.send(body, headers, status);
+var res = module.exports = {
+  __proto__: http.ServerResponse.prototype
 };
 
 /**
@@ -156,15 +40,242 @@ res.status = function(code){
 };
 
 /**
- * Transfer the file at the given `path`. Automatically sets 
- * the _Content-Type_ response header field. `next()` is called
- * when `path` is a directory, or when an error occurs.
+ * Set Link header field with the given `links`.
+ *
+ * Examples:
+ *
+ *    res.links({
+ *      next: 'http://api.example.com/users?page=2',
+ *      last: 'http://api.example.com/users?page=5'
+ *    });
+ *
+ * @param {Object} links
+ * @return {ServerResponse}
+ * @api public
+ */
+
+res.links = function(links){
+  return this.set('Link', Object.keys(links).map(function(rel){
+    return '<' + links[rel] + '>; rel="' + rel + '"';
+  }).join(', '));
+};
+
+/**
+ * Send a response.
+ *
+ * Examples:
+ *
+ *     res.send(new Buffer('wahoo'));
+ *     res.send({ some: 'json' });
+ *     res.send('<p>some html</p>');
+ *     res.send(404, 'Sorry, cant find that');
+ *     res.send(404);
+ *
+ * @param {Mixed} body or status
+ * @param {Mixed} body
+ * @return {ServerResponse}
+ * @api public
+ */
+
+res.send = function(body){
+  var req = this.req
+    , head = 'HEAD' == req.method
+    , len;
+
+  // allow status / body
+  if (2 == arguments.length) {
+    // res.send(body, status) backwards compat
+    if ('number' != typeof body && 'number' == typeof arguments[1]) {
+      this.statusCode = arguments[1];
+    } else {
+      this.statusCode = body;
+      body = arguments[1];
+    }
+  }
+
+  switch (typeof body) {
+    // response status
+    case 'number':
+      this.get('Content-Type') || this.type('txt');
+      this.statusCode = body;
+      body = http.STATUS_CODES[body];
+      break;
+    // string defaulting to html
+    case 'string':
+      if (!this.get('Content-Type')) {
+        this.charset = this.charset || 'utf-8';
+        this.type('html');
+      }
+      break;
+    case 'boolean':
+    case 'object':
+      if (null == body) {
+        body = '';
+      } else if (Buffer.isBuffer(body)) {
+        this.get('Content-Type') || this.type('bin');
+      } else {
+        return this.json(body);
+      }
+      break;
+  }
+
+  // populate Content-Length
+  if (undefined !== body && !this.get('Content-Length')) {
+    this.set('Content-Length', len = Buffer.isBuffer(body)
+      ? body.length
+      : Buffer.byteLength(body));
+  }
+
+  // ETag support
+  // TODO: W/ support
+  if (len > 1024) {
+    if (!this.get('ETag')) {
+      this.set('ETag', etag(body));
+    }
+  }
+
+  // freshness
+  if (req.fresh) this.statusCode = 304;
+
+  // strip irrelevant headers
+  if (204 == this.statusCode || 304 == this.statusCode) {
+    this.removeHeader('Content-Type');
+    this.removeHeader('Content-Length');
+    this.removeHeader('Transfer-Encoding');
+    body = '';
+  }
+
+  // respond
+  this.end(head ? null : body);
+  return this;
+};
+
+/**
+ * Send JSON response.
+ *
+ * Examples:
+ *
+ *     res.json(null);
+ *     res.json({ user: 'tj' });
+ *     res.json(500, 'oh noes!');
+ *     res.json(404, 'I dont have that');
+ *
+ * @param {Mixed} obj or status
+ * @param {Mixed} obj
+ * @return {ServerResponse}
+ * @api public
+ */
+
+res.json = function(obj){
+  // allow status / body
+  if (2 == arguments.length) {
+    // res.json(body, status) backwards compat
+    if ('number' == typeof arguments[1]) {
+      this.statusCode = arguments[1];
+    } else {
+      this.statusCode = obj;
+      obj = arguments[1];
+    }
+  }
+
+  // settings
+  var app = this.app;
+  var replacer = app.get('json replacer');
+  var spaces = app.get('json spaces');
+  var body = JSON.stringify(obj, replacer, spaces);
+
+  // content-type
+  this.charset = this.charset || 'utf-8';
+  this.get('Content-Type') || this.set('Content-Type', 'application/json');
+  
+  return this.send(body);
+};
+
+/**
+ * Send JSON response with JSONP callback support.
+ *
+ * Examples:
+ *
+ *     res.jsonp(null);
+ *     res.jsonp({ user: 'tj' });
+ *     res.jsonp(500, 'oh noes!');
+ *     res.jsonp(404, 'I dont have that');
+ *
+ * @param {Mixed} obj or status
+ * @param {Mixed} obj
+ * @return {ServerResponse}
+ * @api public
+ */
+
+res.jsonp = function(obj){
+  // allow status / body
+  if (2 == arguments.length) {
+    // res.json(body, status) backwards compat
+    if ('number' == typeof arguments[1]) {
+      this.statusCode = arguments[1];
+    } else {
+      this.statusCode = obj;
+      obj = arguments[1];
+    }
+  }
+
+  // settings
+  var app = this.app;
+  var replacer = app.get('json replacer');
+  var spaces = app.get('json spaces');
+  var body = JSON.stringify(obj, replacer, spaces)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029');
+  var callback = this.req.query[app.get('jsonp callback name')];
+
+  // content-type
+  this.charset = this.charset || 'utf-8';
+  this.set('Content-Type', 'application/json');
+  
+  // jsonp
+  if (callback) {
+    this.set('Content-Type', 'text/javascript');
+    var cb = callback.replace(/[^\[\]\w$.]/g, '');
+    body = cb + ' && ' + cb + '(' + body + ');';
+  }
+
+  return this.send(body);
+};
+
+/**
+ * Transfer the file at the given `path`.
+ * 
+ * Automatically sets the _Content-Type_ response header field.
+ * The callback `fn(err)` is invoked when the transfer is complete
+ * or when an error occurs. Be sure to check `res.sentHeader`
+ * if you wish to attempt responding, as the header and some data
+ * may have already been transferred.
  *
  * Options:
  *
  *   - `maxAge` defaulting to 0
  *   - `root`   root directory for relative filenames
  *
+ * Examples:
+ *
+ *  The following example illustrates how `res.sendfile()` may
+ *  be used as an alternative for the `static()` middleware for
+ *  dynamic situations. The code backing `res.sendfile()` is actually
+ *  the same code, so HTTP cache support etc is identical.
+ *
+ *     app.get('/user/:uid/photos/:file', function(req, res){
+ *       var uid = req.params.uid
+ *         , file = req.params.file;
+ *     
+ *       req.user.mayViewFilesFrom(uid, function(yes){
+ *         if (yes) {
+ *           res.sendfile('/uploads/' + uid + '/' + file);
+ *         } else {
+ *           res.send(403, 'Sorry! you cant see that.');
+ *         }
+ *       });
+ *     });
+ *
  * @param {String} path
  * @param {Object|Function} options or fn
  * @param {Function} fn
@@ -172,8 +283,11 @@ res.status = function(code){
  */
 
 res.sendfile = function(path, options, fn){
-  var next = this.req.next;
-  options = options || {};
+  var self = this
+    , req = self.req
+    , next = this.req.next
+    , options = options || {}
+    , done;
 
   // support function as second arg
   if ('function' == typeof options) {
@@ -181,32 +295,185 @@ res.sendfile = function(path, options, fn){
     options = {};
   }
 
-  options.path = encodeURIComponent(path);
-  options.callback = fn;
-  send(this.req, this, next, options);
+  // socket errors
+  req.socket.on('error', error);
+
+  // errors
+  function error(err) {
+    if (done) return;
+    done = true;
+
+    // clean up
+    cleanup();
+    if (!self.headerSent) self.removeHeader('Content-Disposition');
+
+    // callback available
+    if (fn) return fn(err);
+
+    // list in limbo if there's no callback
+    if (self.headerSent) return;
+
+    // delegate
+    next(err);
+  }
+
+  // streaming
+  function stream() {
+    if (done) return;
+    cleanup();
+    if (fn) self.on('finish', fn);
+  }
+
+  // cleanup
+  function cleanup() {
+    req.socket.removeListener('error', error);
+  }
+
+  // transfer
+  var file = send(req, path);
+  if (options.root) file.root(options.root);
+  file.maxage(options.maxAge || 0);
+  file.on('error', error);
+  file.on('directory', next);
+  file.on('stream', stream);
+  file.pipe(this);
+  this.on('finish', cleanup);
 };
 
 /**
- * Set _Content-Type_ response header passed through `mime.lookup()`.
+ * Transfer the file at the given `path` as an attachment.
  *
- * Examples:
+ * Optionally providing an alternate attachment `filename`,
+ * and optional callback `fn(err)`. The callback is invoked
+ * when the data transfer is complete, or when an error has
+ * ocurred. Be sure to check `res.headerSent` if you plan to respond.
  *
- *     var filename = 'path/to/image.png';
- *     res.contentType(filename);
- *     // res.headers['Content-Type'] is now "image/png"
+ * This method uses `res.sendfile()`.
  *
- *     res.contentType('.html');
- *     res.contentType('html');
- *     res.contentType('json');
- *     res.contentType('png');
- *
- * @param {String} type
- * @return {String} the resolved mime type
+ * @param {String} path
+ * @param {String|Function} filename or fn
+ * @param {Function} fn
  * @api public
  */
 
-res.contentType = function(type){
-  return this.header('Content-Type', mime.lookup(type));
+res.download = function(path, filename, fn){
+  // support function as second arg
+  if ('function' == typeof filename) {
+    fn = filename;
+    filename = null;
+  }
+
+  filename = filename || path;
+  this.set('Content-Disposition', 'attachment; filename="' + basename(filename) + '"');
+  return this.sendfile(path, fn);
+};
+
+/**
+ * Set _Content-Type_ response header with `type` through `mime.lookup()`
+ * when it does not contain "/", or set the Content-Type to `type` otherwise.
+ *
+ * Examples:
+ *
+ *     res.type('.html');
+ *     res.type('html');
+ *     res.type('json');
+ *     res.type('application/json');
+ *     res.type('png');
+ *
+ * @param {String} type
+ * @return {ServerResponse} for chaining
+ * @api public
+ */
+
+res.contentType =
+res.type = function(type){
+  return this.set('Content-Type', ~type.indexOf('/')
+    ? type
+    : mime.lookup(type));
+};
+
+/**
+ * Respond to the Acceptable formats using an `obj`
+ * of mime-type callbacks.
+ *
+ * This method uses `req.accepted`, an array of
+ * acceptable types ordered by their quality values.
+ * When "Accept" is not present the _first_ callback
+ * is invoked, otherwise the first match is used. When
+ * no match is performed the server responds with
+ * 406 "Not Acceptable".
+ *
+ * Content-Type is set for you, however if you choose
+ * you may alter this within the callback using `res.type()`
+ * or `res.set('Content-Type', ...)`.
+ *
+ *    res.format({
+ *      'text/plain': function(){
+ *        res.send('hey');
+ *      },
+ *    
+ *      'text/html': function(){
+ *        res.send('<p>hey</p>');
+ *      },
+ *    
+ *      'appliation/json': function(){
+ *        res.send({ message: 'hey' });
+ *      }
+ *    });
+ *
+ * In addition to canonicalized MIME types you may
+ * also use extnames mapped to these types:
+ *
+ *    res.format({
+ *      text: function(){
+ *        res.send('hey');
+ *      },
+ *    
+ *      html: function(){
+ *        res.send('<p>hey</p>');
+ *      },
+ *    
+ *      json: function(){
+ *        res.send({ message: 'hey' });
+ *      }
+ *    });
+ *
+ * By default Express passes an `Error`
+ * with a `.status` of 406 to `next(err)`
+ * if a match is not made. If you provide
+ * a `.default` callback it will be invoked
+ * instead.
+ *
+ * @param {Object} obj
+ * @return {ServerResponse} for chaining
+ * @api public
+ */
+
+res.format = function(obj){
+  var req = this.req
+    , next = req.next;
+
+  var fn = obj.default;
+  if (fn) delete obj.default;
+  var keys = Object.keys(obj);
+
+  var key = req.accepts(keys);
+
+  this.set('Vary', 'Accept');
+
+  if (key) {
+    this.set('Content-Type', normalizeType(key));
+    obj[key](req, this, next);
+  } else if (fn) {
+    fn();
+  } else {
+    var err = new Error('Not Acceptable');
+    err.status = 406;
+    err.types = normalizeTypes(keys);
+    next(err);
+  }
+
+  return this;
 };
 
 /**
@@ -218,81 +485,67 @@ res.contentType = function(type){
  */
 
 res.attachment = function(filename){
-  if (filename) this.contentType(filename);
-  this.header('Content-Disposition', filename
+  if (filename) this.type(extname(filename));
+  this.set('Content-Disposition', filename
     ? 'attachment; filename="' + basename(filename) + '"'
     : 'attachment');
   return this;
 };
 
 /**
- * Transfer the file at the given `path`, with optional 
- * `filename` as an attachment and optional callback `fn(err)`,
- * and optional `fn2(err)` which is invoked when an error has
- * occurred after header has been sent.
+ * Set header `field` to `val`, or pass
+ * an object of header fields.
  *
- * @param {String} path
- * @param {String|Function} filename or fn
- * @param {Function} fn
- * @param {Function} fn2
- * @api public
- */
-
-res.download = function(path, filename, fn, fn2){
-  var self = this;
-
-  // support callback as second arg
-  if ('function' == typeof filename) {
-    fn2 = fn;
-    fn = filename;
-    filename = null;
-  }
-
-  // transfer the file
-  this.attachment(filename || path).sendfile(path, function(err){
-    var sentHeader = self._header;
-    if (err) {
-      if (!sentHeader) self.removeHeader('Content-Disposition');
-      if (sentHeader) {
-        fn2 && fn2(err);
-      } else if (fn) {
-        fn(err);
-      } else {
-        self.req.next(err);
-      }
-    } else if (fn) {
-      fn();
-    }
-  });
-};
-
-/**
- * Set or get response header `name` with optional `val`.
+ * Examples:
  *
- * @param {String} name
+ *    res.set('Accept', 'application/json');
+ *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+ *
+ * Aliased as `res.header()`. 
+ *
+ * @param {String|Object} field
  * @param {String} val
  * @return {ServerResponse} for chaining
  * @api public
  */
 
-res.header = function(name, val){
-  if (1 == arguments.length) return this.getHeader(name);
-  this.setHeader(name, val);
+res.set = 
+res.header = function(field, val){
+  if (2 == arguments.length) {
+    this.setHeader(field, '' + val);
+  } else {
+    for (var key in field) {
+      this.setHeader(key, '' + field[key]);
+    }
+  }
   return this;
 };
 
+/**
+ * Get value for header `field`.
+ *
+ * @param {String} field
+ * @return {String}
+ * @api public
+ */
+
+res.get = function(field){
+  return this.getHeader(field);
+};
+
 /**
  * Clear cookie `name`.
  *
  * @param {String} name
  * @param {Object} options
+ * @param {ServerResponse} for chaining
  * @api public
  */
 
 res.clearCookie = function(name, options){
-  var opts = { expires: new Date(1) };
-  this.cookie(name, '', options
-    ? utils.merge(options, opts)
+  var opts = { expires: new Date(1), path: '/' };
+  return this.cookie(name, '', options
+    ? utils.merge(opts, options)
     : opts);
 };
 
@@ -302,7 +555,8 @@ res.clearCookie = function(name, options){
  * Options:
  *
  *    - `maxAge`   max-age in milliseconds, converted to `expires`
- *    - `path`     defaults to the "basepath" setting which is typically "/"
+ *    - `signed`   sign the cookie
+ *    - `path`     defaults to "/"
  *
  * Examples:
  *
@@ -313,147 +567,156 @@ res.clearCookie = function(name, options){
  *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
  *
  * @param {String} name
- * @param {String} val
+ * @param {String|Object} val
  * @param {Options} options
  * @api public
  */
 
 res.cookie = function(name, val, options){
-  options = options || {};
-  if ('maxAge' in options) options.expires = new Date(Date.now() + options.maxAge);
-  if (undefined === options.path) options.path = this.app.set('basepath');
-  var cookie = utils.serializeCookie(name, val, options);
-  this.header('Set-Cookie', cookie);
+  options = utils.merge({}, options);
+  var secret = this.req.secret;
+  var signed = options.signed;
+  if (signed && !secret) throw new Error('connect.cookieParser("secret") required for signed cookies');
+  if ('object' == typeof val) val = 'j:' + JSON.stringify(val);
+  if (signed) val = 's:' + sign(val, secret);
+  if ('maxAge' in options) {
+    options.expires = new Date(Date.now() + options.maxAge);
+    options.maxAge /= 1000;
+  }
+  if (null == options.path) options.path = '/';
+  this.set('Set-Cookie', cookie.serialize(name, String(val), options));
+  return this;
 };
 
 /**
  * Redirect to the given `url` with optional response `status`
- * defauling to 302.
+ * defaulting to 302.
  *
  * The given `url` can also be the name of a mapped url, for
  * example by default express supports "back" which redirects
- * to the _Referrer_ or _Referer_ headers or the application's
- * "basepath" setting. Express also supports "basepath" out of the box,
- * which can be set via `app.set('basepath', '/blog');`, and defaults
- * to '/'.
+ * to the _Referrer_ or _Referer_ headers or "/".
  *
- * Redirect Mapping:
- * 
- *  To extend the redirect mapping capabilities that Express provides,
- *  we may use the `app.redirect()` method:
- * 
- *     app.redirect('google', 'http://google.com');
- * 
- *  Now in a route we may call:
+ * Examples:
  *
- *     res.redirect('google');
+ *    res.redirect('/foo/bar');
+ *    res.redirect('http://example.com');
+ *    res.redirect(301, 'http://example.com');
+ *    res.redirect('http://example.com', 301);
+ *    res.redirect('../login'); // /blog/post/1 -> /blog/login
  *
- *  We may also map dynamic redirects:
+ * Mounting:
  *
- *      app.redirect('comments', function(req, res){
- *          return '/post/' + req.params.id + '/comments';
- *      });
+ *   When an application is mounted, and `res.redirect()`
+ *   is given a path that does _not_ lead with "/". For 
+ *   example suppose a "blog" app is mounted at "/blog",
+ *   the following redirect would result in "/blog/login":
  *
- *  So now we may do the following, and the redirect will dynamically adjust to
- *  the context of the request. If we called this route with _GET /post/12_ our
- *  redirect _Location_ would be _/post/12/comments_.
+ *      res.redirect('login');
  *
- *      app.get('/post/:id', function(req, res){
- *        res.redirect('comments');
- *      });
+ *   While the leading slash would result in a redirect to "/login":
  *
- *  Unless an absolute `url` is given, the app's mount-point
- *  will be respected. For example if we redirect to `/posts`,
- *  and our app is mounted at `/blog` we will redirect to `/blog/posts`.
+ *      res.redirect('/login');
  *
  * @param {String} url
  * @param {Number} code
  * @api public
  */
 
-res.redirect = function(url, status){
+res.redirect = function(url){
   var app = this.app
     , req = this.req
-    , base = app.set('basepath') || app.route
-    , status = status || 302
     , head = 'HEAD' == req.method
+    , status = 302
     , body;
 
-  // Setup redirect map
-  var map = {
-      back: req.header('Referrer', base)
-    , home: base
-  };
+  // allow status / url
+  if (2 == arguments.length) {
+    if ('number' == typeof url) {
+      status = url;
+      url = arguments[1];
+    } else {
+      status = arguments[1];
+    }
+  }
 
-  // Support custom redirect map
-  map.__proto__ = app.redirects;
+  // setup redirect map
+  var map = { back: req.get('Referrer') || '/' };
 
-  // Attempt mapped redirect
-  var mapped = 'function' == typeof map[url]
-    ? map[url](req, this)
-    : map[url];
+  // perform redirect
+  url = map[url] || url;
 
-  // Perform redirect
-  url = mapped || url;
+  // relative
+  if (!~url.indexOf('://') && 0 != url.indexOf('//')) {
+    var path = app.path();
 
-  // Relative
-  if (!~url.indexOf('://')) {
-    // Respect mount-point
-    if ('/' != base && 0 != url.indexOf(base)) url = base + url;
-
-    // Absolute
-    var host = req.headers.host;
-    url = req.protocol + '://' + host + url;
+    // relative to path
+    if ('.' == url[0]) {
+      url = req.path + '/' + url;
+    // relative to mount-point
+    } else if ('/' != url[0]) {
+      url = path + '/' + url;
+    }
   }
 
   // Support text/{plain,html} by default
-  if (req.accepts('html')) {
-    body = '<p>' + http.STATUS_CODES[status] + '. Redirecting to <a href="' + url + '">' + url + '</a></p>';
-    this.header('Content-Type', 'text/html');
-  } else {
-    body = http.STATUS_CODES[status] + '. Redirecting to ' + url;
-    this.header('Content-Type', 'text/plain');
-  }
+  this.format({
+    text: function(){
+      body = statusCodes[status] + '. Redirecting to ' + encodeURI(url);
+    },
+
+    html: function(){
+      var u = utils.escape(url);
+      body = '<p>' + statusCodes[status] + '. Redirecting to <a href="' + u + '">' + u + '</a></p>';
+    },
+
+    default: function(){
+      body = '';
+    }
+  });
 
   // Respond
   this.statusCode = status;
-  this.header('Location', url);
+  this.set('Location', url);
+  this.set('Content-Length', Buffer.byteLength(body));
   this.end(head ? null : body);
 };
 
 /**
- * Assign the view local variable `name` to `val` or return the
- * local previously assigned to `name`.
+ * Render `view` with the given `options` and optional callback `fn`.
+ * When a callback function is given a response will _not_ be made
+ * automatically, otherwise a response of _200_ and _text/html_ is given.
  *
- * @param {String} name
- * @param {Mixed} val
- * @return {Mixed} val
+ * Options:
+ *
+ *  - `cache`     boolean hinting to the engine it should cache
+ *  - `filename`  filename of the view being rendered
+ *
+ * @param  {String} view
+ * @param  {Object|Function} options or callback function
+ * @param  {Function} fn
  * @api public
  */
 
-res.local = function(name, val){
-  this._locals = this._locals || {};
-  return undefined === val
-    ? this._locals[name]
-    : this._locals[name] = val;
-};
+res.render = function(view, options, fn){
+  var self = this
+    , options = options || {}
+    , req = this.req
+    , app = req.app;
 
-/**
- * Assign several locals with the given `obj`,
- * or return the locals.
- *
- * @param {Object} obj
- * @return {Object|Undefined}
- * @api public
- */
-
-res.locals =
-res.helpers = function(obj){
-  if (obj) {
-    for (var key in obj) {
-      this.local(key, obj[key]);
-    }
-  } else {
-    return this._locals;
+  // support callback function as second arg
+  if ('function' == typeof options) {
+    fn = options, options = {};
   }
+
+  // merge res.locals
+  options._locals = self.locals;
+
+  // default callback to respond
+  fn = fn || function(err, str){
+    if (err) return req.next(err);
+    self.send(str);
+  };
+
+  // render
+  app.render(view, options, fn);
 };