@sgfe/eslint-plugin-sg 1.0.3

package/lib/rules/require-meta-schema.js

@@ -0,0 +1,162 @@
+'use strict';
+
+const { findVariable } = require('eslint-utils');
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'require rules to implement a `meta.schema` property',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/require-meta-schema.md',
+    },
+    hasSuggestions: true,
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          requireSchemaPropertyWhenOptionless: {
+            type: 'boolean',
+            default: true,
+            description:
+              'Whether the rule should require the `meta.schema` property to be specified (with `schema: []`) for rules that have no options.',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      addEmptySchema: 'Add empty schema indicating the rule has no options.',
+      foundOptionsUsage:
+        '`meta.schema` has no schema defined but rule has options.',
+      missing: '`meta.schema` is required (use [] if rule has no schema).',
+      wrongType:
+        '`meta.schema` should be an array or object (use [] if rule has no schema).',
+    },
+  },
+
+  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 {};
+    }
+
+    let contextIdentifiers;
+    const metaNode = ruleInfo.meta;
+    let schemaNode;
+
+    // Options
+    const requireSchemaPropertyWhenOptionless =
+      !context.options[0] ||
+      context.options[0].requireSchemaPropertyWhenOptionless;
+
+    let hasEmptySchema = false;
+    let isUsingOptions = false;
+
+    return {
+      Program(ast) {
+        contextIdentifiers = utils.getContextIdentifiers(scopeManager, ast);
+
+        schemaNode = utils
+          .evaluateObjectProperties(metaNode, scopeManager)
+          .find(
+            (p) => p.type === 'Property' && utils.getKeyName(p) === 'schema'
+          );
+
+        if (!schemaNode) {
+          return;
+        }
+
+        let { value } = schemaNode;
+        if (value.type === 'Identifier' && value.name !== 'undefined') {
+          const variable = findVariable(
+            scopeManager.acquire(value) || scopeManager.globalScope,
+            value
+          );
+
+          // If we can't find the declarator, we have to assume it's in correct type
+          if (
+            !variable ||
+            !variable.defs ||
+            !variable.defs[0] ||
+            !variable.defs[0].node ||
+            variable.defs[0].node.type !== 'VariableDeclarator' ||
+            !variable.defs[0].node.init
+          ) {
+            return;
+          }
+
+          value = variable.defs[0].node.init;
+        }
+
+        if (
+          (value.type === 'ArrayExpression' && value.elements.length === 0) ||
+          (value.type === 'ObjectExpression' && value.properties.length === 0)
+        ) {
+          // Schema is explicitly defined as having no options.
+          hasEmptySchema = true;
+        }
+
+        if (
+          value.type === 'Literal' ||
+          (value.type === 'Identifier' && value.name === 'undefined')
+        ) {
+          context.report({ node: value, messageId: 'wrongType' });
+        }
+      },
+
+      'Program:exit'() {
+        if (!schemaNode && requireSchemaPropertyWhenOptionless) {
+          context.report({
+            node: metaNode || ruleInfo.create,
+            messageId: 'missing',
+            suggest:
+              !isUsingOptions &&
+              metaNode &&
+              metaNode.type === 'ObjectExpression'
+                ? [
+                    {
+                      messageId: 'addEmptySchema',
+                      fix(fixer) {
+                        return utils.insertProperty(
+                          fixer,
+                          metaNode,
+                          'schema: []',
+                          sourceCode
+                        );
+                      },
+                    },
+                  ]
+                : [],
+          });
+        }
+      },
+
+      MemberExpression(node) {
+        // Check if `context.options` was used when no options were defined in `meta.schema`.
+        if (
+          (hasEmptySchema || !schemaNode) &&
+          node.object.type === 'Identifier' &&
+          contextIdentifiers.has(node.object) &&
+          node.property.type === 'Identifier' &&
+          node.property.name === 'options'
+        ) {
+          isUsingOptions = true;
+          context.report({
+            node: schemaNode || metaNode || ruleInfo.create,
+            messageId: 'foundOptionsUsage',
+          });
+        }
+      },
+    };
+  },
+};

