feat: add a basic implementation

Author: Mendes Hugo

.eslintrc.json

@@ -295,7 +295,8 @@
 		"@cspell/spellchecker": [
 			"warn",
 			{
-				"autoFix": true
+				"autoFix": true,
+				"customWordListFile": "./tools/cspell/words.txt"
 			}
 		],
 		"@shopify/no-useless-computed-properties": "error",

src/lib/decorator/get-decorator-name.spec.ts

@@ -0,0 +1,73 @@
+import { parse } from "@typescript-eslint/parser";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+
+import { getDecoratorName } from "./get-decorator-name";
+
+describe("getDecoratorName", () => {
+	const getADecoratorNode = (decorator: string) => {
+		const [classA] = parse(`@${decorator} class A {}`).body;
+
+		if (classA.type === AST_NODE_TYPES.ClassDeclaration) {
+			return classA.decorators![0];
+		}
+
+		throw new Error("Decorator is wrongly set");
+	};
+
+	const names = ["A", "B", "c", "d", "myDecorator", "YOUR_decorator", "GET", "Post"];
+
+	it("should return the name of simple decorators", () => {
+		for (const name of names) {
+			const decorator = getADecoratorNode(name);
+			expect(getDecoratorName(decorator)).toBe(name);
+		}
+	});
+
+	describe("Decorator factories", () => {
+		it("should return the name of an empty factory", () => {
+			for (const name of names) {
+				const decorator = getADecoratorNode(`${name}()`);
+				expect(getDecoratorName(decorator)).toBe(name);
+			}
+		});
+
+		it("should return the name of a factory with parameters", () => {
+			for (const name of names) {
+				const decorator = getADecoratorNode(`${name}("parameter", 123, {})`);
+				expect(getDecoratorName(decorator)).toBe(name);
+			}
+		});
+	});
+
+	describe("factory of factory of ... of decorator factories", () => {
+		it("should return the name of an empty factory of ... factory", () => {
+			for (const name of names) {
+				const decorator = getADecoratorNode(`${name}()()`);
+				expect(getDecoratorName(decorator)).toBe(name);
+			}
+		});
+
+		it("should return the name of a factory of ... factory with parameters", () => {
+			for (const name of names) {
+				const decorator = getADecoratorNode(`${name}("parameter")(123)({})`);
+				expect(getDecoratorName(decorator)).toBe(name);
+			}
+		});
+	});
+
+	it("should fail when it is not a decorator", () => {
+		expect(() =>
+			getDecoratorName({
+				expression: {
+					elements: [],
+					loc: { end: { column: 0, line: 0 }, start: { column: 0, line: 0 } },
+					range: [0, 0],
+					type: AST_NODE_TYPES.ArrayPattern
+				},
+				loc: { end: { column: 0, line: 0 }, start: { column: 0, line: 0 } },
+				range: [0, 0],
+				type: AST_NODE_TYPES.Decorator
+			})
+		).toThrow();
+	});
+});

src/lib/decorator/get-decorator-name.ts

@@ -0,0 +1,22 @@
+import { LeftHandSideExpression } from "@typescript-eslint/types/dist/generated/ast-spec";
+import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
+
+/**
+ * @param decorator the decorator node to get the name from
+ * @returns the name of the given decorator
+ */
+export function getDecoratorName(decorator: TSESTree.Decorator): string {
+	const getName = (expression: LeftHandSideExpression): string => {
+		switch (expression.type) {
+			case AST_NODE_TYPES.CallExpression:
+				return getName(expression.callee);
+
+			case AST_NODE_TYPES.Identifier:
+				return expression.name;
+		}
+
+		throw new Error("Not a valid decorator.");
+	};
+
+	return getName(decorator.expression);
+}

src/lib/decorator/index.ts

@@ -0,0 +1 @@
+export * from "./get-decorator-name";

src/lib/sort-rule/index.ts

@@ -1,3 +1,4 @@
 export * from "./sort-rule";
+export * from "./sort-rule.listener";
 export * from "./sort-rule.message-ids";
 export * from "./sort-rule.options";

src/lib/sort-rule/sort-rule.listener.ts

@@ -0,0 +1,99 @@
+import { TSESTree, TSESLint } from "@typescript-eslint/utils";
+
+import { SortRuleMessageIds } from "./sort-rule.message-ids";
+import { SortRuleOptions } from "./sort-rule.options";
+import { getDecoratorName } from "../decorator";
+
+/**
+ * The rule listener for sorting the decorators
+ *
+ * @param context the context the rule is listening
+ * @param decorators the decorators to test (and fix)
+ * @param options the rule options
+ */
+export function sortRuleListener(
+	context: TSESLint.RuleContext<SortRuleMessageIds, [SortRuleOptions]>,
+	decorators: TSESTree.Decorator[],
+	options: SortRuleOptions
+) {
+	const { autoFix, caseSensitive, direction } = options;
+
+	// Get the name of a decorator
+	const getName = (decorator: TSESTree.Decorator) => {
+		const name = getDecoratorName(decorator);
+		return caseSensitive ? name : name.toLowerCase();
+	};
+
+	const compare = (a: string, b: string) => {
+		const [a1, b1] = direction === "desc" ? [b, a] : [a, b];
+
+		// `localCompare` messes with the upperCase
+		if (a1 === b1) {
+			return 0;
+		}
+
+		return a1 < b1 ? -1 : 1;
+	};
+
+	const decoratorsWithName = decorators.map(decorator => ({
+		name: getName(decorator),
+		node: decorator
+	}));
+
+	const sortRule = (decorators: typeof decoratorsWithName) => {
+		if (decorators.length <= 1) {
+			return;
+		}
+
+		const [{ name: currentName, node: currentNode }, ...remaining] = decorators;
+
+		for (const { name } of remaining) {
+			if (compare(currentName, name) > 0) {
+				context.report({
+					fix: autoFix
+						? fixer => {
+								const sourceCode = context.getSourceCode();
+								const sourceText = sourceCode.getText();
+
+								const sorted = decorators
+									.slice()
+									.sort(({ name: a }, { name: b }) => compare(a, b));
+
+								const newText = sorted.map(({ node: child }, i) => {
+									const textAfter =
+										i === sorted.length - 1
+											? // If it's the last item, there's no text after to append.
+											  ""
+											: // Otherwise, we need to grab the text after the original node.
+											  sourceText.slice(
+													decorators[i].node.range[1], // End index of the current node .
+													decorators[i + 1].node.range[0] // Start index of the next node.
+											  );
+
+									return sourceCode.getText(child) + textAfter;
+								});
+
+								return fixer.replaceTextRange(
+									[
+										decorators[0].node.range[0],
+										decorators[decorators.length - 1].node.range[1]
+									],
+									newText.join("")
+								);
+						  }
+						: undefined,
+					messageId: "incorrect-order",
+					node: currentNode
+				});
+
+				return;
+			}
+		}
+
+		if (autoFix) {
+			sortRule(decorators.slice(1));
+		}
+	};
+
+	sortRule(decoratorsWithName);
+}

