@tuomashatakka/eslint-config 2.6.2 → 3.1.0

package/plugins/whitespaced/rules/class-property-grouping.mjs

@@ -0,0 +1,370 @@
+/**
+ * @fileoverview ESLint rule to enforce grouping of class properties
+ * @author tuomashatakka
+ */
+
+'use strict'
+
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce grouping of class properties",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          groups: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                types: {
+                  type: "array",
+                  items: { type: "string" },
+                },
+                matches: {
+                  type: "array",
+                  items: { type: "string" },
+                },
+                order: { type: "integer", minimum: 0 },
+              },
+              required: ["name", "order"],
+              additionalProperties: false,
+            },
+            default: [
+              {
+                name: "static-properties",
+                types: ["ClassProperty"],
+                matches: ["static"],
+                order: 0,
+              },
+              {
+                name: "static-methods",
+                types: ["MethodDefinition"],
+                matches: ["static"],
+                order: 1,
+              },
+              {
+                name: "instance-properties",
+                types: ["ClassProperty"],
+                matches: [],
+                order: 2,
+              },
+              {
+                name: "constructor",
+                types: ["MethodDefinition"],
+                matches: ["constructor"],
+                order: 3,
+              },
+              {
+                name: "instance-methods",
+                types: ["MethodDefinition"],
+                matches: [],
+                order: 4,
+              },
+            ],
+          },
+          paddingBetweenGroups: {
+            type: "integer",
+            minimum: 0,
+            default: 1,
+          },
+          enforceAlphabeticalSorting: {
+            type: "boolean",
+            default: false,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      wrongGroupOrder:
+        "Class member '{{member}}' should be in group '{{expectedGroup}}' ({{expectedGroupOrder}}) but is in group '{{actualGroup}}' ({{actualGroupOrder}}).",
+      wrongAlphabeticalOrder:
+        "Class members in the same group should be ordered alphabetically. '{{memberA}}' should come before '{{memberB}}'.",
+      incorrectPaddingBetweenGroups:
+        "Expected {{expected}} empty {{lineText}} between class member groups, but found {{actual}}."
+    },
+  },
+  create(context) {
+    const sourceCode = context.getSourceCode();
+    const options = context.options[0] || {};
+
+    // Get configured options with defaults
+    const groups = options.groups || [
+      {
+        name: "static-properties",
+        types: ["ClassProperty"],
+        matches: ["static"],
+        order: 0,
+      },
+      {
+        name: "static-methods",
+        types: ["MethodDefinition"],
+        matches: ["static"],
+        order: 1,
+      },
+      {
+        name: "instance-properties",
+        types: ["ClassProperty"],
+        matches: [],
+        order: 2,
+      },
+      {
+        name: "constructor",
+        types: ["MethodDefinition"],
+        matches: ["constructor"],
+        order: 3,
+      },
+      {
+        name: "instance-methods",
+        types: ["MethodDefinition"],
+        matches: [],
+        order: 4,
+      },
+    ];
+
+    const paddingBetweenGroups = options.paddingBetweenGroups !== undefined ? options.paddingBetweenGroups : 1;
+    const enforceAlphabeticalSorting = options.enforceAlphabeticalSorting !== undefined ? options.enforceAlphabeticalSorting : false;
+
+    /**
+     * Determine which group a class member belongs to
+     * @param {ASTNode} node The class member node
+     * @returns {Object|null} The group object or null if not matched
+     */
+    function getMemberGroup(node) {
+      let nodeType = node.type;
+
+      // Normalize TypeScript property types to match ESLint's ClassProperty
+      if (nodeType === "PropertyDefinition" || nodeType === "TSPropertyDefinition") {
+        nodeType = "ClassProperty";
+      }
+
+      // For each group, check if the node matches the group criteria
+      for (const group of groups) {
+        // Skip if the node type doesn't match any in the group's types
+        if (!group.types.includes(nodeType)) {
+          continue;
+        }
+
+        // For MethodDefinition nodes
+        if (nodeType === "MethodDefinition") {
+          const isConstructor = node.kind === "constructor";
+          const isStatic = !!node.static;
+
+          // If this is a constructor and the group is for constructors
+          if (isConstructor && group.matches.includes("constructor")) {
+            return group;
+          }
+
+          // If this is a static method and the group is for static methods
+          if (isStatic && group.matches.includes("static")) {
+            return group;
+          }
+
+          // If this is not static and not a constructor and the group is for regular instance methods
+          if (!isStatic && !isConstructor && !group.matches.includes("static") && !group.matches.includes("constructor")) {
+            return group;
+          }
+        }
+
+        // For ClassProperty nodes
+        if (nodeType === "ClassProperty") {
+          const isStatic = !!node.static;
+
+          // If this is a static property and the group is for static properties
+          if (isStatic && group.matches.includes("static")) {
+            return group;
+          }
+
+          // If this is not static and the group is for regular instance properties
+          if (!isStatic && !group.matches.includes("static")) {
+            return group;
+          }
+        }
+      }
+
+      return null;
+    }
+
+    /**
+     * Get the member name for a node
+     * @param {ASTNode} node The class member node
+     * @returns {string} The member name
+     */
+    function getMemberName(node) {
+      if (node.type === "MethodDefinition" || node.type === "ClassProperty" ||
+          node.type === "PropertyDefinition" || node.type === "TSPropertyDefinition") {
+        if (node.key.type === "Identifier") {
+          return node.key.name;
+        } else if (node.key.type === "Literal") {
+          return String(node.key.value);
+        }
+      }
+      return "";
+    }
+
+    /**
+     * Check if members are in correct group order
+     * @param {Array<Object>} members Array of { node, group } objects
+     */
+    function checkGroupOrder(members) {
+      let lastGroupOrder = -1;
+      let lastGroup = null;
+
+      for (let i = 0; i < members.length; i++) {
+        const { node, group } = members[i];
+        if (!group) continue;
+
+        const currentGroupOrder = group.order;
+        const memberName = getMemberName(node);
+
+        // Check if group order is correct
+        if (currentGroupOrder < lastGroupOrder) {
+          const lastGroupInfo = lastGroup;
+
+          context.report({
+            node,
+            messageId: "wrongGroupOrder",
+            data: {
+              member: memberName,
+              expectedGroup: lastGroupInfo.name,
+              expectedGroupOrder: lastGroupInfo.order,
+              actualGroup: group.name,
+              actualGroupOrder: group.order,
+            },
+          });
+        }
+
+        lastGroupOrder = currentGroupOrder;
+        lastGroup = group;
+      }
+    }
+
+    /**
+     * Check if members within the same group are sorted alphabetically
+     * @param {Array<Object>} members Array of { node, group } objects
+     */
+    function checkAlphabeticalOrder(members) {
+      if (!enforceAlphabeticalSorting) return;
+
+      // Group members by their group
+      const groupedMembers = {};
+
+      for (const member of members) {
+        if (!member.group) continue;
+
+        const groupName = member.group.name;
+        if (!groupedMembers[groupName]) {
+          groupedMembers[groupName] = [];
+        }
+
+        groupedMembers[groupName].push(member);
+      }
+
+      // Check each group for alphabetical ordering
+      for (const groupName in groupedMembers) {
+        const groupMembers = groupedMembers[groupName];
+
+        for (let i = 1; i < groupMembers.length; i++) {
+          const prevNode = groupMembers[i - 1].node;
+          const currentNode = groupMembers[i].node;
+
+          const prevName = getMemberName(prevNode);
+          const currentName = getMemberName(currentNode);
+
+          if (prevName && currentName && prevName.localeCompare(currentName) > 0) {
+            context.report({
+              node: currentNode,
+              messageId: "wrongAlphabeticalOrder",
+              data: {
+                memberA: currentName,
+                memberB: prevName,
+              },
+            });
+          }
+        }
+      }
+    }
+
+    /**
+     * Check padding between different groups
+     * @param {Array<Object>} members Array of { node, group } objects
+     */
+    function checkGroupPadding(members) {
+      if (paddingBetweenGroups <= 0 || members.length < 2) return;
+
+      let currentGroup = null;
+
+      for (let i = 1; i < members.length; i++) {
+        const prevMember = members[i - 1];
+        const currentMember = members[i];
+
+        // Skip if either member doesn't have a valid group
+        if (!prevMember.group || !currentMember.group) continue;
+
+        // If the groups are different, check padding
+        if (prevMember.group.name !== currentMember.group.name) {
+          const prevNode = prevMember.node;
+          const currentNode = currentMember.node;
+
+          const prevNodeEnd = prevNode.loc.end.line;
+          const currentNodeStart = currentNode.loc.start.line;
+          const blankLines = currentNodeStart - prevNodeEnd - 1;
+
+          if (blankLines !== paddingBetweenGroups) {
+            context.report({
+              node: currentNode,
+              messageId: "incorrectPaddingBetweenGroups",
+              data: {
+                expected: paddingBetweenGroups,
+                actual: blankLines,
+                lineText: paddingBetweenGroups === 1 ? "line" : "lines",
+              },
+              fix(fixer) {
+                const endOfPrevNode = sourceCode.getLastToken(prevNode);
+                const startOfCurrentNode = sourceCode.getFirstToken(currentNode);
+                const range = [
+                  endOfPrevNode.range[1],
+                  startOfCurrentNode.range[0],
+                ];
+
+                // Create the desired padding
+                const newLines = "\n".repeat(paddingBetweenGroups + 1); // +1 for end of current line
+
+                return fixer.replaceTextRange(range, newLines);
+              },
+            });
+          }
+        }
+      }
+    }
+
+    return {
+      ClassBody(node) {
+        if (!node.body || node.body.length <= 1) {
+          return;
+        }
+
+        // Map each node to its group
+        const members = node.body.map(memberNode => ({
+          node: memberNode,
+          group: getMemberGroup(memberNode),
+        }));
+
+        // Run checks
+        checkGroupOrder(members);
+        checkAlphabeticalOrder(members);
+        checkGroupPadding(members);
+      },
+    };
+  },
+};

