fsevents 0.3.8 → 1.0.0

package/node_modules/node-pre-gyp/node_modules/request/node_modules/qs/test/stringify.js

@@ -0,0 +1,259 @@
+/* eslint no-extend-native:0 */
+// Load modules
+
+var Code = require('code');
+var Lab = require('lab');
+var Qs = require('../');
+
+
+// Declare internals
+
+var internals = {};
+
+
+// Test shortcuts
+
+var lab = exports.lab = Lab.script();
+var expect = Code.expect;
+var describe = lab.experiment;
+var it = lab.test;
+
+
+describe('stringify()', function () {
+
+    it('stringifies a querystring object', function (done) {
+
+        expect(Qs.stringify({ a: 'b' })).to.equal('a=b');
+        expect(Qs.stringify({ a: 1 })).to.equal('a=1');
+        expect(Qs.stringify({ a: 1, b: 2 })).to.equal('a=1&b=2');
+        expect(Qs.stringify({ a: 'A_Z' })).to.equal('a=A_Z');
+        expect(Qs.stringify({ a: '€' })).to.equal('a=%E2%82%AC');
+        expect(Qs.stringify({ a: '' })).to.equal('a=%EE%80%80');
+        expect(Qs.stringify({ a: 'א' })).to.equal('a=%D7%90');
+        expect(Qs.stringify({ a: '𐐷' })).to.equal('a=%F0%90%90%B7');
+        done();
+    });
+
+    it('stringifies a nested object', function (done) {
+
+        expect(Qs.stringify({ a: { b: 'c' } })).to.equal('a%5Bb%5D=c');
+        expect(Qs.stringify({ a: { b: { c: { d: 'e' } } } })).to.equal('a%5Bb%5D%5Bc%5D%5Bd%5D=e');
+        done();
+    });
+
+    it('stringifies an array value', function (done) {
+
+        expect(Qs.stringify({ a: ['b', 'c', 'd'] })).to.equal('a%5B0%5D=b&a%5B1%5D=c&a%5B2%5D=d');
+        done();
+    });
+
+    it('omits array indices when asked', function (done) {
+
+        expect(Qs.stringify({ a: ['b', 'c', 'd'] }, { indices: false })).to.equal('a=b&a=c&a=d');
+        done();
+    });
+
+    it('stringifies a nested array value', function (done) {
+
+        expect(Qs.stringify({ a: { b: ['c', 'd'] } })).to.equal('a%5Bb%5D%5B0%5D=c&a%5Bb%5D%5B1%5D=d');
+        done();
+    });
+
+    it('stringifies an object inside an array', function (done) {
+
+        expect(Qs.stringify({ a: [{ b: 'c' }] })).to.equal('a%5B0%5D%5Bb%5D=c');
+        expect(Qs.stringify({ a: [{ b: { c: [1] } }] })).to.equal('a%5B0%5D%5Bb%5D%5Bc%5D%5B0%5D=1');
+        done();
+    });
+
+    it('does not omit object keys when indices = false', function (done) {
+
+        expect(Qs.stringify({ a: [{ b: 'c' }] }, { indices: false })).to.equal('a%5Bb%5D=c');
+        done();
+    });
+
+    it('uses indices notation for arrays when indices=true', function (done) {
+
+        expect(Qs.stringify({ a: ['b', 'c'] }, { indices: true })).to.equal('a%5B0%5D=b&a%5B1%5D=c');
+        done();
+    });
+
+    it('uses indices notation for arrays when no arrayFormat is specified', function (done) {
+
+        expect(Qs.stringify({ a: ['b', 'c'] })).to.equal('a%5B0%5D=b&a%5B1%5D=c');
+        done();
+    });
+
+    it('uses indices notation for arrays when no arrayFormat=indices', function (done) {
+
+        expect(Qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'indices' })).to.equal('a%5B0%5D=b&a%5B1%5D=c');
+        done();
+    });
+
+    it('uses repeat notation for arrays when no arrayFormat=repeat', function (done) {
+
+        expect(Qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'repeat' })).to.equal('a=b&a=c');
+        done();
+    });
+
+    it('uses brackets notation for arrays when no arrayFormat=brackets', function (done) {
+
+        expect(Qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'brackets' })).to.equal('a%5B%5D=b&a%5B%5D=c');
+        done();
+    });
+
+    it('stringifies a complicated object', function (done) {
+
+        expect(Qs.stringify({ a: { b: 'c', d: 'e' } })).to.equal('a%5Bb%5D=c&a%5Bd%5D=e');
+        done();
+    });
+
+    it('stringifies an empty value', function (done) {
+
+        expect(Qs.stringify({ a: '' })).to.equal('a=');
+        expect(Qs.stringify({ a: null }, { strictNullHandling: true })).to.equal('a');
+
+        expect(Qs.stringify({ a: '', b: '' })).to.equal('a=&b=');
+        expect(Qs.stringify({ a: null, b: '' }, { strictNullHandling: true })).to.equal('a&b=');
+
+        expect(Qs.stringify({ a: { b: '' } })).to.equal('a%5Bb%5D=');
+        expect(Qs.stringify({ a: { b: null } }, { strictNullHandling: true })).to.equal('a%5Bb%5D');
+        expect(Qs.stringify({ a: { b: null } }, { strictNullHandling: false })).to.equal('a%5Bb%5D=');
+
+        done();
+    });
+
+    it('stringifies an empty object', function (done) {
+
+        var obj = Object.create(null);
+        obj.a = 'b';
+        expect(Qs.stringify(obj)).to.equal('a=b');
+        done();
+    });
+
+    it('returns an empty string for invalid input', function (done) {
+
+        expect(Qs.stringify(undefined)).to.equal('');
+        expect(Qs.stringify(false)).to.equal('');
+        expect(Qs.stringify(null)).to.equal('');
+        expect(Qs.stringify('')).to.equal('');
+        done();
+    });
+
+    it('stringifies an object with an empty object as a child', function (done) {
+
+        var obj = {
+            a: Object.create(null)
+        };
+
+        obj.a.b = 'c';
+        expect(Qs.stringify(obj)).to.equal('a%5Bb%5D=c');
+        done();
+    });
+
+    it('drops keys with a value of undefined', function (done) {
+
+        expect(Qs.stringify({ a: undefined })).to.equal('');
+
+        expect(Qs.stringify({ a: { b: undefined, c: null } }, { strictNullHandling: true })).to.equal('a%5Bc%5D');
+        expect(Qs.stringify({ a: { b: undefined, c: null } }, { strictNullHandling: false })).to.equal('a%5Bc%5D=');
+        expect(Qs.stringify({ a: { b: undefined, c: '' } })).to.equal('a%5Bc%5D=');
+        done();
+    });
+
+    it('url encodes values', function (done) {
+
+        expect(Qs.stringify({ a: 'b c' })).to.equal('a=b%20c');
+        done();
+    });
+
+    it('stringifies a date', function (done) {
+
+        var now = new Date();
+        var str = 'a=' + encodeURIComponent(now.toISOString());
+        expect(Qs.stringify({ a: now })).to.equal(str);
+        done();
+    });
+
+    it('stringifies the weird object from qs', function (done) {
+
+        expect(Qs.stringify({ 'my weird field': '~q1!2"\'w$5&7/z8)?' })).to.equal('my%20weird%20field=~q1%212%22%27w%245%267%2Fz8%29%3F');
+        done();
+    });
+
+    it('skips properties that are part of the object prototype', function (done) {
+
+        Object.prototype.crash = 'test';
+        expect(Qs.stringify({ a: 'b' })).to.equal('a=b');
+        expect(Qs.stringify({ a: { b: 'c' } })).to.equal('a%5Bb%5D=c');
+        delete Object.prototype.crash;
+        done();
+    });
+
+    it('stringifies boolean values', function (done) {
+
+        expect(Qs.stringify({ a: true })).to.equal('a=true');
+        expect(Qs.stringify({ a: { b: true } })).to.equal('a%5Bb%5D=true');
+        expect(Qs.stringify({ b: false })).to.equal('b=false');
+        expect(Qs.stringify({ b: { c: false } })).to.equal('b%5Bc%5D=false');
+        done();
+    });
+
+    it('stringifies buffer values', function (done) {
+
+        expect(Qs.stringify({ a: new Buffer('test') })).to.equal('a=test');
+        expect(Qs.stringify({ a: { b: new Buffer('test') } })).to.equal('a%5Bb%5D=test');
+        done();
+    });
+
+    it('stringifies an object using an alternative delimiter', function (done) {
+
+        expect(Qs.stringify({ a: 'b', c: 'd' }, { delimiter: ';' })).to.equal('a=b;c=d');
+        done();
+    });
+
+    it('doesn\'t blow up when Buffer global is missing', function (done) {
+
+        var tempBuffer = global.Buffer;
+        delete global.Buffer;
+        expect(Qs.stringify({ a: 'b', c: 'd' })).to.equal('a=b&c=d');
+        global.Buffer = tempBuffer;
+        done();
+    });
+
+    it('selects properties when filter=array', function (done) {
+
+        expect(Qs.stringify({ a: 'b' }, { filter: ['a'] })).to.equal('a=b');
+        expect(Qs.stringify({ a: 1 }, { filter: [] })).to.equal('');
+        expect(Qs.stringify({ a: { b: [1, 2, 3, 4], c: 'd' }, c: 'f' }, { filter: ['a', 'b', 0, 2] })).to.equal('a%5Bb%5D%5B0%5D=1&a%5Bb%5D%5B2%5D=3');
+        done();
+
+    });
+
+    it('supports custom representations when filter=function', function (done) {
+
+        var calls = 0;
+        var obj = { a: 'b', c: 'd', e: { f: new Date(1257894000000) } };
+        var filterFunc = function (prefix, value) {
+
+            calls++;
+            if (calls === 1) {
+                expect(prefix).to.be.empty();
+                expect(value).to.equal(obj);
+            }
+            else if (prefix === 'c') {
+                return;
+            }
+            else if (value instanceof Date) {
+                expect(prefix).to.equal('e[f]');
+                return value.getTime();
+            }
+            return value;
+        };
+
+        expect(Qs.stringify(obj, { filter: filterFunc })).to.equal('a=b&e%5Bf%5D=1257894000000');
+        expect(calls).to.equal(5);
+        done();
+
+    });
+});

