Consider ignore-names in all pep8 naming rules (#5079)

## Summary

This changes all remaining pep8 naming rules to consider the
`ingore-names` argument.

Closes #5050

## Test Plan

Added new tests.

.pre-commit-config.yaml

@@ -3,6 +3,7 @@ fail_fast: true
 exclude: |
   (?x)^(
     crates/ruff/resources/.*|
+    crates/ruff/src/rules/.*/snapshots/.*|
     crates/ruff_python_formatter/resources/.*|
     crates/ruff_python_formatter/src/snapshots/.*
   )$

_typos.toml

@@ -8,3 +8,4 @@ whos = "whos"
 spawnve = "spawnve"
 ned = "ned"
 poit = "poit"
+BA = "BA" # acronym for "Bad Allowed", used in testing.

crates/ruff/resources/test/fixtures/pep8_naming/ignore_names/N801.py

@@ -0,0 +1,11 @@
+class badAllowed:
+    pass
+
+class stillBad:
+    pass
+
+class BAD_ALLOWED:
+    pass
+
+class STILL_BAD:
+    pass

crates/ruff/resources/test/fixtures/pep8_naming/ignore_names/N807.py

@@ -0,0 +1,13 @@
+def __badAllowed__():
+    pass
+
+def __stillBad__():
+    pass
+
+
+def nested():
+    def __badAllowed__():
+        pass
+
+    def __stillBad__():
+        pass

crates/ruff/resources/test/fixtures/pep8_naming/ignore_names/N811.py

@@ -0,0 +1,5 @@
+import mod.BAD_ALLOWED as badAllowed
+import mod.STILL_BAD as stillBad
+
+from mod import BAD_ALLOWED as badAllowed
+from mod import STILL_BAD as stillBad

crates/ruff/resources/test/fixtures/pep8_naming/ignore_names/N812.py

@@ -0,0 +1,5 @@
+import mod.badallowed as badAllowed
+import mod.stillbad as stillBad
+
+from mod import badallowed as BadAllowed
+from mod import stillbad as StillBad

crates/ruff/resources/test/fixtures/pep8_naming/ignore_names/N813.py

@@ -0,0 +1,8 @@
+import mod.BadAllowed as badallowed
+import mod.stillBad as stillbad
+
+from mod import BadAllowed as badallowed
+from mod import StillBad as stillbad
+
+from mod import BadAllowed as bad_allowed
+from mod import StillBad as still_bad

crates/ruff/resources/test/fixtures/pep8_naming/ignore_names/N814.py

@@ -0,0 +1,8 @@
+import mod.BadAllowed as BADALLOWED
+import mod.StillBad as STILLBAD
+
+from mod import BadAllowed as BADALLOWED
+from mod import StillBad as STILLBAD
+
+from mod import BadAllowed as BAD_ALLOWED
+from mod import StillBad as STILL_BAD

crates/ruff/resources/test/fixtures/pep8_naming/ignore_names/N817.py

@@ -0,0 +1,5 @@
+import mod.BadAllowed as BA
+import mod.StillBad as SB
+
+from mod import BadAllowed as BA
+from mod import StillBad as SB

crates/ruff/resources/test/fixtures/pep8_naming/ignore_names/N818.py

@@ -0,0 +1,11 @@
+class BadAllowed(Exception):
+    pass
+
+class StillBad(Exception):
+    pass
+
+class BadAllowed(AnotherError):
+    pass
+
+class StillBad(AnotherError):
+    pass

crates/ruff/src/checkers/ast/mod.rs

@@ -457,6 +457,7 @@ where
                         self.semantic_model.scope(),
                         stmt,
                         name,
+                        &self.settings.pep8_naming.ignore_names,
                         self.locator,
                     ) {
                         self.diagnostics.push(diagnostic);
@@ -703,9 +704,12 @@ where
                     }
                 }
                 if self.enabled(Rule::InvalidClassName) {
-                    if let Some(diagnostic) =
-                        pep8_naming::rules::invalid_class_name(stmt, name, self.locator)
-                    {
+                    if let Some(diagnostic) = pep8_naming::rules::invalid_class_name(
+                        stmt,
+                        name,
+                        &self.settings.pep8_naming.ignore_names,
+                        self.locator,
+                    ) {
                         self.diagnostics.push(diagnostic);
                     }
                 }
@@ -715,6 +719,7 @@ where
                         bases,
                         name,
                         self.locator,
+                        &self.settings.pep8_naming.ignore_names,
                     ) {
                         self.diagnostics.push(diagnostic);
                     }
