eslint-plugin-sonar-config 0.1.1

package/rules/no-constant-binary-expression.js

@@ -0,0 +1,166 @@
+/**
+ * @fileoverview Expressões que sempre retornam o mesmo valor
+ * Cobre: a < a, true && x, x === new Object(), if ({})
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Expressões não devem sempre retornar o mesmo valor",
+    },
+    messages: {
+      alwaysSame:
+        "Esta expressão sempre retorna o mesmo valor ({{result}}).",
+      compareNewObject:
+        "Comparação com novo objeto sempre retorna {{result}}. Objetos são comparados por referência.",
+      constantLogical:
+        "Expressão lógica com '{{value}}' sempre {{behavior}}.",
+      alwaysTruthy:
+        "{{type}} são sempre truthy em condições.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
+    function getNodeText(node) {
+      return sourceCode.getText(node);
+    }
+
+    function areNodesEqual(left, right) {
+      return getNodeText(left) === getNodeText(right);
+    }
+
+    function isNewExpression(node) {
+      return node.type === "NewExpression";
+    }
+
+    function isLiteralBoolean(node, value) {
+      return node.type === "Literal" && node.value === value;
+    }
+
+    function isAlwaysTruthyObject(node) {
+      return (
+        node.type === "ObjectExpression" ||
+        node.type === "ArrayExpression" ||
+        node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionExpression"
+      );
+    }
+
+    return {
+      // Comparações consigo mesmo: a < a, a === a
+      BinaryExpression(node) {
+        const operator = node.operator;
+
+        // Comparação com new Object() - sempre false para ===, true para !==
+        if (
+          (operator === "===" || operator === "==" || operator === "!==" || operator === "!=") &&
+          (isNewExpression(node.left) || isNewExpression(node.right))
+        ) {
+          const result = operator === "!==" || operator === "!=" ? "true" : "false";
+          context.report({
+            node,
+            messageId: "compareNewObject",
+            data: { result },
+          });
+          return;
+        }
+
+        // Comparações consigo mesmo
+        if (!areNodesEqual(node.left, node.right)) return;
+
+        let result = null;
+
+        if (operator === "<" || operator === ">") {
+          result = "false";
+        } else if (operator === "<=" || operator === ">=" || operator === "===" || operator === "==") {
+          result = "true";
+        } else if (operator === "!==" || operator === "!=") {
+          result = "false";
+        } else if (operator === "-") {
+          result = "0";
+        } else if (operator === "/") {
+          result = "1";
+        } else if (operator === "%") {
+          result = "0";
+        } else if (operator === "^") {
+          result = "0";
+        }
+
+        if (result !== null) {
+          context.report({
+            node,
+            messageId: "alwaysSame",
+            data: { result },
+          });
+        }
+      },
+
+      // Logical expressions: true && x, false || x
+      LogicalExpression(node) {
+        const operator = node.operator;
+
+        // true && x -> sempre executa x (redundante)
+        // false && x -> nunca executa x
+        // true || x -> nunca executa x
+        // false || x -> sempre executa x (redundante)
+        if (operator === "&&") {
+          if (isLiteralBoolean(node.left, true)) {
+            context.report({
+              node,
+              messageId: "constantLogical",
+              data: { value: "true", behavior: "executa o lado direito (redundante)" },
+            });
+          } else if (isLiteralBoolean(node.left, false)) {
+            context.report({
+              node,
+              messageId: "constantLogical",
+              data: { value: "false", behavior: "retorna false (lado direito nunca executa)" },
+            });
+          }
+        } else if (operator === "||") {
+          if (isLiteralBoolean(node.left, true)) {
+            context.report({
+              node,
+              messageId: "constantLogical",
+              data: { value: "true", behavior: "retorna true (lado direito nunca executa)" },
+            });
+          } else if (isLiteralBoolean(node.left, false)) {
+            context.report({
+              node,
+              messageId: "constantLogical",
+              data: { value: "false", behavior: "executa o lado direito (redundante)" },
+            });
+          }
+        }
+      },
+
+      // if ({}) - objetos/arrays/funções são sempre truthy
+      IfStatement(node) {
+        if (isAlwaysTruthyObject(node.test)) {
+          const type = node.test.type === "ObjectExpression" ? "Objetos {}"
+            : node.test.type === "ArrayExpression" ? "Arrays []"
+            : "Funções";
+          context.report({
+            node: node.test,
+            messageId: "alwaysTruthy",
+            data: { type },
+          });
+        }
+      },
+
+      ConditionalExpression(node) {
+        if (isAlwaysTruthyObject(node.test)) {
+          const type = node.test.type === "ObjectExpression" ? "Objetos {}"
+            : node.test.type === "ArrayExpression" ? "Arrays []"
+            : "Funções";
+          context.report({
+            node: node.test,
+            messageId: "alwaysTruthy",
+            data: { type },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-empty-regex-alternatives.js

@@ -0,0 +1,102 @@
+/**
+ * @fileoverview Alternativas em regex não devem ser vazias
+ * /a|/ ou /|a/ ou /a||b/ são problemáticos
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Alternativas em regex não devem ser vazias",
+    },
+    messages: {
+      emptyAlternative:
+        "Regex contém alternativa vazia. Remova o '|' desnecessário ou adicione um padrão.",
+    },
+  },
+  create(context) {
+    function checkRegexPattern(pattern, node) {
+      // Verifica se tem || (alternativa vazia no meio)
+      if (pattern.includes("||")) {
+        return true;
+      }
+
+      // Divide por | e verifica se alguma parte é vazia
+      // Mas precisa ignorar | dentro de grupos [] ou escapados
+      let depth = 0;
+      let inCharClass = false;
+      let lastWasPipe = false;
+      let isFirstChar = true;
+
+      for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        const prevChar = i > 0 ? pattern[i - 1] : "";
+
+        // Ignora caracteres escapados
+        if (prevChar === "\\") {
+          isFirstChar = false;
+          lastWasPipe = false;
+          continue;
+        }
+
+        if (char === "[") {
+          inCharClass = true;
+        } else if (char === "]" && inCharClass) {
+          inCharClass = false;
+        } else if (char === "(" && !inCharClass) {
+          depth++;
+        } else if (char === ")" && !inCharClass) {
+          depth--;
+        } else if (char === "|" && !inCharClass) {
+          // | no início ou depois de outro | é alternativa vazia
+          if (isFirstChar || lastWasPipe) {
+            return true;
+          }
+          lastWasPipe = true;
+          isFirstChar = false;
+          continue;
+        }
+
+        isFirstChar = false;
+        lastWasPipe = false;
+      }
+
+      // | no final é alternativa vazia
+      if (lastWasPipe) {
+        return true;
+      }
+
+      return false;
+    }
+
+    return {
+      // Regex literal: /pattern/
+      Literal(node) {
+        if (node.regex) {
+          if (checkRegexPattern(node.regex.pattern, node)) {
+            context.report({
+              node,
+              messageId: "emptyAlternative",
+            });
+          }
+        }
+      },
+
+      // new RegExp("pattern")
+      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: "emptyAlternative",
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-example-rule.js

@@ -0,0 +1,56 @@
+/**
+ * Exemplo de regra ESLint customizada
+ *
+ * Esta regra proíbe o uso de console.log com a string "DEBUG"
+ * É apenas um exemplo para você entender a estrutura.
+ *
+ * Documentação: https://eslint.org/docs/latest/extend/custom-rules
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "suggestion", // "problem" | "suggestion" | "layout"
+    docs: {
+      description: "Proíbe console.log com DEBUG (regra de exemplo)",
+      recommended: false,
+    },
+    fixable: null, // "code" se tiver auto-fix, null se não
+    schema: [], // opções da regra (deixe vazio se não tiver)
+    messages: {
+      noDebugLog: 'Não use console.log com "DEBUG". Remova antes de commitar.',
+    },
+  },
+
+  create(context) {
+    return {
+      // Visitor pattern - visita cada nó da AST
+      // Veja os tipos de nós em: https://astexplorer.net/
+
+      CallExpression(node) {
+        // Verifica se é console.log
+        const isConsoleLog =
+          node.callee.type === "MemberExpression" &&
+          node.callee.object.name === "console" &&
+          node.callee.property.name === "log";
+
+        if (!isConsoleLog) return;
+
+        // Verifica se algum argumento contém "DEBUG"
+        const hasDebug = node.arguments.some(
+          (arg) =>
+            arg.type === "Literal" &&
+            typeof arg.value === "string" &&
+            arg.value.includes("DEBUG")
+        );
+
+        if (hasDebug) {
+          context.report({
+            node,
+            messageId: "noDebugLog",
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-gratuitous-boolean.js

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Expressões booleanas não devem ser gratuitas
+ * Cobre: a === true, a ? true : false, !a ? false : true
+ */
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Expressões booleanas não devem ser gratuitas ou redundantes",
+    },
+    messages: {
+      comparisonWithBoolean:
+        "Comparação desnecessária com '{{value}}'. Use {{suggestion}}.",
+      ternaryBoolean:
+        "Ternário redundante retornando booleanos. Use '{{suggestion}}'.",
+      doubleNegation:
+        "Dupla negação desnecessária. Use '{{suggestion}}'.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
+    function getNodeText(node) {
+      return sourceCode.getText(node);
+    }
+
+    return {
+      // a === true, a === false, a !== true, a !== false
+      BinaryExpression(node) {
+        const { operator, left, right } = node;
+
+        if (!["===", "==", "!==", "!="].includes(operator)) return;
+
+        let booleanSide = null;
+        let otherSide = null;
+
+        if (left.type === "Literal" && typeof left.value === "boolean") {
+          booleanSide = left;
+          otherSide = right;
+        } else if (right.type === "Literal" && typeof right.value === "boolean") {
+          booleanSide = right;
+          otherSide = left;
+        }
+
+        if (!booleanSide) return;
+
+        const boolValue = booleanSide.value;
+        const isEquality = operator === "===" || operator === "==";
+        const otherText = getNodeText(otherSide);
+
+        let suggestion;
+        if (boolValue === true) {
+          suggestion = isEquality ? otherText : `!${otherText}`;
+        } else {
+          suggestion = isEquality ? `!${otherText}` : otherText;
+        }
+
+        context.report({
+          node,
+          messageId: "comparisonWithBoolean",
+          data: { value: String(boolValue), suggestion },
+        });
+      },
+
+      // a ? true : false, a ? false : true
+      ConditionalExpression(node) {
+        const { consequent, alternate, test } = node;
+
+        // Verifica se consequent e alternate são literais booleanos
+        if (
+          consequent.type !== "Literal" ||
+          alternate.type !== "Literal" ||
+          typeof consequent.value !== "boolean" ||
+          typeof alternate.value !== "boolean"
+        ) {
+          return;
+        }
+
+        const testText = getNodeText(test);
+        let suggestion;
+
+        if (consequent.value === true && alternate.value === false) {
+          // a ? true : false -> !!a ou apenas a (se já é boolean)
+          suggestion = `!!${testText}`;
+        } else if (consequent.value === false && alternate.value === true) {
+          // a ? false : true -> !a
+          suggestion = `!${testText}`;
+        } else {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "ternaryBoolean",
+          data: { suggestion },
+        });
+      },
+
+      // !!a quando a já é boolean (verificação básica para !! em literais)
+      UnaryExpression(node) {
+        if (node.operator !== "!") return;
+
+        const arg = node.argument;
+
+        // !!true, !!false
+        if (
+          arg.type === "UnaryExpression" &&
+          arg.operator === "!" &&
+          arg.argument.type === "Literal" &&
+          typeof arg.argument.value === "boolean"
+        ) {
+          context.report({
+            node,
+            messageId: "doubleNegation",
+            data: { suggestion: String(arg.argument.value) },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-identical-branches.js

@@ -0,0 +1,93 @@
+/**
+ * @fileoverview Branches de if/else/ternário/switch não devem ter implementações idênticas
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Branches não devem ter implementações idênticas",
+    },
+    messages: {
+      identicalIfBranches:
+        "Todos os branches do if/else têm a mesma implementação. Remova a condição ou diferencie os branches.",
+      identicalTernary:
+        "Os dois lados do ternário são idênticos. Use o valor diretamente.",
+      identicalSwitchCases:
+        "Todos os cases do switch têm a mesma implementação. Remova o switch ou diferencie os cases.",
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode();
+
+    function getNodeText(node) {
+      if (!node) return "";
+      return sourceCode.getText(node);
+    }
+
+    // Verifica if/else
+    function checkIfStatement(node) {
+      // Precisa ter else para comparar (sem else não é erro conforme exceção)
+      if (!node.alternate) return;
+
+      const consequentText = getNodeText(node.consequent);
+      const alternateText = getNodeText(node.alternate);
+
+      if (consequentText === alternateText) {
+        context.report({
+          node,
+          messageId: "identicalIfBranches",
+        });
+      }
+    }
+
+    // Verifica ternário: condition ? a : a
+    function checkConditionalExpression(node) {
+      const consequentText = getNodeText(node.consequent);
+      const alternateText = getNodeText(node.alternate);
+
+      if (consequentText === alternateText) {
+        context.report({
+          node,
+          messageId: "identicalTernary",
+        });
+      }
+    }
+
+    // Verifica switch com todos os cases iguais
+    function checkSwitchStatement(node) {
+      const cases = node.cases;
+
+      // Precisa ter default para ser erro (conforme exceção)
+      const hasDefault = cases.some((c) => c.test === null);
+      if (!hasDefault) return;
+
+      // Precisa ter pelo menos 2 cases
+      if (cases.length < 2) return;
+
+      // Extrai o código de cada case (sem o break no final)
+      const caseTexts = cases.map((caseNode) => {
+        const statements = caseNode.consequent.filter(
+          (stmt) => stmt.type !== "BreakStatement"
+        );
+        return statements.map((s) => getNodeText(s)).join("\n");
+      });
+
+      // Verifica se todos são idênticos
+      const firstCase = caseTexts[0];
+      const allIdentical = caseTexts.every((text) => text === firstCase);
+
+      if (allIdentical && firstCase !== "") {
+        context.report({
+          node,
+          messageId: "identicalSwitchCases",
+        });
+      }
+    }
+
+    return {
+      IfStatement: checkIfStatement,
+      ConditionalExpression: checkConditionalExpression,
+      SwitchStatement: checkSwitchStatement,
+    };
+  },
+};

package/rules/no-in-array.js

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview Não usar operador "in" em arrays
+ * O operador "in" verifica propriedades do objeto, não índices do array.
+ * Use includes(), indexOf() ou hasOwnProperty() para arrays.
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: 'Não usar operador "in" em arrays',
+    },
+    messages: {
+      noInArray:
+        'Não use o operador "in" em arrays. Use includes(), indexOf() ou um loop for-of.',
+    },
+  },
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        if (node.operator !== "in") return;
+
+        const right = node.right;
+
+        // Detecta array literal: x in [1, 2, 3]
+        if (right.type === "ArrayExpression") {
+          context.report({
+            node,
+            messageId: "noInArray",
+          });
+          return;
+        }
+
+        // Detecta identificadores com nomes comuns de array
+        if (right.type === "Identifier") {
+          const name = right.name.toLowerCase();
+          // Heurística: nomes que terminam com 's', 'list', 'array', 'items', etc.
+          if (
+            name.endsWith("s") ||
+            name.endsWith("list") ||
+            name.endsWith("array") ||
+            name.endsWith("items") ||
+            name.endsWith("arr") ||
+            name === "arr"
+          ) {
+            context.report({
+              node,
+              messageId: "noInArray",
+            });
+          }
+        }
+
+        // Detecta chamadas que retornam arrays: x in arr.filter() ou x in Object.keys()
+        if (right.type === "CallExpression") {
+          const callee = right.callee;
+
+          // Métodos de array que retornam arrays
+          if (callee.type === "MemberExpression" && callee.property) {
+            const methodName = callee.property.name;
+            const arrayMethods = [
+              "filter",
+              "map",
+              "slice",
+              "concat",
+              "flat",
+              "flatMap",
+              "reverse",
+              "sort",
+              "splice",
+              "from",
+              "of",
+            ];
+            if (arrayMethods.includes(methodName)) {
+              context.report({
+                node,
+                messageId: "noInArray",
+              });
+              return;
+            }
+          }
+
+          // Object.keys(), Object.values(), Object.entries(), Array.from()
+          if (
+            callee.type === "MemberExpression" &&
+            callee.object.type === "Identifier"
+          ) {
+            const objName = callee.object.name;
+            const methodName = callee.property.name;
+            if (
+              (objName === "Object" &&
+                ["keys", "values", "entries"].includes(methodName)) ||
+              (objName === "Array" && ["from", "of"].includes(methodName))
+            ) {
+              context.report({
+                node,
+                messageId: "noInArray",
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-in-with-primitives.js

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Não usar operador "in" com tipos primitivos
+ * O operador "in" com primitivos (string, number, boolean) causa TypeError.
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: 'Não usar operador "in" com tipos primitivos',
+    },
+    messages: {
+      noInWithPrimitive:
+        'O operador "in" com tipo primitivo ({{type}}) causa TypeError. Use o objeto equivalente (new String(), etc.) se necessário.',
+    },
+  },
+  create(context) {
+    return {
+      BinaryExpression(node) {
+        if (node.operator !== "in") return;
+
+        const right = node.right;
+
+        // Detecta literais primitivos
+        if (right.type === "Literal") {
+          const value = right.value;
+          let primitiveType = null;
+
+          if (typeof value === "string") {
+            primitiveType = "string";
+          } else if (typeof value === "number") {
+            primitiveType = "number";
+          } else if (typeof value === "boolean") {
+            primitiveType = "boolean";
+          }
+
+          if (primitiveType) {
+            context.report({
+              node,
+              messageId: "noInWithPrimitive",
+              data: { type: primitiveType },
+            });
+          }
+        }
+
+        // Detecta template literals
+        if (right.type === "TemplateLiteral") {
+          context.report({
+            node,
+            messageId: "noInWithPrimitive",
+            data: { type: "string" },
+          });
+        }
+      },
+    };
+  },
+};