package/plugins/whitespaced/rules/consistent-line-spacing.mjs

@@ -0,0 +1,266 @@
+/**
+ * @fileoverview ESLint rule to enforce consistent line spacing before and after statements
+ * @author tuomashatakka
+ */
+
+export default {
+  meta: {
+    type: 'layout',
+    docs: {
+      description: 'Enforce consistent line spacing before and after statements',
+      category:    "Stylistic Issues",
+      recommended: false,
+    },
+    fixable: 'whitespace',
+    schema:  [{
+      type:       "object",
+      properties: {
+        beforeImports:      { type: 'integer', minimum: 0, default: 1 },
+        afterImports:       { type: 'integer', minimum: 0, default: 1 },
+        beforeExports:      { type: 'integer', minimum: 0, default: 1 },
+        afterExports:       { type: 'integer', minimum: 0, default: 1 },
+        beforeClass:        { type: 'integer', minimum: 0, default: 2 },
+        afterClass:         { type: 'integer', minimum: 0, default: 2 },
+        beforeFunction:     { type: 'integer', minimum: 0, default: 2 },
+        afterFunction:      { type: 'integer', minimum: 0, default: 2 },
+        beforeComment:      { type: 'integer', minimum: 0, default: 1 },
+        ignoreTopLevelCode: { type: 'boolean', default: false },
+        skipImportGroups:   { type: 'boolean', default: true },
+        docstringSpacing:   { type: 'integer', minimum: 0, default: 0 },
+      },
+      additionalProperties: false,
+    },],
+    messages: {
+      missingLinesBefore:      "Expected {{expected}} empty {{lineText}} before {{nodeType}}, but found {{actual}}.",
+      missingLinesAfter:       "Expected {{expected}} empty {{lineText}} after {{nodeType}}, but found {{actual}}.",
+      incorrectDocstringSpacing: "Expected {{expected}} empty {{lineText}} between docstring and {{nodeType}}, but found {{actual}}.",
+    },
+  },
+  create (context) {
+    const sourceCode                                                                                                     = context.sourceCode || context.getSourceCode()
+    const options                                                                                              = context.options[0] || {}
+
+    const beforeImports                                                                                                = options.beforeImports !== undefined ? options.beforeImports : 1
+    const afterImports                                                                                                 = options.afterImports !== undefined ? options.afterImports : 1
+    const beforeExports                                                                                                = options.beforeExports !== undefined ? options.beforeExports : 1
+    const afterExports                                                                                                 = options.afterExports !== undefined ? options.afterExports : 1
+    const beforeClass                                                                                                  = options.beforeClass !== undefined ? options.beforeClass : 2
+    const afterClass                                                                                                   = options.afterClass !== undefined ? options.afterClass : 2
+    const beforeFunction                                                                                               = options.beforeFunction !== undefined ? options.beforeFunction : 2
+    const afterFunction                                                                                                = options.afterFunction !== undefined ? options.afterFunction : 2
+    const beforeComment                                                                                                          = options.beforeComment !== undefined ? options.beforeComment : 1
+    const ignoreTopLevelCode                                                                                                     = options.ignoreTopLevelCode !== undefined ? options.ignoreTopLevelCode : false
+    const skipImportGroups                                                                                                       = options.skipImportGroups !== undefined ? options.skipImportGroups : true
+    const docstringSpacing                                                                                                       = options.docstringSpacing !== undefined ? options.docstringSpacing : 0
+
+
+    function isFirstInParent (node) {
+      const parent = node.parent
+      if (!parent || !parent.body || !parent.body.length)
+        return true
+      return parent.body[0] === node
+    }
+
+
+    function isLastInParent (node) {
+      const parent = node.parent
+      if (!parent || !parent.body || !parent.body.length)
+        return true
+      return parent.body[parent.body.length - 1] === node
+    }
+
+
+    function isTopLevel (node) {
+      return node.parent && node.parent.type === 'Program'
+    }
+
+
+    function isImport (node) {
+      return node.type === 'ImportDeclaration'
+    }
+
+
+    /**
+     * Returns the first token of the docstring immediately preceding `node`
+     * (no blank lines between docstring end and node start), or null.
+     *
+     * Detects two docstring forms:
+     *   • Block comment  /* ... *\/  on the line immediately before node
+     *   • One or more consecutive // line comments on the lines immediately before node
+     */
+    function getDocstringBefore (node) {
+      const prev = sourceCode.getTokenBefore(node, { includeComments: true })
+      if (!prev)
+        return null
+
+      // Block comment touching the node (0 blank lines between)
+      if (prev.type === 'Block' && node.loc.start.line <= prev.loc.end.line + 1)
+        return prev
+
+      // Chain of consecutive line comments touching the node
+      if (prev.type === 'Line' && node.loc.start.line <= prev.loc.end.line + 1) {
+        let first = prev
+        for (;;) {
+          const p = sourceCode.getTokenBefore(first, { includeComments: true })
+          if (!p || p.type !== 'Line' || first.loc.start.line > p.loc.end.line + 1)
+            break
+          first = p
+        }
+        return first
+      }
+
+      return null
+    }
+
+
+    /**
+     * Checks blank lines before `node` (or before its attached docstring).
+     *
+     * Key behaviour: if a docstring immediately precedes `node`, we measure
+     * `requiredLines` blank lines from the previous non-comment code token to
+     * the **start of the docstring**, not to the node keyword itself.
+     * This way `beforeFunction: 2` works correctly even when the function has
+     * a leading JSDoc / line-comment block.
+     */
+    function checkLinesBefore (node, requiredLines, nodeType) {
+      if (isFirstInParent(node) && ignoreTopLevelCode && isTopLevel(node))
+        return
+
+      const docstring     = getDocstringBefore(node)
+      const effectiveNode = docstring ?? node // measure TO this node's start
+
+      // Previous non-comment code token (before the docstring if present)
+      const prevCode = sourceCode.getTokenBefore(effectiveNode, {
+        includeComments: false,
+      })
+      if (!prevCode)
+        return
+
+      // Skip consecutive imports when skipImportGroups is on
+      if (skipImportGroups && isImport(node)) {
+        const prevNode = sourceCode.getNodeByRangeIndex(prevCode.range[0])
+        if (prevNode && isImport(prevNode))
+          return
+      }
+
+      const blankLines = effectiveNode.loc.start.line - prevCode.loc.end.line - 1
+
+      if (blankLines !== requiredLines)
+        context.report({
+          node:        effectiveNode,
+          messageId:   'missingLinesBefore',
+          data: {
+            expected: requiredLines,
+            actual:   blankLines,
+            nodeType,
+            lineText: requiredLines === 1 ? 'line' : 'lines',
+          },
+          fix(fixer) {
+            return fixer.replaceTextRange(
+              [ prevCode.range[1], effectiveNode.range[0] ],
+              '\n'.repeat(requiredLines + 1)
+            );
+          },
+        });
+
+      // Also enforce spacing between docstring end and node start
+      if (docstring) {
+        const blankBetween = node.loc.start.line - docstring.loc.end.line - 1
+        if (blankBetween !== docstringSpacing)
+          context.report({
+            node,
+            messageId: 'incorrectDocstringSpacing',
+            data: {
+              expected: docstringSpacing,
+              actual:   blankBetween,
+              nodeType,
+              lineText: docstringSpacing === 1 ? 'line' : 'lines',
+            },
+            fix(fixer) {
+              return fixer.replaceTextRange(
+                [ docstring.range[1], node.range[0] ],
+                '\n'.repeat(docstringSpacing + 1)
+              );
+            },
+          });
+      }
+    }
+
+
+    function checkLinesAfter (node, requiredLines, nodeType) {
+      if (isLastInParent(node) && (ignoreTopLevelCode && isTopLevel(node)))
+        return
+
+      const nextToken = sourceCode.getTokenAfter(node, {
+        includeComments: false,
+      })
+      const nextNode  = nextToken ? sourceCode.getNodeByRangeIndex(nextToken.range[0]) : null
+
+      if (skipImportGroups && isImport(node) && nextNode && isImport(nextNode))
+        return
+
+      const nextTokenWithComments = sourceCode.getTokenAfter(node, {
+        includeComments: true,
+      })
+      if (!nextTokenWithComments)
+        return
+
+      const blankLines = nextTokenWithComments.loc.start.line - node.loc.end.line - 1
+
+      if (blankLines !== requiredLines)
+        context.report({
+          node,
+          messageId: "missingLinesAfter",
+          data: {
+            expected: requiredLines,
+            actual: blankLines,
+            nodeType,
+            lineText: requiredLines === 1 ? "line" : "lines",
+          },
+          fix(fixer) {
+            const tokenAfter = sourceCode.getTokenAfter(node, { includeComments: true });
+            if (!tokenAfter) {
+              return null;
+            }
+
+            const range = [node.range[1], tokenAfter.range[0]];
+            const newLines = "\n".repeat(requiredLines + 1); // +1 because one newline is the end of the current line
+
+            return fixer.replaceTextRange(range, newLines);
+          },
+        });
+    }
+
+
+    return {
+      ImportDeclaration (node) {
+        checkLinesBefore(node, beforeImports, 'import declaration')
+        checkLinesAfter(node, afterImports, 'import declaration')
+      },
+      ExportNamedDeclaration (node) {
+        checkLinesBefore(node, beforeExports, 'export declaration')
+        checkLinesAfter(node, afterExports, 'export declaration')
+      },
+      ExportDefaultDeclaration (node) {
+        checkLinesBefore(node, beforeExports, 'export declaration')
+        checkLinesAfter(node, afterExports, 'export declaration')
+      },
+      ExportAllDeclaration (node) {
+        checkLinesBefore(node, beforeExports, 'export declaration')
+        checkLinesAfter(node, afterExports, 'export declaration')
+      },
+      ClassDeclaration (node) {
+        checkLinesBefore(node, beforeClass, 'class declaration')
+        checkLinesAfter(node, afterClass, 'class declaration')
+      },
+      FunctionDeclaration (node) {
+        checkLinesBefore(node, beforeFunction, 'function declaration')
+        checkLinesAfter(node, afterFunction, 'function declaration')
+      },
+      BlockComment (node) {
+        if (node.loc.start.column === 0)
+          checkLinesBefore(node, beforeComment, 'block comment')
+      },
+    }
+  },
+}