fsevents 1.2.0 → 1.2.2

package/node_modules/needle/lib/parsers.js

@@ -0,0 +1,120 @@
+//////////////////////////////////////////
+// Defines mappings between content-type
+// and the appropriate parsers.
+//////////////////////////////////////////
+
+var Transform = require('stream').Transform;
+var sax = require('sax');
+
+function parseXML(str, cb) {
+  var obj, current, parser = sax.parser(true, { trim: true, lowercase: true })
+  parser.onerror = parser.onend = done;
+
+  function done(err) {
+    parser.onerror = parser.onend = function() { }
+    cb(err, obj)
+  }
+
+  function newElement(name, attributes) {
+    return {
+      name: name || '',
+      value: '',
+      attributes: attributes || {},
+      children: []
+    }
+  }
+
+  parser.ontext = function(t) {
+    if (current) current.value += t
+  }
+
+  parser.onopentag = function(node) {
+    var element = newElement(node.name, node.attributes)
+    if (current) {
+      element.parent = current
+      current.children.push(element)
+    } else { // root object
+      obj = element
+    }
+
+    current = element
+  };
+
+  parser.onclosetag = function() {
+    if (typeof current.parent !== 'undefined') {
+      var just_closed = current
+      current = current.parent
+      delete just_closed.parent
+    }
+  }
+
+  parser.write(str).close()
+}
+
+function parserFactory(name, fn) {
+
+  function parser() {
+    var chunks = [],
+        stream = new Transform({ objectMode: true });
+
+    // Buffer all our data
+    stream._transform = function(chunk, encoding, done) {
+      chunks.push(chunk);
+      done();
+    }
+
+    // And call the parser when all is there.
+    stream._flush = function(done) {
+      var self = this,
+          data = Buffer.concat(chunks);
+
+      try {
+        fn(data, function(err, result) {
+          if (err) throw err;
+          self.push(result);
+        });
+      } catch (err) {
+        self.push(data); // just pass the original data
+      } finally {
+        done();
+      }
+    }
+
+    return stream;
+  }
+
+  return { fn: parser, name: name };
+}
+
+var parsers = {}
+
+function buildParser(name, types, fn) {
+  var parser = parserFactory(name, fn);
+  types.forEach(function(type) {
+    parsers[type] = parser;
+  })
+}
+
+buildParser('json', [
+  'application/json',
+  'text/javascript'
+], function(buffer, cb) {
+  var err, data;
+  try { data = JSON.parse(buffer); } catch (e) { err = e; }
+  cb(err, data);
+});
+
+buildParser('xml', [
+  'text/xml',
+  'application/xml',
+  'application/rdf+xml',
+  'application/rss+xml',
+  'application/atom+xml'
+], function(buffer, cb) {
+  parseXML(buffer.toString(), function(err, obj) {
+    cb(err, obj)
+  })
+});
+
+module.exports = parsers;
+module.exports.use = buildParser;

package/node_modules/needle/lib/querystring.js

@@ -0,0 +1,49 @@
+// based on the qs module, but handles null objects as expected
+// fixes by Tomas Pollak.
+
+var toString = Object.prototype.toString;
+
+function stringify(obj, prefix) {
+  if (prefix && (obj === null || typeof obj == 'undefined')) {
+    return prefix + '=';
+  } else if (toString.call(obj) == '[object Array]') {
+    return stringifyArray(obj, prefix);
+  } else if (toString.call(obj) == '[object Object]') {
+    return stringifyObject(obj, prefix);
+  } else if (toString.call(obj) == '[object Date]') {
+    return obj.toISOString();
+  } else if (prefix) { // string inside array or hash
+    return prefix + '=' + encodeURIComponent(String(obj));
+  } else if (String(obj).indexOf('=') !== -1) { // string with equal sign
+    return String(obj);
+  } else {
+    throw new TypeError('Cannot build a querystring out of: ' + obj);
+  }
+};
+
+function stringifyArray(arr, prefix) {
+  var ret = [];
+
+  for (var i = 0, len = arr.length; i < len; i++) {
+    if (prefix)
+      ret.push(stringify(arr[i], prefix + '[]'));
+    else
+      ret.push(stringify(arr[i]));
+  }
+
+  return ret.join('&');
+}
+
+function stringifyObject(obj, prefix) {
+  var ret = [];
+
+  Object.keys(obj).forEach(function(key) {
+    ret.push(stringify(obj[key], prefix
+      ? prefix + '[' + encodeURIComponent(key) + ']'
+      : encodeURIComponent(key)));
+  })
+
+  return ret.join('&');
+}
+
+exports.build = stringify;

