diff --git a/README.md b/README.md index 810ffecc66..e138087c70 100644 --- a/README.md +++ b/README.md @@ -225,8 +225,8 @@ max-complexity = 10 ``` As an example, the following would configure Ruff to: (1) avoid checking for line-length -violations (`E501`); (2), always autofix, but never remove unused imports (`F401`); and (3) ignore -import-at-top-of-file errors (`E402`) in `__init__.py` files: +violations (`E501`); (2) never remove unused imports (`F401`); and (3) ignore import-at-top-of-file +errors (`E402`) in `__init__.py` files: ```toml [tool.ruff] @@ -236,8 +236,7 @@ select = ["E", "F"] # Never enforce `E501` (line length violations). ignore = ["E501"] -# Always autofix, but never try to fix `F401` (unused imports). -fix = true +# Never try to fix `F401` (unused imports). unfixable = ["F401"] # Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`. @@ -257,6 +256,17 @@ select = ["E", "F", "Q"] docstring-quotes = "double" ``` +Ruff mirrors Flake8's error code system, in which each error code consists of a one-to-three letter +prefix, followed by three digits (e.g., `F401`). The prefix indicates that "source" of the error +code (e.g., `F` for Pyflakes, `E` for `pycodestyle`, `ANN` for `flake8-annotations`). The set of +enabled errors is determined by the `select` and `ignore` options, which support both the full +error code (e.g., `F401`) and the prefix (e.g., `F`). + +As a special-case, Ruff also supports the `ALL` error code, which enables all error codes. Note that +some of the `pydocstyle` error codes are conflicting (e.g., `D203` and `D211`) as they represent +alternative docstring formats. Enabling `ALL` without further configuration may result in suboptimal +behavior, especially for the `pydocstyle` plugin. + As an alternative to `pyproject.toml`, Ruff will also respect a `ruff.toml` file, which implements an equivalent schema (though the `[tool.ruff]` hierarchy can be omitted). For example, the above `pyproject.toml` described above would be represented via the following `ruff.toml`: diff --git a/ruff.schema.json b/ruff.schema.json index 4d84a7ddc9..ad874a470e 100644 --- a/ruff.schema.json +++ b/ruff.schema.json @@ -377,6 +377,7 @@ "A001", "A002", "A003", + "ALL", "ANN", "ANN0", "ANN00", diff --git a/ruff_dev/src/generate_check_code_prefix.rs b/ruff_dev/src/generate_check_code_prefix.rs index 9ff30fc722..ebc756ad83 100644 --- a/ruff_dev/src/generate_check_code_prefix.rs +++ b/ruff_dev/src/generate_check_code_prefix.rs @@ -13,6 +13,8 @@ use itertools::Itertools; use ruff::checks::{CheckCode, PREFIX_REDIRECTS}; use strum::IntoEnumIterator; +const ALL: &'static str = "ALL"; + #[derive(Parser)] #[command(author, version, about, long_about = None)] pub struct Cli { @@ -34,9 +36,15 @@ pub fn main(cli: &Cli) -> Result<()> { let code_suffix_len = code_str.len() - code_prefix_len; for i in 0..=code_suffix_len { let prefix = code_str[..code_prefix_len + i].to_string(); - let entry = prefix_to_codes.entry(prefix).or_default(); - entry.insert(check_code.clone()); + prefix_to_codes + .entry(prefix) + .or_default() + .insert(check_code.clone()); } + prefix_to_codes + .entry(ALL.to_string()) + .or_default() + .insert(check_code.clone()); } // Add any prefix aliases (e.g., "U" to "UP"). @@ -79,6 +87,7 @@ pub fn main(cli: &Cli) -> Result<()> { .derive("Eq") .derive("PartialOrd") .derive("Ord") + .push_variant(Variant::new("None")) .push_variant(Variant::new("Zero")) .push_variant(Variant::new("One")) .push_variant(Variant::new("Two")) @@ -129,14 +138,18 @@ pub fn main(cli: &Cli) -> Result<()> { .line("#[allow(clippy::match_same_arms)]") .line("match self {"); for prefix in prefix_to_codes.keys() { - let num_numeric = prefix.chars().filter(|char| char.is_numeric()).count(); - let specificity = match num_numeric { - 0 => "Zero", - 1 => "One", - 2 => "Two", - 3 => "Three", - 4 => "Four", - _ => panic!("Invalid prefix: {prefix}"), + let specificity = if prefix == "ALL" { + "None" + } else { + let num_numeric = prefix.chars().filter(|char| char.is_numeric()).count(); + match num_numeric { + 0 => "Zero", + 1 => "One", + 2 => "Two", + 3 => "Three", + 4 => "Four", + _ => panic!("Invalid prefix: {prefix}"), + } }; gen = gen.line(format!( "CheckCodePrefix::{prefix} => SuffixLength::{specificity}," diff --git a/src/checks_gen.rs b/src/checks_gen.rs index a6e3df0b43..b46d529a9f 100644 --- a/src/checks_gen.rs +++ b/src/checks_gen.rs @@ -28,6 +28,7 @@ pub enum CheckCodePrefix { A001, A002, A003, + ALL, ANN, ANN0, ANN00, @@ -559,6 +560,7 @@ pub enum CheckCodePrefix { #[derive(PartialEq, Eq, PartialOrd, Ord)] pub enum SuffixLength { + None, Zero, One, Two, @@ -576,6 +578,297 @@ impl CheckCodePrefix { CheckCodePrefix::A001 => vec![CheckCode::A001], CheckCodePrefix::A002 => vec![CheckCode::A002], CheckCodePrefix::A003 => vec![CheckCode::A003], + CheckCodePrefix::ALL => vec![ + CheckCode::E401, + CheckCode::E402, + CheckCode::E501, + CheckCode::E711, + CheckCode::E712, + CheckCode::E713, + CheckCode::E714, + CheckCode::E721, + CheckCode::E722, + CheckCode::E731, + CheckCode::E741, + CheckCode::E742, + CheckCode::E743, + CheckCode::E902, + CheckCode::E999, + CheckCode::W292, + CheckCode::W605, + CheckCode::F401, + CheckCode::F402, + CheckCode::F403, + CheckCode::F404, + CheckCode::F405, + CheckCode::F406, + CheckCode::F407, + CheckCode::F501, + CheckCode::F502, + CheckCode::F503, + CheckCode::F504, + CheckCode::F505, + CheckCode::F506, + CheckCode::F507, + CheckCode::F508, + CheckCode::F509, + CheckCode::F521, + CheckCode::F522, + CheckCode::F523, + CheckCode::F524, + CheckCode::F525, + CheckCode::F541, + CheckCode::F601, + CheckCode::F602, + CheckCode::F621, + CheckCode::F622, + CheckCode::F631, + CheckCode::F632, + CheckCode::F633, + CheckCode::F634, + CheckCode::F701, + CheckCode::F702, + CheckCode::F704, + CheckCode::F706, + CheckCode::F707, + CheckCode::F722, + CheckCode::F811, + CheckCode::F821, + CheckCode::F822, + CheckCode::F823, + CheckCode::F831, + CheckCode::F841, + CheckCode::F842, + CheckCode::F901, + CheckCode::PLC0414, + CheckCode::PLC2201, + CheckCode::PLC3002, + CheckCode::PLE0117, + CheckCode::PLE0118, + CheckCode::PLE1142, + CheckCode::PLR0206, + CheckCode::PLR0402, + CheckCode::PLR1701, + CheckCode::PLR1722, + CheckCode::PLW0120, + CheckCode::PLW0602, + CheckCode::A001, + CheckCode::A002, + CheckCode::A003, + CheckCode::B002, + CheckCode::B003, + CheckCode::B004, + CheckCode::B005, + CheckCode::B006, + CheckCode::B007, + CheckCode::B008, + CheckCode::B009, + CheckCode::B010, + CheckCode::B011, + CheckCode::B012, + CheckCode::B013, + CheckCode::B014, + CheckCode::B015, + CheckCode::B016, + CheckCode::B017, + CheckCode::B018, + CheckCode::B019, + CheckCode::B020, + CheckCode::B021, + CheckCode::B022, + CheckCode::B023, + CheckCode::B024, + CheckCode::B025, + CheckCode::B026, + CheckCode::B027, + CheckCode::B904, + CheckCode::B905, + CheckCode::BLE001, + CheckCode::C400, + CheckCode::C401, + CheckCode::C402, + CheckCode::C403, + CheckCode::C404, + CheckCode::C405, + CheckCode::C406, + CheckCode::C408, + CheckCode::C409, + CheckCode::C410, + CheckCode::C411, + CheckCode::C413, + CheckCode::C414, + CheckCode::C415, + CheckCode::C416, + CheckCode::C417, + CheckCode::T100, + CheckCode::C901, + CheckCode::TID252, + CheckCode::RET501, + CheckCode::RET502, + CheckCode::RET503, + CheckCode::RET504, + CheckCode::RET505, + CheckCode::RET506, + CheckCode::RET507, + CheckCode::RET508, + CheckCode::T201, + CheckCode::T203, + CheckCode::Q000, + CheckCode::Q001, + CheckCode::Q002, + CheckCode::Q003, + CheckCode::ANN001, + CheckCode::ANN002, + CheckCode::ANN003, + CheckCode::ANN101, + CheckCode::ANN102, + CheckCode::ANN201, + CheckCode::ANN202, + CheckCode::ANN204, + CheckCode::ANN205, + CheckCode::ANN206, + CheckCode::ANN401, + CheckCode::YTT101, + CheckCode::YTT102, + CheckCode::YTT103, + CheckCode::YTT201, + CheckCode::YTT202, + CheckCode::YTT203, + CheckCode::YTT204, + CheckCode::YTT301, + CheckCode::YTT302, + CheckCode::YTT303, + CheckCode::SIM118, + CheckCode::UP001, + CheckCode::UP003, + CheckCode::UP004, + CheckCode::UP005, + CheckCode::UP006, + CheckCode::UP007, + CheckCode::UP008, + CheckCode::UP009, + CheckCode::UP010, + CheckCode::UP011, + CheckCode::UP012, + CheckCode::UP013, + CheckCode::UP014, + CheckCode::UP015, + CheckCode::UP016, + CheckCode::UP017, + CheckCode::UP018, + CheckCode::UP019, + CheckCode::UP020, + CheckCode::UP021, + CheckCode::D100, + CheckCode::D101, + CheckCode::D102, + CheckCode::D103, + CheckCode::D104, + CheckCode::D105, + CheckCode::D106, + CheckCode::D107, + CheckCode::D200, + CheckCode::D201, + CheckCode::D202, + CheckCode::D203, + CheckCode::D204, + CheckCode::D205, + CheckCode::D206, + CheckCode::D207, + CheckCode::D208, + CheckCode::D209, + CheckCode::D210, + CheckCode::D211, + CheckCode::D212, + CheckCode::D213, + CheckCode::D214, + CheckCode::D215, + CheckCode::D300, + CheckCode::D301, + CheckCode::D400, + CheckCode::D402, + CheckCode::D403, + CheckCode::D404, + CheckCode::D405, + CheckCode::D406, + CheckCode::D407, + CheckCode::D408, + CheckCode::D409, + CheckCode::D410, + CheckCode::D411, + CheckCode::D412, + CheckCode::D413, + CheckCode::D414, + CheckCode::D415, + CheckCode::D416, + CheckCode::D417, + CheckCode::D418, + CheckCode::D419, + CheckCode::N801, + CheckCode::N802, + CheckCode::N803, + CheckCode::N804, + CheckCode::N805, + CheckCode::N806, + CheckCode::N807, + CheckCode::N811, + CheckCode::N812, + CheckCode::N813, + CheckCode::N814, + CheckCode::N815, + CheckCode::N816, + CheckCode::N817, + CheckCode::N818, + CheckCode::I001, + CheckCode::ERA001, + CheckCode::S101, + CheckCode::S102, + CheckCode::S104, + CheckCode::S105, + CheckCode::S106, + CheckCode::S107, + CheckCode::FBT001, + CheckCode::FBT002, + CheckCode::FBT003, + CheckCode::ARG001, + CheckCode::ARG002, + CheckCode::ARG003, + CheckCode::ARG004, + CheckCode::ARG005, + CheckCode::ICN001, + CheckCode::DTZ001, + CheckCode::DTZ002, + CheckCode::DTZ003, + CheckCode::DTZ004, + CheckCode::DTZ005, + CheckCode::DTZ006, + CheckCode::DTZ007, + CheckCode::DTZ011, + CheckCode::DTZ012, + CheckCode::RUF001, + CheckCode::RUF002, + CheckCode::RUF003, + CheckCode::RUF004, + CheckCode::RUF100, + CheckCode::PGH001, + CheckCode::PGH002, + CheckCode::PGH003, + CheckCode::PD002, + CheckCode::PD003, + CheckCode::PD004, + CheckCode::PD007, + CheckCode::PD008, + CheckCode::PD009, + CheckCode::PD010, + CheckCode::PD011, + CheckCode::PD012, + CheckCode::PD013, + CheckCode::PD015, + CheckCode::PD901, + CheckCode::EM101, + CheckCode::EM102, + CheckCode::EM103, + ], CheckCodePrefix::ANN => vec![ CheckCode::ANN001, CheckCode::ANN002, @@ -2491,6 +2784,7 @@ impl CheckCodePrefix { CheckCodePrefix::A001 => SuffixLength::Three, CheckCodePrefix::A002 => SuffixLength::Three, CheckCodePrefix::A003 => SuffixLength::Three, + CheckCodePrefix::ALL => SuffixLength::None, CheckCodePrefix::ANN => SuffixLength::Zero, CheckCodePrefix::ANN0 => SuffixLength::One, CheckCodePrefix::ANN00 => SuffixLength::Two, @@ -3024,6 +3318,7 @@ impl CheckCodePrefix { pub const CATEGORIES: &[CheckCodePrefix] = &[ CheckCodePrefix::A, + CheckCodePrefix::ALL, CheckCodePrefix::ANN, CheckCodePrefix::ARG, CheckCodePrefix::B, diff --git a/src/settings/mod.rs b/src/settings/mod.rs index 36ed5799f3..4476befb92 100644 --- a/src/settings/mod.rs +++ b/src/settings/mod.rs @@ -379,6 +379,7 @@ fn resolve_codes<'a>(specs: impl Iterator>) -> FxHashSe let mut codes: FxHashSet = FxHashSet::default(); for spec in specs { for specificity in [ + SuffixLength::None, SuffixLength::Zero, SuffixLength::One, SuffixLength::Two,