Just use Prettier defaults

.eslintrc

@@ -1,15 +1,5 @@
 {
-  "extends": [
-    "airbnb-base",
-    "plugin:flowtype/recommended",
-    "prettier"
-  ],
+  "extends": ["plugin:flowtype/recommended", "plugin:prettier/recommended"],
   "parser": "babel-eslint",
-  "plugins": [
-    "flowtype"
-  ],
-  "rules": {
-    "max-len": "off",
-    "no-template-curly-in-string": "off"
-  }
+  "plugins": ["flowtype"]
 }

.prettierrc

@@ -0,0 +1,3 @@
+{
+  "singleQuote": true
+}

__tests__/__util__/parserOptionsMapper.js

@@ -1,23 +1,23 @@
 const defaultParserOptions = {
   ecmaVersion: 6,
   ecmaFeatures: {
-    jsx: true,
-  },
+    jsx: true
+  }
 };
 
 export default function parserOptionsMapper({
   code,
   errors,
   options = [],
-  parserOptions = {},
+  parserOptions = {}
 }) {
   return {
     code,
     errors,
     options,
     parserOptions: {
       ...defaultParserOptions,
-      ...parserOptions,
-    },
+      ...parserOptions
+    }
   };
 }

__tests__/__util__/ruleOptionsMapperFactory.js

@@ -9,18 +9,25 @@ type ESLintTestRunnerTestCase = {
   parserOptions: ?Array<mixed>
 };
 
