eslint-plugin-sonar-config 0.1.1

package/README.MD

@@ -0,0 +1,66 @@
+# eslint-plugin-sonar-config
+
+Plugin ESLint com regras customizadas para qualidade de código em projeto com SonarQube implementado.
+
+## Instalação
+
+```bash
+npm install --save-dev eslint-plugin-sonar-config
+```
+
+## Uso
+
+### Configuração Básica
+
+No seu `.eslintrc.js` ou `.eslintrc.json`:
+
+```json
+{
+  "plugins": ["sonar-config"],
+  "rules": {
+    "sonar-config/no-nested-ternary": "error"
+  }
+}
+```
+
+### Usando Configuração Recomendada
+
+```json
+{
+  "extends": ["plugin:sonar-config/recommended"]
+}
+```
+
+## Regras Disponíveis
+
+### `no-nested-ternary`
+
+Proíbe o uso de ternários aninhados em código de produção.
+
+---
+
+## Integração com a CLI
+
+Este plugin foi desenvolvido para ser usado automaticamente pela CLI de qualidade de código Liferay. A CLI adiciona e configura este plugin automaticamente em novos projetos.
+
+## Desenvolvimento
+
+### Estrutura do Projeto
+
+```
+eslint-plugin-sonar-config/
+├── index.js                          # Entry point
+├── package.json
+├── README.md
+└── rules/
+    ├── no-console-in-production.js
+    ├── require-jsdoc-comments.js
+    └── no-unused-liferay-imports.js
+```
+
+### Testando Localmente
+
+1. Clone o repositório
+2. Execute `npm link` na pasta do plugin
+3. No seu projeto de teste, execute `npm link eslint-plugin-sonar-config`
+4. Configure o `.eslintrc` e teste as regras

package/index.js

