Support Object.assign, et al, for bool-prop-naming

With `propObjectAssignFunctions` set in settings like so:
```
{
 ...
 propOjectAssignFunctions: ["Object.assign"]
 ...
}
```

One can use `Object.assign` for setting the propTypes like this:
```
function Foo() {...}

Foo.propTypes = Object.assign({}, morePropTypes, { isLoading:
PropTypes.bool });
```
And the boolean-prop-naming rule should be able to verify the prop
`isLoading` against the defined options.

Author: jomasti

README.md

@@ -43,6 +43,7 @@ You can also specify some settings that will be shared across all the plugin rul
       "flowVersion": "0.53" // Flow version
     },
     "propWrapperFunctions": [ "forbidExtraProps" ] // The names of any functions used to wrap the propTypes object, such as `forbidExtraProps`. If this isn't set, any propTypes wrapped in a function will be skipped.
+    "propObjectAssignFunctions": [ "Object.assign" ] // The names of functions used to merge props when declaring propTypes. If this isn't set, any propTypes set using any assign/merge function will be skipped.
   }
 }
 ```

lib/rules/boolean-prop-naming.js

@@ -45,6 +45,7 @@ module.exports = {
     const config = context.options[0] || {};
     const rule = config.rule ? new RegExp(config.rule) : null;
     const propTypeNames = config.propTypeNames || ['bool'];
+    const propObjectAssignFunctions = new Set(context.settings.propObjectAssignFunctions || []);
 
     // Remembers all Flowtype object definitions
     const objectTypeAnnotations = new Map();
@@ -158,6 +159,22 @@ module.exports = {
       });
     }
 
+    /**
+     * Checks if call expression node is one of the propObjectAssignFunctions in the settings
+     * @param {ASTNode} node The node to process
+     * @returns {Boolean} True if the function name is defined in the settings, false if not
+     */
+    function isPropObjectAssignFunction(node) {
+      if (!node) {
+        return false;
+      } else if (node.type === 'MemberExpression') {
+        return propObjectAssignFunctions.has(`${node.object.name}.${node.property.name}`);
+      } else if (node.type === 'Identifier') {
+        return propObjectAssignFunctions.has(node.name);
+      }
+      return false;
+    }
+
     // --------------------------------------------------------------------------
     // Public
     // --------------------------------------------------------------------------
@@ -180,7 +197,12 @@ module.exports = {
           return;
         }
         const component = utils.getRelatedComponent(node);
-        if (!component || !node.parent.right.properties) {
+        if (!component || !node.parent.right) {
+          return;
+        }
+        const right = node.parent.right;
+        if (right.type === 'CallExpression' && isPropObjectAssignFunction(right.callee)) {
+          right.arguments.filter(arg => arg.type === 'ObjectExpression').forEach(object => validatePropNaming(component.node, object.properties));
           return;
         }
         validatePropNaming(component.node, node.parent.right.properties);

tests/lib/rules/boolean-prop-naming.js

@@ -102,7 +102,6 @@ ruleTester.run('boolean-prop-naming', rule, {
       rule: '^is[A-Z]([A-Za-z0-9]?)+'
     }]
   }, {
-    // ES6 components as React.Component with non-boolean PropTypes
     code: `
       class Hello extends React.Component {
         render () { return <div />; }
@@ -111,6 +110,9 @@ ruleTester.run('boolean-prop-naming', rule, {
     `,
     options: [{
       rule: '^is[A-Z]([A-Za-z0-9]?)+'
+    }],
+    errors: [{
+      message: 'Prop name (a) doesn\'t match rule (^is[A-Z]([A-Za-z0-9]?)+)'
     }]
   }, {
     code: `
@@ -269,6 +271,18 @@ ruleTester.run('boolean-prop-naming', rule, {
       rule: '^is[A-Z]([A-Za-z0-9]?)+'
     }],
     parser: 'babel-eslint'
+  }, {
+    // No propObjectAssignFunctions setting
+    code: `
+    function Card(props) {
+      return <div>{props.showScore ? 'yeh' : 'no'}</div>;
+    }
+    Card.propTypes = merge({}, Card.propTypes, {
+        showScore: PropTypes.bool
+    });`,
+    options: [{
+      rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+'
+    }]
   }],
 
   invalid: [{
@@ -458,5 +472,56 @@ ruleTester.run('boolean-prop-naming', rule, {
     }, {
       message: 'Prop name (somethingElse) doesn\'t match rule (^is[A-Z]([A-Za-z0-9]?)+)'
     }]
+  }, {
+    code: `
+    function Card(props) {
+      return <div>{props.showScore ? 'yeh' : 'no'}</div>;
+    }
+    Card.propTypes = merge({}, Card.propTypes, {
+        showScore: PropTypes.bool
+    });`,
+    settings: {
+      propObjectAssignFunctions: ['merge']
+    },
+    options: [{
+      rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+'
+    }],
+    errors: [{
+      message: 'Prop name (showScore) doesn\'t match rule (^(is|has)[A-Z]([A-Za-z0-9]?)+)'
+    }]
+  }, {
+    code: `
+    function Card(props) {
+      return <div>{props.showScore ? 'yeh' : 'no'}</div>;
+    }
+    Card.propTypes = Object.assign({}, Card.propTypes, {
+        showScore: PropTypes.bool
+    });`,
+    settings: {
+      propObjectAssignFunctions: ['Object.assign']
+    },
+    options: [{
+      rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+'
+    }],
+    errors: [{
+      message: 'Prop name (showScore) doesn\'t match rule (^(is|has)[A-Z]([A-Za-z0-9]?)+)'
+    }]
+  }, {
+    code: `
+    function Card(props) {
+      return <div>{props.showScore ? 'yeh' : 'no'}</div>;
+    }
+    Card.propTypes = _.assign({}, Card.propTypes, {
+        showScore: PropTypes.bool
+    });`,
+    settings: {
+      propObjectAssignFunctions: ['_.assign']
+    },
+    options: [{
+      rule: '^(is|has)[A-Z]([A-Za-z0-9]?)+'
+    }],
+    errors: [{
+      message: 'Prop name (showScore) doesn\'t match rule (^(is|has)[A-Z]([A-Za-z0-9]?)+)'
+    }]
   }]
 });