package/node_modules/node-pre-gyp/node_modules/request/node_modules/qs/test/utils.js

@@ -0,0 +1,28 @@
+// Load modules
+
+var Code = require('code');
+var Lab = require('lab');
+var Utils = require('../lib/utils');
+
+
+// Declare internals
+
+var internals = {};
+
+
+// Test shortcuts
+
+var lab = exports.lab = Lab.script();
+var expect = Code.expect;
+var describe = lab.experiment;
+var it = lab.test;
+
+
+describe('merge()', function () {
+
+    it('can merge two objects with the same key', function (done) {
+
+        expect(Utils.merge({ a: 'b' }, { a: 'c' })).to.deep.equal({ a: ['b', 'c'] });
+        done();
+    });
+});

package/node_modules/node-pre-gyp/node_modules/request/node_modules/stringstream/.npmignore

@@ -0,0 +1,15 @@
+lib-cov
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+
+pids
+logs
+results
+
+node_modules
+npm-debug.log

package/node_modules/node-pre-gyp/node_modules/request/node_modules/stringstream/.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - 0.4
+  - 0.6

package/node_modules/node-pre-gyp/node_modules/request/node_modules/stringstream/LICENSE.txt

@@ -0,0 +1,4 @@
+Copyright 2012 Michael Hart (michael.hart.au@gmail.com)
+
+This project is free software released under the MIT license:
+http://www.opensource.org/licenses/mit-license.php

