Merge branch 'main' into fix_b006_import

.github/dependabot.yml

@@ -9,5 +9,5 @@ updates:
   - package-ecosystem: "cargo"
     directory: "/"
     schedule:
-      interval: "daily"
+      interval: "weekly"
     labels: ["internal"]

Cargo.toml

@@ -15,7 +15,7 @@ license = "MIT"
 anyhow = { version = "1.0.69" }
 bitflags = { version = "2.3.1" }
 chrono = { version = "0.4.31", default-features = false, features = ["clock"] }
-clap = { version = "4.4.4", features = ["derive"] }
+clap = { version = "4.4.5", features = ["derive"] }
 colored = { version = "2.0.0" }
 filetime = { version = "0.2.20" }
 glob = { version = "0.3.1" }
@@ -26,8 +26,6 @@ is-macro = { version = "0.3.0" }
 itertools = { version = "0.11.0" }
 log = { version = "0.4.17" }
 memchr = "2.6.3"
-num-bigint = { version = "0.4.3" }
-num-traits = { version = "0.2.15" }
 once_cell = { version = "1.17.1" }
 path-absolutize = { version = "3.1.1" }
 proc-macro2 = { version = "1.0.67" }

README.md

@@ -140,7 +140,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com) hook:
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
   # Ruff version.
