Merge remote-tracking branch 'upstream/master' into spaces

Author: pfhayes

docs/rules/button-has-type.md

@@ -0,0 +1,58 @@
+# Prevent usage of `button` elements without an explicit `type` attribute (react/button-has-type)
+
+The default value of `type` attribute for `button` HTML element is `"submit"` which is often not the desired behavior and may lead to unexpected page reloads.
+This rules enforces an explicit `type` attribute for all the `button` elements and checks that its value is valid per spec (i.e., is one of `"button"`, `"submit"`, and `"reset"`).
+
+## Rule Details
+
+The following patterns are considered errors:
+
+```jsx
+var Hello = <button>Hello</button>
+var Hello = <button type="foo">Hello</button>
+
+var Hello = React.createElement('button', {}, 'Hello')
+var Hello = React.createElement('button', {type: 'foo'}, 'Hello')
+```
+
+The following patterns are **not** considered errors:
+
+```jsx
+var Hello = <span>Hello</span>
+var Hello = <span type="foo">Hello</span>
+var Hello = <button type="button">Hello</button>
+var Hello = <button type="submit">Hello</button>
+var Hello = <button type="reset">Hello</button>
+
+var Hello = React.createElement('span', {}, 'Hello')
+var Hello = React.createElement('span', {type: 'foo'}, 'Hello')
+var Hello = React.createElement('button', {type: 'button'}, 'Hello')
+var Hello = React.createElement('button', {type: 'submit'}, 'Hello')
+var Hello = React.createElement('button', {type: 'reset'}, 'Hello')
+```
+
+## Rule Options
+
+```js
+...
+"react/button-has-type": [<enabled>, {
+  "button": <boolean>,
+  "submit": <boolean>,
+  "reset": <boolean>
+}]
+...
+```
+
+You can forbid particular type attribute values by passing `false` as corresponding option (by default all of them are `true`).
+
+The following patterns are considered errors when using `"react/button-has-type": ["error", {reset: false}]`:
+
+```jsx
+var Hello = <button type="reset">Hello</button>
+
+var Hello = React.createElement('button', {type: 'reset'}, 'Hello')
+```
+
+## When Not To Use It
+
+If you use only `"submit"` buttons, you can disable this rule

docs/rules/forbid-prop-types.md

