fsevents 1.2.6 → 1.2.7

package/node_modules/needle/examples/multipart-stream.js

@@ -0,0 +1,25 @@
+var needle = require('./../');
+
+var url  = 'http://posttestserver.com/post.php?dir=needle';
+
+var black_pixel = new Buffer("R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=", 'base64');
+
+var data = {
+  foo: 'bar',
+  nested: {
+    test: 123
+  },
+  image: { buffer: black_pixel, content_type: 'image/gif' }
+}
+
+var resp = needle.post(url, data, { multipart: true });
+
+resp.on('readable', function() {
+  while (data = this.read()) {
+    console.log(data.toString());
+  }
+})
+
+resp.on('done', function(data) {
+  console.log('Done.');
+})

package/node_modules/needle/examples/parsed-stream.js

@@ -0,0 +1,23 @@
+//////////////////////////////////////////
+// This example demonstrates what happends
+// when you use the built-in JSON parser.
+//////////////////////////////////////////
+
+var fs     = require('fs'),
+    stream = require('stream'),
+    needle = require('./../');
+
+var url    = 'http://ip.jsontest.com/',
+    resp   = needle.get(url, { parse: true });
+
+resp.on('readable', function(obj) {
+  var chunk;
+
+  while (chunk = this.read()) {
+    console.log('root = ', chunk);
+  }
+});
+
+resp.on('done', function() {
+  console.log('Done.');
+});

package/node_modules/needle/examples/parsed-stream2.js

@@ -0,0 +1,21 @@
+//////////////////////////////////////////
+// This example illustrates a more complex
+// example of parsing a JSON stream.
+//////////////////////////////////////////
+
+var needle     = require('./../'),
+    JSONStream = require('JSONStream');
+
+var url  = 'http://jsonplaceholder.typicode.com/db';
+
+// Initialize our GET request with our default (JSON) 
+// parsers disabled.
+
+var json = new needle.get(url, {parse: false})
+    // And now interpret the stream as JSON, returning only the
+    // title of all the posts.
+    .pipe(new JSONStream.parse('posts.*.title'));
+
+json.on('data', function (obj) {
+  console.log('got title: \'' + obj + '\'');
+})

package/node_modules/needle/examples/stream-events.js

@@ -0,0 +1,23 @@
+var needle = require('./..');
+
+var resp   = needle.get('google.com', { follow_max: 10, timeout: 5000 });
+
+resp.on('readable', function() {
+  var chunk;
+  while (chunk = this.read()) {
+    console.log('Got ' + chunk.length + ' bytes');
+  }
+})
+
+resp.on('headers', function(headers) {
+  console.log('Got headers', headers);
+})
+
+resp.on('redirect', function(url) {
+  console.log('Redirected to url ' + url);
+})
+
+resp.on('done', function(err) {
+  console.log('Finished. No more data to receive.');
+  if (err) console.log('With error', err)
+})

package/node_modules/needle/examples/stream-to-file.js

@@ -0,0 +1,14 @@
+var fs     = require('fs'),
+    needle = require('./..'),
+    path   = require('path');
+
+var url    = process.argv[2] || 'http://www.google.com/images/errors/robot.png';
+var file   = path.basename(url);
+
+console.log('Downloading ' + file + '...');
+needle
+  .get(url)
+  .pipe(fs.createWriteStream(file))
+  .on('done', function() {
+    console.log('Done!')
+  })

package/node_modules/needle/examples/upload-image.js

