Merge pull request #19 from tjmehta/inverse

add inverse

Author: tjmehta

README.md

@@ -10,13 +10,23 @@ Functional methods like forEach, map, filter, and other Array methods for Object
 # Index
 
 [chain](https://github.com/tjmehta/object-loops#usage)
+
 [every](https://github.com/tjmehta/object-loops#every)
-[find](https://github.com/tjmehta/object-loops#find)
-[findKey](https://github.com/tjmehta/object-loops#findKey)
+
 [filter](https://github.com/tjmehta/object-loops#filter)
+
+[findKey](https://github.com/tjmehta/object-loops#findKey)
+
+[find](https://github.com/tjmehta/object-loops#find)
+
 [forEach](https://github.com/tjmehta/object-loops#forEach)
+
+[mapKeys](https://github.com/tjmehta/object-loops#mapKeys)
+
 [map](https://github.com/tjmehta/object-loops#map)
+
 [reduce](https://github.com/tjmehta/object-loops#reduce)
+
 [some](https://github.com/tjmehta/object-loops#some)
 
 # Usage
@@ -88,6 +98,35 @@ allGreaterThan25 // false
 */
 ```
 
+## filter
+
+Creates a new object with all entries that pass the test implemented by the provided function.
+
+ * @param {object} [obj] - object to filter values, not accepted if being used directly on Object.prototype
+ * @param {function} callback - function to test each value in the object. return true to keep that entry, false otherwise.
+ * @param {*} [thisArg] - optional. context to bind to callback
+ * @returns {object} newly created object with filtered values
+
+```js
+var filter = require('object-loops/filter')
+
+var obj = {
+  foo: 10,
+  bar: 20,
+  baz: 30,
+  qux: 40,
+}
+var filteredObj = filter(obj, function (val, key, obj) {
+  return val > 25
+})
+filteredObj /* Only has entries with vals greater than 25
+{
+  baz: 30,
+  qux: 40
+}
+*/
+```
+
 ## find
 
 Find the value of the the object that passes the test implemented by the callback.
@@ -146,59 +185,59 @@ notfound // undefined
 */
 ```
 
-## filter
+## forEach
 
-Creates a new object with all entries that pass the test implemented by the provided function.
+Executes a provided function once per each object value.
 
- * @param {object} [obj] - object to filter values, not accepted if being used directly on Object.prototype
- * @param {function} callback - function to test each value in the object. return true to keep that entry, false otherwise.
+ * @param {object} [obj] - object to forEach, not accepted if being used directly on Object.prototype
+ * @param {function} callback - function that will be invoked once for each key-value pair
  * @param {*} [thisArg] - optional. context to bind to callback
- * @returns {object} newly created object with filtered values
 
 ```js
-var filter = require('object-loops/filter')
+var forEach = require('object-loops/for-each')
 
 var obj = {
   foo: 10,
   bar: 20,
-  baz: 30,
-  qux: 40,
+  baz: 30
 }
-var filteredObj = filter(obj, function (val, key, obj) {
-  return val > 25
+var keyConcat = ''
+var valSum = 0
+forEach(obj, function (val, key, obj) {
+  keyConcat += key
+  valSum += val
 })
-filteredObj /* Only has entries with vals greater than 25
-{
-  baz: 30,
-  qux: 40
-}
-*/
+keyConcat // = 'foobarbaz'
+valSum    // = 60
 ```
 
-## forEach
+## mapKeys
 
-Executes a provided function once per each object value.
+Creates a new object with the results of calling a provided function on every key in the object.
 
- * @param {object} [obj] - object to forEach, not accepted if being used directly on Object.prototype
- * @param {function} callback - function that will be invoked once for each key-value pair
+ * @param {object} [obj] - object to map keys, not accepted if being used directly on Object.prototype
+ * @param {mapKeysCallback} callback - function that produces the new key for the new mapped object
  * @param {*} [thisArg] - optional. context to bind to callback
+ * @returns {object} newly created object with mapped keys
 
 ```js
-var forEach = require('object-loops/for-each')
+var mapKeys = require('object-loops/map-keys')
 
 var obj = {
   foo: 10,
   bar: 20,
   baz: 30
 }
-var keyConcat = ''
-var valSum = 0
-forEach(obj, function (val, key, obj) {
-  keyConcat += key
-  valSum += val
+var mappedObj = mapKeys(obj, function (key, val, obj) {
+  return key + 'New'
 })
-keyConcat // = 'foobarbaz'
-valSum    // = 60
+mappedObj /* Each key is concated w/ 'New'
+{
+  fooNew: 10,
+  barNew: 20,
+  bazNew: 30
+}
+*/
 ```
 
 ## map

index.js

@@ -16,12 +16,13 @@ module.exports = extendObjectPrototype
 function extendObjectPrototype (hideWarnings) {
   [
     'every',
+    'inverse',
     'filter',
-    'find',
     'findKey',
+    'find',
     'forEach',
-    'map',
     'mapKeys',
+    'map',
     'reduce',
     'some'
   ].forEach(function (methodName) {

inverse.js

@@ -0,0 +1,29 @@
+/**
+ * @module object-loops/inverse
+ */
+var isInteger = require('101/is-integer')
+var reduce = require('./reduce')
+
+/**
+ * Creates a new object with keys and values swapped.
+ * @function module:object-loops/inverse
+ * @param {object} [obj] - object to inverse keys and values, not accepted if being used directly on Object.prototype
+ * @returns {object} newly created object with inverseped values
+ */
+module.exports = inverse
+
+function inverse (obj) {
+  if (Array.isArray(obj)) {
+    var valsAreInts = obj.every(isInteger)
+    return obj.reduce(flip, valsAreInts ? [] : {})
+  }
+  if (typeof obj !== 'object' && typeof obj !== 'function') {
+    throw new TypeError(obj + ' must be an object')
+  }
+  return reduce(obj, flip, {})
+}
+
+function flip (inversed, val, key) {
+  inversed[val] = key
+  return inversed
+}

test/fixtures/reset-object-prototype.js

@@ -1,5 +1,6 @@
 var methodNames = [
   'every',
+  'inverse',
   'filter',
   'find',
   'findKey',

test/test-inverse.js

@@ -0,0 +1,91 @@
+var Code = require('code')
+var Lab = require('lab')
+var lab = exports.lab = Lab.script()
+
+var describe = lab.describe
+var it = lab.it
+var before = lab.before
+var after = lab.after
+var expect = Code.expect
+
+var inverse = require('../inverse')
+
+describe('inverse', function () {
+  describe('prototype', function () {
+    before(function (done) {
+      require('../index')()
+      done()
+    })
+    after(require('./fixtures/reset-object-prototype'))
+    it('should iterate through all the key-value pairs in the object', function (done) {
+      var obj = {
+        foo: 1,
+        bar: 2,
+        baz: 3
+      }
+      var ret = obj.inverse()
+      expect(ret).to.deep.equal({
+        '1': 'foo',
+        '2': 'bar',
+        '3': 'baz'
+      })
+      done()
+    })
+  })
+  describe('require', function () {
+    it('should iterate through all the key-value pairs in the object', function (done) {
+      var obj = {
+        foo: 1,
+        bar: 2,
+        baz: 3
+      }
+      var ret = inverse(obj)
+      expect(ret).to.deep.equal({
+        '1': 'foo',
+        '2': 'bar',
+        '3': 'baz'
+      })
+      done()
+    })
+    it('should iterate through all the key-value pairs in an array (integer values)', function (done) {
+      var arr = [
+        2,
+        4,
+        6
+      ]
+      var ret = inverse(arr)
+      expect(ret).to.deep.equal([
+        undefined,
+        undefined,
+        0,
+        undefined,
+        1,
+        undefined,
+        2
+      ])
+      done()
+    })
+    it('should iterate through all the key-value pairs in an array (non-integer values)', function (done) {
+      var arr = [
+        2,
+        'yo',
+        6
+      ]
+      var ret = inverse(arr)
+      expect(ret).to.deep.equal({
+        '2': 0,
+        'yo': 1,
+        '6': 2
+      })
+      done()
+    })
+    describe('errors', function () {
+      it('should throw an error if obj must be an object', function (done) {
+        var obj = 'notObject'
+        var fn = inverse.bind(null, obj)
+        expect(fn).to.throw(/must be an object/)
+        done()
+      })
+    })
+  })
+})