From 349c627110b25643c307a5e9650f1a0b82b29581 Mon Sep 17 00:00:00 2001 From: John-David Dalton Date: Sun, 7 Feb 2016 20:17:00 -0800 Subject: [PATCH] Add options to `baseConvert`. --- fp/_baseConvert.js | 66 +++++++++++++++++-------- fp/_convertBrowser.js | 5 +- lib/fp/template/convert.jst | 5 +- test/test-fp.js | 99 ++++++++++++++++++++++++++++++++++++- 4 files changed, 149 insertions(+), 26 deletions(-) diff --git a/fp/_baseConvert.js b/fp/_baseConvert.js index 2af63a7f0..76cc02ce8 100644 --- a/fp/_baseConvert.js +++ b/fp/_baseConvert.js @@ -9,9 +9,17 @@ var mapping = require('./_mapping'), * @param {Object} util The util object. * @param {string} name The name of the function to wrap. * @param {Function} func The function to wrap. + * @param {Object} [options] The options object. + * @param {boolean} [options.cap=true] Specify capping iteratee arguments. + * @param {boolean} [options.curry=true] Specify currying. + * @param {boolean} [options.fixed=true] Specify fixed arity. + * @param {boolean} [options.immutable=true] Specify immutable operations. + * @param {boolean} [options.rearg=true] Specify rearranging arguments. * @returns {Function|Object} Returns the converted function or object. */ -function baseConvert(util, name, func) { +function baseConvert(util, name, func, options) { + options || (options = {}); + if (typeof func != 'function') { func = name; name = undefined; @@ -19,6 +27,16 @@ function baseConvert(util, name, func) { if (func == null) { throw new TypeError; } + var config = { + 'cap': 'cap' in options ? options.cap : true, + 'curry': 'curry' in options ? options.curry : true, + 'fixed': 'fixed' in options ? options.fixed : true, + 'immutable': 'immutable' in options ? options.immutable : true, + 'rearg': 'rearg' in options ? options.rearg : true + }; + + var forceRearg = ('rearg' in options) && options.rearg; + var isLib = name === undefined && typeof func.VERSION == 'string'; var _ = isLib ? func : { @@ -107,6 +125,9 @@ function baseConvert(util, name, func) { var func = arguments[0], arity = arguments[1]; + if (!config.cap) { + return iteratee(func, arity); + } arity = arity > 2 ? (arity - 2) : 1; func = iteratee(func); var length = func.length; @@ -145,7 +166,7 @@ function baseConvert(util, name, func) { }, 'runInContext': function(runInContext) { return function(context) { - return baseConvert(util, runInContext(context)); + return baseConvert(util, runInContext(context), undefined, options); }; } }; @@ -157,14 +178,16 @@ function baseConvert(util, name, func) { return wrapper(func); } var wrapped = func; - if (mutateMap.array[name]) { - wrapped = immutWrap(func, cloneArray); - } - else if (mutateMap.object[name]) { - wrapped = immutWrap(func, createCloner(func)); - } - else if (mutateMap.set[name]) { - wrapped = immutWrap(func, cloneDeep); + if (config.immutable) { + if (mutateMap.array[name]) { + wrapped = immutWrap(func, cloneArray); + } + else if (mutateMap.object[name]) { + wrapped = immutWrap(func, createCloner(func)); + } + else if (mutateMap.set[name]) { + wrapped = immutWrap(func, cloneDeep); + } } var result; each(mapping.caps, function(cap) { @@ -174,19 +197,22 @@ function baseConvert(util, name, func) { reargIndexes = mapping.iterateeRearg[name], spreadStart = mapping.methodSpread[name]; - result = spreadStart === undefined - ? ary(wrapped, cap) - : spread(wrapped, spreadStart); - - if (cap > 1 && !mapping.skipRearg[name]) { + if (config.fixed) { + result = spreadStart === undefined + ? ary(wrapped, cap) + : spread(wrapped, spreadStart); + } + if (config.rearg && cap > 1 && (forceRearg || !mapping.skipRearg[name])) { result = rearg(result, mapping.methodRearg[name] || mapping.aryRearg[cap]); } - if (reargIndexes) { - result = iterateeRearg(result, reargIndexes); - } else if (aryN) { - result = iterateeAry(result, aryN); + if (config.cap) { + if (reargIndexes) { + result = iterateeRearg(result, reargIndexes); + } else if (aryN) { + result = iterateeAry(result, aryN); + } } - if (cap > 1) { + if (config.curry && cap > 1) { result = curry(result, cap); } return false; diff --git a/fp/_convertBrowser.js b/fp/_convertBrowser.js index b076778a4..0e69e66cd 100644 --- a/fp/_convertBrowser.js +++ b/fp/_convertBrowser.js @@ -4,10 +4,11 @@ var baseConvert = require('./_baseConvert'); * Converts `lodash` to an immutable auto-curried iteratee-first data-last version. * * @param {Function} lodash The lodash function. + * @param {Object} [options] The options object. See `baseConvert` for more details. * @returns {Function} Returns the converted `lodash`. */ -function browserConvert(lodash) { - return baseConvert(lodash, lodash); +function browserConvert(lodash, options) { + return baseConvert(lodash, lodash, undefined, options); } module.exports = browserConvert; diff --git a/lib/fp/template/convert.jst b/lib/fp/template/convert.jst index 85f3b7535..a1d266fa6 100644 --- a/lib/fp/template/convert.jst +++ b/lib/fp/template/convert.jst @@ -7,10 +7,11 @@ var baseConvert = require('./_baseConvert'), * * @param {string} name The name of the function to wrap. * @param {Function} [func] The function to wrap. + * @param {Object} [options] The options object. See `baseConvert` for more details. * @returns {Function|Object} Returns the converted function or object. */ -function convert(name, func) { - return baseConvert(util, name, func); +function convert(name, func, options) { + return baseConvert(util, name, func, options); } module.exports = convert; diff --git a/test/test-fp.js b/test/test-fp.js index 1a5b04f1a..a10343e14 100644 --- a/test/test-fp.js +++ b/test/test-fp.js @@ -46,8 +46,8 @@ var convert = root.fp || (function() { var baseConvert = load('../fp/_baseConvert.js'); - return function(name, func) { - return baseConvert(_, name, func); + return function(name, func, options) { + return baseConvert(_, name, func, options); }; }()); @@ -76,6 +76,101 @@ console.log('Running lodash/fp tests.'); } + QUnit.module('convert'); + + (function() { + QUnit.test('should accept an `options` argument', function(assert) { + assert.expect(3); + + if (!document) { + var remove = convert('remove', _.remove, { + 'cap': false, + 'curry': false, + 'fixed': false, + 'immutable': false, + 'rearg': false + }); + + var array = [1, 2, 3, 4]; + + var actual = remove(array, function(n) { + return n % 2 == 0; + }); + + assert.deepEqual(array, [1, 3]); + assert.deepEqual(actual, [2, 4]); + assert.deepEqual(remove(), []); + } + else { + skipTest(assert, 3); + } + }); + + QUnit.test('should respect the `cap` option', function(assert) { + assert.expect(1); + + if (!document) { + var iteratee = convert('iteratee', _.iteratee, { + 'cap': false + }); + + var func = iteratee(function(a, b, c) { + return [a, b, c]; + }, 3); + + assert.deepEqual(func(1, 2, 3), [1, 2, 3]); + } + else { + skipTest(assert); + } + }); + + QUnit.test('should respect the `rearg` option', function(assert) { + assert.expect(1); + + if (!document) { + var add = convert('add', _.add, { + 'rearg': true + }); + + assert.strictEqual(add('2')('1'), '12'); + } + else { + skipTest(assert); + } + }); + + QUnit.test('should use `options` in `runInContext`', function(assert) { + assert.expect(3); + + if (!document) { + var runInContext = convert('runInContext', _.runInContext, { + 'cap': false, + 'curry': false, + 'fixed': false, + 'immutable': false, + 'rearg': false + }); + + var array = [1, 2, 3, 4], + lodash = runInContext(); + + var actual = lodash.remove(array, function(n) { + return n % 2 == 0; + }); + + assert.deepEqual(array, [1, 3]); + assert.deepEqual(actual, [2, 4]); + assert.deepEqual(lodash.remove(), []); + } + else { + skipTest(assert, 3); + } + }); + }()); + + /*--------------------------------------------------------------------------*/ + QUnit.module('method arity checks'); (function() {