feat: Sort import specifiers (#4)

* Improve test

* Rename files

* Add spec and file

* Start import specifier rule

* default import

* Comment tests

Author: mskelton

src/__fixtures__/import-specifiers/invalid-comments.ts

@@ -0,0 +1,19 @@
+export const input = `
+import {
+  c,
+  // b
+  b,
+  // a
+  a
+} from 'a'
+`
+
+export const output = `
+import {
+  // a
+  a,
+  // b
+  b,
+  c
+} from 'a'
+`

src/__fixtures__/import-specifiers/valid-comments.ts

@@ -0,0 +1,9 @@
+export const input = `
+import {
+  // a
+  a,
+  // b
+  b,
+  c
+} from 'a'
+`

src/__fixtures__/destructured-properties/invalid-comments.ts renamed to src/__fixtures__/object-patterns/invalid-comments.ts

@@ -1,9 +1,9 @@
 export const input = `
 let {
+  // c
+  c,
   // b
   b,
-  c,
-  // a
   a,
   // rest
   ...rest
@@ -12,10 +12,10 @@ let {
 
 export const output = `
 let {
-  // a
   a,
   // b
   b,
+  // c
   c,
   // rest
   ...rest

src/__fixtures__/destructured-properties/valid-comments.ts renamed to src/__fixtures__/object-patterns/valid-comments.ts

@@ -0,0 +1,117 @@
+import { RuleTester } from "eslint"
+import rule from "../rules/sort-import-specifiers"
+import { invalidFixture, validFixture } from "./utils"
+
+const messages = rule.meta!.messages! as Record<
+  "unsorted" | "unsortedSpecifiers",
+  string
+>
+
+const valid = (input: string) => ({ code: `import ${input} from 'a'` })
+
+const invalid = (input: string, output: string, ...errors: string[]) => ({
+  code: `import ${input} from 'a'`,
+  errors,
+  output: `import ${output} from 'a'`,
+})
+
+const error = (a: string, b: string) =>
+  messages.unsorted.replace("{{a}}", a).replace("{{b}}", b)
+
+const ruleTester = new RuleTester({
+  parserOptions: {
+    ecmaVersion: 2018,
+    sourceType: "module",
+  },
+})
+
+ruleTester.run("sort/imported-variables", rule, {
+  valid: [
+    // Basic
+    valid("{}"),
+    valid("{a}"),
+    valid("{a, b, c}"),
+    valid("{_, a, b}"),
+    valid("{p,q,r,s,t,u,v,w,x,y,z}"),
+
+    // Case insensitive
+    valid("{a, B, c, D}"),
+    valid("{_, A, b}"),
+
+    // Default and namespace imports
+    valid("React"),
+    valid("* as React"),
+    valid("React, {a, b}"),
+
+    //
+    valid("{a as b, b as a}"),
+
+    // Comments
+    validFixture("import-specifiers/valid-comments"),
+  ],
+  invalid: [
+    // Basic
+    invalid(
+      "{c, a, b}",
+      "{a, b, c}",
+      messages.unsortedSpecifiers,
+      error("a", "c")
+    ),
+    invalid(
+      "{b, a, _}",
+      "{_, a, b}",
+      messages.unsortedSpecifiers,
+      error("a", "b"),
+      error("_", "a")
+    ),
+
+    // Case insensitive
+    invalid(
+      "{b, A, _}",
+      "{_, A, b}",
+      messages.unsortedSpecifiers,
+      error("A", "b"),
+      error("_", "A")
+    ),
+    invalid(
+      "{D, a, c, B}",
+      "{a, B, c, D}",
+      messages.unsortedSpecifiers,
+      error("a", "D"),
+      error("B", "c")
+    ),
+
+    // Default and namespace imports
+    invalid(
+      "React, {c, a, b}",
+      "React, {a, b, c}",
+      messages.unsortedSpecifiers,
+      error("a", "c")
+    ),
+
+    // All properties are sorted with a single sort
+    invalid(
+      "{z,y,x,w,v,u,t,s,r,q,p}",
+      "{p,q,r,s,t,u,v,w,x,y,z}",
+      messages.unsortedSpecifiers,
+      error("y", "z"),
+      error("x", "y"),
+      error("w", "x"),
+      error("v", "w"),
+      error("u", "v"),
+      error("t", "u"),
+      error("s", "t"),
+      error("r", "s"),
+      error("q", "r"),
+      error("p", "q")
+    ),
+
+    // Comments
+    invalidFixture(
+      "import-specifiers/invalid-comments",
+      messages.unsortedSpecifiers,
+      error("b", "c"),
+      error("a", "b")
+    ),
+  ],
+})

src/__tests__/sort-import-specifiers.spec.ts

@@ -1,5 +1,5 @@
 import { RuleTester } from "eslint"
-import rule from "../rules/sort-destructured-properties"
+import rule from "../rules/sort-object-patterns"
 import { invalidFixture, validFixture } from "./utils"
 
 const messages = rule.meta!.messages! as Record<
@@ -46,7 +46,7 @@ ruleTester.run("sort/destructured-properties", rule, {
     valid("{...rest}"),
 
     // Comments
-    validFixture("destructured-properties/valid-comments"),
+    validFixture("object-patterns/valid-comments"),
   ],
   invalid: [
     // Basic
@@ -107,9 +107,10 @@ ruleTester.run("sort/destructured-properties", rule, {
 
     // Comments
     invalidFixture(
-      "destructured-properties/invalid-comments",
+      "object-patterns/invalid-comments",
       messages.unsortedPattern,
-      error("a", "c")
+      error("b", "c"),
+      error("a", "b")
     ),
   ],
 })

src/__tests__/sort-destructured-properties.spec.ts renamed to src/__tests__/sort-object-patterns.spec.ts

@@ -1,20 +1,23 @@
 import sortImports from "./rules/sort-imports"
+import sortImportSpecifiers from "./rules/sort-imports"
+import sortObjectPatterns from "./rules/sort-object-patterns"
 import sortObjectProperties from "./rules/sort-object-properties"
-import sortObjectPatterns from "./rules/sort-destructured-properties"
 
 module.exports = {
   configs: {
     recommended: {
       plugins: ["sort"],
       rules: {
         "sort/imports": "warn",
+        "sort/imported-variables": "warn",
         "sort/destructured-properties": "warn",
         "sort/object-properties": "warn",
       },
     },
   },
   rules: {
     "sort/imports": sortImports,
+    "sort/imported-variables": sortImportSpecifiers,
     "sort/destructured-properties": sortObjectPatterns,
     "sort/object-properties": sortObjectProperties,
   },

src/index.ts

@@ -0,0 +1,110 @@
+import { Rule } from "eslint"
+import {
+  ImportDeclaration,
+  ImportSpecifier,
+  ImportDefaultSpecifier,
+  ImportNamespaceSpecifier,
+} from "estree"
+import {
+  getSorter,
+  getTextWithComments,
+  getNodeGroupRange,
+  getTextBetweenNodes,
+} from "./utils"
+
+type Specifier =
+  | ImportSpecifier
+  | ImportDefaultSpecifier
+  | ImportNamespaceSpecifier
+
+function getNodeText(node: ImportSpecifier) {
+  return node.imported.name
+}
+
+const isImportSpecifier = (node: Specifier): node is ImportSpecifier =>
+  node.type === "ImportSpecifier"
+
+const getNodeSortValue = (node: Specifier) =>
+  isImportSpecifier(node) ? getNodeText(node).toLowerCase() : -Infinity
+
+function autofix(context: Rule.RuleContext, node: ImportDeclaration) {
+  const source = context.getSourceCode()
+
+  context.report({
+    node,
+    messageId: "unsortedSpecifiers",
+    fix(fixer) {
+      const text = node.specifiers
+        .slice()
+        .sort(getSorter(getNodeSortValue))
+        .reduce((acc, currentNode, index) => {
+          return (
+            acc +
+            getTextWithComments(source, currentNode) +
+            getTextBetweenNodes(
+              source,
+              node.specifiers[index],
+              node.specifiers[index + 1]
+            )
+          )
+        }, "")
+
+      return fixer.replaceTextRange(
+        getNodeGroupRange(source, node.specifiers),
+        text
+      )
+    },
+  })
+}
+
+function sort(node: ImportDeclaration, context: Rule.RuleContext) {
+  const specifiers = node.specifiers.filter(isImportSpecifier)
+
+  // If there are less than two specifiers, there is nothing to sort.
+  if (specifiers.length < 2) {
+    return
+  }
+
+  let lastUnsortedNode: ImportSpecifier | null = null
+
+  specifiers.reduce((previousNode, currentNode) => {
+    if (getNodeSortValue(currentNode) < getNodeSortValue(previousNode)) {
+      context.report({
+        node: currentNode,
+        messageId: "unsorted",
+        data: {
+          a: getNodeText(currentNode),
+          b: getNodeText(previousNode),
+        },
+      })
+
+      lastUnsortedNode = currentNode
+    }
+
+    return currentNode
+  })
+
+  // If we fixed each set of unsorted nodes, it would require multiple runs to
+  // fix if there are multiple unsorted nodes. Instead, we add a add special
+  // error with an autofix rule which will sort all specifiers at once.
+  if (lastUnsortedNode) {
+    autofix(context, node)
+  }
+}
+
+export default {
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        sort(node as ImportDeclaration, context)
+      },
+    }
+  },
+  meta: {
+    fixable: "code",
+    messages: {
+      unsorted: "Expected '{{a}}' to be before '{{b}}'.",
+      unsortedSpecifiers: "Expected imported variables to be sorted.",
+    },
+  },
+} as Rule.RuleModule

src/rules/sort-import-specifiers.ts

@@ -109,7 +109,6 @@ export default {
     messages: {
       unsorted: "Expected '{{a}}' to be before '{{b}}'.",
       unsortedPattern: "Expected destructured properties to be sorted.",
-      invalidRest: "Expected rest element to be the last property.",
     },
   },
 } as Rule.RuleModule

src/rules/sort-destructured-properties.ts renamed to src/rules/sort-object-patterns.ts

@@ -1,18 +1,18 @@
 import { AST, SourceCode } from "eslint"
-import { AssignmentProperty, Comment, Node, RestElement } from "estree"
+import { Comment, Node } from "estree"
 
-type Property = AssignmentProperty | RestElement
-
-export function getSorter(sortFn: (node: Property) => string | number) {
-  return (a: Property, b: Property) => {
+export function getSorter<T extends Node>(
+  sortFn: (node: T) => string | number
+) {
+  return (a: T, b: T) => {
     const aText = sortFn(a)
     const bText = sortFn(b)
 
     if (aText === Infinity) return 1
     if (aText === -Infinity) return -1
 
-    if (aText < bText) return -1
     if (aText > bText) return 1
+    if (aText < bText) return -1
 
     return 0
   }