@sun-asterisk/sunlint 1.0.7 → 1.1.4

package/integrations/eslint/plugin/rules/common/c017-limit-constructor-logic.js

@@ -0,0 +1,146 @@
+/**
+ * Custom ESLint rule for: C017 – Limit constructor logic
+ * Rule ID: custom/c017
+ * Purpose: Enforce minimal logic in constructors to maintain clean initialization
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Limit constructor logic",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      constructorLogic: "Constructor contains complex logic: {{description}}. Move to initialization methods",
+      tooManyStatements: "Constructor has too many statements ({{count}}). Consider simplifying or moving logic to initialization methods"
+    }
+  },
+  create(context) {
+    function isSimpleAssignment(node) {
+      // Simple property assignments like this.prop = value
+      if (node.type === "ExpressionStatement" && 
+          node.expression.type === "AssignmentExpression" &&
+          node.expression.left.type === "MemberExpression" &&
+          node.expression.left.object.type === "ThisExpression") {
+        
+        // Check if right side is a simple value (not complex computation)
+        const right = node.expression.right;
+        return right.type === "Literal" ||
+               right.type === "Identifier" ||
+               (right.type === "MemberExpression" && right.property.name === "length") ||
+               (right.type === "CallExpression" && right.callee.type === "Identifier" && 
+                ['require', 'process'].includes(right.callee.name));
+      }
+      return false;
+    }
+
+    function isSimpleDeclaration(node) {
+      // Simple variable declarations
+      return node.type === "VariableDeclaration";
+    }
+
+    function isSuperCall(node) {
+      // super() calls
+      return node.type === "ExpressionStatement" && 
+             node.expression.type === "CallExpression" &&
+             node.expression.callee.type === "Super";
+    }
+
+    function isComplexLogic(node) {
+      // Complex patterns that shouldn't be in constructor
+      switch (node.type) {
+        case "IfStatement":
+        case "WhileStatement":
+        case "ForStatement":
+        case "SwitchStatement":
+        case "TryStatement":
+          return { type: "control_flow", description: "control flow statements" };
+          
+        case "ExpressionStatement":
+          if (node.expression.type === "CallExpression") {
+            const callee = node.expression.callee;
+            
+            // Method calls that aren't simple setters
+            if (callee.type === "MemberExpression") {
+              const methodName = callee.property.name;
+              
+              // Allow simple MobX observable setup
+              if (methodName === "makeObservable" || methodName === "makeAutoObservable") {
+                return null;
+              }
+              
+              // Flag complex method calls
+              if (!['push', 'set', 'add'].includes(methodName)) {
+                return { type: "method_call", description: "complex method calls" };
+              }
+            }
+            
+            // Direct function calls (not method calls)
+            if (callee.type === "Identifier" && 
+                !['require', 'parseInt', 'parseFloat', 'Boolean', 'Number', 'String'].includes(callee.name)) {
+              return { type: "function_call", description: "function calls" };
+            }
+          }
+          
+          // Complex assignments with computations
+          if (node.expression.type === "AssignmentExpression") {
+            const right = node.expression.right;
+            if (right.type === "BinaryExpression" || 
+                right.type === "ConditionalExpression" ||
+                (right.type === "CallExpression" && 
+                 right.callee.type === "MemberExpression" &&
+                 !['map', 'filter', 'toString', 'slice'].includes(right.callee.property.name))) {
+              return { type: "complex_assignment", description: "complex computations" };
+            }
+          }
+          break;
+      }
+      
+      return null;
+    }
+
+    return {
+      MethodDefinition(node) {
+        if (node.kind === "constructor" && node.value && node.value.body) {
+          const statements = node.value.body.body;
+          let complexLogicCount = 0;
+          
+          for (const stmt of statements) {
+            // Skip simple assignments, declarations, and super calls
+            if (isSimpleAssignment(stmt) || 
+                isSimpleDeclaration(stmt) || 
+                isSuperCall(stmt)) {
+              continue;
+            }
+            
+            // Check for complex logic
+            const complexity = isComplexLogic(stmt);
+            if (complexity) {
+              context.report({
+                node: stmt,
+                messageId: "constructorLogic",
+                data: {
+                  description: complexity.description
+                }
+              });
+              complexLogicCount++;
+            }
+          }
+          
+          // Also flag constructors with too many statements overall
+          if (statements.length > 10) {
+            context.report({
+              node: node,
+              messageId: "tooManyStatements", 
+              data: {
+                count: statements.length
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+};

package/integrations/eslint/plugin/rules/common/c018-no-generic-throw.js

@@ -0,0 +1,335 @@
+/**
+ * Custom ESLint rule for: C018 – Do not throw generic errors, always use specific messages
+ * Rule ID: custom/c018
+ * Purpose: Enforce specific error messages when throwing errors to improve debugging and error handling
+ */
+
+const c018Rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Do not throw generic errors, always use specific messages",
+      recommended: false
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowGenericInTests: {
+            type: "boolean",
+            description: "Whether to allow generic throws in test files (default: true)"
+          },
+          allowRethrow: {
+            type: "boolean",
+            description: "Whether to allow rethrowing caught errors (default: true)"
+          },
+          allowThrowVariable: {
+            type: "boolean",
+            description: "Whether to allow throwing variables/identifiers (default: false)"
+          },
+          requiredMessagePatterns: {
+            type: "array",
+            items: { type: "string" },
+            description: "Regex patterns that error messages must match"
+          },
+          minimumMessageLength: {
+            type: "number",
+            description: "Minimum length for error messages (default: 10)"
+          },
+          allowedGenericMessages: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of allowed generic messages"
+          },
+          customErrorClasses: {
+            type: "array",
+            items: { type: "string" },
+            description: "Custom error class names that are allowed"
+          },
+          strictMode: {
+            type: "boolean",
+            description: "Enable strict mode with additional checks (default: false)"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      genericError: "Do not throw generic errors. Provide a specific error message.",
+      emptyError: "Error message cannot be empty. Provide a specific error message.",
+      messageToolShort: "Error message too short (minimum {{minLength}} characters). Vietnamese: 'Message error quá ngắn (tối thiểu {{minLength}} ký tự)'",
+      genericErrorMessage: "Generic error message '{{message}}' should be more specific. Vietnamese: 'Message error generic nên cụ thể hơn'",
+      throwWithoutMessage: "Throw statement must include a specific error message. Vietnamese: 'Throw statement phải có message error cụ thể'",
+      useSpecificErrorClass: "Use specific error class instead of generic Error. Vietnamese: 'Dùng error class cụ thể thay vì Error generic'",
+      invalidMessagePattern: "Error message doesn't match required patterns. Vietnamese: 'Message error không khớp pattern yêu cầu'",
+      throwBareString: "Throwing bare string is not recommended, use Error object with message. Vietnamese: 'Throw string trực tiếp không khuyến khích, dùng Error object với message'"
+    },
+    fixable: null
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    
+    // Default configuration
+    const allowGenericInTests = options.allowGenericInTests !== false;
+    const allowRethrow = options.allowRethrow !== false;
+    const allowThrowVariable = options.allowThrowVariable || false;
+    const requiredMessagePatterns = options.requiredMessagePatterns || [];
+    const minimumMessageLength = options.minimumMessageLength || 10;
+    const allowedGenericMessages = new Set(options.allowedGenericMessages || []);
+    const customErrorClasses = new Set(options.customErrorClasses || ['ValidationError', 'BusinessError', 'NetworkError', 'AuthenticationError', 'AuthorizationError']);
+    const strictMode = options.strictMode || false;
+
+    const sourceCode = context.getSourceCode();
+    const filename = context.getFilename();
+
+    // Generic error messages to detect
+    const genericMessages = new Set([
+      'error',
+      'Error',
+      'ERROR',
+      'something went wrong',
+      'something failed',
+      'operation failed',
+      'invalid',
+      'invalid input',
+      'bad input',
+      'error occurred',
+      'an error occurred',
+      'failed',
+      'failure',
+      'exception',
+      'unexpected error',
+      'internal error',
+      'system error',
+      'unknown error'
+    ]);
+
+    function isTestFile() {
+      if (!allowGenericInTests) return false;
+      
+      const testPatterns = ['.test.', '.spec.', '__tests__', '/test/', '/tests/', '.e2e.'];
+      return testPatterns.some(pattern => filename.includes(pattern));
+    }
+
+    function isRethrowStatement(node) {
+      if (!allowRethrow) return false;
+
+      // Check if throwing a caught error parameter
+      if (node.argument && node.argument.type === 'Identifier') {
+        // Look for catch clauses in parent scopes
+        let parent = node.parent;
+        while (parent) {
+          if (parent.type === 'CatchClause' && 
+              parent.param && 
+              parent.param.name === node.argument.name) {
+            return true;
+          }
+          parent = parent.parent;
+        }
+      }
+
+      return false;
+    }
+
+    function getErrorMessage(node) {
+      if (!node.argument) return null;
+
+      // Direct string literal
+      if (node.argument.type === 'Literal') {
+        return node.argument.value;
+      }
+
+      // new Error("message")
+      if (node.argument.type === 'NewExpression' && 
+          node.argument.callee && 
+          node.argument.arguments && 
+          node.argument.arguments.length > 0) {
+        const firstArg = node.argument.arguments[0];
+        if (firstArg.type === 'Literal') {
+          return firstArg.value;
+        }
+      }
+
+      return null;
+    }
+
+    function getErrorClassName(node) {
+      if (node.argument && 
+          node.argument.type === 'NewExpression' && 
+          node.argument.callee) {
+        if (node.argument.callee.type === 'Identifier') {
+          return node.argument.callee.name;
+        }
+      }
+      return null;
+    }
+
+    function isGenericErrorMessage(message) {
+      if (typeof message !== 'string') return false;
+      
+      const normalizedMessage = message.toLowerCase().trim();
+      return genericMessages.has(normalizedMessage) || 
+             genericMessages.has(message.trim());
+    }
+
+    function isMessageTooShort(message) {
+      if (typeof message !== 'string') return false;
+      return message.trim().length < minimumMessageLength;
+    }
+
+    function matchesRequiredPatterns(message) {
+      if (requiredMessagePatterns.length === 0) return true;
+      if (typeof message !== 'string') return false;
+      
+      return requiredMessagePatterns.some(pattern => {
+        try {
+          const regex = new RegExp(pattern);
+          return regex.test(message);
+        } catch (e) {
+          return false;
+        }
+      });
+    }
+
+    function isAllowedGenericMessage(message) {
+      if (typeof message !== 'string') return false;
+      return allowedGenericMessages.has(message.trim());
+    }
+
+    function checkThrowStatement(node) {
+      // Skip if in test file and allowed
+      if (isTestFile()) {
+        return;
+      }
+
+      // Skip if this is a rethrow
+      if (isRethrowStatement(node)) {
+        return;
+      }
+
+      // Check for throw without argument
+      if (!node.argument) {
+        context.report({
+          node,
+          messageId: 'throwWithoutMessage'
+        });
+        return;
+      }
+
+      // Check for throwing variables/identifiers
+      if (node.argument.type === 'Identifier' && !allowThrowVariable) {
+        context.report({
+          node,
+          messageId: 'genericError'
+        });
+        return;
+      }
+
+      // Check for throwing bare strings
+      if (node.argument.type === 'Literal' && typeof node.argument.value === 'string') {
+        if (strictMode) {
+          context.report({
+            node,
+            messageId: 'throwBareString'
+          });
+          return;
+        }
+        
+        const message = node.argument.value;
+        validateMessage(node, message);
+        return;
+      }
+
+      // Check for new Error() constructions
+      if (node.argument.type === 'NewExpression') {
+        const errorClassName = getErrorClassName(node);
+        const errorMessage = getErrorMessage(node);
+
+        // Check error class
+        if (strictMode && errorClassName === 'Error') {
+          context.report({
+            node,
+            messageId: 'useSpecificErrorClass'
+          });
+        }
+
+        // Check error message
+        if (errorMessage !== null) {
+          validateMessage(node, errorMessage);
+        } else if (node.argument.arguments.length === 0) {
+          context.report({
+            node,
+            messageId: 'throwWithoutMessage'
+          });
+        }
+        return;
+      }
+
+      // Generic throw statement
+      context.report({
+        node,
+        messageId: 'genericError'
+      });
+    }
+
+    function validateMessage(node, message) {
+      if (!message || typeof message !== 'string') {
+        context.report({
+          node,
+          messageId: 'throwWithoutMessage'
+        });
+        return;
+      }
+
+      // Check for empty or whitespace-only message
+      if (message.trim() === '') {
+        context.report({
+          node,
+          messageId: 'emptyError'
+        });
+        return;
+      }
+
+      // Check if message is allowed generic
+      if (isAllowedGenericMessage(message)) {
+        return;
+      }
+
+      // Check for generic messages
+      if (isGenericErrorMessage(message)) {
+        context.report({
+          node,
+          messageId: 'genericErrorMessage',
+          data: { message: message.trim() }
+        });
+        return;
+      }
+
+      // Check message length
+      if (isMessageTooShort(message)) {
+        context.report({
+          node,
+          messageId: 'messageToolShort',
+          data: { minLength: minimumMessageLength }
+        });
+        return;
+      }
+
+      // Check required patterns
+      if (!matchesRequiredPatterns(message)) {
+        context.report({
+          node,
+          messageId: 'invalidMessagePattern'
+        });
+        return;
+      }
+    }
+
+    return {
+      ThrowStatement: checkThrowStatement
+    };
+  }
+};
+
+module.exports = c018Rule;

