Rename rules currently not conforming to naming convention

crates/ruff/src/commands/format.rs

@@ -799,7 +799,7 @@ pub(super) fn warn_incompatible_formatter_settings(resolver: &Resolver) {
             // ```
             Rule::MissingTrailingComma,
             // The formatter always removes blank lines before the docstring.
-            Rule::OneBlankLineBeforeClass,
+            Rule::IncorrectBlankLineBeforeClass,
         ] {
             if setting.linter.rules.enabled(rule) {
                 incompatible_rules.insert(rule);
@@ -830,7 +830,7 @@ pub(super) fn warn_incompatible_formatter_settings(resolver: &Resolver) {
         }
 
         // Validate all rules that rely on tab styles.
-        if setting.linter.rules.enabled(Rule::IndentWithSpaces)
+        if setting.linter.rules.enabled(Rule::DocstringTabIndentation)
             && setting.formatter.indent_style.is_tab()
         {
             warn_user_once!("The `format.indent-style=\"tab\"` option is incompatible with `D206`, with requires space-based indentation. We recommend disabling these rules when using the formatter, which enforces a consistent indentation style. Alternatively, set the `format.indent-style` option to `\"space\"`.");

crates/ruff/tests/format.rs

@@ -1112,7 +1112,7 @@ def say_hy(name: str):
     1 file reformatted
 
     ----- stderr -----
-    warning: `one-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible. Ignoring `one-blank-line-before-class`.
+    warning: `incorrect-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible. Ignoring `incorrect-blank-line-before-class`.
     warning: `multi-line-summary-first-line` (D212) and `multi-line-summary-second-line` (D213) are incompatible. Ignoring `multi-line-summary-second-line`.
     warning: The following rules may cause conflicts when used with the formatter: `COM812`, `ISC001`. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding them to the `ignore` configuration.
     ");

crates/ruff/tests/integration_test.rs

@@ -1037,7 +1037,7 @@ fn preview_enabled_all() {
     [*] 1 fixable with the `--fix` option (1 hidden fix can be enabled with the `--unsafe-fixes` option).
 
     ----- stderr -----
-    warning: `one-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible. Ignoring `one-blank-line-before-class`.
+    warning: `incorrect-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible. Ignoring `incorrect-blank-line-before-class`.
     warning: `multi-line-summary-first-line` (D212) and `multi-line-summary-second-line` (D213) are incompatible. Ignoring `multi-line-summary-second-line`.
     ");
 }

crates/ruff_linter/resources/test/fixtures/pydocstyle/D202.py

@@ -1,4 +1,4 @@
-"""Test: no-blank-line-after-function special-cases around comment handling."""
+"""Test: blank-line-after-function special-cases around comment handling."""
 
 # OK
 def outer():

crates/ruff_linter/src/checkers/ast/analyze/definitions.rs

@@ -34,40 +34,40 @@ pub(crate) fn definitions(checker: &mut Checker) {
     let enforce_stubs_and_runtime = checker.enabled(Rule::IterMethodReturnIterable);
     let enforce_dunder_method = checker.enabled(Rule::BadDunderMethodName);
     let enforce_docstrings = checker.any_enabled(&[
-        Rule::BlankLineAfterLastSection,
-        Rule::BlankLineAfterSummary,
+        Rule::MissingBlankLineAfterLastSection,
+        Rule::MissingBlankLineAfterSummary,
         Rule::BlankLineBeforeClass,
         Rule::BlankLinesBetweenHeaderAndContent,
-        Rule::CapitalizeSectionName,
-        Rule::DashedUnderlineAfterSection,
+        Rule::NonCapitalizedSectionName,
+        Rule::MissingDashedUnderlineAfterSection,
         Rule::DocstringStartsWithThis,
         Rule::EmptyDocstring,
         Rule::EmptyDocstringSection,
-        Rule::EndsInPeriod,
-        Rule::EndsInPunctuation,
+        Rule::MissingTrailingPeriod,
+        Rule::MissingTerminalPunctuation,
         Rule::EscapeSequenceInDocstring,
         Rule::FirstWordUncapitalized,
-        Rule::FitsOnOneLine,
-        Rule::IndentWithSpaces,
+        Rule::UnnecessaryMultilineDocstring,
+        Rule::DocstringTabIndentation,
         Rule::MultiLineSummaryFirstLine,
         Rule::MultiLineSummarySecondLine,
         Rule::NewLineAfterLastParagraph,
-        Rule::NewLineAfterSectionName,
-        Rule::NoBlankLineAfterFunction,
+        Rule::MissingNewLineAfterSectionName,
+        Rule::BlankLineAfterFunction,
         Rule::NoBlankLineAfterSection,
-        Rule::NoBlankLineBeforeFunction,
+        Rule::BlankLineBeforeFunction,
         Rule::NoBlankLineBeforeSection,
-        Rule::NoSignature,
+        Rule::SignatureInDocstring,
         Rule::NonImperativeMood,
-        Rule::OneBlankLineAfterClass,
-        Rule::OneBlankLineBeforeClass,
+        Rule::IncorrectBlankLineAfterClass,
+        Rule::IncorrectBlankLineBeforeClass,
         Rule::OverIndentation,
         Rule::OverloadWithDocstring,
-        Rule::SectionNameEndsInColon,
-        Rule::SectionNotOverIndented,
-        Rule::SectionUnderlineAfterName,
-        Rule::SectionUnderlineMatchesSectionLength,
-        Rule::SectionUnderlineNotOverIndented,
+        Rule::MissingSectionNameColon,
+        Rule::OverindentedSection,
+        Rule::MissingSectionUnderlineAfterName,
+        Rule::MismatchedSectionUnderlineLength,
+        Rule::OverindentedSectionUnderline,
         Rule::SurroundingWhitespace,
         Rule::TripleSingleQuotes,
         Rule::UnderIndentation,
@@ -220,27 +220,24 @@ pub(crate) fn definitions(checker: &mut Checker) {
             if !pydocstyle::rules::not_empty(checker, &docstring) {
                 continue;
             }
-            if checker.enabled(Rule::FitsOnOneLine) {
+            if checker.enabled(Rule::UnnecessaryMultilineDocstring) {
                 pydocstyle::rules::one_liner(checker, &docstring);
             }
-            if checker.any_enabled(&[
-                Rule::NoBlankLineAfterFunction,
-                Rule::NoBlankLineBeforeFunction,
-            ]) {
+            if checker.any_enabled(&[Rule::BlankLineAfterFunction, Rule::BlankLineBeforeFunction]) {
                 pydocstyle::rules::blank_before_after_function(checker, &docstring);
             }
             if checker.any_enabled(&[
                 Rule::BlankLineBeforeClass,
-                Rule::OneBlankLineAfterClass,
-                Rule::OneBlankLineBeforeClass,
+                Rule::IncorrectBlankLineAfterClass,
+                Rule::IncorrectBlankLineBeforeClass,
             ]) {
                 pydocstyle::rules::blank_before_after_class(checker, &docstring);
             }
-            if checker.enabled(Rule::BlankLineAfterSummary) {
+            if checker.enabled(Rule::MissingBlankLineAfterSummary) {
                 pydocstyle::rules::blank_after_summary(checker, &docstring);
             }
             if checker.any_enabled(&[
-                Rule::IndentWithSpaces,
+                Rule::DocstringTabIndentation,
                 Rule::OverIndentation,
                 Rule::UnderIndentation,
             ]) {
@@ -264,7 +261,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
             if checker.enabled(Rule::EscapeSequenceInDocstring) {
                 pydocstyle::rules::backslashes(checker, &docstring);
             }
-            if checker.enabled(Rule::EndsInPeriod) {
+            if checker.enabled(Rule::MissingTrailingPeriod) {
                 pydocstyle::rules::ends_with_period(checker, &docstring);
             }
             if checker.enabled(Rule::NonImperativeMood) {
@@ -274,7 +271,7 @@ pub(crate) fn definitions(checker: &mut Checker) {
                     &checker.settings.pydocstyle,
                 );
             }
-            if checker.enabled(Rule::NoSignature) {
+            if checker.enabled(Rule::SignatureInDocstring) {
                 pydocstyle::rules::no_signature(checker, &docstring);
             }
             if checker.enabled(Rule::FirstWordUncapitalized) {
@@ -283,28 +280,28 @@ pub(crate) fn definitions(checker: &mut Checker) {
             if checker.enabled(Rule::DocstringStartsWithThis) {
                 pydocstyle::rules::starts_with_this(checker, &docstring);
             }
-            if checker.enabled(Rule::EndsInPunctuation) {
+            if checker.enabled(Rule::MissingTerminalPunctuation) {
                 pydocstyle::rules::ends_with_punctuation(checker, &docstring);
             }
             if checker.enabled(Rule::OverloadWithDocstring) {
                 pydocstyle::rules::if_needed(checker, &docstring);
             }
 
             let enforce_sections = checker.any_enabled(&[
-                Rule::BlankLineAfterLastSection,
+                Rule::MissingBlankLineAfterLastSection,
                 Rule::BlankLinesBetweenHeaderAndContent,
-                Rule::CapitalizeSectionName,
-                Rule::DashedUnderlineAfterSection,
+                Rule::NonCapitalizedSectionName,
+                Rule::MissingDashedUnderlineAfterSection,
                 Rule::EmptyDocstringSection,
                 Rule::MultiLineSummaryFirstLine,
-                Rule::NewLineAfterSectionName,
+                Rule::MissingNewLineAfterSectionName,
                 Rule::NoBlankLineAfterSection,
                 Rule::NoBlankLineBeforeSection,
-                Rule::SectionNameEndsInColon,
-                Rule::SectionNotOverIndented,
-                Rule::SectionUnderlineAfterName,
-                Rule::SectionUnderlineMatchesSectionLength,
-                Rule::SectionUnderlineNotOverIndented,
+                Rule::MissingSectionNameColon,
+                Rule::OverindentedSection,
+                Rule::MissingSectionUnderlineAfterName,
+                Rule::MismatchedSectionUnderlineLength,
+                Rule::OverindentedSectionUnderline,
                 Rule::UndocumentedParam,
             ]);
             if enforce_sections || enforce_pydoclint {

crates/ruff_linter/src/codes.rs

@@ -545,41 +545,41 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pydocstyle, "105") => (RuleGroup::Stable, rules::pydocstyle::rules::UndocumentedMagicMethod),
         (Pydocstyle, "106") => (RuleGroup::Stable, rules::pydocstyle::rules::UndocumentedPublicNestedClass),
         (Pydocstyle, "107") => (RuleGroup::Stable, rules::pydocstyle::rules::UndocumentedPublicInit),
-        (Pydocstyle, "200") => (RuleGroup::Stable, rules::pydocstyle::rules::FitsOnOneLine),
-        (Pydocstyle, "201") => (RuleGroup::Stable, rules::pydocstyle::rules::NoBlankLineBeforeFunction),
-        (Pydocstyle, "202") => (RuleGroup::Stable, rules::pydocstyle::rules::NoBlankLineAfterFunction),
-        (Pydocstyle, "203") => (RuleGroup::Stable, rules::pydocstyle::rules::OneBlankLineBeforeClass),
-        (Pydocstyle, "204") => (RuleGroup::Stable, rules::pydocstyle::rules::OneBlankLineAfterClass),
-        (Pydocstyle, "205") => (RuleGroup::Stable, rules::pydocstyle::rules::BlankLineAfterSummary),
-        (Pydocstyle, "206") => (RuleGroup::Stable, rules::pydocstyle::rules::IndentWithSpaces),
+        (Pydocstyle, "200") => (RuleGroup::Stable, rules::pydocstyle::rules::UnnecessaryMultilineDocstring),
+        (Pydocstyle, "201") => (RuleGroup::Stable, rules::pydocstyle::rules::BlankLineBeforeFunction),
+        (Pydocstyle, "202") => (RuleGroup::Stable, rules::pydocstyle::rules::BlankLineAfterFunction),
+        (Pydocstyle, "203") => (RuleGroup::Stable, rules::pydocstyle::rules::IncorrectBlankLineBeforeClass),
+        (Pydocstyle, "204") => (RuleGroup::Stable, rules::pydocstyle::rules::IncorrectBlankLineAfterClass),
+        (Pydocstyle, "205") => (RuleGroup::Stable, rules::pydocstyle::rules::MissingBlankLineAfterSummary),
+        (Pydocstyle, "206") => (RuleGroup::Stable, rules::pydocstyle::rules::DocstringTabIndentation),
         (Pydocstyle, "207") => (RuleGroup::Stable, rules::pydocstyle::rules::UnderIndentation),
         (Pydocstyle, "208") => (RuleGroup::Stable, rules::pydocstyle::rules::OverIndentation),
         (Pydocstyle, "209") => (RuleGroup::Stable, rules::pydocstyle::rules::NewLineAfterLastParagraph),
         (Pydocstyle, "210") => (RuleGroup::Stable, rules::pydocstyle::rules::SurroundingWhitespace),
         (Pydocstyle, "211") => (RuleGroup::Stable, rules::pydocstyle::rules::BlankLineBeforeClass),
         (Pydocstyle, "212") => (RuleGroup::Stable, rules::pydocstyle::rules::MultiLineSummaryFirstLine),
         (Pydocstyle, "213") => (RuleGroup::Stable, rules::pydocstyle::rules::MultiLineSummarySecondLine),
-        (Pydocstyle, "214") => (RuleGroup::Stable, rules::pydocstyle::rules::SectionNotOverIndented),
-        (Pydocstyle, "215") => (RuleGroup::Stable, rules::pydocstyle::rules::SectionUnderlineNotOverIndented),
+        (Pydocstyle, "214") => (RuleGroup::Stable, rules::pydocstyle::rules::OverindentedSection),
+        (Pydocstyle, "215") => (RuleGroup::Stable, rules::pydocstyle::rules::OverindentedSectionUnderline),
         (Pydocstyle, "300") => (RuleGroup::Stable, rules::pydocstyle::rules::TripleSingleQuotes),
         (Pydocstyle, "301") => (RuleGroup::Stable, rules::pydocstyle::rules::EscapeSequenceInDocstring),
-        (Pydocstyle, "400") => (RuleGroup::Stable, rules::pydocstyle::rules::EndsInPeriod),
+        (Pydocstyle, "400") => (RuleGroup::Stable, rules::pydocstyle::rules::MissingTrailingPeriod),
         (Pydocstyle, "401") => (RuleGroup::Stable, rules::pydocstyle::rules::NonImperativeMood),
-        (Pydocstyle, "402") => (RuleGroup::Stable, rules::pydocstyle::rules::NoSignature),
+        (Pydocstyle, "402") => (RuleGroup::Stable, rules::pydocstyle::rules::SignatureInDocstring),
         (Pydocstyle, "403") => (RuleGroup::Stable, rules::pydocstyle::rules::FirstWordUncapitalized),
         (Pydocstyle, "404") => (RuleGroup::Stable, rules::pydocstyle::rules::DocstringStartsWithThis),
-        (Pydocstyle, "405") => (RuleGroup::Stable, rules::pydocstyle::rules::CapitalizeSectionName),
-        (Pydocstyle, "406") => (RuleGroup::Stable, rules::pydocstyle::rules::NewLineAfterSectionName),
-        (Pydocstyle, "407") => (RuleGroup::Stable, rules::pydocstyle::rules::DashedUnderlineAfterSection),
-        (Pydocstyle, "408") => (RuleGroup::Stable, rules::pydocstyle::rules::SectionUnderlineAfterName),
-        (Pydocstyle, "409") => (RuleGroup::Stable, rules::pydocstyle::rules::SectionUnderlineMatchesSectionLength),
+        (Pydocstyle, "405") => (RuleGroup::Stable, rules::pydocstyle::rules::NonCapitalizedSectionName),
+        (Pydocstyle, "406") => (RuleGroup::Stable, rules::pydocstyle::rules::MissingNewLineAfterSectionName),
+        (Pydocstyle, "407") => (RuleGroup::Stable, rules::pydocstyle::rules::MissingDashedUnderlineAfterSection),
+        (Pydocstyle, "408") => (RuleGroup::Stable, rules::pydocstyle::rules::MissingSectionUnderlineAfterName),
+        (Pydocstyle, "409") => (RuleGroup::Stable, rules::pydocstyle::rules::MismatchedSectionUnderlineLength),
         (Pydocstyle, "410") => (RuleGroup::Stable, rules::pydocstyle::rules::NoBlankLineAfterSection),
         (Pydocstyle, "411") => (RuleGroup::Stable, rules::pydocstyle::rules::NoBlankLineBeforeSection),
         (Pydocstyle, "412") => (RuleGroup::Stable, rules::pydocstyle::rules::BlankLinesBetweenHeaderAndContent),
-        (Pydocstyle, "413") => (RuleGroup::Stable, rules::pydocstyle::rules::BlankLineAfterLastSection),
+        (Pydocstyle, "413") => (RuleGroup::Stable, rules::pydocstyle::rules::MissingBlankLineAfterLastSection),
         (Pydocstyle, "414") => (RuleGroup::Stable, rules::pydocstyle::rules::EmptyDocstringSection),
-        (Pydocstyle, "415") => (RuleGroup::Stable, rules::pydocstyle::rules::EndsInPunctuation),
-        (Pydocstyle, "416") => (RuleGroup::Stable, rules::pydocstyle::rules::SectionNameEndsInColon),
+        (Pydocstyle, "415") => (RuleGroup::Stable, rules::pydocstyle::rules::MissingTerminalPunctuation),
+        (Pydocstyle, "416") => (RuleGroup::Stable, rules::pydocstyle::rules::MissingSectionNameColon),
         (Pydocstyle, "417") => (RuleGroup::Stable, rules::pydocstyle::rules::UndocumentedParam),
         (Pydocstyle, "418") => (RuleGroup::Stable, rules::pydocstyle::rules::OverloadWithDocstring),
         (Pydocstyle, "419") => (RuleGroup::Stable, rules::pydocstyle::rules::EmptyDocstring),

crates/ruff_linter/src/fix/mod.rs

@@ -142,9 +142,11 @@ fn cmp_fix(rule1: Rule, rule2: Rule, fix1: &Fix, fix2: &Fix) -> std::cmp::Orderi
     .then_with(|| fix1.min_start().cmp(&fix2.min_start()))
     // Break ties in the event of overlapping rules, for some specific combinations.
     .then_with(|| match (&rule1, &rule2) {
-        // Apply `EndsInPeriod` fixes before `NewLineAfterLastParagraph` fixes.
-        (Rule::EndsInPeriod, Rule::NewLineAfterLastParagraph) => std::cmp::Ordering::Less,
-        (Rule::NewLineAfterLastParagraph, Rule::EndsInPeriod) => std::cmp::Ordering::Greater,
+        // Apply `MissingTrailingPeriod` fixes before `NewLineAfterLastParagraph` fixes.
+        (Rule::MissingTrailingPeriod, Rule::NewLineAfterLastParagraph) => std::cmp::Ordering::Less,
+        (Rule::NewLineAfterLastParagraph, Rule::MissingTrailingPeriod) => {
+            std::cmp::Ordering::Greater
+        }
         // Apply `IfElseBlockInsteadOfDictGet` fixes before `IfElseBlockInsteadOfIfExp` fixes.
         (Rule::IfElseBlockInsteadOfDictGet, Rule::IfElseBlockInsteadOfIfExp) => {
             std::cmp::Ordering::Less

crates/ruff_linter/src/registry.rs

@@ -357,9 +357,9 @@ impl Rule {
 pub const INCOMPATIBLE_CODES: &[(Rule, Rule, &str); 2] = &[
     (
         Rule::BlankLineBeforeClass,
-        Rule::OneBlankLineBeforeClass,
-        "`one-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are \
-         incompatible. Ignoring `one-blank-line-before-class`.",
+        Rule::IncorrectBlankLineBeforeClass,
+        "`incorrect-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are \
+         incompatible. Ignoring `incorrect-blank-line-before-class`.",
     ),
     (
         Rule::MultiLineSummaryFirstLine,