fp.convert should handle aliased and remapped methods. [closes #2728]

fp/_baseConvert.js

@@ -1,5 +1,7 @@
 var mapping = require('./_mapping'),
+    aliasToReal = mapping.aliasToReal,
     mutateMap = mapping.mutate,
+    remap = mapping.remap,
     fallbackHolder = require('./placeholder');
 
 /**
@@ -351,13 +353,16 @@ function baseConvert(util, name, func, options) {
    * @returns {Function} Returns the new converter function.
    */
   function createConverter(name, func) {
-    var oldOptions = options;
+    var realName = aliasToReal[name] || name,
+        methodName = remap[realName] || realName,
+        oldOptions = options;
+
     return function(options) {
       var newUtil = isLib ? pristine : helpers,
-          newFunc = isLib ? pristine[name] : func,
+          newFunc = isLib ? pristine[methodName] : func,
           newOptions = assign(assign({}, oldOptions), options);
 
-      return baseConvert(newUtil, name, newFunc, newOptions);
+      return baseConvert(newUtil, realName, newFunc, newOptions);
     };
   }
 
@@ -428,7 +433,7 @@ function baseConvert(util, name, func, options) {
    * @returns {Function} Returns the converted function.
    */
   function wrap(name, func) {
-    name = mapping.aliasToReal[name] || name;
+    name = aliasToReal[name] || name;
 
     var result,
         wrapped = func,
@@ -491,7 +496,7 @@ function baseConvert(util, name, func, options) {
   var pairs = [];
   each(aryMethodKeys, function(aryKey) {
     each(mapping.aryMethod[aryKey], function(key) {
-      var func = _[mapping.remap[key] || key];
+      var func = _[remap[key] || key];
       if (func) {
         pairs.push([key, wrap(key, func)]);
       }

test/test-fp.js

@@ -273,6 +273,25 @@
       assert.strictEqual(fp.isArray(array), true);
       assert.strictEqual(isArray()(array), true);
     });
+
+    QUnit.test('should convert method aliases', function(assert) {
+      assert.expect(1);
+
+      var all = fp.all.convert({ 'rearg': false }),
+          actual = all([0])(_.identity);
+
+      assert.strictEqual(actual, false);
+    });
+
+    QUnit.test('should convert remapped methods', function(assert) {
+      assert.expect(1);
+
+      var extendAll = fp.extendAll.convert({ 'immutable': false }),
+          object = {};
+
+      extendAll([object, { 'a': 1 }, { 'b': 2 }]);
+      assert.deepEqual(object, { 'a': 1, 'b': 2 });
+    });
   }());
 
   /*--------------------------------------------------------------------------*/