1// Load modules
  2
  3var Utils = require('./utils');
  4
  5
  6// Declare internals
  7
  8var internals = {
  9    delimiter: '&',
 10    depth: 5,
 11    arrayLimit: 20,
 12    parameterLimit: 1000
 13};
 14
 15
 16internals.parseValues = function (str, options) {
 17
 18    var obj = {};
 19    var parts = str.split(options.delimiter, options.parameterLimit === Infinity ? undefined : options.parameterLimit);
 20
 21    for (var i = 0, il = parts.length; i < il; ++i) {
 22        var part = parts[i];
 23        var pos = part.indexOf(']=') === -1 ? part.indexOf('=') : part.indexOf(']=') + 1;
 24
 25        if (pos === -1) {
 26            obj[Utils.decode(part)] = '';
 27        }
 28        else {
 29            var key = Utils.decode(part.slice(0, pos));
 30            var val = Utils.decode(part.slice(pos + 1));
 31
 32            if (!obj.hasOwnProperty(key)) {
 33                obj[key] = val;
 34            }
 35            else {
 36                obj[key] = [].concat(obj[key]).concat(val);
 37            }
 38        }
 39    }
 40
 41    return obj;
 42};
 43
 44
 45internals.parseObject = function (chain, val, options) {
 46
 47    if (!chain.length) {
 48        return val;
 49    }
 50
 51    var root = chain.shift();
 52
 53    var obj = {};
 54    if (root === '[]') {
 55        obj = [];
 56        obj = obj.concat(internals.parseObject(chain, val, options));
 57    }
 58    else {
 59        var cleanRoot = root[0] === '[' && root[root.length - 1] === ']' ? root.slice(1, root.length - 1) : root;
 60        var index = parseInt(cleanRoot, 10);
 61        var indexString = '' + index;
 62        if (!isNaN(index) &&
 63            root !== cleanRoot &&
 64            indexString === cleanRoot &&
 65            index <= options.arrayLimit) {
 66
 67            obj = [];
 68            obj[index] = internals.parseObject(chain, val, options);
 69        }
 70        else {
 71            obj[cleanRoot] = internals.parseObject(chain, val, options);
 72        }
 73    }
 74
 75    return obj;
 76};
 77
 78
 79internals.parseKeys = function (key, val, options) {
 80
 81    if (!key) {
 82        return;
 83    }
 84
 85    // The regex chunks
 86
 87    var parent = /^([^\[\]]*)/;
 88    var child = /(\[[^\[\]]*\])/g;
 89
 90    // Get the parent
 91
 92    var segment = parent.exec(key);
 93
 94    // Don't allow them to overwrite object prototype properties
 95
 96    if (Object.prototype.hasOwnProperty(segment[1])) {
 97        return;
 98    }
 99
100    // Stash the parent if it exists
101
102    var keys = [];
103    if (segment[1]) {
104        keys.push(segment[1]);
105    }
106
107    // Loop through children appending to the array until we hit depth
108
109    var i = 0;
110    while ((segment = child.exec(key)) !== null && i < options.depth) {
111
112        ++i;
113        if (!Object.prototype.hasOwnProperty(segment[1].replace(/\[|\]/g, ''))) {
114            keys.push(segment[1]);
115        }
116    }
117
118    // If there's a remainder, just add whatever is left
119
120    if (segment) {
121        keys.push('[' + key.slice(segment.index) + ']');
122    }
123
124    return internals.parseObject(keys, val, options);
125};
126
127
128module.exports = function (str, options) {
129
130    if (str === '' ||
131        str === null ||
132        typeof str === 'undefined') {
133
134        return {};
135    }
136
137    options = options || {};
138    options.delimiter = typeof options.delimiter === 'string' || Utils.isRegExp(options.delimiter) ? options.delimiter : internals.delimiter;
139    options.depth = typeof options.depth === 'number' ? options.depth : internals.depth;
140    options.arrayLimit = typeof options.arrayLimit === 'number' ? options.arrayLimit : internals.arrayLimit;
141    options.parameterLimit = typeof options.parameterLimit === 'number' ? options.parameterLimit : internals.parameterLimit;
142
143    var tempObj = typeof str === 'string' ? internals.parseValues(str, options) : str;
144    var obj = {};
145
146    // Iterate over the keys and setup the new object
147
148    var keys = Object.keys(tempObj);
149    for (var i = 0, il = keys.length; i < il; ++i) {
150        var key = keys[i];
151        var newObj = internals.parseKeys(key, tempObj[key], options);
152        obj = Utils.merge(obj, newObj);
153    }
154
155    return Utils.compact(obj);
156};