qs 2.3.1 → 2.4.1

package/.travis.yml

@@ -1,4 +1,6 @@
 language: node_js
 
 node_js:
-  - 0.10
+  - 0.10
+  - 0.12
+  - iojs

package/CHANGELOG.md

@@ -1,10 +1,20 @@
 
-## [**2.3.0**](https://github.com/hapijs/qs/issues?milestone=15&state=open)
+## [**2.3.3**](https://github.com/hapijs/qs/issues?milestone=18&state=open)
+- [**#59**](https://github.com/hapijs/qs/issues/59) make sure array indexes are >= 0, closes #57
+- [**#58**](https://github.com/hapijs/qs/issues/58) make qs usable for browser loader
+
+## [**2.3.2**](https://github.com/hapijs/qs/issues?milestone=17&state=closed)
+- [**#55**](https://github.com/hapijs/qs/issues/55) allow merging a string into an object
+
+## [**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)
-- [**#49**](https://github.com/hapijs/qs/issues/49) refactor utils.merge, fixes #45
 - [**#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)

package/Makefile

@@ -1,8 +1,8 @@
 test:
-	@node node_modules/lab/bin/lab
+	@node node_modules/lab/bin/lab -a code -L
 test-cov:
-	@node node_modules/lab/bin/lab -t 100
+	@node node_modules/lab/bin/lab -a code -t 100 -L
 test-cov-html:
-	@node node_modules/lab/bin/lab -r html -o coverage.html
+	@node node_modules/lab/bin/lab -a code -L -r html -o coverage.html
 
-.PHONY: test test-cov test-cov-html
+.PHONY: test test-cov test-cov-html

package/README.md

@@ -153,6 +153,8 @@ Qs.parse('a[1]=b', { arrayLimit: 0 });
 // { a: { '1': 'b' } }
 ```
 
+To disable array parsing entirely, set `arrayLimit` to `-1`.
+
 If you mix notations, **qs** will merge the two items into an object:
 
 ```javascript
@@ -198,6 +200,17 @@ Qs.stringify({ a: ['b', 'c', 'd'] }, { indices: false });
 // 'a=b&a=c&a=d'
 ```
 
+You may use the `arrayFormat` option to specify the format of the output array
+
+```javascript
+Qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'indices' })
+// 'a[0]=b&a[1]=c'
+Qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'brackets' })
+// 'a[]=b&a[]=c'
+Qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'repeat' })
+// 'a=b&a=c'
+```
+
 Empty strings and null values will omit the value, but the equals sign (=) remains in place:
 
 ```javascript

package/index.js

@@ -1 +1 @@
-module.exports = require('./lib');
+module.exports = require('./lib/');

package/lib/parse.js

