@dmitryrechkin/eslint-standard 1.3.5 → 1.3.7

package/eslint.config.mjs

@@ -8,6 +8,7 @@ import simpleImportSortPlugin from 'eslint-plugin-simple-import-sort';
 import perfectionistPlugin from 'eslint-plugin-perfectionist';
 import jsdocIndentPlugin from './src/plugins/jsdoc-indent.mjs';
 import interfaceBracePlugin from './src/plugins/interface-brace.mjs';
+import switchCaseBracePlugin from './src/plugins/switch-case-brace.mjs';
 import securityPlugin from 'eslint-plugin-security';
 import jsxA11yPlugin from 'eslint-plugin-jsx-a11y';
 import promisePlugin from 'eslint-plugin-promise';
@@ -48,6 +49,7 @@ export default function ({
 				'perfectionist': perfectionistPlugin,
 				'jsdoc-indent': jsdocIndentPlugin,
 				'interface-brace': interfaceBracePlugin,
+				'switch-case-brace': switchCaseBracePlugin,
 				'security': securityPlugin,
 				'jsx-a11y': jsxA11yPlugin,
 				'promise': promisePlugin,
@@ -182,6 +184,9 @@ export default function ({
 				
 				// Enhanced: Interface brace style
 				'interface-brace/interface-brace-style': 'error',
+				
+				// Enhanced: Switch case brace style - Allman style for case blocks
+				'switch-case-brace/switch-case-brace-style': 'error',
 
 				// Additional naming conventions based on coding standards
 				'@typescript-eslint/naming-convention': [
@@ -795,6 +800,7 @@ export default function ({
 		// Test file specific overrides
 		{
 			files: ['**/*.test.{js,jsx,ts,tsx}', '**/*.spec.{js,jsx,ts,tsx}', '**/tests/**/*.{js,jsx,ts,tsx}'],
+			ignores: ['**/tests/fixtures/**/*'], // Don't apply test overrides to fixture files
 			rules: {
 				// Disable function scoping rule for test helpers
 				'unicorn/consistent-function-scoping': 'off',
@@ -808,9 +814,16 @@ export default function ({
 					exceptions: ['id', 'fn']
 				}],
 				
-				// Relax rules that are too strict for tests
-				'unicorn/no-null': 'warn',                    // APIs often legitimately use null
-				'functional/no-loop-statements': 'warn',      // Loops can be clearer than functional alternatives in tests
+				// Disable rules inappropriate for test files
+				'functional/no-loop-statements': 'off',      // Loops are often clearer than functional alternatives in tests
+				'functional/no-let': 'off',                  // Test setup requires mutable variables
+				'functional/immutable-data': 'off',          // Test mocking requires object mutations
+				'security/detect-non-literal-fs-filename': 'off', // Tests legitimately need dynamic file paths
+				'unicorn/prefer-module': 'off',              // Tests may need __dirname for reliable paths
+				
+				// Keep as warnings - still worth improving when possible
+				'unicorn/no-null': 'off',                    // APIs often use null, but const can be better
+				'sonarjs/no-duplicate-string': 'off',        // Test strings repeat, but constants still help readability
 			},
 		},
 	];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@dmitryrechkin/eslint-standard",
 	"description": "This package provides a shared ESLint configuration which includes TypeScript support and a set of specific linting rules designed to ensure high-quality and consistent code style across projects.",
-	"version": "1.3.5",
+	"version": "1.3.7",
 	"main": "eslint.config.mjs",
 	"bin": {
 		"eslint-standard": "./src/cli/index.mjs"
@@ -24,6 +24,7 @@
 		"test:security": "node tests/test-security-rules.js",
 		"test:sonarjs": "node tests/test-sonarjs-rules.js",
 		"test:unicorn": "node tests/test-unicorn-rules.js",
+		"test:switch-case": "node tests/test-switch-case-simple.js",
 		"test:cli": "node tests/test-cli.js",
 		"test:install": "node tests/test-install-simulation.js"
 	},

package/src/plugins/switch-case-brace.mjs

@@ -0,0 +1,119 @@
+/**
+ * Custom ESLint plugin rule to enforce Allman-style brace placement for switch case blocks
+ * Forces case block opening braces to be on new lines
+ * 
+ * Example:
+ * case 'VALUE':
+ * {
+ *     // code here
+ * }
+ */
+
+const switchCaseBraceRule = {
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforce Allman-style brace placement for switch case blocks',
+			category: 'Stylistic Issues',
+			recommended: false
+		},
+		fixable: 'whitespace',
+		schema: [],
+		messages: {
+			expectedNewlineBeforeOpeningBrace: 'Expected a newline before opening brace in case block.',
+			expectedNewlineAfterOpeningBrace: 'Expected a newline after opening brace in case block.'
+		}
+	},
+
+	create(context) {
+		const sourceCode = context.getSourceCode();
+
+		/**
+		 * Check if a case clause has a block statement and enforce proper brace placement
+		 * @param {ASTNode} node - The SwitchCase node
+		 */
+		function checkCaseClause(node) {
+			// Only process case clauses that have a single BlockStatement
+			if (node.consequent.length !== 1 || node.consequent[0].type !== 'BlockStatement') {
+				return;
+			}
+
+			const blockStatement = node.consequent[0];
+			const openingBrace = sourceCode.getFirstToken(blockStatement);
+			const closingBrace = sourceCode.getLastToken(blockStatement);
+
+			// Get the colon token after case label
+			const colonToken = sourceCode.getTokenAfter(node.test || sourceCode.getFirstToken(node));
+
+			// Check if opening brace is on the same line as the colon
+			if (colonToken.loc.end.line === openingBrace.loc.start.line) {
+				context.report({
+					node: blockStatement,
+					messageId: 'expectedNewlineBeforeOpeningBrace',
+					fix(fixer) {
+						// Add newline and proper indentation before opening brace
+						const indentation = '\t'.repeat(getIndentLevel(node) + 1);
+						return fixer.replaceTextRange(
+							[colonToken.range[1], openingBrace.range[0]],
+							`\n${indentation}`
+						);
+					}
+				});
+			}
+
+			// Check if content inside braces needs proper formatting
+			if (blockStatement.body.length > 0) {
+				const firstStatement = blockStatement.body[0];
+				const firstStatementToken = sourceCode.getFirstToken(firstStatement);
+				
+				// Check if the first statement is on the same line as opening brace
+				if (openingBrace.loc.end.line === firstStatementToken.loc.start.line) {
+					context.report({
+						node: firstStatement,
+						messageId: 'expectedNewlineAfterOpeningBrace',
+						fix(fixer) {
+							// Add newline and proper indentation after opening brace
+							const indentation = '\t'.repeat(getIndentLevel(node) + 2);
+							const fixes = [];
+							
+							// Add newline after opening brace
+							fixes.push(fixer.insertTextAfter(openingBrace, `\n${indentation}`));
+							
+							// Also ensure closing brace is on its own line with proper indentation
+							const lastStatement = blockStatement.body[blockStatement.body.length - 1];
+							const lastToken = sourceCode.getLastToken(lastStatement);
+							const closingBraceIndentation = '\t'.repeat(getIndentLevel(node) + 1);
+							
+							if (lastToken.loc.end.line === closingBrace.loc.start.line) {
+								fixes.push(fixer.insertTextBefore(closingBrace, `\n${closingBraceIndentation}`));
+							}
+							
+							return fixes;
+						}
+					});
+				}
+			}
+		}
+
+		/**
+		 * Get the indentation level for a node
+		 * @param {ASTNode} node - The node to check
+		 * @returns {number} The indentation level
+		 */
+		function getIndentLevel(node) {
+			const line = sourceCode.lines[node.loc.start.line - 1];
+			const match = line.match(/^(\t*)/);
+			return match ? match[1].length : 0;
+		}
+
+		return {
+			SwitchCase: checkCaseClause
+		};
+	}
+};
+
+export default {
+	rules: {
+		'switch-case-brace-style': switchCaseBraceRule
+	}
+};