-  rev: v0.0.290
+  rev: v0.0.291
   hooks:
     - id: ruff
 ```

crates/flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.290"
+version = "0.0.291"
 description = """
 Convert Flake8 configuration files to Ruff configuration files.
 """

crates/ruff_benchmark/benches/formatter.rs

@@ -4,7 +4,7 @@ use ruff_benchmark::criterion::{
     criterion_group, criterion_main, BenchmarkId, Criterion, Throughput,
 };
 use ruff_benchmark::{TestCase, TestFile, TestFileDownloadError};
-use ruff_python_formatter::{format_node, PyFormatOptions};
+use ruff_python_formatter::{format_module_ast, PyFormatOptions};
 use ruff_python_index::CommentRangesBuilder;
 use ruff_python_parser::lexer::lex;
 use ruff_python_parser::{parse_tokens, Mode};
@@ -65,13 +65,14 @@ fn benchmark_formatter(criterion: &mut Criterion) {
                 let comment_ranges = comment_ranges.finish();
 
                 // Parse the AST.
-                let python_ast = parse_tokens(tokens, Mode::Module, "<filename>")
+                let module = parse_tokens(tokens, Mode::Module, "<filename>")
                     .expect("Input to be a valid python program");
 
                 b.iter(|| {
                     let options = PyFormatOptions::from_extension(Path::new(case.name()));
-                    let formatted = format_node(&python_ast, &comment_ranges, case.code(), options)
-                        .expect("Formatting to succeed");
+                    let formatted =
+                        format_module_ast(&module, &comment_ranges, case.code(), options)
+                            .expect("Formatting to succeed");
 
                     formatted.print().expect("Printing to succeed")
                 });

crates/ruff_cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_cli"
-version = "0.0.290"
+version = "0.0.291"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_cli/src/commands/config.rs

@@ -1,12 +1,13 @@
 use anyhow::{anyhow, Result};
 
 use ruff_workspace::options::Options;
+use ruff_workspace::options_base::OptionsMetadata;
 
 #[allow(clippy::print_stdout)]
 pub(crate) fn config(key: Option<&str>) -> Result<()> {
     match key {
         None => print!("{}", Options::metadata()),
-        Some(key) => match Options::metadata().get(key) {
+        Some(key) => match Options::metadata().find(key) {
             None => {
                 return Err(anyhow!("Unknown option: {key}"));
             }

crates/ruff_cli/src/commands/format.rs

@@ -15,9 +15,9 @@ use ruff_linter::fs;
 use ruff_linter::logging::LogLevel;
 use ruff_linter::warn_user_once;
 use ruff_python_ast::{PySourceType, SourceType};
-use ruff_python_formatter::{format_module, FormatModuleError, PyFormatOptions};
-use ruff_source_file::{find_newline, LineEnding};
+use ruff_python_formatter::{format_module_source, FormatModuleError};
 use ruff_workspace::resolver::python_files_in_path;
+use ruff_workspace::FormatterSettings;
 
 use crate::args::{CliOverrides, FormatArguments};
 use crate::panic::{catch_unwind, PanicError};
@@ -73,15 +73,17 @@ pub(crate) fn format(
                     };
 
                     let resolved_settings = resolver.resolve(path, &pyproject_config);
-                    let options = resolved_settings.formatter.to_format_options(source_type);
-                    debug!("Formatting {} with {:?}", path.display(), options);
 
-                    Some(match catch_unwind(|| format_path(path, options, mode)) {
-                        Ok(inner) => inner,
-                        Err(error) => {
-                            Err(FormatCommandError::Panic(Some(path.to_path_buf()), error))
-                        }
-                    })
+                    Some(
+                        match catch_unwind(|| {
+                            format_path(path, &resolved_settings.formatter, source_type, mode)
+                        }) {
+                            Ok(inner) => inner,
+                            Err(error) => {
+                                Err(FormatCommandError::Panic(Some(path.to_path_buf()), error))
+                            }
+                        },
+                    )
                 }
                 Err(err) => Some(Err(FormatCommandError::Ignore(err))),
             }
@@ -139,21 +141,17 @@ pub(crate) fn format(
 #[tracing::instrument(skip_all, fields(path = %path.display()))]
 fn format_path(
     path: &Path,
-    options: PyFormatOptions,
+    settings: &FormatterSettings,
+    source_type: PySourceType,
     mode: FormatMode,
 ) -> Result<FormatCommandResult, FormatCommandError> {
     let unformatted = std::fs::read_to_string(path)
         .map_err(|err| FormatCommandError::Read(Some(path.to_path_buf()), err))?;
 
-    let line_ending = match find_newline(&unformatted) {
-        Some((_, LineEnding::Lf)) | None => ruff_formatter::printer::LineEnding::LineFeed,
-        Some((_, LineEnding::Cr)) => ruff_formatter::printer::LineEnding::CarriageReturn,
-        Some((_, LineEnding::CrLf)) => ruff_formatter::printer::LineEnding::CarriageReturnLineFeed,
-    };
-
-    let options = options.with_line_ending(line_ending);
+    let options = settings.to_format_options(source_type, &unformatted);
+    debug!("Formatting {} with {:?}", path.display(), options);
 
-    let formatted = format_module(&unformatted, options)
+    let formatted = format_module_source(&unformatted, options)
         .map_err(|err| FormatCommandError::FormatModule(Some(path.to_path_buf()), err))?;
 
     let formatted = formatted.as_code();

crates/ruff_cli/src/commands/format_stdin.rs

@@ -5,8 +5,9 @@ use anyhow::Result;
 use log::warn;
 
 use ruff_python_ast::PySourceType;
-use ruff_python_formatter::{format_module, PyFormatOptions};
+use ruff_python_formatter::format_module_source;
 use ruff_workspace::resolver::python_file_at_path;
+use ruff_workspace::FormatterSettings;
 
 use crate::args::{CliOverrides, FormatArguments};
 use crate::commands::format::{FormatCommandError, FormatCommandResult, FormatMode};
@@ -37,12 +38,7 @@ pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> R
     // Format the file.
     let path = cli.stdin_filename.as_deref();
 
-    let options = pyproject_config
-        .settings
-        .formatter
-        .to_format_options(path.map(PySourceType::from).unwrap_or_default());
-
-    match format_source(path, options, mode) {
+    match format_source(path, &pyproject_config.settings.formatter, mode) {
         Ok(result) => match mode {
             FormatMode::Write => Ok(ExitStatus::Success),
             FormatMode::Check => {
@@ -63,12 +59,18 @@ pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> R
 /// Format source code read from `stdin`.
 fn format_source(
     path: Option<&Path>,
-    options: PyFormatOptions,
+    settings: &FormatterSettings,
     mode: FormatMode,
 ) -> Result<FormatCommandResult, FormatCommandError> {
     let unformatted = read_from_stdin()
         .map_err(|err| FormatCommandError::Read(path.map(Path::to_path_buf), err))?;
-    let formatted = format_module(&unformatted, options)
+
+    let options = settings.to_format_options(
+        path.map(PySourceType::from).unwrap_or_default(),
+        &unformatted,
+    );
+
+    let formatted = format_module_source(&unformatted, options)
         .map_err(|err| FormatCommandError::FormatModule(path.map(Path::to_path_buf), err))?;
     let formatted = formatted.as_code();
 

crates/ruff_cli/src/diagnostics.rs

@@ -254,10 +254,9 @@ pub(crate) fn lint_path(
                                 // mutated it.
                                 let src_notebook = source_kind.as_ipy_notebook().unwrap();
                                 let mut stdout = io::stdout().lock();
-                                for ((idx, src_cell), dest_cell) in src_notebook
-                                    .cells()
-                                    .iter()
-                                    .enumerate()
+                                // Cell indices are 1-based.
+                                for ((idx, src_cell), dest_cell) in (1u32..)
+                                    .zip(src_notebook.cells().iter())
                                     .zip(dest_notebook.cells().iter())
                                 {
                                     let (Cell::Code(src_code_cell), Cell::Code(dest_code_cell)) =