package/node_modules/{delayed-stream/License → needle/license.txt}

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Debuggable Limited <felix@debuggable.com>
+Copyright (c) Fork, Ltd.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -12,7 +12,7 @@ all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

package/node_modules/needle/package.json

@@ -0,0 +1,102 @@
+{
+  "_from": "needle@^2.2.0",
+  "_id": "needle@2.2.0",
+  "_inBundle": false,
+  "_integrity": "sha512-eFagy6c+TYayorXw/qtAdSvaUpEbBsDwDyxYFgLZ0lTojfH7K+OdBqAF7TAFwDokJaGpubpSGG0wO3iC0XPi8w==",
+  "_location": "/needle",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "needle@^2.2.0",
+    "name": "needle",
+    "escapedName": "needle",
+    "rawSpec": "^2.2.0",
+    "saveSpec": null,
+    "fetchSpec": "^2.2.0"
+  },
+  "_requiredBy": [
+    "/node-pre-gyp"
+  ],
+  "_resolved": "https://registry.npmjs.org/needle/-/needle-2.2.0.tgz",
+  "_shasum": "f14efc69cee1024b72c8b21c7bdf94a731dc12fa",
+  "_spec": "needle@^2.2.0",
+  "_where": "/Users/eshanker/Code/fsevents/node_modules/node-pre-gyp",
+  "author": {
+    "name": "Tomás Pollak",
+    "email": "tomas@forkhq.com"
+  },
+  "bin": {
+    "needle": "./bin/needle"
+  },
+  "bugs": {
+    "url": "https://github.com/tomas/needle/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "debug": "^2.1.2",
+    "iconv-lite": "^0.4.4",
+    "sax": "^1.2.4"
+  },
+  "deprecated": false,
+  "description": "The leanest and most handsome HTTP client in the Nodelands.",
+  "devDependencies": {
+    "JSONStream": "",
+    "jschardet": "",
+    "mocha": "",
+    "q": "",
+    "should": "",
+    "sinon": "",
+    "xml2js": ""
+  },
+  "directories": {
+    "lib": "./lib"
+  },
+  "engines": {
+    "node": ">= 0.10.x"
+  },
+  "homepage": "https://github.com/tomas/needle#readme",
+  "keywords": [
+    "http",
+    "https",
+    "simple",
+    "request",
+    "client",
+    "multipart",
+    "upload",
+    "proxy",
+    "deflate",
+    "timeout",
+    "charset",
+    "iconv",
+    "cookie",
+    "redirect"
+  ],
+  "license": "MIT",
+  "main": "./lib/needle",
+  "name": "needle",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tomas/needle.git"
+  },
+  "scripts": {
+    "test": "mocha test"
+  },
+  "tags": [
+    "http",
+    "https",
+    "simple",
+    "request",
+    "client",
+    "multipart",
+    "upload",
+    "proxy",
+    "deflate",
+    "timeout",
+    "charset",
+    "iconv",
+    "cookie",
+    "redirect"
+  ],
+  "version": "2.2.0"
+}

package/node_modules/needle/test/basic_auth_spec.js