@@ -0,0 +1,116 @@
+import noNestedTernary from "./rules/no-nested-ternary.js";
+import awaitOnlyPromises from "./rules/await-only-promises.js";
+import forLoopUpdateCounter from "./rules/for-loop-update-counter.js";
+import maxSwitchCases from "./rules/max-switch-cases.js";
+import noArrayDelete from "./rules/no-array-delete.js";
+import noExampleRule from "./rules/no-example-rule.js";
+import noInArray from "./rules/no-in-array.js";
+import noInWithPrimitives from "./rules/no-in-with-primitives.js";
+import noIndexOfComparePositive from "./rules/no-index-of-compare-positive.js";
+import noLabelInSwitch from "./rules/no-label-in-switch.js";
+import noThisInFunctionalComponent from "./rules/no-this-in-functional-component.js";
+import preferForOf from "./rules/prefer-for-of.js";
+import preferRegexExec from "./rules/prefer-regex-exec.js";
+import requireReduceInitialValue from "./rules/require-reduce-initial-value.js";
+import requireSortCompare from "./rules/require-sort-compare.js";
+import useStateCallback from "./rules/use-state-callback.js";
+import preferWhile from "./rules/prefer-while.js";
+import noIdenticalBranches from "./rules/no-identical-branches.js";
+import noEmptyRegexAlternatives from "./rules/no-empty-regex-alternatives.js";
+import regexAnchorWithAlternation from "./rules/regex-anchor-with-alternation.js";
+import noNonNumericArrayIndex from "./rules/no-non-numeric-array-index.js";
+import arrayMethodMissingArgs from "./rules/array-method-missing-args.js";
+import noMisleadingArrayMutation from "./rules/no-misleading-array-mutation.js";
+import noUnsafeWindowOpen from "./rules/no-unsafe-window-open.js";
+import noConstantBinaryExpression from "./rules/no-constant-binary-expression.js";
+import noBitwiseInBoolean from "./rules/no-bitwise-in-boolean.js";
+import noInvertedBooleanCheck from "./rules/no-inverted-boolean-check.js";
+import noGratuitousBoolean from "./rules/no-gratuitous-boolean.js";
+import noRedundantBooleanCondition from "./rules/no-redundant-boolean-condition.js";
+import noRedundantCallApply from "./rules/no-redundant-call-apply.js";
+
+const rulesConfig = {
+  "no-nested-ternary": { rule: noNestedTernary, level: "error" },
+  "no-example-rule": { rule: noExampleRule, level: "error" },
+  "require-sort-compare": { rule: requireSortCompare, level: "error" },
+  "require-reduce-initial-value": {
+    rule: requireReduceInitialValue,
+    level: "error",
+  },
+  "await-only-promises": { rule: awaitOnlyPromises, level: "error" },
+  "no-array-delete": { rule: noArrayDelete, level: "error" },
+  "no-in-array": { rule: noInArray, level: "error" },
+  "prefer-for-of": { rule: preferForOf, level: "warn" },
+  "for-loop-update-counter": { rule: forLoopUpdateCounter, level: "error" },
+  "no-in-with-primitives": { rule: noInWithPrimitives, level: "error" },
+  "no-index-of-compare-positive": {
+    rule: noIndexOfComparePositive,
+    level: "error",
+  },
+  "prefer-regex-exec": { rule: preferRegexExec, level: "error" },
+  "no-label-in-switch": { rule: noLabelInSwitch, level: "error" },
+  "max-switch-cases": { rule: maxSwitchCases, level: "error" },
+  "use-state-callback": { rule: useStateCallback, level: "error" },
+  "no-this-in-functional-component": {
+    rule: noThisInFunctionalComponent,
+    level: "error",
+  },
+  "prefer-while": { rule: preferWhile, level: "error" },
+  "no-identical-branches": { rule: noIdenticalBranches, level: "error" },
+  "no-empty-regex-alternatives": {
+    rule: noEmptyRegexAlternatives,
+    level: "error",
+  },
+  "regex-anchor-with-alternation": {
+    rule: regexAnchorWithAlternation,
+    level: "error",
+  },
+  "no-non-numeric-array-index": {
+    rule: noNonNumericArrayIndex,
+    level: "error",
+  },
+  "array-method-missing-args": { rule: arrayMethodMissingArgs, level: "error" },
+  "no-misleading-array-mutation": {
+    rule: noMisleadingArrayMutation,
+    level: "error",
+  },
+  "no-unsafe-window-open": { rule: noUnsafeWindowOpen, level: "error" },
+  "no-constant-binary-expression": {
+    rule: noConstantBinaryExpression,
+    level: "error",
+  },
+  "no-bitwise-in-boolean": { rule: noBitwiseInBoolean, level: "error" },
+  "no-inverted-boolean-check": { rule: noInvertedBooleanCheck, level: "error" },
+  "no-gratuitous-boolean": { rule: noGratuitousBoolean, level: "error" },
+  "no-redundant-boolean-condition": {
+    rule: noRedundantBooleanCondition,
+    level: "error",
+  },
+  "no-redundant-call-apply": { rule: noRedundantCallApply, level: "error" },
+};
+
+const rules = Object.fromEntries(
+  Object.entries(rulesConfig).map(([name, { rule }]) => [name, rule])
+);
+
+const recommendedRules = Object.fromEntries(
+  Object.entries(rulesConfig).map(([name, { level }]) => [
+    `sonar-config/${name}`,
+    level,
+  ])
+);
+
+const plugin = {
+  meta: {
+    name: "eslint-plugin-sonar-config",
+    version: "0.1.1",
+  },
+  rules,
+  configs: {
+    recommended: {
+      rules: recommendedRules,
+    },
+  },
+};
+
+export default plugin;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "eslint-plugin-sonar-config",
+  "version": "0.1.1",
+  "description": "ESLint plugin com regras customizadas para melhorar a qualidade de código em projeto com Sonar implementado.",
+  "main": "index.js",
+  "type": "module",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "sonar",
+    "code-quality"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "eslint": "8.57.0"
+  },
+  "engines": {
+    "node": "16.0.0"
+  },
+  "exports": {
+    ".": "./index.js"
+  }
+}

