Merge pull request #451 from ljharb/eslint_5

[New] eslint ^5 support

Author: ljharb

.eslintrc

@@ -8,6 +8,7 @@
     "flowtype"
   ],
   rules: {
-    'no-template-curly-in-string': 'off'
+    'max-len': 'off',
+    'no-template-curly-in-string': 'off',
   }
 }

.travis.yml

@@ -11,6 +11,8 @@ cache:
   yarn: true
   directories:
     - node_modules
+before_script:
+  - if [ -n "${ESLINT-}" ]; then npm uninstall --no-save eslint-config-airbnb-base && npm install --no-save "eslint@${ESLINT}"; fi
 script:
   - if [ "${FLOW-}" = true ]; then npm run flow; fi
   - if [ "${LINT-}" = true ]; then npm run lint; fi
@@ -21,13 +23,22 @@ sudo: false
 env:
   global:
     - TEST=true
+  matrix:
+    - ESLINT=5
+    - ESLINT=4
+    - ESLINT=3
 matrix:
   fast_finish: true
   include:
     - node_js: "node"
       env: FLOW=true TEST=false
     - node_js: "node"
       env: LINT=true TEST=false
+  exclude:
+    - node_js: "5"
+      env: ESLINT=5
+    - node_js: "4"
+      env: ESLINT=5
   allow_failures:
     - node_js: "9"
     - node_js: "7"

__mocks__/genInteractives.js

@@ -140,12 +140,12 @@ const nonInteractiveRoles = roleNames
 
 export function genElementSymbol(openingElement: Object) {
   return (
-    openingElement.name.name +
-    (openingElement.attributes.length > 0
+    openingElement.name.name + (openingElement.attributes.length > 0
       ? `${openingElement.attributes
         .map(attr => `[${attr.name.name}="${attr.value.value}"]`)
         .join('')}`
-      : '')
+      : ''
+    )
   );
 }
 