@@ -0,0 +1,196 @@
+var helpers = require('./helpers'),
+    should  = require('should'),
+    needle  = require('./../'),
+    server;
+
+var port = 7707;
+
+describe('Basic Auth', function() {
+
+  before(function(done) {
+    server = helpers.server({ port: port }, done);
+  })
+
+  after(function(done) {
+    server.close(done);
+  })
+
+  ///////////////// helpers
+
+  var get_auth = function(header) {
+    var token  = header.split(/\s+/).pop();
+    return token && new Buffer(token, 'base64').toString().split(':');
+  }
+
+  describe('when neither username or password are passed', function() {
+
+    it('doesnt send any Authorization headers', function(done) {
+      needle.get('localhost:' + port, { parse: true }, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        Object.keys(sent_headers).should.not.containEql('authorization');
+        done();
+      })
+    })
+
+  })
+
+  describe('when username is an empty string, and password is a valid string', function() {
+
+    var opts = { username: '', password: 'foobar', parse: true };
+
+    it('doesnt send any Authorization headers', function(done) {
+      needle.get('localhost:' + port, { parse: true }, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        Object.keys(sent_headers).should.not.containEql('authorization');
+        done();
+      })
+    })
+
+  });
+
+  describe('when username is a valid string, but no username is passed', function() {
+
+    var opts = { username: 'foobar', parse: true };
+
+    it('sends Authorization header', function(done) {
+      needle.get('localhost:' + port, opts, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        Object.keys(sent_headers).should.containEql('authorization');
+        done();
+      })
+    })
+
+    it('Basic Auth only includes username, without colon', function(done) {
+      needle.get('localhost:' + port, opts, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        var auth = get_auth(sent_headers['authorization']);
+        auth[0].should.equal('foobar');
+        auth.should.have.lengthOf(1);
+        done();
+      })
+    })
+
+  })
+
+  describe('when username is a valid string, and password is null', function() {
+
+    var opts = { username: 'foobar', password: null, parse: true };
+
+    it('sends Authorization header', function(done) {
+      needle.get('localhost:' + port, opts, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        Object.keys(sent_headers).should.containEql('authorization');
+        done();
+      })
+    })
+
+    it('Basic Auth only includes both username and password', function(done) {
+      needle.get('localhost:' + port, opts, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        var auth = get_auth(sent_headers['authorization']);
+        auth[0].should.equal('foobar');
+        auth[1].should.equal('');
+        done();
+      })
+    })
+
+  })
+
+  describe('when username is a valid string, and password is an empty string', function() {
+
+    var opts = { username: 'foobar', password: '', parse: true };
+
+    it('sends Authorization header', function(done) {
+      needle.get('localhost:' + port, opts, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        Object.keys(sent_headers).should.containEql('authorization');
+        done();
+      })
+    })
+
+    it('Basic Auth only includes both username and password', function(done) {
+      needle.get('localhost:' + port, opts, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        var auth = get_auth(sent_headers['authorization']);
+        auth[0].should.equal('foobar');
+        auth[1].should.equal('');
+        auth.should.have.lengthOf(2);
+        done();
+      })
+    })
+
+  })
+
+  describe('when username AND password are non empty strings', function() {
+
+    var opts = { username: 'foobar', password: 'jakub', parse: true };
+
+    it('sends Authorization header', function(done) {
+      needle.get('localhost:' + port, opts, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        Object.keys(sent_headers).should.containEql('authorization');
+        done();
+      })
+    })
+
+    it('Basic Auth only includes both user and password', function(done) {
+      needle.get('localhost:' + port, opts, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        var auth = get_auth(sent_headers['authorization']);
+        auth[0].should.equal('foobar');
+        auth[1].should.equal('jakub');
+        auth.should.have.lengthOf(2);
+        done();
+      })
+    })
+
+  })
+
+  describe('URL with @ but not username/pass', function() {
+    it('doesnt send Authorization header', function(done) {
+      var url = 'localhost:' + port + '/abc/@def/xyz.zip';
+
+      needle.get(url, {}, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        Object.keys(sent_headers).should.not.containEql('authorization');
+        done();
+      })
+    })
+
+    it('sends user:pass headers if passed via options', function(done) {
+      var url = 'localhost:' + port + '/abc/@def/xyz.zip';
+
+      needle.get(url, { username: 'foo' }, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        Object.keys(sent_headers).should.containEql('authorization');
+        sent_headers['authorization'].should.eql('Basic Zm9v')
+        done();
+      })
+    })
+  })
+
+  describe('when username/password are included in URL', function() {
+    var opts = { parse: true };
+
+    it('sends Authorization header', function(done) {
+      needle.get('foobar:jakub@localhost:' + port, opts, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        Object.keys(sent_headers).should.containEql('authorization');
+        done();
+      })
+    })
+
+    it('Basic Auth only includes both user and password', function(done) {
+      needle.get('foobar:jakub@localhost:' + port, opts, function(err, resp) {
+        var sent_headers = resp.body.headers;
+        var auth = get_auth(sent_headers['authorization']);
+        auth[0].should.equal('foobar');
+        auth[1].should.equal('jakub');
+        auth.should.have.lengthOf(2);
+        done();
+      })
+    })
+
+  })
+
+})