package/node_modules/node-pre-gyp/node_modules/request/node_modules/stringstream/README.md

@@ -0,0 +1,38 @@
+# Decode streams into strings The Right Way(tm)
+
+```javascript
+var fs   = require('fs')
+var zlib = require('zlib')
+var strs = require('stringstream')
+
+var utf8Stream = fs.createReadStream('massiveLogFile.gz')
+  .pipe(zlib.createGunzip())
+  .pipe(strs('utf8'))
+```
+
+No need to deal with `setEncoding()` weirdness, just compose streams
+like they were supposed to be!
+
+Handles input and output encoding:
+
+```javascript
+// Stream from utf8 to hex to base64... Why not, ay.
+var hex64Stream = fs.createReadStream('myFile')
+  .pipe(strs('utf8', 'hex'))
+  .pipe(strs('hex', 'base64'))
+```
+
+Also deals with `base64` output correctly by aligning each emitted data
+chunk so that there are no dangling `=` characters:
+
+```javascript
+var stream = fs.createReadStream('myFile').pipe(strs('base64'))
+
+var base64Str = ''
+
+stream.on('data', function(data) { base64Str += data })
+stream.on('end', function() {
+  console.log('My base64 encoded file is: ' + base64Str) // Wouldn't work with setEncoding()
+  console.log('Original file is: ' + new Buffer(base64Str, 'base64'))
+})
+```