@@ -156,15 +156,16 @@ export function genInteractiveElements() {
     if (bracketIndex > -1) {
       name = elementSymbol.slice(0, bracketIndex);
     }
-    const attributes = interactiveElementsMap[elementSymbol].map(({ prop, value }) =>
-      JSXAttributeMock(prop, value));
+    const attributes = interactiveElementsMap[elementSymbol].map(({ prop, value }) => JSXAttributeMock(prop, value));
     return JSXElementMock(name, attributes);
   });
 }
 
 export function genInteractiveRoleElements() {
-  return [...interactiveRoles, 'button article', 'fakerole button article'].map(value =>
-    JSXElementMock('div', [JSXAttributeMock('role', value)]));
+  return [...interactiveRoles, 'button article', 'fakerole button article'].map(value => JSXElementMock(
+    'div',
+    [JSXAttributeMock('role', value)],
+  ));
 }
 
 export function genNonInteractiveElements() {
@@ -174,15 +175,17 @@ export function genNonInteractiveElements() {
     if (bracketIndex > -1) {
       name = elementSymbol.slice(0, bracketIndex);
     }
-    const attributes = nonInteractiveElementsMap[elementSymbol].map(({ prop, value }) =>
-      JSXAttributeMock(prop, value));
+    const attributes = nonInteractiveElementsMap[elementSymbol].map(({ prop, value }) => JSXAttributeMock(prop, value));
     return JSXElementMock(name, attributes);
   });
 }
 
 export function genNonInteractiveRoleElements() {
-  return [...nonInteractiveRoles, 'article button', 'fakerole article button'].map(value =>
-    JSXElementMock('div', [JSXAttributeMock('role', value)]));
+  return [
+    ...nonInteractiveRoles,
+    'article button',
+    'fakerole article button',
+  ].map(value => JSXElementMock('div', [JSXAttributeMock('role', value)]));
 }
 
 export function genAbstractRoleElements() {
@@ -195,8 +198,7 @@ export function genNonAbstractRoleElements() {
 
 export function genIndeterminantInteractiveElements() {
   return Object.keys(indeterminantInteractiveElementsMap).map((name) => {
-    const attributes = indeterminantInteractiveElementsMap[name].map(({ prop, value }) =>
-      JSXAttributeMock(prop, value));
+    const attributes = indeterminantInteractiveElementsMap[name].map(({ prop, value }) => JSXAttributeMock(prop, value));
     return JSXElementMock(name, attributes);
   });
 }

__tests__/src/rules/anchor-is-valid-test.js

@@ -18,15 +18,11 @@ import rule from '../../../src/rules/anchor-is-valid';
 
 const ruleTester = new RuleTester();
 
-const preferButtonErrorMessage = 'Anchor used as a button. ' +
-  'Anchors are primarily expected to navigate. ' +
-  'Use the button element instead.';
+const preferButtonErrorMessage = 'Anchor used as a button. Anchors are primarily expected to navigate. Use the button element instead.';
 
-const noHrefErrorMessage = 'The href attribute is required on an anchor. ' +
-  'Provide a valid, navigable address as the href value.';
+const noHrefErrorMessage = 'The href attribute is required on an anchor. Provide a valid, navigable address as the href value.';
 
-const invalidHrefErrorMessage = 'The href attribute requires a valid address. ' +
-  'Provide a valid, navigable address as the href value.';
+const invalidHrefErrorMessage = 'The href attribute requires a valid address. Provide a valid, navigable address as the href value.';
 
 const preferButtonexpectedError = {
   message: preferButtonErrorMessage,

__tests__/src/rules/aria-activedescendant-has-tabindex-test.js

@@ -18,8 +18,7 @@ import rule from '../../../src/rules/aria-activedescendant-has-tabindex';
 const ruleTester = new RuleTester();
 
 const expectedError = {
-  message: 'An element that manages focus with `aria-activedescendant` ' +
-    'must be tabbable',
+  message: 'An element that manages focus with `aria-activedescendant` must be tabbable',
   type: 'JSXOpeningElement',
 };
 

__tests__/src/rules/aria-proptypes-test.js

@@ -11,7 +11,9 @@
 import { aria } from 'aria-query';
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
-import rule, { validityCheck } from '../../../src/rules/aria-proptypes';
+import rule from '../../../src/rules/aria-proptypes';
+
+const { validityCheck } = rule;
 
 // -----------------------------------------------------------------------------
 // Tests

__tests__/src/rules/click-events-have-key-events-test.js

@@ -18,8 +18,7 @@ import rule from '../../../src/rules/click-events-have-key-events';
 
 const ruleTester = new RuleTester();
 
-const errorMessage = 'Visible, non-interactive elements with click handlers' +
-' must have at least one keyboard listener.';
+const errorMessage = 'Visible, non-interactive elements with click handlers must have at least one keyboard listener.';
 
 const expectedError = {
   message: errorMessage,

__tests__/src/rules/img-redundant-alt-test.js

@@ -24,9 +24,7 @@ const array = [{
 const ruleTester = new RuleTester();
 
 const expectedError = {
-  message: 'Redundant alt attribute. Screen-readers already announce `img` tags as an image. ' +
-    'You don\'t need to use the words `image`, `photo,` or `picture` ' +
-    '(or any specified custom words) in the alt prop.',
+  message: 'Redundant alt attribute. Screen-readers already announce `img` tags as an image. You don’t need to use the words `image`, `photo,` or `picture` (or any specified custom words) in the alt prop.',
   type: 'JSXOpeningElement',
 };
 

__tests__/src/rules/interactive-supports-focus-test.js

@@ -35,16 +35,13 @@ function template(strings, ...keys) {
 const ruleName = 'interactive-supports-focus';
 const type = 'JSXOpeningElement';
 const codeTemplate = template`<${0} role="${1}" ${2}={() => void 0} />`;
-const tabindexTemplate =
-  template`<${0} role="${1}" ${2}={() => void 0} tabIndex="0" />`;
+const tabindexTemplate = template`<${0} role="${1}" ${2}={() => void 0} tabIndex="0" />`;
 const tabbableTemplate = template`Elements with the '${0}' interactive role must be tabbable.`;
 const focusableTemplate = template`Elements with the '${0}' interactive role must be focusable.`;
 
-const recommendedOptions =
-  (configs.recommended.rules[`jsx-a11y/${ruleName}`][1] || {});
+const recommendedOptions = configs.recommended.rules[`jsx-a11y/${ruleName}`][1] || {};
 
-const strictOptions =
-  (configs.strict.rules[`jsx-a11y/${ruleName}`][1] || {});
+const strictOptions = configs.strict.rules[`jsx-a11y/${ruleName}`][1] || {};
 
 const alwaysValid = [
   { code: '<div />' },
@@ -170,25 +167,29 @@ const triggeringHandlers = [
   ...eventHandlersByType.keyboard,
 ];
 
-const passReducer = (roles, handlers, messageTemplate) =>
-  staticElements.reduce((elementAcc, element) =>
-    elementAcc.concat(roles.reduce((roleAcc, role) =>
-      roleAcc.concat(handlers
-        .map(handler => ({
-          code: messageTemplate(element, role, handler),
-        }))), [])), []);
-
-const failReducer = (roles, handlers, messageTemplate) =>
-  staticElements.reduce((elementAcc, element) =>
-    elementAcc.concat(roles.reduce((roleAcc, role) =>
-      roleAcc.concat(handlers
-        .map(handler => ({
-          code: codeTemplate(element, role, handler),
-          errors: [{
-            type,
-            message: messageTemplate(role),
-          }],
-        }))), [])), []);
+const passReducer = (roles, handlers, messageTemplate) => (
+  staticElements.reduce((elementAcc, element) => (
+    elementAcc.concat(roles.reduce((roleAcc, role) => (
+      roleAcc.concat(handlers.map(handler => ({
+        code: messageTemplate(element, role, handler),
+      })))
+    ), []))
+  ), [])
+);
+
+const failReducer = (roles, handlers, messageTemplate) => (
+  staticElements.reduce((elementAcc, element) => (
+    elementAcc.concat(roles.reduce((roleAcc, role) => (
+      roleAcc.concat(handlers.map(handler => ({
+        code: codeTemplate(element, role, handler),
+        errors: [{
+          type,
+          message: messageTemplate(role),
+        }],
+      })))
+    ), []))
+  ), [])
+);
 
 ruleTester.run(`${ruleName}:recommended`, rule, {
   valid: [

__tests__/src/rules/no-access-key-test.js

@@ -19,9 +19,7 @@ import rule from '../../../src/rules/no-access-key';
 const ruleTester = new RuleTester();
 
 const expectedError = {
-  message: 'No access key attribute allowed. Inconsistencies ' +
-  'between keyboard shortcuts and keyboard comments used by screenreader ' +
-  'and keyboard only users create a11y complications.',
+  message: 'No access key attribute allowed. Inconsistencies between keyboard shortcuts and keyboard comments used by screenreader and keyboard only users create a11y complications.',
   type: 'JSXOpeningElement',
 };