@sun-asterisk/sunlint 1.0.7 → 1.1.3

package/integrations/eslint/plugin/rules/common/c003-no-vague-abbreviations.js

@@ -0,0 +1,246 @@
+/**
+ * Custom ESLint rule for: C003 – Clear variable names, avoid arbitrary abbreviations
+ * Rule ID: custom/c003
+ * Purpose: Ensure clear, understandable variable names without arbitrary abbreviations
+ */
+
+const c003Rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Clear variable names, avoid arbitrary abbreviations",
+      recommended: false
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowedSingleChar: {
+            type: "array",
+            items: { type: "string" },
+            description: "Single character variables that are allowed (default: i, j, k)"
+          },
+          allowedAbbreviations: {
+            type: "array", 
+            items: { type: "string" },
+            description: "Common abbreviations that are allowed"
+          },
+          minLength: {
+            type: "integer",
+            minimum: 1,
+            description: "Minimum variable name length (default: 2)"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      singleChar: "Variable '{{name}}' is only 1 character long. Use descriptive names (except for counters like i, j, k).",
+      tooShort: "Variable '{{name}}' is too short ({{length}} characters). Use descriptive names with at least {{minLength}} characters.", 
+      abbreviation: "Variable '{{name}}' appears to be an unclear abbreviation. Use full descriptive names.",
+      unclear: "Variable '{{name}}' is unclear or ambiguous. Use more specific descriptive names."
+    }
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const allowedSingleChar = new Set(options.allowedSingleChar || ['i', 'j', 'k', 'x', 'y', 'z']);
+    const allowedAbbreviations = new Set(options.allowedAbbreviations || [
+      'id', 'url', 'api', 'ui', 'db', 'config', 'env', 'app',
+      'btn', 'img', 'src', 'dest', 'req', 'res', 'ctx',
+      'min', 'max', 'len', 'num', 'str', 'json'
+    ]);
+    const minLength = options.minLength || 2;
+
+    // Common abbreviation patterns that should be avoided
+    const suspiciousAbbreviations = [
+      /^[a-z]{1,2}[0-9]*$/, // e.g., 'u', 'usr', 'n1', 'v2'
+      /^[a-z]*[aeiou]*[bcdfghjklmnpqrstvwxyz]{3,}$/, // too many consonants
+      /^[bcdfghjklmnpqrstvwxyz]{3,}[aeiou]*$/, // consonants at start
+      /^(tmp|temp|val|var|data|info|item|elem|el|obj|arr)([A-Z0-9].*)?$/, // generic names
+      /^[a-z]+(Mgr|Ctrl|Svc|Repo|Util|Hlpr|Mngr)$/, // manager/helper patterns  
+    ];
+
+    // Generic/unclear variable names that should be avoided
+    const unclearNames = new Set([
+      'data', 'info', 'item', 'element', 'object', 'value', 'result', 
+      'response', 'request', 'temp', 'tmp', 'var', 'variable',
+      'stuff', 'thing', 'something', 'anything', 'everything',
+      'flag', 'check', 'test', 'validate', 'process', 'handle',
+      'obj', 'arg', 'val', 'fn'
+    ]);
+
+    function isCounterContext(node) {
+      // Check if variable is used as a loop counter
+      if (!node || !node.parent) return false;
+      
+      let parent = node.parent;
+      
+      // Go up the tree to find ForStatement/ForInStatement/ForOfStatement
+      while (parent) {
+        if (parent.type === 'ForStatement') {
+          return parent.init && parent.init.declarations && 
+                 parent.init.declarations.some(decl => decl && decl.id === node);
+        }
+        if (parent.type === 'ForInStatement' || parent.type === 'ForOfStatement') {
+          return parent.left && (parent.left === node || 
+                 (parent.left.type === 'VariableDeclaration' && 
+                  parent.left.declarations.some(decl => decl && decl.id === node)));
+        }
+        parent = parent.parent;
+      }
+      return false;
+    }
+
+    function checkVariableName(node, name) {
+      // Safety checks
+      if (!node || !name || typeof name !== 'string') {
+        return;
+      }
+
+      // Skip if it's a destructuring pattern with specific exceptions
+      if (node.parent && node.parent.type === 'Property' && node.parent.shorthand) {
+        return; // Allow destructuring shorthand
+      }
+
+      // Skip TypeScript type annotations and interface properties
+      if (node.parent && (node.parent.type === 'TSTypeAnnotation' || 
+                         node.parent.type === 'TSPropertySignature' ||
+                         node.parent.type === 'TSMethodSignature')) {
+        return;
+      }
+
+      // Single character check
+      if (name.length === 1) {
+        if (!allowedSingleChar.has(name.toLowerCase()) && !isCounterContext(node)) {
+          context.report({
+            node,
+            messageId: "singleChar",
+            data: { name }
+          });
+        }
+        return;
+      }
+
+      // Minimum length check
+      if (name.length < minLength) {
+        context.report({
+          node,
+          messageId: "tooShort", 
+          data: { name, length: name.length, minLength }
+        });
+        return;
+      }
+
+      // Skip allowed abbreviations
+      if (allowedAbbreviations.has(name.toLowerCase())) {
+        return;
+      }
+
+      // Check for unclear/generic names
+      if (unclearNames.has(name.toLowerCase())) {
+        context.report({
+          node,
+          messageId: "unclear",
+          data: { name }
+        });
+        return;
+      }
+
+      // Check for suspicious abbreviation patterns
+      for (const pattern of suspiciousAbbreviations) {
+        if (pattern.test(name)) {
+          context.report({
+            node,
+            messageId: "abbreviation", 
+            data: { name }
+          });
+          return;
+        }
+      }
+    }
+
+    function checkParameter(param) {
+      if (!param) return;
+      
+      if (param.type === 'Identifier') {
+        checkVariableName(param, param.name);
+      } else if (param.type === 'AssignmentPattern' && param.left && param.left.type === 'Identifier') {
+        // Handle default parameters
+        checkVariableName(param.left, param.left.name);
+      } else if (param.type === 'ObjectPattern' && param.properties) {
+        // Handle object destructuring in parameters
+        param.properties.forEach(prop => {
+          if (prop && prop.type === 'Property' && prop.value && prop.value.type === 'Identifier') {
+            checkVariableName(prop.value, prop.value.name);
+          }
+        });
+      } else if (param.type === 'ArrayPattern' && param.elements) {
+        // Handle array destructuring in parameters
+        param.elements.forEach(element => {
+          if (element && element.type === 'Identifier') {
+            checkVariableName(element, element.name);
+          }
+        });
+      }
+    }
+
+    return {
+      VariableDeclarator(node) {
+        if (!node || !node.id) return;
+        
+        if (node.id.type === 'Identifier') {
+          checkVariableName(node.id, node.id.name);
+        } else if (node.id.type === 'ObjectPattern') {
+          // Handle destructuring
+          if (node.id.properties) {
+            node.id.properties.forEach(prop => {
+              if (prop && prop.type === 'Property' && prop.value && prop.value.type === 'Identifier') {
+                checkVariableName(prop.value, prop.value.name);
+              }
+            });
+          }
+        } else if (node.id.type === 'ArrayPattern') {
+          // Handle array destructuring
+          if (node.id.elements) {
+            node.id.elements.forEach(element => {
+              if (element && element.type === 'Identifier') {
+                checkVariableName(element, element.name);
+              }
+            });
+          }
+        }
+      },
+
+      FunctionDeclaration(node) {
+        // Check function parameters
+        if (node && node.params) {
+          node.params.forEach(param => checkParameter(param));
+        }
+      },
+
+      ArrowFunctionExpression(node) {
+        // Check arrow function parameters
+        if (node && node.params) {
+          node.params.forEach(param => checkParameter(param));
+        }
+      },
+
+      FunctionExpression(node) {
+        // Check function expression parameters
+        if (node && node.params) {
+          node.params.forEach(param => checkParameter(param));
+        }
+      },
+
+      CatchClause(node) {
+        // Check catch clause parameters
+        if (node && node.param && node.param.type === 'Identifier') {
+          checkVariableName(node.param, node.param.name);
+        }
+      }
+    };
+  }
+};
+
+module.exports = c003Rule;

