wip: code formatting nits continued

test/partial-methods.spec.js

@@ -0,0 +1,124 @@
+import lodashStable from 'lodash';
+import { _, identity, slice } from './utils';
+import placeholder from '../src/placeholder';
+import curry from '../src/curry';
+
+describe('partial methods', () => {
+    lodashStable.each(['partial', 'partialRight'], (methodName) => {
+        const func = _[methodName],
+            isPartial = methodName === 'partial',
+            ph = func.placeholder;
+
+        it(`\`_.${methodName}\` partially applies arguments`, () => {
+            const par = func(identity, 'a');
+            expect(par()).toBe('a');
+        });
+
+        it(`\`_.${methodName}\` creates a function that can be invoked with additional arguments`, () => {
+            const fn = function (a, b) {
+                    return [a, b];
+                },
+                par = func(fn, 'a'),
+                expected = isPartial ? ['a', 'b'] : ['b', 'a'];
+
+            expect(par('b')).toEqual(expected);
+        });
+
+        it(`\`_.${methodName}\` works when there are no partially applied arguments and the created function is invoked without additional arguments`, () => {
+            const fn = function () {
+                    return arguments.length;
+                },
+                par = func(fn);
+
+            expect(par()).toBe(0);
+        });
+
+        it(`\`_.${methodName}\` works when there are no partially applied arguments and the created function is invoked with additional arguments`, () => {
+            const par = func(identity);
+            expect(par('a')).toBe('a');
+        });
+
+        it(`\`_.${methodName}\` should support placeholders`, () => {
+            let fn = function () {
+                    return slice.call(arguments);
+                },
+                par = func(fn, ph, 'b', ph);
+
+            expect(par('a', 'c')).toEqual(['a', 'b', 'c']);
+            expect(par('a')).toEqual(['a', 'b', undefined]);
+            expect(par()).toEqual([undefined, 'b', undefined]);
+
+            if (isPartial) {
+                expect(par('a', 'c', 'd')).toEqual(['a', 'b', 'c', 'd']);
+            } else {
+                par = func(fn, ph, 'c', ph);
+                expect(par('a', 'b', 'd')).toEqual(['a', 'b', 'c', 'd']);
+            }
+        });
+
+        it(`\`_.${methodName}\` should use \`_.placeholder\` when set`, () => {
+            const _ph = (placeholder = {}),
+                fn = function () {
+                    return slice.call(arguments);
+                },
+                par = func(fn, _ph, 'b', ph),
+                expected = isPartial ? ['a', 'b', ph, 'c'] : ['a', 'c', 'b', ph];
+
+            expect(par('a', 'c')).toEqual(expected);
+            delete placeholder;
+        });
+
+        it(`\`_.${methodName}\` creates a function with a \`length\` of \`0\``, () => {
+            const fn = function (a, b, c) {},
+                par = func(fn, 'a');
+
+            expect(par.length).toBe(0);
+        });
+
+        it(`\`_.${methodName}\` should ensure \`new par\` is an instance of \`func\``, () => {
+            function Foo(value) {
+                return value && object;
+            }
+
+            var object = {},
+                par = func(Foo);
+
+            expect(new par() instanceof Foo)
+            expect(new par(true)).toBe(object);
+        });
+
+        it(`\`_.${methodName}\` should clone metadata for created functions`, () => {
+            function greet(greeting, name) {
+                return `${greeting} ${name}`;
+            }
+
+            const par1 = func(greet, 'hi'),
+                par2 = func(par1, 'barney'),
+                par3 = func(par1, 'pebbles');
+
+            expect(par1('fred')).toBe(isPartial ? 'hi fred' : 'fred hi');
+            expect(par2()).toBe(isPartial ? 'hi barney' : 'barney hi');
+            expect(par3()).toBe(isPartial ? 'hi pebbles' : 'pebbles hi');
+        });
+
+        it(`\`_.${methodName}\` should work with curried functions`, () => {
+            const fn = function (a, b, c) {
+                    return a + b + c;
+                },
+                curried = curry(func(fn, 1), 2);
+
+            expect(curried(2, 3)).toBe(6);
+            expect(curried(2)(3)).toBe(6);
+        });
+
+        it('should work with placeholders and curried functions', () => {
+            const fn = function () {
+                    return slice.call(arguments);
+                },
+                curried = curry(fn),
+                par = func(curried, ph, 'b', ph, 'd');
+
+            expect(par('a', 'c')).toEqual(['a', 'b', 'c', 'd']);
+        });
+    });
+});