src/rules/sort-on-accessors.ts

@@ -1,10 +1,58 @@
-import { createSortRule } from "../lib/sort-rule";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { TSESTree } from "@typescript-eslint/utils";
+
+import { createSortRule, sortRuleListener } from "../lib/sort-rule";
 
 export const SORT_ON_ACCESSORS_NAME = "sort-on-accessors";
 
 export const sortOnAccessors = createSortRule({
-	create: () => {
-		throw new Error("Not implemented yet");
+	create: (context, [optionsWithDefault]) => {
+		const { autoFix } = optionsWithDefault;
+
+		const getDecorated = (node: TSESTree.Decorator) => {
+			const { parent } = node;
+
+			// Only get the decorated node, if it is an accessor
+			if (parent?.type === AST_NODE_TYPES.MethodDefinition && parent.kind === "get") {
+				return parent;
+			}
+
+			return false;
+		};
+
+		return autoFix
+			? {
+					// TODO: a selector for the accessors only
+					Decorator(node) {
+						const parent = getDecorated(node);
+						if (!parent) {
+							return;
+						}
+
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- the current node comes from there
+						const decorators = parent.decorators!;
+
+						// Run the listener only when on the first node
+						if (decorators[0] === node) {
+							sortRuleListener(context, decorators, optionsWithDefault);
+						}
+					}
+			  }
+			: {
+					Decorator(node) {
+						const parent = getDecorated(node);
+						if (!parent) {
+							return;
+						}
+
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- the current node comes from there
+						const decorators = parent.decorators!;
+
+						// Get only the decorators after the current one
+						const nodeIndex = decorators.findIndex(decorator => decorator === node);
+						sortRuleListener(context, decorators.slice(nodeIndex), optionsWithDefault);
+					}
+			  };
 	},
 	meta: {
 		docs: {

src/rules/sort-on-classes.ts

@@ -1,10 +1,36 @@
-import { createSortRule } from "../lib/sort-rule";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+
+import { createSortRule, sortRuleListener } from "../lib/sort-rule";
 
 export const SORT_ON_CLASSES_NAME = "sort-on-classes";
 
 export const sortOnClasses = createSortRule({
-	create: () => {
-		throw new Error("Not implemented yet");
+	create: (context, [optionsWithDefault]) => {
+		const { autoFix } = optionsWithDefault;
+
+		return autoFix
+			? {
+					ClassDeclaration({ decorators }) {
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- always defined on class declarations
+						sortRuleListener(context, decorators!, optionsWithDefault);
+					}
+			  }
+			: {
+					Decorator(node) {
+						const { parent } = node;
+						if (parent?.type !== AST_NODE_TYPES.ClassDeclaration) {
+							// Only for classes decorators
+							return;
+						}
+
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- the current node comes from there
+						const decorators = parent.decorators!;
+
+						// Get only the decorators after the current one
+						const nodeIndex = decorators.findIndex(decorator => decorator === node);
+						sortRuleListener(context, decorators.slice(nodeIndex), optionsWithDefault);
+					}
+			  };
 	},
 	meta: {
 		docs: {

src/rules/sort-on-methods.ts

@@ -1,10 +1,36 @@
-import { createSortRule } from "../lib/sort-rule";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+
+import { createSortRule, sortRuleListener } from "../lib/sort-rule";
 
 export const SORT_ON_METHODS_NAME = "sort-on-methods";
 
 export const sortOnMethods = createSortRule({
-	create: () => {
-		throw new Error("Not implemented yet");
+	create: (context, [optionsWithDefault]) => {
+		const { autoFix } = optionsWithDefault;
+
+		return autoFix
+			? {
+					MethodDefinition({ decorators }) {
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- always defined on method definitions
+						sortRuleListener(context, decorators!, optionsWithDefault);
+					}
+			  }
+			: {
+					Decorator(node) {
+						const { parent } = node;
+						if (parent?.type !== AST_NODE_TYPES.MethodDefinition) {
+							// Only for methods decorators
+							return;
+						}
+
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- the current node comes from there
+						const decorators = parent.decorators!;
+
+						// Get only the decorators after the current one
+						const nodeIndex = decorators.findIndex(decorator => decorator === node);
+						sortRuleListener(context, decorators.slice(nodeIndex), optionsWithDefault);
+					}
+			  };
 	},
 	meta: {
 		docs: {