feat: new rule mapDispatchToProps-prefer-shorthand (#19)

* feat: new rule mapDispatchToProps-prefer-shorthand

Author: DianaSuvorova

docs/rules/maoDispatchToProps-prefer-shorthand.md

@@ -0,0 +1,45 @@
+#  Enforces that mapDispatchToProps uses a shorthand method to wrap actions in dispatch calls whenever possible. (react-redux/mapDispatchToProps-prefer-shorthand)
+
+>[mapDispatchToProps(dispatch, [ownProps]): dispatchProps] (Object or Function): 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.
+
+[source](https://github.com/reactjs/react-redux/blob/master/docs/api.md#connectmapstatetoprops-mapdispatchtoprops-mergeprops-options)
+
+## Rule details
+
+The following pattern is considered incorrect:
+
+```js
+const mapDispatchToProps = (dispatch) => ({
+  action: () => dispatch(action())
+})
+
+// it should use equivalent shorthand wrapping instead:
+// const mapDispatchToProps = {action}
+```
+
+```js
+const mapDispatchToProps = (dispatch) => ({
+  action: () => dispatch(action()),
+  action1: (arg1, arg2) => dispatch(action(arg1, arg2))
+})
+```
+
+The following patterns are considered correct:
+
+
+```js
+const mapDispatchToProps = {action}
+```
+
+```js
+const mapDispatchToProps = (dispatch) => ({
+  action: () => dispatch(actionHelper(true))
+})
+```
+
+```js
+const mapDispatchToProps = (dispatch) => ({
+  action: () => dispatch(action()),
+  action1: (arg1, arg2) => dispatch(action(arg1 + arg2))
+})
+```

index.js

@@ -1,6 +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-prefer-shorthand': require('./lib/rules/mapDispatchToProps-prefer-shorthand'),
   'mapDispatchToProps-returns-object': require('./lib/rules/mapDispatchToProps-returns-object'),
   'mapDispatchToProps-prefer-parameters-names': require('./lib/rules/mapDispatchToProps-prefer-parameters-names'),
   'mapStateToProps-no-store': require('./lib/rules/mapStateToProps-no-store'),
@@ -27,6 +28,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-prefer-shorthand': 2,
         'react-redux/mapDispatchToProps-returns-object': 2,
         'react-redux/mapStateToProps-no-store': 2,
         'react-redux/mapStateToProps-prefer-parameters-names': 2,

lib/rules/mapDispatchToProps-prefer-shorthand.js

@@ -0,0 +1,80 @@
+const isReactReduxConnect = require('../isReactReduxConnect');
+const utils = require('../utils');
+
+const report = function (context, node) {
+  context.report({
+    message: 'mapDispatchToProps should use a shorthand dispatch wrapping instead',
+    node,
+  });
+};
+
+const getParamsString = (params, context) =>
+  params.map(param => context.getSource(param)).join(',');
+
+
+const propertyCanUseShortHandButDoesnt = (context, prop, dispatchName) => {
+  const propName = prop.key && prop.key.name;
+  const sourceCode = context.getSource(prop.value).replace(/(\r\n|\n|\r|\t| |;)/gm, '');
+  if (prop.value && (prop.value.type === 'ArrowFunctionExpression' ||
+    prop.value.type === 'FunctionExpression')) {
+    const fncDef = prop.value;
+    const paramString = getParamsString(fncDef.params, context);
+    if ((sourceCode === `(${paramString})=>${dispatchName}(${propName}(${paramString}))`)
+      || (sourceCode === `function(${paramString}){return${dispatchName}(${propName}(${paramString}))}`
+      )) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const checkReturnNode = function (context, returnNode, dispatchName) {
+  if (returnNode.properties.every(prop =>
+    propertyCanUseShortHandButDoesnt(context, prop, dispatchName))
+  ) {
+    report(context, returnNode);
+  }
+};
+
+
+module.exports = function (context) {
+  return {
+    VariableDeclaration(node) {
+      node.declarations.forEach((decl) => {
+        if (decl.id && decl.id.name === 'mapDispatchToProps') {
+          if (decl.init && (
+            decl.init.type === 'ArrowFunctionExpression' ||
+            decl.init.type === 'FunctionExpression'
+          )) {
+            const returnNode = utils.getReturnNode(decl.init);
+            if (returnNode && returnNode.type === 'ObjectExpression') {
+              checkReturnNode(context, returnNode, 'dispatch');
+            }
+          }
+        }
+      });
+    },
+    FunctionDeclaration(node) {
+      if (node.id && node.id.name === 'mapDispatchToProps') {
+        const returnNode = utils.getReturnNode(node.body);
+        if (returnNode && returnNode.type === 'ObjectExpression') {
+          checkReturnNode(context, returnNode, 'dispatch');
+        }
+      }
+    },
+    CallExpression(node) {
+      if (isReactReduxConnect(node)) {
+        const mapDispatchToProps = node.arguments && node.arguments[1];
+        if (mapDispatchToProps && (
+          mapDispatchToProps.type === 'ArrowFunctionExpression' ||
+          mapDispatchToProps.type === 'FunctionExpression')
+        ) {
+          const returnNode = utils.getReturnNode(mapDispatchToProps);
+          if (returnNode && returnNode.type === 'ObjectExpression') {
+            checkReturnNode(context, returnNode, 'dispatch');
+          }
+        }
+      }
+    },
+  };
+};

package.json

@@ -35,7 +35,7 @@
     "eslint-plugin-standard": "^3.0.1",
     "husky": "^0.14.3",
     "mocha": "^4.0.1",
-    "semantic-release": "^11.0.2"
+    "semantic-release": "^12.4.1"
   },
   "engines": {
     "node": ">=6.10.0"

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

@@ -0,0 +1,77 @@
+require('babel-eslint');
+
+const rule = require('../../../lib/rules/mapDispatchToProps-prefer-shorthand');
+const RuleTester = require('eslint').RuleTester;
+
+const parserOptions = {
+  ecmaVersion: 6,
+  sourceType: 'module',
+  ecmaFeatures: {
+    experimentalObjectRestSpread: true,
+  },
+};
+
+const ruleTester = new RuleTester({ parserOptions });
+
+ruleTester.run('mapDispatchToProps-prefer-shorthand', rule, {
+  valid: [
+    'function mapDispatchToProps () {return {action}}',
+    `const mapDispatchToProps = dispatch => ({
+      onDoSomething: function() {return dispatch(toDo())},
+      action2: (arg1, arg2) => dispatch(action2(arg1, arg2)),
+    });`,
+    `const mapDispatchToProps = dispatch => ({
+      onDoSomething: () => dispatch(onDoSomething()),
+      action2: (arg1, arg2) => dispatch(action2(arg1 + arg2)),
+    });`,
+    'const mapDispatchToProps = {}',
+    'const mapDispatchToProps = null',
+    'const mapDispatchToProps = actionsMap',
+    'const mapDispatchToProps = {...actions}',
+    'const mapDispatchToProps = {anAction: anAction}',
+    `export default connect(
+      state => ({
+        productsList: state.Products.productsList,
+      }),
+      { fetchProducts }
+    )(Products);
+    `,
+    `const mapDispatchToProps = dispatch => ({
+      onDoSomething: () => dispatch(toSomethingElse())
+    });`,
+    'connect(null, null)(App)',
+    'function mapDispatchToProps () {return aThing}',
+  ],
+  invalid: [{
+    code: `const mapDispatchToProps = dispatch => ({
+      onDoSomething: () => dispatch(onDoSomething()),
+      action1: () => dispatch(action1()),
+      action2: (arg1, arg2) => dispatch(action2(arg1, arg2)),
+    });`,
+    errors: [
+      {
+        message: 'mapDispatchToProps should use a shorthand dispatch wrapping instead',
+      },
+    ],
+  }, {
+    code: `const mapDispatchToProps = dispatch => ({
+      onDoSomething: function() {return dispatch(onDoSomething())}
+    });`,
+    errors: [
+      {
+        message: 'mapDispatchToProps should use a shorthand dispatch wrapping instead',
+      },
+    ],
+  }, {
+    code: `const mapDispatchToProps = function(dispatch) {
+              return { requestFilteredItems: (client, keyword) =>
+                dispatch(requestFilteredItems(client, keyword))
+            };
+        }`,
+    errors: [
+      {
+        message: 'mapDispatchToProps should use a shorthand dispatch wrapping instead',
+      },
+    ],
+  }],
+});