Move _.omitPath to object.builders per comment by @joshuacc in #177

Also reimplements the function as suggested by @joshuacc. More tests
pass in this way, but still not all.

This is somewhat inconsistent; arguably, _.omitWhen, _.pickWhen and
_.selectKeys belong in object.builders, too.

Author: jgonggrijp

docs/underscore.object.builders.js.md

@@ -26,7 +26,7 @@ _.frequencies(citations);
 
 Returns a new object resulting from merging the passed objects. Objects
 are processed in order, so each will override properties of the same
-name occurring in earlier arguments. 
+name occurring in earlier arguments.
 
 Returns `null` if called without arguments.
 
@@ -148,3 +148,28 @@ obj === imperialObj;
 ```
 
 --------------------------------------------------------------------------------
+
+#### omitPath
+
+**Signature:** `_.omitPath(obj:Object, ks:String|Array)`
+
+Returns a copy of `obj` excluding the value represented by the `ks` path.
+Path may be given as an array or as a dot-separated string.
+If the path contains an array, the value of the path will be removed from all the array elements.
+
+```javascript
+var test = {
+    foo: true,
+    bar: false,
+    baz: 42,
+    dada: {
+        carlos: {
+            pepe: 9
+        },
+        pedro: 'pedro'
+    }
+};
+
+_.omitPath(test, 'dada.carlos.pepe');
+// => {foo: true, bar: false, baz: 42, dada: {carlos: {}, pedro: 'pedro'}}
+```

docs/underscore.object.selectors.js.md

@@ -220,28 +220,3 @@ var philosopherCities = {
 _.selectKeys(philosopherCities, ["Plato", "Plotinus"]);
 // => { Plato: "Athens", Plotinus: "Rome" }
 ```
-
-#### omitPath
-
-**Signature:** `_.omitPath(obj:Object, ks:String|Array)`
-
-Returns a copy of `obj` excluding the value represented by the `ks` path.
-Path may be given as an array or as a dot-separated string.
-If the path contains an array, the value of the path will be removed from all the array elements.
-
-```javascript
-var test = {
-    foo: true,
-    bar: false,
-    baz: 42,
-    dada: {
-        carlos: {
-            pepe: 9
-        },
-        pedro: 'pedro'
-    }
-};
-
-_.omitPath(test, 'dada.carlos.pepe');
-// => {foo: true, bar: false, baz: 42, dada: {carlos: {}, pedro: 'pedro'}}
-```

test/object.builders.js