package/integrations/eslint/plugin/rules/common/c006-function-name-verb-noun.js

@@ -0,0 +1,216 @@
+/**
+ * Custom ESLint rule for: C006 – Function names must be verbs or verb-noun phrases
+ * Rule ID: custom/c006
+ * Purpose: Enforce function naming convention using verbs or verb-noun phrases to clearly indicate actions
+ */
+
+const c006Rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Function names must be verbs or verb-noun phrases",
+      recommended: false
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowedVerbs: {
+            type: "array",
+            items: { type: "string" },
+            description: "Additional verbs to allow (beyond common ones)"
+          },
+          allowedPrefixes: {
+            type: "array", 
+            items: { type: "string" },
+            description: "Allowed verb prefixes (default: get, set, is, has, can, should, etc.)"
+          },
+          allowConstructors: {
+            type: "boolean",
+            description: "Allow constructor functions (PascalCase) (default: true)"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      notVerbNoun: "Function '{{name}}' should be a verb or verb-noun phrase (e.g., 'getData', 'calculateTotal', 'validateInput').",
+      useVerbForm: "Function '{{name}}' should start with a verb. Consider: '{{suggestions}}'.",
+      avoidNounOnly: "Function '{{name}}' appears to be a noun only. Use verb form like 'get{{name}}', 'create{{name}}', or 'process{{name}}'."
+    }
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    
+    // Common verb prefixes that indicate action
+    const commonVerbPrefixes = new Set([
+      'get', 'set', 'fetch', 'load', 'save', 'store', 'update', 'delete', 'remove',
+      'create', 'make', 'build', 'generate', 'produce', 'construct',
+      'add', 'insert', 'append', 'push', 'pop', 'shift', 'unshift',
+      'find', 'search', 'filter', 'sort', 'map', 'reduce', 'transform',
+      'validate', 'verify', 'check', 'test', 'confirm', 'ensure',
+      'calculate', 'compute', 'process', 'parse', 'format', 'convert',
+      'send', 'receive', 'transmit', 'broadcast', 'emit', 'dispatch',
+      'open', 'close', 'start', 'stop', 'begin', 'end', 'finish',
+      'show', 'hide', 'display', 'render', 'draw', 'paint',
+      'connect', 'disconnect', 'link', 'unlink', 'attach', 'detach',
+      'enable', 'disable', 'activate', 'deactivate', 'toggle',
+      'is', 'has', 'can', 'should', 'will', 'must', 'may', 'does',
+      'handle', 'manage', 'control', 'execute', 'run', 'invoke',
+      'reset', 'clear', 'clean', 'refresh', 'reload', 'restore',
+      
+      // Based on user feedback - missing important verbs
+      'count', 'reopen', 'request', 'use', 'go', 'retry', 'redirect',
+      
+      // Event handler prefixes
+      'on',
+      
+      // Common patterns that should be allowed as verbs
+      'process', // can be both noun and verb - when standalone should be allowed
+    ]);
+
+    const allowedPrefixes = new Set([
+      ...commonVerbPrefixes,
+      ...(options.allowedPrefixes || [])
+    ]);
+
+    const allowedVerbs = new Set([
+      ...commonVerbPrefixes,
+      ...(options.allowedVerbs || [])
+    ]);
+
+    const allowConstructors = options.allowConstructors !== false;
+
+    // Helper function to check if a name is PascalCase (likely a constructor)
+    function isPascalCase(name) {
+      return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+    }
+
+    // Helper function to check if a name is camelCase starting with a verb
+    function isVerbNounPattern(name) {
+      if (!name || name.length === 0) return false;
+      
+      // Check if it starts with a known verb prefix
+      const lowerName = name.toLowerCase();
+      for (const verb of allowedPrefixes) {
+        if (lowerName.startsWith(verb.toLowerCase())) {
+          return true;
+        }
+      }
+      
+      return false;
+    }
+
+    // Generate suggestions for a noun-based function name
+    function generateSuggestions(name) {
+      const suggestions = [
+        `get${name.charAt(0).toUpperCase() + name.slice(1)}`,
+        `create${name.charAt(0).toUpperCase() + name.slice(1)}`,
+        `process${name.charAt(0).toUpperCase() + name.slice(1)}`
+      ];
+      return suggestions.join(', ');
+    }
+
+    // Check if the name appears to be just a noun
+    function isLikelyNounOnly(name) {
+      const nounPatterns = [
+        /^(user|data|info|item|list|array|object|config|settings|options)$/i,
+        /^(file|document|record|entry|element|component|widget)$/i,
+        /^(message|notification|alert|error|warning|success)$/i,
+        /^(report|summary|total|count|number|value|result)$/i
+      ];
+      
+      return nounPatterns.some(pattern => pattern.test(name));
+    }
+
+    function checkFunctionName(node, name) {
+      // Safety checks
+      if (!node || !name || typeof name !== 'string') {
+        return;
+      }
+
+      // Allow constructor functions (PascalCase)
+      if (allowConstructors && isPascalCase(name)) {
+        return;
+      }
+
+      // Skip very short names (likely okay: a, b, fn, etc.)
+      if (name.length <= 2) {
+        return;
+      }
+
+      // Check if it follows verb-noun pattern
+      if (isVerbNounPattern(name)) {
+        return; // Good! Follows the pattern
+      }
+
+      // Check if it's likely a noun-only name
+      if (isLikelyNounOnly(name)) {
+        context.report({
+          node,
+          messageId: "avoidNounOnly",
+          data: { 
+            name,
+            suggestions: generateSuggestions(name)
+          }
+        });
+        return;
+      }
+
+      // General violation - doesn't start with verb
+      context.report({
+        node,
+        messageId: "notVerbNoun",
+        data: { name }
+      });
+    }
+
+    return {
+      FunctionDeclaration(node) {
+        if (node.id && node.id.name) {
+          checkFunctionName(node.id, node.id.name);
+        }
+      },
+
+      FunctionExpression(node) {
+        // Check named function expressions
+        if (node.id && node.id.name) {
+          checkFunctionName(node.id, node.id.name);
+        }
+      },
+
+      ArrowFunctionExpression(node) {
+        // For arrow functions assigned to variables
+        if (node.parent && node.parent.type === 'VariableDeclarator' && node.parent.id) {
+          checkFunctionName(node.parent.id, node.parent.id.name);
+        }
+      },
+
+      MethodDefinition(node) {
+        // Check class methods
+        if (node.key && node.key.name && node.kind === 'method') {
+          // Skip constructor methods
+          if (node.key.name !== 'constructor') {
+            checkFunctionName(node.key, node.key.name);
+          }
+        }
+      },
+
+      Property(node) {
+        // Check object method properties
+        if (node.method && node.key && node.key.name) {
+          checkFunctionName(node.key, node.key.name);
+        }
+        // Check function values assigned to object properties
+        if (!node.method && node.value && 
+            (node.value.type === 'FunctionExpression' || node.value.type === 'ArrowFunctionExpression') &&
+            node.key && node.key.name) {
+          checkFunctionName(node.key, node.key.name);
+        }
+      }
+    };
+  }
+};
+
+module.exports = c006Rule;