@@ -29,6 +29,10 @@ internals.parseValues = function (str, options) {
             var key = Utils.decode(part.slice(0, pos));
             var val = Utils.decode(part.slice(pos + 1));
 
+            if (Object.prototype.hasOwnProperty(key)) {
+                continue;
+            }
+
             if (!obj.hasOwnProperty(key)) {
                 obj[key] = val;
             }
@@ -62,6 +66,7 @@ internals.parseObject = function (chain, val, options) {
         if (!isNaN(index) &&
             root !== cleanRoot &&
             indexString === cleanRoot &&
+            index >= 0 &&
             index <= options.arrayLimit) {
 
             obj = [];

package/lib/stringify.js

@@ -7,11 +7,21 @@ var Utils = require('./utils');
 
 var internals = {
     delimiter: '&',
-    indices: true
+    arrayPrefixGenerators: {
+        brackets: function (prefix, key) {
+            return prefix + '[]';
+        },
+        indices: function (prefix, key) {
+            return prefix + '[' + key + ']';
+        },
+        repeat: function (prefix, key) {
+            return prefix;
+        }
+    }
 };
 
 
-internals.stringify = function (obj, prefix, options) {
+internals.stringify = function (obj, prefix, generateArrayPrefix) {
 
     if (Utils.isBuffer(obj)) {
         obj = obj.toString();
@@ -39,13 +49,11 @@ internals.stringify = function (obj, prefix, options) {
     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));
+        if (Array.isArray(obj)) {
+            values = values.concat(internals.stringify(obj[key], generateArrayPrefix(prefix, key), generateArrayPrefix));
         }
         else {
-            values = values.concat(internals.stringify(obj[key], prefix + '[' + key + ']', options));
+            values = values.concat(internals.stringify(obj[key], prefix + '[' + key + ']', generateArrayPrefix));
         }
     }
 
@@ -57,7 +65,6 @@ 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 = [];
 
@@ -67,10 +74,23 @@ module.exports = function (obj, options) {
         return '';
     }
 
+    var arrayFormat;
+    if (options.arrayFormat in internals.arrayPrefixGenerators) {
+        arrayFormat = options.arrayFormat;
+    }
+    else if ('indices' in options) {
+        arrayFormat = options.indices ? 'indices' : 'repeat';
+    }
+    else {
+        arrayFormat = 'indices';
+    }
+
+    var generateArrayPrefix = internals.arrayPrefixGenerators[arrayFormat];
+
     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));
+        keys = keys.concat(internals.stringify(obj[key], key, generateArrayPrefix));
     }
 
     return keys.join(delimiter);

package/lib/utils.js

@@ -27,7 +27,13 @@ exports.merge = function (target, source) {
     }
 
     if (typeof source !== 'object') {
-        target.push(source);
+        if (Array.isArray(target)) {
+            target.push(source);
+        }
+        else {
+            target[source] = true;
+        }
+
         return target;
     }
 
@@ -88,7 +94,7 @@ exports.compact = function (obj, refs) {
     if (Array.isArray(obj)) {
         var compacted = [];
 
-        for (var i = 0, l = obj.length; i < l; ++i) {
+        for (var i = 0, il = obj.length; i < il; ++i) {
             if (typeof obj[i] !== 'undefined') {
                 compacted.push(obj[i]);
             }
@@ -98,7 +104,7 @@ exports.compact = function (obj, refs) {
     }
 
     var keys = Object.keys(obj);
-    for (var i = 0, il = keys.length; i < il; ++i) {
+    for (i = 0, il = keys.length; i < il; ++i) {
         var key = keys[i];
         obj[key] = exports.compact(obj[key], refs);
     }

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "qs",
-  "version": "2.3.1",
+  "version": "2.4.1",
   "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": "4.x.x"
+    "code": "1.x.x",
+    "lab": "5.x.x"
   },
   "scripts": {
     "test": "make test-cov"

package/test/parse.js

@@ -1,5 +1,7 @@
+/* eslint no-extend-native:0 */
 // Load modules
 
+var Code = require('code');
 var Lab = require('lab');
 var Qs = require('../');
 
@@ -12,7 +14,7 @@ var internals = {};
 // Test shortcuts
 
 var lab = exports.lab = Lab.script();
-var expect = Lab.expect;
+var expect = Code.expect;
 var describe = lab.experiment;
 var it = lab.test;
 
@@ -158,6 +160,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' } });
@@ -179,7 +187,7 @@ describe('parse()', function () {
 
     it('cannot override prototypes', function (done) {
 
-        var obj = Qs.parse('toString=bad&bad[toString]=bad&constructor=bad');
+        var obj = Qs.parse('hasOwnProperty=bad&toString=bad&bad[toString]=bad&constructor=bad');
         expect(typeof obj.toString).to.equal('function');
         expect(typeof obj.bad.toString).to.equal('function');
         expect(typeof obj.constructor).to.equal('function');
@@ -296,6 +304,8 @@ describe('parse()', function () {
 
     it('allows overriding array limit', function (done) {
 
+        expect(Qs.parse('a[0]=b', { arrayLimit: -1 })).to.deep.equal({ a: { '0': 'b' } });
+        expect(Qs.parse('a[-1]=b', { arrayLimit: -1 })).to.deep.equal({ a: { '-1': 'b' } });
         expect(Qs.parse('a[0]=b&a[1]=c', { arrayLimit: 0 })).to.deep.equal({ a: { '0': 'b', '1': 'c' } });
         done();
     });
@@ -303,14 +313,14 @@ describe('parse()', function () {
     it('parses an object', function (done) {
 
         var input = {
-            "user[name]": {"pop[bob]": 3},
-            "user[email]": null
+            'user[name]': {'pop[bob]': 3},
+            'user[email]': null
         };
 
         var expected = {
-            "user": {
-                "name": {"pop[bob]": 3},
-                "email": null
+            'user': {
+                'name': {'pop[bob]': 3},
+                'email': null
             }
         };
 
@@ -323,14 +333,14 @@ describe('parse()', function () {
     it('parses an object and not child values', function (done) {
 
         var input = {
-            "user[name]": {"pop[bob]": { "test": 3 }},
-            "user[email]": null
+            'user[name]': {'pop[bob]': { 'test': 3 }},
+            'user[email]': null
         };
 
         var expected = {
-            "user": {
-                "name": {"pop[bob]": { "test": 3 }},
-                "email": null
+            'user': {
+                'name': {'pop[bob]': { 'test': 3 }},
+                'email': null
             }
         };
 
@@ -344,8 +354,9 @@ describe('parse()', function () {
 
         var tempBuffer = global.Buffer;
         delete global.Buffer;
-        expect(Qs.parse('a=b&c=d')).to.deep.equal({ a: 'b', c: 'd' });
+        var result = Qs.parse('a=b&c=d');
         global.Buffer = tempBuffer;
+        expect(result).to.deep.equal({ a: 'b', c: 'd' });
         done();
     });
 
@@ -365,10 +376,10 @@ describe('parse()', function () {
         expect(function () {
 
             parsed = Qs.parse({ 'foo[bar]': 'baz', 'foo[baz]': a });
-        }).to.not.throw(Error);
+        }).to.not.throw();
 
-        expect(parsed).to.have.key('foo');
-        expect(parsed.foo).to.have.keys('bar', 'baz');
+        expect(parsed).to.contain('foo');
+        expect(parsed.foo).to.contain('bar', 'baz');
         expect(parsed.foo.bar).to.equal('baz');
         expect(parsed.foo.baz).to.deep.equal(a);
         done();
@@ -378,9 +389,11 @@ 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' } });
+        var result = Qs.parse({ a: a });
+        expect(result).to.contain('a');
+        expect(result.a).to.deep.equal(a);
         done();
     });
 

package/test/stringify.js

@@ -1,5 +1,7 @@
+/* eslint no-extend-native:0 */
 // Load modules
 
+var Code = require('code');
 var Lab = require('lab');
 var Qs = require('../');
 
@@ -12,7 +14,7 @@ var internals = {};
 // Test shortcuts
 
 var lab = exports.lab = Lab.script();
-var expect = Lab.expect;
+var expect = Code.expect;
 var describe = lab.experiment;
 var it = lab.test;
 
@@ -65,6 +67,36 @@ describe('stringify()', function () {
         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');