Move Configuration to ruff_workspace crate (#6920)

crates/flake8_to_ruff/src/black.rs

@@ -0,0 +1,12 @@
+//! Extract Black configuration settings from a pyproject.toml.
+
+use ruff::settings::types::PythonVersion;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub(crate) struct Black {
+    #[serde(alias = "line-length", alias = "line_length")]
+    pub(crate) line_length: Option<usize>,
+    #[serde(alias = "target-version", alias = "target_version")]
+    pub(crate) target_version: Option<Vec<PythonVersion>>,
+}

crates/flake8_to_ruff/src/converter.rs

@@ -0,0 +1,640 @@
+use std::collections::{HashMap, HashSet};
+
+use itertools::Itertools;
+
+use ruff::line_width::LineLength;
+use ruff::registry::Linter;
+use ruff::rule_selector::RuleSelector;
+use ruff::rules::flake8_pytest_style::types::{
+    ParametrizeNameType, ParametrizeValuesRowType, ParametrizeValuesType,
+};
+use ruff::rules::flake8_quotes::settings::Quote;
+use ruff::rules::flake8_tidy_imports::settings::Strictness;
+use ruff::rules::pydocstyle::settings::Convention;
+use ruff::settings::types::PythonVersion;
+use ruff::warn_user;
+use ruff_workspace::options::{
+    Flake8AnnotationsOptions, Flake8BugbearOptions, Flake8BuiltinsOptions, Flake8ErrMsgOptions,
+    Flake8PytestStyleOptions, Flake8QuotesOptions, Flake8TidyImportsOptions, McCabeOptions,
+    Options, Pep8NamingOptions, PydocstyleOptions,
+};
+use ruff_workspace::pyproject::Pyproject;
+
+use super::external_config::ExternalConfig;
+use super::plugin::Plugin;
+use super::{parser, plugin};
+
+const DEFAULT_SELECTORS: &[RuleSelector] = &[
+    RuleSelector::Linter(Linter::Pyflakes),
+    RuleSelector::Linter(Linter::Pycodestyle),
+];
+
+pub(crate) fn convert(
+    config: &HashMap<String, HashMap<String, Option<String>>>,
+    external_config: &ExternalConfig,
+    plugins: Option<Vec<Plugin>>,
+) -> Pyproject {
+    // Extract the Flake8 section.
+    let flake8 = config
+        .get("flake8")
+        .expect("Unable to find flake8 section in INI file");
+
+    // Extract all referenced rule code prefixes, to power plugin inference.
+    let mut referenced_codes: HashSet<RuleSelector> = HashSet::default();
+    for (key, value) in flake8 {
+        if let Some(value) = value {
+            match key.as_str() {
+                "select" | "ignore" | "extend-select" | "extend_select" | "extend-ignore"
+                | "extend_ignore" => {
+                    referenced_codes.extend(parser::parse_prefix_codes(value.as_ref()));
+                }
+                "per-file-ignores" | "per_file_ignores" => {
+                    if let Ok(per_file_ignores) =
+                        parser::parse_files_to_codes_mapping(value.as_ref())
+                    {
+                        for (_, codes) in parser::collect_per_file_ignores(per_file_ignores) {
+                            referenced_codes.extend(codes);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Infer plugins, if not provided.
+    let plugins = plugins.unwrap_or_else(|| {
+        let from_options = plugin::infer_plugins_from_options(flake8);
+        if !from_options.is_empty() {
+            #[allow(clippy::print_stderr)]
+            {
+                eprintln!("Inferred plugins from settings: {from_options:#?}");
+            }
+        }
+        let from_codes = plugin::infer_plugins_from_codes(&referenced_codes);
+        if !from_codes.is_empty() {
+            #[allow(clippy::print_stderr)]
+            {
+                eprintln!("Inferred plugins from referenced codes: {from_codes:#?}");
+            }
+        }
+        from_options.into_iter().chain(from_codes).collect()
+    });
+
+    // Check if the user has specified a `select`. If not, we'll add our own
+    // default `select`, and populate it based on user plugins.
+    let mut select = flake8
+        .get("select")
+        .and_then(|value| {
+            value
+                .as_ref()
+                .map(|value| HashSet::from_iter(parser::parse_prefix_codes(value)))
+        })
+        .unwrap_or_else(|| resolve_select(&plugins));
+    let mut ignore: HashSet<RuleSelector> = flake8
+        .get("ignore")
+        .and_then(|value| {
+            value
+                .as_ref()
+                .map(|value| HashSet::from_iter(parser::parse_prefix_codes(value)))
+        })
+        .unwrap_or_default();
+
+    // Parse each supported option.
+    let mut options = Options::default();
+    let mut flake8_annotations = Flake8AnnotationsOptions::default();
+    let mut flake8_bugbear = Flake8BugbearOptions::default();
+    let mut flake8_builtins = Flake8BuiltinsOptions::default();
+    let mut flake8_errmsg = Flake8ErrMsgOptions::default();
+    let mut flake8_pytest_style = Flake8PytestStyleOptions::default();
+    let mut flake8_quotes = Flake8QuotesOptions::default();
+    let mut flake8_tidy_imports = Flake8TidyImportsOptions::default();
+    let mut mccabe = McCabeOptions::default();
+    let mut pep8_naming = Pep8NamingOptions::default();
+    let mut pydocstyle = PydocstyleOptions::default();
+    for (key, value) in flake8 {
+        if let Some(value) = value {
+            match key.as_str() {
+                // flake8
+                "builtins" => {
+                    options.builtins = Some(parser::parse_strings(value.as_ref()));
+                }
+                "max-line-length" | "max_line_length" => match value.parse::<usize>() {
+                    Ok(line_length) => {
+                        options.line_length = Some(LineLength::from(line_length));
+                    }
+                    Err(e) => {
+                        warn_user!("Unable to parse '{key}' property: {e}");
+                    }
+                },
+                "select" => {
+                    // No-op (handled above).
+                    select.extend(parser::parse_prefix_codes(value.as_ref()));
+                }
+                "ignore" => {
+                    // No-op (handled above).
+                }
+                "extend-select" | "extend_select" => {
+                    // Unlike Flake8, use a single explicit `select`.
+                    select.extend(parser::parse_prefix_codes(value.as_ref()));
+                }
+                "extend-ignore" | "extend_ignore" => {
+                    // Unlike Flake8, use a single explicit `ignore`.
+                    ignore.extend(parser::parse_prefix_codes(value.as_ref()));
+                }
+                "exclude" => {
+                    options.exclude = Some(parser::parse_strings(value.as_ref()));
+                }
+                "extend-exclude" | "extend_exclude" => {
+                    options.extend_exclude = Some(parser::parse_strings(value.as_ref()));
+                }
+                "per-file-ignores" | "per_file_ignores" => {
+                    match parser::parse_files_to_codes_mapping(value.as_ref()) {
+                        Ok(per_file_ignores) => {
+                            options.per_file_ignores =
+                                Some(parser::collect_per_file_ignores(per_file_ignores));
+                        }
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
+                    }
+                }
+                // flake8-bugbear
+                "extend-immutable-calls" | "extend_immutable_calls" => {
+                    flake8_bugbear.extend_immutable_calls =
+                        Some(parser::parse_strings(value.as_ref()));
+                }
+                // flake8-builtins
+                "builtins-ignorelist" | "builtins_ignorelist" => {
+                    flake8_builtins.builtins_ignorelist =
+                        Some(parser::parse_strings(value.as_ref()));
+                }
+                // flake8-annotations
+                "suppress-none-returning" | "suppress_none_returning" => {
+                    match parser::parse_bool(value.as_ref()) {
+                        Ok(bool) => flake8_annotations.suppress_none_returning = Some(bool),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
+                    }
+                }
+                "suppress-dummy-args" | "suppress_dummy_args" => {
+                    match parser::parse_bool(value.as_ref()) {
+                        Ok(bool) => flake8_annotations.suppress_dummy_args = Some(bool),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
+                    }
+                }
+                "mypy-init-return" | "mypy_init_return" => {
+                    match parser::parse_bool(value.as_ref()) {
+                        Ok(bool) => flake8_annotations.mypy_init_return = Some(bool),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
+                    }
+                }
+                "allow-star-arg-any" | "allow_star_arg_any" => {
+                    match parser::parse_bool(value.as_ref()) {
+                        Ok(bool) => flake8_annotations.allow_star_arg_any = Some(bool),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
+                    }
+                }
+                // flake8-quotes
+                "quotes" | "inline-quotes" | "inline_quotes" => match value.trim() {
+                    "'" | "single" => flake8_quotes.inline_quotes = Some(Quote::Single),
+                    "\"" | "double" => flake8_quotes.inline_quotes = Some(Quote::Double),
+                    _ => {
+                        warn_user!("Unexpected '{key}' value: {value}");
+                    }
+                },
+                "multiline-quotes" | "multiline_quotes" => match value.trim() {
+                    "'" | "single" => flake8_quotes.multiline_quotes = Some(Quote::Single),
+                    "\"" | "double" => flake8_quotes.multiline_quotes = Some(Quote::Double),
+                    _ => {
+                        warn_user!("Unexpected '{key}' value: {value}");
+                    }
+                },
+                "docstring-quotes" | "docstring_quotes" => match value.trim() {
+                    "'" | "single" => flake8_quotes.docstring_quotes = Some(Quote::Single),
+                    "\"" | "double" => flake8_quotes.docstring_quotes = Some(Quote::Double),
+                    _ => {
+                        warn_user!("Unexpected '{key}' value: {value}");
+                    }
+                },
+                "avoid-escape" | "avoid_escape" => match parser::parse_bool(value.as_ref()) {
+                    Ok(bool) => flake8_quotes.avoid_escape = Some(bool),
+                    Err(e) => {
+                        warn_user!("Unable to parse '{key}' property: {e}");
+                    }
+                },
+                // pep8-naming
+                "ignore-names" | "ignore_names" => {
+                    pep8_naming.ignore_names = Some(parser::parse_strings(value.as_ref()));
+                }
+                "classmethod-decorators" | "classmethod_decorators" => {
+                    pep8_naming.classmethod_decorators =
+                        Some(parser::parse_strings(value.as_ref()));
+                }
+                "staticmethod-decorators" | "staticmethod_decorators" => {
+                    pep8_naming.staticmethod_decorators =
+                        Some(parser::parse_strings(value.as_ref()));
+                }
+                // flake8-tidy-imports
+                "ban-relative-imports" | "ban_relative_imports" => match value.trim() {
+                    "true" => flake8_tidy_imports.ban_relative_imports = Some(Strictness::All),
+                    "parents" => {
+                        flake8_tidy_imports.ban_relative_imports = Some(Strictness::Parents);
+                    }
+                    _ => {
+                        warn_user!("Unexpected '{key}' value: {value}");
+                    }
+                },
+                // flake8-docstrings
+                "docstring-convention" => match value.trim() {
+                    "google" => pydocstyle.convention = Some(Convention::Google),
+                    "numpy" => pydocstyle.convention = Some(Convention::Numpy),
+                    "pep257" => pydocstyle.convention = Some(Convention::Pep257),
+                    "all" => pydocstyle.convention = None,
+                    _ => {
+                        warn_user!("Unexpected '{key}' value: {value}");
+                    }
+                },
+                // mccabe
+                "max-complexity" | "max_complexity" => match value.parse::<usize>() {
+                    Ok(max_complexity) => mccabe.max_complexity = Some(max_complexity),
+                    Err(e) => {
+                        warn_user!("Unable to parse '{key}' property: {e}");
+                    }
+                },
+                // flake8-errmsg
+                "errmsg-max-string-length" | "errmsg_max_string_length" => {
+                    match value.parse::<usize>() {
+                        Ok(max_string_length) => {
+                            flake8_errmsg.max_string_length = Some(max_string_length);
+                        }
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
+                    }
+                }
+                // flake8-pytest-style
+                "pytest-fixture-no-parentheses" | "pytest_fixture_no_parentheses " => {
+                    match parser::parse_bool(value.as_ref()) {
+                        Ok(bool) => flake8_pytest_style.fixture_parentheses = Some(!bool),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
+                    }
+                }
+                "pytest-parametrize-names-type" | "pytest_parametrize_names_type" => {
+                    match value.trim() {
+                        "csv" => {
+                            flake8_pytest_style.parametrize_names_type =
+                                Some(ParametrizeNameType::Csv);
+                        }
+                        "tuple" => {
+                            flake8_pytest_style.parametrize_names_type =
+                                Some(ParametrizeNameType::Tuple);
+                        }
+                        "list" => {
+                            flake8_pytest_style.parametrize_names_type =
+                                Some(ParametrizeNameType::List);
+                        }
+                        _ => {
+                            warn_user!("Unexpected '{key}' value: {value}");
+                        }
+                    }
+                }
+                "pytest-parametrize-values-type" | "pytest_parametrize_values_type" => {
+                    match value.trim() {
+                        "tuple" => {
+                            flake8_pytest_style.parametrize_values_type =
+                                Some(ParametrizeValuesType::Tuple);
+                        }
+                        "list" => {
+                            flake8_pytest_style.parametrize_values_type =
+                                Some(ParametrizeValuesType::List);
+                        }
+                        _ => {
+                            warn_user!("Unexpected '{key}' value: {value}");
+                        }
+                    }
+                }
+                "pytest-parametrize-values-row-type" | "pytest_parametrize_values_row_type" => {
+                    match value.trim() {
+                        "tuple" => {
+                            flake8_pytest_style.parametrize_values_row_type =
+                                Some(ParametrizeValuesRowType::Tuple);
+                        }
+                        "list" => {
+                            flake8_pytest_style.parametrize_values_row_type =
+                                Some(ParametrizeValuesRowType::List);
+                        }
+                        _ => {
+                            warn_user!("Unexpected '{key}' value: {value}");
+                        }
+                    }
+                }
+                "pytest-raises-require-match-for" | "pytest_raises_require_match_for" => {
+                    flake8_pytest_style.raises_require_match_for =
+                        Some(parser::parse_strings(value.as_ref()));
+                }
+                "pytest-mark-no-parentheses" | "pytest_mark_no_parentheses" => {
+                    match parser::parse_bool(value.as_ref()) {
+                        Ok(bool) => flake8_pytest_style.mark_parentheses = Some(!bool),
+                        Err(e) => {
+                            warn_user!("Unable to parse '{key}' property: {e}");
+                        }
+                    }
+                }
+                // Unknown
+                _ => {
+                    warn_user!("Skipping unsupported property: {}", key);
+                }
+            }
+        }
+    }
+
+    // Deduplicate and sort.
+    options.select = Some(
+        select
+            .into_iter()
+            .sorted_by_key(RuleSelector::prefix_and_code)
+            .collect(),
+    );
+    options.ignore = Some(
+        ignore
+            .into_iter()
+            .sorted_by_key(RuleSelector::prefix_and_code)
+            .collect(),
+    );
+    if flake8_annotations != Flake8AnnotationsOptions::default() {
+        options.flake8_annotations = Some(flake8_annotations);
+    }
+    if flake8_bugbear != Flake8BugbearOptions::default() {
+        options.flake8_bugbear = Some(flake8_bugbear);
+    }
+    if flake8_builtins != Flake8BuiltinsOptions::default() {
+        options.flake8_builtins = Some(flake8_builtins);
+    }
+    if flake8_errmsg != Flake8ErrMsgOptions::default() {
+        options.flake8_errmsg = Some(flake8_errmsg);
+    }
+    if flake8_pytest_style != Flake8PytestStyleOptions::default() {
+        options.flake8_pytest_style = Some(flake8_pytest_style);
+    }
+    if flake8_quotes != Flake8QuotesOptions::default() {
+        options.flake8_quotes = Some(flake8_quotes);
+    }
+    if flake8_tidy_imports != Flake8TidyImportsOptions::default() {
+        options.flake8_tidy_imports = Some(flake8_tidy_imports);
+    }
+    if mccabe != McCabeOptions::default() {
+        options.mccabe = Some(mccabe);
+    }
+    if pep8_naming != Pep8NamingOptions::default() {
+        options.pep8_naming = Some(pep8_naming);
+    }
+    if pydocstyle != PydocstyleOptions::default() {
+        options.pydocstyle = Some(pydocstyle);
+    }
+
+    // Extract any settings from the existing `pyproject.toml`.
+    if let Some(black) = &external_config.black {
+        if let Some(line_length) = &black.line_length {
+            options.line_length = Some(LineLength::from(*line_length));
+        }
+
+        if let Some(target_version) = &black.target_version {
+            if let Some(target_version) = target_version.iter().min() {
+                options.target_version = Some(*target_version);
+            }
+        }
+    }
+
+    if let Some(isort) = &external_config.isort {
+        if let Some(src_paths) = &isort.src_paths {
+            match options.src.as_mut() {
+                Some(src) => {
+                    src.extend_from_slice(src_paths);
+                }
+                None => {
+                    options.src = Some(src_paths.clone());
+                }
+            }
+        }
+    }
+
+    if let Some(project) = &external_config.project {
+        if let Some(requires_python) = &project.requires_python {
+            if options.target_version.is_none() {
+                options.target_version =
+                    PythonVersion::get_minimum_supported_version(requires_python);
+            }
+        }
+    }
+
+    // Create the pyproject.toml.
+    Pyproject::new(options)
+}
+
+/// Resolve the set of enabled `RuleSelector` values for the given
+/// plugins.
+fn resolve_select(plugins: &[Plugin]) -> HashSet<RuleSelector> {
+    let mut select: HashSet<_> = DEFAULT_SELECTORS.iter().cloned().collect();
+    select.extend(plugins.iter().map(|p| Linter::from(p).into()));
+    select
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::str::FromStr;
+
+    use anyhow::Result;
+    use itertools::Itertools;
+    use pep440_rs::VersionSpecifiers;
+
+    use pretty_assertions::assert_eq;
+    use ruff::line_width::LineLength;
+    use ruff::registry::Linter;
+    use ruff::rule_selector::RuleSelector;
+    use ruff::rules::flake8_quotes;
+    use ruff::rules::pydocstyle::settings::Convention;
+    use ruff::settings::types::PythonVersion;
+    use ruff_workspace::options::{Flake8QuotesOptions, Options, PydocstyleOptions};
+    use ruff_workspace::pyproject::Pyproject;
+
+    use crate::converter::DEFAULT_SELECTORS;
+    use crate::pep621::Project;
+    use crate::ExternalConfig;
+
+    use super::super::plugin::Plugin;
+    use super::convert;
+
+    fn default_options(plugins: impl IntoIterator<Item = RuleSelector>) -> Options {
+        Options {
+            ignore: Some(vec![]),
+            select: Some(
+                DEFAULT_SELECTORS
+                    .iter()
+                    .cloned()
+                    .chain(plugins)
+                    .sorted_by_key(RuleSelector::prefix_and_code)
+                    .collect(),
+            ),
+            ..Options::default()
+        }
+    }
+
+    #[test]
+    fn it_converts_empty() {
+        let actual = convert(
+            &HashMap::from([("flake8".to_string(), HashMap::default())]),
+            &ExternalConfig::default(),
+            None,
+        );
+        let expected = Pyproject::new(default_options([]));
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_converts_dashes() {
+        let actual = convert(
+            &HashMap::from([(
+                "flake8".to_string(),
+                HashMap::from([("max-line-length".to_string(), Some("100".to_string()))]),
+            )]),
+            &ExternalConfig::default(),
+            Some(vec![]),
+        );
+        let expected = Pyproject::new(Options {
+            line_length: Some(LineLength::from(100)),
+            ..default_options([])
+        });
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_converts_underscores() {
+        let actual = convert(
+            &HashMap::from([(
+                "flake8".to_string(),
+                HashMap::from([("max_line_length".to_string(), Some("100".to_string()))]),
+            )]),
+            &ExternalConfig::default(),
+            Some(vec![]),
+        );
+        let expected = Pyproject::new(Options {
+            line_length: Some(LineLength::from(100)),
+            ..default_options([])
+        });
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_ignores_parse_errors() {
+        let actual = convert(
+            &HashMap::from([(
+                "flake8".to_string(),
+                HashMap::from([("max_line_length".to_string(), Some("abc".to_string()))]),
+            )]),
+            &ExternalConfig::default(),
+            Some(vec![]),
+        );
+        let expected = Pyproject::new(default_options([]));
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_converts_plugin_options() {
+        let actual = convert(
+            &HashMap::from([(
+                "flake8".to_string(),
+                HashMap::from([("inline-quotes".to_string(), Some("single".to_string()))]),
+            )]),
+            &ExternalConfig::default(),
+            Some(vec![]),
+        );
+        let expected = Pyproject::new(Options {
+            flake8_quotes: Some(Flake8QuotesOptions {
+                inline_quotes: Some(flake8_quotes::settings::Quote::Single),
+                multiline_quotes: None,
+                docstring_quotes: None,
+                avoid_escape: None,
+            }),
+            ..default_options([])
+        });
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_converts_docstring_conventions() {
+        let actual = convert(
+            &HashMap::from([(
+                "flake8".to_string(),
+                HashMap::from([(
+                    "docstring-convention".to_string(),
+                    Some("numpy".to_string()),
+                )]),
+            )]),
+            &ExternalConfig::default(),
+            Some(vec![Plugin::Flake8Docstrings]),
+        );
+        let expected = Pyproject::new(Options {
+            pydocstyle: Some(PydocstyleOptions {
+                convention: Some(Convention::Numpy),
+                ignore_decorators: None,
+                property_decorators: None,
+            }),
+            ..default_options([Linter::Pydocstyle.into()])
+        });
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_infers_plugins_if_omitted() {
+        let actual = convert(
+            &HashMap::from([(
+                "flake8".to_string(),
+                HashMap::from([("inline-quotes".to_string(), Some("single".to_string()))]),
+            )]),
+            &ExternalConfig::default(),
+            None,
+        );
+        let expected = Pyproject::new(Options {
+            flake8_quotes: Some(Flake8QuotesOptions {
+                inline_quotes: Some(flake8_quotes::settings::Quote::Single),
+                multiline_quotes: None,
+                docstring_quotes: None,
+                avoid_escape: None,
+            }),
+            ..default_options([Linter::Flake8Quotes.into()])
+        });
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_converts_project_requires_python() -> Result<()> {
+        let actual = convert(
+            &HashMap::from([("flake8".to_string(), HashMap::default())]),
+            &ExternalConfig {
+                project: Some(&Project {
+                    requires_python: Some(VersionSpecifiers::from_str(">=3.8.16, <3.11")?),
+                }),
+                ..ExternalConfig::default()
+            },
+            Some(vec![]),
+        );
+        let expected = Pyproject::new(Options {
+            target_version: Some(PythonVersion::Py38),
+            ..default_options([])
+        });
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+}

crates/flake8_to_ruff/src/external_config.rs

@@ -0,0 +1,10 @@
+use super::black::Black;
+use super::isort::Isort;
+use super::pep621::Project;
+
+#[derive(Default)]
+pub(crate) struct ExternalConfig<'a> {
+    pub(crate) black: Option<&'a Black>,
+    pub(crate) isort: Option<&'a Isort>,
+    pub(crate) project: Option<&'a Project>,
+}

crates/flake8_to_ruff/src/isort.rs

@@ -0,0 +1,10 @@
+//! Extract isort configuration settings from a pyproject.toml.
+
+use serde::{Deserialize, Serialize};
+
+/// The [isort configuration](https://pycqa.github.io/isort/docs/configuration/config_files.html).
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub(crate) struct Isort {
+    #[serde(alias = "src-paths", alias = "src_paths")]
+    pub(crate) src_paths: Option<Vec<String>>,
+}

crates/flake8_to_ruff/src/main.rs

@@ -1,12 +1,24 @@
 //! Utility to generate Ruff's `pyproject.toml` section from a Flake8 INI file.
 
+mod black;
+mod converter;
+mod external_config;
+mod isort;
+mod parser;
+mod pep621;
+mod plugin;
+mod pyproject;
+
 use std::path::PathBuf;
 
 use anyhow::Result;
 use clap::Parser;
 use configparser::ini::Ini;
 
-use ruff::flake8_to_ruff::{self, ExternalConfig};
+use crate::converter::convert;
+use crate::external_config::ExternalConfig;
+use crate::plugin::Plugin;
+use crate::pyproject::parse;
 use ruff::logging::{set_up_logging, LogLevel};
 
 #[derive(Parser)]
@@ -25,7 +37,7 @@ struct Args {
     pyproject: Option<PathBuf>,
     /// List of plugins to enable.
     #[arg(long, value_delimiter = ',')]
-    plugin: Option<Vec<flake8_to_ruff::Plugin>>,
+    plugin: Option<Vec<Plugin>>,
 }
 
 fn main() -> Result<()> {
@@ -39,7 +51,7 @@ fn main() -> Result<()> {
     let config = ini.load(args.file).map_err(|msg| anyhow::anyhow!(msg))?;
 
     // Read the pyproject.toml file.
-    let pyproject = args.pyproject.map(flake8_to_ruff::parse).transpose()?;
+    let pyproject = args.pyproject.map(parse).transpose()?;
     let external_config = pyproject
         .as_ref()
         .and_then(|pyproject| pyproject.tool.as_ref())
@@ -57,7 +69,7 @@ fn main() -> Result<()> {
     };
 
     // Create Ruff's pyproject.toml section.
-    let pyproject = flake8_to_ruff::convert(&config, &external_config, args.plugin)?;
+    let pyproject = convert(&config, &external_config, args.plugin);
 
     #[allow(clippy::print_stdout)]
     {

crates/flake8_to_ruff/src/parser.rs

@@ -0,0 +1,390 @@
+use std::str::FromStr;
+
+use anyhow::{bail, Result};
+use once_cell::sync::Lazy;
+use regex::Regex;
+use ruff::settings::types::PatternPrefixPair;
+use ruff::{warn_user, RuleSelector};
+use rustc_hash::FxHashMap;
+
+static COMMA_SEPARATED_LIST_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"[,\s]").unwrap());
+
+/// Parse a comma-separated list of `RuleSelector` values (e.g.,
+/// "F401,E501").
+pub(crate) fn parse_prefix_codes(value: &str) -> Vec<RuleSelector> {
+    let mut codes: Vec<RuleSelector> = vec![];
+    for code in COMMA_SEPARATED_LIST_RE.split(value) {
+        let code = code.trim();
+        if code.is_empty() {
+            continue;
+        }
+        if let Ok(code) = RuleSelector::from_str(code) {
+            codes.push(code);
+        } else {
+            warn_user!("Unsupported prefix code: {code}");
+        }
+    }
+    codes
+}
+
+/// Parse a comma-separated list of strings (e.g., "__init__.py,__main__.py").
+pub(crate) fn parse_strings(value: &str) -> Vec<String> {
+    COMMA_SEPARATED_LIST_RE
+        .split(value)
+        .map(str::trim)
+        .filter(|part| !part.is_empty())
+        .map(String::from)
+        .collect()
+}
+
+/// Parse a boolean.
+pub(crate) fn parse_bool(value: &str) -> Result<bool> {
+    match value.trim() {
+        "true" => Ok(true),
+        "false" => Ok(false),
+        _ => bail!("Unexpected boolean value: {value}"),
+    }
+}
+
+#[derive(Debug)]
+struct Token {
+    token_name: TokenType,
+    src: String,
+}
+
+#[derive(Debug, Copy, Clone)]
+enum TokenType {
+    Code,
+    File,
+    Colon,
+    Comma,
+    Ws,
+    Eof,
+}
+
+struct State {
+    seen_sep: bool,
+    seen_colon: bool,
+    filenames: Vec<String>,
+    codes: Vec<String>,
+}
+
+impl State {
+    const fn new() -> Self {
+        Self {
+            seen_sep: true,
+            seen_colon: false,
+            filenames: vec![],
+            codes: vec![],
+        }
+    }
+
+    /// Generate the list of `StrRuleCodePair` pairs for the current
+    /// state.
+    fn parse(&self) -> Vec<PatternPrefixPair> {
+        let mut codes: Vec<PatternPrefixPair> = vec![];
+        for code in &self.codes {
+            if let Ok(code) = RuleSelector::from_str(code) {
+                for filename in &self.filenames {
+                    codes.push(PatternPrefixPair {
+                        pattern: filename.clone(),
+                        prefix: code.clone(),
+                    });
+                }
+            } else {
+                warn_user!("Unsupported prefix code: {code}");
+            }
+        }
+        codes
+    }
+}
+
+/// Tokenize the raw 'files-to-codes' mapping.
+fn tokenize_files_to_codes_mapping(value: &str) -> Vec<Token> {
+    let mut tokens = vec![];
+    let mut i = 0;
+    while i < value.len() {
+        for (token_re, token_name) in [
+            (
+                Regex::new(r"([A-Z]+[0-9]*)(?:$|\s|,)").unwrap(),
+                TokenType::Code,
+            ),
+            (Regex::new(r"([^\s:,]+)").unwrap(), TokenType::File),
+            (Regex::new(r"(\s*:\s*)").unwrap(), TokenType::Colon),
+            (Regex::new(r"(\s*,\s*)").unwrap(), TokenType::Comma),
+            (Regex::new(r"(\s+)").unwrap(), TokenType::Ws),
+        ] {
+            if let Some(cap) = token_re.captures(&value[i..]) {
+                let mat = cap.get(1).unwrap();
+                if mat.start() == 0 {
+                    tokens.push(Token {
+                        token_name,
+                        src: mat.as_str().trim().to_string(),
+                    });
+                    i += mat.end();
+                    break;
+                }
+            }
+        }
+    }
+    tokens.push(Token {
+        token_name: TokenType::Eof,
+        src: String::new(),
+    });
+    tokens
+}
+
+/// Parse a 'files-to-codes' mapping, mimicking Flake8's internal logic.
+/// See: <https://github.com/PyCQA/flake8/blob/7dfe99616fc2f07c0017df2ba5fa884158f3ea8a/src/flake8/utils.py#L45>
+pub(crate) fn parse_files_to_codes_mapping(value: &str) -> Result<Vec<PatternPrefixPair>> {
+    if value.trim().is_empty() {
+        return Ok(vec![]);
+    }
+    let mut codes: Vec<PatternPrefixPair> = vec![];
+    let mut state = State::new();
+    for token in tokenize_files_to_codes_mapping(value) {
+        if matches!(token.token_name, TokenType::Comma | TokenType::Ws) {
+            state.seen_sep = true;
+        } else if !state.seen_colon {
+            if matches!(token.token_name, TokenType::Colon) {
+                state.seen_colon = true;
+                state.seen_sep = true;
+            } else if state.seen_sep && matches!(token.token_name, TokenType::File) {
+                state.filenames.push(token.src);
+                state.seen_sep = false;
+            } else {
+                bail!("Unexpected token: {:?}", token.token_name);
+            }
+        } else {
+            if matches!(token.token_name, TokenType::Eof) {
+                codes.extend(state.parse());
+                state = State::new();
+            } else if state.seen_sep && matches!(token.token_name, TokenType::Code) {
+                state.codes.push(token.src);
+                state.seen_sep = false;
+            } else if state.seen_sep && matches!(token.token_name, TokenType::File) {
+                codes.extend(state.parse());
+                state = State::new();
+                state.filenames.push(token.src);
+                state.seen_sep = false;
+            } else {
+                bail!("Unexpected token: {:?}", token.token_name);
+            }
+        }
+    }
+    Ok(codes)
+}
+
+/// Collect a list of `PatternPrefixPair` structs as a `BTreeMap`.
+pub(crate) fn collect_per_file_ignores(
+    pairs: Vec<PatternPrefixPair>,
+) -> FxHashMap<String, Vec<RuleSelector>> {
+    let mut per_file_ignores: FxHashMap<String, Vec<RuleSelector>> = FxHashMap::default();
+    for pair in pairs {
+        per_file_ignores
+            .entry(pair.pattern)
+            .or_insert_with(Vec::new)
+            .push(pair.prefix);
+    }
+    per_file_ignores
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::Result;
+    use ruff::RuleSelector;
+
+    use ruff::codes;
+    use ruff::registry::Linter;
+    use ruff::settings::types::PatternPrefixPair;
+
+    use super::{parse_files_to_codes_mapping, parse_prefix_codes, parse_strings};
+
+    #[test]
+    fn it_parses_prefix_codes() {
+        let actual = parse_prefix_codes("");
+        let expected: Vec<RuleSelector> = vec![];
+        assert_eq!(actual, expected);
+
+        let actual = parse_prefix_codes(" ");
+        let expected: Vec<RuleSelector> = vec![];
+        assert_eq!(actual, expected);
+
+        let actual = parse_prefix_codes("F401");
+        let expected = vec![codes::Pyflakes::_401.into()];
+        assert_eq!(actual, expected);
+
+        let actual = parse_prefix_codes("F401,");
+        let expected = vec![codes::Pyflakes::_401.into()];
+        assert_eq!(actual, expected);
+
+        let actual = parse_prefix_codes("F401,E501");
+        let expected = vec![
+            codes::Pyflakes::_401.into(),
+            codes::Pycodestyle::E501.into(),
+        ];
+        assert_eq!(actual, expected);
+
+        let actual = parse_prefix_codes("F401, E501");
+        let expected = vec![
+            codes::Pyflakes::_401.into(),
+            codes::Pycodestyle::E501.into(),
+        ];
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_parses_strings() {
+        let actual = parse_strings("");
+        let expected: Vec<String> = vec![];
+        assert_eq!(actual, expected);
+
+        let actual = parse_strings(" ");
+        let expected: Vec<String> = vec![];
+        assert_eq!(actual, expected);
+
+        let actual = parse_strings("__init__.py");
+        let expected = vec!["__init__.py".to_string()];
+        assert_eq!(actual, expected);
+
+        let actual = parse_strings("__init__.py,");
+        let expected = vec!["__init__.py".to_string()];
+        assert_eq!(actual, expected);
+
+        let actual = parse_strings("__init__.py,__main__.py");
+        let expected = vec!["__init__.py".to_string(), "__main__.py".to_string()];
+        assert_eq!(actual, expected);
+
+        let actual = parse_strings("__init__.py, __main__.py");
+        let expected = vec!["__init__.py".to_string(), "__main__.py".to_string()];
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn it_parse_files_to_codes_mapping() -> Result<()> {
+        let actual = parse_files_to_codes_mapping("")?;
+        let expected: Vec<PatternPrefixPair> = vec![];
+        assert_eq!(actual, expected);
+
+        let actual = parse_files_to_codes_mapping(" ")?;
+        let expected: Vec<PatternPrefixPair> = vec![];
+        assert_eq!(actual, expected);
+
+        // Ex) locust
+        let actual = parse_files_to_codes_mapping(
+            "per-file-ignores =
+    locust/test/*: F841
+    examples/*: F841
+    *.pyi: E302,E704"
+                .strip_prefix("per-file-ignores =")
+                .unwrap(),
+        )?;
+        let expected: Vec<PatternPrefixPair> = vec![
+            PatternPrefixPair {
+                pattern: "locust/test/*".to_string(),
+                prefix: codes::Pyflakes::_841.into(),
+            },
+            PatternPrefixPair {
+                pattern: "examples/*".to_string(),
+                prefix: codes::Pyflakes::_841.into(),
+            },
+        ];
+        assert_eq!(actual, expected);
+
+        // Ex) celery
+        let actual = parse_files_to_codes_mapping(
+            "per-file-ignores =
+   t/*,setup.py,examples/*,docs/*,extra/*:
+       D,"
+            .strip_prefix("per-file-ignores =")
+            .unwrap(),
+        )?;
+        let expected: Vec<PatternPrefixPair> = vec![
+            PatternPrefixPair {
+                pattern: "t/*".to_string(),
+                prefix: Linter::Pydocstyle.into(),
+            },
+            PatternPrefixPair {
+                pattern: "setup.py".to_string(),
+                prefix: Linter::Pydocstyle.into(),
+            },
+            PatternPrefixPair {
+                pattern: "examples/*".to_string(),
+                prefix: Linter::Pydocstyle.into(),
+            },
+            PatternPrefixPair {
+                pattern: "docs/*".to_string(),
+                prefix: Linter::Pydocstyle.into(),
+            },
+            PatternPrefixPair {
+                pattern: "extra/*".to_string(),
+                prefix: Linter::Pydocstyle.into(),
+            },
+        ];
+        assert_eq!(actual, expected);
+
+        // Ex) scrapy
+        let actual = parse_files_to_codes_mapping(
+            "per-file-ignores =
+    scrapy/__init__.py:E402
+    scrapy/core/downloader/handlers/http.py:F401
+    scrapy/http/__init__.py:F401
+    scrapy/linkextractors/__init__.py:E402,F401
+    scrapy/selector/__init__.py:F401
+    scrapy/spiders/__init__.py:E402,F401
+    scrapy/utils/url.py:F403,F405
+    tests/test_loader.py:E741"
+                .strip_prefix("per-file-ignores =")
+                .unwrap(),
+        )?;
+        let expected: Vec<PatternPrefixPair> = vec![
+            PatternPrefixPair {
+                pattern: "scrapy/__init__.py".to_string(),
+                prefix: codes::Pycodestyle::E402.into(),
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/core/downloader/handlers/http.py".to_string(),
+                prefix: codes::Pyflakes::_401.into(),
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/http/__init__.py".to_string(),
+                prefix: codes::Pyflakes::_401.into(),
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/linkextractors/__init__.py".to_string(),
+                prefix: codes::Pycodestyle::E402.into(),
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/linkextractors/__init__.py".to_string(),
+                prefix: codes::Pyflakes::_401.into(),
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/selector/__init__.py".to_string(),
+                prefix: codes::Pyflakes::_401.into(),
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/spiders/__init__.py".to_string(),
+                prefix: codes::Pycodestyle::E402.into(),
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/spiders/__init__.py".to_string(),
+                prefix: codes::Pyflakes::_401.into(),
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/utils/url.py".to_string(),
+                prefix: codes::Pyflakes::_403.into(),
+            },
+            PatternPrefixPair {
+                pattern: "scrapy/utils/url.py".to_string(),
+                prefix: codes::Pyflakes::_405.into(),
+            },
+            PatternPrefixPair {
+                pattern: "tests/test_loader.py".to_string(),
+                prefix: codes::Pycodestyle::E741.into(),
+            },
+        ];
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+}

crates/flake8_to_ruff/src/pep621.rs

@@ -0,0 +1,10 @@
+//! Extract PEP 621 configuration settings from a pyproject.toml.
+
+use pep440_rs::VersionSpecifiers;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub(crate) struct Project {
+    #[serde(alias = "requires-python", alias = "requires_python")]
+    pub(crate) requires_python: Option<VersionSpecifiers>,
+}

crates/flake8_to_ruff/src/plugin.rs

@@ -0,0 +1,367 @@
+use std::collections::{BTreeSet, HashMap, HashSet};
+use std::fmt;
+use std::str::FromStr;
+
+use anyhow::anyhow;
+use ruff::registry::Linter;
+use ruff::RuleSelector;
+
+#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub enum Plugin {
+    Flake82020,
+    Flake8Annotations,
+    Flake8Bandit,
+    Flake8BlindExcept,
+    Flake8BooleanTrap,
+    Flake8Bugbear,
+    Flake8Builtins,
+    Flake8Commas,
+    Flake8Comprehensions,
+    Flake8Datetimez,
+    Flake8Debugger,
+    Flake8Docstrings,
+    Flake8Eradicate,
+    Flake8ErrMsg,
+    Flake8Executable,
+    Flake8ImplicitStrConcat,
+    Flake8ImportConventions,
+    Flake8NoPep420,
+    Flake8Pie,
+    Flake8Print,
+    Flake8PytestStyle,
+    Flake8Quotes,
+    Flake8Return,
+    Flake8Simplify,
+    Flake8TidyImports,
+    Flake8TypeChecking,
+    Flake8UnusedArguments,
+    Flake8UsePathlib,
+    McCabe,
+    PEP8Naming,
+    PandasVet,
+    Pyupgrade,
+    Tryceratops,
+}
+
+impl FromStr for Plugin {
+    type Err = anyhow::Error;
+
+    fn from_str(string: &str) -> Result<Self, Self::Err> {
+        match string {
+            "flake8-2020" => Ok(Plugin::Flake82020),
+            "flake8-annotations" => Ok(Plugin::Flake8Annotations),
+            "flake8-bandit" => Ok(Plugin::Flake8Bandit),
+            "flake8-blind-except" => Ok(Plugin::Flake8BlindExcept),
+            "flake8-boolean-trap" => Ok(Plugin::Flake8BooleanTrap),
+            "flake8-bugbear" => Ok(Plugin::Flake8Bugbear),
+            "flake8-builtins" => Ok(Plugin::Flake8Builtins),
+            "flake8-commas" => Ok(Plugin::Flake8Commas),
+            "flake8-comprehensions" => Ok(Plugin::Flake8Comprehensions),
+            "flake8-datetimez" => Ok(Plugin::Flake8Datetimez),
+            "flake8-debugger" => Ok(Plugin::Flake8Debugger),
+            "flake8-docstrings" => Ok(Plugin::Flake8Docstrings),
+            "flake8-eradicate" => Ok(Plugin::Flake8Eradicate),
+            "flake8-errmsg" => Ok(Plugin::Flake8ErrMsg),
+            "flake8-executable" => Ok(Plugin::Flake8Executable),
+            "flake8-implicit-str-concat" => Ok(Plugin::Flake8ImplicitStrConcat),
+            "flake8-import-conventions" => Ok(Plugin::Flake8ImportConventions),
+            "flake8-no-pep420" => Ok(Plugin::Flake8NoPep420),
+            "flake8-pie" => Ok(Plugin::Flake8Pie),
+            "flake8-print" => Ok(Plugin::Flake8Print),
+            "flake8-pytest-style" => Ok(Plugin::Flake8PytestStyle),
+            "flake8-quotes" => Ok(Plugin::Flake8Quotes),
+            "flake8-return" => Ok(Plugin::Flake8Return),
+            "flake8-simplify" => Ok(Plugin::Flake8Simplify),
+            "flake8-tidy-imports" => Ok(Plugin::Flake8TidyImports),
+            "flake8-type-checking" => Ok(Plugin::Flake8TypeChecking),
+            "flake8-unused-arguments" => Ok(Plugin::Flake8UnusedArguments),
+            "flake8-use-pathlib" => Ok(Plugin::Flake8UsePathlib),
+            "mccabe" => Ok(Plugin::McCabe),
+            "pep8-naming" => Ok(Plugin::PEP8Naming),
+            "pandas-vet" => Ok(Plugin::PandasVet),
+            "pyupgrade" => Ok(Plugin::Pyupgrade),
+            "tryceratops" => Ok(Plugin::Tryceratops),
+            _ => Err(anyhow!("Unknown plugin: {string}")),
+        }
+    }
+}
+
+impl fmt::Debug for Plugin {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Plugin::Flake82020 => "flake8-2020",
+                Plugin::Flake8Annotations => "flake8-annotations",
+                Plugin::Flake8Bandit => "flake8-bandit",
+                Plugin::Flake8BlindExcept => "flake8-blind-except",
+                Plugin::Flake8BooleanTrap => "flake8-boolean-trap",
+                Plugin::Flake8Bugbear => "flake8-bugbear",
+                Plugin::Flake8Builtins => "flake8-builtins",
+                Plugin::Flake8Commas => "flake8-commas",
+                Plugin::Flake8Comprehensions => "flake8-comprehensions",
+                Plugin::Flake8Datetimez => "flake8-datetimez",
+                Plugin::Flake8Debugger => "flake8-debugger",
+                Plugin::Flake8Docstrings => "flake8-docstrings",
+                Plugin::Flake8Eradicate => "flake8-eradicate",
+                Plugin::Flake8ErrMsg => "flake8-errmsg",
+                Plugin::Flake8Executable => "flake8-executable",
+                Plugin::Flake8ImplicitStrConcat => "flake8-implicit-str-concat",
+                Plugin::Flake8ImportConventions => "flake8-import-conventions",
+                Plugin::Flake8NoPep420 => "flake8-no-pep420",
+                Plugin::Flake8Pie => "flake8-pie",
+                Plugin::Flake8Print => "flake8-print",
+                Plugin::Flake8PytestStyle => "flake8-pytest-style",
+                Plugin::Flake8Quotes => "flake8-quotes",
+                Plugin::Flake8Return => "flake8-return",
+                Plugin::Flake8Simplify => "flake8-simplify",
+                Plugin::Flake8TidyImports => "flake8-tidy-imports",
+                Plugin::Flake8TypeChecking => "flake8-type-checking",
+                Plugin::Flake8UnusedArguments => "flake8-unused-arguments",
+                Plugin::Flake8UsePathlib => "flake8-use-pathlib",
+                Plugin::McCabe => "mccabe",
+                Plugin::PEP8Naming => "pep8-naming",
+                Plugin::PandasVet => "pandas-vet",
+                Plugin::Pyupgrade => "pyupgrade",
+                Plugin::Tryceratops => "tryceratops",
+            }
+        )
+    }
+}
+
+impl From<&Plugin> for Linter {
+    fn from(plugin: &Plugin) -> Self {
+        match plugin {
+            Plugin::Flake82020 => Linter::Flake82020,
+            Plugin::Flake8Annotations => Linter::Flake8Annotations,
+            Plugin::Flake8Bandit => Linter::Flake8Bandit,
+            Plugin::Flake8BlindExcept => Linter::Flake8BlindExcept,
+            Plugin::Flake8BooleanTrap => Linter::Flake8BooleanTrap,
+            Plugin::Flake8Bugbear => Linter::Flake8Bugbear,
+            Plugin::Flake8Builtins => Linter::Flake8Builtins,
+            Plugin::Flake8Commas => Linter::Flake8Commas,
+            Plugin::Flake8Comprehensions => Linter::Flake8Comprehensions,
+            Plugin::Flake8Datetimez => Linter::Flake8Datetimez,
+            Plugin::Flake8Debugger => Linter::Flake8Debugger,
+            Plugin::Flake8Docstrings => Linter::Pydocstyle,
+            Plugin::Flake8Eradicate => Linter::Eradicate,
+            Plugin::Flake8ErrMsg => Linter::Flake8ErrMsg,
+            Plugin::Flake8Executable => Linter::Flake8Executable,
+            Plugin::Flake8ImplicitStrConcat => Linter::Flake8ImplicitStrConcat,
+            Plugin::Flake8ImportConventions => Linter::Flake8ImportConventions,
+            Plugin::Flake8NoPep420 => Linter::Flake8NoPep420,
+            Plugin::Flake8Pie => Linter::Flake8Pie,
+            Plugin::Flake8Print => Linter::Flake8Print,
+            Plugin::Flake8PytestStyle => Linter::Flake8PytestStyle,
+            Plugin::Flake8Quotes => Linter::Flake8Quotes,
+            Plugin::Flake8Return => Linter::Flake8Return,
+            Plugin::Flake8Simplify => Linter::Flake8Simplify,
+            Plugin::Flake8TidyImports => Linter::Flake8TidyImports,
+            Plugin::Flake8TypeChecking => Linter::Flake8TypeChecking,
+            Plugin::Flake8UnusedArguments => Linter::Flake8UnusedArguments,
+            Plugin::Flake8UsePathlib => Linter::Flake8UsePathlib,
+            Plugin::McCabe => Linter::McCabe,
+            Plugin::PEP8Naming => Linter::PEP8Naming,
+            Plugin::PandasVet => Linter::PandasVet,
+            Plugin::Pyupgrade => Linter::Pyupgrade,
+            Plugin::Tryceratops => Linter::Tryceratops,
+        }
+    }
+}
+
+/// Infer the enabled plugins based on user-provided options.
+///
+/// For example, if the user specified a `mypy-init-return` setting, we should
+/// infer that `flake8-annotations` is active.
+pub(crate) fn infer_plugins_from_options(flake8: &HashMap<String, Option<String>>) -> Vec<Plugin> {
+    let mut plugins = BTreeSet::new();
+    for key in flake8.keys() {
+        match key.as_str() {
+            // flake8-annotations
+            "suppress-none-returning" | "suppress_none_returning" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "suppress-dummy-args" | "suppress_dummy_args" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "allow-untyped-defs" | "allow_untyped_defs" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "allow-untyped-nested" | "allow_untyped_nested" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "mypy-init-return" | "mypy_init_return" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "dispatch-decorators" | "dispatch_decorators" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "overload-decorators" | "overload_decorators" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            "allow-star-arg-any" | "allow_star_arg_any" => {
+                plugins.insert(Plugin::Flake8Annotations);
+            }
+            // flake8-bugbear
+            "extend-immutable-calls" | "extend_immutable_calls" => {
+                plugins.insert(Plugin::Flake8Bugbear);
+            }
+            // flake8-builtins
+            "builtins-ignorelist" | "builtins_ignorelist" => {
+                plugins.insert(Plugin::Flake8Builtins);
+            }
+            // flake8-docstrings
+            "docstring-convention" | "docstring_convention" => {
+                plugins.insert(Plugin::Flake8Docstrings);
+            }
+            // flake8-eradicate
+            "eradicate-aggressive" | "eradicate_aggressive" => {
+                plugins.insert(Plugin::Flake8Eradicate);
+            }
+            "eradicate-whitelist" | "eradicate_whitelist" => {
+                plugins.insert(Plugin::Flake8Eradicate);
+            }
+            "eradicate-whitelist-extend" | "eradicate_whitelist_extend" => {
+                plugins.insert(Plugin::Flake8Eradicate);
+            }
+            // flake8-pytest-style
+            "pytest-fixture-no-parentheses" | "pytest_fixture_no_parentheses " => {
+                plugins.insert(Plugin::Flake8PytestStyle);
+            }
+            "pytest-parametrize-names-type" | "pytest_parametrize_names_type" => {
+                plugins.insert(Plugin::Flake8PytestStyle);
+            }
+            "pytest-parametrize-values-type" | "pytest_parametrize_values_type" => {
+                plugins.insert(Plugin::Flake8PytestStyle);
+            }
+            "pytest-parametrize-values-row-type" | "pytest_parametrize_values_row_type" => {
+                plugins.insert(Plugin::Flake8PytestStyle);
+            }
+            "pytest-raises-require-match-for" | "pytest_raises_require_match_for" => {
+                plugins.insert(Plugin::Flake8PytestStyle);
+            }
+            "pytest-mark-no-parentheses" | "pytest_mark_no_parentheses" => {
+                plugins.insert(Plugin::Flake8PytestStyle);
+            }
+            // flake8-quotes
+            "quotes" | "inline-quotes" | "inline_quotes" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            "multiline-quotes" | "multiline_quotes" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            "docstring-quotes" | "docstring_quotes" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            "avoid-escape" | "avoid_escape" => {
+                plugins.insert(Plugin::Flake8Quotes);
+            }
+            // flake8-tidy-imports
+            "ban-relative-imports" | "ban_relative_imports" => {
+                plugins.insert(Plugin::Flake8TidyImports);
+            }
+            "banned-modules" | "banned_modules" => {
+                plugins.insert(Plugin::Flake8TidyImports);
+            }
+            // mccabe
+            "max-complexity" | "max_complexity" => {
+                plugins.insert(Plugin::McCabe);
+            }
+            // pep8-naming
+            "ignore-names" | "ignore_names" => {
+                plugins.insert(Plugin::PEP8Naming);
+            }
+            "classmethod-decorators" | "classmethod_decorators" => {
+                plugins.insert(Plugin::PEP8Naming);
+            }
+            "staticmethod-decorators" | "staticmethod_decorators" => {
+                plugins.insert(Plugin::PEP8Naming);
+            }
+            "max-string-length" | "max_string_length" => {
+                plugins.insert(Plugin::Flake8ErrMsg);
+            }
+            _ => {}
+        }
+    }
+    Vec::from_iter(plugins)
+}
+
+/// Infer the enabled plugins based on the referenced prefixes.
+///
+/// For example, if the user ignores `ANN101`, we should infer that
+/// `flake8-annotations` is active.
+pub(crate) fn infer_plugins_from_codes(selectors: &HashSet<RuleSelector>) -> Vec<Plugin> {
+    // Ignore cases in which we've knowingly changed rule prefixes.
+    [
+        Plugin::Flake82020,
+        Plugin::Flake8Annotations,
+        Plugin::Flake8Bandit,
+        // Plugin::Flake8BlindExcept,
+        Plugin::Flake8BooleanTrap,
+        Plugin::Flake8Bugbear,
+        Plugin::Flake8Builtins,
+        // Plugin::Flake8Commas,
+        Plugin::Flake8Comprehensions,
+        Plugin::Flake8Datetimez,
+        Plugin::Flake8Debugger,
+        Plugin::Flake8Docstrings,
+        // Plugin::Flake8Eradicate,
+        Plugin::Flake8ErrMsg,
+        Plugin::Flake8Executable,
+        Plugin::Flake8ImplicitStrConcat,
+        // Plugin::Flake8ImportConventions,
+        Plugin::Flake8NoPep420,
+        Plugin::Flake8Pie,
+        Plugin::Flake8Print,
+        Plugin::Flake8PytestStyle,
+        Plugin::Flake8Quotes,
+        Plugin::Flake8Return,
+        Plugin::Flake8Simplify,
+        // Plugin::Flake8TidyImports,
+        // Plugin::Flake8TypeChecking,
+        Plugin::Flake8UnusedArguments,
+        // Plugin::Flake8UsePathlib,
+        Plugin::McCabe,
+        Plugin::PEP8Naming,
+        Plugin::PandasVet,
+        Plugin::Tryceratops,
+    ]
+    .into_iter()
+    .filter(|plugin| {
+        for selector in selectors {
+            if selector
+                .into_iter()
+                .any(|rule| Linter::from(plugin).rules().any(|r| r == rule))
+            {
+                return true;
+            }
+        }
+        false
+    })
+    .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use super::{infer_plugins_from_options, Plugin};
+
+    #[test]
+    fn it_infers_plugins() {
+        let actual = infer_plugins_from_options(&HashMap::from([(
+            "inline-quotes".to_string(),
+            Some("single".to_string()),
+        )]));
+        let expected = vec![Plugin::Flake8Quotes];
+        assert_eq!(actual, expected);
+
+        let actual = infer_plugins_from_options(&HashMap::from([(
+            "staticmethod-decorators".to_string(),
+            Some("[]".to_string()),
+        )]));
+        let expected = vec![Plugin::PEP8Naming];
+        assert_eq!(actual, expected);
+    }
+}

crates/flake8_to_ruff/src/pyproject.rs

@@ -0,0 +1,26 @@
+use std::path::Path;
+
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+use super::black::Black;
+use super::isort::Isort;
+use super::pep621::Project;
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub(crate) struct Tools {
+    pub(crate) black: Option<Black>,
+    pub(crate) isort: Option<Isort>,
+}
+
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub(crate) struct Pyproject {
+    pub(crate) tool: Option<Tools>,
+    pub(crate) project: Option<Project>,
+}
+
+pub(crate) fn parse<P: AsRef<Path>>(path: P) -> Result<Pyproject> {
+    let contents = std::fs::read_to_string(path)?;
+    let pyproject = toml::from_str::<Pyproject>(&contents)?;
+    Ok(pyproject)
+}