fix: proper implementation of mapDispatchToProps-prefer-object (#7)

Author: DianaSuvorova

docs/rules/mapDispatchToProps-prefer-object.md

@@ -10,21 +10,24 @@ In most cases one just needs to pass an object with an actions. And connect wrap
 The following pattern is considered incorrect:
 
 ```js
-const mapDispatchToProps = (dispatch) => (
-        {
-            requestFilteredItems: (keyword) => {
-                dispatch(requestFilteredItems(keyword));
-            }
-        }
-    )
+const mapDispatchToProps = (dispatch) => dispatch(action())
 ```
 
-The following patterns are considered correct:
+```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)
+```

lib/rules/mapDispatchToProps-prefer-object.js

@@ -1,28 +1,41 @@
+const isReactReduxConnect = require('../isReactReduxConnect');
+
 const report = function (context, node) {
   context.report({
     message: 'mapDispatchToProps should return object',
     node,
   });
 };
 
-const checkDeclaration = function (context, node) {
-  const init = (
-    node.id &&
-    node.id.name === 'mapDispatchToProps' &&
-    ((node.init && node.init.body) || node.body)
-  );
-  if (init && context.getSource(init) !== '{}') {
-    report(context, node);
-  }
-};
 
 module.exports = function (context) {
   return {
     VariableDeclaration(node) {
-      node.declarations.forEach(decl => checkDeclaration(context, decl));
+      node.declarations.forEach((decl) => {
+        if (decl.id && decl.id.name === 'mapDispatchToProps') {
+          if (decl.init && (
+            decl.init.type === 'ArrowFunctionExpression' ||
+            decl.init.type === 'FunctionExpression'
+          )) {
+            report(context, decl);
+          }
+        }
+      });
     },
     FunctionDeclaration(node) {
-      checkDeclaration(context, node);
+      if (node.id && node.id.name === 'mapDispatchToProps') {
+        report(context, node.body);
+      }
+    },
+    CallExpression(node) {
+      if (isReactReduxConnect(node)) {
+        const mapDispatchToProps = node.arguments && node.arguments[1];
+        if (mapDispatchToProps.type === 'ArrowFunctionExpression' ||
+        mapDispatchToProps.type === 'FunctionExpression'
+        ) {
+          report(context, mapDispatchToProps);
+        }
+      }
     },
   };
 };

lib/rules/mapStateToProps-no-store.js

@@ -31,10 +31,10 @@ module.exports = function (context) {
       node.declarations.forEach((decl) => {
         if (decl.id && decl.id.name === 'mapStateToProps') {
           const body = decl.init.body;
-          const firxtParamName = decl.init.params &&
+          const firstParamName = decl.init.params &&
                 decl.init.params[0] &&
                 decl.init.params[0].name;
-          checkFunction(context, body, firxtParamName);
+          checkFunction(context, body, firstParamName);
         }
       });
     },

package.json

@@ -13,8 +13,8 @@
   "scripts": {
     "lint": "eslint ./",
     "test": "npm run lint && mocha tests --recursive",
-    "test-single": "mocha tests/lib/rules/mapStateToProps-no-store",
-    "debug-test": "mocha --debug-brk --inspect tests/lib/rules/mapStateToProps-no-store",
+    "test-single": "mocha tests/lib/rules/mapDispatchToProps-prefer-object",
+    "debug-test": "mocha --debug-brk --inspect tests/lib/rules/mapDispatchToProps-prefer-object",
     "semantic-release": "semantic-release",
     "commitmsg": "npm run test && commitlint -e $GIT_PARAMS"
   },

tests/lib/rules/mapDispatchToProps-prefer-object.js

@@ -16,10 +16,29 @@ const ruleTester = new RuleTester({ parserOptions });
 ruleTester.run('mapDispatchToProps-prefer-object', rule, {
   valid: [
     'const mapDispatchToProps = {anAction: anAction}',
-    'const mapDispatchToProps = () => {}',
-    'function mapDispatchToProps () {}',
+    `export default connect(
+      state => ({
+        productsList: state.Products.productsList,
+      }),
+      { fetchProducts }
+    )(Products);
+    `,
   ],
   invalid: [{
+    code: 'function mapDispatchToProps () {}',
+    errors: [
+      {
+        message: 'mapDispatchToProps should return object',
+      },
+    ],
+  }, {
+    code: 'const mapDispatchToProps = () => {}',
+    errors: [
+      {
+        message: 'mapDispatchToProps should return object',
+      },
+    ],
+  }, {
     code: `const mapDispatchToProps = (dispatch) => (
             {
                 requestFilteredItems: (client, keyword) => {
@@ -32,5 +51,55 @@ ruleTester.run('mapDispatchToProps-prefer-object', rule, {
         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 => ({
+                productsList: state.Products.productsList,
+              }),
+              dispatch => dispatch(action())
+            )(Products);
+            `,
+    errors: [
+      {
+        message: 'mapDispatchToProps should return object',
+      },
+    ],
+  }, {
+    code: `export default connect(
+              state => ({
+                productsList: state.Products.productsList,
+              }),
+              function(dispatch){ return dispatch(action()) }
+            )(Products);
+            `,
+    errors: [
+      {
+        message: 'mapDispatchToProps should return object',
+      },
+    ],
   }],
 });