@sgfe/eslint-plugin-sg 1.0.3

package/lib/rules/meta-property-ordering.js

@@ -0,0 +1,108 @@
+/**
+ * @fileoverview Enforces the order of meta properties
+ */
+
+'use strict';
+
+const { getKeyName, getRuleInfo } = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'enforce the order of meta properties',
+      category: 'Rules',
+      recommended: false,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/meta-property-ordering.md',
+    },
+    fixable: 'code',
+    schema: [
+      {
+        type: 'array',
+        elements: { type: 'string' },
+      },
+    ],
+    messages: {
+      inconsistentOrder:
+        'The meta properties should be placed in a consistent order: [{{order}}].',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    const ruleInfo = getRuleInfo(sourceCode);
+    if (!ruleInfo) {
+      return {};
+    }
+
+    const order = context.options[0] || [
+      'type',
+      'docs',
+      'fixable',
+      'hasSuggestions',
+      'deprecated',
+      'replacedBy',
+      'schema',
+      'defaultOptions', // https://github.com/eslint/rfcs/tree/main/designs/2023-rule-options-defaults
+      'messages',
+    ];
+
+    const orderMap = new Map(order.map((name, i) => [name, i]));
+
+    return {
+      Program() {
+        if (!ruleInfo.meta || ruleInfo.meta.properties.length < 2) {
+          return;
+        }
+
+        const props = ruleInfo.meta.properties;
+
+        let last;
+
+        const violatingProps = props.filter((prop) => {
+          const curr = orderMap.has(getKeyName(prop))
+            ? orderMap.get(getKeyName(prop))
+            : Number.POSITIVE_INFINITY;
+          return last > (last = curr);
+        });
+
+        if (violatingProps.length === 0) {
+          return;
+        }
+
+        const knownProps = props
+          .filter((prop) => orderMap.has(getKeyName(prop)))
+          .sort(
+            (a, b) => orderMap.get(getKeyName(a)) - orderMap.get(getKeyName(b))
+          );
+        const unknownProps = props.filter(
+          (prop) => !orderMap.has(getKeyName(prop))
+        );
+
+        for (const violatingProp of violatingProps) {
+          context.report({
+            node: violatingProp,
+            messageId: 'inconsistentOrder',
+            data: {
+              order: knownProps.map(getKeyName).join(', '),
+            },
+            fix(fixer) {
+              const expectedProps = [...knownProps, ...unknownProps];
+              return props.map((prop, k) => {
+                return fixer.replaceText(
+                  prop,
+                  sourceCode.getText(expectedProps[k])
+                );
+              });
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/lib/rules/no-deprecated-context-methods.js

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Disallows usage of deprecated methods on rule context objects
+ * @author Teddy Katz
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+const DEPRECATED_PASSTHROUGHS = {
+  getSource: 'getText',
+  getSourceLines: 'getLines',
+  getAllComments: 'getAllComments',
+  getNodeByRangeIndex: 'getNodeByRangeIndex',
+  getComments: 'getComments',
+  getCommentsBefore: 'getCommentsBefore',
+  getCommentsAfter: 'getCommentsAfter',
+  getCommentsInside: 'getCommentsInside',
+  getJSDocComment: 'getJSDocComment',
+  getFirstToken: 'getFirstToken',
+  getFirstTokens: 'getFirstTokens',
+  getLastToken: 'getLastToken',
+  getLastTokens: 'getLastTokens',
+  getTokenAfter: 'getTokenAfter',
+  getTokenBefore: 'getTokenBefore',
+  getTokenByRangeStart: 'getTokenByRangeStart',
+  getTokens: 'getTokens',
+  getTokensAfter: 'getTokensAfter',
+  getTokensBefore: 'getTokensBefore',
+  getTokensBetween: 'getTokensBetween',
+};
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'disallow usage of deprecated methods on rule context objects',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/no-deprecated-context-methods.md',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      newFormat:
+        'Use `{{contextName}}.getSourceCode().{{replacement}}` instead of `{{contextName}}.{{original}}`.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return {
+      'Program:exit'(ast) {
+        [...utils.getContextIdentifiers(sourceCode.scopeManager, ast)]
+          .filter(
+            (contextId) =>
+              contextId.parent.type === 'MemberExpression' &&
+              contextId === contextId.parent.object &&
+              contextId.parent.property.type === 'Identifier' &&
+              Object.prototype.hasOwnProperty.call(
+                DEPRECATED_PASSTHROUGHS,
+                contextId.parent.property.name
+              )
+          )
+          .forEach((contextId) =>
+            context.report({
+              node: contextId.parent,
+              messageId: 'newFormat',
+              data: {
+                contextName: contextId.name,
+                original: contextId.parent.property.name,
+                replacement:
+                  DEPRECATED_PASSTHROUGHS[contextId.parent.property.name],
+              },
+              fix: (fixer) => [
+                fixer.insertTextAfter(contextId, '.getSourceCode()'),
+                fixer.replaceText(
+                  contextId.parent.property,
+                  DEPRECATED_PASSTHROUGHS[contextId.parent.property.name]
+                ),
+              ],
+            })
+          );
+      },
+    };
+  },
+};

package/lib/rules/no-deprecated-report-api.js

@@ -0,0 +1,83 @@
+/**
+ * @fileoverview Disallow the version of `context.report()` with multiple arguments
+ * @author Teddy Katz
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'disallow the version of `context.report()` with multiple arguments',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/no-deprecated-report-api.md',
+    },
+    fixable: 'code', // or "code" or "whitespace"
+    schema: [],
+    messages: {
+      useNewAPI: 'Use the new-style context.report() API.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    let contextIdentifiers;
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return {
+      Program(ast) {
+        contextIdentifiers = utils.getContextIdentifiers(
+          sourceCode.scopeManager,
+          ast
+        );
+      },
+      CallExpression(node) {
+        if (
+          node.callee.type === 'MemberExpression' &&
+          contextIdentifiers.has(node.callee.object) &&
+          node.callee.property.type === 'Identifier' &&
+          node.callee.property.name === 'report' &&
+          (node.arguments.length > 1 ||
+            (node.arguments.length === 1 &&
+              node.arguments[0].type === 'SpreadElement'))
+        ) {
+          context.report({
+            node: node.callee.property,
+            messageId: 'useNewAPI',
+            fix(fixer) {
+              const openingParen = sourceCode.getTokenBefore(node.arguments[0]);
+              const closingParen = sourceCode.getLastToken(node);
+              const reportInfo = utils.getReportInfo(node, context);
+
+              if (!reportInfo) {
+                return null;
+              }
+
+              return fixer.replaceTextRange(
+                [openingParen.range[1], closingParen.range[0]],
+                `{${Object.keys(reportInfo)
+                  .map(
+                    (key) => `${key}: ${sourceCode.getText(reportInfo[key])}`
+                  )
+                  .join(', ')}}`
+              );
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/lib/rules/no-identical-tests.js

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview disallow identical tests
+ * @author 薛定谔的猫<hh_2013@foxmail.com>
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow identical tests',
+      category: 'Tests',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/no-identical-tests.md',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      identical: 'This test case is identical to another case.',
+    },
+  },
+
+  create(context) {
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+
+    // ----------------------------------------------------------------------
+    // Helpers
+    // ----------------------------------------------------------------------
+    /**
+     * Create a unique cache key
+     * @param {object} test
+     * @returns {string}
+     */
+    function toKey(test) {
+      if (test.type !== 'ObjectExpression') {
+        return JSON.stringify([test.type, sourceCode.getText(test)]);
+      }
+      return JSON.stringify([
+        test.type,
+        ...test.properties.map((p) => sourceCode.getText(p)).sort(),
+      ]);
+    }
+
+    return {
+      Program(ast) {
+        utils.getTestInfo(context, ast).forEach((testRun) => {
+          [testRun.valid, testRun.invalid].forEach((tests) => {
+            const cache = new Set();
+            tests.forEach((test) => {
+              const key = toKey(test);
+              if (cache.has(key)) {
+                context.report({
+                  node: test,
+                  messageId: 'identical',
+                  fix(fixer) {
+                    const start = sourceCode.getTokenBefore(test);
+                    const end = sourceCode.getTokenAfter(test);
+                    return fixer.removeRange(
+                      // should remove test's trailing comma
+                      [
+                        start.range[1],
+                        end.value === ',' ? end.range[1] : test.range[1],
+                      ]
+                    );
+                  },
+                });
+              } else {
+                cache.add(key);
+              }
+            });
+          });
+        });
+      },
+    };
+  },
+};

package/lib/rules/no-missing-message-ids.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'disallow `messageId`s that are missing from `meta.messages`',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/no-missing-message-ids.md',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      missingMessage:
+        '`meta.messages` is missing the messageId "{{messageId}}".',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    const { scopeManager } = sourceCode;
+    const ruleInfo = utils.getRuleInfo(sourceCode);
+    if (!ruleInfo) {
+      return {};
+    }
+
+    const messagesNode = utils.getMessagesNode(ruleInfo, scopeManager);
+
+    let contextIdentifiers;
+
+    if (!messagesNode || messagesNode.type !== 'ObjectExpression') {
+      // If we can't find `meta.messages`, disable the rule.
+      return {};
+    }
+
+    return {
+      Program(ast) {
+        contextIdentifiers = utils.getContextIdentifiers(scopeManager, ast);
+      },
+
+      CallExpression(node) {
+        const scope = sourceCode.getScope?.(node) || context.getScope(); // TODO: just use sourceCode.getScope() when we drop support for ESLint < 9.0.0
+        // Check for messageId properties used in known calls to context.report();
+        if (
+          node.callee.type === 'MemberExpression' &&
+          contextIdentifiers.has(node.callee.object) &&
+          node.callee.property.type === 'Identifier' &&
+          node.callee.property.name === 'report'
+        ) {
+          const reportInfo = utils.getReportInfo(node, context);
+          if (!reportInfo) {
+            return;
+          }
+
+          const reportMessagesAndDataArray =
+            utils.collectReportViolationAndSuggestionData(reportInfo);
+          for (const { messageId } of reportMessagesAndDataArray.filter(
+            (obj) => obj.messageId
+          )) {
+            const values =
+              messageId.type === 'Literal'
+                ? [messageId]
+                : utils.findPossibleVariableValues(messageId, scopeManager);
+
+            // Look for any possible string values we found for this messageId.
+            values.forEach((val) => {
+              if (
+                val.type === 'Literal' &&
+                typeof val.value === 'string' &&
+                val.value !== '' &&
+                !utils.getMessageIdNodeById(
+                  val.value,
+                  ruleInfo,
+                  scopeManager,
+                  scope
+                )
+              )
+                // Couldn't find this messageId in `meta.messages`.
+                context.report({
+                  node: val,
+                  messageId: 'missingMessage',
+                  data: {
+                    messageId: val.value,
+                  },
+                });
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/lib/rules/no-missing-placeholders.js

@@ -0,0 +1,131 @@
+/**
+ * @fileoverview Disallow missing placeholders in rule report messages
+ * @author Teddy Katz
+ */
+
+'use strict';
+
+const utils = require('../utils');
+const { getStaticValue } = require('eslint-utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow missing placeholders in rule report messages',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/no-missing-placeholders.md',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      placeholderDoesNotExist:
+        "The placeholder {{{{missingKey}}}} is missing (must provide it in the report's `data` object).",
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    const { scopeManager } = sourceCode;
+
+    let contextIdentifiers;
+
+    const ruleInfo = utils.getRuleInfo(sourceCode);
+    if (!ruleInfo) {
+      return {};
+    }
+
+    const messagesNode = utils.getMessagesNode(ruleInfo, scopeManager);
+
+    return {
+      Program(ast) {
+        contextIdentifiers = utils.getContextIdentifiers(scopeManager, ast);
+      },
+      CallExpression(node) {
+        const scope = sourceCode.getScope?.(node) || context.getScope(); // TODO: just use sourceCode.getScope() when we drop support for ESLint < 9.0.0
+        if (
+          node.callee.type === 'MemberExpression' &&
+          contextIdentifiers.has(node.callee.object) &&
+          node.callee.property.type === 'Identifier' &&
+          node.callee.property.name === 'report'
+        ) {
+          const reportInfo = utils.getReportInfo(node, context);
+          if (!reportInfo) {
+            return;
+          }
+
+          const reportMessagesAndDataArray =
+            utils.collectReportViolationAndSuggestionData(reportInfo);
+
+          if (messagesNode) {
+            // Check for any potential instances where we can use the messageId to fill in the message for convenience.
+            reportMessagesAndDataArray.forEach((obj) => {
+              if (
+                !obj.message &&
+                obj.messageId &&
+                obj.messageId.type === 'Literal' &&
+                typeof obj.messageId.value === 'string'
+              ) {
+                const correspondingMessage = utils.getMessageIdNodeById(
+                  obj.messageId.value,
+                  ruleInfo,
+                  scopeManager,
+                  scope
+                );
+                if (correspondingMessage) {
+                  obj.message = correspondingMessage.value;
+                }
+              }
+            });
+          }
+
+          for (const {
+            message,
+            messageId,
+            data,
+          } of reportMessagesAndDataArray.filter((obj) => obj.message)) {
+            const messageStaticValue = getStaticValue(message, scope);
+            if (
+              ((message.type === 'Literal' &&
+                typeof message.value === 'string') ||
+                (messageStaticValue &&
+                  typeof messageStaticValue.value === 'string')) &&
+              (!data || data.type === 'ObjectExpression')
+            ) {
+              // Same regex as the one ESLint uses
+              // https://github.com/eslint/eslint/blob/e5446449d93668ccbdb79d78cc69f165ce4fde07/lib/eslint.js#L990
+              const PLACEHOLDER_MATCHER = /{{\s*([^{}]+?)\s*}}/g;
+              let match;
+
+              while (
+                (match = PLACEHOLDER_MATCHER.exec(
+                  message.value || messageStaticValue.value
+                ))
+              ) {
+                const matchingProperty =
+                  data &&
+                  data.properties.find(
+                    (prop) => utils.getKeyName(prop) === match[1]
+                  );
+
+                if (!matchingProperty) {
+                  context.report({
+                    node: data || messageId || message,
+                    messageId: 'placeholderDoesNotExist',
+                    data: { missingKey: match[1] },
+                  });
+                }
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};