xonecas.io
142
St

startsInvasion / files

startsInvasion / libs / node_modules / reqwest / build / connect / lib / utils.js

8.0 KB
1
2/*!
3 * Connect - utils
4 * Copyright(c) 2010 Sencha Inc.
5 * Copyright(c) 2011 TJ Holowaychuk
6 * MIT Licensed
7 */
8
9/**
10 * Module dependencies.
11 */
12
13var crypto = require('crypto')
14  , Path = require('path')
15  , fs = require('fs');
16
17/**
18 * Flatten the given `arr`.
19 *
20 * @param {Array} arr
21 * @return {Array}
22 * @api private
23 */
24
25exports.flatten = function(arr, ret){
26  var ret = ret || []
27    , len = arr.length;
28  for (var i = 0; i < len; ++i) {
29    if (Array.isArray(arr[i])) {
30      exports.flatten(arr[i], ret);
31    } else {
32      ret.push(arr[i]);
33    }
34  }
35  return ret;
36};
37
38/**
39 * Return md5 hash of the given string and optional encoding,
40 * defaulting to hex.
41 *
42 *     utils.md5('wahoo');
43 *     // => "e493298061761236c96b02ea6aa8a2ad"
44 *
45 * @param {String} str
46 * @param {String} encoding
47 * @return {String}
48 * @api public
49 */
50
51exports.md5 = function(str, encoding){
52  return crypto
53    .createHash('md5')
54    .update(str)
55    .digest(encoding || 'hex');
56};
57
58/**
59 * Merge object b with object a.
60 *
61 *     var a = { foo: 'bar' }
62 *       , b = { bar: 'baz' };
63 *     
64 *     utils.merge(a, b);
65 *     // => { foo: 'bar', bar: 'baz' }
66 *
67 * @param {Object} a
68 * @param {Object} b
69 * @return {Object}
70 * @api public
71 */
72
73exports.merge = function(a, b){
74  if (a && b) {
75    for (var key in b) {
76      a[key] = b[key];
77    }
78  }
79  return a;
80};
81
82/**
83 * Escape the given string of `html`.
84 *
85 * @param {String} html
86 * @return {String}
87 * @api public
88 */
89
90exports.escape = function(html){
91  return String(html)
92    .replace(/&(?!\w+;)/g, '&amp;')
93    .replace(/</g, '&lt;')
94    .replace(/>/g, '&gt;')
95    .replace(/"/g, '&quot;');
96};
97
98
99/**
100 * Return a unique identifier with the given `len`.
101 *
102 *     utils.uid(10);
103 *     // => "FDaS435D2z"
104 *
105 * @param {Number} len
106 * @return {String}
107 * @api public
108 */
109
110exports.uid = function(len) {
111  var buf = []
112    , chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
113    , charlen = chars.length;
114
115  for (var i = 0; i < len; ++i) {
116    buf.push(chars[getRandomInt(0, charlen - 1)]);
117  }
118
119  return buf.join('');
120};
121
122/**
123 * Parse the given cookie string into an object.
124 *
125 * @param {String} str
126 * @return {Object}
127 * @api public
128 */
129
130exports.parseCookie = function(str){
131  var obj = {}
132    , pairs = str.split(/[;,] */);
133  for (var i = 0, len = pairs.length; i < len; ++i) {
134    var pair = pairs[i]
135      , eqlIndex = pair.indexOf('=')
136      , key = pair.substr(0, eqlIndex).trim().toLowerCase()
137      , val = pair.substr(++eqlIndex, pair.length).trim();
138
139    // Quoted values
140    if (val[0] === '"') {
141      val = val.slice(1, -1);
142    }
143
144    // Only assign once
145    if (obj[key] === undefined) {
146      obj[key] = decodeURIComponent(val.replace(/\+/g, ' '));
147    }
148  }
149  return obj;
150};
151
152/**
153 * Serialize the given object into a cookie string.
154 *
155 *      utils.serializeCookie('name', 'tj', { httpOnly: true })
156 *      // => "name=tj; httpOnly"
157 *
158 * @param {String} name
159 * @param {String} val
160 * @param {Object} obj
161 * @return {String}
162 * @api public
163 */
164
165exports.serializeCookie = function(name, val, obj){
166  var pairs = [name + '=' + encodeURIComponent(val)]
167    , obj = obj || {};
168
169  if (obj.domain) pairs.push('domain=' + obj.domain);
170  if (obj.path) pairs.push('path=' + obj.path);
171  if (obj.expires) pairs.push('expires=' + obj.expires.toUTCString());
172  if (obj.httpOnly) pairs.push('httpOnly');
173  if (obj.secure) pairs.push('secure');
174
175  return pairs.join('; ');
176};
177
178/**
179 * Pause `data` and `end` events on the given `obj`.
180 * Middleware performing async tasks _should_ utilize
181 * this utility (or similar), to re-emit data once
182 * the async operation has completed, otherwise these
183 * events may be lost.
184 *
185 *      var pause = utils.pause(req);
186 *      fs.readFile(path, function(){
187 *         next();
188 *         pause.resume();
189 *      });
190 *
191 * @param {Object} obj
192 * @return {Object}
193 * @api public
194 */
195
196exports.pause = function(obj){
197  var onData
198    , onEnd
199    , events = [];
200
201  // buffer data
202  obj.on('data', onData = function(data, encoding){
203    events.push(['data', data, encoding]);
204  });
205
206  // buffer end
207  obj.on('end', onEnd = function(data, encoding){
208    events.push(['end', data, encoding]);
209  });
210
211  return {
212    end: function(){
213      obj.removeListener('data', onData);
214      obj.removeListener('end', onEnd);
215    },
216    resume: function(){
217      this.end();
218      for (var i = 0, len = events.length; i < len; ++i) {
219        obj.emit.apply(obj, events[i]);
220      }
221    }
222  };
223};
224
225/**
226 * Check `req` and `res` to see if it has been modified.
227 *
228 * @param {IncomingMessage} req
229 * @param {ServerResponse} res
230 * @return {Boolean}
231 * @api public
232 */
233
234exports.modified = function(req, res, headers) {
235  var headers = headers || res._headers || {}
236    , modifiedSince = req.headers['if-modified-since']
237    , lastModified = headers['last-modified']
238    , noneMatch = req.headers['if-none-match']
239    , etag = headers['etag'];
240
241  if (noneMatch) noneMatch = noneMatch.split(/ *, */);
242
243  // check If-None-Match
244  if (noneMatch && etag && ~noneMatch.indexOf(etag)) {
245    return false;
246  }
247
248  // check If-Modified-Since
249  if (modifiedSince && lastModified) {
250    modifiedSince = new Date(modifiedSince);
251    lastModified = new Date(lastModified);
252    // Ignore invalid dates
253    if (!isNaN(modifiedSince.getTime())) {
254      if (lastModified <= modifiedSince) return false;
255    }
256  }
257  
258  return true;
259};
260
261/**
262 * Strip `Content-*` headers from `res`.
263 *
264 * @param {ServerResponse} res
265 * @api public
266 */
267
268exports.removeContentHeaders = function(res){
269  Object.keys(res._headers).forEach(function(field){
270    if (0 == field.indexOf('content')) {
271      res.removeHeader(field);
272    }
273  });
274};
275
276/**
277 * Check if `req` is a conditional GET request.
278 *
279 * @param {IncomingMessage} req
280 * @return {Boolean}
281 * @api public
282 */
283
284exports.conditionalGET = function(req) {
285  return req.headers['if-modified-since']
286    || req.headers['if-none-match'];
287};
288
289/**
290 * Respond with 412 "Unauthorized".
291 *
292 * @param {ServerResponse} res
293 * @param {String} realm
294 * @api public
295 */
296
297exports.unauthorized = function(res, realm) {
298  res.statusCode = 401;
299  res.setHeader('WWW-Authenticate', 'Basic realm="' + realm + '"');
300  res.end('Unauthorized');
301};
302
303/**
304 * Respond with 400 "Bad Request".
305 *
306 * @param {ServerResponse} res
307 * @api public
308 */
309
310exports.badRequest = function(res) {
311  res.statusCode = 400;
312  res.end('Bad Request');
313};
314
315/**
316 * Respond with 304 "Not Modified".
317 *
318 * @param {ServerResponse} res
319 * @param {Object} headers
320 * @api public
321 */
322
323exports.notModified = function(res) {
324  exports.removeContentHeaders(res);
325  res.statusCode = 304;
326  res.end();
327};
328
329/**
330 * Return an ETag in the form of `"<size>-<mtime>"`
331 * from the given `stat`.
332 *
333 * @param {Object} stat
334 * @return {String}
335 * @api public
336 */
337
338exports.etag = function(stat) {
339  return '"' + stat.size + '-' + Number(stat.mtime) + '"';
340};
341
342/**
343 * Parse "Range" header `str` relative to the given file `size`.
344 *
345 * @param {Number} size
346 * @param {String} str
347 * @return {Array}
348 * @api public
349 */
350
351exports.parseRange = function(size, str){
352  var valid = true;
353  var arr = str.substr(6).split(',').map(function(range){
354    var range = range.split('-')
355      , start = parseInt(range[0], 10)
356      , end = parseInt(range[1], 10);
357
358    // -500
359    if (isNaN(start)) {
360      start = size - end;
361      end = size - 1;
362    // 500-
363    } else if (isNaN(end)) {
364      end = size - 1;
365    }
366
367    // Invalid
368    if (isNaN(start) || isNaN(end) || start > end) valid = false;
369
370    return { start: start, end: end };
371  });
372  return valid ? arr : undefined;
373};
374
375/**
376 * Convert array-like object to an `Array`.
377 *
378 * node-bench measured "16.5 times faster than Array.prototype.slice.call()"
379 *
380 * @param {Object} obj
381 * @return {Array}
382 * @api public
383 */
384
385var toArray = exports.toArray = function(obj){
386  var len = obj.length
387    , arr = new Array(len);
388  for (var i = 0; i < len; ++i) {
389    arr[i] = obj[i];
390  }
391  return arr;
392};
393
394/**
395 * Retrun a random int, used by `utils.uid()`
396 *
397 * @param {Number} min
398 * @param {Number} max
399 * @return {Number}
400 * @api private
401 */
402
403function getRandomInt(min, max) {
404  return Math.floor(Math.random() * (max - min + 1)) + min;
405}