@@ -0,0 +1,51 @@
+var needle = require('../'),
+    path   = require('path');
+
+var image = 'https://upload.wikimedia.org/wikipedia/commons/a/af/Tux.png';
+
+function upload(obj, cb) {
+  console.log('Uploading image...');
+
+  var url = 'http://deviantsart.com';
+
+  var opts = {
+    timeout:  10000,
+    follow:    3,
+    multipart: true
+  };
+
+  var params = {
+    file: obj
+  }
+
+  needle.post(url, params, opts, function(err, resp) {
+    if (err || !resp.body.match('url'))
+      return cb(err || new Error('No image URL found.'))
+
+    cb(null, JSON.parse(resp.body).url)
+  })
+}
+
+function download(url, cb) {
+  console.log('Getting ' + url);
+  needle.get(url, function(err, resp) {
+    if (err) throw err;
+
+    cb(null, resp.body);
+  })
+}
+
+////////////////////////////////////////
+// ok, now go.
+
+download(image, function(err, buffer) {
+  if (err) throw err;
+
+  var obj = { buffer: buffer, content_type: 'image/png' };
+
+  upload(obj, function(err, url) {
+    if (err) throw err;
+
+    console.log('Image uploaded to ' + url);
+  })
+})

package/node_modules/needle/lib/auth.js

@@ -0,0 +1,110 @@
+var createHash = require('crypto').createHash;
+
+function get_header(header, credentials, opts) {
+  var type = header.split(' ')[0],
+      user = credentials[0],
+      pass = credentials[1];
+
+  if (type == 'Digest') {
+    return digest.generate(header, user, pass, opts.method, opts.path);
+  } else if (type == 'Basic') {
+    return basic(user, pass);
+  }
+}
+
+////////////////////
+// basic
+
+function md5(string) {
+  return createHash('md5').update(string).digest('hex');
+}
+
+function basic(user, pass) {
+  var str  = typeof pass == 'undefined' ? user : [user, pass].join(':');
+  return 'Basic ' + new Buffer(str).toString('base64');
+}
+
+////////////////////
+// digest
+// logic inspired from https://github.com/simme/node-http-digest-client
+
+var digest = {};
+
+digest.parse_header = function(header) {
+  var challenge = {},
+      matches   = header.match(/([a-z0-9_-]+)="?([a-z0-9=\/\.@\s-]+)"?/gi);
+
+  for (var i = 0, l = matches.length; i < l; i++) {
+    var parts = matches[i].split('='),
+        key   = parts.shift(),
+        val   = parts.join('=').replace(/^"/, '').replace(/"$/, '');
+
+    challenge[key] = val;
+  }
+
+  return challenge;
+}
+
+digest.update_nc = function(nc) {
+  var max = 99999999;
+  nc++;
+
+  if (nc > max)
+    nc = 1;
+
+  var padding = new Array(8).join('0') + '';
+  nc = nc + '';
+  return padding.substr(0, 8 - nc.length) + nc;
+}
+
+digest.generate = function(header, user, pass, method, path) {
+
+  var nc        = 1,
+      cnonce    = null,
+      challenge = digest.parse_header(header);
+
+  var ha1  = md5(user + ':' + challenge.realm + ':' + pass),
+      ha2  = md5(method.toUpperCase() + ':' + path),
+      resp = [ha1, challenge.nonce];
+
+  if (typeof challenge.qop === 'string') {
+    cnonce = md5(Math.random().toString(36)).substr(0, 8);
+    nc     = digest.update_nc(nc);
+    resp   = resp.concat(nc, cnonce);
+  }
+
+  resp = resp.concat(challenge.qop, ha2);
+
+  var params = {
+    uri      : path,
+    realm    : challenge.realm,
+    nonce    : challenge.nonce,
+    username : user,
+    response : md5(resp.join(':'))
+  }
+
+  if (challenge.qop) {
+    params.qop = challenge.qop;
+  }
+
+  if (challenge.opaque) {
+    params.opaque = challenge.opaque;
+  }
+
+  if (cnonce) {
+    params.nc = nc;
+    params.cnonce = cnonce;
+  }
+
+  header = []
+  for (var k in params)
+    header.push(k + '="' + params[k] + '"')
+
+  return 'Digest ' + header.join(', ');
+}
+
+module.exports = {
+  header : get_header,
+  basic  : basic,
+  digest : digest.generate
+}

