RegExp pick

README.md

@@ -392,7 +392,7 @@ var passAny = require('101/pass-any');
 ## pick
 
 Returns a new object with the specified keys (with key values from obj).
-Supports partial functionality (great with array functions, like map).
+Supports regular expressions and partial functionality (great with array functions, like map).
 
 ```js
 var pick = require('101/pick');
@@ -402,6 +402,7 @@ var obj = {
 };
 
 pick(obj, 'foo');          // { foo: 1 }
+pick(obj, RegExp('oo$'));  // { foo: 1 }
 pick(obj, ['foo']);        // { foo: 1 }
 pick(obj, ['foo', 'bar']); // { foo: 1, bar: 2 }
 

package.json

@@ -4,7 +4,7 @@
   "description": "common javascript utils that can be required selectively that assume es5+",
   "main": "index.js",
   "scripts": {
-    "test": "lab -c test",
+    "test": "lab -c -t 100 test",
     "test-watch": "nodemon --exec lab -c test"
   },
   "repository": {

pick.js

@@ -9,7 +9,7 @@ var isObject = require('./is-object');
  * When only keys are specified pick returns a partial-function which accepts obj.
  * @function module:101/pick
  * @param {object} [obj] - object whose keys are picked
- * @param {string|array} keys... - keys which will be taken from obj (can be specifieds as args (strings and/or arrays)
+ * @param {string|regexp|array} keys... - keys which will be taken from obj, can be specifieds as args (strings, regular epxressions, and/or arrays)
  * @return {object|function} Object with only the keys specified from the original obj or Partial-function pick (which accepts obj) and returns an object
  */
 module.exports = function () {
@@ -27,18 +27,49 @@ module.exports = function () {
 
 function pick (obj, args) {
   var keys = [];
-  args.forEach(function (key) {
-    keys = keys.concat(key);
+  var regexps = [];
+  function concatElement(el) {
+    if (el instanceof RegExp) {
+      regexps = regexps.concat(el);
+    }
+    else {
+      keys = keys.concat(el);
+    }
+  }
+  args.forEach(function (element) {
+    if (Array.isArray(element)) {
+      element.forEach(function(subelement){
+        concatElement(subelement);
+      });
+    }
+    else {
+      concatElement(element);
+    }
   });
   var out = {};
-  keys.forEach(copy(obj, out));
+  if (keys.length > 0) {
+    keys.forEach(copyWithString(obj, out));
+  }
+  if (regexps.length > 0) {
+    regexps.forEach(function(regexp){
+      Object.keys(obj).forEach(copyWithRegExp(obj, out, regexp));
+    });
+  }
   return out;
 }
 
-function copy (from, to) {
+function copyWithString (from, to) {
   return function (key) {
     if (key in from) {
       to[key] = from[key];
     }
   };
+}
+
+function copyWithRegExp (from, to, regexp) {
+  return function (key) {
+    if (regexp.test(key) && !(key in to)) {
+      to[key] = from[key];
+    }
+  };
 }

test/test-pick.js

@@ -40,6 +40,32 @@ describe('pick', function () {
     });
     expect(pick(obj)).to.eql({});
     expect(pick(obj, [])).to.eql({});
+    expect(pick(obj, RegExp('a'))).to.eql({
+      bar: 1
+    });
+    expect(pick(obj, RegExp('a'), 'foo')).to.eql({
+      foo: 1,
+      bar: 1
+    });
+    expect(pick(obj, [RegExp('q|b')], 'bar')).to.eql({
+      bar: 1,
+      qux: 1
+    });
+    expect(pick(obj, [RegExp('q'), RegExp('f')], ['bar'])).to.eql({
+      foo: 1,
+      bar: 1,
+      qux: 1
+    });
+    expect(pick(obj, [RegExp('q'), 'foo'], 'bar')).to.eql({
+      foo: 1,
+      bar: 1,
+      qux: 1
+    });
+    expect(pick(obj, [RegExp('x$'), 'foo'], [RegExp('b')])).to.eql({
+      foo: 1,
+      bar: 1,
+      qux: 1
+    });
     done();
   });
   it('should pick keys from objects in an array when used with map', function(done) {
@@ -135,6 +161,70 @@ describe('pick', function () {
         bar: 3
       }
     ]);
+    expect(objs.map(pick(RegExp('q|g')))).to.eql([
+      {},
+      {
+        qux: 2
+      },
+      {
+        goo: 3
+      }
+    ]);
+    expect(objs.map(pick(RegExp('BAR', 'i'), 'foo'))).to.eql([
+      {
+        bar: 1
+      },
+      {
+        foo: 2,
+        bar: 2
+      },
+      {
+        foo: 3,
+        bar: 3
+      }
+    ]);
+    expect(objs.map(pick([RegExp('b')], 'foo'))).to.eql([
+      {
+        bar: 1
+      },
+      {
+        foo: 2,
+        bar: 2
+      },
+      {
+        foo: 3,
+        bar: 3
+      }
+    ]);
+    expect(objs.map(pick([RegExp('b'), 'qux'], ['foo']))).to.eql([
+      {
+        bar: 1
+      },
+      {
+        bar: 2,
+        foo: 2,
+        qux: 2
+      },
+      {
+        foo: 3,
+        bar: 3
+      }
+    ]);
+    expect(objs.map(pick([RegExp('b'), RegExp('^f')], [RegExp('oo$')]))).to.eql([
+      {
+        bar: 1
+      },
+      {
+        bar: 2,
+        foo: 2
+      },
+      {
+        bar: 3,
+        foo: 3,
+        koo: 3,
+        goo: 3
+      }
+    ]);
     expect(objs.map(pick())).to.eql([
       {}, {}, {}
     ]);