package/node_modules/needle/test/compression_spec.js

@@ -0,0 +1,94 @@
+var should = require('should'),
+    needle = require('./../'),
+    http   = require('http'),
+    zlib   = require('zlib'),
+    stream = require('stream'),
+    port   = 11123,
+    server;
+
+describe('compression', function(){
+
+  require.bind(null, 'zlib').should.not.throw()
+
+  var jsonData = '{"foo":"bar"}';
+
+  describe('when server supports compression', function(){
+
+    before(function(){
+      server = http.createServer(function(req, res) {
+        var raw = new stream.PassThrough();
+
+        var acceptEncoding = req.headers['accept-encoding'];
+        if (!acceptEncoding) {
+          acceptEncoding = '';
+        }
+
+        if (acceptEncoding.match(/\bdeflate\b/)) {
+          res.setHeader('Content-Encoding', 'deflate');
+          raw.pipe(zlib.createDeflate()).pipe(res);
+        } else if (acceptEncoding.match(/\bgzip\b/)) {
+          res.setHeader('Content-Encoding', 'gzip');
+          raw.pipe(zlib.createGzip()).pipe(res);
+        } else {
+          raw.pipe(res);
+        }
+
+        res.setHeader('Content-Type', 'application/json')
+        if (req.headers['with-bad']) {
+          res.end('foo'); // end, no deflate data
+        } else {
+          raw.end(jsonData)
+        }
+
+      })
+
+      server.listen(port);
+    });
+
+    after(function(done){
+      server.close(done);
+    })
+
+    describe('and client requests no compression', function() {
+      it('should have the body decompressed', function(done){
+        needle.get('localhost:' + port, function(err, response, body){
+          should.ifError(err);
+          body.should.have.property('foo', 'bar');
+          response.bytes.should.equal(jsonData.length);
+          done();
+        })
+      })
+    })
+
+    describe('and client requests gzip compression', function() {
+      it('should have the body decompressed', function(done){
+        needle.get('localhost:' + port, {headers: {'Accept-Encoding': 'gzip'}}, function(err, response, body){
+          should.ifError(err);
+          body.should.have.property('foo', 'bar');
+          response.bytes.should.not.equal(jsonData.length);
+          done();
+        })
+      })
+    })
+
+    describe('and client requests deflate compression', function() {
+      it('should have the body decompressed', function(done){
+        needle.get('localhost:' + port, {headers: {'Accept-Encoding': 'deflate'}}, function(err, response, body){
+          should.ifError(err);
+          body.should.have.property('foo', 'bar');
+          response.bytes.should.not.equal(jsonData.length);
+          done();
+        })
+      })
+
+      it('should rethrow errors from decompressors', function(done){
+        needle.get('localhost:' + port, {headers: {'Accept-Encoding': 'deflate', 'With-Bad': 'true'}}, function(err, response, body) {
+          should.exist(err);
+          err.message.should.equal("incorrect header check");
+          err.code.should.equal("Z_DATA_ERROR")
+          done();
+        })
+      })
+    })
+  })
+})