@@ -44,14 +44,22 @@ class Component extends React.Component {
 
 ```js
 ...
-"react/forbid-prop-types": [<enabled>, { "forbid": [<string>] }]
+"react/forbid-prop-types": [<enabled>, { "forbid": [<string>], checkContextTypes: <boolean>, checkChildContextTypes: <boolean> }]
 ...
 ```
 
 ### `forbid`
 
 An array of strings, with the names of `PropTypes` keys that are forbidden. The default value for this option is `['any', 'array', 'object']`.
 
+### `checkContextTypes`
+
+Whether or not to check `contextTypes` for forbidden prop types. The default value is false.
+
+### `checkChildContextTypes`
+
+Whether or not to check `childContextTypes` for forbidden prop types. The default value is false.
+
 ## When not to use
 
 This rule is a formatting/documenting preference and not following it won't negatively affect the quality of your code. This rule encourages prop types that more specifically document their usage.

docs/rules/no-deprecated.md

@@ -23,6 +23,9 @@ const propTypes = {
   foo: PropTypes.bar,
 };
 
+//Any factories under React.DOM
+React.DOM.div();
+
 import React, { PropTypes } from 'react';
 ```
 

docs/rules/prefer-stateless-function.md

@@ -6,7 +6,7 @@ Stateless functional components are simpler than class based components and will
 
 This rule will check your class based React components for
 
-* methods/properties other than `displayName`, `propTypes`, `render` and useless constructor (same detection as ESLint [no-useless-constructor rule](http://eslint.org/docs/rules/no-useless-constructor))
+* methods/properties other than `displayName`, `propTypes`, `contextTypes`, `defaultProps`, `render` and useless constructor (same detection as ESLint [no-useless-constructor rule](http://eslint.org/docs/rules/no-useless-constructor))
 * instance property other than `this.props` and `this.context`
 * extension of `React.PureComponent` (if the `ignorePureComponents` flag is true)
 * presence of `ref` attribute in JSX

docs/rules/require-default-props.md

@@ -102,6 +102,19 @@ Greeting.defaultProps = {
 };
 ```
 
+```jsx
+type Props = {
+  foo: string,
+  bar?: string
+};
+
+function MyStatelessComponent(props: Props) {
+  return <div>Hello {props.foo} {props.bar}</div>;
+}
+```
+
+The following patterns are **not** considered warnings:
+
 ```jsx
 class Greeting extends React.Component {
   render() {
@@ -121,19 +134,6 @@ class Greeting extends React.Component {
 }
 ```
 
-```jsx
-type Props = {
-  foo: string,
-  bar?: string
-};
-
-function MyStatelessComponent(props: Props) {
-  return <div>Hello {props.foo} {props.bar}</div>;
-}
-```
-
-The following patterns are **not** considered warnings:
-
 ```jsx
 function MyStatelessComponent({ foo, bar }) {
   return <div>{foo}{bar}</div>;
@@ -184,6 +184,91 @@ NotAComponent.propTypes = {
 };
 ```
 
+## Rule Options
+
+```js
+...
+"react/require-default-props": [<enabled>, { forbidDefaultForRequired: <boolean> }]
+...
+```
+
+* `enabled`: for enabling the rule. 0=off, 1=warn, 2=error. Defaults to 0.
+* `forbidDefaultForRequired`: optional boolean to forbid prop default for a required prop. Defaults to false.
+
+### `forbidDefaultForRequired`
+
+Forbids setting a default for props that are marked as `isRequired`.
+
+The following patterns are warnings:
+
+```jsx
+class Greeting extends React.Component {
+  render() {
+    return (
+      <h1>Hello, {this.props.foo} {this.props.bar}</h1>
+    );
+  }
+
+  static propTypes = {
+    foo: PropTypes.string,
+    bar: PropTypes.string.isRequired
+  };
+
+  static defaultProps = {
+    foo: "foo",
+    bar: "bar"
+  };
+}
+```
+
+```jsx
+function MyStatelessComponent({ foo, bar }) {
+  return <div>{foo}{bar}</div>;
+}
+
+MyStatelessComponent.propTypes = {
+  foo: PropTypes.string.isRequired,
+  bar: PropTypes.string
+};
+
+MyStatelessComponent.defaultProps = {
+  foo: 'foo',
+  bar: 'bar'
+};
+```
+
+The following patterns are **not** warnings:
+
+```jsx
+class Greeting extends React.Component {
+  render() {
+    return (
+      <h1>Hello, {this.props.foo} {this.props.bar}</h1>
+    );
+  }
+
+  static propTypes = {
+    foo: PropTypes.string,
+    bar: PropTypes.string.isRequired
+  };
+
+  static defaultProps = {
+    foo: "foo"
+  };
+}
+```
+
+```jsx
+function MyStatelessComponent({ foo, bar }) {
+  return <div>{foo}{bar}</div>;
+}
+
+MyStatelessComponent.propTypes = {
+  foo: PropTypes.string.isRequired,
+  bar: PropTypes.string.isRequired
+};
+```
+
 ## When Not To Use It
 
 If you don't care about using `defaultsProps` for your component's props that are not required, you can disable this rule.

index.js

@@ -30,6 +30,7 @@ const allRules = {
   'jsx-no-literals': require('./lib/rules/jsx-no-literals'),
   'jsx-no-target-blank': require('./lib/rules/jsx-no-target-blank'),
   'jsx-one-expression-per-line': require('./lib/rules/jsx-one-expression-per-line'),
+  'button-has-type': require('./lib/rules/button-has-type'),
   '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'),

lib/rules/boolean-prop-naming.js

@@ -6,6 +6,7 @@
 
 const has = require('has');
 const Components = require('../util/Components');
+const propsUtil = require('../util/props');
 
 // ------------------------------------------------------------------------------
 // Rule Definition
@@ -49,32 +50,6 @@ module.exports = {
     // Remembers all Flowtype object definitions
     const objectTypeAnnotations = new Map();
 
-    /**
-     * Checks if node is `propTypes` declaration
-     * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if node is `propTypes` declaration, false if not.
-     */
-    function isPropTypesDeclaration(node) {
-      // Special case for class properties
-      // (babel-eslint does not expose property name so we have to rely on tokens)
-      if (node && node.type === 'ClassProperty') {
-        const tokens = context.getFirstTokens(node, 2);
-        if (tokens[0].value === 'propTypes' || (tokens[1] && tokens[1].value === 'propTypes')) {
-          return true;
-        }
-        // Flow support
-        if (node.typeAnnotation && node.key.name === 'props') {
-          return true;
-        }
-        return false;
-      }
-
-      return Boolean(
-        node &&
-        node.name === 'propTypes'
-      );
-    }
-
     /**
      * Returns the prop key to ensure we handle the following cases:
      * propTypes: {
@@ -169,7 +144,7 @@ module.exports = {
 
     return {
       ClassProperty: function(node) {
-        if (!rule || !isPropTypesDeclaration(node)) {
+        if (!rule || !propsUtil.isPropTypesDeclaration(node)) {
           return;
         }
         if (node.value && node.value.properties) {
@@ -181,7 +156,7 @@ module.exports = {
       },
 
       MemberExpression: function(node) {
-        if (!rule || !isPropTypesDeclaration(node.property)) {
+        if (!rule || !propsUtil.isPropTypesDeclaration(node)) {
           return;
         }
         const component = utils.getRelatedComponent(node);
@@ -198,7 +173,7 @@ module.exports = {
 
         // Search for the proptypes declaration
         node.properties.forEach(property => {
-          if (!isPropTypesDeclaration(property.key)) {
+          if (!propsUtil.isPropTypesDeclaration(property)) {
             return;
           }
           validatePropNaming(node, property.value.properties);