package/node_modules/node-pre-gyp/node_modules/request/node_modules/stringstream/example.js

@@ -0,0 +1,27 @@
+var fs   = require('fs')
+var zlib = require('zlib')
+var strs = require('stringstream')
+
+var utf8Stream = fs.createReadStream('massiveLogFile.gz')
+  .pipe(zlib.createGunzip())
+  .pipe(strs('utf8'))
+
+utf8Stream.pipe(process.stdout)
+
+// Stream from utf8 to hex to base64... Why not, ay.
+var hex64Stream = fs.createReadStream('myFile')
+  .pipe(strs('utf8', 'hex'))
+  .pipe(strs('hex', 'base64'))
+
+hex64Stream.pipe(process.stdout)
+
+// Deals with base64 correctly by aligning chunks
+var stream = fs.createReadStream('myFile').pipe(strs('base64'))
+
+var base64Str = ''
+
+stream.on('data', function(data) { base64Str += data })
+stream.on('end', function() {
+  console.log('My base64 encoded file is: ' + base64Str) // Wouldn't work with setEncoding()
+  console.log('Original file is: ' + new Buffer(base64Str, 'base64'))
+})

package/node_modules/node-pre-gyp/node_modules/request/node_modules/stringstream/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "stringstream",
+  "version": "0.0.4",
+  "description": "Encode and decode streams into string streams",
+  "author": {
+    "name": "Michael Hart",
+    "email": "michael.hart.au@gmail.com",
+    "url": "http://github.com/mhart"
+  },
+  "main": "stringstream.js",
+  "keywords": [
+    "string",
+    "stream",
+    "base64",
+    "gzip"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mhart/StringStream.git"
+  },
+  "license": "MIT",
+  "readme": "# Decode streams into strings The Right Way(tm)\n\n```javascript\nvar fs   = require('fs')\nvar zlib = require('zlib')\nvar strs = require('stringstream')\n\nvar utf8Stream = fs.createReadStream('massiveLogFile.gz')\n  .pipe(zlib.createGunzip())\n  .pipe(strs('utf8'))\n```\n\nNo need to deal with `setEncoding()` weirdness, just compose streams\nlike they were supposed to be!\n\nHandles input and output encoding:\n\n```javascript\n// Stream from utf8 to hex to base64... Why not, ay.\nvar hex64Stream = fs.createReadStream('myFile')\n  .pipe(strs('utf8', 'hex'))\n  .pipe(strs('hex', 'base64'))\n```\n\nAlso deals with `base64` output correctly by aligning each emitted data\nchunk so that there are no dangling `=` characters:\n\n```javascript\nvar stream = fs.createReadStream('myFile').pipe(strs('base64'))\n\nvar base64Str = ''\n\nstream.on('data', function(data) { base64Str += data })\nstream.on('end', function() {\n  console.log('My base64 encoded file is: ' + base64Str) // Wouldn't work with setEncoding()\n  console.log('Original file is: ' + new Buffer(base64Str, 'base64'))\n})\n```\n",
+  "readmeFilename": "README.md",
+  "_id": "stringstream@0.0.4",
+  "dist": {
+    "shasum": "0f0e3423f942960b5692ac324a57dd093bc41a92",
+    "tarball": "http://registry.npmjs.org/stringstream/-/stringstream-0.0.4.tgz"
+  },
+  "_npmVersion": "1.2.0",
+  "_npmUser": {
+    "name": "hichaelmart",
+    "email": "michael.hart.au@gmail.com"
+  },
+  "maintainers": [
+    {
+      "name": "hichaelmart",
+      "email": "michael.hart.au@gmail.com"
+    }
+  ],
+  "directories": {},
+  "_shasum": "0f0e3423f942960b5692ac324a57dd093bc41a92",
+  "_from": "stringstream@~0.0.4",
+  "_resolved": "https://registry.npmjs.org/stringstream/-/stringstream-0.0.4.tgz",
+  "bugs": {
+    "url": "https://github.com/mhart/StringStream/issues"
+  },
+  "homepage": "https://github.com/mhart/StringStream",
+  "scripts": {}
+}

