eslint-plugin-sonar-config 0.1.1

package/rules/prefer-for-of.js

@@ -0,0 +1,119 @@
+/**
+ * @fileoverview Preferir for...of ao invés de for tradicional com índice
+ * Quando o índice é usado apenas para acessar elementos do array, for...of é mais legível.
+ */
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Preferir for...of ao invés de for tradicional com índice",
+    },
+    messages: {
+      preferForOf:
+        "Use for...of ao invés de for com índice para iterar arrays. É mais legível.",
+    },
+  },
+  create(context) {
+    return {
+      ForStatement(node) {
+        // Verifica se tem inicialização com let i = 0
+        const init = node.init;
+        if (!init || init.type !== "VariableDeclaration") return;
+        if (init.declarations.length !== 1) return;
+
+        const declaration = init.declarations[0];
+        if (declaration.id.type !== "Identifier") return;
+
+        const counterName = declaration.id.name;
+
+        // Verifica se inicializa com 0
+        if (
+          !declaration.init ||
+          declaration.init.type !== "Literal" ||
+          declaration.init.value !== 0
+        ) {
+          return;
+        }
+
+        // Verifica se a condição é i < arr.length
+        const test = node.test;
+        if (!test || test.type !== "BinaryExpression") return;
+        if (test.operator !== "<" && test.operator !== "<=") return;
+
+        // Lado esquerdo deve ser o contador
+        if (test.left.type !== "Identifier" || test.left.name !== counterName) {
+          return;
+        }
+
+        // Lado direito deve ser .length
+        if (
+          test.right.type !== "MemberExpression" ||
+          test.right.property.type !== "Identifier" ||
+          test.right.property.name !== "length"
+        ) {
+          return;
+        }
+
+        const arrayName =
+          test.right.object.type === "Identifier"
+            ? test.right.object.name
+            : null;
+
+        if (!arrayName) return;
+
+        // Verifica se o update é i++ ou i += 1
+        const update = node.update;
+        if (!update) return;
+
+        let isSimpleIncrement = false;
+        if (
+          update.type === "UpdateExpression" &&
+          update.operator === "++" &&
+          update.argument.type === "Identifier" &&
+          update.argument.name === counterName
+        ) {
+          isSimpleIncrement = true;
+        } else if (
+          update.type === "AssignmentExpression" &&
+          update.operator === "+=" &&
+          update.left.type === "Identifier" &&
+          update.left.name === counterName &&
+          update.right.type === "Literal" &&
+          update.right.value === 1
+        ) {
+          isSimpleIncrement = true;
+        }
+
+        if (!isSimpleIncrement) return;
+
+        // Verifica se o corpo usa apenas arr[i] para ler valores
+        // e não usa o índice i diretamente para outras coisas
+        const body = node.body;
+        const sourceCode = context.getSourceCode();
+        const bodyText = sourceCode.getText(body);
+
+        // Conta usos do índice
+        const indexPattern = new RegExp(`\\b${counterName}\\b`, "g");
+        const indexMatches = bodyText.match(indexPattern) || [];
+
+        // Conta usos como arr[i]
+        const arrayAccessPattern = new RegExp(
+          `\\b${arrayName}\\s*\\[\\s*${counterName}\\s*\\]`,
+          "g"
+        );
+        const arrayAccessMatches = bodyText.match(arrayAccessPattern) || [];
+
+        // Se o índice é usado apenas para acessar o array, sugere for...of
+        if (
+          indexMatches.length > 0 &&
+          indexMatches.length === arrayAccessMatches.length
+        ) {
+          context.report({
+            node,
+            messageId: "preferForOf",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/prefer-regex-exec.js

@@ -0,0 +1,72 @@
+/**
+ * @fileoverview Preferir RegExp.exec() ao invés de String.match()
+ * RegExp.exec() é mais rápido e produz o mesmo resultado quando não há flag 'g'.
+ */
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Preferir RegExp.exec() ao invés de String.match()",
+    },
+    messages: {
+      preferRegexExec:
+        "Use regex.exec(string) ao invés de string.match(regex). É mais performático.",
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        // Verifica se é uma chamada de .match()
+        if (node.callee.type !== "MemberExpression") return;
+        if (node.callee.property.type !== "Identifier") return;
+        if (node.callee.property.name !== "match") return;
+
+        // Verifica se tem exatamente 1 argumento
+        if (node.arguments.length !== 1) return;
+
+        const arg = node.arguments[0];
+
+        // Se o argumento é um regex literal
+        if (arg.type === "Literal" && arg.regex) {
+          // Se não tem flag 'g', pode usar exec()
+          if (!arg.regex.flags.includes("g")) {
+            context.report({
+              node,
+              messageId: "preferRegexExec",
+            });
+          }
+          return;
+        }
+
+        // Se o argumento é new RegExp()
+        if (
+          arg.type === "NewExpression" &&
+          arg.callee.type === "Identifier" &&
+          arg.callee.name === "RegExp"
+        ) {
+          // Verifica se as flags não contêm 'g'
+          if (arg.arguments.length < 2) {
+            // Sem flags, pode usar exec()
+            context.report({
+              node,
+              messageId: "preferRegexExec",
+            });
+            return;
+          }
+
+          const flagsArg = arg.arguments[1];
+          if (
+            flagsArg.type === "Literal" &&
+            typeof flagsArg.value === "string" &&
+            !flagsArg.value.includes("g")
+          ) {
+            context.report({
+              node,
+              messageId: "preferRegexExec",
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/prefer-while.js

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Use "while" ao invés de "for" quando não há init e update
+ * for (; condition; ) {} → while (condition) {}
+ */
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: 'Use "while" ao invés de "for" quando não há inicialização e incremento',
+    },
+    messages: {
+      preferWhile: 'Use "while" ao invés de "for" quando não há inicialização e incremento.',
+    },
+  },
+  create(context) {
+    return {
+      ForStatement(node) {
+        // Se não tem init E não tem update, deveria ser while
+        if (!node.init && !node.update) {
+          context.report({
+            node,
+            messageId: "preferWhile",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/regex-anchor-with-alternation.js

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview Alternativas em regex devem ser agrupadas quando usadas com anchors (^ ou $)
+ * /^a|b/ deveria ser /^(a|b)/ ou /^a|^b/
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Alternativas em regex devem ser agrupadas quando usadas com anchors",
+    },
+    messages: {
+      anchorWithAlternation:
+        "Anchor (^ ou $) com alternativas não agrupadas. Use /^(a|b)/ ao invés de /^a|b/.",
+    },
+  },
+  create(context) {
+    function checkRegexPattern(pattern, node) {
+      // Ignora se não tem alternação
+      if (!pattern.includes("|")) return false;
+
+      // Ignora se já está todo dentro de um grupo: ^(...|...)$
+      if (/^\^?\([^)]+\)\$?$/.test(pattern)) return false;
+
+      // Verifica se tem ^ no início sem agrupar todas as alternativas
+      // /^a|b/ é problemático, mas /^a|^b/ é ok
+      if (pattern.startsWith("^")) {
+        // Divide por | no nível raiz (não dentro de grupos)
+        const alternatives = splitByPipe(pattern.slice(1));
+
+        // Se tem mais de uma alternativa e nem todas começam com ^
+        if (alternatives.length > 1) {
+          const allHaveStart = alternatives.every(alt => alt.startsWith("^") || alternatives.indexOf(alt) === 0);
+          if (!allHaveStart) {
+            // Verifica se a primeira alternativa termina antes do |
+            // e a segunda não tem ^ próprio
+            const secondAlt = alternatives[1];
+            if (secondAlt && !secondAlt.startsWith("^")) {
+              return true;
+            }
+          }
+        }
+      }
+
+      // Verifica se tem $ no final sem agrupar todas as alternativas
+      // /a|b$/ é problemático, mas /a$|b$/ é ok
+      if (pattern.endsWith("$") && !pattern.endsWith("\\$")) {
+        const alternatives = splitByPipe(pattern.slice(0, -1));
+
+        if (alternatives.length > 1) {
+          const allHaveEnd = alternatives.every(alt => alt.endsWith("$") || alternatives.indexOf(alt) === alternatives.length - 1);
+          if (!allHaveEnd) {
+            const secondToLast = alternatives[alternatives.length - 2];
+            if (secondToLast && !secondToLast.endsWith("$")) {
+              return true;
+            }
+          }
+        }
+      }
+
+      return false;
+    }
+
+    // Divide string por | mas não dentro de grupos () ou []
+    function splitByPipe(str) {
+      const result = [];
+      let current = "";
+      let parenDepth = 0;
+      let bracketDepth = 0;
+
+      for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        const prevChar = i > 0 ? str[i - 1] : "";
+
+        if (prevChar === "\\") {
+          current += char;
+          continue;
+        }
+
+        if (char === "(") parenDepth++;
+        else if (char === ")") parenDepth--;
+        else if (char === "[") bracketDepth++;
+        else if (char === "]") bracketDepth--;
+        else if (char === "|" && parenDepth === 0 && bracketDepth === 0) {
+          result.push(current);
+          current = "";
+          continue;
+        }
+
+        current += char;
+      }
+
+      if (current) result.push(current);
+      return result;
+    }
+
+    return {
+      Literal(node) {
+        if (node.regex) {
+          if (checkRegexPattern(node.regex.pattern, node)) {
+            context.report({
+              node,
+              messageId: "anchorWithAlternation",
+            });
+          }
+        }
+      },
+
+      NewExpression(node) {
+        if (
+          node.callee.name === "RegExp" &&
+          node.arguments.length > 0 &&
+          node.arguments[0].type === "Literal" &&
+          typeof node.arguments[0].value === "string"
+        ) {
+          if (checkRegexPattern(node.arguments[0].value, node)) {
+            context.report({
+              node,
+              messageId: "anchorWithAlternation",
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/require-reduce-initial-value.js

@@ -0,0 +1,43 @@
+/**
+ * Regra: Array.reduce() deve incluir um valor inicial
+ *
+ * Sonar: javascript:S6959
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Array.reduce() e Array.reduceRight() devem ter um valor inicial",
+    },
+    messages: {
+      requireInitialValue:
+        '"{{method}}" deve ter um valor inicial para evitar TypeError em arrays vazios.',
+    },
+  },
+
+  create(context) {
+    return {
+      CallExpression(node) {
+        // Verifica se é uma chamada de método
+        if (node.callee.type !== "MemberExpression") return;
+
+        const methodName = node.callee.property.name;
+
+        // Verifica se é .reduce() ou .reduceRight()
+        if (methodName !== "reduce" && methodName !== "reduceRight") return;
+
+        // Verifica se tem apenas 1 argumento (callback sem valor inicial)
+        if (node.arguments.length === 1) {
+          context.report({
+            node,
+            messageId: "requireInitialValue",
+            data: { method: methodName },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/require-sort-compare.js

@@ -0,0 +1,43 @@
+/**
+ * Regra: Array.sort() e Array.toSorted() devem usar função de comparação
+ *
+ * Sonar: javascript:S2871
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Array.sort() e Array.toSorted() devem ter uma função de comparação",
+    },
+    messages: {
+      requireCompare:
+        'Forneça uma função de comparação para "{{method}}". Sem ela, a ordenação é lexicográfica (ex: [1, 10, 2] em vez de [1, 2, 10]).',
+    },
+  },
+
+  create(context) {
+    return {
+      CallExpression(node) {
+        // Verifica se é uma chamada de método
+        if (node.callee.type !== "MemberExpression") return;
+
+        const methodName = node.callee.property.name;
+
+        // Verifica se é .sort() ou .toSorted()
+        if (methodName !== "sort" && methodName !== "toSorted") return;
+
+        // Verifica se não tem argumentos (sem função de comparação)
+        if (node.arguments.length === 0) {
+          context.report({
+            node,
+            messageId: "requireCompare",
+            data: { method: methodName },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/use-state-callback.js

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview useState setter deve usar callback quando referencia o estado anterior
+ * Evita bugs de state stale devido ao batching do React.
+ */
+
+/**
+ * Verifica recursivamente se um nó contém uma referência ao identificador
+ */
+function containsIdentifier(node, name) {
+  if (!node) return false;
+
+  if (node.type === "Identifier" && node.name === name) {
+    return true;
+  }
+
+  // Verifica todos os filhos do nó
+  for (const key of Object.keys(node)) {
+    if (key === "parent" || key === "range" || key === "loc") continue;
+
+    const child = node[key];
+
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (item && typeof item === "object" && containsIdentifier(item, name)) {
+          return true;
+        }
+      }
+    } else if (child && typeof child === "object" && child.type) {
+      if (containsIdentifier(child, name)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "useState setter deve usar callback quando referencia o estado anterior",
+    },
+    messages: {
+      useCallback:
+        'Use callback no setter: "{{setter}}(prev => ...)" ao invés de referenciar "{{state}}" diretamente.',
+    },
+  },
+  create(context) {
+    // Map de setters para seus estados: { setCount: "count", setName: "name" }
+    const setterToState = new Map();
+
+    return {
+      // Detecta: const [count, setCount] = useState(...)
+      VariableDeclarator(node) {
+        if (node.id.type !== "ArrayPattern") return;
+        if (node.id.elements.length !== 2) return;
+
+        const init = node.init;
+        if (!init) return;
+
+        // Verifica se é useState()
+        const isUseState =
+          (init.type === "CallExpression" &&
+            init.callee.type === "Identifier" &&
+            init.callee.name === "useState") ||
+          (init.type === "CallExpression" &&
+            init.callee.type === "MemberExpression" &&
+            init.callee.property.name === "useState");
+
+        if (!isUseState) return;
+
+        const stateElement = node.id.elements[0];
+        const setterElement = node.id.elements[1];
+
+        if (
+          stateElement &&
+          stateElement.type === "Identifier" &&
+          setterElement &&
+          setterElement.type === "Identifier"
+        ) {
+          setterToState.set(setterElement.name, stateElement.name);
+        }
+      },
+
+      // Detecta: setCount(count + 1) ao invés de setCount(prev => prev + 1)
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier") return;
+
+        const setterName = node.callee.name;
+        const stateName = setterToState.get(setterName);
+
+        if (!stateName) return;
+        if (node.arguments.length !== 1) return;
+
+        const arg = node.arguments[0];
+
+        // Se já é uma função callback, está OK
+        if (
+          arg.type === "ArrowFunctionExpression" ||
+          arg.type === "FunctionExpression"
+        ) {
+          return;
+        }
+
+        // Verifica se o argumento referencia o estado
+        if (containsIdentifier(arg, stateName)) {
+          context.report({
+            node,
+            messageId: "useCallback",
+            data: {
+              setter: setterName,
+              state: stateName,
+            },
+          });
+        }
+      },
+    };
+  },
+};