-export default function ruleOptionsMapperFactory(ruleOptions: Array<mixed> = []) {
+export default function ruleOptionsMapperFactory(
+  ruleOptions: Array<mixed> = []
+) {
   // eslint-disable-next-line
   return ({ code, errors, options, parserOptions }: ESLintTestRunnerTestCase): ESLintTestRunnerTestCase => {
     return {
       code,
       errors,
       // Flatten the array of objects in an array of one object.
-      options: (options || []).concat(ruleOptions).reduce((acc, item) => [{
-        ...acc[0],
-        ...item,
-      }], [{}]),
-      parserOptions,
+      options: (options || []).concat(ruleOptions).reduce(
+        (acc, item) => [
+          {
+            ...acc[0],
+            ...item
+          }
+        ],
+        [{}]
+      ),
+      parserOptions
     };
   };
 }

__tests__/index-test.js

@@ -6,11 +6,12 @@ import fs from 'fs';
 import path from 'path';
 import plugin from '../src';
 
-const rules = fs.readdirSync(path.resolve(__dirname, '../src/rules/'))
+const rules = fs
+  .readdirSync(path.resolve(__dirname, '../src/rules/'))
   .map(f => path.basename(f, '.js'));
 
 describe('all rule files should be exported by the plugin', () => {
-  rules.forEach((ruleName) => {
+  rules.forEach(ruleName => {
     it(`should export ${ruleName}`, () => {
       assert.equal(
         plugin.rules[ruleName],
@@ -21,13 +22,13 @@ describe('all rule files should be exported by the plugin', () => {
 });
 
 describe('configurations', () => {
-  it('should export a \'recommended\' configuration', () => {
+  it("should export a 'recommended' configuration", () => {
     assert(plugin.configs.recommended);
   });
 });
 
 describe('schemas', () => {
-  rules.forEach((ruleName) => {
+  rules.forEach(ruleName => {
     it(`${ruleName} should export a schema with type object`, () => {
       const rule = require(path.join('../src/rules', ruleName)); // eslint-disable-line
       const schema = rule.meta && rule.meta.schema && rule.meta.schema[0];

__tests__/src/rules/accessibility-label-test.js

@@ -21,50 +21,50 @@ const ruleTester = new RuleTester();
 const expectedError = {
   message:
     'If an element adopts the accessible={true} prop, it (or at least one of its children) must also set the accessibilityLabel prop',
-  type: 'JSXOpeningElement',
+  type: 'JSXOpeningElement'
 };
 
 ruleTester.run('accessibility-label', rule, {
   valid: [
     {
-      code: '<View accessible={true} accessibilityLabel={"Tap me!"}/>',
+      code: '<View accessible={true} accessibilityLabel={"Tap me!"}/>'
     },
     {
-      code: '<View accessible={true} accessibilityLabel="Tap me!"/>',
+      code: '<View accessible={true} accessibilityLabel="Tap me!"/>'
     },
     {
       code:
-        '<View accessible={true}><Text accessibilityLabel="Tap me!">Button</Text></View>',
+        '<View accessible={true}><Text accessibilityLabel="Tap me!">Button</Text></View>'
     },
     {
       code: `
         <View accessible={true} accessibilityLabel="Tap me!">
           <View>
             <Text acessibilityLabel={"Tap me!"}>Button</Text>
           </View>
-        </View>`,
-    },
+        </View>`
+    }
   ].map(parserOptionsMapper),
   invalid: [
     {
       code: '<View accessible={true} />',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<View accessible={true} accessibilityLabel/>',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<View accessible={true} accessibilityLabel=""/>',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<View accessible={true} accessibilityLabel={""}/>',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<View accessible={true} />',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: `
@@ -73,7 +73,7 @@ ruleTester.run('accessibility-label', rule, {
           <Text>Button</Text>
         </View>
       </View>`,
-      errors: [expectedError],
-    },
-  ].map(parserOptionsMapper),
+      errors: [expectedError]
+    }
+  ].map(parserOptionsMapper)
 });

__tests__/src/rules/has-accessibility-props-test.js

@@ -20,7 +20,7 @@ const ruleTester = new RuleTester();
 
 const expectedError = touchable => ({
   message: `<${touchable}> must have the accessibilityRole prop, or both accessibilityComponentType and accessibilityTraits`,
-  type: 'JSXOpeningElement',
+  type: 'JSXOpeningElement'
 });
 
 ruleTester.run('has-accessibility-props', rule, {
@@ -30,86 +30,85 @@ ruleTester.run('has-accessibility-props', rule, {
     { code: '<TouchableOpacitys />;' },
     {
       code:
-        '<Touchable accessibilityTraits="none" accessibilityComponentType="none"/>;',
+        '<Touchable accessibilityTraits="none" accessibilityComponentType="none"/>;'
     },
     {
       code:
-        '<TouchableOpacity accessibilityTraits="none" accessibilityComponentType="none"/>;',
+        '<TouchableOpacity accessibilityTraits="none" accessibilityComponentType="none"/>;'
     },
     {
       code:
-        '<TouchableHighlight accessibilityTraits="none" accessibilityComponentType="none"/>;',
+        '<TouchableHighlight accessibilityTraits="none" accessibilityComponentType="none"/>;'
     },
     {
       code:
-        '<TouchableWithoutFeedback accessibilityTraits="none" accessibilityComponentType="none"/>;',
+        '<TouchableWithoutFeedback accessibilityTraits="none" accessibilityComponentType="none"/>;'
     },
     {
       code:
-        '<TouchableNativeFeedback accessibilityTraits="none" accessibilityComponentType="none"/>;',
+        '<TouchableNativeFeedback accessibilityTraits="none" accessibilityComponentType="none"/>;'
     },
     {
       code:
-        '<div><TouchableNativeFeedback accessibilityTraits="none" accessibilityComponentType="none"/></div>;',
+        '<div><TouchableNativeFeedback accessibilityTraits="none" accessibilityComponentType="none"/></div>;'
     },
     {
-      code:
-        '<div><TouchableNativeFeedback accessibilityRole="none"/></div>;',
-    },
+      code: '<div><TouchableNativeFeedback accessibilityRole="none"/></div>;'
+    }
   ].map(parserOptionsMapper),
   invalid: [
     { code: '<Touchable />;', errors: [expectedError('Touchable')] },
     {
       code: '<TouchableOpacity />;',
-      errors: [expectedError('TouchableOpacity')],
+      errors: [expectedError('TouchableOpacity')]
     },
     {
       code: '<TouchableOpacity accessibilityTraits="none"/>;',
-      errors: [expectedError('TouchableOpacity')],
+      errors: [expectedError('TouchableOpacity')]
     },
     {
       code: '<TouchableOpacity accessibilityComponentType="none"/>;',
-      errors: [expectedError('TouchableOpacity')],
+      errors: [expectedError('TouchableOpacity')]
     },
     {
       code: '<TouchableHighlight />;',
-      errors: [expectedError('TouchableHighlight')],
+      errors: [expectedError('TouchableHighlight')]
     },
     {
       code: '<TouchableHighlight accessibilityComponentType="none"/>;',
-      errors: [expectedError('TouchableHighlight')],
+      errors: [expectedError('TouchableHighlight')]
     },
     {
       code: '<TouchableHighlight accessibilityComponentType="none"/>;',
-      errors: [expectedError('TouchableHighlight')],
+      errors: [expectedError('TouchableHighlight')]
     },
     {
       code: '<TouchableWithoutFeedback />;',
-      errors: [expectedError('TouchableWithoutFeedback')],
+      errors: [expectedError('TouchableWithoutFeedback')]
     },
     {
       code: '<TouchableWithoutFeedback accessibilityComponentType="none"/>;',
-      errors: [expectedError('TouchableWithoutFeedback')],
+      errors: [expectedError('TouchableWithoutFeedback')]
     },
     {
       code: '<TouchableWithoutFeedback accessibilityComponentType="none"/>;',
-      errors: [expectedError('TouchableWithoutFeedback')],
+      errors: [expectedError('TouchableWithoutFeedback')]
     },
     {
       code: '<TouchableNativeFeedback />;',
-      errors: [expectedError('TouchableNativeFeedback')],
+      errors: [expectedError('TouchableNativeFeedback')]
     },
     {
       code: '<TouchableNativeFeedback accessibilityComponentType="none"/>;',
-      errors: [expectedError('TouchableNativeFeedback')],
+      errors: [expectedError('TouchableNativeFeedback')]
     },
     {
       code: '<TouchableNativeFeedback accessibilityComponentType="none"/>;',
-      errors: [expectedError('TouchableNativeFeedback')],
+      errors: [expectedError('TouchableNativeFeedback')]
     },
     {
       code: '<div><TouchableOpacity /></div>;',
-      errors: [expectedError('TouchableOpacity')],
-    },
-  ].map(parserOptionsMapper),
+      errors: [expectedError('TouchableOpacity')]
+    }
+  ].map(parserOptionsMapper)
 });

__tests__/src/rules/has-valid-accessibility-component-type-test.js

@@ -20,7 +20,7 @@ const ruleTester = new RuleTester();
 
 const expectedError = {
   message: 'accessibilityComponentType must be one of defined values',
-  type: 'JSXAttribute',
+  type: 'JSXAttribute'
 };
 
 ruleTester.run('has-valid-accessibility-component-type', rule, {
@@ -29,29 +29,29 @@ ruleTester.run('has-valid-accessibility-component-type', rule, {
     { code: '<TouchableOpacity accessibilityComponentType="button" />;' },
     {
       code:
-        '<TouchableOpacity accessibilityComponentType="radiobutton_checked" />;',
+        '<TouchableOpacity accessibilityComponentType="radiobutton_checked" />;'
     },
     {
       code:
-        '<TouchableOpacity accessibilityComponentType="radiobutton_unchecked" />;',
-    },
+        '<TouchableOpacity accessibilityComponentType="radiobutton_unchecked" />;'
+    }
   ].map(parserOptionsMapper),
   invalid: [
     {
       code: '<TouchableOpacity accessibilityComponentType="duck" />',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<TouchableOpacity accessibilityComponentType="non" />;',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<TouchableOpacity accessibilityComponentType="nones" />;',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<TouchableOpacity accessibilityComponentType="primary-button" />',
-      errors: [expectedError],
-    },
-  ].map(parserOptionsMapper),
+      errors: [expectedError]
+    }
+  ].map(parserOptionsMapper)
 });

__tests__/src/rules/has-valid-accessibility-live-region-test.js

@@ -21,35 +21,35 @@ const ruleTester = new RuleTester();
 
 const expectedError = {
   message: 'accessibilityLiveRegion must be one of defined values',
-  type: 'JSXAttribute',
+  type: 'JSXAttribute'
 };
 
 ruleTester.run('has-valid-accessibility-live-region', rule, {
   valid: [
     { code: '<Text accessibilityLiveRegion="none">Click Me</Text>' },
     { code: '<Text accessibilityLiveRegion="polite">Click Me</Text>' },
-    { code: '<Text accessibilityLiveRegion="assertive">Click Me</Text>' },
+    { code: '<Text accessibilityLiveRegion="assertive">Click Me</Text>' }
   ].map(parserOptionsMapper),
   invalid: [
     {
       code: '<Text accessibilityLiveRegion >Click Me</Text>',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<Text accessibilityLiveRegion="">Click Me</Text>',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<Text accessibilityLiveRegion="non">Click Me</Text>',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<Text accessibilityLiveRegion="nones">Click Me</Text>',
-      errors: [expectedError],
+      errors: [expectedError]
     },
     {
       code: '<Text accessibilityLiveRegion="rude">Click Me</Text>',
-      errors: [expectedError],
-    },
-  ].map(parserOptionsMapper),
+      errors: [expectedError]
+    }
+  ].map(parserOptionsMapper)
 });