package/node_modules/node-pre-gyp/node_modules/request/node_modules/stringstream/stringstream.js

@@ -0,0 +1,102 @@
+var util = require('util')
+var Stream = require('stream')
+var StringDecoder = require('string_decoder').StringDecoder
+
+module.exports = StringStream
+module.exports.AlignedStringDecoder = AlignedStringDecoder
+
+function StringStream(from, to) {
+  if (!(this instanceof StringStream)) return new StringStream(from, to)
+
+  Stream.call(this)
+
+  if (from == null) from = 'utf8'
+
+  this.readable = this.writable = true
+  this.paused = false
+  this.toEncoding = (to == null ? from : to)
+  this.fromEncoding = (to == null ? '' : from)
+  this.decoder = new AlignedStringDecoder(this.toEncoding)
+}
+util.inherits(StringStream, Stream)
+
+StringStream.prototype.write = function(data) {
+  if (!this.writable) {
+    var err = new Error('stream not writable')
+    err.code = 'EPIPE'
+    this.emit('error', err)
+    return false
+  }
+  if (this.fromEncoding) {
+    if (Buffer.isBuffer(data)) data = data.toString()
+    data = new Buffer(data, this.fromEncoding)
+  }
+  var string = this.decoder.write(data)
+  if (string.length) this.emit('data', string)
+  return !this.paused
+}
+
+StringStream.prototype.flush = function() {
+  if (this.decoder.flush) {
+    var string = this.decoder.flush()
+    if (string.length) this.emit('data', string)
+  }
+}
+
+StringStream.prototype.end = function() {
+  if (!this.writable && !this.readable) return
+  this.flush()
+  this.emit('end')
+  this.writable = this.readable = false
+  this.destroy()
+}
+
+StringStream.prototype.destroy = function() {
+  this.decoder = null
+  this.writable = this.readable = false
+  this.emit('close')
+}
+
+StringStream.prototype.pause = function() {
+  this.paused = true
+}
+
+StringStream.prototype.resume = function () {
+  if (this.paused) this.emit('drain')
+  this.paused = false
+}
+
+function AlignedStringDecoder(encoding) {
+  StringDecoder.call(this, encoding)
+
+  switch (this.encoding) {
+    case 'base64':
+      this.write = alignedWrite
+      this.alignedBuffer = new Buffer(3)
+      this.alignedBytes = 0
+      break
+  }
+}
+util.inherits(AlignedStringDecoder, StringDecoder)
+
+AlignedStringDecoder.prototype.flush = function() {
+  if (!this.alignedBuffer || !this.alignedBytes) return ''
+  var leftover = this.alignedBuffer.toString(this.encoding, 0, this.alignedBytes)
+  this.alignedBytes = 0
+  return leftover
+}
+
+function alignedWrite(buffer) {
+  var rem = (this.alignedBytes + buffer.length) % this.alignedBuffer.length
+  if (!rem && !this.alignedBytes) return buffer.toString(this.encoding)
+
+  var returnBuffer = new Buffer(this.alignedBytes + buffer.length - rem)
+
+  this.alignedBuffer.copy(returnBuffer, 0, 0, this.alignedBytes)
+  buffer.copy(returnBuffer, this.alignedBytes, 0, buffer.length - rem)
+
+  buffer.copy(this.alignedBuffer, 0, buffer.length - rem, buffer.length)
+  this.alignedBytes = rem
+
+  return returnBuffer.toString(this.encoding)
+}