@@ -898,7 +903,11 @@ where
                         if self.enabled(Rule::ConstantImportedAsNonConstant) {
                             if let Some(diagnostic) =
                                 pep8_naming::rules::constant_imported_as_non_constant(
-                                    name, asname, alias, stmt,
+                                    name,
+                                    asname,
+                                    alias,
+                                    stmt,
+                                    &self.settings.pep8_naming.ignore_names,
                                 )
                             {
                                 self.diagnostics.push(diagnostic);
@@ -908,7 +917,11 @@ where
                         if self.enabled(Rule::LowercaseImportedAsNonLowercase) {
                             if let Some(diagnostic) =
                                 pep8_naming::rules::lowercase_imported_as_non_lowercase(
-                                    name, asname, alias, stmt,
+                                    name,
+                                    asname,
+                                    alias,
+                                    stmt,
+                                    &self.settings.pep8_naming.ignore_names,
                                 )
                             {
                                 self.diagnostics.push(diagnostic);
@@ -918,7 +931,11 @@ where
                         if self.enabled(Rule::CamelcaseImportedAsLowercase) {
                             if let Some(diagnostic) =
                                 pep8_naming::rules::camelcase_imported_as_lowercase(
-                                    name, asname, alias, stmt,
+                                    name,
+                                    asname,
+                                    alias,
+                                    stmt,
+                                    &self.settings.pep8_naming.ignore_names,
                                 )
                             {
                                 self.diagnostics.push(diagnostic);
@@ -928,7 +945,11 @@ where
                         if self.enabled(Rule::CamelcaseImportedAsConstant) {
                             if let Some(diagnostic) =
                                 pep8_naming::rules::camelcase_imported_as_constant(
-                                    name, asname, alias, stmt,
+                                    name,
+                                    asname,
+                                    alias,
+                                    stmt,
+                                    &self.settings.pep8_naming.ignore_names,
                                 )
                             {
                                 self.diagnostics.push(diagnostic);
@@ -938,7 +959,11 @@ where
                         if self.enabled(Rule::CamelcaseImportedAsAcronym) {
                             if let Some(diagnostic) =
                                 pep8_naming::rules::camelcase_imported_as_acronym(
-                                    name, asname, alias, stmt,
+                                    name,
+                                    asname,
+                                    alias,
+                                    stmt,
+                                    &self.settings.pep8_naming.ignore_names,
                                 )
                             {
                                 self.diagnostics.push(diagnostic);
@@ -1197,6 +1222,7 @@ where
                                     asname,
                                     alias,
                                     stmt,
+                                    &self.settings.pep8_naming.ignore_names,
                                 )
                             {
                                 self.diagnostics.push(diagnostic);
@@ -1210,6 +1236,7 @@ where
                                     asname,
                                     alias,
                                     stmt,
+                                    &self.settings.pep8_naming.ignore_names,
                                 )
                             {
                                 self.diagnostics.push(diagnostic);
@@ -1223,6 +1250,7 @@ where
                                     asname,
                                     alias,
                                     stmt,
+                                    &self.settings.pep8_naming.ignore_names,
                                 )
                             {
                                 self.diagnostics.push(diagnostic);
@@ -1236,6 +1264,7 @@ where
                                     asname,
                                     alias,
                                     stmt,
+                                    &self.settings.pep8_naming.ignore_names,
                                 )
                             {
                                 self.diagnostics.push(diagnostic);
@@ -1249,6 +1278,7 @@ where
                                     asname,
                                     alias,
                                     stmt,
+                                    &self.settings.pep8_naming.ignore_names,
                                 )
                             {
                                 self.diagnostics.push(diagnostic);

crates/ruff/src/checkers/filesystem.rs

@@ -25,7 +25,9 @@ pub(crate) fn check_file_path(
 
     // pep8-naming
     if settings.rules.enabled(Rule::InvalidModuleName) {
-        if let Some(diagnostic) = invalid_module_name(path, package) {
+        if let Some(diagnostic) =
+            invalid_module_name(path, package, &settings.pep8_naming.ignore_names)
+        {
             diagnostics.push(diagnostic);
         }
     }

crates/ruff/src/rules/pep8_naming/mod.rs

@@ -106,22 +106,33 @@ mod tests {
         Ok(())
     }
 
+    #[test_case(Rule::InvalidClassName, "N801.py")]
     #[test_case(Rule::InvalidFunctionName, "N802.py")]
     #[test_case(Rule::InvalidArgumentName, "N803.py")]
     #[test_case(Rule::InvalidFirstArgumentNameForClassMethod, "N804.py")]
     #[test_case(Rule::InvalidFirstArgumentNameForMethod, "N805.py")]
     #[test_case(Rule::NonLowercaseVariableInFunction, "N806.py")]
+    #[test_case(Rule::DunderFunctionName, "N807.py")]
+    #[test_case(Rule::ConstantImportedAsNonConstant, "N811.py")]
+    #[test_case(Rule::LowercaseImportedAsNonLowercase, "N812.py")]
+    #[test_case(Rule::CamelcaseImportedAsLowercase, "N813.py")]
+    #[test_case(Rule::CamelcaseImportedAsConstant, "N814.py")]
     #[test_case(Rule::MixedCaseVariableInClassScope, "N815.py")]
     #[test_case(Rule::MixedCaseVariableInGlobalScope, "N816.py")]
+    #[test_case(Rule::CamelcaseImportedAsAcronym, "N817.py")]
+    #[test_case(Rule::ErrorSuffixOnExceptionName, "N818.py")]
+    #[test_case(Rule::InvalidModuleName, "N999/badAllowed/__init__.py")]
     fn ignore_names(rule_code: Rule, path: &str) -> Result<()> {
         let snapshot = format!("ignore_names_{}_{path}", rule_code.noqa_code());
         let diagnostics = test_path(
             PathBuf::from_iter(["pep8_naming", "ignore_names", path]).as_path(),
             &settings::Settings {
                 pep8_naming: pep8_naming::settings::Settings {
                     ignore_names: vec![
-                        IdentifierPattern::new("*Allowed").unwrap(),
-                        IdentifierPattern::new("*ALLOWED").unwrap(),
+                        IdentifierPattern::new("*allowed*").unwrap(),
+                        IdentifierPattern::new("*Allowed*").unwrap(),
+                        IdentifierPattern::new("*ALLOWED*").unwrap(),
+                        IdentifierPattern::new("BA").unwrap(), // For N817.
                     ],
                     ..Default::default()
                 },

crates/ruff/src/rules/pep8_naming/rules/camelcase_imported_as_acronym.rs

@@ -5,6 +5,7 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_python_stdlib::str::{self};
 
 use crate::rules::pep8_naming::helpers;
+use crate::settings::types::IdentifierPattern;
 
 /// ## What it does
 /// Checks for `CamelCase` imports that are aliased as acronyms.
@@ -52,7 +53,15 @@ pub(crate) fn camelcase_imported_as_acronym(
     asname: &str,
     alias: &Alias,
     stmt: &Stmt,
+    ignore_names: &[IdentifierPattern],
 ) -> Option<Diagnostic> {
+    if ignore_names
+        .iter()
+        .any(|ignore_name| ignore_name.matches(asname))
+    {
+        return None;
+    }
+
     if helpers::is_camelcase(name)
         && !str::is_lower(asname)
         && str::is_upper(asname)

crates/ruff/src/rules/pep8_naming/rules/camelcase_imported_as_constant.rs

@@ -5,6 +5,7 @@ use ruff_macros::{derive_message_formats, violation};
 use ruff_python_stdlib::str::{self};
 
 use crate::rules::pep8_naming::helpers;
+use crate::settings::types::IdentifierPattern;
 
 /// ## What it does
 /// Checks for `CamelCase` imports that are aliased to constant-style names.
@@ -49,7 +50,15 @@ pub(crate) fn camelcase_imported_as_constant(
     asname: &str,
     alias: &Alias,
     stmt: &Stmt,
+    ignore_names: &[IdentifierPattern],
 ) -> Option<Diagnostic> {
+    if ignore_names
+        .iter()
+        .any(|ignore_name| ignore_name.matches(name))
+    {
+        return None;
+    }
+
     if helpers::is_camelcase(name)
         && !str::is_lower(asname)
         && str::is_upper(asname)

crates/ruff/src/rules/pep8_naming/rules/camelcase_imported_as_lowercase.rs

@@ -4,6 +4,7 @@ use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 
 use crate::rules::pep8_naming::helpers;
+use crate::settings::types::IdentifierPattern;
 
 /// ## What it does
 /// Checks for `CamelCase` imports that are aliased to lowercase names.
@@ -48,7 +49,15 @@ pub(crate) fn camelcase_imported_as_lowercase(
     asname: &str,
     alias: &Alias,
     stmt: &Stmt,
+    ignore_names: &[IdentifierPattern],
 ) -> Option<Diagnostic> {
+    if ignore_names
+        .iter()
+        .any(|ignore_name| ignore_name.matches(asname))
+    {
+        return None;
+    }
+
     if helpers::is_camelcase(name) && ruff_python_stdlib::str::is_lower(asname) {
         let mut diagnostic = Diagnostic::new(
             CamelcaseImportedAsLowercase {

crates/ruff/src/rules/pep8_naming/rules/constant_imported_as_non_constant.rs

@@ -4,6 +4,8 @@ use ruff_diagnostics::{Diagnostic, Violation};
 use ruff_macros::{derive_message_formats, violation};
 use ruff_python_stdlib::str;
 
+use crate::settings::types::IdentifierPattern;
+
 /// ## What it does
 /// Checks for constant imports that are aliased to non-constant-style
 /// names.
@@ -48,7 +50,15 @@ pub(crate) fn constant_imported_as_non_constant(
     asname: &str,
     alias: &Alias,
     stmt: &Stmt,
+    ignore_names: &[IdentifierPattern],
 ) -> Option<Diagnostic> {
+    if ignore_names
+        .iter()
+        .any(|ignore_name| ignore_name.matches(name))
+    {
+        return None;
+    }
+
     if str::is_upper(name) && !str::is_upper(asname) {
         let mut diagnostic = Diagnostic::new(
             ConstantImportedAsNonConstant {

crates/ruff/src/rules/pep8_naming/rules/dunder_function_name.rs

@@ -6,6 +6,8 @@ use ruff_python_ast::helpers::identifier_range;
 use ruff_python_ast::source_code::Locator;
 use ruff_python_semantic::scope::{Scope, ScopeKind};
 
+use crate::settings::types::IdentifierPattern;
+
 /// ## What it does
 /// Checks for functions with "dunder" names (that is, names with two
 /// leading and trailing underscores) that are not documented.
@@ -45,6 +47,7 @@ pub(crate) fn dunder_function_name(
     scope: &Scope,
     stmt: &Stmt,
     name: &str,
+    ignore_names: &[IdentifierPattern],
     locator: &Locator,
 ) -> Option<Diagnostic> {
     if matches!(scope.kind, ScopeKind::Class(_)) {
@@ -57,6 +60,12 @@ pub(crate) fn dunder_function_name(
     if matches!(scope.kind, ScopeKind::Module) && (name == "__getattr__" || name == "__dir__") {
         return None;
     }
+    if ignore_names
+        .iter()
+        .any(|ignore_name| ignore_name.matches(name))
+    {
+        return None;
+    }
 
     Some(Diagnostic::new(
         DunderFunctionName,