qs 2.1.0 → 2.2.3

package/CHANGELOG.md

@@ -0,0 +1,78 @@
+
+## [**2.2.3**](https://github.com/hapijs/qs/issues?milestone=12&state=open)
+- [**#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.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.2**](https://github.com/hapijs/qs/issues?milestone=11&state=open)
+- [**#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?
+
+---
+
+
+# 2014-08-28
+95 commits against 24 issues, over a month [`32edf33`](https://github.com/hapijs/qs/commit/32edf33)⎆[`b1e7b53`](https://github.com/hapijs/qs/commit/b1e7b53)
+
+## [**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)
+- [**#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
+- [**#26**](https://github.com/hapijs/qs/issues/26) Don't use Buffer global if it's not present
+- [**#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)
+- [**#20**](https://github.com/hapijs/qs/issues/20) Configurable parametersLimit
+- [**#18**](https://github.com/hapijs/qs/issues/18) Why is there arrayLimit?
+- [**#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
+
+
+## Issues
+- [**#25**](https://github.com/hapijs/qs/issues/25) Remove references to Buffer
+- [**#11**](https://github.com/hapijs/qs/issues/11) Flattened keys in array does not parse correctly
+- [**#8**](https://github.com/hapijs/qs/issues/8) Square brackets should be URI encoded
+- [**#3**](https://github.com/hapijs/qs/issues/3) Update README.md
+- [**#2**](https://github.com/hapijs/qs/issues/2) Add travis and rework package
+

package/lib/parse.js

@@ -16,7 +16,7 @@ var internals = {
 internals.parseValues = function (str, options) {
 
     var obj = {};
-    var parts = str.split(options.delimiter, options.parameterLimit);
+    var parts = str.split(options.delimiter, options.parameterLimit === Infinity ? undefined : options.parameterLimit);
 
     for (var i = 0, il = parts.length; i < il; ++i) {
         var part = parts[i];
@@ -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 {
@@ -138,16 +138,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

@@ -1,5 +1,7 @@
 // Load modules
 
+var Utils = require('./utils');
+
 
 // Declare internals
 
@@ -10,7 +12,7 @@ var internals = {
 
 internals.stringify = function (obj, prefix) {
 
-    if (Buffer.isBuffer(obj)) {
+    if (Utils.isBuffer(obj)) {
         obj = obj.toString();
     }
     else if (obj instanceof Date) {

package/lib/utils.js

@@ -20,54 +20,35 @@ exports.arrayToObject = function (source) {
 };
 
 
-exports.clone = function (source) {
-
-    if (typeof source !== 'object' ||
-        source === null) {
-
-        return source;
-    }
-
-    if (Buffer.isBuffer(source)) {
-        return source.toString();
-    }
-
-    var obj = Array.isArray(source) ? [] : {};
-    for (var i in source) {
-        if (source.hasOwnProperty(i)) {
-            obj[i] = exports.clone(source[i]);
-        }
-    }
-
-    return obj;
-};
-
-
 exports.merge = function (target, source) {
 
     if (!source) {
         return target;
     }
 
-    var obj = exports.clone(target);
-
     if (Array.isArray(source)) {
         for (var i = 0, il = source.length; i < il; ++i) {
             if (typeof source[i] !== 'undefined') {
-                if (typeof obj[i] === 'object') {
-                    obj[i] = exports.merge(obj[i], source[i]);
+                if (typeof target[i] === 'object') {
+                    target[i] = exports.merge(target[i], source[i]);
                 }
                 else {
-                    obj[i] = source[i];
+                    target[i] = source[i];
                 }
             }
         }
 
-        return obj;
+        return target;
     }
 
-    if (Array.isArray(obj)) {
-        obj = exports.arrayToObject(obj);
+    if (Array.isArray(target)) {
+        if (typeof source !== 'object') {
+            target.push(source);
+            return target;
+        }
+        else {
+            target = exports.arrayToObject(target);
+        }
     }
 
     var keys = Object.keys(source);
@@ -78,19 +59,19 @@ exports.merge = function (target, source) {
         if (value &&
             typeof value === 'object') {
 
-            if (!obj[key]) {
-                obj[key] = exports.clone(value);
+            if (!target[key]) {
+                target[key] = value;
             }
             else {
-                obj[key] = exports.merge(obj[key], value);
+                target[key] = exports.merge(target[key], value);
             }
         }
         else {
-            obj[key] = value;
+            target[key] = value;
         }
     }
 
-    return obj;
+    return target;
 };
 
 
@@ -104,34 +85,55 @@ exports.decode = function (str) {
 };
 
 
-exports.compact = function (obj) {
+exports.compact = function (obj, refs) {
+
+    if (typeof obj !== 'object' ||
+        obj === null) {
 
-    if (typeof obj !== 'object' || obj === null) {
         return obj;
     }
 
-    var compacted = {};
+    refs = refs || [];
+    var lookup = refs.indexOf(obj);
+    if (lookup !== -1) {
+        return refs[lookup];
+    }
 
-    for (var key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            if (Array.isArray(obj[key])) {
-                compacted[key] = [];
+    refs.push(obj);
 
-                for (var i = 0, l = obj[key].length; i < l; i++) {
-                    if (typeof obj[key][i] !== 'undefined') {
-                        compacted[key].push(obj[key][i]);
-                    }
-                }
-            }
-            else {
-                compacted[key] = exports.compact(obj[key]);
+    if (Array.isArray(obj)) {
+        var compacted = [];
+
+        for (var i = 0, l = obj.length; i < l; ++i) {
+            if (typeof obj[i] !== 'undefined') {
+                compacted.push(obj[i]);
             }
         }
+
+        return compacted;
     }
 
-    return compacted;
+    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;
 };
 
+
 exports.isRegExp = function (obj) {
     return Object.prototype.toString.call(obj) === '[object RegExp]';
 };
+
+
+exports.isBuffer = function (obj) {
+
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.isBuffer(obj);
+    }
+    else {
+        return false;
+    }
+};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "qs",
-  "version": "2.1.0",
+  "version": "2.2.3",
   "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"

package/test/parse.js

@@ -11,11 +11,12 @@ 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 before = lab.before;
+var after = lab.after;
+var describe = lab.experiment;
+var it = lab.test;
 
 
 describe('#parse', function () {
@@ -189,6 +190,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 +207,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();
     });
 
@@ -271,6 +273,12 @@ describe('#parse', function () {
         done();
     });
 
+    it('allows setting the parameter limit to Infinity', function (done) {
+
+        expect(Qs.parse('a=b&c=d', { parameterLimit: Infinity })).to.deep.equal({ a: 'b', c: 'd' });
+        done();
+    });
+
     it('allows overriding array limit', function (done) {
 
         expect(Qs.parse('a[0]=b&a[1]=c', { arrayLimit: 0 })).to.deep.equal({ a: { '0': 'b', '1': 'c' } });
@@ -316,4 +324,62 @@ describe('#parse', function () {
         expect(result).to.deep.equal(expected);
         done();
     });
+
+    it('does not blow up when Buffer global is missing', function (done) {
+
+        var tempBuffer = global.Buffer;
+        delete global.Buffer;
+        expect(Qs.parse('a=b&c=d')).to.deep.equal({ a: 'b', c: 'd' });
+        global.Buffer = tempBuffer;
+        done();
+    });
+
+    it('does not crash when using invalid dot notation', function (done) {
+
+        expect(Qs.parse('roomInfoList[0].childrenAges[0]=15&roomInfoList[0].numberOfAdults=2')).to.deep.equal({ roomInfoList: [['15', '2']] });
+        done();
+    });
+
+    it('does not crash when parsing circular references', function (done) {
+
+        var a = {};
+        a.b = a;
+
+        var parsed;
+
+        expect(function () {
+
+            parsed = Qs.parse({ 'foo[bar]': 'baz', 'foo[baz]': a });
+        }).to.not.throw(Error);
+
+        expect(parsed).to.have.key('foo');
+        expect(parsed.foo).to.have.keys('bar', 'baz');
+        expect(parsed.foo.bar).to.equal('baz');
+        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,11 +11,12 @@ 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 before = lab.before;
+var after = lab.after;
+var describe = lab.experiment;
+var it = lab.test;
 
 
 describe('#stringify', function () {
@@ -126,4 +127,13 @@ describe('#stringify', function () {
         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();
+    });
 });