qs 1.1.0 → 1.2.0

package/README.md

@@ -19,6 +19,10 @@ var str = Qs.stringify(obj);  // 'a=c'
 
 ### Parsing Objects
 
+```javascript
+Qs.parse(string, [depth], [delimiter]);
+```
+
 **qs** allows you to create nested objects within your query strings, by surrounding the name of sub-keys with square brackets `[]`.
 For example, the string `'foo[bar]=baz'` converts to:
 
@@ -79,6 +83,13 @@ Qs.parse('a[b][c][d][e][f][g][h][i]=j', 1);
 
 The depth limit mitigate abuse when **qs** is used to parse user input, and it is recommended to keep it a reasonably small number.
 
+An optional delimiter can also be passed:
+
+```javascript
+Qs.parse('a=b;c=d', ';');
+// { a: 'b', c: 'd' }
+```
+
 ### Parsing Arrays
 
 **qs** can also parse arrays using a similar `[]` notation:
@@ -137,6 +148,10 @@ Qs.parse('a[][b]=c');
 
 ### Stringifying
 
+```javascript
+Qs.stringify(object, [delimiter]);
+```
+
 When stringifying, **qs** always URI encodes output. Objects are stringified as you would expect:
 
 ```javascript
@@ -168,3 +183,9 @@ Properties that are set to `undefined` will be omitted entirely:
 Qs.stringify({ a: null, b: undefined });
 // 'a='
 ```
+
+The delimiter may be overridden with stringify as well:
+
+```javascript
+Qs.stringify({ a: 'b', c: 'd' }, ';');
+// 'a=b;c=d'

package/lib/parse.js

@@ -6,16 +6,19 @@ var Utils = require('./utils');
 // Declare internals
 
 var internals = {
+    delimiter: '&',
     depth: 5,
     arrayLimit: 20,
     parametersLimit: 1000
 };
 
 
-internals.parseValues = function (str) {
+internals.parseValues = function (str, delimiter) {
+
+    delimiter = typeof delimiter === 'undefined' ? internals.delimiter : delimiter;
 
     var obj = {};
-    var parts = str.split('&').slice(0, internals.parametersLimit);
+    var parts = str.split(delimiter, internals.parametersLimit);
 
     for (var i = 0, il = parts.length; i < il; ++i) {
         var part = parts[i];
@@ -79,8 +82,6 @@ internals.parseKeys = function (key, val, depth) {
         return;
     }
 
-    depth = typeof depth === 'undefined' ? internals.depth : depth;
-
     // The regex chunks
 
     var parent = /^([^\[\]]*)/;
@@ -124,7 +125,7 @@ internals.parseKeys = function (key, val, depth) {
 };
 
 
-module.exports = function (str, depth) {
+module.exports = function (str, depth, delimiter) {
 
     if (str === '' ||
         str === null ||
@@ -133,11 +134,16 @@ module.exports = function (str, depth) {
         return {};
     }
 
-    var tempObj = typeof str === 'string' ? internals.parseValues(str) : Utils.clone(str);
+    if (typeof depth !== 'number') {
+        delimiter = depth;
+        depth = internals.depth;
+    }
+
+    var tempObj = typeof str === 'string' ? internals.parseValues(str, delimiter) : Utils.clone(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], depth);

package/lib/stringify.js

@@ -3,7 +3,9 @@
 
 // Declare internals
 
-var internals = {};
+var internals = {
+    delimiter: '&'
+};
 
 
 internals.stringify = function (obj, prefix) {
@@ -37,7 +39,9 @@ internals.stringify = function (obj, prefix) {
 };
 
 
-module.exports = function (obj) {
+module.exports = function (obj, delimiter) {
+
+    delimiter = typeof delimiter === 'undefined' ? internals.delimiter : delimiter;
 
     var keys = [];
 
@@ -47,5 +51,5 @@ module.exports = function (obj) {
         }
     }
 
-    return keys.join('&');
+    return keys.join(delimiter);
 };

package/lib/utils.js

@@ -10,8 +10,7 @@ exports.arrayToObject = function (source) {
 
     var obj = {};
     for (var i = 0, il = source.length; i < il; ++i) {
-        if (source[i] !== undefined &&
-            source[i] !== null) {
+        if (typeof source[i] !== 'undefined') {
 
             obj[i] = source[i];
         }
@@ -54,8 +53,13 @@ exports.merge = function (target, source) {
 
     if (Array.isArray(source)) {
         for (var i = 0, il = source.length; i < il; ++i) {
-            if (source[i] !== undefined) {
-                obj[i] = source[i];
+            if (typeof source[i] !== 'undefined') {
+                if (typeof obj[i] === 'object') {
+                    obj[i] = exports.merge(obj[i], source[i]);
+                }
+                else {
+                    obj[i] = source[i];
+                }
             }
         }
 
@@ -114,9 +118,7 @@ exports.compact = function (obj) {
                 compacted[key] = [];
 
                 for (var i = 0, l = obj[key].length; i < l; i++) {
-                    if (obj[key].hasOwnProperty(i) &&
-                        obj[key][i] !== null) {
-
+                    if (typeof obj[key][i] !== 'undefined') {
                         compacted[key].push(obj[key][i]);
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qs",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A querystring parser that supports nesting and arrays, with a depth limit",
   "homepage": "https://github.com/hapijs/qs",
   "main": "index.js",

package/test/parse.js

@@ -138,6 +138,7 @@ describe('#parse', function () {
         expect(Qs.parse('foo[bad]=baz&foo[]=bar')).to.deep.equal({ foo: { bad: 'baz', '0': 'bar' } });
         expect(Qs.parse('foo[]=bar&foo[bad]=baz')).to.deep.equal({ foo: { '0': 'bar', bad: 'baz' } });
         expect(Qs.parse('foo[bad]=baz&foo[]=bar&foo[]=foo')).to.deep.equal({ foo: { bad: 'baz', '0': 'bar', '1': 'foo' } });
+        expect(Qs.parse('foo[0][a]=a&foo[0][b]=b&foo[1][a]=aa&foo[1][b]=bb')).to.deep.equal({foo: [ {a: 'a', b: 'b'}, {a: 'aa', b: 'bb'} ]});
         done();
     });
 
@@ -236,8 +237,19 @@ describe('#parse', function () {
     it('should not throw when a native prototype has an enumerable property', { parallel: false }, function (done) {
 
         Object.prototype.crash = '';
-        expect(Qs.parse.bind(null, 'test')).to.not.throw();
+        Array.prototype.crash = '';
+        expect(Qs.parse.bind(null, 'a=b')).to.not.throw();
+        expect(Qs.parse('a=b')).to.deep.equal({ a: 'b' });
+        expect(Qs.parse.bind(null, 'a[][b]=c')).to.not.throw();
+        expect(Qs.parse('a[][b]=c')).to.deep.equal({ a: [{ b: 'c' }] });
         delete Object.prototype.crash;
+        delete Array.prototype.crash;
+        done();
+    });
+
+    it('parses a string with an alternative delimiter', function (done) {
+
+        expect(Qs.parse('a=b;c=d', ';')).to.deep.equal({ a: 'b', c: 'd' });
         done();
     });
 });

package/test/stringify.js

@@ -120,4 +120,10 @@ describe('#stringify', function () {
         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' }, ';')).to.equal('a=b;c=d');
+        done();
+    });
 });