qs 2.2.4 → 2.3.2

package/CHANGELOG.md

@@ -1,4 +1,18 @@
 
+## [**2.3.1**](https://github.com/hapijs/qs/issues?milestone=16&state=closed)
+- [**#52**](https://github.com/hapijs/qs/issues/52) Return "undefined" and "false" instead of throwing "TypeError".
+
+## [**2.3.0**](https://github.com/hapijs/qs/issues?milestone=15&state=closed)
+- [**#50**](https://github.com/hapijs/qs/issues/50) add option to omit array indices, closes #46
+
+## [**2.2.5**](https://github.com/hapijs/qs/issues?milestone=14&state=closed)
+- [**#39**](https://github.com/hapijs/qs/issues/39) Is there an alternative to Buffer.isBuffer?
+- [**#49**](https://github.com/hapijs/qs/issues/49) refactor utils.merge, fixes #45
+- [**#41**](https://github.com/hapijs/qs/issues/41) avoid browserifying Buffer, for #39
+
+## [**2.2.4**](https://github.com/hapijs/qs/issues?milestone=13&state=closed)
+- [**#38**](https://github.com/hapijs/qs/issues/38) how to handle object keys beginning with a number
+
 ## [**2.2.3**](https://github.com/hapijs/qs/issues?milestone=12&state=closed)
 - [**#37**](https://github.com/hapijs/qs/issues/37) parser discards first empty value in array
 - [**#36**](https://github.com/hapijs/qs/issues/36) Update to lab 4.x

package/README.md

@@ -184,13 +184,20 @@ Qs.stringify({ a: { b: 'c' } });
 
 Examples beyond this point will be shown as though the output is not URI encoded for clarity. Please note that the return values in these cases *will* be URI encoded during real usage.
 
-When arrays are stringified, they are always given explicit indices:
+When arrays are stringified, by default they are given explicit indices:
 
 ```javascript
 Qs.stringify({ a: ['b', 'c', 'd'] });
 // 'a[0]=b&a[1]=c&a[2]=d'
 ```
 
+You may override this by setting the `indices` option to `false`:
+
+```javascript
+Qs.stringify({ a: ['b', 'c', 'd'] }, { indices: false });
+// 'a=b&a=c&a=d'
+```
+
 Empty strings and null values will omit the value, but the equals sign (=) remains in place:
 
 ```javascript

package/lib/stringify.js

@@ -6,11 +6,12 @@ var Utils = require('./utils');
 // Declare internals
 
 var internals = {
-    delimiter: '&'
+    delimiter: '&',
+    indices: true
 };
 
 
-internals.stringify = function (obj, prefix) {
+internals.stringify = function (obj, prefix, options) {
 
     if (Utils.isBuffer(obj)) {
         obj = obj.toString();
@@ -31,9 +32,20 @@ internals.stringify = function (obj, prefix) {
 
     var values = [];
 
-    for (var key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            values = values.concat(internals.stringify(obj[key], prefix + '[' + key + ']'));
+    if (typeof obj === 'undefined') {
+        return values;
+    }
+
+    var objKeys = Object.keys(obj);
+    for (var i = 0, il = objKeys.length; i < il; ++i) {
+        var key = objKeys[i];
+        if (!options.indices &&
+            Array.isArray(obj)) {
+
+            values = values.concat(internals.stringify(obj[key], prefix, options));
+        }
+        else {
+            values = values.concat(internals.stringify(obj[key], prefix + '[' + key + ']', options));
         }
     }
 
@@ -45,13 +57,20 @@ module.exports = function (obj, options) {
 
     options = options || {};
     var delimiter = typeof options.delimiter === 'undefined' ? internals.delimiter : options.delimiter;
+    options.indices = typeof options.indices === 'boolean' ? options.indices : internals.indices;
 
     var keys = [];
 
-    for (var key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            keys = keys.concat(internals.stringify(obj[key], key));
-        }
+    if (typeof obj !== 'object' ||
+        obj === null) {
+
+        return '';
+    }
+
+    var objKeys = Object.keys(obj);
+    for (var i = 0, il = objKeys.length; i < il; ++i) {
+        var key = objKeys[i];
+        keys = keys.concat(internals.stringify(obj[key], key, options));
     }
 
     return keys.join(delimiter);

package/lib/utils.js

@@ -26,29 +26,26 @@ exports.merge = function (target, source) {
         return target;
     }
 
-    if (Array.isArray(source)) {
-        for (var i = 0, il = source.length; i < il; ++i) {
-            if (typeof source[i] !== 'undefined') {
-                if (typeof target[i] === 'object') {
-                    target[i] = exports.merge(target[i], source[i]);
-                }
-                else {
-                    target[i] = source[i];
-                }
-            }
+    if (typeof source !== 'object') {
+        if (Array.isArray(target)) {
+            target.push(source);
+        }
+        else {
+            target[source] = true;
         }
 
         return target;
     }
 
-    if (Array.isArray(target)) {
-        if (typeof source !== 'object') {
-            target.push(source);
-            return target;
-        }
-        else {
-            target = exports.arrayToObject(target);
-        }
+    if (typeof target !== 'object') {
+        target = [target].concat(source);
+        return target;
+    }
+
+    if (Array.isArray(target) &&
+        !Array.isArray(source)) {
+
+        target = exports.arrayToObject(target);
     }
 
     var keys = Object.keys(source);
@@ -56,18 +53,11 @@ exports.merge = function (target, source) {
         var key = keys[k];
         var value = source[key];
 
-        if (value &&
-            typeof value === 'object') {
-
-            if (!target[key]) {
-                target[key] = value;
-            }
-            else {
-                target[key] = exports.merge(target[key], value);
-            }
+        if (!target[key]) {
+            target[key] = value;
         }
         else {
-            target[key] = value;
+            target[key] = exports.merge(target[key], value);
         }
     }
 
@@ -130,10 +120,13 @@ exports.isRegExp = function (obj) {
 
 exports.isBuffer = function (obj) {
 
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.isBuffer(obj);
-    }
-    else {
+    if (obj === null ||
+        typeof obj === 'undefined') {
+
         return false;
     }
+
+    return !!(obj.constructor &&
+        obj.constructor.isBuffer &&
+        obj.constructor.isBuffer(obj));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qs",
-  "version": "2.2.4",
+  "version": "2.3.2",
   "description": "A querystring parser that supports nesting and arrays, with a depth limit",
   "homepage": "https://github.com/hapijs/qs",
   "main": "index.js",
@@ -19,7 +19,6 @@
     "querystring",
     "qs"
   ],
-  "author": "Nathan LaFreniere <quitlahok@gmail.com>",
   "licenses": [
     {
       "type": "BSD",

package/test/parse.js

@@ -13,13 +13,11 @@ var internals = {};
 
 var lab = exports.lab = Lab.script();
 var expect = Lab.expect;
-var before = lab.before;
-var after = lab.after;
 var describe = lab.experiment;
 var it = lab.test;
 
 
-describe('#parse', function () {
+describe('parse()', function () {
 
     it('parses a simple string', function (done) {
 
@@ -82,6 +80,17 @@ describe('#parse', function () {
         done();
     });
 
+    it('parses a mix of simple and explicit arrays', function (done) {
+
+        expect(Qs.parse('a=b&a[]=c')).to.deep.equal({ a: ['b', 'c'] });
+        expect(Qs.parse('a[]=b&a=c')).to.deep.equal({ a: ['b', 'c'] });
+        expect(Qs.parse('a[0]=b&a=c')).to.deep.equal({ a: ['b', 'c'] });
+        expect(Qs.parse('a=b&a[0]=c')).to.deep.equal({ a: ['b', 'c'] });
+        expect(Qs.parse('a[1]=b&a=c')).to.deep.equal({ a: ['b', 'c'] });
+        expect(Qs.parse('a=b&a[1]=c')).to.deep.equal({ a: ['b', 'c'] });
+        done();
+    });
+
     it('parses a nested array', function (done) {
 
         expect(Qs.parse('a[b][]=c&a[b][]=d')).to.deep.equal({ a: { b: ['c', 'd'] } });
@@ -149,6 +158,12 @@ describe('#parse', function () {
         done();
     });
 
+    it('can add keys to objects', function (done) {
+
+        expect(Qs.parse('a[b]=c&a=d')).to.deep.equal({ a: { b: 'c', d: true } });
+        done();
+    });
+
     it('correctly prunes undefined values when converting an array to an object', function (done) {
 
         expect(Qs.parse('a[2]=b&a[99999999]=c')).to.deep.equal({ a: { '2': 'b', '99999999': 'c' } });
@@ -369,7 +384,7 @@ describe('#parse', function () {
 
         var a = Object.create(null);
         a.b = 'c';
-        
+
         expect(Qs.parse(a)).to.deep.equal({ b: 'c' });
         expect(Qs.parse({ a: a })).to.deep.equal({ a: { b: 'c' } });
         done();

package/test/stringify.js

@@ -13,13 +13,11 @@ var internals = {};
 
 var lab = exports.lab = Lab.script();
 var expect = Lab.expect;
-var before = lab.before;
-var after = lab.after;
 var describe = lab.experiment;
 var it = lab.test;
 
 
-describe('#stringify', function () {
+describe('stringify()', function () {
 
     it('stringifies a querystring object', function (done) {
 
@@ -42,6 +40,12 @@ describe('#stringify', function () {
         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');
@@ -55,6 +59,12 @@ describe('#stringify', function () {
         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('stringifies a complicated object', function (done) {
 
         expect(Qs.stringify({ a: { b: 'c', d: 'e' } })).to.equal('a%5Bb%5D=c&a%5Bd%5D=e');
@@ -70,6 +80,34 @@ describe('#stringify', function () {
         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('');