@tuomashatakka/eslint-config 2.6.2 → 3.1.0

package/plugins/whitespaced/rules/aligned-assignments.mjs

@@ -0,0 +1,385 @@
+/**
+ * @fileoverview ESLint rule to enforce vertically aligned assignments
+ * @author tuomashatakka
+ */
+
+export default {
+  meta: {
+    type: 'layout',
+    docs: {
+      description: 'Enforce vertically aligned assignments in declaration blocks',
+      category:    'Stylistic Issues',
+      recommended: false,
+    },
+    fixable: 'whitespace',
+    schema:  [{
+      type:       'object',
+      properties: {
+        alignComments:                 { type: 'boolean', default: false },
+        alignLiterals:                 { type: 'boolean', default: false },
+        blockSize:                     { type: 'integer', minimum: 2, default: 2 },
+        ignoreAdjacent:                { type: 'boolean', default: true },
+        ignoreIfAssignmentsNotInBlock: { type: 'boolean', default: true },
+        alignTypes:                    { type: 'boolean', default: false },
+        ignoreTypesMismatch:           { type: 'boolean', default: true },
+        alignMemberAssignments:        { type: 'boolean', default: true },
+      },
+      additionalProperties: false,
+    }],
+    messages: {
+      misalignedAssignment: 'Assignment operators should be vertically aligned within blocks.',
+      misalignedTypes:      'Type declarations should be vertically aligned within blocks.',
+    },
+  },
+  create (context) {
+    const sourceCode = context.sourceCode || context.getSourceCode()
+    const options    = context.options[0] || {}
+
+    const alignComments                 = options.alignComments !== undefined ? options.alignComments : false
+    const alignLiterals                 = options.alignLiterals !== undefined ? options.alignLiterals : false
+    const blockSize                     = options.blockSize !== undefined ? options.blockSize : 2
+    const ignoreAdjacent                = options.ignoreAdjacent !== undefined ? options.ignoreAdjacent : true
+    const ignoreIfAssignmentsNotInBlock = options.ignoreIfAssignmentsNotInBlock !== undefined ? options.ignoreIfAssignmentsNotInBlock : true
+    const alignTypes                    = options.alignTypes !== undefined ? options.alignTypes : false
+    const ignoreTypesMismatch           = options.ignoreTypesMismatch !== undefined ? options.ignoreTypesMismatch : true
+    const alignMemberAssignments        = options.alignMemberAssignments !== undefined ? options.alignMemberAssignments : true
+
+
+    function getEqualsColumn (declarator) {
+      const equalsToken = sourceCode.getTokenBefore(
+        declarator.init,
+        token => token.value === '='
+      )
+
+      return equalsToken ? equalsToken.loc.start.column : null
+    }
+
+
+    function getTypeColonColumn (declarator) {
+      if (declarator.id && declarator.id.typeAnnotation) {
+        const colonToken = sourceCode.getFirstToken(declarator.id.typeAnnotation)
+        return colonToken ? colonToken.loc.start.column : null
+      }
+      return null
+    }
+
+
+    function areNodesAdjacent (node1, node2) {
+      return node2.loc.start.line === node1.loc.end.line + 1
+    }
+
+
+    function haveSameKind (declarations) {
+      if (!declarations.length)
+        return true
+
+      const firstKind = declarations[0].parent.kind
+      return declarations.every(decl => decl.parent.kind === firstKind)
+    }
+
+
+    function allHaveTypes (declarations) {
+      return declarations.every(decl =>
+        decl.id && decl.id.typeAnnotation
+      )
+    }
+
+
+    function anyHaveTypes (declarations) {
+      return declarations.some(decl =>
+        decl.id && decl.id.typeAnnotation
+      )
+    }
+
+
+    function getMaxEqualsColumn (declarations) {
+      return Math.max(...declarations.map(getEqualsColumn))
+    }
+
+
+    function getMaxTypeColonColumn (declarations) {
+      const columns = declarations
+        .map(getTypeColonColumn)
+        .filter(column => column !== null)
+
+      return columns.length ? Math.max(...columns) : null
+    }
+
+
+function getFixedDeclaration (declarator, targetMaxEqualsColumn) {
+      const originalText = sourceCode.getText(declarator)
+      const idText = sourceCode.getText(declarator.id)
+      const initText = declarator.init ? sourceCode.getText(declarator.init) : ''
+
+      if (!initText)
+        return originalText
+
+      // Get the equals token
+      const equalsToken = sourceCode.getTokenBefore(
+        declarator.init,
+        token => token.value === '='
+      )
+
+      if (!equalsToken)
+        return originalText
+
+      const currentEqualsColumn = equalsToken.loc.start.column
+      const padding = targetMaxEqualsColumn - currentEqualsColumn
+
+      if (padding <= 0)
+        return originalText
+
+      // Build the fixed text: id + padding + '= ' + init
+      const result = idText + ' '.repeat(padding) + '= ' + initText
+
+      return result
+    }
+
+
+    function getIdLengthWithType (declarator) {
+      const idText = sourceCode.getText(declarator.id)
+      if (declarator.id && declarator.id.typeAnnotation) {
+        const typeText = sourceCode.getText(declarator.id.typeAnnotation)
+        return idText.length + 1 + typeText.length
+      }
+      return idText.length
+    }
+
+
+    function checkAlignment (declarations) {
+      if (declarations.length < blockSize)
+        return
+
+      if (ignoreIfAssignmentsNotInBlock && !haveSameKind(declarations))
+        return
+
+      // Get actual equals column positions
+      const equalsColumns = declarations.map(d => getEqualsColumn(d)).filter(c => c !== null)
+
+      // Check if already aligned by comparing equals columns directly
+      if (equalsColumns.length >= 2) {
+        const maxEqualsCol = Math.max(...equalsColumns)
+        const minEqualsCol = Math.min(...equalsColumns)
+        if (maxEqualsCol === minEqualsCol)
+          return
+      }
+
+      const maxIdLength = Math.max(...declarations.map(getIdLengthWithType))
+
+      let maxTypeLength = null
+      if (alignTypes && anyHaveTypes(declarations)) {
+        if (ignoreTypesMismatch && !allHaveTypes(declarations)) {
+          // Skip only type alignment but still do equals alignment
+        }
+        else {
+          const typeLengths = declarations
+            .map(d => d.id?.typeAnnotation ? sourceCode.getText(d.id.typeAnnotation).length : 0)
+            .filter(l => l > 0)
+          maxTypeLength = typeLengths.length ? Math.max(...typeLengths) : null
+        }
+      }
+
+      const maxEqualsColumn = Math.max(...equalsColumns)
+
+      declarations.forEach(declarator => {
+        const equalsCol = getEqualsColumn(declarator)
+
+        if (equalsCol !== null && equalsCol !== maxEqualsColumn)
+          context.report({
+            node:      declarator,
+            messageId: 'misalignedAssignment',
+            fix (fixer) {
+              return fixer.replaceText(
+                declarator,
+                getFixedDeclaration(declarator, maxEqualsColumn)
+              )
+            },
+          })
+      })
+    }
+
+
+    function processDeclarationGroup (declarations) {
+      if (!declarations.length)
+        return
+
+      const declarationsWithInits = declarations.filter(decl => decl.init)
+
+      if (declarationsWithInits.length < blockSize)
+        return
+
+      if (ignoreAdjacent) {
+        const adjacentGroups = []
+        let currentGroup = [ declarationsWithInits[0] ]
+
+        for (let i = 1; i < declarationsWithInits.length; i++) {
+          const prevDecl    = declarationsWithInits[i - 1]
+          const currentDecl = declarationsWithInits[i]
+
+          if (areNodesAdjacent(prevDecl, currentDecl))
+            currentGroup.push(currentDecl); else {
+            if (currentGroup.length >= blockSize)
+              adjacentGroups.push(currentGroup)
+            currentGroup = [ currentDecl ]
+          }
+        }
+
+        if (currentGroup.length >= blockSize)
+          adjacentGroups.push(currentGroup)
+
+        adjacentGroups.forEach(checkAlignment)
+      }
+      else
+        checkAlignment(declarationsWithInits)
+    }
+
+
+    // ── Member assignment alignment (this.prop = value, obj.prop = value) ────
+
+    function getMemberAssignEqualsColumn (exprStmt) {
+      const assignExpr  = exprStmt.expression
+      const equalsToken = sourceCode.getTokenBefore(
+        assignExpr.right,
+        token => token.value === '=' && token.type === 'Punctuator'
+      )
+      return equalsToken ? equalsToken.loc.start.column : null
+    }
+
+
+    function getFixedMemberAssignment (exprStmt, targetMaxLeftLength) {
+      const assignExpr = exprStmt.expression
+      const left       = assignExpr.left
+      const right      = assignExpr.right
+      const leftText   = sourceCode.getText(left)
+      const rightText  = sourceCode.getText(right)
+
+      const leftLength = leftText.length
+      const padding    = targetMaxLeftLength - leftLength
+
+      return leftText + ' '.repeat(padding) + '= ' + rightText
+    }
+
+
+    function getMemberLeftLength (exprStmt) {
+      const left = exprStmt.expression.left
+      return sourceCode.getText(left).trimEnd().length
+    }
+
+
+    function getMemberEqualsColumn (exprStmt) {
+      const assignExpr  = exprStmt.expression
+      const equalsToken = sourceCode.getTokenBefore(
+        assignExpr.right,
+        token => token.value === '=' && token.type === 'Punctuator'
+      )
+      return equalsToken ? equalsToken.loc.start.column : null
+    }
+
+
+    function checkMemberAlignment (stmts) {
+      if (stmts.length < blockSize)
+        return
+
+      const lengths   = stmts.map(getMemberLeftLength)
+      const maxLength = Math.max(...lengths)
+
+      // Check if already aligned by comparing equals columns
+      const equalsColumns = stmts.map(s => getMemberEqualsColumn(s)).filter(c => c !== null)
+      if (equalsColumns.length >= 2) {
+        const maxCol     = Math.max(...equalsColumns)
+        const allAligned = equalsColumns.every(c => c === maxCol)
+        if (allAligned)
+          return
+      }
+
+      stmts.forEach(stmt => {
+        const length = getMemberLeftLength(stmt)
+        if (length !== maxLength)
+          context.report({
+            node:      stmt.expression,
+            messageId: 'misalignedAssignment',
+            fix (fixer) {
+              return fixer.replaceText(stmt.expression, getFixedMemberAssignment(stmt, maxLength))
+            },
+          })
+      })
+    }
+
+
+    function processMemberAssignments (blockBody) {
+      if (!alignMemberAssignments)
+        return
+
+      const memberStmts = blockBody.filter(stmt =>
+        stmt.type === 'ExpressionStatement' &&
+        stmt.expression &&
+        stmt.expression.type === 'AssignmentExpression' &&
+        stmt.expression.operator === '=' &&
+        stmt.expression.left.type === 'MemberExpression'
+      )
+
+      if (memberStmts.length < blockSize)
+        return
+
+      if (ignoreAdjacent) {
+        const groups = []
+        let group    = [ memberStmts[0] ]
+
+        for (let i = 1; i < memberStmts.length; i++)
+          if (areNodesAdjacent(memberStmts[i - 1], memberStmts[i]))
+            group.push(memberStmts[i])
+          else {
+            if (group.length >= blockSize)
+              groups.push(group)
+            group = [ memberStmts[i] ]
+          }
+        if (group.length >= blockSize)
+          groups.push(group)
+        groups.forEach(checkMemberAlignment)
+      }
+      else
+        checkMemberAlignment(memberStmts)
+    }
+
+
+    // ── Shared block processor ─────────────────────────────────────────────
+
+    function processBlockVariables (node) {
+      const scopeBody    = node.type === 'Program' ? node.body : node.body ? node.body : []
+      const declarations = []
+
+      for (const statement of scopeBody)
+        if (statement.type === 'VariableDeclaration')
+          declarations.push(...statement.declarations)
+
+      processDeclarationGroup(declarations)
+      processMemberAssignments(scopeBody)
+    }
+
+
+    return {
+      Program (node) {
+        processBlockVariables(node)
+      },
+
+      BlockStatement (node) {
+        processBlockVariables(node)
+      },
+
+      SwitchCase (node) {
+        if (!node.consequent)
+          return
+
+        const declarations = []
+        const memberStmts  = []
+
+        for (const statement of node.consequent)
+          if (statement.type === 'VariableDeclaration')
+            declarations.push(...statement.declarations)
+
+        processDeclarationGroup(declarations)
+        processMemberAssignments(node.consequent)
+      },
+    }
+  },
+}

