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

test/node_modules/express/lib/request.js

@@ -1,168 +1,248 @@
 
-/*!
- * Express - request
- * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca>
- * MIT Licensed
- */
-
 /**
  * Module dependencies.
  */
 
 var http = require('http')
-  , req = http.IncomingMessage.prototype
   , utils = require('./utils')
-  , parse = require('url').parse
-  , mime = require('mime');
+  , connect = require('connect')
+  , fresh = require('fresh')
+  , parseRange = require('range-parser')
+  , parse = connect.utils.parseUrl
+  , mime = connect.mime;
 
 /**
- * Default flash formatters.
- *
- * @type Object
+ * Request prototype.
  */
 
-var flashFormatters = exports.flashFormatters = {
-  s: function(val){
-    return String(val);
-  }
+var req = exports = module.exports = {
+  __proto__: http.IncomingMessage.prototype
 };
 
 /**
- * Return request header or optional default.
+ * Return request header.
  *
  * The `Referrer` header field is special-cased,
- * both `Referrer` and `Referer` will yield are
- * interchangeable.
+ * both `Referrer` and `Referer` are interchangeable.
  *
  * Examples:
  *
- *     req.header('Content-Type');
+ *     req.get('Content-Type');
  *     // => "text/plain"
  *     
- *     req.header('content-type');
+ *     req.get('content-type');
  *     // => "text/plain"
  *     
- *     req.header('Accept');
+ *     req.get('Something');
  *     // => undefined
- *     
- *     req.header('Accept', 'text/html');
- *     // => "text/html"
+ *
+ * Aliased as `req.header()`.
  *
  * @param {String} name
- * @param {String} defaultValue
  * @return {String} 
  * @api public
  */
 
-req.header = function(name, defaultValue){
+req.get = 
+req.header = function(name){
   switch (name = name.toLowerCase()) {
     case 'referer':
     case 'referrer':
       return this.headers.referrer
-        || this.headers.referer
-        || defaultValue;
+        || this.headers.referer;
     default:
-      return this.headers[name] || defaultValue;
+      return this.headers[name];
   }
 };
 
 /**
- * Get `field`'s `param` value, defaulting to ''.
+ * Check if the given `type(s)` is acceptable, returning
+ * the best match when true, otherwise `undefined`, in which
+ * case you should respond with 406 "Not Acceptable".
  *
- * Examples:
- *
- *     req.get('content-disposition', 'filename');
- *     // => "something.png"
- *
- * @param {String} field
- * @param {String} param
- * @return {String}
- * @api public
- */
-
-req.get = function(field, param){
-  var val = this.header(field);
-  if (!val) return '';
-  var regexp = new RegExp(param + ' *= *(?:"([^"]+)"|([^;]+))', 'i');
-  if (!regexp.exec(val)) return '';
-  return RegExp.$1 || RegExp.$2;
-};
-
-/**
- * Short-hand for `require('url').parse(req.url).pathname`.
- *
- * @return {String}
- * @api public
- */
-
-req.__defineGetter__('path', function(){
-  return parse(this.url).pathname;
-});
-
-/**
- * Check if the _Accept_ header is present, and includes the given `type`.
- *
- * When the _Accept_ header is not present `true` is returned. Otherwise
- * the given `type` is matched by an exact match, and then subtypes. You
- * may pass the subtype such as "html" which is then converted internally
- * to "text/html" using the mime lookup table.
+ * The `type` value may be a single mime type string
+ * such as "application/json", the extension name
+ * such as "json", a comma-delimted list such as "json, html, text/plain",
+ * or an array `["json", "html", "text/plain"]`. When a list
+ * or array is given the _best_ match, if any is returned.
  *
  * Examples:
  * 
  *     // Accept: text/html
  *     req.accepts('html');
- *     // => true
+ *     // => "html"
  *
- *     // Accept: text/*; application/json
+ *     // Accept: text/*, application/json
  *     req.accepts('html');
+ *     // => "html"
  *     req.accepts('text/html');
- *     req.accepts('text/plain');
+ *     // => "text/html"
+ *     req.accepts('json, text');
+ *     // => "json"
  *     req.accepts('application/json');
- *     // => true
+ *     // => "application/json"
  *
+ *     // Accept: text/*, application/json
  *     req.accepts('image/png');
  *     req.accepts('png');
- *     // => false
+ *     // => undefined
  *
- * @param {String} type
- * @return {Boolean}
+ *     // Accept: text/*;q=.5, application/json
+ *     req.accepts(['html', 'json']);
+ *     req.accepts('html, json');
+ *     // => "json"
+ *
+ * @param {String|Array} type(s)
+ * @return {String}
  * @api public
  */
 
 req.accepts = function(type){
-  var accept = this.header('Accept');
-
-  // normalize extensions ".json" -> "json"
-  if (type && '.' == type[0]) type = type.substr(1);
-
-  // when Accept does not exist, or contains '*/*' return true
-  if (!accept || ~accept.indexOf('*/*')) {
-    return true;
-  } else if (type) {
-    // allow "html" vs "text/html" etc
-    if (!~type.indexOf('/')) type = mime.lookup(type);
-
-    // check if we have a direct match
-    if (~accept.indexOf(type)) return true;
-
-    // check if we have type/*
-    type = type.split('/')[0] + '/*';
-    return !!~accept.indexOf(type);
-  } else {
-    return false;
-  }
+  return utils.accepts(type, this.get('Accept'));
 };
 
+/**
+ * Check if the given `charset` is acceptable,
+ * otherwise you should respond with 406 "Not Acceptable".
+ *
+ * @param {String} charset
+ * @return {Boolean}
+ * @api public
+ */
+
+req.acceptsCharset = function(charset){
+  var accepted = this.acceptedCharsets;
+  return accepted.length
+    ? ~accepted.indexOf(charset)
+    : true;
+};
+
+/**
+ * Check if the given `lang` is acceptable,
+ * otherwise you should respond with 406 "Not Acceptable".
+ *
+ * @param {String} lang
+ * @return {Boolean}
+ * @api public
+ */
+
+req.acceptsLanguage = function(lang){
+  var accepted = this.acceptedLanguages;
+  return accepted.length
+    ? ~accepted.indexOf(lang)
+    : true;
+};
+
+/**
+ * Parse Range header field,
+ * capping to the given `size`.
+ *
+ * Unspecified ranges such as "0-" require
+ * knowledge of your resource length. In
+ * the case of a byte range this is of course
+ * the total number of bytes. If the Range
+ * header field is not given `null` is returned,
+ * `-1` when unsatisfiable, `-2` when syntactically invalid.
+ *
+ * NOTE: remember that ranges are inclusive, so
+ * for example "Range: users=0-3" should respond
+ * with 4 users when available, not 3.
+ *
+ * @param {Number} size
+ * @return {Array}
+ * @api public
+ */
+
+req.range = function(size){
+  var range = this.get('Range');
+  if (!range) return;
+  return parseRange(size, range);
+};
+
+/**
+ * Return an array of Accepted media types
+ * ordered from highest quality to lowest.
+ *
+ * Examples:
+ *
+ *     [ { value: 'application/json',
+ *         quality: 1,
+ *         type: 'application',
+ *         subtype: 'json' },
+ *       { value: 'text/html',
+ *         quality: 0.5,
+ *         type: 'text',
+ *         subtype: 'html' } ]
+ *
+ * @return {Array}
+ * @api public
+ */
+
+req.__defineGetter__('accepted', function(){
+  var accept = this.get('Accept');
+  return accept
+    ? utils.parseAccept(accept)
+    : [];
+});
+
+/**
+ * Return an array of Accepted languages
+ * ordered from highest quality to lowest.
+ *
+ * Examples:
+ *
+ *     Accept-Language: en;q=.5, en-us
+ *     ['en-us', 'en']
+ *
+ * @return {Array}
+ * @api public
+ */
+
+req.__defineGetter__('acceptedLanguages', function(){
+  var accept = this.get('Accept-Language');
+  return accept
+    ? utils
+      .parseQuality(accept)
+      .map(function(obj){
+        return obj.value;
+      })
+    : [];
+});
+
+/**
+ * Return an array of Accepted charsets
+ * ordered from highest quality to lowest.
+ *
+ * Examples:
+ *
+ *     Accept-Charset: iso-8859-5;q=.2, unicode-1-1;q=0.8
+ *     ['unicode-1-1', 'iso-8859-5']
+ *
+ * @return {Array}
+ * @api public
+ */
+
+req.__defineGetter__('acceptedCharsets', function(){
+  var accept = this.get('Accept-Charset');
+  return accept
+    ? utils
+      .parseQuality(accept)
+      .map(function(obj){
+        return obj.value;
+      })
+    : [];
+});
+
 /**
  * Return the value of param `name` when present or `defaultValue`.
  *
  *  - Checks route placeholders, ex: _/user/:id_
+ *  - Checks body params, ex: id=12, {"id":12}
  *  - Checks query string params, ex: ?id=12
- *  - Checks urlencoded body params, ex: id=12
  *
- * To utilize urlencoded request bodies, `req.body`
+ * To utilize request bodies, `req.body`
  * should be an object. This can be done by using
- * the `connect.bodyParser` middleware.
+ * the `connect.bodyParser()` middleware.
  *
  * @param {String} name
  * @param {Mixed} defaultValue
@@ -171,80 +251,15 @@ req.accepts = function(type){
  */
 
 req.param = function(name, defaultValue){
-  // route params like /user/:id
-  if (this.params && this.params.hasOwnProperty(name) && undefined !== this.params[name]) {
-    return this.params[name]; 
-  }
-  // query string params
-  if (undefined !== this.query[name]) {
-    return this.query[name]; 
-  }
-  // request body params via connect.bodyParser
-  if (this.body && undefined !== this.body[name]) {
-    return this.body[name];
-  }
+  var params = this.params || {};
+  var body = this.body || {};
+  var query = this.query || {};
+  if (null != params[name] && params.hasOwnProperty(name)) return params[name];
+  if (null != body[name]) return body[name];
+  if (null != query[name]) return query[name];
   return defaultValue;
 };
 
-/**
- * Queue flash `msg` of the given `type`.
- *
- * Examples:
- *
- *      req.flash('info', 'email sent');
- *      req.flash('error', 'email delivery failed');
- *      req.flash('info', 'email re-sent');
- *      // => 2
- *
- *      req.flash('info');
- *      // => ['email sent', 'email re-sent']
- *
- *      req.flash('info');
- *      // => []
- *
- *      req.flash();
- *      // => { error: ['email delivery failed'], info: [] }
- *
- * Formatting:
- *
- * Flash notifications also support arbitrary formatting support.
- * For example you may pass variable arguments to `req.flash()`
- * and use the %s specifier to be replaced by the associated argument:
- *
- *     req.flash('info', 'email has been sent to %s.', userName);
- *
- * To add custom formatters use the `exports.flashFormatters` object.
- *
- * @param {String} type
- * @param {String} msg
- * @return {Array|Object|Number}
- * @api public
- */
-
-req.flash = function(type, msg){
-  if (this.session === undefined) throw Error('req.flash() requires sessions');
-  var msgs = this.session.flash = this.session.flash || {};
-  if (type && msg) {
-    var i = 2
-      , args = arguments
-      , formatters = this.app.flashFormatters || {};
-    formatters.__proto__ = flashFormatters;
-    msg = utils.miniMarkdown(msg);
-    msg = msg.replace(/%([a-zA-Z])/g, function(_, format){
-      var formatter = formatters[format];
-      if (formatter) return formatter(utils.escape(args[i++]));
-    });
-    return (msgs[type] = msgs[type] || []).push(msg);
-  } else if (type) {
-    var arr = msgs[type];
-    delete msgs[type];
-    return arr || [];
-  } else {
-    this.session.flash = {};
-    return msgs;
-  }
-};
-
 /**
  * Check if the incoming request contains the "Content-Type" 
  * header field, and it contains the give mime `type`.
@@ -254,45 +269,25 @@ req.flash = function(type, msg){
  *      // With Content-Type: text/html; charset=utf-8
  *      req.is('html');
  *      req.is('text/html');
+ *      req.is('text/*');
  *      // => true
  *     
  *      // When Content-Type is application/json
  *      req.is('json');
  *      req.is('application/json');
+ *      req.is('application/*');
  *      // => true
  *     
  *      req.is('html');
  *      // => false
  * 
- * Ad-hoc callbacks can also be registered with Express, to perform
- * assertions again the request, for example if we need an expressive
- * way to check if our incoming request is an image, we can register "an image"
- * callback:
- * 
- *       app.is('an image', function(req){
- *         return 0 == req.headers['content-type'].indexOf('image');
- *       });
- *       
- *  Now within our route callbacks, we can use to to assert content types
- *  such as "image/jpeg", "image/png", etc.
- * 
- *      app.post('/image/upload', function(req, res, next){
- *        if (req.is('an image')) {
- *          // do something
- *        } else {
- *          next();
- *        }
- *      });
- * 
  * @param {String} type
  * @return {Boolean}
  * @api public
  */
 
 req.is = function(type){
-  var fn = this.app.is(type);
-  if (fn) return fn(this);
-  var ct = this.headers['content-type'];
+  var ct = this.get('Content-Type');
   if (!ct) return false;
   ct = ct.split(';')[0];
   if (!~type.indexOf('/')) type = mime.lookup(type);
@@ -306,22 +301,6 @@ req.is = function(type){
   return !! ~ct.indexOf(type);
 };
 
-// Callback for isXMLHttpRequest / xhr
-
-function isxhr() {
-  return this.header('X-Requested-With', '').toLowerCase() === 'xmlhttprequest';
-}
-
-/**
- * Check if the request was an _XMLHttpRequest_.
- *
- * @return {Boolean}
- * @api public
- */
-
-req.__defineGetter__('isXMLHttpRequest', isxhr);
-req.__defineGetter__('xhr', isxhr);
-
 /**
  * Return the protocol string "http" or "https"
  * when requested with TLS. When the "trust proxy" 
@@ -335,11 +314,11 @@ req.__defineGetter__('xhr', isxhr);
  */
 
 req.__defineGetter__('protocol', function(){
-  var trustProxy = this.app.set('trust proxy');
+  var trustProxy = this.app.get('trust proxy');
   return this.connection.encrypted
     ? 'https'
     : trustProxy
-      ? (this.header('X-Forwarded-Proto') || 'http')
+      ? (this.get('X-Forwarded-Proto') || 'http')
       : 'http';
 });
 
@@ -354,4 +333,154 @@ req.__defineGetter__('protocol', function(){
 
 req.__defineGetter__('secure', function(){
   return 'https' == this.protocol;
-});
+});
+
+/**
+ * Return the remote address, or when
+ * "trust proxy" is `true` return
+ * the upstream addr.
+ *
+ * @return {String}
+ * @api public
+ */
+
+req.__defineGetter__('ip', function(){
+  return this.ips[0] || this.connection.remoteAddress;
+});
+
+/**
+ * When "trust proxy" is `true`, parse
+ * the "X-Forwarded-For" ip address list.
+ *
+ * For example if the value were "client, proxy1, proxy2"
+ * you would receive the array `["client", "proxy1", "proxy2"]`
+ * where "proxy2" is the furthest down-stream.
+ *
+ * @return {Array}
+ * @api public
+ */
+
+req.__defineGetter__('ips', function(){
+  var trustProxy = this.app.get('trust proxy');
+  var val = this.get('X-Forwarded-For');
+  return trustProxy && val
+    ? val.split(/ *, */)
+    : [];
+});
+
+/**
+ * Return basic auth credentials.
+ *
+ * Examples:
+ *
+ *    // http://tobi:hello@example.com
+ *    req.auth
+ *    // => { username: 'tobi', password: 'hello' }
+ *
+ * @return {Object} or undefined
+ * @api public
+ */
+
+req.__defineGetter__('auth', function(){
+  // missing
+  var auth = this.get('Authorization');
+  if (!auth) return;
+
+  // malformed
+  var parts = auth.split(' ');
+  if ('basic' != parts[0].toLowerCase()) return;
+  if (!parts[1]) return;
+  auth = parts[1];
+
+  // credentials
+  auth = new Buffer(auth, 'base64').toString().split(':');
+  return { username: auth[0], password: auth[1] };
+});
+
+/**
+ * Return subdomains as an array.
+ *
+ * For example "tobi.ferrets.example.com"
+ * would provide `["ferrets", "tobi"]`.
+ *
+ * @return {Array}
+ * @api public
+ */
+
+req.__defineGetter__('subdomains', function(){
+  return this.get('Host')
+    .split('.')
+    .slice(0, -2)
+    .reverse();
+});
+
+/**
+ * Short-hand for `url.parse(req.url).pathname`.
+ *
+ * @return {String}
+ * @api public
+ */
+
+req.__defineGetter__('path', function(){
+  return parse(this).pathname;
+});
+
+/**
+ * Parse the "Host" header field hostname.
+ *
+ * @return {String}
+ * @api public
+ */
+
+req.__defineGetter__('host', function(){
+  return this.get('Host').split(':')[0];
+});
+
+/**
+ * Check if the request is fresh, aka
+ * Last-Modified and/or the ETag
+ * still match.
+ *
+ * @return {Boolean}
+ * @api public
+ */
+
+req.__defineGetter__('fresh', function(){
+  var method = this.method;
+  var s = this.res.statusCode;
+
+  // GET or HEAD for weak freshness validation only
+  if ('GET' != method && 'HEAD' != method) return false;
+
+  // 2xx or 304 as per rfc2616 14.26
+  if ((s >= 200 && s < 300) || 304 == s) {
+    return fresh(this.headers, this.res._headers);
+  }
+
+  return false;
+});
+
+/**
+ * Check if the request is stale, aka
+ * "Last-Modified" and / or the "ETag" for the
+ * resource has changed.
+ *
+ * @return {Boolean}
+ * @api public
+ */
+
+req.__defineGetter__('stale', function(){
+  return !this.fresh;
+});
+
+/**
+ * Check if the request was an _XMLHttpRequest_.
+ *
+ * @return {Boolean}
+ * @api public
+ */
+
+req.__defineGetter__('xhr', function(){
+  var val = this.get('X-Requested-With') || '';
+  return 'xmlhttprequest' == val.toLowerCase();
+});