Merge branch 'feature/flatten-depth' (pull request #2868)

modules/_flatten.js

@@ -4,19 +4,24 @@ import isArray from './isArray.js';
 import isArguments from './isArguments.js';
 
 // Internal implementation of a recursive `flatten` function.
-export default function flatten(input, shallow, strict, output) {
+export default function flatten(input, depth, strict, output) {
   output = output || [];
+  if (!depth && depth !== 0) {
+    depth = Infinity;
+  } else if (depth <= 0) {
+    return output.concat(input);
+  }
   var idx = output.length;
   for (var i = 0, length = getLength(input); i < length; i++) {
     var value = input[i];
     if (isArrayLike(value) && (isArray(value) || isArguments(value))) {
       // Flatten current level of array or arguments object.
-      if (shallow) {
+      if (depth > 1) {
+        flatten(value, depth - 1, strict, output);
+        idx = output.length;
+      } else {
         var j = 0, len = value.length;
         while (j < len) output[idx++] = value[j++];
-      } else {
-        flatten(value, shallow, strict, output);
-        idx = output.length;
       }
     } else if (!strict) {
       output[idx++] = value;

modules/flatten.js

@@ -1,6 +1,7 @@
 import _flatten from './_flatten.js';
 
-// Flatten out an array, either recursively (by default), or just one level.
-export default function flatten(array, shallow) {
-  return _flatten(array, shallow, false);
+// Flatten out an array, either recursively (by default), or up to `depth`.
+// Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively.
+export default function flatten(array, depth) {
+  return _flatten(array, depth, false);
 }

test/arrays.js

@@ -100,10 +100,15 @@
     var list = [1, [2], [3, [[[4]]]]];
     assert.deepEqual(_.flatten(list), [1, 2, 3, 4], 'can flatten nested arrays');
     assert.deepEqual(_.flatten(list, true), [1, 2, 3, [[[4]]]], 'can shallowly flatten nested arrays');
+    assert.deepEqual(_.flatten(list, false), [1, 2, 3, 4], 'false means deep');
     var result = (function(){ return _.flatten(arguments); }(1, [2], [3, [[[4]]]]));
     assert.deepEqual(result, [1, 2, 3, 4], 'works on an arguments object');
     list = [[1], [2], [3], [[4]]];
     assert.deepEqual(_.flatten(list, true), [1, 2, 3, [4]], 'can shallowly flatten arrays containing only other arrays');
+    list = [1, [2], [[3]], [[[4]]]];
+    assert.deepEqual(_.flatten(list, 2), [1, 2, 3, [4]], 'can flatten arrays to a given depth');
+    assert.deepEqual(_.flatten(list, 0), list, 'can flatten arrays to depth of 0');
+    assert.deepEqual(_.flatten(list, -1), list, 'can flatten arrays to depth of -1');
 
     assert.strictEqual(_.flatten([_.range(10), _.range(10), 5, 1, 3], true).length, 23, 'can flatten medium length arrays');
     assert.strictEqual(_.flatten([_.range(10), _.range(10), 5, 1, 3]).length, 23, 'can shallowly flatten medium length arrays');
@@ -242,6 +247,9 @@
     var result = _.difference([1, 2, 3], [2, 30, 40]);
     assert.deepEqual(result, [1, 3], 'can find the difference of two arrays');
 
+    var result = _.difference([1, 2, 3], [2, 30, 40, [1]]);
+    assert.deepEqual(result, [1, 3], 'avoids deep flattening of arrays');
+
     result = _([1, 2, 3]).difference([2, 30, 40]);
     assert.deepEqual(result, [1, 3], 'can perform an OO-style difference');
 

test/functions.js

@@ -124,9 +124,11 @@
     var sayLast = moe.sayLast;
     assert.strictEqual(sayLast(1, 2, 3, 4, 5, 6, 7, 'Tom'), 'hi: moe', 'createCallback works with any number of arguments');
 
-    _.bindAll(moe, ['getName']);
+    _.bindAll(moe, ['getName'], [['sayHi']]);
     var getName = moe.getName;
+    var sayHi = moe.sayHi;
     assert.strictEqual(getName(), 'name: moe', 'flattens arguments into a single list');
+    assert.strictEqual(sayHi(), 'hi: moe', 'deeply flattens arguments into a single list');
   });
 
   QUnit.test('memoize', function(assert) {

test/objects.js

@@ -178,6 +178,8 @@
     assert.deepEqual(result, {b: 2, c: 3}, 'can restrict properties to those named in an array');
     result = _.pick({a: 1, b: 2, c: 3}, ['a'], 'b');
     assert.deepEqual(result, {a: 1, b: 2}, 'can restrict properties to those named in mixed args');
+    result = _.pick({a: 1, b: 2, c: 3}, ['a'], [['b']]);
+    assert.deepEqual(result, {a: 1, b: 2}, 'can restrict properties to those named in mixed deep args');
     result = _.pick(['a', 'b'], 1);
     assert.deepEqual(result, {1: 'b'}, 'can pick numeric properties');
 
@@ -219,6 +221,8 @@
     assert.deepEqual(result, {b: 2}, 'can omit several named properties');
     result = _.omit({a: 1, b: 2, c: 3}, ['b', 'c']);
     assert.deepEqual(result, {a: 1}, 'can omit properties named in an array');
+    result = _.omit({a: 1, b: 2, c: 3}, ['b', ['c']]);
+    assert.deepEqual(result, {a: 1}, 'can omit properties named in a nested array');
     result = _.omit(['a', 'b'], 0);
     assert.deepEqual(result, {1: 'b'}, 'can omit numeric properties');