package/lib/rules/require-meta-type.js

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview require rules to implement a `meta.type` property
+ * @author 薛定谔的猫<weiran.zsd@outlook.com>
+ */
+
+'use strict';
+
+const { getStaticValue } = require('eslint-utils');
+const utils = require('../utils');
+const VALID_TYPES = new Set(['problem', 'suggestion', 'layout']);
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'require rules to implement a `meta.type` property',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/require-meta-type.md',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      missing:
+        '`meta.type` is required (must be either `problem`, `suggestion`, or `layout`).',
+      unexpected:
+        '`meta.type` must be either `problem`, `suggestion`, or `layout`.',
+    },
+  },
+
+  create(context) {
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    const ruleInfo = utils.getRuleInfo(sourceCode);
+    if (!ruleInfo) {
+      return {};
+    }
+
+    return {
+      Program(node) {
+        const scope = sourceCode.getScope?.(node) || context.getScope(); // TODO: just use sourceCode.getScope() when we drop support for ESLint < v9.0.0
+        const { scopeManager } = sourceCode;
+
+        const metaNode = ruleInfo.meta;
+        const typeNode = utils
+          .evaluateObjectProperties(metaNode, scopeManager)
+          .find((p) => p.type === 'Property' && utils.getKeyName(p) === 'type');
+
+        if (!typeNode) {
+          context.report({
+            node: metaNode || ruleInfo.create,
+            messageId: 'missing',
+          });
+          return;
+        }
+
+        const staticValue = getStaticValue(typeNode.value, scope);
+        if (!staticValue) {
+          // Ignore non-static values since we can't determine what they look like.
+          return;
+        }
+
+        if (!VALID_TYPES.has(staticValue.value)) {
+          context.report({ node: typeNode.value, messageId: 'unexpected' });
+        }
+      },
+    };
+  },
+};

package/lib/rules/test-case-property-ordering.js

