eslint-plugin-sonar-config 0.1.1

package/rules/no-index-of-compare-positive.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview indexOf não deve ser comparado com números positivos
+ * Comparar indexOf > 0 ignora o primeiro elemento. Use >= 0 ou includes().
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "indexOf não deve ser comparado com números positivos",
+    },
+    messages: {
+      noPositiveIndexOf:
+        'Comparar indexOf com > 0 ignora o primeiro elemento (índice 0). Use ">= 0" ou ".includes()" ao invés.',
+    },
+  },
+  create(context) {
+    /**
+     * Verifica se o nó é uma chamada de indexOf/lastIndexOf
+     */
+    function isIndexOfCall(node) {
+      if (node.type !== "CallExpression") return false;
+      if (node.callee.type !== "MemberExpression") return false;
+
+      const methodName = node.callee.property.name;
+      return methodName === "indexOf" || methodName === "lastIndexOf";
+    }
+
+    /**
+     * Verifica se é um literal numérico positivo (> 0)
+     */
+    function isPositiveNumber(node) {
+      return (
+        node.type === "Literal" &&
+        typeof node.value === "number" &&
+        node.value > 0
+      );
+    }
+
+    /**
+     * Verifica se é o número 0
+     */
+    function isZero(node) {
+      return (
+        node.type === "Literal" &&
+        typeof node.value === "number" &&
+        node.value === 0
+      );
+    }
+
+    return {
+      BinaryExpression(node) {
+        const { operator, left, right } = node;
+
+        // indexOf(...) > 0 ou indexOf(...) >= 1
+        if (isIndexOfCall(left)) {
+          if (
+            (operator === ">" && isZero(right)) ||
+            (operator === ">=" && isPositiveNumber(right))
+          ) {
+            context.report({
+              node,
+              messageId: "noPositiveIndexOf",
+            });
+          }
+        }
+
+        // 0 < indexOf(...) ou 1 <= indexOf(...)
+        if (isIndexOfCall(right)) {
+          if (
+            (operator === "<" && isZero(left)) ||
+            (operator === "<=" && isPositiveNumber(left))
+          ) {
+            context.report({
+              node,
+              messageId: "noPositiveIndexOf",
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-inverted-boolean-check.js

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview Checks booleanos não devem ser invertidos desnecessariamente
+ * !(a === b) deveria ser a !== b
+ */
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Checks booleanos não devem ser invertidos desnecessariamente",
+    },
+    messages: {
+      invertedCheck:
+        "Negação desnecessária. Use '{{suggestion}}' ao invés de '!({{original}})'.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
+    const opposites = {
+      "===": "!==",
+      "!==": "===",
+      "==": "!=",
+      "!=": "==",
+      "<": ">=",
+      ">": "<=",
+      "<=": ">",
+      ">=": "<",
+    };
+
+    return {
+      UnaryExpression(node) {
+        if (node.operator !== "!") return;
+
+        const arg = node.argument;
+
+        // !(a === b) -> a !== b
+        if (arg.type === "BinaryExpression" && opposites[arg.operator]) {
+          const left = sourceCode.getText(arg.left);
+          const right = sourceCode.getText(arg.right);
+          const original = `${left} ${arg.operator} ${right}`;
+          const suggestion = `${left} ${opposites[arg.operator]} ${right}`;
+
+          context.report({
+            node,
+            messageId: "invertedCheck",
+            data: { original, suggestion },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-label-in-switch.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Switch não deve conter labels que não são case
+ * Misturar labels e cases no switch é confuso e pode ser erro de digitação.
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Switch não deve conter labels que não são case",
+    },
+    messages: {
+      noLabelInSwitch:
+        'Label "{{label}}" dentro do switch é confuso. Use apenas "case" e "default".',
+    },
+  },
+  create(context) {
+    return {
+      SwitchStatement(node) {
+        // Para cada case do switch
+        for (const switchCase of node.cases) {
+          // Verifica os statements dentro do case
+          for (const statement of switchCase.consequent) {
+            checkForLabels(statement, context);
+          }
+        }
+      },
+    };
+
+    function checkForLabels(node, ctx) {
+      if (!node) return;
+
+      // Se é um labeled statement
+      if (node.type === "LabeledStatement") {
+        ctx.report({
+          node,
+          messageId: "noLabelInSwitch",
+          data: { label: node.label.name },
+        });
+      }
+
+      // Verifica statements aninhados em blocos
+      if (node.type === "BlockStatement") {
+        for (const stmt of node.body) {
+          checkForLabels(stmt, ctx);
+        }
+      }
+
+      // Verifica if/else
+      if (node.type === "IfStatement") {
+        checkForLabels(node.consequent, ctx);
+        checkForLabels(node.alternate, ctx);
+      }
+    }
+  },
+};

package/rules/no-misleading-array-mutation.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview Métodos que mutam arrays não devem ser usados de forma enganosa
+ * const reversed = arr.reverse() é problemático pois arr também é mutado
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Métodos que mutam arrays não devem ser usados de forma enganosa",
+    },
+    messages: {
+      misleadingMutation:
+        "O método '{{method}}' muta o array original. Atribuir o resultado a outra variável é enganoso. Use '.slice().{{method}}()' ou '.toSorted()'/'toReversed()'.",
+    },
+  },
+  create(context) {
+    // Métodos que mutam o array E retornam o próprio array
+    // sort é tratado por require-sort-compare, então não incluímos aqui
+    const mutatingMethods = new Set([
+      "reverse",
+      "fill",
+      "copyWithin",
+    ]);
+
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "MemberExpression") return;
+        if (node.callee.property.type !== "Identifier") return;
+
+        const methodName = node.callee.property.name;
+        if (!mutatingMethods.has(methodName)) return;
+
+        const parent = node.parent;
+
+        // Caso: const reversed = arr.reverse() (atribuindo a variável diferente)
+        if (
+          parent.type === "VariableDeclarator" &&
+          parent.init === node &&
+          node.callee.object.type === "Identifier" &&
+          parent.id.type === "Identifier"
+        ) {
+          // Se o nome da variável destino é diferente do array original, é enganoso
+          if (node.callee.object.name !== parent.id.name) {
+            context.report({
+              node,
+              messageId: "misleadingMutation",
+              data: { method: methodName },
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-nested-ternary.js

@@ -0,0 +1,43 @@
+/**
+ * Regra: Proíbe ternários aninhados
+ *
+ * Ternários aninhados tornam o código difícil de ler e manter.
+ * Use if/else ou extraia a lógica para funções separadas.
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Proíbe ternários aninhados",
+    },
+    messages: {
+      nested:
+        "Ternário aninhado encontrado. Evite ternários dentro de ternários.",
+    },
+    schema: [],
+  },
+
+  create(context) {
+    return {
+      ConditionalExpression(node) {
+        const { consequent, alternate } = node;
+
+        if (consequent && consequent.type === "ConditionalExpression") {
+          context.report({
+            node: consequent,
+            messageId: "nested",
+          });
+        }
+
+        if (alternate && alternate.type === "ConditionalExpression") {
+          context.report({
+            node: alternate,
+            messageId: "nested",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-non-numeric-array-index.js

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Índices de arrays devem ser numéricos
+ * arr["foo"] é problemático, deve usar objeto ao invés de array
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Índices de arrays devem ser numéricos",
+    },
+    messages: {
+      nonNumericIndex:
+        "Índice de array deve ser numérico. Use um objeto se precisar de chaves string.",
+    },
+  },
+  create(context) {
+    // Rastreia variáveis que são arrays
+    const arrayVariables = new Set();
+
+    return {
+      // Detecta declarações de array: const arr = [] ou const arr = [1,2,3]
+      VariableDeclarator(node) {
+        if (
+          node.init &&
+          node.init.type === "ArrayExpression" &&
+          node.id.type === "Identifier"
+        ) {
+          arrayVariables.add(node.id.name);
+        }
+      },
+
+      // Detecta acesso com índice não-numérico: arr["foo"] ou arr[variable]
+      MemberExpression(node) {
+        // Só verifica se é computed (arr[x]) e não arr.x
+        if (!node.computed) return;
+
+        // Verifica se o objeto é um array conhecido
+        if (node.object.type !== "Identifier") return;
+        if (!arrayVariables.has(node.object.name)) return;
+
+        const property = node.property;
+
+        // Se é um literal string que não é número
+        if (property.type === "Literal" && typeof property.value === "string") {
+          // Verifica se a string não é um número
+          if (isNaN(Number(property.value))) {
+            context.report({
+              node,
+              messageId: "nonNumericIndex",
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-redundant-boolean-condition.js

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Condições booleanas não devem ser redundantes
+ * if (a) { if (a) { ... } } - o segundo if é redundante
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Condições booleanas não devem ser redundantes dentro de blocos condicionais",
+    },
+    messages: {
+      redundantCondition:
+        "Condição redundante: '{{condition}}' já foi verificada no bloco externo.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
+    function getConditionText(node) {
+      return sourceCode.getText(node);
+    }
+
+    // Coleta todas as condições de um if/else if chain que garantem verdadeiro
+    function collectTruthyConditions(node, conditions = new Set()) {
+      if (!node) return conditions;
+
+      if (node.type === "IfStatement") {
+        conditions.add(getConditionText(node.test));
+      }
+
+      return conditions;
+    }
+
+    // Verifica se uma condição ou parte dela é redundante
+    function isRedundant(testNode, truthyConditions) {
+      const testText = getConditionText(testNode);
+
+      // Verifica se a condição exata já foi verificada
+      if (truthyConditions.has(testText)) {
+        return testText;
+      }
+
+      // Verifica partes de uma expressão &&
+      // Ex: if (a && b) { if (a) } - a é redundante
+      if (testNode.type === "Identifier" || testNode.type === "MemberExpression") {
+        for (const cond of truthyConditions) {
+          // Se a condição externa contém && com esta variável
+          if (cond.includes(testText + " &&") || cond.includes("&& " + testText)) {
+            return testText;
+          }
+        }
+      }
+
+      return null;
+    }
+
+    function checkNestedConditions(node, truthyConditions) {
+      if (!node) return;
+
+      if (node.type === "IfStatement") {
+        const redundant = isRedundant(node.test, truthyConditions);
+        if (redundant) {
+          context.report({
+            node: node.test,
+            messageId: "redundantCondition",
+            data: { condition: redundant },
+          });
+        }
+
+        // Adiciona a condição atual e continua verificando dentro do consequent
+        const newConditions = new Set(truthyConditions);
+        newConditions.add(getConditionText(node.test));
+        checkBlock(node.consequent, newConditions);
+
+        // No else, a condição original é falsa, então não adiciona
+        if (node.alternate) {
+          checkBlock(node.alternate, truthyConditions);
+        }
+      } else if (node.type === "BlockStatement") {
+        checkBlock(node, truthyConditions);
+      }
+    }
+
+    function checkBlock(block, truthyConditions) {
+      if (!block) return;
+
+      if (block.type === "BlockStatement") {
+        for (const stmt of block.body) {
+          checkNestedConditions(stmt, truthyConditions);
+        }
+      } else {
+        checkNestedConditions(block, truthyConditions);
+      }
+    }
+
+    return {
+      IfStatement(node) {
+        // Só processa if's de nível superior (não aninhados)
+        // Os aninhados serão processados recursivamente
+        const parent = node.parent;
+        if (
+          parent.type === "IfStatement" &&
+          (parent.consequent === node || parent.alternate === node)
+        ) {
+          return; // Será processado pelo pai
+        }
+        if (parent.type === "BlockStatement") {
+          const grandparent = parent.parent;
+          if (grandparent && grandparent.type === "IfStatement") {
+            return; // Será processado pelo avô
+          }
+        }
+
+        // Processa este if e seus aninhados
+        const conditions = new Set();
+        conditions.add(getConditionText(node.test));
+        checkBlock(node.consequent, conditions);
+      },
+    };
+  },
+};

package/rules/no-redundant-call-apply.js

@@ -0,0 +1,73 @@
+/**
+ * @fileoverview Chamadas .call() e .apply() não devem ser redundantes
+ * fn.call(undefined, a, b) deveria ser fn(a, b)
+ */
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Chamadas .call() e .apply() não devem ser redundantes",
+    },
+    messages: {
+      redundantCall:
+        "Chamada redundante de '.call()'. Use '{{name}}({{args}})' diretamente.",
+      redundantApply:
+        "Chamada redundante de '.apply()'. Use '{{name}}({{args}})' ou spread operator.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
+    function isNullOrUndefined(node) {
+      if (!node) return true;
+      if (node.type === "Identifier" && node.name === "undefined") return true;
+      if (node.type === "Literal" && node.value === null) return true;
+      return false;
+    }
+
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "MemberExpression") return;
+        if (node.callee.property.type !== "Identifier") return;
+
+        const methodName = node.callee.property.name;
+        const object = node.callee.object;
+
+        // fn.call(undefined, a, b) ou fn.call(null, a, b)
+        if (methodName === "call") {
+          const args = node.arguments;
+
+          // Se o primeiro argumento é undefined/null, é redundante
+          if (args.length === 0 || isNullOrUndefined(args[0])) {
+            // Pega o nome da função
+            let fnName = sourceCode.getText(object);
+            let restArgs = args.slice(1).map(a => sourceCode.getText(a)).join(", ");
+
+            context.report({
+              node,
+              messageId: "redundantCall",
+              data: { name: fnName, args: restArgs },
+            });
+          }
+        }
+
+        // fn.apply(undefined, [a, b]) ou fn.apply(null, [a, b])
+        if (methodName === "apply") {
+          const args = node.arguments;
+
+          // Se o primeiro argumento é undefined/null
+          if (args.length <= 1 || isNullOrUndefined(args[0])) {
+            let fnName = sourceCode.getText(object);
+            let argsText = args[1] ? `...${sourceCode.getText(args[1])}` : "";
+
+            context.report({
+              node,
+              messageId: "redundantApply",
+              data: { name: fnName, args: argsText },
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-this-in-functional-component.js

@@ -0,0 +1,102 @@
+/**
+ * @fileoverview Não usar "this" em componentes funcionais React
+ * Componentes funcionais não têm instância, então "this" não faz sentido.
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: 'Não usar "this" em componentes funcionais React',
+    },
+    messages: {
+      noThisInFunctional:
+        'Não use "this" em componentes funcionais. Use props diretamente ou destructuring.',
+    },
+  },
+  create(context) {
+    // Stack para rastrear funções
+    const functionStack = [];
+
+    /**
+     * Verifica se o nome parece ser um componente React (PascalCase)
+     */
+    function isPascalCase(name) {
+      return name && /^[A-Z]/.test(name);
+    }
+
+    /**
+     * Obtém o nome da função
+     */
+    function getFunctionName(node) {
+      // function Foo() {}
+      if (node.type === "FunctionDeclaration" && node.id) {
+        return node.id.name;
+      }
+
+      // const Foo = function() {} ou const Foo = () => {}
+      if (node.parent.type === "VariableDeclarator" && node.parent.id) {
+        return node.parent.id.name;
+      }
+
+      return null;
+    }
+
+    function enterFunction(node) {
+      const name = getFunctionName(node);
+      functionStack.push({
+        node,
+        name,
+        isPascalCase: isPascalCase(name),
+        isClassMethod: false,
+      });
+    }
+
+    function exitFunction() {
+      functionStack.pop();
+    }
+
+    return {
+      // Entra em uma função
+      FunctionDeclaration: enterFunction,
+      FunctionExpression: enterFunction,
+      ArrowFunctionExpression: enterFunction,
+
+      // Sai da função
+      "FunctionDeclaration:exit": exitFunction,
+      "FunctionExpression:exit": exitFunction,
+      "ArrowFunctionExpression:exit": exitFunction,
+
+      // Entra em um método de classe
+      MethodDefinition() {
+        functionStack.push({
+          node: null,
+          name: null,
+          isPascalCase: false,
+          isClassMethod: true,
+        });
+      },
+
+      "MethodDefinition:exit"() {
+        functionStack.pop();
+      },
+
+      // Verifica uso de this
+      ThisExpression(node) {
+        if (functionStack.length === 0) return;
+
+        const current = functionStack[functionStack.length - 1];
+
+        // Se estamos em um método de classe, this é permitido
+        if (current.isClassMethod) return;
+
+        // Se estamos em uma função com nome PascalCase (provável componente), this é erro
+        if (current.isPascalCase) {
+          context.report({
+            node,
+            messageId: "noThisInFunctional",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-unsafe-window-open.js

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview window.open() deve usar 'noopener' para segurança
+ * Sem noopener, a janela aberta pode acessar window.opener
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "window.open() deve incluir 'noopener' nas features",
+    },
+    messages: {
+      missingNoopener:
+        "window.open() deve incluir 'noopener' no terceiro argumento para prevenir acesso via window.opener.",
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        // Verifica se é window.open()
+        if (
+          node.callee.type === "MemberExpression" &&
+          node.callee.object.name === "window" &&
+          node.callee.property.name === "open"
+        ) {
+          const args = node.arguments;
+
+          // Se não tem terceiro argumento (features), é problema
+          if (args.length < 3) {
+            context.report({
+              node,
+              messageId: "missingNoopener",
+            });
+            return;
+          }
+
+          // Se tem terceiro argumento, verifica se inclui noopener
+          const featuresArg = args[2];
+          if (
+            featuresArg.type === "Literal" &&
+            typeof featuresArg.value === "string"
+          ) {
+            if (!featuresArg.value.includes("noopener")) {
+              context.report({
+                node,
+                messageId: "missingNoopener",
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};