Revert "BREAKING CHANGE: refactor MDTP-prefer-object to MDTP-returns-object (#17)"

This reverts commit e628781.

Author: DianaSuvorova

docs/rules/mapDispatchToProps-prefer-object.md

@@ -0,0 +1,33 @@
+#  Enforces that mapDispatchToProps returns an object. (react-redux/mapDispatchToProps-prefer-object)
+
+In most cases one just needs to pass an object with an actions. And connect wraps it into dispatch function.
+
+[react-redux documentation](https://github.com/reactjs/react-redux/blob/master/docs/api.md#arguments)
+> If an object is passed, each function inside it is assumed to be a Redux action creator. An object with the same function names, but with every action creator wrapped into a dispatch call so they may be invoked directly, will be merged into the component’s props.
+
+## Rule details
+
+The following pattern is considered incorrect:
+
+```js
+const mapDispatchToProps = (dispatch) => dispatch(action())
+```
+
+```js
+connect((state) => state, (dispatch) => dispatch(action()))(App)
+```
+
+```js
+const mapDispatchToProps = () => {}
+```
+
+The following patterns are considered correct:
+
+
+```js
+const mapDispatchToProps = {anAction: anAction}
+```
+
+```js
+connect((state) => state, {anAction}))(App)
+```

docs/rules/mapDispatchToProps-returns-object.md

@@ -1,7 +1,7 @@
 const rules = {
   'connect-prefer-minimum-two-arguments': require('./lib/rules/connect-prefer-minimum-two-arguments'),
   'connect-prefer-named-arguments': require('./lib/rules/connect-prefer-named-arguments'),
-  'mapDispatchToProps-returns-object': require('./lib/rules/mapDispatchToProps-returns-object'),
+  'mapDispatchToProps-prefer-object': require('./lib/rules/mapDispatchToProps-prefer-object'),
   'mapDispatchToProps-prefer-parameters-names': require('./lib/rules/mapDispatchToProps-prefer-parameters-names'),
   'mapStateToProps-no-store': require('./lib/rules/mapStateToProps-no-store'),
   'mapStateToProps-prefer-parameters-names': require('./lib/rules/mapStateToProps-prefer-parameters-names'),
@@ -27,7 +27,7 @@ module.exports = {
         'react-redux/connect-prefer-minimum-two-arguments': 0,
         'react-redux/connect-prefer-named-arguments': 2,
         'react-redux/mapDispatchToProps-prefer-parameters-names': 2,
-        'react-redux/mapDispatchToProps-returns-object': 2,
+        'react-redux/mapDispatchToProps-prefer-object': 2,
         'react-redux/mapStateToProps-no-store': 2,
         'react-redux/mapStateToProps-prefer-parameters-names': 2,
         'react-redux/prefer-separate-component-file': 1,

index.js

@@ -1,5 +1,4 @@
 const isReactReduxConnect = require('../isReactReduxConnect');
-const utils = require('../utils');
 
 const report = function (context, node) {
   context.report({
@@ -18,20 +17,14 @@ module.exports = function (context) {
             decl.init.type === 'ArrowFunctionExpression' ||
             decl.init.type === 'FunctionExpression'
           )) {
-            const returnNode = utils.getReturnNode(decl.init);
-            if (!utils.isObject(returnNode)) {
-              report(context, node);
-            }
+            report(context, decl);
           }
         }
       });
     },
     FunctionDeclaration(node) {
       if (node.id && node.id.name === 'mapDispatchToProps') {
-        const returnNode = utils.getReturnNode(node.body);
-        if (!utils.isObject(returnNode)) {
-          report(context, node);
-        }
+        report(context, node.body);
       }
     },
     CallExpression(node) {
@@ -41,10 +34,7 @@ module.exports = function (context) {
           mapDispatchToProps.type === 'ArrowFunctionExpression' ||
           mapDispatchToProps.type === 'FunctionExpression')
         ) {
-          const returnNode = utils.getReturnNode(mapDispatchToProps);
-          if (!utils.isObject(returnNode)) {
-            report(context, node);
-          }
+          report(context, mapDispatchToProps);
         }
       }
     },