@@ -0,0 +1,107 @@
+/**
+ * @fileoverview Requires the properties of a test case to be placed in a consistent order.
+ * @author 薛定谔的猫<hh_2013@foxmail.com>
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'require the properties of a test case to be placed in a consistent order',
+      category: 'Tests',
+      recommended: false,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/test-case-property-ordering.md',
+    },
+    fixable: 'code',
+    schema: [
+      {
+        type: 'array',
+        elements: { type: 'string' },
+      },
+    ],
+    messages: {
+      inconsistentOrder:
+        'The properties of a test case should be placed in a consistent order: [{{order}}].',
+    },
+  },
+
+  create(context) {
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+    const order = context.options[0] || [
+      'filename',
+      'code',
+      'output',
+      'options',
+      'parser',
+      'languageOptions', // flat-mode only
+      'parserOptions', // eslintrc-mode only
+      'globals', // eslintrc-mode only
+      'env', // eslintrc-mode only
+      'errors',
+    ];
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+
+    return {
+      Program(ast) {
+        utils.getTestInfo(context, ast).forEach((testRun) => {
+          [testRun.valid, testRun.invalid].forEach((tests) => {
+            tests.forEach((test) => {
+              const properties = (test && test.properties) || [];
+              const keyNames = properties.map(utils.getKeyName);
+
+              for (let i = 0, lastChecked; i < keyNames.length; i++) {
+                const current = order.indexOf(keyNames[i]);
+
+                // current < lastChecked to catch unordered;
+                // and lastChecked === -1 to catch extra properties before.
+                if (
+                  current > -1 &&
+                  (current < lastChecked || lastChecked === -1)
+                ) {
+                  let orderMsg = order.filter((item) =>
+                    keyNames.includes(item)
+                  );
+                  orderMsg = [
+                    ...orderMsg,
+                    ...(lastChecked === -1
+                      ? keyNames.filter((item) => !order.includes(item))
+                      : []),
+                  ];
+
+                  context.report({
+                    node: properties[i],
+                    messageId: 'inconsistentOrder',
+                    data: { order: orderMsg.join(', ') },
+                    fix(fixer) {
+                      return orderMsg.map((key, index) => {
+                        const propertyToInsert =
+                          properties[keyNames.indexOf(key)];
+                        return fixer.replaceText(
+                          properties[index],
+                          sourceCode.getText(propertyToInsert)
+                        );
+                      });
+                    },
+                  });
+                }
+                lastChecked = current;
+              }
+            });
+          });
+        });
+      },
+    };
+  },
+};

package/lib/rules/test-case-shorthand-strings.js

@@ -0,0 +1,124 @@
+/**
+ * @fileoverview Enforce consistent usage of shorthand strings for test cases with no options
+ * @author Teddy Katz
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'enforce consistent usage of shorthand strings for test cases with no options',
+      category: 'Tests',
+      recommended: false,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/test-case-shorthand-strings.md',
+    },
+    fixable: 'code',
+    schema: [
+      { enum: ['as-needed', 'never', 'consistent', 'consistent-as-needed'] },
+    ],
+    messages: {
+      useShorthand:
+        'Use {{preferred}} for this test case instead of {{actual}}.',
+    },
+  },
+
+  create(context) {
+    const shorthandOption = context.options[0] || 'as-needed';
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+
+    // ----------------------------------------------------------------------
+    // Helpers
+    // ----------------------------------------------------------------------
+
+    /**
+     * Reports test cases as necessary
+     * @param {object[]} cases A list of test case nodes
+     * @returns {void}
+     */
+    function reportTestCases(cases) {
+      const caseInfoList = cases
+        .map((testCase) => {
+          if (
+            testCase.type === 'Literal' ||
+            testCase.type === 'TemplateLiteral'
+          ) {
+            return { node: testCase, shorthand: true, needsLongform: false };
+          }
+          if (testCase.type === 'ObjectExpression') {
+            return {
+              node: testCase,
+              shorthand: false,
+              needsLongform: !(
+                testCase.properties.length === 1 &&
+                utils.getKeyName(testCase.properties[0]) === 'code'
+              ),
+            };
+          }
+          return null;
+        })
+        .filter(Boolean);
+
+      const isConsistent =
+        new Set(caseInfoList.map((caseInfo) => caseInfo.shorthand)).size <= 1;
+      const hasCaseNeedingLongform = caseInfoList.some(
+        (caseInfo) => caseInfo.needsLongform
+      );
+
+      caseInfoList
+        .filter(
+          {
+            'as-needed': (caseInfo) =>
+              !caseInfo.shorthand && !caseInfo.needsLongform,
+            never: (caseInfo) => caseInfo.shorthand,
+            consistent: isConsistent
+              ? () => false
+              : (caseInfo) => caseInfo.shorthand,
+            'consistent-as-needed': (caseInfo) =>
+              caseInfo.shorthand === hasCaseNeedingLongform,
+          }[shorthandOption]
+        )
+        .forEach((badCaseInfo) => {
+          context.report({
+            node: badCaseInfo.node,
+            messageId: 'useShorthand',
+            data: {
+              preferred: badCaseInfo.shorthand ? 'an object' : 'a string',
+              actual: badCaseInfo.shorthand ? 'a string' : 'an object',
+            },
+            fix(fixer) {
+              return fixer.replaceText(
+                badCaseInfo.node,
+                badCaseInfo.shorthand
+                  ? `{code: ${sourceCode.getText(badCaseInfo.node)}}`
+                  : sourceCode.getText(badCaseInfo.node.properties[0].value)
+              );
+            },
+          });
+        });
+    }
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return {
+      Program(ast) {
+        utils
+          .getTestInfo(context, ast)
+          .map((testRun) => testRun.valid)
+          .filter(Boolean)
+          .forEach(reportTestCases);
+      },
+    };
+  },
+};