Add no-deprecated-methods rule to prevents usage of deprecated component lifecycle methods

.travis.yml

@@ -9,6 +9,8 @@ node_js:
   - '4'
 before_install:
   - 'nvm install-latest-npm'
+before_script:
+  - 'if [ -n "${ESLINT-}" ]; then npm install --no-save "eslint@${ESLINT}" ; fi'
 script:
   - 'if [ -n "${PRETEST-}" ]; then npm run pretest ; fi'
   - 'if [ -n "${TEST-}" ]; then npm run unit-test ; fi'
@@ -21,7 +23,28 @@ matrix:
   include:
     - node_js: 'lts/*'
       env: PRETEST=true
+    - node_js: '9'
+      env: TEST=true ESLINT=next
+    - node_js: '8'
+      env: TEST=true ESLINT=next
+    - node_js: '7'
+      env: TEST=true ESLINT=next
+    - node_js: '6'
+      env: TEST=true ESLINT=next
+    - node_js: '9'
+      env: TEST=true ESLINT=3
+    - node_js: '8'
+      env: TEST=true ESLINT=3
+    - node_js: '7'
+      env: TEST=true ESLINT=3
+    - node_js: '6'
+      env: TEST=true ESLINT=3
+    - node_js: '5'
+      env: TEST=true ESLINT=3
+    - node_js: '4'
+      env: TEST=true ESLINT=3
   allow_failures:
     - node_js: '9'
     - node_js: '7'
     - node_js: '5'
+    - env: TEST=true ESLINT=next

CHANGELOG.md

