feat: Implement fixation in array style rules

gajus · Sep 29, 2017 · 4a6f03d · 4a6f03d
1 parent afd4210
commit 4a6f03d
Show file tree

Hide file tree

Showing 8 changed files with 88 additions and 26 deletions.
diff --git a/.README/rules/array-style-complex-type.md b/.README/rules/array-style-complex-type.md
@@ -1,5 +1,7 @@
 ### `array-style-complex-type`
 
+_The `--fix` option on the command line automatically fixes problems reported by this rule._
+
 Enforces a particular style for array type annotations for complex types. Type is considered complex in these cases:
 
 * [Maybe type](https://flow.org/en/docs/types/maybe/)

diff --git a/.README/rules/array-style-simple-type.md b/.README/rules/array-style-simple-type.md
@@ -1,5 +1,7 @@
 ### `array-style-simple-type`
 
+_The `--fix` option on the command line automatically fixes problems reported by this rule._
+
 Enforces a particular style for array type annotations for complex types. Type is considered simple in these cases:
 
 * Primitive types

diff --git a/src/rules/arrayStyle/index.js b/src/rules/arrayStyle/index.js
@@ -1,4 +1,5 @@
 import isSimpleType from './isSimpleType';
+import needWrap from './needWrap';
 
 const schema = [
   {
@@ -7,20 +8,41 @@ const schema = [
   }
 ];
 
+const fixShorthand = (context, node) => {
+  return (fixer) => {
+    const rawElementType = context.getSourceCode().getText(node.elementType);
+
+    return fixer.replaceText(node, 'Array<' + rawElementType + '>');
+  };
+};
+
+const fixVerbose = (context, node) => {
+  return (fixer) => {
+    const elementTypeNode = node.typeParameters.params[0];
+    const rawElementType = context.getSourceCode().getText(elementTypeNode);
+
+    if (needWrap(elementTypeNode)) {
+      return fixer.replaceText(node, '(' + rawElementType + ')[]');
+    } else {
+      return fixer.replaceText(node, rawElementType + '[]');
+    }
+  };
+};
+
 export default (defaultConfig, shorthandHandler, verboseHandler) => {
   const create = (context) => {
     const verbose = (context.options[0] || defaultConfig) === 'verbose';
 
     return {
       // shorthand
       ArrayTypeAnnotation (node) {
-        shorthandHandler(isSimpleType(node.elementType), verbose, context, node);
+        shorthandHandler(isSimpleType(node.elementType), verbose, context, node, fixShorthand(context, node));
       },
       // verbose
       GenericTypeAnnotation (node) {
         if (node.id.name === 'Array') {
           if (node.typeParameters.params.length === 1) {
-            verboseHandler(isSimpleType(node.typeParameters.params[0]), verbose, context, node);
+            verboseHandler(isSimpleType(node.typeParameters.params[0]), verbose, context, node, fixVerbose(context, node));
           }
         }
       }

diff --git a/src/rules/arrayStyle/needWrap.js b/src/rules/arrayStyle/needWrap.js
@@ -0,0 +1,7 @@
+import isSimpleType from './isSimpleType';
+
+const complexTypesWithoutWrap = ['TupleTypeAnnotation', 'ObjectTypeAnnotation'];
+
+export default (node) => {
+  return !isSimpleType(node) && complexTypesWithoutWrap.indexOf(node.type) === -1;
+};
diff --git a/src/rules/arrayStyleComplexType.js b/src/rules/arrayStyleComplexType.js
@@ -1,17 +1,19 @@
 import makeArrayStyleRule from './arrayStyle';
 
-const shorthandHandler = (isSimpleType, verbose, context, node) => {
+const shorthandHandler = (isSimpleType, verbose, context, node, fix) => {
   if (!isSimpleType && verbose) {
     context.report({
+      fix,
       message: 'Use "Array<ComplexType>", not "ComplexType[]"',
       node
     });
   }
 };
 
-const verboseHandler = (isSimpleType, verbose, context, node) => {
+const verboseHandler = (isSimpleType, verbose, context, node, fix) => {
   if (!isSimpleType && !verbose) {
     context.report({
+      fix,
       message: 'Use "ComplexType[]", not "Array<ComplexType>"',
       node
     });

diff --git a/src/rules/arrayStyleSimpleType.js b/src/rules/arrayStyleSimpleType.js
@@ -1,17 +1,19 @@
 import makeArrayStyleRule from './arrayStyle';
 
-const shorthandHandler = (isSimpleType, verbose, context, node) => {
+const shorthandHandler = (isSimpleType, verbose, context, node, fix) => {
   if (isSimpleType && verbose) {
     context.report({
+      fix,
       message: 'Use "Array<SimpleType>", not "SimpleType[]"',
       node
     });
   }
 };
 
-const verboseHandler = (isSimpleType, verbose, context, node) => {
+const verboseHandler = (isSimpleType, verbose, context, node, fix) => {
   if (isSimpleType && !verbose) {
     context.report({
+      fix,
       message: 'Use "SimpleType[]", not "Array<SimpleType>"',
       node
     });

diff --git a/tests/rules/assertions/arrayStyleComplexType.js b/tests/rules/assertions/arrayStyleComplexType.js
@@ -2,37 +2,51 @@ export default {
   invalid: [
     {
       code: 'type X = (?string)[]',
-      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}]
+      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}],
+      output: 'type X = Array<?string>'
     },
     {
       code: 'type X = (?string)[]',
       errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}],
-      options: ['verbose']
+      options: ['verbose'],
+      output: 'type X = Array<?string>'
     },
     {
       code: 'type X = Array<?string>',
       errors: [{message: 'Use "ComplexType[]", not "Array<ComplexType>"'}],
-      options: ['shorthand']
+      options: ['shorthand'],
+      output: 'type X = (?string)[]'
+    },
+    {
+      code: 'type X = Array<{foo: string}>',
+      errors: [{message: 'Use "ComplexType[]", not "Array<ComplexType>"'}],
+      options: ['shorthand'],
+      output: 'type X = {foo: string}[]'
     },
     {
       code: 'type X = (string | number)[]',
-      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}]
+      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}],
+      output: 'type X = Array<string | number>'
     },
     {
       code: 'type X = (string & number)[]',
-      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}]
+      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}],
+      output: 'type X = Array<string & number>'
     },
     {
       code: 'type X = [string, number][]',
-      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}]
+      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}],
+      output: 'type X = Array<[string, number]>'
     },
     {
-      code: 'type X = ({foo: string})[]',
-      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}]
+      code: 'type X = {foo: string}[]',
+      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}],
+      output: 'type X = Array<{foo: string}>'
     },
     {
       code: 'type X = (string => number)[]',
-      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}]
+      errors: [{message: 'Use "Array<ComplexType>", not "ComplexType[]"'}],
+      output: 'type X = Array<string => number>'
     }
   ],
   misconfigured: [

diff --git a/tests/rules/assertions/arrayStyleSimpleType.js b/tests/rules/assertions/arrayStyleSimpleType.js
@@ -2,49 +2,60 @@ export default {
   invalid: [
     {
       code: 'type X = Array<string>',
-      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}]
+      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}],
+      output: 'type X = string[]'
     },
     {
       code: 'type X = string[]',
       errors: [{message: 'Use "Array<SimpleType>", not "SimpleType[]"'}],
-      options: ['verbose']
+      options: ['verbose'],
+      output: 'type X = Array<string>'
     },
     {
       code: 'type X = Array<string>',
       errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}],
-      options: ['shorthand']
+      options: ['shorthand'],
+      output: 'type X = string[]'
     },
     {
       code: 'type X = Array<Date>',
-      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}]
+      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}],
+      output: 'type X = Date[]'
     },
     {
       code: 'type X = Array<Promise<string>>',
-      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}]
+      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}],
+      output: 'type X = Promise<string>[]'
     },
     {
       code: 'type X = Array<$Keys<{ foo: string }>>',
-      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}]
+      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}],
+      output: 'type X = $Keys<{ foo: string }>[]'
     },
     {
       code: 'type X = Array<any>',
-      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}]
+      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}],
+      output: 'type X = any[]'
     },
     {
       code: 'type X = Array<mixed>',
-      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}]
+      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}],
+      output: 'type X = mixed[]'
     },
     {
       code: 'type X = Array<void>',
-      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}]
+      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}],
+      output: 'type X = void[]'
     },
     {
       code: 'type X = Array<null>',
-      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}]
+      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}],
+      output: 'type X = null[]'
     },
     {
       code: 'type X = Array<string[]>',
-      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}]
+      errors: [{message: 'Use "SimpleType[]", not "Array<SimpleType>"'}],
+      output: 'type X = string[][]'
     }
   ],
   misconfigured: [