package/rules/array-method-missing-args.js

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview Métodos push/unshift devem receber pelo menos 1 argumento
+ * [].push() ou arr.push() sem argumentos é inútil e provavelmente um bug
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Métodos push/unshift devem receber pelo menos 1 argumento",
+    },
+    messages: {
+      missingArgs:
+        "O método '{{method}}' foi chamado sem argumentos. Isso não faz nada.",
+    },
+  },
+  create(context) {
+    // Apenas push e unshift - claramente bugs quando sem argumentos
+    const methodsNeedingArgs = new Set(["push", "unshift"]);
+
+    return {
+      CallExpression(node) {
+        // Verifica se é chamada de método: algo.push()
+        if (node.callee.type !== "MemberExpression") return;
+        if (node.callee.property.type !== "Identifier") return;
+
+        const methodName = node.callee.property.name;
+
+        // Só verifica push e unshift
+        if (!methodsNeedingArgs.has(methodName)) return;
+
+        // Se foi chamado sem argumentos, é um problema
+        if (node.arguments.length === 0) {
+          context.report({
+            node,
+            messageId: "missingArgs",
+            data: {
+              method: methodName,
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/await-only-promises.js

@@ -0,0 +1,84 @@
+/**
+ * Regra: "await" deve ser usado apenas com Promises
+ *
+ * Sonar: javascript:S4123
+ *
+ * Nota: Esta é uma verificação simplificada que detecta await em valores literais.
+ * Para verificação completa de tipos, seria necessário type checking do TypeScript.
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: '"await" deve ser usado apenas com Promises',
+    },
+    messages: {
+      awaitOnlyPromises:
+        '"await" deve ser usado apenas com Promises. Usar await em valores não-Promise é desnecessário.',
+    },
+  },
+
+  create(context) {
+    return {
+      AwaitExpression(node) {
+        const argument = node.argument;
+
+        // Detecta await em literais (string, number, boolean, null, etc.)
+        if (argument.type === "Literal") {
+          context.report({
+            node,
+            messageId: "awaitOnlyPromises",
+          });
+          return;
+        }
+
+        // Detecta await em arrays literais
+        if (argument.type === "ArrayExpression") {
+          context.report({
+            node,
+            messageId: "awaitOnlyPromises",
+          });
+          return;
+        }
+
+        // Detecta await em objetos literais
+        if (argument.type === "ObjectExpression") {
+          context.report({
+            node,
+            messageId: "awaitOnlyPromises",
+          });
+          return;
+        }
+
+        // Detecta await em template literals
+        if (argument.type === "TemplateLiteral") {
+          context.report({
+            node,
+            messageId: "awaitOnlyPromises",
+          });
+          return;
+        }
+
+        // Detecta await em arrow functions (sem chamar)
+        if (argument.type === "ArrowFunctionExpression") {
+          context.report({
+            node,
+            messageId: "awaitOnlyPromises",
+          });
+          return;
+        }
+
+        // Detecta await em function expressions (sem chamar)
+        if (argument.type === "FunctionExpression") {
+          context.report({
+            node,
+            messageId: "awaitOnlyPromises",
+          });
+          return;
+        }
+      },
+    };
+  },
+};

package/rules/for-loop-update-counter.js

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview O update do for loop deve modificar a variável usada na condição
+ * Evita bugs onde o incremento modifica uma variável diferente da condição.
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "O update do for loop deve modificar a variável usada na condição",
+    },
+    messages: {
+      updateWrongCounter:
+        'O update do for modifica "{{updateVar}}" mas a condição usa "{{conditionVar}}". Isso pode causar loop infinito.',
+    },
+  },
+  create(context) {
+    /**
+     * Extrai o nome da variável sendo modificada em um update expression
+     */
+    function getUpdatedVariable(node) {
+      if (!node) return null;
+
+      // i++ ou i--
+      if (node.type === "UpdateExpression" && node.argument.type === "Identifier") {
+        return node.argument.name;
+      }
+
+      // i += 1 ou i = i + 1
+      if (node.type === "AssignmentExpression" && node.left.type === "Identifier") {
+        return node.left.name;
+      }
+
+      // Expressão de sequência: i++, j++
+      if (node.type === "SequenceExpression") {
+        // Retorna array de todas as variáveis modificadas
+        return node.expressions.map(getUpdatedVariable).filter(Boolean);
+      }
+
+      return null;
+    }
+
+    /**
+     * Extrai variáveis usadas na condição do for
+     */
+    function getConditionVariables(node) {
+      const variables = [];
+
+      function extract(n) {
+        if (!n) return;
+
+        if (n.type === "Identifier") {
+          variables.push(n.name);
+        } else if (n.type === "BinaryExpression" || n.type === "LogicalExpression") {
+          extract(n.left);
+          extract(n.right);
+        } else if (n.type === "UnaryExpression") {
+          extract(n.argument);
+        } else if (n.type === "MemberExpression") {
+          extract(n.object);
+        }
+      }
+
+      extract(node);
+      return variables;
+    }
+
+    return {
+      ForStatement(node) {
+        const update = node.update;
+        const test = node.test;
+
+        if (!update || !test) return;
+
+        const updatedVars = getUpdatedVariable(update);
+        const conditionVars = getConditionVariables(test);
+
+        if (!updatedVars || conditionVars.length === 0) return;
+
+        // Converte para array se não for
+        const updatedVarsArray = Array.isArray(updatedVars)
+          ? updatedVars
+          : [updatedVars];
+
+        // Verifica se pelo menos uma variável do update está na condição
+        const hasMatchingVar = updatedVarsArray.some((v) =>
+          conditionVars.includes(v)
+        );
+
+        if (!hasMatchingVar) {
+          context.report({
+            node: update,
+            messageId: "updateWrongCounter",
+            data: {
+              updateVar: updatedVarsArray.join(", "),
+              conditionVar: conditionVars[0],
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/max-switch-cases.js

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Switch não deve ter muitos cases
+ * Quando há muitos cases, considere usar um objeto Map para melhor legibilidade.
+ */
+const MAX_CASES = 30;
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Switch não deve ter muitos cases",
+    },
+    messages: {
+      tooManyCases:
+        "Switch tem {{count}} cases. Considere usar um objeto/Map ao invés (máximo recomendado: {{max}}).",
+    },
+  },
+  create(context) {
+    return {
+      SwitchStatement(node) {
+        // Conta apenas cases não vazios (ignora fall-through)
+        const nonEmptyCases = node.cases.filter(
+          (c) => c.consequent.length > 0
+        ).length;
+
+        if (nonEmptyCases > MAX_CASES) {
+          context.report({
+            node,
+            messageId: "tooManyCases",
+            data: {
+              count: nonEmptyCases,
+              max: MAX_CASES,
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-array-delete.js

@@ -0,0 +1,69 @@
+/**
+ * Regra: Não usar "delete" em elementos de array
+ *
+ * Sonar: javascript:S2870
+ *
+ * delete em arrays deixa um "buraco" (undefined) e não atualiza o length.
+ * Use splice() ou filter() ao invés.
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: 'Não usar "delete" em elementos de array',
+    },
+    messages: {
+      noArrayDelete:
+        'Não use "delete" em arrays. Use splice() ou filter() para remover elementos.',
+    },
+  },
+
+  create(context) {
+    return {
+      UnaryExpression(node) {
+        // Verifica se é operador delete
+        if (node.operator !== "delete") return;
+
+        const argument = node.argument;
+
+        // Verifica se é acesso por índice: arr[0], arr[i], arr[expr]
+        if (
+          argument.type === "MemberExpression" &&
+          argument.computed === true
+        ) {
+          // Verifica se o índice é um número ou expressão numérica
+          const property = argument.property;
+
+          // delete arr[0] - índice literal numérico
+          if (property.type === "Literal" && typeof property.value === "number") {
+            context.report({
+              node,
+              messageId: "noArrayDelete",
+            });
+            return;
+          }
+
+          // delete arr[i] - variável como índice (provavelmente número)
+          if (property.type === "Identifier") {
+            context.report({
+              node,
+              messageId: "noArrayDelete",
+            });
+            return;
+          }
+
+          // delete arr[i + 1] - expressão como índice
+          if (property.type === "BinaryExpression") {
+            context.report({
+              node,
+              messageId: "noArrayDelete",
+            });
+            return;
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-bitwise-in-boolean.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Operadores bitwise não devem ser usados em contextos booleanos
+ * if (a & b) provavelmente deveria ser if (a && b)
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Operadores bitwise não devem ser usados em contextos booleanos",
+    },
+    messages: {
+      bitwiseInBoolean:
+        "Operador bitwise '{{operator}}' em contexto booleano. Use '{{suggestion}}' para lógica booleana.",
+    },
+  },
+  create(context) {
+    function checkBitwiseInBoolean(node, testNode) {
+      if (testNode.type !== "BinaryExpression") return;
+
+      const operator = testNode.operator;
+
+      if (operator === "&") {
+        context.report({
+          node: testNode,
+          messageId: "bitwiseInBoolean",
+          data: { operator: "&", suggestion: "&&" },
+        });
+      } else if (operator === "|") {
+        context.report({
+          node: testNode,
+          messageId: "bitwiseInBoolean",
+          data: { operator: "|", suggestion: "||" },
+        });
+      }
+    }
+
+    return {
+      IfStatement(node) {
+        checkBitwiseInBoolean(node, node.test);
+      },
+      WhileStatement(node) {
+        checkBitwiseInBoolean(node, node.test);
+      },
+      DoWhileStatement(node) {
+        checkBitwiseInBoolean(node, node.test);
+      },
+      ForStatement(node) {
+        if (node.test) {
+          checkBitwiseInBoolean(node, node.test);
+        }
+      },
+      ConditionalExpression(node) {
+        checkBitwiseInBoolean(node, node.test);
+      },
+    };
+  },
+};