diff --git a/README.md b/README.md index 408830ea535aa..1ab3c9d42652d 100644 --- a/README.md +++ b/README.md @@ -300,7 +300,7 @@ ruff check --config "lint.per-file-ignores = {'some_file.py' = ['F841']}" ``` To opt in to the latest lint rules, formatter style changes, interface updates, and more, enable -[preview mode](https://docs.astral.sh/ruff/rules/) by setting `preview = true` in your configuration +[preview mode](https://docs.astral.sh/ruff/preview/) by setting `preview = true` in your configuration file or passing `--preview` on the command line. Preview mode enables a collection of unstable features that may change prior to stabilization. @@ -311,7 +311,7 @@ for more on the linting and formatting commands, respectively. -**Ruff supports over 800 lint rules**, many of which are inspired by popular tools like Flake8, +**Ruff supports over 900 lint rules**, many of which are inspired by popular tools like Flake8, isort, pyupgrade, and others. Regardless of the rule's origin, Ruff re-implements every rule in Rust as a first-party feature. @@ -322,6 +322,12 @@ stylistic rules that overlap with the use of a formatter, like `ruff format` or If you're just getting started with Ruff, **the default rule set is a great place to start**: it catches a wide variety of common errors (like unused imports) with zero configuration. +In [preview](https://docs.astral.sh/ruff/preview/), Ruff enables an expanded set of default rules +that includes rules from the `B`, `UP`, and `RUF` categories, as well as many more. If you give the +new defaults a try, feel free to leave feedback in the [GitHub +discussion](https://github.com/astral-sh/ruff/discussions/23203), where you can also find the new +rule set listed in full. + Beyond the defaults, Ruff re-implements some of the most popular Flake8 plugins and related code diff --git a/crates/ruff/tests/cli/lint.rs b/crates/ruff/tests/cli/lint.rs index e12499b4b8fbb..8134a9af18600 100644 --- a/crates/ruff/tests/cli/lint.rs +++ b/crates/ruff/tests/cli/lint.rs @@ -3255,7 +3255,6 @@ fn walrus_before_py38() { .args(STDIN_BASE_OPTIONS) .args(["--stdin-filename", "test.py"]) .arg("--target-version=py37") - .arg("--preview") .arg("-") .pass_stdin(r#"(x := 1)"#), @" @@ -3939,3 +3938,434 @@ fn supported_file_extensions_preview_enabled() -> Result<()> { "); Ok(()) } + +#[test] +fn preview_default_rules() -> Result<()> { + let test = CliTest::with_settings(|_path, mut settings| { + settings.add_filter(r"(?s).*(linter\.rules\.enabled[^]]+]).*", "$1"); + settings + })?; + + test.write_file("try.py", "1")?; + + assert_cmd_snapshot!( + test.check_command().args(["--preview", "--show-settings"]), + @" + linter.rules.enabled = [ + sys-version-slice3 (YTT101), + sys-version2 (YTT102), + sys-version-cmp-str3 (YTT103), + sys-version-info0-eq3 (YTT201), + six-py3 (YTT202), + sys-version-info1-cmp-int (YTT203), + sys-version-info-minor-cmp-int (YTT204), + sys-version0 (YTT301), + sys-version-cmp-str10 (YTT302), + sys-version-slice1 (YTT303), + cancel-scope-no-checkpoint (ASYNC100), + trio-sync-call (ASYNC105), + async-zero-sleep (ASYNC115), + long-sleep-not-forever (ASYNC116), + blocking-http-call-in-async-function (ASYNC210), + create-subprocess-in-async-function (ASYNC220), + run-process-in-async-function (ASYNC221), + wait-for-process-in-async-function (ASYNC222), + blocking-open-call-in-async-function (ASYNC230), + blocking-sleep-in-async-function (ASYNC251), + exec-builtin (S102), + try-except-pass (S110), + try-except-continue (S112), + blind-except (BLE001), + unary-prefix-increment-decrement (B002), + assignment-to-os-environ (B003), + unreliable-callable-check (B004), + strip-with-multi-characters (B005), + mutable-argument-default (B006), + function-call-in-default-argument (B008), + get-attr-with-constant (B009), + set-attr-with-constant (B010), + jump-statement-in-finally (B012), + redundant-tuple-in-exception-handler (B013), + duplicate-handler-exception (B014), + useless-comparison (B015), + raise-literal (B016), + assert-raises-exception (B017), + useless-expression (B018), + cached-instance-method (B019), + loop-variable-overrides-iterator (B020), + f-string-docstring (B021), + useless-contextlib-suppress (B022), + function-uses-loop-variable (B023), + duplicate-try-block-exception (B025), + star-arg-unpacking-after-keyword-arg (B026), + except-with-empty-tuple (B029), + except-with-non-exception-classes (B030), + reuse-of-groupby-generator (B031), + unintentional-type-annotation (B032), + duplicate-value (B033), + static-key-dict-comprehension (B035), + mutable-contextvar-default (B039), + unnecessary-generator-list (C400), + unnecessary-generator-set (C401), + unnecessary-generator-dict (C402), + unnecessary-list-comprehension-set (C403), + unnecessary-list-comprehension-dict (C404), + unnecessary-literal-set (C405), + unnecessary-literal-dict (C406), + unnecessary-collection-call (C408), + unnecessary-literal-within-tuple-call (C409), + unnecessary-literal-within-list-call (C410), + unnecessary-list-call (C411), + unnecessary-call-around-sorted (C413), + unnecessary-double-cast-or-process (C414), + unnecessary-subscript-reversal (C415), + unnecessary-map (C417), + unnecessary-literal-within-dict-call (C418), + unnecessary-comprehension-in-call (C419), + call-datetime-without-tzinfo (DTZ001), + call-datetime-today (DTZ002), + call-datetime-utcnow (DTZ003), + call-datetime-utcfromtimestamp (DTZ004), + call-datetime-now-without-tzinfo (DTZ005), + call-datetime-fromtimestamp (DTZ006), + call-datetime-strptime-without-zone (DTZ007), + call-date-today (DTZ011), + call-date-fromtimestamp (DTZ012), + datetime-min-max (DTZ901), + debugger (T100), + shebang-not-executable (EXE001), + shebang-missing-executable-file (EXE002), + shebang-leading-whitespace (EXE004), + shebang-not-first-line (EXE005), + future-rewritable-type-annotation (FA100), + future-required-type-annotation (FA102), + f-string-in-get-text-func-call (INT001), + format-in-get-text-func-call (INT002), + printf-in-get-text-func-call (INT003), + direct-logger-instantiation (LOG001), + invalid-get-logger-argument (LOG002), + undocumented-warn (LOG009), + exc-info-outside-except-handler (LOG014), + root-logger-call (LOG015), + logging-warn (G010), + logging-extra-attr-clash (G101), + logging-exc-info (G201), + logging-redundant-exc-info (G202), + unnecessary-placeholder (PIE790), + duplicate-class-field-definition (PIE794), + non-unique-enums (PIE796), + unnecessary-spread (PIE800), + unnecessary-dict-kwargs (PIE804), + reimplemented-container-builtin (PIE807), + unnecessary-range-start (PIE808), + multiple-starts-ends-with (PIE810), + unprefixed-type-param (PYI001), + complex-if-statement-in-stub (PYI002), + unrecognized-version-info-check (PYI003), + patch-version-comparison (PYI004), + wrong-tuple-length-version-comparison (PYI005), + bad-version-info-comparison (PYI006), + unrecognized-platform-check (PYI007), + unrecognized-platform-name (PYI008), + pass-statement-stub-body (PYI009), + non-empty-stub-body (PYI010), + pass-in-class-body (PYI012), + ellipsis-in-non-empty-class-body (PYI013), + assignment-default-in-stub (PYI015), + duplicate-union-member (PYI016), + complex-assignment-in-stub (PYI017), + unused-private-type-var (PYI018), + custom-type-var-for-self (PYI019), + quoted-annotation-in-stub (PYI020), + unaliased-collections-abc-set-import (PYI025), + type-alias-without-annotation (PYI026), + str-or-repr-defined-in-stub (PYI029), + unnecessary-literal-union (PYI030), + any-eq-ne-annotation (PYI032), + type-comment-in-stub (PYI033), + non-self-return-type (PYI034), + unassigned-special-variable-in-stub (PYI035), + bad-exit-annotation (PYI036), + redundant-numeric-union (PYI041), + snake-case-type-alias (PYI042), + t-suffixed-type-alias (PYI043), + future-annotations-in-stub (PYI044), + iter-method-return-iterable (PYI045), + unused-private-protocol (PYI046), + unused-private-type-alias (PYI047), + stub-body-multiple-statements (PYI048), + unused-private-typed-dict (PYI049), + no-return-argument-annotation-in-stub (PYI050), + unannotated-assignment-in-stub (PYI052), + unnecessary-type-union (PYI055), + byte-string-usage (PYI057), + generator-return-from-iter-method (PYI058), + generic-not-last-base-class (PYI059), + redundant-none-literal (PYI061), + duplicate-literal-member (PYI062), + pep484-style-positional-only-parameter (PYI063), + redundant-final-literal (PYI064), + bad-version-info-order (PYI066), + pytest-raises-without-exception (PT010), + pytest-duplicate-parametrize-test-cases (PT014), + pytest-deprecated-yield-fixture (PT020), + pytest-erroneous-use-fixtures-on-fixture (PT025), + pytest-use-fixtures-without-parameters (PT026), + pytest-warns-with-multiple-statements (PT031), + unnecessary-return-none (RET501), + unnecessary-assign (RET504), + duplicate-isinstance-call (SIM101), + collapsible-if (SIM102), + needless-bool (SIM103), + return-in-try-except-finally (SIM107), + enumerate-for-loop (SIM113), + if-with-same-arms (SIM114), + open-file-with-context-handler (SIM115), + multiple-with-statements (SIM117), + in-dict-keys (SIM118), + negate-equal-op (SIM201), + negate-not-equal-op (SIM202), + double-negation (SIM208), + if-expr-with-true-false (SIM210), + if-expr-with-false-true (SIM211), + expr-and-not-expr (SIM220), + expr-or-not-expr (SIM221), + expr-or-true (SIM222), + expr-and-false (SIM223), + if-else-block-instead-of-dict-get (SIM401), + split-static-string (SIM905), + zip-dict-keys-and-values (SIM911), + runtime-import-in-type-checking-block (TC004), + empty-type-checking-block (TC005), + unquoted-type-alias (TC007), + runtime-string-union (TC010), + py-path (PTH124), + invalid-pathlib-with-suffix (PTH210), + static-join-to-f-string (FLY002), + unsorted-imports (I001), + invalid-module-name (N999), + unnecessary-list-cast (PERF101), + incorrect-dict-iterator (PERF102), + manual-list-comprehension (PERF401), + manual-list-copy (PERF402), + manual-dict-comprehension (PERF403), + bare-except (E722), + io-error (E902), + invalid-escape-sequence (W605), + empty-docstring (D419), + unused-import (F401), + import-shadowed-by-loop-var (F402), + late-future-import (F404), + future-feature-not-defined (F407), + percent-format-invalid-format (F501), + percent-format-expected-mapping (F502), + percent-format-expected-sequence (F503), + percent-format-extra-named-arguments (F504), + percent-format-missing-argument (F505), + percent-format-mixed-positional-and-named (F506), + percent-format-positional-count-mismatch (F507), + percent-format-star-requires-sequence (F508), + percent-format-unsupported-format-character (F509), + string-dot-format-invalid-format (F521), + string-dot-format-extra-named-arguments (F522), + string-dot-format-extra-positional-arguments (F523), + string-dot-format-missing-arguments (F524), + string-dot-format-mixing-automatic (F525), + f-string-missing-placeholders (F541), + multi-value-repeated-key-literal (F601), + multi-value-repeated-key-variable (F602), + expressions-in-star-assignment (F621), + multiple-starred-expressions (F622), + assert-tuple (F631), + is-literal (F632), + invalid-print-syntax (F633), + if-tuple (F634), + break-outside-loop (F701), + continue-outside-loop (F702), + yield-outside-function (F704), + return-outside-function (F706), + default-except-not-last (F707), + redefined-while-unused (F811), + undefined-name (F821), + undefined-export (F822), + undefined-local (F823), + unused-variable (F841), + unused-annotation (F842), + raise-not-implemented (F901), + invalid-mock-access (PGH005), + type-name-incorrect-variance (PLC0105), + type-bivariance (PLC0131), + type-param-name-mismatch (PLC0132), + single-string-slots (PLC0205), + dict-index-missing-items (PLC0206), + iteration-over-set (PLC0208), + useless-import-alias (PLC0414), + unnecessary-direct-lambda-call (PLC3002), + yield-in-init (PLE0100), + return-in-init (PLE0101), + nonlocal-and-global (PLE0115), + continue-in-finally (PLE0116), + nonlocal-without-binding (PLE0117), + load-before-global-declaration (PLE0118), + invalid-length-return-type (PLE0303), + invalid-index-return-type (PLE0305), + invalid-str-return-type (PLE0307), + invalid-bytes-return-type (PLE0308), + invalid-hash-return-type (PLE0309), + invalid-all-object (PLE0604), + invalid-all-format (PLE0605), + potential-index-error (PLE0643), + misplaced-bare-raise (PLE0704), + repeated-keyword-argument (PLE1132), + await-outside-async (PLE1142), + logging-too-many-args (PLE1205), + logging-too-few-args (PLE1206), + bad-string-format-character (PLE1300), + bad-string-format-type (PLE1307), + bad-str-strip-call (PLE1310), + invalid-envvar-value (PLE1507), + singledispatch-method (PLE1519), + singledispatchmethod-function (PLE1520), + yield-from-in-async-function (PLE1700), + bidirectional-unicode (PLE2502), + invalid-character-backspace (PLE2510), + invalid-character-sub (PLE2512), + invalid-character-esc (PLE2513), + invalid-character-nul (PLE2514), + invalid-character-zero-width-space (PLE2515), + comparison-with-itself (PLR0124), + comparison-of-constant (PLR0133), + property-with-parameters (PLR0206), + manual-from-import (PLR0402), + redefined-argument-from-local (PLR1704), + useless-return (PLR1711), + repeated-equality-comparison (PLR1714), + boolean-chained-comparison (PLR1716), + sys-exit-alias (PLR1722), + if-stmt-min-max (PLR1730), + unnecessary-dict-index-lookup (PLR1733), + unnecessary-list-index-lookup (PLR1736), + empty-comment (PLR2044), + useless-else-on-loop (PLW0120), + self-assigning-variable (PLW0127), + redeclared-assigned-name (PLW0128), + assert-on-string-literal (PLW0129), + named-expr-without-context (PLW0131), + useless-exception-statement (PLW0133), + nan-comparison (PLW0177), + bad-staticmethod-argument (PLW0211), + super-without-brackets (PLW0245), + import-self (PLW0406), + global-variable-not-assigned (PLW0602), + global-at-module-level (PLW0604), + self-or-cls-assignment (PLW0642), + binary-op-exception (PLW0711), + bad-open-mode (PLW1501), + shallow-copy-environ (PLW1507), + invalid-envvar-default (PLW1508), + subprocess-popen-preexec-fn (PLW1509), + subprocess-run-without-check (PLW1510), + useless-with-lock (PLW2101), + useless-metaclass-type (UP001), + type-of-primitive (UP003), + useless-object-inheritance (UP004), + deprecated-unittest-alias (UP005), + non-pep585-annotation (UP006), + non-pep604-annotation-union (UP007), + super-call-with-parameters (UP008), + utf8-encoding-declaration (UP009), + unnecessary-future-import (UP010), + lru-cache-without-parameters (UP011), + unnecessary-encode-utf8 (UP012), + convert-named-tuple-functional-to-class (UP014), + datetime-timezone-utc (UP017), + native-literals (UP018), + typing-text-str-alias (UP019), + open-alias (UP020), + replace-universal-newlines (UP021), + replace-stdout-stderr (UP022), + deprecated-c-element-tree (UP023), + os-error-alias (UP024), + unicode-kind-prefix (UP025), + deprecated-mock-import (UP026), + yield-in-for-loop (UP028), + unnecessary-builtin-import (UP029), + format-literals (UP030), + printf-string-formatting (UP031), + f-string (UP032), + lru-cache-with-maxsize-none (UP033), + extraneous-parentheses (UP034), + deprecated-import (UP035), + outdated-version-block (UP036), + quoted-annotation (UP037), + unnecessary-class-parentheses (UP039), + non-pep695-type-alias (UP040), + timeout-error-alias (UP041), + unnecessary-default-type-args (UP043), + non-pep646-unpack (UP044), + non-pep604-annotation-optional (UP045), + non-pep695-generic-class (UP046), + non-pep695-generic-function (UP047), + private-type-parameter (UP049), + useless-class-metaclass-type (UP050), + print-empty-string (FURB105), + for-loop-writes (FURB122), + readlines-in-for (FURB129), + check-and-remove-from-set (FURB132), + if-expr-min-max (FURB136), + verbose-decimal-constructor (FURB157), + bit-count (FURB161), + fromisoformat-replace-z (FURB162), + redundant-log-base (FURB163), + int-on-sliced-str (FURB166), + regex-flag-alias (FURB167), + isinstance-type-none (FURB168), + type-none-comparison (FURB169), + implicit-cwd (FURB177), + hashlib-digest-hex (FURB181), + slice-to-remove-prefix-or-suffix (FURB188), + zip-instead-of-pairwise (RUF007), + mutable-dataclass-default (RUF008), + function-call-in-dataclass-default-argument (RUF009), + explicit-f-string-type-conversion (RUF010), + mutable-class-default (RUF012), + implicit-optional (RUF013), + unnecessary-iterable-allocation-for-first-element (RUF015), + invalid-index-type (RUF016), + quadratic-list-summation (RUF017), + assignment-in-assert (RUF018), + unnecessary-key-check (RUF019), + never-union (RUF020), + unsorted-dunder-all (RUF022), + unsorted-dunder-slots (RUF023), + mutable-fromkeys-value (RUF024), + default-factory-kwarg (RUF026), + invalid-formatter-suppression-comment (RUF028), + assert-with-print-message (RUF030), + decimal-from-float-literal (RUF032), + post-init-default (RUF033), + useless-if-else (RUF034), + invalid-assert-message-literal-argument (RUF040), + unnecessary-nested-literal (RUF041), + unnecessary-cast-to-int (RUF046), + map-int-version-parsing (RUF048), + dataclass-enum (RUF049), + if-key-in-dict-del (RUF051), + class-with-mixed-type-vars (RUF053), + unnecessary-round (RUF057), + starmap-zip (RUF058), + unused-unpacked-variable (RUF059), + unused-noqa (RUF100), + redirected-noqa (RUF101), + invalid-pyproject-toml (RUF200), + raise-vanilla-class (TRY002), + type-check-without-type-error (TRY004), + verbose-raise (TRY201), + useless-try-except (TRY203), + try-consider-else (TRY300), + verbose-log-message (TRY401), + ] + ", + ); + Ok(()) +} diff --git a/crates/ruff/tests/integration_test.rs b/crates/ruff/tests/integration_test.rs index 8149004565770..cc6678882a5bb 100644 --- a/crates/ruff/tests/integration_test.rs +++ b/crates/ruff/tests/integration_test.rs @@ -876,7 +876,9 @@ fn parse_error_not_included() { #[test] fn full_output_preview() { - let mut cmd = RuffCheck::default().args(["--preview"]).build(); + let mut cmd = RuffCheck::default() + .args(["--preview", "--select=E741"]) + .build(); assert_cmd_snapshot!(cmd .pass_stdin("l = 1"), @" success: false @@ -907,7 +909,7 @@ preview = true ", )?; let mut cmd = RuffCheck::default().config(&pyproject_toml).build(); - assert_cmd_snapshot!(cmd.pass_stdin("l = 1"), @" + assert_cmd_snapshot!(cmd.arg("--select=E741").pass_stdin("l = 1"), @" success: false exit_code: 1 ----- stdout ----- diff --git a/crates/ruff_linter/src/rule_selector.rs b/crates/ruff_linter/src/rule_selector.rs index b3eee0d8370b3..b3e08407e94ea 100644 --- a/crates/ruff_linter/src/rule_selector.rs +++ b/crates/ruff_linter/src/rule_selector.rs @@ -35,6 +35,15 @@ pub enum RuleSelector { }, } +impl RuleSelector { + pub(crate) const fn rule(prefix: RuleCodePrefix) -> Self { + Self::Rule { + prefix, + redirected_from: None, + } + } +} + impl From for RuleSelector { fn from(linter: Linter) -> Self { Self::Linter(linter) diff --git a/crates/ruff_linter/src/settings/mod.rs b/crates/ruff_linter/src/settings/mod.rs index 75f9bfe680408..b098d891d97e4 100644 --- a/crates/ruff_linter/src/settings/mod.rs +++ b/crates/ruff_linter/src/settings/mod.rs @@ -371,6 +371,422 @@ pub const DEFAULT_SELECTORS: &[RuleSelector] = &[ }, ]; +#[rustfmt::skip] +pub const PREVIEW_DEFAULT_SELECTORS: &[RuleSelector] = &[ + RuleSelector::rule(RuleCodePrefix::Flake8Async(codes::Flake8Async::_100)), // ASYNC100 + RuleSelector::rule(RuleCodePrefix::Flake8Async(codes::Flake8Async::_105)), // ASYNC105 + RuleSelector::rule(RuleCodePrefix::Flake8Async(codes::Flake8Async::_115)), // ASYNC115 + RuleSelector::rule(RuleCodePrefix::Flake8Async(codes::Flake8Async::_116)), // ASYNC116 + RuleSelector::rule(RuleCodePrefix::Flake8Async(codes::Flake8Async::_210)), // ASYNC210 + RuleSelector::rule(RuleCodePrefix::Flake8Async(codes::Flake8Async::_220)), // ASYNC220 + RuleSelector::rule(RuleCodePrefix::Flake8Async(codes::Flake8Async::_221)), // ASYNC221 + RuleSelector::rule(RuleCodePrefix::Flake8Async(codes::Flake8Async::_222)), // ASYNC222 + RuleSelector::rule(RuleCodePrefix::Flake8Async(codes::Flake8Async::_230)), // ASYNC230 + RuleSelector::rule(RuleCodePrefix::Flake8Async(codes::Flake8Async::_251)), // ASYNC251 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_002)), // B002 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_003)), // B003 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_004)), // B004 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_005)), // B005 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_006)), // B006 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_008)), // B008 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_009)), // B009 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_010)), // B010 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_012)), // B012 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_013)), // B013 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_014)), // B014 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_015)), // B015 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_016)), // B016 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_017)), // B017 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_018)), // B018 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_019)), // B019 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_020)), // B020 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_021)), // B021 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_022)), // B022 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_023)), // B023 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_025)), // B025 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_026)), // B026 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_029)), // B029 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_030)), // B030 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_031)), // B031 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_032)), // B032 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_033)), // B033 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_035)), // B035 + RuleSelector::rule(RuleCodePrefix::Flake8Bugbear(codes::Flake8Bugbear::_039)), // B039 + RuleSelector::rule(RuleCodePrefix::Flake8BlindExcept(codes::Flake8BlindExcept::_001)), // BLE001 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_00)), // C400 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_01)), // C401 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_02)), // C402 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_03)), // C403 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_04)), // C404 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_05)), // C405 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_06)), // C406 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_08)), // C408 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_09)), // C409 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_10)), // C410 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_11)), // C411 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_13)), // C413 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_14)), // C414 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_15)), // C415 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_17)), // C417 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_18)), // C418 + RuleSelector::rule(RuleCodePrefix::Flake8Comprehensions(codes::Flake8Comprehensions::_19)), // C419 + RuleSelector::rule(RuleCodePrefix::Pydocstyle(codes::Pydocstyle::_419)), // D419 + RuleSelector::rule(RuleCodePrefix::Flake8Datetimez(codes::Flake8Datetimez::_001)), // DTZ001 + RuleSelector::rule(RuleCodePrefix::Flake8Datetimez(codes::Flake8Datetimez::_002)), // DTZ002 + RuleSelector::rule(RuleCodePrefix::Flake8Datetimez(codes::Flake8Datetimez::_003)), // DTZ003 + RuleSelector::rule(RuleCodePrefix::Flake8Datetimez(codes::Flake8Datetimez::_004)), // DTZ004 + RuleSelector::rule(RuleCodePrefix::Flake8Datetimez(codes::Flake8Datetimez::_005)), // DTZ005 + RuleSelector::rule(RuleCodePrefix::Flake8Datetimez(codes::Flake8Datetimez::_006)), // DTZ006 + RuleSelector::rule(RuleCodePrefix::Flake8Datetimez(codes::Flake8Datetimez::_007)), // DTZ007 + RuleSelector::rule(RuleCodePrefix::Flake8Datetimez(codes::Flake8Datetimez::_011)), // DTZ011 + RuleSelector::rule(RuleCodePrefix::Flake8Datetimez(codes::Flake8Datetimez::_012)), // DTZ012 + RuleSelector::rule(RuleCodePrefix::Flake8Datetimez(codes::Flake8Datetimez::_901)), // DTZ901 + RuleSelector::rule(RuleCodePrefix::Pycodestyle(codes::Pycodestyle::E722)), // E722 + RuleSelector::rule(RuleCodePrefix::Pycodestyle(codes::Pycodestyle::E902)), // E902 + RuleSelector::rule(RuleCodePrefix::Flake8Executable(codes::Flake8Executable::_001)), // EXE001 + RuleSelector::rule(RuleCodePrefix::Flake8Executable(codes::Flake8Executable::_002)), // EXE002 + RuleSelector::rule(RuleCodePrefix::Flake8Executable(codes::Flake8Executable::_004)), // EXE004 + RuleSelector::rule(RuleCodePrefix::Flake8Executable(codes::Flake8Executable::_005)), // EXE005 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_401)), // F401 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_402)), // F402 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_404)), // F404 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_407)), // F407 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_501)), // F501 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_502)), // F502 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_503)), // F503 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_504)), // F504 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_505)), // F505 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_506)), // F506 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_507)), // F507 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_508)), // F508 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_509)), // F509 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_521)), // F521 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_522)), // F522 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_523)), // F523 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_524)), // F524 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_525)), // F525 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_541)), // F541 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_601)), // F601 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_602)), // F602 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_621)), // F621 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_622)), // F622 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_631)), // F631 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_632)), // F632 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_633)), // F633 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_634)), // F634 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_701)), // F701 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_702)), // F702 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_704)), // F704 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_706)), // F706 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_707)), // F707 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_811)), // F811 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_821)), // F821 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_822)), // F822 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_823)), // F823 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_841)), // F841 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_842)), // F842 + RuleSelector::rule(RuleCodePrefix::Pyflakes(codes::Pyflakes::_901)), // F901 + RuleSelector::rule(RuleCodePrefix::Flake8FutureAnnotations(codes::Flake8FutureAnnotations::_100)), // FA100 + RuleSelector::rule(RuleCodePrefix::Flake8FutureAnnotations(codes::Flake8FutureAnnotations::_102)), // FA102 + RuleSelector::rule(RuleCodePrefix::Flynt(codes::Flynt::_002)), // FLY002 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_105)), // FURB105 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_122)), // FURB122 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_129)), // FURB129 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_132)), // FURB132 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_136)), // FURB136 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_157)), // FURB157 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_161)), // FURB161 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_162)), // FURB162 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_163)), // FURB163 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_166)), // FURB166 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_167)), // FURB167 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_168)), // FURB168 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_169)), // FURB169 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_177)), // FURB177 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_181)), // FURB181 + RuleSelector::rule(RuleCodePrefix::Refurb(codes::Refurb::_188)), // FURB188 + RuleSelector::rule(RuleCodePrefix::Flake8LoggingFormat(codes::Flake8LoggingFormat::_010)), // G010 + RuleSelector::rule(RuleCodePrefix::Flake8LoggingFormat(codes::Flake8LoggingFormat::_101)), // G101 + RuleSelector::rule(RuleCodePrefix::Flake8LoggingFormat(codes::Flake8LoggingFormat::_201)), // G201 + RuleSelector::rule(RuleCodePrefix::Flake8LoggingFormat(codes::Flake8LoggingFormat::_202)), // G202 + RuleSelector::rule(RuleCodePrefix::Isort(codes::Isort::_001)), // I001 + RuleSelector::rule(RuleCodePrefix::Flake8GetText(codes::Flake8GetText::_001)), // INT001 + RuleSelector::rule(RuleCodePrefix::Flake8GetText(codes::Flake8GetText::_002)), // INT002 + RuleSelector::rule(RuleCodePrefix::Flake8GetText(codes::Flake8GetText::_003)), // INT003 + RuleSelector::rule(RuleCodePrefix::Flake8Logging(codes::Flake8Logging::_001)), // LOG001 + RuleSelector::rule(RuleCodePrefix::Flake8Logging(codes::Flake8Logging::_002)), // LOG002 + RuleSelector::rule(RuleCodePrefix::Flake8Logging(codes::Flake8Logging::_009)), // LOG009 + RuleSelector::rule(RuleCodePrefix::Flake8Logging(codes::Flake8Logging::_014)), // LOG014 + RuleSelector::rule(RuleCodePrefix::Flake8Logging(codes::Flake8Logging::_015)), // LOG015 + RuleSelector::rule(RuleCodePrefix::PEP8Naming(codes::PEP8Naming::_999)), // N999 + RuleSelector::rule(RuleCodePrefix::Perflint(codes::Perflint::_101)), // PERF101 + RuleSelector::rule(RuleCodePrefix::Perflint(codes::Perflint::_102)), // PERF102 + RuleSelector::rule(RuleCodePrefix::Perflint(codes::Perflint::_401)), // PERF401 + RuleSelector::rule(RuleCodePrefix::Perflint(codes::Perflint::_402)), // PERF402 + RuleSelector::rule(RuleCodePrefix::Perflint(codes::Perflint::_403)), // PERF403 + RuleSelector::rule(RuleCodePrefix::PygrepHooks(codes::PygrepHooks::_005)), // PGH005 + RuleSelector::rule(RuleCodePrefix::Flake8Pie(codes::Flake8Pie::_790)), // PIE790 + RuleSelector::rule(RuleCodePrefix::Flake8Pie(codes::Flake8Pie::_794)), // PIE794 + RuleSelector::rule(RuleCodePrefix::Flake8Pie(codes::Flake8Pie::_796)), // PIE796 + RuleSelector::rule(RuleCodePrefix::Flake8Pie(codes::Flake8Pie::_800)), // PIE800 + RuleSelector::rule(RuleCodePrefix::Flake8Pie(codes::Flake8Pie::_804)), // PIE804 + RuleSelector::rule(RuleCodePrefix::Flake8Pie(codes::Flake8Pie::_807)), // PIE807 + RuleSelector::rule(RuleCodePrefix::Flake8Pie(codes::Flake8Pie::_808)), // PIE808 + RuleSelector::rule(RuleCodePrefix::Flake8Pie(codes::Flake8Pie::_810)), // PIE810 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::C0105)), // PLC0105 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::C0131)), // PLC0131 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::C0132)), // PLC0132 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::C0205)), // PLC0205 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::C0206)), // PLC0206 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::C0208)), // PLC0208 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::C0414)), // PLC0414 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::C3002)), // PLC3002 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0100)), // PLE0100 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0101)), // PLE0101 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0115)), // PLE0115 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0116)), // PLE0116 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0117)), // PLE0117 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0118)), // PLE0118 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0303)), // PLE0303 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0305)), // PLE0305 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0307)), // PLE0307 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0308)), // PLE0308 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0309)), // PLE0309 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0604)), // PLE0604 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0605)), // PLE0605 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0643)), // PLE0643 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E0704)), // PLE0704 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1132)), // PLE1132 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1142)), // PLE1142 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1205)), // PLE1205 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1206)), // PLE1206 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1300)), // PLE1300 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1307)), // PLE1307 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1310)), // PLE1310 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1507)), // PLE1507 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1519)), // PLE1519 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1520)), // PLE1520 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E1700)), // PLE1700 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E2502)), // PLE2502 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E2510)), // PLE2510 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E2512)), // PLE2512 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E2513)), // PLE2513 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E2514)), // PLE2514 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::E2515)), // PLE2515 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R0124)), // PLR0124 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R0133)), // PLR0133 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R0206)), // PLR0206 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R0402)), // PLR0402 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R1704)), // PLR1704 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R1711)), // PLR1711 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R1714)), // PLR1714 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R1716)), // PLR1716 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R1722)), // PLR1722 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R1730)), // PLR1730 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R1733)), // PLR1733 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R1736)), // PLR1736 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::R2044)), // PLR2044 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0120)), // PLW0120 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0127)), // PLW0127 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0128)), // PLW0128 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0129)), // PLW0129 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0131)), // PLW0131 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0133)), // PLW0133 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0177)), // PLW0177 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0211)), // PLW0211 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0245)), // PLW0245 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0406)), // PLW0406 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0602)), // PLW0602 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0604)), // PLW0604 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0642)), // PLW0642 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W0711)), // PLW0711 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W1501)), // PLW1501 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W1507)), // PLW1507 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W1508)), // PLW1508 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W1509)), // PLW1509 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W1510)), // PLW1510 + RuleSelector::rule(RuleCodePrefix::Pylint(codes::Pylint::W2101)), // PLW2101 + RuleSelector::rule(RuleCodePrefix::Flake8PytestStyle(codes::Flake8PytestStyle::_010)), // PT010 + RuleSelector::rule(RuleCodePrefix::Flake8PytestStyle(codes::Flake8PytestStyle::_014)), // PT014 + RuleSelector::rule(RuleCodePrefix::Flake8PytestStyle(codes::Flake8PytestStyle::_020)), // PT020 + RuleSelector::rule(RuleCodePrefix::Flake8PytestStyle(codes::Flake8PytestStyle::_025)), // PT025 + RuleSelector::rule(RuleCodePrefix::Flake8PytestStyle(codes::Flake8PytestStyle::_026)), // PT026 + RuleSelector::rule(RuleCodePrefix::Flake8PytestStyle(codes::Flake8PytestStyle::_031)), // PT031 + RuleSelector::rule(RuleCodePrefix::Flake8UsePathlib(codes::Flake8UsePathlib::_124)), // PTH124 + RuleSelector::rule(RuleCodePrefix::Flake8UsePathlib(codes::Flake8UsePathlib::_210)), // PTH210 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_001)), // PYI001 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_002)), // PYI002 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_003)), // PYI003 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_004)), // PYI004 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_005)), // PYI005 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_006)), // PYI006 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_007)), // PYI007 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_008)), // PYI008 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_009)), // PYI009 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_010)), // PYI010 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_012)), // PYI012 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_013)), // PYI013 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_015)), // PYI015 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_016)), // PYI016 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_017)), // PYI017 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_018)), // PYI018 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_019)), // PYI019 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_020)), // PYI020 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_025)), // PYI025 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_026)), // PYI026 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_029)), // PYI029 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_030)), // PYI030 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_032)), // PYI032 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_033)), // PYI033 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_034)), // PYI034 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_035)), // PYI035 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_036)), // PYI036 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_041)), // PYI041 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_042)), // PYI042 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_043)), // PYI043 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_044)), // PYI044 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_045)), // PYI045 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_046)), // PYI046 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_047)), // PYI047 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_048)), // PYI048 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_049)), // PYI049 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_050)), // PYI050 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_052)), // PYI052 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_055)), // PYI055 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_057)), // PYI057 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_058)), // PYI058 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_059)), // PYI059 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_061)), // PYI061 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_062)), // PYI062 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_063)), // PYI063 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_064)), // PYI064 + RuleSelector::rule(RuleCodePrefix::Flake8Pyi(codes::Flake8Pyi::_066)), // PYI066 + RuleSelector::rule(RuleCodePrefix::Flake8Return(codes::Flake8Return::_501)), // RET501 + RuleSelector::rule(RuleCodePrefix::Flake8Return(codes::Flake8Return::_504)), // RET504 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_007)), // RUF007 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_008)), // RUF008 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_009)), // RUF009 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_010)), // RUF010 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_012)), // RUF012 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_013)), // RUF013 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_015)), // RUF015 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_016)), // RUF016 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_017)), // RUF017 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_018)), // RUF018 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_019)), // RUF019 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_020)), // RUF020 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_022)), // RUF022 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_023)), // RUF023 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_024)), // RUF024 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_026)), // RUF026 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_028)), // RUF028 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_030)), // RUF030 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_032)), // RUF032 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_033)), // RUF033 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_034)), // RUF034 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_040)), // RUF040 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_041)), // RUF041 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_046)), // RUF046 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_048)), // RUF048 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_049)), // RUF049 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_051)), // RUF051 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_053)), // RUF053 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_057)), // RUF057 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_058)), // RUF058 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_059)), // RUF059 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_100)), // RUF100 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_101)), // RUF101 + RuleSelector::rule(RuleCodePrefix::Ruff(codes::Ruff::_200)), // RUF200 + RuleSelector::rule(RuleCodePrefix::Flake8Bandit(codes::Flake8Bandit::_102)), // S102 + RuleSelector::rule(RuleCodePrefix::Flake8Bandit(codes::Flake8Bandit::_110)), // S110 + RuleSelector::rule(RuleCodePrefix::Flake8Bandit(codes::Flake8Bandit::_112)), // S112 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_101)), // SIM101 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_102)), // SIM102 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_103)), // SIM103 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_107)), // SIM107 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_113)), // SIM113 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_114)), // SIM114 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_115)), // SIM115 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_117)), // SIM117 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_118)), // SIM118 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_201)), // SIM201 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_202)), // SIM202 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_208)), // SIM208 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_210)), // SIM210 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_211)), // SIM211 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_220)), // SIM220 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_221)), // SIM221 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_222)), // SIM222 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_223)), // SIM223 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_401)), // SIM401 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_905)), // SIM905 + RuleSelector::rule(RuleCodePrefix::Flake8Simplify(codes::Flake8Simplify::_911)), // SIM911 + RuleSelector::rule(RuleCodePrefix::Flake8Debugger(codes::Flake8Debugger::_0)), // T100 + RuleSelector::rule(RuleCodePrefix::Flake8TypeChecking(codes::Flake8TypeChecking::_004)), // TC004 + RuleSelector::rule(RuleCodePrefix::Flake8TypeChecking(codes::Flake8TypeChecking::_005)), // TC005 + RuleSelector::rule(RuleCodePrefix::Flake8TypeChecking(codes::Flake8TypeChecking::_007)), // TC007 + RuleSelector::rule(RuleCodePrefix::Flake8TypeChecking(codes::Flake8TypeChecking::_010)), // TC010 + RuleSelector::rule(RuleCodePrefix::Tryceratops(codes::Tryceratops::_002)), // TRY002 + RuleSelector::rule(RuleCodePrefix::Tryceratops(codes::Tryceratops::_004)), // TRY004 + RuleSelector::rule(RuleCodePrefix::Tryceratops(codes::Tryceratops::_201)), // TRY201 + RuleSelector::rule(RuleCodePrefix::Tryceratops(codes::Tryceratops::_203)), // TRY203 + RuleSelector::rule(RuleCodePrefix::Tryceratops(codes::Tryceratops::_300)), // TRY300 + RuleSelector::rule(RuleCodePrefix::Tryceratops(codes::Tryceratops::_401)), // TRY401 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_001)), // UP001 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_003)), // UP003 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_004)), // UP004 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_005)), // UP005 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_006)), // UP006 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_007)), // UP007 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_008)), // UP008 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_009)), // UP009 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_010)), // UP010 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_011)), // UP011 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_012)), // UP012 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_014)), // UP014 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_017)), // UP017 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_018)), // UP018 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_019)), // UP019 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_020)), // UP020 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_021)), // UP021 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_022)), // UP022 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_023)), // UP023 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_024)), // UP024 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_025)), // UP025 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_026)), // UP026 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_028)), // UP028 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_029)), // UP029 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_030)), // UP030 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_031)), // UP031 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_032)), // UP032 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_033)), // UP033 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_034)), // UP034 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_035)), // UP035 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_036)), // UP036 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_037)), // UP037 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_039)), // UP039 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_040)), // UP040 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_041)), // UP041 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_043)), // UP043 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_044)), // UP044 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_045)), // UP045 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_046)), // UP046 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_047)), // UP047 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_049)), // UP049 + RuleSelector::rule(RuleCodePrefix::Pyupgrade(codes::Pyupgrade::_050)), // UP050 + RuleSelector::rule(RuleCodePrefix::Pycodestyle(codes::Pycodestyle::W605)), // W605 + RuleSelector::rule(RuleCodePrefix::Flake82020(codes::Flake82020::_101)), // YTT101 + RuleSelector::rule(RuleCodePrefix::Flake82020(codes::Flake82020::_102)), // YTT102 + RuleSelector::rule(RuleCodePrefix::Flake82020(codes::Flake82020::_103)), // YTT103 + RuleSelector::rule(RuleCodePrefix::Flake82020(codes::Flake82020::_201)), // YTT201 + RuleSelector::rule(RuleCodePrefix::Flake82020(codes::Flake82020::_202)), // YTT202 + RuleSelector::rule(RuleCodePrefix::Flake82020(codes::Flake82020::_203)), // YTT203 + RuleSelector::rule(RuleCodePrefix::Flake82020(codes::Flake82020::_204)), // YTT204 + RuleSelector::rule(RuleCodePrefix::Flake82020(codes::Flake82020::_301)), // YTT301 + RuleSelector::rule(RuleCodePrefix::Flake82020(codes::Flake82020::_302)), // YTT302 + RuleSelector::rule(RuleCodePrefix::Flake82020(codes::Flake82020::_303)), // YTT303 +]; + pub const TASK_TAGS: &[&str] = &["TODO", "FIXME", "XXX"]; pub static DUMMY_VARIABLE_RGX: LazyLock = diff --git a/crates/ruff_workspace/src/configuration.rs b/crates/ruff_workspace/src/configuration.rs index 5c204b3a0078c..48a580e50961d 100644 --- a/crates/ruff_workspace/src/configuration.rs +++ b/crates/ruff_workspace/src/configuration.rs @@ -33,7 +33,8 @@ use ruff_linter::settings::types::{ RequiredVersion, UnsafeFixes, }; use ruff_linter::settings::{ - DEFAULT_SELECTORS, DUMMY_VARIABLE_RGX, LinterSettings, TASK_TAGS, TargetVersion, + DEFAULT_SELECTORS, DUMMY_VARIABLE_RGX, LinterSettings, PREVIEW_DEFAULT_SELECTORS, TASK_TAGS, + TargetVersion, }; use ruff_linter::{ RuleSelector, fs, warn_user_once, warn_user_once_by_id, warn_user_once_by_message, @@ -831,8 +832,14 @@ impl LintConfiguration { require_explicit: self.explicit_preview_rules.unwrap_or_default(), }; + let selectors = if preview.mode.is_enabled() { + PREVIEW_DEFAULT_SELECTORS + } else { + DEFAULT_SELECTORS + }; + // The select_set keeps track of which rules have been selected. - let mut select_set: RuleSet = DEFAULT_SELECTORS + let mut select_set: RuleSet = selectors .iter() .flat_map(|selector| selector.rules(&preview)) .collect(); diff --git a/scripts/generate_mkdocs.py b/scripts/generate_mkdocs.py index d78307b28e42c..c043ff79ad819 100644 --- a/scripts/generate_mkdocs.py +++ b/scripts/generate_mkdocs.py @@ -73,6 +73,7 @@ class Section(NamedTuple): "https://docs.astral.sh/ruff/rules/": "rules.md", "https://docs.astral.sh/ruff/settings/": "settings.md", "#whos-using-ruff": "https://github.com/astral-sh/ruff#whos-using-ruff", + "https://docs.astral.sh/ruff/preview/": "preview.md", }