Add optional override feature in invert object utility helper

In utilities, `invertObject` can now take an optional 2nd parameter
which is an override function. The function takes the parameters
key and value and the override is only valid if it returns with an
array of 2 items. Otherwise, the default swapping behavior will
occur as usual.

The motivation for adding this feature is because React's
SVGDOMPropertyConfig has properrty keys with values of 0. As a
result, the override will come in handy when dealing with those
properties.

Add utilities tests to verify the new feature in the helper.

Author: remarkablemark

lib/utilities.js

@@ -29,20 +29,32 @@ function camelCase(string) {
 /**
  * Swap key with value in an object.
  *
- * @param  {Object} obj - The object.
- * @return {Object}     - The inverted object.
+ * @param  {Object}   obj        - The object.
+ * @param  {Function} [override] - The override method.
+ * @return {Object}              - The inverted object.
  */
-function invertObject(obj) {
+function invertObject(obj, override) {
     if (typeof obj !== 'object' || !obj) { // null is an object
         throw new Error('`invert`: First argument must be an object.');
     }
 
-    var result = {};
     var key;
     var value;
+    var isOverridePresent = typeof override === 'function';
+    var overrides = {};
+    var result = {};
 
     for (key in obj) {
         value = obj[key];
+
+        if (isOverridePresent) {
+            overrides = override(key, value);
+            if (overrides && overrides.length === 2) {
+                result[overrides[0]] = overrides[1];
+                continue;
+            }
+        }
+
         if (typeof value === 'string') {
             result[value] = key;
         }

test/utilities.js

@@ -36,6 +36,12 @@ describe('utilties', function() {
     describe('`invertObject` helper', function() {
         var invertObject = utilities.invertObject;
 
+        it('throws an error if the first argument is invalid', function() {
+            [undefined, null, 'foo', 1337].forEach(function(parameter) {
+                assert.throws(function() { invertObject(parameter); });
+            });
+        })
+
         it('swaps key with value for object', function() {
             assert.deepEqual(
                 invertObject({ foo: 'bar', baz: 'qux' }),
@@ -59,11 +65,29 @@ describe('utilties', function() {
             );
         });
 
-        it('throws an error if the first argument is invalid', function() {
-            [undefined, null, 'foo', 1337].forEach(function(parameter) {
-                assert.throws(function() { invertObject(parameter); });
-            });
-        })
+        it('uses override if valid', function() {
+            assert.deepEqual(
+                invertObject({ foo: 'bar', baz: 'qux' }, function(key, value) {
+                    if (key === 'foo') {
+                        return ['key', 'value'];
+                    }
+                }),
+                { key: 'value', qux: 'baz' }
+            );
+        });
+
+        it('does not use override if invalid', function() {
+            assert.deepEqual(
+                invertObject({ foo: 'bar', baz: 'qux' }, function(key, value) {
+                    if (key === 'foo') {
+                        return ['key'];
+                    } else if (key === 'baz') {
+                        return { key: 'value'  };
+                    }
+                }),
+                { bar: 'foo', qux: 'baz' }
+            );
+        });
     });
 
 });