Use each-props and change API about reverse flag.

Author: sttk

README.md

@@ -15,7 +15,7 @@ Install
 -------
 
 ```
-$ npm i copy-props
+$ npm i copy-props --save
 ```
 
 Usage
@@ -58,11 +58,11 @@ Usage
     var src = { a: 1, b: { b1: 'bbb' } };
     var dst = { a: 0 };
 
-    copyProps(src, dst, function(value, keyChain) {
-      if (keyChain === 'a') {
+    copyProps(src, dst, function(value, keychain) {
+      if (keychain === 'a') {
         return value * 2;
       }
-      if (keyChain === 'b.b1') {
+      if (keychain === 'b.b1') {
         return value.toUpperCase();
       }
     });
@@ -74,12 +74,12 @@ Usage
     ```js
     var src = { a: 1, b: { c: 'CCC' }, d: { e: 'EEE' } };
     var dst = { a: 9, b: { c: 'xxx' }, d: { e: 'yyy' } };
-    var fromToProps = [ 'a.b.c', 'd.e' ];
-    copyProps(src, dst, fromToProps);
+    var fromto = [ 'a.b.c', 'd.e' ];
+    copyProps(src, dst, fromto);
     // => { a: 1, b: { c: 'CCC' }, d: { e: 'EEE' } }
     ```
 
-* Can copy reversively (from *dst* to *src*) by option `{ reverse: true }` (and return *src*):
+* Can copy reversively (from *dst* to *src*) by reverse flag (and return *src*):
 
     ```js
     var src = { a: 1, b: { b1: 'bbb' }, c: 'ccc' };
@@ -98,56 +98,48 @@ Usage
       'b.b1': 'f.b1',
       'b.b2': 'f.b2',
       'c': 'f.c',
-    }, { reverse: true });
+    }, true);
     // => { a: 2, b: { b1: 'bbb', b2: 'yyy' }, c: 'ccc', d: 'ddd' }
     ```
 
-* Can reject to copy null value by option `{ rejectNull: true }` :
+* If a value of source property is undefined (when not using converter), or a result of converter is undefined (when using converter), the value is not copied.
 
     ```js
-    var src = { a: 8, b: { c: -1, d: null } };
-    var dst = { a: 1, b: { c:  2, e: 4 } };
-
-    copyProps(src, dst, function(v) {
-      return (typeof v !== 'number' || v < 0) ? null : v;
-    }, { rejectNull: true });
-    // => { a: 8, b: { c: 2, e: 4 } }
-    ```
-
-    ***This `opts` must be passed at the place of the 4rd argument or later.***
-    
-    So, when you use the `opts` and don't use neither `fromToProps` nor `converter`, write the code as follows:
-
-    ```js
-    var src = { a: 8, b: { c: -1, d: null } };
-    var dst = { a: 1, b: { c:  2, e: 4 } };
-
-    copyProps(src, dst, null, { rejectNull: true });
-    // => { a: 8, b: { c: -1, e: 4 } }
+    var src = { a: 'A', b: undefined, c: null, d: 1 };
+    var dst = { a: 'a', b: 'b', c: 'c' };
+
+    copyProps(src, dst, function(value, key) {
+      if (key === 'd') {
+        return undefined;
+      } else {
+        return value;
+      }
+    });
+    // => { a: 'A', b: 'b', c: null }
     ```
 
 API
 ---
 
-### <u>copyProps(src, dst [, fromToProps] [, converter] [, opts]) => object</u>
+### <u>copyProps(src, dst [, fromto] [, converter] [, reverse]) => object</u>
 
 Copy properties of *src* to *dst* deeply.
-If *fromToProps* is given, it is able to copy between different properties.
+If *fromto* is given, it is able to copy between different properties.
 If *converter* is given, it is able to convert the terminal values.
 
 * **Arguments:**
 
     * **src** [object] : a source object of copy.
     * **dst** [object] : a destinate object of copy.
-    * **fromToProps** [object | array] : an object mapping properties between *src* and *dst*. (optional)
+    * **fromto** [object | array] : an object mapping properties between *src* and *dst*. (optional)
     * **converter** [function] : a function to convert terminal values in *src*. (optional) 
-    * **opts** [object] : an option object which specifys copy's behaviors (optional)
+    * **reverse** [boolean] : copys reversively from dst to src and returns src object. `fromto` is also reversively used from value to key. This default value is `false`. (optional)
 
 * **Return** [object] : *dst* object after copying.
 
-#### *Format of fromToProps*
+#### *Format of fromto*
 
-*fromToProps* is a non-nested key-value object. And the *key*s are property key chains of *src* and the *value*s are property key chains of *dst*. 
+*fromto* is a non-nested key-value object. And the *key*s are property key chains of *src* and the *value*s are property key chains of *dst*. 
 The key chain is a string which is concatenated property keys on each level with dots, like `'aaa.bbb.ccc'`.
 
 The following example copys the value of `src.aaa.bbb.ccc` to `dst.xxx.yyy`.
@@ -158,29 +150,21 @@ copyProps(src, dst, {
 })
 ```
 
-*fromToProps* can be an array. In that case, the array works as a map which has pairs of same key and value.
+*fromto* can be an array. In that case, the array works as a map which has pairs of same key and value.
 
 #### *API of converter*
 
-**<u>converter(value, keyChain) => any</u>**
+**<u>converter(value, keychain) => any</u>**
 
 *converter* is a function to convert terminal values of propeerties of *src*.
 
 * **Arguments:**
 
     * **value** [any] : a property value to be converted.
-    * **keyChain** [string] : a string of property keys concatenated with dots.
+    * **keychain** [string] : a string of property keys concatenated with dots.
 
 * **Return:** [any] : converted value.
 
-#### *Properties of opts*
-
-*opts* can have following properties:
-
-* **reverse** [boolean] : Copys reversively from *dst* to *src* and returns *src* object. *fromToProps* is also reversively used from value to key. This default value is `false`.
-* **rejectNull** [boolean] : if this option is `true`, a value of a source object or a return value of *converter* is not copied when the value is null. The default value is `true`.
-
-
 License
 -------
 

index.js

@@ -4,53 +4,167 @@
 
 var inspect = require('util').inspect;
 var isPlainObject = require('lodash.isplainobject');
-var copyProps = require('./lib/copy-props');
+var eachProps = require('each-props');
+var setDeep = require('lodash.set');
 
-module.exports = function(src, dst, fromTo, converter, opts) {
+module.exports = function(src, dst, fromto, converter, reverse) {
   if (!isPlainObject(src)) {
-    throw new TypeError('The 1st argument need to be a plain object: ' +
+    throw new TypeError('The source needs to be a plain object: ' +
       inspect(src));
   }
 
   if (!isPlainObject(dst)) {
-    throw new TypeError('The 2nd argument need to be a plain object: ' +
+    throw new TypeError('The destination needs to be a plain object: ' +
       inspect(dst));
   }
 
-  if (opts == null) {
-    if (isPlainObject(converter)) {
-      opts = converter;
-
-      if (typeof fromTo === 'function') {
-        converter = fromTo;
-        fromTo = null;
+  switch (typeof fromto) {
+    case 'boolean': {
+      reverse = fromto;
+      converter = noop;
+      fromto = undefined;
+      break;
+    }
+    case 'function': {
+      reverse = converter;
+      converter = fromto;
+      fromto = undefined;
+      break;
+    }
+    default: {
+      if (fromto == null) {
+        /*fromto = fromto;*/
+      } else if (isPlainObject(fromto)) {
+        /*fromto = fromto;*/
+      } else if (Array.isArray(fromto)) {
+        fromto = arrayToMap(fromto);
       } else {
-        converter = null;
+        throw new TypeError('The from-to map needs to be a plain object: ' +
+          inspect(fromto));
       }
+      break;
+    }
+  }
 
-    } else if (converter == null) {
+  switch (typeof converter) {
+    case 'function': {
+      break;
+    }
+    case 'boolean': {
+      reverse = converter;
+      converter = noop;
+      break;
+    }
+    default: {
+      if (converter == null) {
+        converter = noop;
+      } else {
+        throw new TypeError('The converter needs to be a function: ' +
+          inspect(converter));
+      }
+    }
+  }
 
-      if (typeof fromTo === 'function') {
-        converter = fromTo;
-        fromTo = null;
+  switch (typeof reverse) {
+    case 'boolean': {
+      break;
+    }
+    default: {
+      if (reverse == null) {
+        reverse = false;
+      } else {
+        throw new TypeError('The reverse flag needs to be a boolean: ' +
+          inspect(reverse));
       }
     }
   }
 
-  if (opts != null && !isPlainObject(opts)) {
-    throw new TypeError('The 5th argument need to be an object: ' +
-      inspect(opts));
+  return copyProps(src, dst, fromto, converter, reverse);
+};
+
+function noop(v) {
+  return v;
+}
+
+function invert(fromto) {
+  var inverted = {};
+  var keys = Object.keys(fromto);
+  for (var i = 0, n = keys.length; i < n; i++) {
+    var key = keys[i];
+    var val = fromto[key];
+    if (!inverted[val]) {
+      inverted[val] = [];
+    }
+    inverted[val].push(key);
   }
+  return inverted;
+}
 
-  if (converter != null && typeof converter !== 'function') {
-    throw new TypeError('The 4th argument need to be a function: ' +
-      inspect(converter));
+function arrayToMap(array) {
+  var map = {};
+  for (var i = 0, n = array.length; i < n; i++) {
+    map[array[i]] = array[i];
   }
+  return map;
+}
 
-  if (fromTo != null && !isPlainObject(fromTo) && !Array.isArray(fromTo)) {
-    throw new TypeError('The 3th argument need to be a plain object or ' +
-      'an array: ' + inspect(fromTo));
+function copyProps(src, dst, fromto, converter, reverse) {
+  if (reverse) {
+    var tmp = src;
+    src = dst;
+    dst = tmp;
   }
 
-  return copyProps(src, dst, fromTo, converter, opts);
-};
+  if (isPlainObject(fromto)) {
+    if (reverse) {
+      fromto = invert(fromto);
+
+      eachProps(src, function(value, keychain, opts) {
+        if (isPlainObject(value)) {
+          return;
+        }
+        var dstKeychains = fromto[keychain];
+        if (dstKeychains == null) {
+          return;
+        }
+        for (var i = 0, n = dstKeychains.length; i < n; i++) {
+          var dstValue = converter(value, keychain, dstKeychains[i], opts);
+          if (dstValue === undefined) {
+            return;
+          }
+          setDeep(dst, dstKeychains[i], dstValue);
+        }
+      });
+      return dst;
+    }
+
+    eachProps(src, function(value, keychain, opts) {
+      if (isPlainObject(value)) {
+        return;
+      }
+      var dstKeychain = fromto[keychain];
+      if (!dstKeychain) {
+        return;
+      }
+      var dstValue = converter(value, keychain, dstKeychain, opts);
+      if (dstValue === undefined) {
+        return;
+      }
+      setDeep(dst, dstKeychain, dstValue);
+    });
+    return dst;
+
+  } else {
+    eachProps(src, function(value, keychain, opts) {
+      if (isPlainObject(value)) {
+        return;
+      }
+      var dstValue = converter(value, keychain, keychain, opts);
+      if (dstValue === undefined) {
+        return;
+      }
+      setDeep(dst, keychain, dstValue);
+    });
+    return dst;
+  }
+}