dgbuilder/dgeflows/node_modules/express/lib/utils.js

   1 /**
   2  * Module dependencies.
   3  */
   4
   5 var contentDisposition = require('content-disposition');
   6 var deprecate = require('depd')('express');
   7 var mime = require('send').mime;
   8 var basename = require('path').basename;
   9 var etag = require('etag');
  10 var proxyaddr = require('proxy-addr');
  11 var qs = require('qs');
  12 var querystring = require('querystring');
  13 var typer = require('media-typer');
  14
  15 /**
  16  * Return strong ETag for `body`.
  17  *
  18  * @param {String|Buffer} body
  19  * @param {String} [encoding]
  20  * @return {String}
  21  * @api private
  22  */
  23
  24 exports.etag = function (body, encoding) {
  25   var buf = !Buffer.isBuffer(body)
  26     ? new Buffer(body, encoding)
  27     : body;
  28
  29   return etag(buf, {weak: false});
  30 };
  31
  32 /**
  33  * Return weak ETag for `body`.
  34  *
  35  * @param {String|Buffer} body
  36  * @param {String} [encoding]
  37  * @return {String}
  38  * @api private
  39  */
  40
  41 exports.wetag = function wetag(body, encoding){
  42   var buf = !Buffer.isBuffer(body)
  43     ? new Buffer(body, encoding)
  44     : body;
  45
  46   return etag(buf, {weak: true});
  47 };
  48
  49 /**
  50  * Check if `path` looks absolute.
  51  *
  52  * @param {String} path
  53  * @return {Boolean}
  54  * @api private
  55  */
  56
  57 exports.isAbsolute = function(path){
  58   if ('/' == path[0]) return true;
  59   if (':' == path[1] && '\\' == path[2]) return true;
  60   if ('\\\\' == path.substring(0, 2)) return true; // Microsoft Azure absolute path
  61 };
  62
  63 /**
  64  * Flatten the given `arr`.
  65  *
  66  * @param {Array} arr
  67  * @return {Array}
  68  * @api private
  69  */
  70
  71 exports.flatten = function(arr, ret){
  72   ret = ret || [];
  73   var len = arr.length;
  74   for (var i = 0; i < len; ++i) {
  75     if (Array.isArray(arr[i])) {
  76       exports.flatten(arr[i], ret);
  77     } else {
  78       ret.push(arr[i]);
  79     }
  80   }
  81   return ret;
  82 };
  83
  84 /**
  85  * Normalize the given `type`, for example "html" becomes "text/html".
  86  *
  87  * @param {String} type
  88  * @return {Object}
  89  * @api private
  90  */
  91
  92 exports.normalizeType = function(type){
  93   return ~type.indexOf('/')
  94     ? acceptParams(type)
  95     : { value: mime.lookup(type), params: {} };
  96 };
  97
  98 /**
  99  * Normalize `types`, for example "html" becomes "text/html".
 100  *
 101  * @param {Array} types
 102  * @return {Array}
 103  * @api private
 104  */
 105
 106 exports.normalizeTypes = function(types){
 107   var ret = [];
 108
 109   for (var i = 0; i < types.length; ++i) {
 110     ret.push(exports.normalizeType(types[i]));
 111   }
 112
 113   return ret;
 114 };
 115
 116 /**
 117  * Generate Content-Disposition header appropriate for the filename.
 118  * non-ascii filenames are urlencoded and a filename* parameter is added
 119  *
 120  * @param {String} filename
 121  * @return {String}
 122  * @api private
 123  */
 124
 125 exports.contentDisposition = deprecate.function(contentDisposition,
 126   'utils.contentDisposition: use content-disposition npm module instead');
 127
 128 /**
 129  * Parse accept params `str` returning an
 130  * object with `.value`, `.quality` and `.params`.
 131  * also includes `.originalIndex` for stable sorting
 132  *
 133  * @param {String} str
 134  * @return {Object}
 135  * @api private
 136  */
 137
 138 function acceptParams(str, index) {
 139   var parts = str.split(/ *; */);
 140   var ret = { value: parts[0], quality: 1, params: {}, originalIndex: index };
 141
 142   for (var i = 1; i < parts.length; ++i) {
 143     var pms = parts[i].split(/ *= */);
 144     if ('q' == pms[0]) {
 145       ret.quality = parseFloat(pms[1]);
 146     } else {
 147       ret.params[pms[0]] = pms[1];
 148     }
 149   }
 150
 151   return ret;
 152 }
 153
 154 /**
 155  * Compile "etag" value to function.
 156  *
 157  * @param  {Boolean|String|Function} val
 158  * @return {Function}
 159  * @api private
 160  */
 161
 162 exports.compileETag = function(val) {
 163   var fn;
 164
 165   if (typeof val === 'function') {
 166     return val;
 167   }
 168
 169   switch (val) {
 170     case true:
 171       fn = exports.wetag;
 172       break;
 173     case false:
 174       break;
 175     case 'strong':
 176       fn = exports.etag;
 177       break;
 178     case 'weak':
 179       fn = exports.wetag;
 180       break;
 181     default:
 182       throw new TypeError('unknown value for etag function: ' + val);
 183   }
 184
 185   return fn;
 186 }
 187
 188 /**
 189  * Compile "query parser" value to function.
 190  *
 191  * @param  {String|Function} val
 192  * @return {Function}
 193  * @api private
 194  */
 195
 196 exports.compileQueryParser = function compileQueryParser(val) {
 197   var fn;
 198
 199   if (typeof val === 'function') {
 200     return val;
 201   }
 202
 203   switch (val) {
 204     case true:
 205       fn = querystring.parse;
 206       break;
 207     case false:
 208       fn = newObject;
 209       break;
 210     case 'extended':
 211       fn = qs.parse;
 212       break;
 213     case 'simple':
 214       fn = querystring.parse;
 215       break;
 216     default:
 217       throw new TypeError('unknown value for query parser function: ' + val);
 218   }
 219
 220   return fn;
 221 }
 222
 223 /**
 224  * Compile "proxy trust" value to function.
 225  *
 226  * @param  {Boolean|String|Number|Array|Function} val
 227  * @return {Function}
 228  * @api private
 229  */
 230
 231 exports.compileTrust = function(val) {
 232   if (typeof val === 'function') return val;
 233
 234   if (val === true) {
 235     // Support plain true/false
 236     return function(){ return true };
 237   }
 238
 239   if (typeof val === 'number') {
 240     // Support trusting hop count
 241     return function(a, i){ return i < val };
 242   }
 243
 244   if (typeof val === 'string') {
 245     // Support comma-separated values
 246     val = val.split(/ *, */);
 247   }
 248
 249   return proxyaddr.compile(val || []);
 250 }
 251
 252 /**
 253  * Set the charset in a given Content-Type string.
 254  *
 255  * @param {String} type
 256  * @param {String} charset
 257  * @return {String}
 258  * @api private
 259  */
 260
 261 exports.setCharset = function(type, charset){
 262   if (!type || !charset) return type;
 263
 264   // parse type
 265   var parsed = typer.parse(type);
 266
 267   // set charset
 268   parsed.parameters.charset = charset;
 269
 270   // format type
 271   return typer.format(parsed);
 272 };
 273
 274 /**
 275  * Return new empty object.
 276  *
 277  * @return {Object}
 278  * @api private
 279  */
 280
 281 function newObject() {
 282   return {};
 283 }