Merge branch 'master' into flow-53-hoc

Author: yannickcr

.eslintrc

@@ -3,10 +3,10 @@
        "es6": true,
        "node": true
     },
-    parserOptions: {
-      ecmaVersion: 6,
-      ecmaFeatures: {
-          jsx: true
+    "parserOptions": {
+      "ecmaVersion": 6,
+      "ecmaFeatures": {
+          "jsx": true
       }
     },
     "rules": {

README.md

@@ -142,6 +142,7 @@ Finally, enable all of the rules that you would like to use.  Use [our preset](#
 * [react/jsx-no-literals](docs/rules/jsx-no-literals.md): Prevent usage of unwrapped JSX strings
 * [react/jsx-no-target-blank](docs/rules/jsx-no-target-blank.md): Prevent usage of unsafe `target='_blank'`
 * [react/jsx-no-undef](docs/rules/jsx-no-undef.md): Disallow undeclared variables in JSX
+* [react/jsx-curly-brace-presence](docs/rules/jsx-curly-brace-presence.md): Enforce curly braces or disallow unnecessary curly braces in JSX
 * [react/jsx-pascal-case](docs/rules/jsx-pascal-case.md): Enforce PascalCase for user-defined JSX components
 * [react/jsx-sort-props](docs/rules/jsx-sort-props.md): Enforce props alphabetical sorting (fixable)
 * [react/jsx-space-before-closing](docs/rules/jsx-space-before-closing.md): Validate spacing before closing bracket in JSX (fixable)

docs/rules/jsx-curly-brace-presence.md

@@ -0,0 +1,150 @@
+# Enforce curly braces or disallow unnecessary curly braces in JSX props and/or children. (react/jsx-curly-brace-presence)
+
+This rule allows you to enforce curly braces or disallow unnecessary curly braces in JSX props and/or children.
+
+For situations where JSX expressions are unnecessary, please refer to [the React doc](https://facebook.github.io/react/docs/jsx-in-depth.html) and [this page about JSX gotchas](https://github.com/facebook/react/blob/v15.4.0-rc.3/docs/docs/02.3-jsx-gotchas.md#html-entities).
+
+**Fixable:** This rule is automatically fixable using the `--fix` flag on the command line
+
+## Rule Details
+
+By default, this rule will check for and warn about unnecessary curly braces in both JSX props and children.
+
+You can pass in options to enforce the presence of curly braces on JSX props or children or both. The same options are available for not allowing unnecessary curly braces as well as ignoring the check.
+
+## Rule Options
+
+```js
+...
+"react/jsx-curly-brace-presence": [<enabled>, { "props": <string>, "children": <string> }]
+...
+```
+
+or alternatively
+
+```js
+...
+"react/jsx-curly-brace-presence": [<enabled>, <string>]
+...
+```
+
+### Valid options for <string>
+
+They are `always`, `never` and `ignore` for checking on JSX props and children.
+
+* `always`: always enforce curly braces inside JSX props or/and children
+* `never`: never allow unnecessary curly braces inside JSX props or/and children
+* `ignore`: ignore the rule for JSX props or/and children
+
+If passed in the option to fix, this is how a style violation will get fixed
+
+* `always`: wrap a JSX attribute in curly braces/JSX expression and/or a JSX child the same way but also with double quotes
+* `never`: get rid of curly braces from a JSX attribute and/or a JSX child
+
+- All fixing operations use double quotes.
+
+For examples:
+
+When `{ props: "always", children: "always" }` is set, the following patterns will be given warnings.
+
+```jsx
+<App>Hello world</App>;
+<App prop='Hello world'>{'Hello world'}</App>;
+```
+
+They can be fixed to:
+
+```jsx
+<App>{"Hello world"}</App>;
+<App prop={"Hello world"}>{'Hello world'}</App>;
+```
+
+When `{ props: "never", children: "never" }` is set, the following patterns will be given warnings.
+
+```jsx
+<App>{'Hello world'}</App>;
+<App prop={'Hello world'} attr={"foo"} />;
+```
+
+They can be fixed to:
+
+```jsx
+<App>Hello world</App>;
+<App prop="Hello world" attr="foo" />;
+```
+
+### Alternative syntax
+
+The options are also `always`, `never` and `ignore` for the same meanings.
+
+In this syntax, only a string is provided and the default will be set to that option for checking on both JSX props and children.
+
+For examples:
+
+When `'always'` is set, the following patterns will be given warnings.
+
+```jsx
+<App>Hello world</App>;
+<App prop='Hello world' attr="foo">Hello world</App>;
+```
+
+They can be fixed to:
+```jsx
+<App>{"Hello world"}</App>;
+<App prop={"Hello world"} attr={"foo"}>{"Hello world"}</App>;
+```
+
+When `'never'` is set, the following pattern will be given warnings.
+
+```jsx
+<App prop={'foo'} attr={"bar"}>{'Hello world'}</App>;
+```
+
+It can fixed to:
+
+```jsx
+<App prop="foo" attr="bar">Hello world</App>;
+```
+
+## Edge cases
+
+The fix also deals with template literals, strings with quotes, and strings with escapes characters.
+
+* If the rule is set to get rid of unnecessary curly braces and the template literal inside a JSX expression has no expression, it will throw a warning and be fixed with double quotes. For example:
+
+```jsx
+<App prop={`Hello world`}>{`Hello world`}</App>;
+```
+
+will be warned and fixed to:
+
+```jsx
+<App prop="Hello world">Hello world</App>;
+```
+
+* If the rule is set to enforce curly braces and the strings have quotes, it will be fixed with double quotes for JSX children and the normal way for JSX attributes.
+
+For example:
+
+
+```jsx
+<App prop='Hello "foo" world'>Hello 'foo' "bar" world</App>;
+```
+
+will warned and fixed to:
+
+```jsx
+<App prop={"Hello \"foo\" world"}>{"Hello 'foo' \"bar\" world"}</App>;
+```
+
+* If the rule is set to get rid of unnecessary curly braces and the strings have escaped characters, it will not warn or fix for JSX children because JSX expressions are necessary in this case. For instance:
+
+The following pattern will not be given a warning even if `'never'` is passed.
+
+```jsx
+<App>{"Hello \u00b7 world"}</App>;
+```
+
+## When Not To Use It
+
+You should turn this rule off if you are not concerned about maintaining consistency regarding the use of curly braces in JSX props and/or children as well as the use of unnecessary JSX expressions.

docs/rules/sort-comp.md

@@ -1,6 +1,6 @@
 # Enforce component methods order (react/sort-comp)
 
-When creating React components it is more convenient to always follow the same organisation for methods order to helps you to easily find lifecyle methods, event handlers, etc.
+When creating React components it is more convenient to always follow the same organisation for method order to help you easily find lifecyle methods, event handlers, etc.
 
 **Fixable:** This rule is automatically fixable using the [`sort-comp` transform](https://github.com/reactjs/react-codemod/blob/master/transforms/sort-comp.js) in [react-codemod](https://www.npmjs.com/package/react-codemod).
 

index.js

@@ -28,6 +28,7 @@ const allRules = {
   'jsx-no-literals': require('./lib/rules/jsx-no-literals'),
   'jsx-no-target-blank': require('./lib/rules/jsx-no-target-blank'),
   'jsx-no-undef': require('./lib/rules/jsx-no-undef'),
+  'jsx-curly-brace-presence': require('./lib/rules/jsx-curly-brace-presence'),
   'jsx-pascal-case': require('./lib/rules/jsx-pascal-case'),
   'jsx-sort-props': require('./lib/rules/jsx-sort-props'),
   'jsx-space-before-closing': require('./lib/rules/jsx-space-before-closing'),

lib/rules/boolean-prop-naming.js

@@ -118,7 +118,7 @@ module.exports = {
       const component = components.get(node) || node;
       const invalidProps = component.invalidProps || [];
 
-      proptypes.forEach(prop => {
+      (proptypes || []).forEach(prop => {
         const propKey = getPropKey(prop);
         const flowCheck = (
           prop.type === 'ObjectTypeProperty' &&

lib/rules/default-props-match-prop-types.js

@@ -163,23 +163,46 @@ module.exports = {
       }));
     }
 
+    /**
+     * Handles Props defined in IntersectionTypeAnnotation nodes
+     * e.g. type Props = PropsA & PropsB
+     * @param   {ASTNode} intersectionTypeAnnotation ObjectExpression node.
+     * @returns {Object[]}
+     */
+    function getPropertiesFromIntersectionTypeAnnotationNode(annotation) {
+      return annotation.types.reduce((properties, type) => {
+        annotation = resolveGenericTypeAnnotation(type);
+
+        if (annotation && annotation.id) {
+          annotation = findVariableByName(annotation.id.name);
+        }
+
+        return properties.concat(annotation.properties);
+      }, []);
+    }
+
     /**
      * Extracts a PropType from a TypeAnnotation node.
      * @param   {ASTNode} node TypeAnnotation node.
      * @returns {Object[]}     Array of PropType object representations, to be consumed by `addPropTypesToComponent`.
      */
     function getPropTypesFromTypeAnnotation(node) {
-      let properties;
+      let properties = [];
 
       switch (node.typeAnnotation.type) {
         case 'GenericTypeAnnotation':
           let annotation = resolveGenericTypeAnnotation(node.typeAnnotation);
 
-          if (annotation && annotation.id) {
-            annotation = findVariableByName(annotation.id.name);
+          if (annotation && annotation.type === 'IntersectionTypeAnnotation') {
+            properties = getPropertiesFromIntersectionTypeAnnotationNode(annotation);
+          } else {
+            if (annotation && annotation.id) {
+              annotation = findVariableByName(annotation.id.name);
+            }
+
+            properties = annotation ? (annotation.properties || []) : [];
           }
 
-          properties = annotation ? (annotation.properties || []) : [];
           break;
 
         case 'UnionTypeAnnotation':
@@ -314,7 +337,6 @@ module.exports = {
       if (!component) {
         return;
       }
-
       addPropTypesToComponent(component, getPropTypesFromTypeAnnotation(node.typeAnnotation, context));
     }