package/plugins/whitespaced/rules/block-padding.mjs

@@ -0,0 +1,289 @@
+/**
+ * @fileoverview ESLint rule to enforce whitespaced block padding with docstring support
+ * @author tuomashatakka
+ */
+
+export default {
+  meta: {
+    type: 'layout',
+    docs: {
+      description: 'Enforce whitespaced block padding with docstring support',
+      category:    "Stylistic Issues",
+      recommended: false,
+    },
+    fixable: 'whitespace',
+    schema:  [{
+      type:       "object",
+      properties: {
+        rootBlockPadding:          { type: 'integer', minimum: 0, default: 2 },
+        nestedBlockPadding:        { type: 'integer', minimum: 0, default: 1 },
+        enforceBeginningPadding:   { type: 'boolean', default: false },
+        enforceEndPadding:         { type: 'boolean', default: false },
+        docstringPadding:          { type: 'integer', minimum: 0, default: 1 },
+        treatCommentsAsDocstrings: { type: 'boolean', default: true },
+      },
+      additionalProperties: false,
+    },],
+    messages: {
+      missingPaddingBetweenRootBlocks:   "Expected {{expected}} empty {{lineText}} between root-level blocks, but found {{actual}}.",
+      missingPaddingBetweenNestedBlocks: 'Expected {{expected}} empty {{lineText}} between nested blocks, but found {{actual}}.',
+      missingPaddingAtBeginning:         "Expected no empty lines at the beginning of the file.",
+      missingPaddingAtEnd:               "Expected {{expected}} empty {{lineText}} at the end of the file, but found {{actual}}.",
+      missingPaddingAfterDocstring:      "Expected {{expected}} empty {{lineText}} after docstring, but found {{actual}}.",
+    },
+  },
+  create (context) {
+    const sourceCode                          = context.sourceCode || context.getSourceCode()
+    const options                             = context.options[0] || {}
+    const rootBlockPadding                    = options.rootBlockPadding !== undefined ? options.rootBlockPadding : 2
+    const nestedBlockPadding                  = options.nestedBlockPadding !== undefined ? options.nestedBlockPadding : 1
+    const enforceBeginningPadding             = options.enforceBeginningPadding !== undefined ? options.enforceBeginningPadding : false
+    const enforceEndPadding                   = options.enforceEndPadding !== undefined ? options.enforceEndPadding : false
+    const docstringPadding                    = options.docstringPadding !== undefined ? options.docstringPadding : 1
+    const treatCommentsAsDocstrings                     = options.treatCommentsAsDocstrings !== undefined ? options.treatCommentsAsDocstrings : true
+
+    function getBlankLinesBetween (node1, node2) {
+      const node1End               = node1.loc.end.line
+      const node2Start                         = node2.loc.start.line
+      return node2Start - node1End - 1
+    }
+
+
+function isDocstring (comment) {
+      if (comment.type === 'Block') {
+        const commentText                        = comment.value
+        const isMultiline                        = commentText.includes('\n');
+        const hasDocstringPatterns                             = (/\s*@\w+|param|return|description|example|author/).test(commentText)
+        return isMultiline || hasDocstringPatterns
+      }
+      return false
+    }
+
+
+function getDocstringComments (node) {
+      const comments = sourceCode.getCommentsBefore(node)
+
+      if (!comments || !comments.length)
+        return []
+
+      if (comments.some(comment => comment.type === 'Block')) {
+        const lastBlockComment = [ ...comments ].reverse().find(comment => comment.type === 'Block')
+        return lastBlockComment && isDocstring(lastBlockComment)
+? [
+          lastBlockComment,
+        ]
+: []
+      }
+
+      if (treatCommentsAsDocstrings && comments.some(comment => comment.type === 'Line')) {
+        const consecutiveLineComments = []
+        let lastLine = -1
+
+        for (let i = comments.length - 1; i >= 0; i--) {
+          const comment = comments[i]
+          if (comment.type !== 'Line')
+            continue;
+
+          if (lastLine === -1 || comment.loc.end.line + 1 === lastLine) {
+            consecutiveLineComments.unshift(comment)
+            lastLine = comment.loc.start.line
+          }
+ else 
+break;
+        }
+
+        if (consecutiveLineComments.length >= 2 ||
+            consecutiveLineComments.length === 1 &&
+             (/\s*@\w+|param|return|description|example|author/).test(consecutiveLineComments[0].value)) 
+return consecutiveLineComments
+      }
+
+      return []
+    }
+
+
+function checkDocstringPadding (node) {
+      const docstringComments = getDocstringComments(node)
+
+      if (!docstringComments.length)
+        return;
+
+      const lastComment                         = docstringComments[docstringComments.length - 1]
+      const commentEnd              = lastComment.loc.end.line
+      const nodeStart               = node.loc.start.line
+      const blankLines              = nodeStart - commentEnd - 1
+
+      if (blankLines !== docstringPadding) 
+context.report({
+        node,
+        messageId: "missingPaddingAfterDocstring",
+        data: {
+            expected: docstringPadding,
+            actual: blankLines,
+            lineText: docstringPadding === 1 ? "line" : "lines",
+          },
+        fix(fixer) {
+            const range = [lastComment.range[1], sourceCode.getFirstToken(node).range[0]];
+            const newLines = "\n".repeat(docstringPadding + 1);
+            return fixer.replaceTextRange(range, newLines);
+          },
+      });
+    }
+
+
+    function checkRootLevelBlankLines (nodes) {
+      for (let i = 0; i < nodes.length - 1; i++) {
+        const currentNode                             = nodes[i]
+        const nextNode                  = nodes[i + 1]
+        const blankLines                = getBlankLinesBetween(currentNode, nextNode)
+
+        if (blankLines !== rootBlockPadding) 
+context.report({
+          node: nextNode,
+          messageId: "missingPaddingBetweenRootBlocks",
+          data: {
+              expected: rootBlockPadding,
+              actual: blankLines,
+              lineText: rootBlockPadding === 1 ? "line" : "lines",
+            },
+          fix(fixer) {
+              const endOfCurrentNode = sourceCode.getLastToken(currentNode);
+              const startOfNextNode = sourceCode.getFirstToken(nextNode);
+              const range = [endOfCurrentNode.range[1], startOfNextNode.range[0]];
+              const newLines = "\n".repeat(rootBlockPadding + 1);
+              return fixer.replaceTextRange(range, newLines);
+            },
+        });
+      }
+    }
+
+
+    function checkNestedBlankLines (node, bodyNodes) {
+      for (let i = 0; i < bodyNodes.length - 1; i++) {
+        const currentNode                             = bodyNodes[i]
+        const nextNode                  = bodyNodes[i + 1]
+        const blankLines                = getBlankLinesBetween(currentNode, nextNode)
+
+        if (blankLines !== nestedBlockPadding) 
+context.report({
+          node: nextNode,
+          messageId: "missingPaddingBetweenNestedBlocks",
+          data: {
+              expected: nestedBlockPadding,
+              actual: blankLines,
+              lineText: nestedBlockPadding === 1 ? "line" : "lines",
+            },
+          fix(fixer) {
+              const endOfCurrentNode = sourceCode.getLastToken(currentNode);
+              const startOfNextNode = sourceCode.getFirstToken(nextNode);
+              const range = [endOfCurrentNode.range[1], startOfNextNode.range[0]];
+              const newLines = "\n".repeat(nestedBlockPadding + 1);
+              return fixer.replaceTextRange(range, newLines);
+            },
+        });
+      }
+    }
+
+
+    function checkBeginningPadding (firstNode) {
+      if (enforceBeginningPadding && firstNode) {
+        const startLine = firstNode.loc.start.line
+
+        if (startLine > 1) 
+context.report({
+          node: firstNode,
+          messageId: "missingPaddingAtBeginning",
+          fix(fixer) {
+              const rangeStart = 0;
+              const rangeEnd = sourceCode.getFirstToken(firstNode).range[0];
+              const sourceText = sourceCode.getText().substring(0, rangeEnd);
+              const contentStart = sourceText.search(/\S/);
+
+              if (contentStart !== -1) {
+                return fixer.removeRange([0, contentStart]);
+              } else {
+                return fixer.removeRange([0, rangeEnd]);
+              }
+            },
+        });
+      }
+    }
+
+
+    function checkEndPadding (lastNode) {
+      if (enforceEndPadding && lastNode) {
+        const sourceText                    = sourceCode.getText()
+        const lastNodeEnd                   = lastNode.loc.end.line
+        const totalLines                    = sourceText.split('\n').length
+        const blankLinesAtEnd                             = totalLines - lastNodeEnd
+
+        if (blankLinesAtEnd !== rootBlockPadding) 
+context.report({
+          node: lastNode,
+          messageId: "missingPaddingAtEnd",
+          data: {
+              expected: rootBlockPadding,
+              actual: blankLinesAtEnd,
+              lineText: rootBlockPadding === 1 ? "line" : "lines",
+            },
+          fix(fixer) {
+              const endOfLastNode = sourceCode.getLastToken(lastNode);
+              const end = sourceCode.getText().length;
+              const newLines = "\n".repeat(rootBlockPadding);
+              return fixer.replaceTextRange([endOfLastNode.range[1], end], newLines);
+            },
+        });
+      }
+    }
+
+
+    return {
+  Program (node) {
+        const body = node.body
+        if (body.length === 0) 
+return;
+
+        checkBeginningPadding(body[0])
+        checkEndPadding(body[body.length - 1])
+        checkRootLevelBlankLines(body)
+
+        body.forEach(childNode => {
+          checkDocstringPadding(childNode)
+        });
+      },
+  BlockStatement (node) {
+        if (node.body.length > 1) {
+          checkNestedBlankLines(node, node.body)
+
+          node.body.forEach(childNode => {
+            checkDocstringPadding(childNode)
+          });
+        }
+      },
+  SwitchStatement (node) {
+        if (node.cases.length > 1) checkNestedBlankLines(node, node.cases);
+      },
+  ClassBody (node) {
+        if (node.body.length > 1) {
+          checkNestedBlankLines(node, node.body)
+
+          node.body.forEach(childNode => {
+            checkDocstringPadding(childNode)
+          });
+        }
+      },
+  FunctionDeclaration (node) {
+        checkDocstringPadding(node)
+      },
+  ClassDeclaration (node) {
+        checkDocstringPadding(node)
+      },
+  MethodDefinition (node) {
+        checkDocstringPadding(node)
+      },
+  ArrowFunctionExpression (node) {
+        if (node.parent.type === 'VariableDeclarator') checkDocstringPadding(node);
+      },
+}
+  },
+}