eslint-plugin-th-rules 1.11.3 → 1.12.0

package/.vscode/settings.json

@@ -1 +1,5 @@
-{}
+{
+    "cSpell.words": [
+        "sonarjs"
+    ]
+}

package/.xo-config.json

@@ -0,0 +1,5 @@
+{
+    "extends": [
+        "plugin:th-rules/recommended-typescript"
+    ]
+}

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [1.12.0](https://github.com/tomerh2001/eslint-plugin-th-rules/compare/v1.11.4...v1.12.0) (2024-08-19)
+
+
+### Features
+
+* created no-comments rule ([82dda49](https://github.com/tomerh2001/eslint-plugin-th-rules/commit/82dda49f7f4708b68b8a4bd81e5af3ca84519a43))
+
+## [1.11.4](https://github.com/tomerh2001/eslint-plugin-th-rules/compare/v1.11.3...v1.11.4) (2024-08-19)
+
+
+### Bug Fixes
+
+* Update regex pattern for disallowed comments ([11d9e1b](https://github.com/tomerh2001/eslint-plugin-th-rules/commit/11d9e1bde0382460defb252701c20769f30e67e6))
+
 ## [1.11.3](https://github.com/tomerh2001/eslint-plugin-th-rules/compare/v1.11.2...v1.11.3) (2024-08-19)
 
 

package/README.md

@@ -59,3 +59,35 @@ This rule targets unnamed default exports and automatically generates a named ex
   }
 }
 ```
+### 3. No-Disallowed-Comments Rule
+
+**Rule ID:** `th-rules/no-disallowed-comments`
+
+#### Description
+
+This rule disallows comments unless they match specified allowed patterns. It ensures that only relevant and permitted comments are present in the codebase, such as TODOs, warnings, JSDoc comments, ESLint directives, etc.
+
+#### Rule Details
+
+By default, the following comments are allowed:
+
+- TODO, WARNING, ERROR, INFO (case-insensitive).
+- ESLint directives like `/* eslint-disable */`.
+- JSDoc comments (any comment starting with `/**`).
+
+You can also configure additional patterns to allow or disallow specific types of comments.
+
+#### Configuration
+
+```json
+{
+  "rules": {
+    "th-rules/no-disallowed-comments": [
+      "error",
+      {
+        "allow": ["keep", "important"],
+        "disallow": ["deprecated", "hack"]
+      }
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-th-rules",
-  "version": "1.11.3",
+  "version": "1.12.0",
   "description": "A List of custom ESLint rules created by Tomer Horowitz",
   "keywords": [
     "eslint",
@@ -18,16 +18,17 @@
     "update:eslint-docs": "eslint-doc-generator"
   },
   "dependencies": {
+    "@babel/eslint-parser": "^7.25.1",
     "eslint-config-jsdoc": "^15.4.0",
     "eslint-config-xo": "^0.46.0",
     "eslint-config-xo-react": "^0.27.0",
     "eslint-plugin-jsdoc": "^50.2.2",
-    "eslint-plugin-no-comments": "^1.1.10",
     "eslint-plugin-react": "^7.35.0",
     "eslint-plugin-react-hooks": "^4.6.2",
     "eslint-plugin-react-native": "^4.1.0",
     "eslint-plugin-security": "^3.0.1",
     "eslint-plugin-sonarjs": "^1.0.4",
+    "eslint-plugin-th-rules": "^1.11.4",
     "requireindex": "^1.2.0"
   },
   "devDependencies": {

package/src/index.js

@@ -18,6 +18,7 @@ configs.recommended = {
 	rules: {
 		'th-rules/no-destructuring': 'error',
 		'th-rules/no-default-export': 'error',
+		'th-rules/no-comments': 'error',
 		'unicorn/prefer-module': 'warn',
 		'unicorn/filename-case': 'off',
 		'unicorn/no-array-callback-reference': 'off',
@@ -26,14 +27,9 @@ configs.recommended = {
 		'unicorn/no-await-expression-member': 'off',
 		'new-cap': 'off',
 		'no-await-in-loop': 'off',
+		'n/file-extension-in-import': 'off',
+		'import/no-cycle': 'off',
 		camelcase: 'warn',
-		'no-comments/disallowComments': [
-			'error',
-			{
-				allow: ['^/\\*\\*(?:[\\s\\S]*?)\\*/$', 'eslint-disable', 'global', 'TODO', 'FIXME', 'NOTE', 'DEBUG'],
-			},
-		],
-
 	},
 	env: {
 		node: true,
@@ -43,7 +39,7 @@ configs.recommended = {
 };
 
 for (const configName of Object.keys(configs)) {
-	configs[configName + '-typescript'] = {
+	configs[`${configName}-typescript`] = {
 		...configs[configName],
 		extends: [
 			'plugin:@typescript-eslint/strict-type-checked',

package/src/rules/no-comments.js

@@ -0,0 +1,96 @@
+/* eslint-disable unicorn/prefer-module */
+
+const allowedPatterns = [
+/todo/i, // Allow TODO (case-insensitive)
+/warning/i, // Allow WARNING (case-insensitive)
+/error/i, // Allow ERROR (case-insensitive)
+/info/i, // Allow INFO (case-insensitive)
+/^\s*eslint-(disable|enable|env|globals|ignore|directive)/, // Allow ESLint directives
+];
+
+const meta = {
+type: 'problem',
+docs: {
+    description: 'Disallow comments except for specified allowed patterns.',
+},
+fixable: 'code',
+schema: [
+    {
+    type: 'object',
+    properties: {
+        allow: {
+        type: 'array',
+        items: {
+            type: 'string',
+        },
+        description: 'Additional patterns to allow in comments.',
+        },
+        disallow: {
+        type: 'array',
+        items: {
+            type: 'string',
+        },
+        description: 'Additional patterns to disallow in comments.',
+        },
+    },
+    additionalProperties: false,
+    },
+],
+};
+
+function create(context) {
+const options = context.options[0] || {};
+const userAllowedPatterns = (options.allow || []).map((pattern) => new RegExp(pattern));
+const userDisallowedPatterns = (options.disallow || []).map((pattern) => new RegExp(pattern));
+
+function isCommentAllowed(comment) {
+    const text = comment.value.trim();
+
+    // Check if the comment is a valid JSDoc comment
+    if (comment.type === 'Block' && comment.value.startsWith('*')) {
+    return true; // Allow any JSDoc-style block comment (/** ... */)
+    }
+
+    // Check if the comment matches any allowed pattern
+    for (const pattern of [...allowedPatterns, ...userAllowedPatterns]) {
+    if (pattern.test(text)) {
+        return true;
+    }
+    }
+
+    // Check if the comment matches any disallowed pattern
+    for (const pattern of userDisallowedPatterns) {
+    if (pattern.test(text)) {
+        return false;
+    }
+    }
+
+    return false; // Disallow by default if no match
+}
+
+return {
+    Program() {
+    const sourceCode = context.getSourceCode();
+    const comments = sourceCode.getAllComments();
+
+    comments.forEach((comment) => {
+        if (!isCommentAllowed(comment)) {
+        context.report({
+            node: comment,
+            message: 'Comment not allowed.',
+            fix(fixer) {
+            return fixer.remove(comment);
+            },
+        });
+        }
+    });
+    },
+};
+}
+
+const rule = {
+meta,
+create,
+};
+
+module.exports = rule;

package/src/tests/no-comments.js

@@ -0,0 +1,115 @@
+/* eslint-disable unicorn/prefer-module */
+
+const { RuleTester } = require('eslint');
+const rule = require('../rules/no-comments.js');
+
+// Initialize RuleTester without the old parserOptions, using the new format
+const ruleTester = new RuleTester({
+  parser: require.resolve('@babel/eslint-parser'),
+});
+
+ruleTester.run('no-comments', rule, {
+  valid: [
+    {
+      code: `
+        /**
+         * JSDoc comment
+         * @param {string} name - The name of the person.
+         */
+        function foo(name) {}
+      `,
+    },
+    {
+      code: `
+        // TODO: this needs to be refactored
+        const x = 5;
+      `,
+    },
+    {
+      code: `
+        /* WARNING: temporary fix */
+        const y = 10;
+      `,
+    },
+    {
+      code: `
+        // eslint-disable-next-line no-console
+        console.log("hello");
+      `,
+    },
+    {
+      code: `
+        // keep this comment
+        const z = 15;
+      `,
+      options: [{ allow: ['keep'] }],
+    },
+  ],
+
+  invalid: [
+    {
+      code: `
+        // Regular comment
+        const a = 5;
+      `,
+      errors: [{ message: 'Comment not allowed.' }],
+      output: `
+        const a = 5;
+      `,
+    },
+    {
+      code: `
+        // Some disallowed comment
+        const b = 10;
+      `,
+      options: [{ disallow: ['disallowed'] }],
+      errors: [{ message: 'Comment not allowed.' }],
+      output: `
+        const b = 10;
+      `,
+    },
+    {
+      code: `
+        // DEPRECATED: Remove this function in the next version
+        function deprecatedFunc() {}
+      `,
+      options: [{ disallow: ['deprecated'] }],
+      errors: [{ message: 'Comment not allowed.' }],
+      output: `
+        function deprecatedFunc() {}
+      `,
+    },
+    {
+      code: `
+        // important comment
+        const c = 20;
+      `,
+      errors: [{ message: 'Comment not allowed.' }],
+      output: `
+        const c = 20;
+      `,
+    },
+    {
+      code: `
+        // A completely random comment
+        const d = 25;
+      `,
+      options: [{ allow: ['keep'] }],
+      errors: [{ message: 'Comment not allowed.' }],
+      output: `
+        const d = 25;
+      `,
+    },
+    {
+      code: `
+        // @ts-ignore
+        const e = "typescript";
+      `,
+      options: [{ disallow: ['@ts-ignore'] }],
+      errors: [{ message: 'Comment not allowed.' }],
+      output: `
+        const e = "typescript";
+      `,
+    },
+  ],
+});