From a7b70008bab4010dc0aea993be8d1668dd608185 Mon Sep 17 00:00:00 2001
From: John-David Dalton <john.david.dalton@gmail.com>
Date: Thu, 9 Jul 2015 19:52:18 -0700
Subject: [PATCH] Drop boolean `options` param support in `_.mixin`.

---
 lodash.src.js | 61 ++++++++++++++++++++++-----------------------------
 test/test.js  |  9 ++++----
 2 files changed, 31 insertions(+), 39 deletions(-)

diff --git a/lodash.src.js b/lodash.src.js
index 88ed3ff87..300e693fd 100644
--- a/lodash.src.js
+++ b/lodash.src.js
@@ -10804,52 +10804,43 @@
      * // => ['e']
      */
     function mixin(object, source, options) {
-      if (options == null) {
-        var isObj = isObject(source),
-            props = isObj ? keys(source) : undefined,
-            methodNames = (props && props.length) ? baseFunctions(source, props) : undefined;
+      var props = keys(source),
+          methodNames = baseFunctions(source, props);
 
-        if (!(methodNames ? methodNames.length : isObj)) {
-          methodNames = false;
-          options = source;
-          source = object;
-          object = this;
-        }
-      }
-      if (!methodNames) {
+      if (options == null &&
+          !(isObject(source) && (methodNames.length || !props.length))) {
+        options = source;
+        source = object;
+        object = this;
         methodNames = baseFunctions(source, keys(source));
       }
-      var chain = true,
+      var chain = (isObject(options) && 'chain' in options) ? options.chain : true,
           index = -1,
           isFunc = isFunction(object),
           length = methodNames.length;
 
-      if (options === false) {
-        chain = false;
-      } else if (isObject(options) && 'chain' in options) {
-        chain = options.chain;
-      }
       while (++index < length) {
         var methodName = methodNames[index],
             func = source[methodName];
 
-        object[methodName] = func;
-        if (isFunc) {
-          object.prototype[methodName] = (function(func) {
-            return function() {
-              var chainAll = this.__chain__;
-              if (chain || chainAll) {
-                var result = object(this.__wrapped__),
-                    actions = result.__actions__ = arrayCopy(this.__actions__);
+        (function(func) {
+          object[methodName] = func;
+          if (!isFunc) {
+            return;
+          }
+          object.prototype[methodName] = function() {
+            var chainAll = this.__chain__;
+            if (chain || chainAll) {
+              var result = object(this.__wrapped__),
+                  actions = result.__actions__ = copyArray(this.__actions__);
 
-                actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
-                result.__chain__ = chainAll;
-                return result;
-              }
-              return func.apply(object, arrayPush([this.value()], arguments));
-            };
-          }(func));
-        }
+              actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
+              result.__chain__ = chainAll;
+              return result;
+            }
+            return func.apply(object, arrayPush([this.value()], arguments));
+          };
+        }(func));
       }
       return object;
     }
@@ -11547,7 +11538,7 @@
         }
       });
       return source;
-    }()), false);
+    }()), { 'chain': false });
 
     /*------------------------------------------------------------------------*/
 
diff --git a/test/test.js b/test/test.js
index faf9b314b..e1dbf8cab 100644
--- a/test/test.js
+++ b/test/test.js
@@ -10943,16 +10943,17 @@
       function Foo() {}
       Foo.prototype.a = _.noop;
 
-      deepEqual(_.mixin({}, new Foo), {});
+      var object = {};
+      strictEqual(_.mixin(object, new Foo), object);
     });
 
-    test('should accept an `options` argument', 16, function() {
+    test('should accept an `options` argument', 8, function() {
       function message(func, chain) {
         return (func === _ ? 'lodash' : 'provided') + ' function should ' + (chain ? '' : 'not ') + 'chain';
       }
 
       _.each([_, Wrapper], function(func) {
-        _.each([false, true, { 'chain': false }, { 'chain': true }], function(options) {
+        _.each([{ 'chain': false }, { 'chain': true }], function(options) {
           if (!isNpm) {
             if (func === _) {
               _.mixin(source, options);
@@ -10962,7 +10963,7 @@
             var wrapped = func(array),
                 actual = wrapped.a();
 
-            if (options === true || (options && options.chain)) {
+            if (options.chain) {
               strictEqual(actual.value(), 'a', message(func, true));
               ok(actual instanceof func, message(func, true));
             } else {