Add missing transform feature.

Author: koresar

.eslintrc

@@ -165,6 +165,6 @@
     "space-before-function-paren": [2, "never"], // http://eslint.org/docs/rules/space-before-function-paren
     "space-infix-ops": 2,            // http://eslint.org/docs/rules/space-infix-ops
     "space-return-throw-case": 2,    // http://eslint.org/docs/rules/space-return-throw-case
-    "spaced-line-comment": 2,        // http://eslint.org/docs/rules/spaced-line-comment
+    "spaced-line-comment": 2         // http://eslint.org/docs/rules/spaced-line-comment
   }
 }

README.md

@@ -3,6 +3,12 @@
 
 Mixes/merges/extends your object in multiple ways.
 
+Unlike underscore/lodash utility methods this module allows you to:
+* mix or deep merge objects' prototype chain. Regular mixin/extend/assign implementations can't do that.
+* mix or deep merge unique properties only. I.e. no data will be overwritten if a property already exists.
+* filter each individual property by target value, source value, and key. See API.
+* transform each value by target value, source value, and key. See API.
+
 ## Install
 ```sh
 $ npm install supermixer
@@ -42,7 +48,7 @@ functionMixer({}, { a: "x" },  { b: function(){} });
 
 ### Mixin functions including prototype chain.
 ```js
-// assigns functions only, but traverse through the protorype chain
+// assigns functions only, but traverse through the prototype chain
 var chainFunctionMixer = mixer({
   filter: function (val) { return typeof val === 'function' ; },
   chain: true
@@ -97,5 +103,29 @@ mergeChainData(new EventEmitter());
 // { hello: "world" }
 ```
 
+## API
+
+### supermixer(opts = {})
+The `opts`:
+```
+ * @param {Object} opts
+ * @param {Function} opts.filter Function which filters value and key.
+ * @param {Function} opts.transform Function which transforms each value.
+ * @param {Boolean} opts.chain Loop through prototype properties too.
+ * @param {Boolean} opts.deep Deep looping through the nested properties.
+ * @param {Boolean} opts.noOverwrite Do not overwrite any existing data (aka first one wins).
+```
+
+Usage:
+```js
+mixer({
+  filter(sourceValue, targetValue, key) { return key[0] !== '_'; }, // do not copy "private" values
+  transform(resultValue, targetValue, key) { console.log(key); return resultValue; }, // log each key which gets set
+  chain: true,
+  deep: true,
+  noOverwrite: true
+});
+```
+
 ## Want to contribute?
 This project is Open Open Source. This means whoever submits an accepted PR will receive write permissions to the project.

src/mixer.js

@@ -9,6 +9,7 @@ import isUndefined from 'lodash/lang/isUndefined';
  *
  * @param {Object} opts
  * @param {Function} opts.filter Function which filters value and key.
+ * @param {Function} opts.transform Function which transforms each value.
  * @param {Boolean} opts.chain Loop through prototype properties too.
  * @param {Boolean} opts.deep Deep looping through the nested properties.
  * @param {Boolean} opts.noOverwrite Do not overwrite any existing data (aka first one wins).
@@ -45,12 +46,14 @@ export default function mixer(opts = {}) {
       }
     }
 
-    function iteratee(srcValue, key) {
-      if (opts.filter && !opts.filter(srcValue, target[key], key)) {
+    function iteratee(sourceValue, key) {
+      const targetValue = target[key];
+      if (opts.filter && !opts.filter(sourceValue, targetValue, key)) {
         return;
       }
 
-      target[key] = opts.deep ? opts._innerMixer(target[key], srcValue) : srcValue;
+      const result = opts.deep ? opts._innerMixer(targetValue, sourceValue) : sourceValue;
+      target[key] = opts.transform ? opts.transform(result, targetValue, key) : result;
     }
 
     const loop = opts.chain ? forIn : forOwn;

test/all-options.js

@@ -0,0 +1,33 @@
+import test from 'tape';
+import mixer from '../src/index';
+
+test('all options work together', (t) => {
+  var mix = mixer({
+    filter(sourceValue, targetValue, key) { return key[0] !== '_'; },
+    transform(resultingValue, targetValue, key) { return key === 'name' ? 'new name' : resultingValue; },
+    chain: true,
+    deep: true,
+    noOverwrite: true
+  });
+
+  // Using tape.Test as a good example of a complex object.
+  const obj = new test.Test('old name');
+  obj.deep = { deeper: true };
+  const result = mix({ readable: 'no overwrite please' }, obj);
+
+  t.equal(obj.readable, true, 'pre check source object');
+  t.notEqual(obj.name, 'new name', 'pre check source object');
+
+  t.ok(result.assert, 'should grab prototype properties');
+  t.ok(result.emit, 'should grab prototype of prototype properties');
+  t.notOk(result._ok, 'should filter out private properties');
+  t.notOk(result._skip, 'should filter out private properties');
+  t.notOk(result._end, 'should filter out private properties');
+  t.notOk(result._assert, 'should filter out private properties');
+  t.ok(result.deep.deeper, 'should grab deep properties');
+  t.equal(result.name, 'new name', 'should transform values');
+  t.equal(result.readable, 'no overwrite please', 'should not overwrite properties');
+
+  t.end();
+});
+