package/integrations/eslint/plugin/rules/common/c023-no-duplicate-variable-name-in-scope.js

@@ -0,0 +1,142 @@
+/**
+ * Custom ESLint rule for: C023 – Do not use duplicate variable names in the same scope
+ * Rule ID: custom/c023
+ * Purpose: Prevent variable name shadowing and maintain clear variable scoping
+ */
+
+const c023Rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Do not use duplicate variable names in the same scope",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      duplicateVariable: "Variable '{{name}}' is already declared in this scope"
+    }
+  },
+  create(context) {
+    const scopeStack = [];
+    const variableMap = new Map();
+
+    function enterScope() {
+      scopeStack.push(new Map());
+    }
+
+    function exitScope() {
+      const scope = scopeStack.pop();
+      // Clean up variables from the exited scope
+      for (const [name, info] of scope) {
+        const globalInfo = variableMap.get(name);
+        if (globalInfo) {
+          globalInfo.scopes.delete(scope);
+          if (globalInfo.scopes.size === 0) {
+            variableMap.delete(name);
+          }
+        }
+      }
+    }
+
+    function checkVariable(node, name) {
+      if (scopeStack.length === 0) return;
+
+      const currentScope = scopeStack[scopeStack.length - 1];
+      
+      // Check if variable is already declared in current scope
+      if (currentScope.has(name)) {
+        context.report({
+          node,
+          messageId: "duplicateVariable",
+          data: { name }
+        });
+        return;
+      }
+
+      // Add variable to current scope
+      currentScope.set(name, {
+        node,
+        scopes: new Set([currentScope])
+      });
+
+      // Update global variable map
+      if (!variableMap.has(name)) {
+        variableMap.set(name, {
+          scopes: new Set([currentScope])
+        });
+      } else {
+        variableMap.get(name).scopes.add(currentScope);
+      }
+    }
+
+    return {
+      Program() {
+        enterScope();
+      },
+      "Program:exit"() {
+        exitScope();
+      },
+      FunctionDeclaration() {
+        enterScope();
+      },
+      "FunctionDeclaration:exit"() {
+        exitScope();
+      },
+      FunctionExpression() {
+        enterScope();
+      },
+      "FunctionExpression:exit"() {
+        exitScope();
+      },
+      ArrowFunctionExpression() {
+        enterScope();
+      },
+      "ArrowFunctionExpression:exit"() {
+        exitScope();
+      },
+      BlockStatement() {
+        enterScope();
+      },
+      "BlockStatement:exit"() {
+        exitScope();
+      },
+      CatchClause() {
+        enterScope();
+      },
+      "CatchClause:exit"() {
+        exitScope();
+      },
+      ForStatement() {
+        enterScope();
+      },
+      "ForStatement:exit"() {
+        exitScope();
+      },
+      ForInStatement() {
+        enterScope();
+      },
+      "ForInStatement:exit"() {
+        exitScope();
+      },
+      ForOfStatement() {
+        enterScope();
+      },
+      "ForOfStatement:exit"() {
+        exitScope();
+      },
+      SwitchStatement() {
+        enterScope();
+      },
+      "SwitchStatement:exit"() {
+        exitScope();
+      },
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier") {
+          checkVariable(node, node.id.name);
+        }
+      }
+    };
+  }
+};
+
+module.exports = c023Rule;