@@ -3,6 +3,35 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 This change log adheres to standards from [Keep a CHANGELOG](http://keepachangelog.com).
 
+## [7.9.1] - 2018-06-03
+* Nothing was fixed; this is a republish with some updated deps. ([#1804][] @ljharb)
+
+[#1804]: https://github.com/yannickcr/eslint-plugin-react/issues/1804
+
+## [7.9.0] - 2018-06-03
+### Added
+* Add [`jsx-props-no-multi-spaces`][] rule ([#1755][] @ThiefMaster)
+* Add `first` option to [`jsx-indent-props`][] ([#398][] @ThiefMaster)
+* Add `enforceDynamicLinks` option to [`jsx-no-target-blank`][] ([#1737][] @kenearley)
+
+### Fixed
+* Fix static lifecycle methods validation in [`sort-comp`][] ([#1793][] @lynxtaa)
+* Fix crash in [`no-typos`][] when encountering anonymous react imports ([#1796][] @jsg2021)
+* Fix ESLint 3 support ([#1779][])
+
+### Changed
+* Documentation improvements ([#1794][] @lencioni)
+* Update Travis CI configuration to test on multiple ESLint verions
+
+[7.9.0]: https://github.com/yannickcr/eslint-plugin-react/compare/v7.8.2...v7.9.0
+[#1755]: https://github.com/yannickcr/eslint-plugin-react/pull/1755
+[#398]: https://github.com/yannickcr/eslint-plugin-react/issues/398
+[#1737]: https://github.com/yannickcr/eslint-plugin-react/issues/1737
+[#1793]: https://github.com/yannickcr/eslint-plugin-react/issues/1793
+[#1796]: https://github.com/yannickcr/eslint-plugin-react/pull/1796
+[#1779]: https://github.com/yannickcr/eslint-plugin-react/issues/1779
+[#1794]: https://github.com/yannickcr/eslint-plugin-react/pull/1794
+
 ## [7.8.2] - 2018-05-13
 ### Fixed
 * Fix crash in [`boolean-prop-naming`][] when encountering a required shape prop type ([#1791][] @pcorpet)
@@ -2205,3 +2234,4 @@ If you're still not using React 15 you can keep the old behavior by setting the
 [`no-this-in-sfc`]: docs/rules/no-this-in-sfc.md
 [`jsx-sort-default-props`]: docs/rules/jsx-sort-default-props.md
 [`jsx-max-depth`]: docs/rules/jsx-max-depth.md
+[`jsx-props-no-multi-spaces`]: docs/rules/jsx-props-no-multi-spaces.md

docs/rules/jsx-no-target-blank.md

@@ -15,8 +15,8 @@ This rule aims to prevent user generated links from creating security vulerabili
 
 There are two main options for the rule:
 
-* `{"enforceDynamicLinks": "always"}` enforces the rule if the href is a dyanamic link (default)
-* `{"enforceDynamicLinks": "never"}` does not enforce the rule if the href is a dyamic link
+* `{"enforceDynamicLinks": "always"}` enforces the rule if the href is a dynamic link (default)
+* `{"enforceDynamicLinks": "never"}` does not enforce the rule if the href is a dynamic link
 
 
 ### always (default)

lib/rules/boolean-prop-naming.js

@@ -68,9 +68,10 @@ module.exports = {
      * @param {Object} node The node we're getting the name of
      */
     function getPropKey(node) {
-      // Check for `ExperimentalSpreadProperty` so we can skip validation of those fields.
-      // Otherwise it will look for `node.value.property` which doesn't exist and breaks Eslint.
-      if (node.type === 'ExperimentalSpreadProperty') {
+      // Check for `ExperimentalSpreadProperty` (ESLint 3/4) and `SpreadElement` (ESLint 5)
+      // so we can skip validation of those fields.
+      // Otherwise it will look for `node.value.property` which doesn't exist and breaks ESLint.
+      if (node.type === 'ExperimentalSpreadProperty' || node.type === 'SpreadElement') {
         return null;
       }
       if (node.value.property) {

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

@@ -41,6 +41,9 @@ module.exports = {
     const configuration = context.options[0] || {};
     const allowRequiredDefaults = configuration.allowRequiredDefaults || false;
     const propWrapperFunctions = new Set(context.settings.propWrapperFunctions || []);
+    // Used to track the type annotations in scope.
+    // Necessary because babel's scopes do not track type annotations.
+    let stack = null;
 
     /**
      * Try to resolve the node passed in to a variable in the current scope. If the node passed in is not
@@ -62,6 +65,22 @@ module.exports = {
       return node;
     }
 
+    /**
+     * Helper for accessing the current scope in the stack.
+     * @param {string} key The name of the identifier to access. If omitted, returns the full scope.
+     * @param {ASTNode} value If provided sets the new value for the identifier.
+     * @returns {Object|ASTNode} Either the whole scope or the ASTNode associated with the given identifier.
+     */
+    function typeScope(key, value) {
+      if (arguments.length === 0) {
+        return stack[stack.length - 1];
+      } else if (arguments.length === 1) {
+        return stack[stack.length - 1][key];
+      }
+      stack[stack.length - 1][key] = value;
+      return value;
+    }
+
     /**
      * Tries to find the definition of a GenericTypeAnnotation in the current scope.
      * @param  {ASTNode}      node The node GenericTypeAnnotation node to resolve.
@@ -72,7 +91,7 @@ module.exports = {
         return null;
       }
 
-      return variableUtil.findVariableByName(context, node.id.name);
+      return variableUtil.findVariableByName(context, node.id.name) || typeScope(node.id.name);
     }
 
     function resolveUnionTypeAnnotation(node) {
@@ -92,7 +111,7 @@ module.exports = {
      * @returns {Object[]}        Array of PropType object representations, to be consumed by `addPropTypesToComponent`.
      */
     function getPropTypesFromObjectExpression(objectExpression) {
-      const props = objectExpression.properties.filter(property => property.type !== 'ExperimentalSpreadProperty');
+      const props = objectExpression.properties.filter(property => property.type !== 'ExperimentalSpreadProperty' && property.type !== 'SpreadElement');
 
       return props.map(property => ({
         name: property.key.name,
@@ -190,7 +209,7 @@ module.exports = {
      *                                     from this ObjectExpression can't be resolved.
      */
     function getDefaultPropsFromObjectExpression(objectExpression) {
-      const hasSpread = objectExpression.properties.find(property => property.type === 'ExperimentalSpreadProperty');
+      const hasSpread = objectExpression.properties.find(property => property.type === 'ExperimentalSpreadProperty' || property.type === 'SpreadElement');
 
       if (hasSpread) {
         return 'unresolved';
@@ -524,7 +543,7 @@ module.exports = {
 
         // Search for the proptypes declaration
         node.properties.forEach(property => {
-          if (property.type === 'ExperimentalSpreadProperty') {
+          if (property.type === 'ExperimentalSpreadProperty' || property.type === 'SpreadElement') {
             return;
           }
 
@@ -551,12 +570,29 @@ module.exports = {
         });
       },
 
+      TypeAlias: function(node) {
+        typeScope(node.id.name, node.right);
+      },
+
+      Program: function() {
+        stack = [{}];
+      },
+
+      BlockStatement: function () {
+        stack.push(Object.create(typeScope()));
+      },
+
+      'BlockStatement:exit': function () {
+        stack.pop();
+      },
+
       // Check for type annotations in stateless components
       FunctionDeclaration: handleStatelessComponent,
       ArrowFunctionExpression: handleStatelessComponent,
       FunctionExpression: handleStatelessComponent,
 
       'Program:exit': function() {
+        stack = null;
         const list = components.list();
 
         for (const component in list) {

lib/rules/destructuring-assignment.js

@@ -78,7 +78,8 @@ module.exports = {
       // this.props.Aprop || this.context.aProp || this.state.aState
       const isPropUsed = (
         node.object.type === 'MemberExpression' && node.object.object.type === 'ThisExpression' &&
-        (node.object.property.name === 'props' || node.object.property.name === 'context' || node.object.property.name === 'state')
+        (node.object.property.name === 'props' || node.object.property.name === 'context' || node.object.property.name === 'state') &&
+        !isAssignmentToProp(node)
       );
 
       if (isPropUsed && configuration === 'always') {

lib/rules/jsx-child-element-spacing.js

@@ -79,7 +79,7 @@ module.exports = {
           if (
             (lastChild || nextChild) &&
             (!lastChild || isInlineElement(lastChild)) &&
-            (child && child.type === 'Literal') &&
+            (child && (child.type === 'Literal' || child.type === 'JSXText')) &&
             (!nextChild || isInlineElement(nextChild)) &&
             true
           ) {

lib/rules/jsx-curly-brace-presence.js

@@ -250,6 +250,12 @@ module.exports = {
         if (shouldCheckForMissingCurly(node.parent, userConfig)) {
           reportMissingCurly(node);
         }
+      },
+
+      JSXText: node => {
+        if (shouldCheckForMissingCurly(node.parent, userConfig)) {
+          reportMissingCurly(node);
+        }
       }
     };
   }

lib/rules/jsx-indent.js

@@ -214,7 +214,7 @@ module.exports = {
         // Use the parent in a list or an array
         if (prevToken.type === 'JSXText' || prevToken.type === 'Punctuator' && prevToken.value === ',') {
           prevToken = sourceCode.getNodeByRangeIndex(prevToken.range[0]);
-          prevToken = prevToken.type === 'Literal' ? prevToken.parent : prevToken;
+          prevToken = prevToken.type === 'Literal' || prevToken.type === 'JSXText' ? prevToken.parent : prevToken;
         // Use the first non-punctuator token in a conditional expression
         } else if (prevToken.type === 'Punctuator' && prevToken.value === ':') {
           do {

lib/rules/jsx-no-literals.js

@@ -77,6 +77,12 @@ module.exports = {
         }
       },
 
+      JSXText: function(node) {
+        if (getValidation(node)) {
+          reportLiteralNode(node);
+        }
+      },
+
       TemplateLiteral: function(node) {
         const parent = getParentIgnoringBinaryExpressions(node);
         if (isNoStrings && parent.type === 'JSXExpressionContainer') {

lib/rules/jsx-one-expression-per-line.js

@@ -54,7 +54,7 @@ module.exports = {
           let countNewLinesBeforeContent = 0;
           let countNewLinesAfterContent = 0;
 
-          if (child.type === 'Literal') {
+          if (child.type === 'Literal' || child.type === 'JSXText') {
             if (/^\s*$/.test(child.raw)) {
               return;
             }
@@ -110,14 +110,14 @@ module.exports = {
             }
 
             function spaceBetweenPrev () {
-              return (prevChild.type === 'Literal' && / $/.test(prevChild.raw)) ||
-                (child.type === 'Literal' && /^ /.test(child.raw)) ||
+              return ((prevChild.type === 'Literal' || prevChild.type === 'JSXText') && / $/.test(prevChild.raw)) ||
+                ((child.type === 'Literal' || child.type === 'JSXText') && /^ /.test(child.raw)) ||
                 sourceCode.isSpaceBetweenTokens(prevChild, child);
             }
 
             function spaceBetweenNext () {
-              return (nextChild.type === 'Literal' && /^ /.test(nextChild.raw)) ||
-                (child.type === 'Literal' && / $/.test(child.raw)) ||
+              return ((nextChild.type === 'Literal' || nextChild.type === 'JSXText') && /^ /.test(nextChild.raw)) ||
+                ((child.type === 'Literal' || child.type === 'JSXText') && / $/.test(child.raw)) ||
                 sourceCode.isSpaceBetweenTokens(child, nextChild);
             }
 

lib/rules/jsx-sort-props.js

@@ -107,19 +107,30 @@ const generateFixerFunction = (node, context, reservedList) => {
 
   return function(fixer) {
     const fixers = [];
+    let source = sourceCode.getText();
 
     // Replace each unsorted attribute with the sorted one.
     sortableAttributeGroups.forEach((sortableGroup, ii) => {
       sortableGroup.forEach((attr, jj) => {
         const sortedAttr = sortedAttributeGroups[ii][jj];
         const sortedAttrText = sourceCode.getText(sortedAttr);
-        fixers.push(
-          fixer.replaceTextRange([attr.range[0], attr.range[1]], sortedAttrText)
-        );
+        fixers.push({
+          range: [attr.range[0], attr.range[1]],
+          text: sortedAttrText
+        });
       });
     });
 
-    return fixers;
+    fixers.sort((a, b) => a.range[0] < b.range[0]);
+
+    const rangeStart = fixers[fixers.length - 1].range[0];
+    const rangeEnd = fixers[0].range[1];
+
+    fixers.forEach(fix => {
+      source = `${source.substr(0, fix.range[0])}${fix.text}${source.substr(fix.range[1])}`;
+    });
+
+    return fixer.replaceTextRange([rangeStart, rangeEnd], source.substr(rangeStart, rangeEnd - rangeStart));
   };
 };
 

lib/rules/no-danger-with-children.js

@@ -36,7 +36,7 @@ module.exports = {
       return node.properties.find(prop => {
         if (prop.type === 'Property') {
           return prop.key.name === propName;
-        } else if (prop.type === 'ExperimentalSpreadProperty') {
+        } else if (prop.type === 'ExperimentalSpreadProperty' || prop.type === 'SpreadElement') {
           const variable = findSpreadVariable(prop.argument.name);
           if (variable && variable.defs.length && variable.defs[0].node.init) {
             if (seenProps.indexOf(prop.argument.name) > -1) {
@@ -74,7 +74,7 @@ module.exports = {
      * @returns {Boolean} True if node is a line break, false if not
      */
     function isLineBreak(node) {
-      const isLiteral = node.type === 'Literal';
+      const isLiteral = node.type === 'Literal' || node.type === 'JSXText';
       const isMultiline = node.loc.start.line !== node.loc.end.line;
       const isWhiteSpaces = /^\s*$/.test(node.value);
 

lib/rules/no-typos.js

@@ -45,7 +45,7 @@ module.exports = {
     let propTypesPackageName = null;
     let reactPackageName = null;
 
-    function checkValidPropTypeQualfier(node) {
+    function checkValidPropTypeQualifier(node) {
       if (node.name !== 'isRequired') {
         context.report({
           node: node,
@@ -101,14 +101,14 @@ module.exports = {
           isPropTypesPackage(node.object.object)
         ) { // PropTypes.myProp.isRequired
           checkValidPropType(node.object.property);
-          checkValidPropTypeQualfier(node.property);
+          checkValidPropTypeQualifier(node.property);
         } else if (
           isPropTypesPackage(node.object) &&
           node.property.name !== 'isRequired'
         ) { // PropTypes.myProp
           checkValidPropType(node.property);
         } else if (node.object.type === 'CallExpression') {
-          checkValidPropTypeQualfier(node.property);
+          checkValidPropTypeQualifier(node.property);
           checkValidCallExpression(node.object);
         }
       } else if (node.type === 'CallExpression') {
@@ -126,8 +126,7 @@ module.exports = {
 
     function reportErrorIfClassPropertyCasingTypo(node, propertyName) {
       if (propertyName === 'propTypes' || propertyName === 'contextTypes' || propertyName === 'childContextTypes') {
-        const propsNode = node && node.parent && node.parent.type === 'AssignmentExpression' && node.parent.right;
-        checkValidPropObject(propsNode);
+        checkValidPropObject(node);
       }
       STATIC_CLASS_PROPERTIES.forEach(CLASS_PROP => {
         if (propertyName && CLASS_PROP.toLowerCase() === propertyName.toLowerCase() && CLASS_PROP !== propertyName) {
@@ -176,7 +175,7 @@ module.exports = {
 
         const tokens = context.getFirstTokens(node, 2);
         const propertyName = tokens[1].value;
-        reportErrorIfClassPropertyCasingTypo(node, propertyName);
+        reportErrorIfClassPropertyCasingTypo(node.value, propertyName);
       },
 
       MemberExpression: function(node) {
@@ -193,9 +192,10 @@ module.exports = {
 
         if (
           relatedComponent &&
-          (utils.isES6Component(relatedComponent.node) || utils.isReturningJSX(relatedComponent.node))
+          (utils.isES6Component(relatedComponent.node) || utils.isReturningJSX(relatedComponent.node)) &&
+          (node.parent && node.parent.type === 'AssignmentExpression' && node.parent.right)
         ) {
-          reportErrorIfClassPropertyCasingTypo(node, propertyName);
+          reportErrorIfClassPropertyCasingTypo(node.parent.right, propertyName);
         }
       },