package/node_modules/needle/lib/cookies.js

@@ -0,0 +1,79 @@
+
+//  Simple cookie handling implementation based on the standard RFC 6265.
+//
+//  This module just has two functionalities:
+//    - Parse a set-cookie-header as a key value object
+//    - Write a cookie-string from a key value object
+//
+//  All cookie attributes are ignored.
+
+var unescape = require('querystring').unescape;
+
+var COOKIE_PAIR        = /^([^=\s]+)\s*=\s*("?)\s*(.*)\s*\2\s*$/;
+var EXCLUDED_CHARS     = /[\x00-\x1F\x7F\x3B\x3B\s\"\,\\"%]/g;
+var TRAILING_SEMICOLON = /\x3B+$/;
+var SEP_SEMICOLON      = /\s*\x3B\s*/;
+
+// i know these should be 'const', but I'd like to keep
+// supporting earlier node.js versions as long as I can. :)
+
+var KEY_INDEX   = 1; // index of key from COOKIE_PAIR match
+var VALUE_INDEX = 3; // index of value from COOKIE_PAIR match
+
+// Returns a copy str trimmed and without trainling semicolon.
+function cleanCookieString(str) {
+  return str.trim().replace(/\x3B+$/, '');
+}
+
+function getFirstPair(str) {
+  var index = str.indexOf('\x3B');
+  return index === -1 ? str : str.substr(0, index);
+}
+
+// Returns a encoded copy of str based on RFC6265 S4.1.1.
+function encodeCookieComponent(str) {
+  return str.toString().replace(EXCLUDED_CHARS, encodeURIComponent);
+}
+
+// Parses a set-cookie-string based on the standard defined in RFC6265 S4.1.1.
+function parseSetCookieString(str) {
+  str = cleanCookieString(str);
+  str = getFirstPair(str);
+
+  var res = COOKIE_PAIR.exec(str);
+  if (!res || !res[VALUE_INDEX]) return null;
+
+  return {
+    name  : unescape(res[KEY_INDEX]),
+    value : unescape(res[VALUE_INDEX])
+  };
+}
+
+// Parses a set-cookie-header and returns a key/value object.
+// Each key represents the name of a cookie.
+function parseSetCookieHeader(header) {
+  if (!header) return {};
+  header = Array.isArray(header) ? header : [header];
+
+  return header.reduce(function(res, str) {
+    var cookie = parseSetCookieString(str);
+    if (cookie) res[cookie.name] = cookie.value;
+    return res;
+  }, {});
+}
+
+// Writes a set-cookie-string based on the standard definded in RFC6265 S4.1.1.
+function writeCookieString(obj) {
+  return Object.keys(obj).reduce(function(str, name) {
+    var encodedName  = encodeCookieComponent(name);
+    var encodedValue = encodeCookieComponent(obj[name]);
+    str += (str ? '; ' : '') + encodedName + '=' + encodedValue;
+    return str;
+  }, '');
+}
+
+// returns a key/val object from an array of cookie strings
+exports.read = parseSetCookieHeader;
+
+// writes a cookie string header
+exports.write = writeCookieString;

package/node_modules/needle/lib/decoder.js

@@ -0,0 +1,53 @@
+var iconv,
+    inherits  = require('util').inherits,
+    stream    = require('stream');
+
+var regex = /(?:charset|encoding)\s*=\s*['"]? *([\w\-]+)/i;
+
+inherits(StreamDecoder, stream.Transform);
+
+function StreamDecoder(charset) {
+  if (!(this instanceof StreamDecoder))
+    return new StreamDecoder(charset);
+
+  stream.Transform.call(this, charset);
+  this.charset = charset;
+  this.parsed_chunk = false;
+}
+
+StreamDecoder.prototype._transform = function(chunk, encoding, done) {
+  var res, found;
+
+  // try get charset from chunk, just once
+  if (this.charset == 'iso-8859-1' && !this.parsed_chunk) {
+    this.parsed_chunk = true;
+
+    var matches = regex.exec(chunk.toString());
+    if (matches) {
+      found = matches[1].toLowerCase();
+      this.charset = found == 'utf-8' ? 'utf8' : found;
+    }
+  }
+
+  try {
+    res = iconv.decode(chunk, this.charset);
+  } catch(e) { // something went wrong, just return original chunk
+    res = chunk;
+  }
+
+  this.push(res);
+  done();
+}
+
+module.exports = function(charset) {
+  try {
+    if (!iconv) iconv = require('iconv-lite');
+  } catch(e) {
+    /* iconv not found */
+  }
+
+  if (iconv)
+    return new StreamDecoder(charset);
+  else
+    return new stream.PassThrough;
+}

package/node_modules/needle/lib/multipart.js

@@ -0,0 +1,98 @@
+var readFile = require('fs').readFile,
+    basename = require('path').basename;
+
+exports.build = function(data, boundary, callback) {
+
+  if (typeof data != 'object' || typeof data.pipe == 'function')
+    return callback(new Error('Multipart builder expects data as key/val object.'));
+
+  var body   = '',
+      object = flatten(data),
+      count  = Object.keys(object).length;
+
+  if (count === 0)
+    return callback(new Error('Empty multipart body. Invalid data.'))
+
+  function done(err, section) {
+    if (err) return callback(err);
+    if (section) body += section;
+    --count || callback(null, body + '--' + boundary + '--');
+  };
+
+  for (var key in object) {
+    var value = object[key];
+    if (value === null || typeof value == 'undefined') {
+      done();
+    } else if (Buffer.isBuffer(value)) {
+      var part = { buffer: value, content_type: 'application/octet-stream' };
+      generate_part(key, part, boundary, done);
+    } else {
+      var part = (value.buffer || value.file || value.content_type) ? value : { value: value };
+      generate_part(key, part, boundary, done);
+    }
+  }
+
+}
+
+function generate_part(name, part, boundary, callback) {
+
+  var return_part = '--' + boundary + '\r\n';
+  return_part += 'Content-Disposition: form-data; name="' + name + '"';
+
+  function append(data, filename) {
+
+    if (data) {
+      var binary = part.content_type.indexOf('text') == -1;
+      return_part += '; filename="' + encodeURIComponent(filename) + '"\r\n';
+      if (binary) return_part += 'Content-Transfer-Encoding: binary\r\n';
+      return_part += 'Content-Type: ' + part.content_type + '\r\n\r\n';
+      return_part += binary ? data.toString('binary') : data.toString('utf8');
+    }
+
+    callback(null, return_part + '\r\n');
+  };
+
+  if ((part.file || part.buffer) && part.content_type) {
+
+    var filename = part.filename ? part.filename : part.file ? basename(part.file) : name;
+    if (part.buffer) return append(part.buffer, filename);
+
+    readFile(part.file, function(err, data) {
+      if (err) return callback(err);
+      append(data, filename);
+    });
+
+  } else {
+
+    if (typeof part.value == 'object')
+      return callback(new Error('Object received for ' + name + ', expected string.'))
+
+    if (part.content_type) {
+      return_part += '\r\n';
+      return_part += 'Content-Type: ' + part.content_type;
+    }
+
+    return_part += '\r\n\r\n';
+    return_part += new Buffer(String(part.value), 'utf8').toString('binary');
+    append();
+
+  }
+
+}
+
+// flattens nested objects for multipart body
+function flatten(object, into, prefix) {
+  into = into || {};
+
+  for(var key in object) {
+    var prefix_key = prefix ? prefix + '[' + key + ']' : key;
+    var prop = object[key];
+
+    if (prop && typeof prop === 'object' && !(prop.buffer || prop.file || prop.content_type))
+      flatten(prop, into, prefix_key)
+    else
+      into[prefix_key] = prop;
+  }
+
+  return into;
+}