lib/rules/mapDispatchToProps-returns-object.js renamed to lib/rules/mapDispatchToProps-prefer-object.js

@@ -1,31 +1,18 @@
 'use strict';
 
-const isObject = node => node && (
-  node.type === 'ObjectExpression' || node.type === 'Identifier'
-);
-
 const getReturnNode = (node) => {
   const body = node.body;
-  if (!body) {
+  if (!body || !body.length) {
     return node;
-  } else if (isObject(body)) {
-    return body;
-  } else if (body.type === 'BlockStatement') {
-    return getReturnNode(body);
   }
   for (let i = body.length - 1; i >= 0; i -= 1) {
     if (body[i].type === 'ReturnStatement') {
-      const arg = body[i].argument;
-      if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
-        return getReturnNode(arg);
-      }
-      return arg;
+      return body[i].argument;
     }
   }
   return null;
 };
 
 module.exports = {
   getReturnNode,
-  isObject,
 };

lib/utils.js

@@ -1,6 +1,6 @@
 require('babel-eslint');
 
-const rule = require('../../../lib/rules/mapDispatchToProps-returns-object');
+const rule = require('../../../lib/rules/mapDispatchToProps-prefer-object');
 const RuleTester = require('eslint').RuleTester;
 
 const parserOptions = {
@@ -13,11 +13,8 @@ const parserOptions = {
 
 const ruleTester = new RuleTester({ parserOptions });
 
-ruleTester.run('mapDispatchToProps-returns-object', rule, {
+ruleTester.run('mapDispatchToProps-prefer-object', rule, {
   valid: [
-    'const mapDispatchToProps = {}',
-    'const mapDispatchToProps = null',
-    'const mapDispatchToProps = actionsMap',
     'const mapDispatchToProps = {...actions}',
     'const mapDispatchToProps = {anAction: anAction}',
     `export default connect(
@@ -27,29 +24,7 @@ ruleTester.run('mapDispatchToProps-returns-object', rule, {
       { fetchProducts }
     )(Products);
     `,
-    'function mapDispatchToProps () {return {action}}',
-    `const mapDispatchToProps = (dispatch) => (
-            {
-                requestFilteredItems: (client, keyword) => {
-                    dispatch(requestFilteredItems(client, keyword));
-                }
-            }
-        )
-    `,
-    `const mapDispatchToProps = dispatch => ({
-      onDoSomething: () => dispatch(toSomethingElse())
-    });`,
-    `const mapDispatchToProps = function(dispatch) {
-          return { requestFilteredItems: (client, keyword) => {
-            dispatch(requestFilteredItems(client, keyword));
-          }
-        }
-    }`,
     'connect(null, null)(App)',
-    'function mapDispatchToProps () {return aThing}',
-    `function mapDispatchToProps(dispatch) {
-      return { actions: bindActionCreators(actionCreators, dispatch) }
-    }`,
   ],
   invalid: [{
     code: 'function mapDispatchToProps () {}',
@@ -65,6 +40,43 @@ ruleTester.run('mapDispatchToProps-returns-object', rule, {
         message: 'mapDispatchToProps should return object',
       },
     ],
+  }, {
+    code: `const mapDispatchToProps = (dispatch) => (
+            {
+                requestFilteredItems: (client, keyword) => {
+                    dispatch(requestFilteredItems(client, keyword));
+                }
+            }
+        )`,
+    errors: [
+      {
+        message: 'mapDispatchToProps should return object',
+      },
+    ],
+  }, {
+    code: `function mapDispatchToProps(dispatch) {
+              return { requestFilteredItems: (client, keyword) => {
+                dispatch(requestFilteredItems(client, keyword));
+              }
+            }
+        }`,
+    errors: [
+      {
+        message: 'mapDispatchToProps should return object',
+      },
+    ],
+  }, {
+    code: `const mapDispatchToProps = function(dispatch) {
+              return { requestFilteredItems: (client, keyword) => {
+                dispatch(requestFilteredItems(client, keyword));
+              }
+            }
+        }`,
+    errors: [
+      {
+        message: 'mapDispatchToProps should return object',
+      },
+    ],
   }, {
     code: `export default connect(
               state => ({