Removed shallowEqualScalar, simplified connect update logic

Author: taylorhakes

src/components/createConnectDecorator.js

@@ -1,5 +1,4 @@
 import getDisplayName from '../utils/getDisplayName';
-import shallowEqualScalar from '../utils/shallowEqualScalar';
 
 export default function createConnectDecorator(React, Connector) {
   const { Component } = React;
@@ -9,10 +8,6 @@ export default function createConnectDecorator(React, Connector) {
       static displayName = `Connector(${getDisplayName(DecoratedComponent)})`;
       static DecoratedComponent = DecoratedComponent;
 
-      shouldComponentUpdate(nextProps) {
-        return !shallowEqualScalar(this.props, nextProps);
-      }
-
       render() {
         return (
           <Connector select={state => select(state, this.props)}>

src/components/createConnector.js

@@ -23,20 +23,10 @@ export default function createConnector(React) {
     };
 
     shouldComponentUpdate(nextProps, nextState) {
-      return !this.isSliceEqual(this.state.slice, nextState.slice) ||
+      return !shallowEqual(this.state.slice, nextState.slice) ||
              !shallowEqual(this.props, nextProps);
     }
 
-    isSliceEqual(slice, nextSlice) {
-      const isRefEqual = slice === nextSlice;
-      if (isRefEqual) {
-        return true;
-      } else if (typeof slice !== 'object' || typeof nextSlice !== 'object') {
-        return isRefEqual;
-      }
-      return shallowEqual(slice, nextSlice);
-    }
-
     constructor(props, context) {
       super(props, context);
       this.state = this.selectState(props, context);
@@ -60,7 +50,7 @@ export default function createConnector(React) {
 
     handleChange(props = this.props) {
       const nextState = this.selectState(props, this.context);
-      if (!this.isSliceEqual(this.state.slice, nextState.slice)) {
+      if (!shallowEqual(this.state.slice, nextState.slice)) {
         this.setState(nextState);
       }
     }

src/utils/shallowEqual.js

@@ -3,6 +3,11 @@ export default function shallowEqual(objA, objB) {
     return true;
   }
 
+  if (typeof objA !== 'object' || objA === null ||
+      typeof objB !== 'object' || objB === null) {
+    return false;
+  }
+
   const keysA = Object.keys(objA);
   const keysB = Object.keys(objB);
 
@@ -11,10 +16,8 @@ export default function shallowEqual(objA, objB) {
   }
 
   // Test for A's keys different from B.
-  const hasOwn = Object.prototype.hasOwnProperty;
   for (let i = 0; i < keysA.length; i++) {
-    if (!hasOwn.call(objB, keysA[i]) ||
-        objA[keysA[i]] !== objB[keysA[i]]) {
+    if (objA[keysA[i]] !== objB[keysA[i]]) {
       return false;
     }
   }

src/utils/shallowEqualScalar.js

@@ -0,0 +1,94 @@
+import expect from 'expect';
+import shallowEqual from '../../src/utils/shallowEqual';
+
+describe('Utils', () => {
+  // More info: https://github.com/gaearon/redux/pull/75#issuecomment-111635748
+  describe('shallowEqual', () => {
+    it('should return true if arguments fields are equal', () => {
+      expect(
+        shallowEqual(
+          { a: 1, b: 2, c: undefined },
+          { a: 1, b: 2, c: undefined }
+        )
+      ).toBe(true);
+
+      expect(
+        shallowEqual(
+          { a: 1, b: 2, c: 3 },
+          { a: 1, b: 2, c: 3 }
+        )
+      ).toBe(true);
+
+      const o = {};
+      expect(
+        shallowEqual(
+          { a: 1, b: 2, c: o },
+          { a: 1, b: 2, c: o }
+        )
+      ).toBe(true);
+      expect(
+          shallowEqual(
+              null,
+              null
+          )
+      ).toBe(true);
+      expect(
+          shallowEqual(
+              1,
+              1
+          )
+      ).toBe(true);
+    });
+
+    it('should return false if first argument has too many keys', () => {
+      expect(
+        shallowEqual(
+          { a: 1, b: 2, c: 3 },
+          { a: 1, b: 2 }
+        )
+      ).toBe(false);
+    });
+
+    it('should return false if second argument has too many keys', () => {
+      expect(
+        shallowEqual(
+          { a: 1, b: 2 },
+          { a: 1, b: 2, c: 3 }
+        )
+      ).toBe(false);
+    });
+
+    it('should return false if arguments have different keys', () => {
+      expect(
+        shallowEqual(
+          { a: 1, b: 2, c: undefined },
+          { a: 1, bb: 2, c: undefined }
+        )
+      ).toBe(false);
+    });
+    it('should return false if different values', () => {
+      expect(
+          shallowEqual(
+              { a: 1, b: 2, c: {} },
+              { a: 1, b: 2, c: {} }
+          )
+      ).toBe(false);
+    });
+    it('should return true if both empty objects', () => {
+      expect(
+          shallowEqual(
+              {},
+              {}
+          )
+      ).toBe(true);
+    });
+    it('should return false if object and null', () => {
+      expect(
+          shallowEqual(
+             null,
+              {}
+          )
+      ).toBe(false);
+    });
+  });
+});