Change fixable_set to include RuleSelector::All/Nursery (#4852)

crates/ruff/src/rule_selector.rs

@@ -5,8 +5,8 @@ use serde::{Deserialize, Serialize};
 use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
 
-use crate::codes::RuleCodePrefix;
 use crate::codes::RuleIter;
+use crate::codes::{self, RuleCodePrefix};
 use crate::registry::{Linter, Rule, RuleNamespace};
 use crate::rule_redirects::get_redirect;
 
@@ -14,6 +14,8 @@ use crate::rule_redirects::get_redirect;
 pub enum RuleSelector {
     /// Select all rules.
     All,
+    /// Select all nursery rules.
+    Nursery,
     /// Legacy category to select both the `mccabe` and `flake8-comprehensions` linters
     /// via a single selector.
     C,
@@ -39,30 +41,30 @@ impl FromStr for RuleSelector {
     type Err = ParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s == "ALL" {
+        match s {
-            Ok(Self::All)
+            "ALL" => Ok(Self::All),
-        } else if s == "C" {
+            "NURSERY" => Ok(Self::Nursery),
-            Ok(Self::C)
+            "C" => Ok(Self::C),
-        } else if s == "T" {
+            "T" => Ok(Self::T),
-            Ok(Self::T)
+            _ => {
-        } else {
+                let (s, redirected_from) = match get_redirect(s) {
-            let (s, redirected_from) = match get_redirect(s) {
+                    Some((from, target)) => (target, Some(from)),
-                Some((from, target)) => (target, Some(from)),
+                    None => (s, None),
-                None => (s, None),
+                };
-            };
 
-            let (linter, code) =
+                let (linter, code) =
-                Linter::parse_code(s).ok_or_else(|| ParseError::Unknown(s.to_string()))?;
+                    Linter::parse_code(s).ok_or_else(|| ParseError::Unknown(s.to_string()))?;
 
-            if code.is_empty() {
+                if code.is_empty() {
-                return Ok(Self::Linter(linter));
+                    return Ok(Self::Linter(linter));
+                }
+
+                Ok(Self::Prefix {
+                    prefix: RuleCodePrefix::parse(&linter, code)
+                        .map_err(|_| ParseError::Unknown(s.to_string()))?,
+                    redirected_from,
+                })
             }
-
-            Ok(Self::Prefix {
-                prefix: RuleCodePrefix::parse(&linter, code)
-                    .map_err(|_| ParseError::Unknown(s.to_string()))?,
-                redirected_from,
-            })
         }
     }
 }
@@ -79,6 +81,7 @@ impl RuleSelector {
     pub fn prefix_and_code(&self) -> (&'static str, &'static str) {
         match self {
             RuleSelector::All => ("", "ALL"),
+            RuleSelector::Nursery => ("", "NURSERY"),
             RuleSelector::C => ("", "C"),
             RuleSelector::T => ("", "T"),
             RuleSelector::Prefix { prefix, .. } => {
@@ -157,6 +160,9 @@ impl IntoIterator for &RuleSelector {
             RuleSelector::All => {
                 RuleSelectorIter::All(Rule::iter().filter(|rule| select_all(*rule)))
             }
+            RuleSelector::Nursery => {
+                RuleSelectorIter::Nursery(Rule::iter().filter(codes::Rule::is_nursery))
+            }
             RuleSelector::C => RuleSelectorIter::Chain(
                 Linter::Flake8Comprehensions
                     .into_iter()
@@ -175,6 +181,7 @@ impl IntoIterator for &RuleSelector {
 
 pub enum RuleSelectorIter {
     All(std::iter::Filter<RuleIter, fn(&Rule) -> bool>),
+    Nursery(std::iter::Filter<RuleIter, fn(&Rule) -> bool>),
     Chain(std::iter::Chain<std::vec::IntoIter<Rule>, std::vec::IntoIter<Rule>>),
     Vec(std::vec::IntoIter<Rule>),
 }
@@ -185,6 +192,7 @@ impl Iterator for RuleSelectorIter {
     fn next(&mut self) -> Option<Self::Item> {
         match self {
             RuleSelectorIter::All(iter) => iter.next(),
+            RuleSelectorIter::Nursery(iter) => iter.next(),
             RuleSelectorIter::Chain(iter) => iter.next(),
             RuleSelectorIter::Vec(iter) => iter.next(),
         }
@@ -262,6 +270,7 @@ impl RuleSelector {
     pub(crate) fn specificity(&self) -> Specificity {
         match self {
             RuleSelector::All => Specificity::All,
+            RuleSelector::Nursery => Specificity::All,
             RuleSelector::T => Specificity::LinterGroup,
             RuleSelector::C => Specificity::LinterGroup,
             RuleSelector::Linter(..) => Specificity::Linter,

crates/ruff/src/settings/mod.rs

@@ -259,7 +259,10 @@ impl From<&Configuration> for RuleTable {
         // The select_set keeps track of which rules have been selected.
         let mut select_set: RuleSet = defaults::PREFIXES.iter().flatten().collect();
         // The fixable set keeps track of which rules are fixable.
-        let mut fixable_set: RuleSet = RuleSelector::All.into_iter().collect();
+        let mut fixable_set: RuleSet = RuleSelector::All
+            .into_iter()
+            .chain(RuleSelector::Nursery.into_iter())
+            .collect();
 
         // Ignores normally only subtract from the current set of selected
         // rules.  By that logic the ignore in `select = [], ignore = ["E501"]`