@@ -52,7 +52,7 @@ $(document).ready(function() {
 
     assert.deepEqual(_.setPath(obj, 9, ['a', 'b', 'c']), {a: {b: {c: 9, d: 108}}}, '');
     assert.deepEqual(_.setPath(ary, 9, [1, 1, 0]), ['a', ['b', [9, 'd'], 'e']], '');
-    assert.deepEqual(_.setPath(nest, 9, [1, 'b', 1]), [1, {a: 2, b: [3,9], c: 5}, 6], ''); 
+    assert.deepEqual(_.setPath(nest, 9, [1, 'b', 1]), [1, {a: 2, b: [3,9], c: 5}, 6], '');
 
     assert.deepEqual(_.setPath(obj, 9, 'a'), {a: 9}, '');
     assert.deepEqual(_.setPath(ary, 9, 1), ['a', 9], '');
@@ -69,7 +69,7 @@ $(document).ready(function() {
 
     assert.deepEqual(_.updatePath(obj, _.always(9), ['a', 'b', 'c']), {a: {b: {c: 9, d: 108}}}, '');
     assert.deepEqual(_.updatePath(ary, _.always(9), [1, 1, 0]), ['a', ['b', [9, 'd'], 'e']], '');
-    assert.deepEqual(_.updatePath(nest, _.always(9), [1, 'b', 1]), [1, {a: 2, b: [3,9], c: 5}, 6], ''); 
+    assert.deepEqual(_.updatePath(nest, _.always(9), [1, 'b', 1]), [1, {a: 2, b: [3,9], c: 5}, 6], '');
 
     assert.deepEqual(_.updatePath(obj, _.always(9), 'a'), {a: 9}, '');
     assert.deepEqual(_.updatePath(ary, _.always(9), 1), ['a', 9], '');
@@ -79,4 +79,18 @@ $(document).ready(function() {
     assert.deepEqual(nest, [1, {a: 2, b: [3,4], c: 5}, 6], 'should not modify the original nested structure');
   });
 
+  QUnit.test("omitPath", function(assert){
+    var a = {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro', list: [{file: '..', more: {other: { a: 1, b: 2}}, name: 'aa'}, {file: '..', name: 'bb'}]}};
+
+    assert.deepEqual(_.omitPath(a, 'dada.carlos.pepe'), {foo: true, bar: false, baz: 42, dada: {carlos: {}, pedro: 'pedro', list: [{file: '..', more: {other: { a: 1, b: 2}} , name: 'aa'}, {file: '..', name: 'bb'}]}}, "should return an object without the value that represent the path");
+    assert.deepEqual(_.omitPath(a, 'dada.carlos'), {foo: true, bar: false, baz: 42, dada: {pedro: 'pedro', list: [{file: '..', more: {other: { a: 1, b: 2}} , name: 'aa'}, {file: '..', name: 'bb'}]}}, "should return an object without the value that represent the path");
+    assert.deepEqual(_.omitPath(a, ''), {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro', list: [{file: '..', more: {other: { a: 1, b: 2}} , name: 'aa'}, {file: '..', name: 'bb'}]}}, "should return the whole object because the path is empty");
+
+    assert.deepEqual(_.omitPath(a, 'dada.list.file'), {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro', list: [{name: 'aa', more: {other: { a: 1, b: 2}}}, {name: 'bb'}]}}, "should return an object without the value in each object of the list");
+    assert.deepEqual(_.omitPath(a, 'dada.list.name'), {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro', list: [{file: '..', more: {other: { a: 1, b: 2}}}, {file: '..'}]}}, "should return an object without the value in each object of the list");
+
+    assert.deepEqual(_.omitPath(a, 'dada.list'), {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro'}}, "should return an object without the list");
+
+    assert.deepEqual(_.omitPath(a, 'dada.list.more.other.a'), {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro', list: [{file: '..', more: {other: { b: 2}} , name: 'aa'}, {file: '..', name: 'bb'}]}}, "should return an object without the value inside the values of the list");
+  });
 });

test/object.selectors.js

@@ -107,19 +107,4 @@ $(document).ready(function() {
 
     assert.deepEqual(_.omitWhen(a, _.isEmpty), {baz: "something", quux: ['a']}, "should return an object with kvs that return a falsey value for the given predicate");
   });
-
-  QUnit.test("omitPath", function(assert){
-    var a = {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro', list: [{file: '..', more: {other: { a: 1, b: 2}}, name: 'aa'}, {file: '..', name: 'bb'}]}};
-
-    assert.deepEqual(_.omitPath(a, 'dada.carlos.pepe'), {foo: true, bar: false, baz: 42, dada: {carlos: {}, pedro: 'pedro', list: [{file: '..', more: {other: { a: 1, b: 2}} , name: 'aa'}, {file: '..', name: 'bb'}]}}, "should return an object without the value that represent the path");
-    assert.deepEqual(_.omitPath(a, 'dada.carlos'), {foo: true, bar: false, baz: 42, dada: {pedro: 'pedro', list: [{file: '..', more: {other: { a: 1, b: 2}} , name: 'aa'}, {file: '..', name: 'bb'}]}}, "should return an object without the value that represent the path");
-    assert.deepEqual(_.omitPath(a, ''), {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro', list: [{file: '..', more: {other: { a: 1, b: 2}} , name: 'aa'}, {file: '..', name: 'bb'}]}}, "should return the whole object because the path is empty");
-
-    assert.deepEqual(_.omitPath(a, 'dada.list.file'), {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro', list: [{name: 'aa', more: {other: { a: 1, b: 2}}}, {name: 'bb'}]}}, "should return an object without the value in each object of the list");
-    assert.deepEqual(_.omitPath(a, 'dada.list.name'), {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro', list: [{file: '..', more: {other: { a: 1, b: 2}}}, {file: '..'}]}}, "should return an object without the value in each object of the list");
-
-    assert.deepEqual(_.omitPath(a, 'dada.list'), {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro'}}, "should return an object without the list");
-
-    assert.deepEqual(_.omitPath(a, 'dada.list.more.other.a'), {foo: true, bar: false, baz: 42, dada: {carlos: { pepe: 9 }, pedro: 'pedro', list: [{file: '..', more: {other: { b: 2}} , name: 'aa'}, {file: '..', name: 'bb'}]}}, "should return an object without the value inside the values of the list");
-  });
 });

underscore.object.builders.js

@@ -106,6 +106,16 @@
       return ret;
     },
 
+    // Returns an object excluding the value represented by the path
+    omitPath: function(obj, ks, copy){
+      if (!obj) return copy;
+      if (typeof ks == "string") ks = ks.split(".");
+      if (!copy) copy = obj = _.snapshot(obj);
+      if (ks.length > 1) return _.omitPath(obj[ks[0]], _.tail(ks), copy);
+      delete obj[ks[0]];
+      return copy;
+    },
+
     // Sets the value at any depth in a nested object based on the
     // path described by the keys given.
     setPath: function(obj, value, ks, defaultValue) {

underscore.object.selectors.js

@@ -121,50 +121,6 @@
 
     omitWhen: function(obj, pred) {
       return _.pickWhen(obj, function(e) { return !pred(e); });
-    },
-
-    // Returns an object excluding the value represented by the path
-    omitPath: function(obj, ks){
-      if (typeof ks == "string") ks = ks.split(".");
-
-      // If we have reached an undefined property
-      // then stop executing and return undefined
-      if (obj === undefined) return void 0;
-
-      // If the path array has no more elements, we've reached
-      // the intended property and return its value
-      if (ks.length === 0) return obj;
-
-      // If we still have elements in the path array and the current
-      // value is null, stop executing and return undefined
-      if (obj === null) return void 0;
-
-      var copy = {};
-
-      var deepFunc = function (obj, path){
-        if (!path)
-          path = [];
-        _.each(obj, function(value, key) {
-          if (_.isObject(value)){
-            if (_.difference(ks, _.union(path, key)).length !== 0){
-              if (_.isArray(value)){
-                _.getPath(copy, path)[key] = [];
-              }else{
-                _.getPath(copy, path)[key] = {};
-              }
-              path.push(key);
-              deepFunc(value, path);
-              path.pop(key);
-            }
-          }else{
-            if (_.difference(ks, _.union(path, key)).length !== 0)
-              _.getPath(copy, path)[key] = value;
-          }
-        });
-      };
-      deepFunc(obj);
-
-      return copy;
     }
 
   });