package/node_modules/node-pre-gyp/node_modules/request/node_modules/tough-cookie/.editorconfig

@@ -0,0 +1,12 @@
+# This file is for unifying the coding style for different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2

package/node_modules/node-pre-gyp/node_modules/request/node_modules/tough-cookie/.jshintrc

@@ -0,0 +1,70 @@
+{
+    "passfail"      : false,
+    "maxerr"        : 100,
+
+    "browser"       : false,
+    "node"          : true,
+    "rhino"         : false,
+    "couch"         : false,
+    "wsh"           : false,
+
+    "jquery"        : false,
+    "prototypejs"   : false,
+    "mootools"      : false,
+    "dojo"          : false,
+
+    "debug"         : false,
+    "devel"         : false,
+
+    "esnext"        : true,
+    "strict"        : true,
+    "globalstrict"  : true,
+
+    "asi"           : false,
+    "laxbreak"      : false,
+    "bitwise"       : true,
+    "boss"          : false,
+    "curly"         : true,
+    "eqeqeq"        : false,
+    "eqnull"        : true,
+    "evil"          : false,
+    "expr"          : false,
+    "forin"         : false,
+    "immed"         : true,
+    "lastsemic"     : true,
+    "latedef"       : false,
+    "loopfunc"      : false,
+    "noarg"         : true,
+    "regexp"        : false,
+    "regexdash"     : false,
+    "scripturl"     : false,
+    "shadow"        : false,
+    "supernew"      : false,
+    "undef"         : true,
+    "unused"         : true,
+
+    "newcap"        : true,
+    "noempty"       : true,
+    "nonew"         : true,
+    "nomen"         : false,
+    "onevar"        : false,
+    "onecase"       : true,
+    "plusplus"      : false,
+    "proto"         : false,
+    "sub"           : true,
+    "trailing"      : true,
+    "white"         : false,
+
+    "predef": [
+      "describe",
+      "it",
+      "before",
+      "beforeEach",
+      "after",
+      "afterEach",
+      "expect",
+      "setTimeout",
+      "clearTimeout"
+    ],
+    "maxlen": 0
+}

package/node_modules/node-pre-gyp/node_modules/request/node_modules/tough-cookie/.npmignore

@@ -0,0 +1,4 @@
+.idea
+node_modules/
+.*.sw[nmop]
+npm-debug.log

package/node_modules/node-pre-gyp/node_modules/request/node_modules/tough-cookie/.travis.yml

@@ -0,0 +1,9 @@
+language: node_js
+node_js:
+- "0.10"
+- "0.12"
+- iojs
+matrix:
+  fast_finish: true
+  allow_failures:
+    - node_js: 0.11