package/integrations/eslint/plugin/rules/common/c010-limit-block-nesting.js

@@ -0,0 +1,90 @@
+/**
+ * Custom ESLint rule for: C010 – Không nên có hơn 3 cấp lồng nhau (nested block)
+ * Rule ID: custom/c010
+ * Goal: Limit nested blocks (if/for/while/switch) to maximum 3 levels to improve readability and maintainability
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Không nên có hơn 3 cấp lồng nhau (nested block)",
+      recommended: false
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          maxDepth: {
+            type: "integer",
+            minimum: 1
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      tooDeep: "Block nesting is too deep (level {{depth}}). Maximum allowed is {{maxDepth}} levels."
+    }
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const maxDepth = options.maxDepth || 3;
+    let blockStack = [];
+
+    function enterBlock(node) {
+      blockStack.push(node);
+      const depth = blockStack.length;
+
+      if (depth > maxDepth) {
+        context.report({
+          node,
+          messageId: "tooDeep",
+          data: {
+            depth,
+            maxDepth
+          }
+        });
+      }
+    }
+
+    function exitBlock() {
+      blockStack.pop();
+    }
+
+    return {
+      // Handle if statements
+      IfStatement: enterBlock,
+      'IfStatement:exit': exitBlock,
+      
+      // Handle for loops
+      ForStatement: enterBlock,
+      'ForStatement:exit': exitBlock,
+      
+      ForInStatement: enterBlock,
+      'ForInStatement:exit': exitBlock,
+      
+      ForOfStatement: enterBlock,
+      'ForOfStatement:exit': exitBlock,
+      
+      // Handle while loops
+      WhileStatement: enterBlock,
+      'WhileStatement:exit': exitBlock,
+      
+      DoWhileStatement: enterBlock,
+      'DoWhileStatement:exit': exitBlock,
+      
+      // Handle switch statements
+      SwitchStatement: enterBlock,
+      'SwitchStatement:exit': exitBlock,
+      
+      // Handle try-catch blocks
+      TryStatement: enterBlock,
+      'TryStatement:exit': exitBlock,
+      
+      // Handle with statements (though rarely used)
+      WithStatement: enterBlock,
+      'WithStatement:exit': exitBlock
+    };
+  }
+};

package/integrations/eslint/plugin/rules/common/c013-no-dead-code.js

@@ -0,0 +1,78 @@
+/**
+ * Custom ESLint rule for: C013 – Do not leave dead code commented out
+ * Rule ID: custom/c013
+ * Purpose: Prevent commented-out code from being left in the codebase to maintain cleanliness
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Do not leave dead code commented out",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      deadCode: "Unreachable code detected after return statement. Remove dead code or restructure logic.",
+      commentedCode: "Do not leave dead code commented out. Remove it or use version control to track changes."
+    }
+  },
+  create(context) {
+    function isTerminatingStatement(stmt) {
+      return stmt.type === "ReturnStatement" ||
+             stmt.type === "ThrowStatement" ||
+             stmt.type === "ContinueStatement" ||
+             stmt.type === "BreakStatement";
+    }
+
+    function isExecutableStatement(stmt) {
+      // Exclude declarations and empty statements
+      return stmt.type !== "EmptyStatement" &&
+             stmt.type !== "FunctionDeclaration" &&
+             stmt.type !== "VariableDeclaration" &&
+             !stmt.type.includes("Declaration");
+    }
+
+    function checkBlockForUnreachableCode(node) {
+      let unreachable = false;
+      for (let i = 0; i < node.body.length; i++) {
+        const stmt = node.body[i];
+        
+        if (unreachable && isExecutableStatement(stmt)) {
+          context.report({
+            node: stmt,
+            messageId: "deadCode"
+          });
+        }
+
+        if (isTerminatingStatement(stmt)) {
+          unreachable = true;
+        }
+      }
+    }
+
+    return {
+      // Handle unreachable code in all block statements
+      BlockStatement: checkBlockForUnreachableCode,
+
+      // Handle switch cases
+      SwitchCase(node) {
+        let unreachable = false;
+        for (let i = 0; i < node.consequent.length; i++) {
+          const stmt = node.consequent[i];
+          
+          if (unreachable && isExecutableStatement(stmt)) {
+            context.report({
+              node: stmt,
+              messageId: "deadCode"
+            });
+          }
+
+          if (isTerminatingStatement(stmt)) {
+            unreachable = true;
+          }
+        }
+      }
+    };
+  }
+};

package/integrations/eslint/plugin/rules/common/c014-abstract-dependency-preferred.js

@@ -0,0 +1,38 @@
+/**
+ * Custom ESLint rule for: C014 – Use Dependency Injection instead of direct instantiation
+ * Rule ID: custom/c014
+ * Purpose: Enforce dependency injection pattern by preventing direct class instantiation
+ */
+
+module.exports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Use Dependency Injection instead of direct instantiation",
+      recommended: false
+    },
+    schema: [],
+    messages: {
+      directInstantiation: "Avoid direct class instantiation. Use dependency injection instead."
+    }
+  },
+  create(context) {
+    return {
+      NewExpression(node) {
+        if (
+          node.callee &&
+          node.callee.type === "Identifier" &&
+          /^[A-Z]/.test(node.callee.name) // Class name starts with uppercase
+        ) {
+          context.report({
+            node,
+            messageId: "directInstantiation",
+            data: {
+              name: node.callee.name
+            }
+          });
+        }
+      }
+    };
+  }
+};