qs 2.2.1 → 2.2.5

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+
+## [**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
+
+## [**2.2.2**](https://github.com/hapijs/qs/issues?milestone=11&state=closed)
+- [**#33**](https://github.com/hapijs/qs/issues/33) Error when plain object in a value
+- [**#34**](https://github.com/hapijs/qs/issues/34) use Object.prototype.hasOwnProperty.call instead of obj.hasOwnProperty
+- [**#24**](https://github.com/hapijs/qs/issues/24) Changelog? Semver?
+
+## [**2.2.1**](https://github.com/hapijs/qs/issues?milestone=10&state=closed)
+- [**#32**](https://github.com/hapijs/qs/issues/32) account for circular references properly, closes #31
+- [**#31**](https://github.com/hapijs/qs/issues/31) qs.parse stackoverflow on circular objects
+
+## [**2.2.0**](https://github.com/hapijs/qs/issues?milestone=9&state=closed)
+- [**#26**](https://github.com/hapijs/qs/issues/26) Don't use Buffer global if it's not present
+- [**#30**](https://github.com/hapijs/qs/issues/30) Bug when merging non-object values into arrays
+- [**#29**](https://github.com/hapijs/qs/issues/29) Don't call Utils.clone at the top of Utils.merge
+- [**#23**](https://github.com/hapijs/qs/issues/23) Ability to not limit parameters?
+
+## [**2.1.0**](https://github.com/hapijs/qs/issues?milestone=8&state=closed)
+- [**#22**](https://github.com/hapijs/qs/issues/22) Enable using a RegExp as delimiter
+
+## [**2.0.0**](https://github.com/hapijs/qs/issues?milestone=7&state=closed)
+- [**#18**](https://github.com/hapijs/qs/issues/18) Why is there arrayLimit?
+- [**#20**](https://github.com/hapijs/qs/issues/20) Configurable parametersLimit
+- [**#21**](https://github.com/hapijs/qs/issues/21) make all limits optional, for #18, for #20
+
+## [**1.2.2**](https://github.com/hapijs/qs/issues?milestone=6&state=closed)
+- [**#19**](https://github.com/hapijs/qs/issues/19) Don't overwrite null values
+
+## [**1.2.1**](https://github.com/hapijs/qs/issues?milestone=5&state=closed)
+- [**#16**](https://github.com/hapijs/qs/issues/16) ignore non-string delimiters
+- [**#15**](https://github.com/hapijs/qs/issues/15) Close code block
+
+## [**1.2.0**](https://github.com/hapijs/qs/issues?milestone=4&state=closed)
+- [**#12**](https://github.com/hapijs/qs/issues/12) Add optional delim argument
+- [**#13**](https://github.com/hapijs/qs/issues/13) fix #11: flattened keys in array are now correctly parsed
+
+## [**1.1.0**](https://github.com/hapijs/qs/issues?milestone=3&state=closed)
+- [**#7**](https://github.com/hapijs/qs/issues/7) Empty values of a POST array disappear after being submitted
+- [**#9**](https://github.com/hapijs/qs/issues/9) Should not omit equals signs (=) when value is null
+- [**#6**](https://github.com/hapijs/qs/issues/6) Minor grammar fix in README
+
+## [**1.0.2**](https://github.com/hapijs/qs/issues?milestone=2&state=closed)
+- [**#5**](https://github.com/hapijs/qs/issues/5) array holes incorrectly copied into object on large index
+

package/lib/parse.js

@@ -29,7 +29,7 @@ internals.parseValues = function (str, options) {
             var key = Utils.decode(part.slice(0, pos));
             var val = Utils.decode(part.slice(pos + 1));
 
-            if (!obj[key]) {
+            if (!obj.hasOwnProperty(key)) {
                 obj[key] = val;
             }
             else {
@@ -58,8 +58,10 @@ internals.parseObject = function (chain, val, options) {
     else {
         var cleanRoot = root[0] === '[' && root[root.length - 1] === ']' ? root.slice(1, root.length - 1) : root;
         var index = parseInt(cleanRoot, 10);
+        var indexString = '' + index;
         if (!isNaN(index) &&
             root !== cleanRoot &&
+            indexString === cleanRoot &&
             index <= options.arrayLimit) {
 
             obj = [];
@@ -138,16 +140,16 @@ module.exports = function (str, options) {
     options.arrayLimit = typeof options.arrayLimit === 'number' ? options.arrayLimit : internals.arrayLimit;
     options.parameterLimit = typeof options.parameterLimit === 'number' ? options.parameterLimit : internals.parameterLimit;
 
-    var tempObj = typeof str === 'string' ? internals.parseValues(str, options) : Utils.clone(str);
+    var tempObj = typeof str === 'string' ? internals.parseValues(str, options) : str;
     var obj = {};
 
     // Iterate over the keys and setup the new object
-    //
-    for (var key in tempObj) {
-        if (tempObj.hasOwnProperty(key)) {
-            var newObj = internals.parseKeys(key, tempObj[key], options);
-            obj = Utils.merge(obj, newObj);
-        }
+
+    var keys = Object.keys(tempObj);
+    for (var i = 0, il = keys.length; i < il; ++i) {
+        var key = keys[i];
+        var newObj = internals.parseKeys(key, tempObj[key], options);
+        obj = Utils.merge(obj, newObj);
     }
 
     return Utils.compact(obj);

package/lib/stringify.js

@@ -31,10 +31,14 @@ 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];
+        values = values.concat(internals.stringify(obj[key], prefix + '[' + key + ']'));
     }
 
     return values;
@@ -48,10 +52,10 @@ module.exports = function (obj, options) {
 
     var keys = [];
 
-    for (var key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            keys = keys.concat(internals.stringify(obj[key], key));
-        }
+    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));
     }
 
     return keys.join(delimiter);

package/lib/utils.js

@@ -20,68 +20,26 @@ exports.arrayToObject = function (source) {
 };
 
 
-exports.clone = function (source, refs) {
-
-    if (typeof source !== 'object' ||
-        source === null) {
-
-        return source;
-    }
-
-    if (exports.isBuffer(source)) {
-        return source.toString();
-    }
-
-    refs = refs || [];
-
-    var lookup = refs.indexOf(source);
-    if (lookup !== -1) {
-        return refs[lookup];
-    }
-
-    var copy = Array.isArray(source) ? [] : source;
-
-    refs.push(source);
-
-    for (var i in source) {
-        if (source.hasOwnProperty(i)) {
-            copy[i] = exports.clone(source[i], refs);
-        }
-    }
-
-    return copy;
-};
-
-
 exports.merge = function (target, source) {
 
     if (!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') {
+        target.push(source);
+        return target;
+    }
 
+    if (typeof target !== 'object') {
+        target = [target].concat(source);
         return target;
     }
 
-    if (Array.isArray(target)) {
-        if (typeof source !== 'object') {
-            target.push(source);
-            return target;
-        }
-        else {
-            target = exports.arrayToObject(target);
-        }
+    if (Array.isArray(target) &&
+        !Array.isArray(source)) {
+
+        target = exports.arrayToObject(target);
     }
 
     var keys = Object.keys(source);
@@ -89,18 +47,11 @@ exports.merge = function (target, source) {
         var key = keys[k];
         var value = source[key];
 
-        if (value &&
-            typeof value === 'object') {
-
-            if (!target[key]) {
-                target[key] = exports.clone(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);
         }
     }
 
@@ -146,10 +97,10 @@ exports.compact = function (obj, refs) {
         return compacted;
     }
 
-    for (var key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            obj[key] = exports.compact(obj[key], refs);
-        }
+    var keys = Object.keys(obj);
+    for (var i = 0, il = keys.length; i < il; ++i) {
+        var key = keys[i];
+        obj[key] = exports.compact(obj[key], refs);
     }
 
     return obj;
@@ -163,10 +114,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,12 +1,12 @@
 {
   "name": "qs",
-  "version": "2.2.1",
+  "version": "2.2.5",
   "description": "A querystring parser that supports nesting and arrays, with a depth limit",
   "homepage": "https://github.com/hapijs/qs",
   "main": "index.js",
   "dependencies": {},
   "devDependencies": {
-    "lab": "3.x.x"
+    "lab": "4.x.x"
   },
   "scripts": {
     "test": "make test-cov"
@@ -19,7 +19,6 @@
     "querystring",
     "qs"
   ],
-  "author": "Nathan LaFreniere <quitlahok@gmail.com>",
   "licenses": [
     {
       "type": "BSD",

package/test/parse.js

@@ -11,14 +11,13 @@ var internals = {};
 
 // Test shortcuts
 
+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;
+var describe = lab.experiment;
+var it = lab.test;
 
 
-describe('#parse', function () {
+describe('parse()', function () {
 
     it('parses a simple string', function (done) {
 
@@ -81,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'] } });
@@ -103,6 +113,12 @@ describe('#parse', function () {
         done();
     });
 
+    it('supports keys that begin with a number', function (done) {
+
+        expect(Qs.parse('a[12b]=c')).to.deep.equal({ a: { '12b': 'c' } });
+        done();
+    });
+
     it('supports encoded = signs', function (done) {
 
         expect(Qs.parse('he%3Dllo=th%3Dere')).to.deep.equal({ 'he=llo': 'th=ere' });
@@ -189,6 +205,7 @@ describe('#parse', function () {
 
         expect(Qs.parse('a[]=b&a[]=&a[]=c')).to.deep.equal({ a: ['b', '', 'c'] });
         expect(Qs.parse('a[0]=b&a[1]=&a[2]=c&a[19]=')).to.deep.equal({ a: ['b', '', 'c', ''] });
+        expect(Qs.parse('a[]=&a[]=b&a[]=c')).to.deep.equal({ a: ['', 'b', 'c'] });
         done();
     });
 
@@ -205,10 +222,10 @@ describe('#parse', function () {
         done();
     });
 
-    it('parses buffers to strings', function (done) {
+    it('parses buffers correctly', function (done) {
 
         var b = new Buffer('test');
-        expect(Qs.parse({ a: b })).to.deep.equal({ a: b.toString() });
+        expect(Qs.parse({ a: b })).to.deep.equal({ a: b });
         done();
     });
 
@@ -356,4 +373,28 @@ describe('#parse', function () {
         expect(parsed.foo.baz).to.deep.equal(a);
         done();
     });
+
+    it('parses plain objects correctly', function (done) {
+
+        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();
+    });
+
+    it('parses dates correctly', function (done) {
+
+        var now = new Date();
+        expect(Qs.parse({ a: now })).to.deep.equal({ a: now });
+        done();
+    });
+
+    it('parses regular expressions correctly', function (done) {
+
+        var re = /^test$/;
+        expect(Qs.parse({ a: re })).to.deep.equal({ a: re });
+        done();
+    });
 });

package/test/stringify.js

@@ -11,14 +11,13 @@ var internals = {};
 
 // Test shortcuts
 
+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;
+var describe = lab.experiment;
+var it = lab.test;
 
 
-describe('#stringify', function () {
+describe('stringify()', function () {
 
     it('stringifies a querystring object', function (done) {
 
@@ -69,6 +68,25 @@ 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('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('');