Split off ruff_cli crate from ruff library

This lets you test the ruff linters or use the ruff library
without having to compile the ~100 additional dependencies
that are needed by the CLI.

Because we set the following in the [workspace] section of Cargo.toml:

   default-members = [".", "ruff_cli"]

`cargo run` still runs the CLI and `cargo test` still tests
the code in src/ as well as the code in the new ruff_cli crate.
(But you can now also run `cargo test -p ruff` to only test the linters.)

ruff_cli/Cargo.toml

@@ -0,0 +1,62 @@
+[package]
+name = "ruff_cli"
+version = "0.0.220"
+authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
+edition = "2021"
+rust-version = "1.65.0"
+documentation = "https://github.com/charliermarsh/ruff"
+homepage = "https://github.com/charliermarsh/ruff"
+repository = "https://github.com/charliermarsh/ruff"
+readme = "../README.md"
+license = "MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[[bin]]
+name = "ruff"
+path = "src/main.rs"
+doctest = false
+
+[dependencies]
+ruff = { path = ".." }
+
+annotate-snippets = { version = "0.9.1", features = ["color"] }
+anyhow = { version = "1.0.66" }
+atty = { version = "0.2.14" }
+bincode = { version = "1.3.3" }
+cachedir = { version = "0.3.0" }
+chrono = { version = "0.4.21", default-features = false, features = ["clock"] }
+clap = { version = "4.0.1", features = ["derive", "env"] }
+clap_complete_command = { version = "0.4.0" }
+clearscreen = { version = "2.0.0" }
+colored = { version = "2.0.0" }
+filetime = { version = "0.2.17" }
+glob = { version = "0.3.0" }
+ignore = { version = "0.4.18" }
+itertools = { version = "0.10.5" }
+log = { version = "0.4.17" }
+notify = { version = "5.0.0" }
+path-absolutize = { version = "3.0.14", features = ["once_cell_cache"] }
+quick-junit = { version = "0.3.2" }
+rayon = { version = "1.5.3" }
+regex = { version = "1.6.0" }
+rustc-hash = { version = "1.1.0" }
+serde = { version = "1.0.147", features = ["derive"] }
+serde_json = { version = "1.0.87" }
+similar = { version = "2.2.1" }
+textwrap = { version = "0.16.0" }
+update-informer = { version = "0.6.0", default-features = false, features = ["pypi"], optional = true }
+walkdir = { version = "2.3.2" }
+
+[dev-dependencies]
+assert_cmd = { version = "2.0.4" }
+strum = { version = "0.24.1" }
+ureq = { version = "2.5.0", features = [] }
+
+[features]
+default = ["update-informer"]
+update-informer = ["dep:update-informer"]
+
+[package.metadata.maturin]
+name = "ruff"
+# Setting the name here is necessary for maturin to include the package in its builds.

ruff_cli/src/cache.rs

@@ -0,0 +1,124 @@
+use std::collections::hash_map::DefaultHasher;
+use std::fs;
+use std::hash::{Hash, Hasher};
+use std::io::Write;
+use std::path::Path;
+
+use anyhow::Result;
+use filetime::FileTime;
+use log::error;
+use path_absolutize::Absolutize;
+use ruff::message::Message;
+use ruff::settings::{flags, Settings};
+use serde::{Deserialize, Serialize};
+
+const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[derive(Serialize, Deserialize)]
+struct CacheMetadata {
+    mtime: i64,
+}
+
+#[derive(Serialize)]
+struct CheckResultRef<'a> {
+    metadata: &'a CacheMetadata,
+    messages: &'a [Message],
+}
+
+#[derive(Deserialize)]
+struct CheckResult {
+    metadata: CacheMetadata,
+    messages: Vec<Message>,
+}
+
+fn content_dir() -> &'static Path {
+    Path::new("content")
+}
+
+fn cache_key<P: AsRef<Path>>(path: P, settings: &Settings, autofix: flags::Autofix) -> u64 {
+    let mut hasher = DefaultHasher::new();
+    CARGO_PKG_VERSION.hash(&mut hasher);
+    path.as_ref().absolutize().unwrap().hash(&mut hasher);
+    settings.hash(&mut hasher);
+    autofix.hash(&mut hasher);
+    hasher.finish()
+}
+
+#[allow(dead_code)]
+/// Initialize the cache at the specified `Path`.
+pub fn init(path: &Path) -> Result<()> {
+    // Create the cache directories.
+    fs::create_dir_all(path.join(content_dir()))?;
+
+    // Add the CACHEDIR.TAG.
+    if !cachedir::is_tagged(path)? {
+        cachedir::add_tag(path)?;
+    }
+
+    // Add the .gitignore.
+    let gitignore_path = path.join(".gitignore");
+    if !gitignore_path.exists() {
+        let mut file = fs::File::create(gitignore_path)?;
+        file.write_all(b"*")?;
+    }
+
+    Ok(())
+}
+
+fn write_sync(cache_dir: &Path, key: u64, value: &[u8]) -> Result<(), std::io::Error> {
+    fs::write(
+        cache_dir.join(content_dir()).join(format!("{key:x}")),
+        value,
+    )
+}
+
+fn read_sync(cache_dir: &Path, key: u64) -> Result<Vec<u8>, std::io::Error> {
+    fs::read(cache_dir.join(content_dir()).join(format!("{key:x}")))
+}
+
+/// Get a value from the cache.
+pub fn get<P: AsRef<Path>>(
+    path: P,
+    metadata: &fs::Metadata,
+    settings: &Settings,
+    autofix: flags::Autofix,
+) -> Option<Vec<Message>> {
+    let encoded = read_sync(&settings.cache_dir, cache_key(path, settings, autofix)).ok()?;
+    let (mtime, messages) = match bincode::deserialize::<CheckResult>(&encoded[..]) {
+        Ok(CheckResult {
+            metadata: CacheMetadata { mtime },
+            messages,
+        }) => (mtime, messages),
+        Err(e) => {
+            error!("Failed to deserialize encoded cache entry: {e:?}");
+            return None;
+        }
+    };
+    if FileTime::from_last_modification_time(metadata).unix_seconds() != mtime {
+        return None;
+    }
+    Some(messages)
+}
+
+/// Set a value in the cache.
+pub fn set<P: AsRef<Path>>(
+    path: P,
+    metadata: &fs::Metadata,
+    settings: &Settings,
+    autofix: flags::Autofix,
+    messages: &[Message],
+) {
+    let check_result = CheckResultRef {
+        metadata: &CacheMetadata {
+            mtime: FileTime::from_last_modification_time(metadata).unix_seconds(),
+        },
+        messages,
+    };
+    if let Err(e) = write_sync(
+        &settings.cache_dir,
+        cache_key(path, settings, autofix),
+        &bincode::serialize(&check_result).unwrap(),
+    ) {
+        error!("Failed to write to cache: {e:?}");
+    }
+}

ruff_cli/src/cli.rs

@@ -0,0 +1,461 @@
+use std::path::{Path, PathBuf};
+
+use clap::{command, Parser};
+use regex::Regex;
+use ruff::logging::LogLevel;
+use ruff::registry::{RuleCode, RuleCodePrefix};
+use ruff::resolver::ConfigProcessor;
+use ruff::settings::types::{
+    FilePattern, PatternPrefixPair, PerFileIgnore, PythonVersion, SerializationFormat,
+};
+use ruff::{fs, mccabe};
+use rustc_hash::FxHashMap;
+
+#[derive(Debug, Parser)]
+#[command(
+    author,
+    name = "ruff",
+    about = "Ruff: An extremely fast Python linter."
+)]
+#[command(version)]
+#[allow(clippy::struct_excessive_bools)]
+pub struct Cli {
+    #[arg(required_unless_present_any = ["clean", "explain", "generate_shell_completion"])]
+    pub files: Vec<PathBuf>,
+    /// Path to the `pyproject.toml` or `ruff.toml` file to use for
+    /// configuration.
+    #[arg(long, conflicts_with = "isolated")]
+    pub config: Option<PathBuf>,
+    /// Enable verbose logging.
+    #[arg(short, long, group = "verbosity")]
+    pub verbose: bool,
+    /// Print lint violations, but nothing else.
+    #[arg(short, long, group = "verbosity")]
+    pub quiet: bool,
+    /// Disable all logging (but still exit with status code "1" upon detecting
+    /// lint violations).
+    #[arg(short, long, group = "verbosity")]
+    pub silent: bool,
+    /// Exit with status code "0", even upon detecting lint violations.
+    #[arg(short, long)]
+    pub exit_zero: bool,
+    /// Run in watch mode by re-running whenever files change.
+    #[arg(short, long)]
+    pub watch: bool,
+    /// Attempt to automatically fix lint violations.
+    #[arg(long, overrides_with("no_fix"))]
+    fix: bool,
+    #[clap(long, overrides_with("fix"), hide = true)]
+    no_fix: bool,
+    /// Fix any fixable lint violations, but don't report on leftover
+    /// violations. Implies `--fix`.
+    #[arg(long, overrides_with("no_fix_only"))]
+    fix_only: bool,
+    #[clap(long, overrides_with("fix_only"), hide = true)]
+    no_fix_only: bool,
+    /// Avoid writing any fixed files back; instead, output a diff for each
+    /// changed file to stdout.
+    #[arg(long)]
+    pub diff: bool,
+    /// Disable cache reads.
+    #[arg(short, long)]
+    pub no_cache: bool,
+    /// Ignore all configuration files.
+    #[arg(long, conflicts_with = "config")]
+    pub isolated: bool,
+    /// Comma-separated list of rule codes to enable (or ALL, to enable all
+    /// rules).
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub select: Option<Vec<RuleCodePrefix>>,
+    /// Like --select, but adds additional rule codes on top of the selected
+    /// ones.
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub extend_select: Option<Vec<RuleCodePrefix>>,
+    /// Comma-separated list of rule codes to disable.
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub ignore: Option<Vec<RuleCodePrefix>>,
+    /// Like --ignore, but adds additional rule codes on top of the ignored
+    /// ones.
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub extend_ignore: Option<Vec<RuleCodePrefix>>,
+    /// List of paths, used to omit files and/or directories from analysis.
+    #[arg(long, value_delimiter = ',', value_name = "FILE_PATTERN")]
+    pub exclude: Option<Vec<FilePattern>>,
+    /// Like --exclude, but adds additional files and directories on top of
+    /// those already excluded.
+    #[arg(long, value_delimiter = ',', value_name = "FILE_PATTERN")]
+    pub extend_exclude: Option<Vec<FilePattern>>,
+    /// List of rule codes to treat as eligible for autofix. Only applicable
+    /// when autofix itself is enabled (e.g., via `--fix`).
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub fixable: Option<Vec<RuleCodePrefix>>,
+    /// List of rule codes to treat as ineligible for autofix. Only applicable
+    /// when autofix itself is enabled (e.g., via `--fix`).
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
+    pub unfixable: Option<Vec<RuleCodePrefix>>,
+    /// List of mappings from file pattern to code to exclude
+    #[arg(long, value_delimiter = ',')]
+    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    /// Output serialization format for violations.
+    #[arg(long, value_enum, env = "RUFF_FORMAT")]
+    pub format: Option<SerializationFormat>,
+    /// The name of the file when passing it through stdin.
+    #[arg(long)]
+    pub stdin_filename: Option<PathBuf>,
+    /// Path to the cache directory.
+    #[arg(long, env = "RUFF_CACHE_DIR")]
+    pub cache_dir: Option<PathBuf>,
+    /// Show violations with source code.
+    #[arg(long, overrides_with("no_show_source"))]
+    show_source: bool,
+    #[clap(long, overrides_with("show_source"), hide = true)]
+    no_show_source: bool,
+    /// Respect file exclusions via `.gitignore` and other standard ignore
+    /// files.
+    #[arg(long, overrides_with("no_respect_gitignore"))]
+    respect_gitignore: bool,
+    #[clap(long, overrides_with("respect_gitignore"), hide = true)]
+    no_respect_gitignore: bool,
+    /// Enforce exclusions, even for paths passed to Ruff directly on the
+    /// command-line.
+    #[arg(long, overrides_with("no_force_exclude"))]
+    force_exclude: bool,
+    #[clap(long, overrides_with("force_exclude"), hide = true)]
+    no_force_exclude: bool,
+    /// Enable or disable automatic update checks.
+    #[arg(long, overrides_with("no_update_check"))]
+    update_check: bool,
+    #[clap(long, overrides_with("update_check"), hide = true)]
+    no_update_check: bool,
+    /// Regular expression matching the name of dummy variables.
+    #[arg(long)]
+    pub dummy_variable_rgx: Option<Regex>,
+    /// The minimum Python version that should be supported.
+    #[arg(long)]
+    pub target_version: Option<PythonVersion>,
+    /// Set the line-length for length-associated rules and automatic
+    /// formatting.
+    #[arg(long)]
+    pub line_length: Option<usize>,
+    /// Maximum McCabe complexity allowed for a given function.
+    #[arg(long)]
+    pub max_complexity: Option<usize>,
+    /// Enable automatic additions of `noqa` directives to failing lines.
+    #[arg(
+        long,
+        // conflicts_with = "add_noqa",
+        conflicts_with = "clean",
+        conflicts_with = "explain",
+        conflicts_with = "generate_shell_completion",
+        conflicts_with = "show_files",
+        conflicts_with = "show_settings",
+        // Unsupported default-command arguments.
+        conflicts_with = "stdin_filename",
+        conflicts_with = "watch",
+    )]
+    pub add_noqa: bool,
+    /// Clear any caches in the current directory or any subdirectories.
+    #[arg(
+        long,
+        // Fake subcommands.
+        conflicts_with = "add_noqa",
+        // conflicts_with = "clean",
+        conflicts_with = "explain",
+        conflicts_with = "generate_shell_completion",
+        conflicts_with = "show_files",
+        conflicts_with = "show_settings",
+        // Unsupported default-command arguments.
+        conflicts_with = "stdin_filename",
+        conflicts_with = "watch",
+    )]
+    pub clean: bool,
+    /// Explain a rule.
+    #[arg(
+        long,
+        // Fake subcommands.
+        conflicts_with = "add_noqa",
+        conflicts_with = "clean",
+        // conflicts_with = "explain",
+        conflicts_with = "generate_shell_completion",
+        conflicts_with = "show_files",
+        conflicts_with = "show_settings",
+        // Unsupported default-command arguments.
+        conflicts_with = "stdin_filename",
+        conflicts_with = "watch",
+    )]
+    pub explain: Option<RuleCode>,
+    /// Generate shell completion
+    #[arg(
+        long,
+        hide = true,
+        value_name = "SHELL",
+        // Fake subcommands.
+        conflicts_with = "add_noqa",
+        conflicts_with = "clean",
+        conflicts_with = "explain",
+        // conflicts_with = "generate_shell_completion",
+        conflicts_with = "show_files",
+        conflicts_with = "show_settings",
+        // Unsupported default-command arguments.
+        conflicts_with = "stdin_filename",
+        conflicts_with = "watch",
+    )]
+    pub generate_shell_completion: Option<clap_complete_command::Shell>,
+    /// See the files Ruff will be run against with the current settings.
+    #[arg(
+        long,
+        // Fake subcommands.
+        conflicts_with = "add_noqa",
+        conflicts_with = "clean",
+        conflicts_with = "explain",
+        conflicts_with = "generate_shell_completion",
+        // conflicts_with = "show_files",
+        conflicts_with = "show_settings",
+        // Unsupported default-command arguments.
+        conflicts_with = "stdin_filename",
+        conflicts_with = "watch",
+    )]
+    pub show_files: bool,
+    /// See the settings Ruff will use to lint a given Python file.
+    #[arg(
+        long,
+        // Fake subcommands.
+        conflicts_with = "add_noqa",
+        conflicts_with = "clean",
+        conflicts_with = "explain",
+        conflicts_with = "generate_shell_completion",
+        conflicts_with = "show_files",
+        // conflicts_with = "show_settings",
+        // Unsupported default-command arguments.
+        conflicts_with = "stdin_filename",
+        conflicts_with = "watch",
+    )]
+    pub show_settings: bool,
+}
+
+impl Cli {
+    /// Partition the CLI into command-line arguments and configuration
+    /// overrides.
+    pub fn partition(self) -> (Arguments, Overrides) {
+        (
+            Arguments {
+                add_noqa: self.add_noqa,
+                clean: self.clean,
+                config: self.config,
+                diff: self.diff,
+                exit_zero: self.exit_zero,
+                explain: self.explain,
+                files: self.files,
+                generate_shell_completion: self.generate_shell_completion,
+                isolated: self.isolated,
+                no_cache: self.no_cache,
+                quiet: self.quiet,
+                show_files: self.show_files,
+                show_settings: self.show_settings,
+                silent: self.silent,
+                stdin_filename: self.stdin_filename,
+                verbose: self.verbose,
+                watch: self.watch,
+            },
+            Overrides {
+                dummy_variable_rgx: self.dummy_variable_rgx,
+                exclude: self.exclude,
+                extend_exclude: self.extend_exclude,
+                extend_ignore: self.extend_ignore,
+                extend_select: self.extend_select,
+                fixable: self.fixable,
+                ignore: self.ignore,
+                line_length: self.line_length,
+                max_complexity: self.max_complexity,
+                per_file_ignores: self.per_file_ignores,
+                respect_gitignore: resolve_bool_arg(
+                    self.respect_gitignore,
+                    self.no_respect_gitignore,
+                ),
+                select: self.select,
+                show_source: resolve_bool_arg(self.show_source, self.no_show_source),
+                target_version: self.target_version,
+                unfixable: self.unfixable,
+                // TODO(charlie): Included in `pyproject.toml`, but not inherited.
+                cache_dir: self.cache_dir,
+                fix: resolve_bool_arg(self.fix, self.no_fix),
+                fix_only: resolve_bool_arg(self.fix_only, self.no_fix_only),
+                force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
+                format: self.format,
+                update_check: resolve_bool_arg(self.update_check, self.no_update_check),
+            },
+        )
+    }
+}
+
+fn resolve_bool_arg(yes: bool, no: bool) -> Option<bool> {
+    match (yes, no) {
+        (true, false) => Some(true),
+        (false, true) => Some(false),
+        (false, false) => None,
+        (..) => unreachable!("Clap should make this impossible"),
+    }
+}
+
+/// CLI settings that are distinct from configuration (commands, lists of files,
+/// etc.).
+#[allow(clippy::struct_excessive_bools)]
+pub struct Arguments {
+    pub add_noqa: bool,
+    pub clean: bool,
+    pub config: Option<PathBuf>,
+    pub diff: bool,
+    pub exit_zero: bool,
+    pub explain: Option<RuleCode>,
+    pub files: Vec<PathBuf>,
+    pub generate_shell_completion: Option<clap_complete_command::Shell>,
+    pub isolated: bool,
+    pub no_cache: bool,
+    pub quiet: bool,
+    pub show_files: bool,
+    pub show_settings: bool,
+    pub silent: bool,
+    pub stdin_filename: Option<PathBuf>,
+    pub verbose: bool,
+    pub watch: bool,
+}
+
+/// CLI settings that function as configuration overrides.
+#[derive(Clone)]
+#[allow(clippy::struct_excessive_bools)]
+pub struct Overrides {
+    pub dummy_variable_rgx: Option<Regex>,
+    pub exclude: Option<Vec<FilePattern>>,
+    pub extend_exclude: Option<Vec<FilePattern>>,
+    pub extend_ignore: Option<Vec<RuleCodePrefix>>,
+    pub extend_select: Option<Vec<RuleCodePrefix>>,
+    pub fixable: Option<Vec<RuleCodePrefix>>,
+    pub ignore: Option<Vec<RuleCodePrefix>>,
+    pub line_length: Option<usize>,
+    pub max_complexity: Option<usize>,
+    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    pub respect_gitignore: Option<bool>,
+    pub select: Option<Vec<RuleCodePrefix>>,
+    pub show_source: Option<bool>,
+    pub target_version: Option<PythonVersion>,
+    pub unfixable: Option<Vec<RuleCodePrefix>>,
+    // TODO(charlie): Captured in pyproject.toml as a default, but not part of `Settings`.
+    pub cache_dir: Option<PathBuf>,
+    pub fix: Option<bool>,
+    pub fix_only: Option<bool>,
+    pub force_exclude: Option<bool>,
+    pub format: Option<SerializationFormat>,
+    pub update_check: Option<bool>,
+}
+
+impl ConfigProcessor for &Overrides {
+    fn process_config(&self, config: &mut ruff::settings::configuration::Configuration) {
+        if let Some(cache_dir) = &self.cache_dir {
+            config.cache_dir = Some(cache_dir.clone());
+        }
+        if let Some(dummy_variable_rgx) = &self.dummy_variable_rgx {
+            config.dummy_variable_rgx = Some(dummy_variable_rgx.clone());
+        }
+        if let Some(exclude) = &self.exclude {
+            config.exclude = Some(exclude.clone());
+        }
+        if let Some(extend_exclude) = &self.extend_exclude {
+            config.extend_exclude.extend(extend_exclude.clone());
+        }
+        if let Some(fix) = &self.fix {
+            config.fix = Some(*fix);
+        }
+        if let Some(fix_only) = &self.fix_only {
+            config.fix_only = Some(*fix_only);
+        }
+        if let Some(fixable) = &self.fixable {
+            config.fixable = Some(fixable.clone());
+        }
+        if let Some(format) = &self.format {
+            config.format = Some(*format);
+        }
+        if let Some(force_exclude) = &self.force_exclude {
+            config.force_exclude = Some(*force_exclude);
+        }
+        if let Some(ignore) = &self.ignore {
+            config.ignore = Some(ignore.clone());
+        }
+        if let Some(line_length) = &self.line_length {
+            config.line_length = Some(*line_length);
+        }
+        if let Some(max_complexity) = &self.max_complexity {
+            config.mccabe = Some(mccabe::settings::Options {
+                max_complexity: Some(*max_complexity),
+            });
+        }
+        if let Some(per_file_ignores) = &self.per_file_ignores {
+            config.per_file_ignores = Some(collect_per_file_ignores(per_file_ignores.clone()));
+        }
+        if let Some(respect_gitignore) = &self.respect_gitignore {
+            config.respect_gitignore = Some(*respect_gitignore);
+        }
+        if let Some(select) = &self.select {
+            config.select = Some(select.clone());
+        }
+        if let Some(show_source) = &self.show_source {
+            config.show_source = Some(*show_source);
+        }
+        if let Some(target_version) = &self.target_version {
+            config.target_version = Some(*target_version);
+        }
+        if let Some(unfixable) = &self.unfixable {
+            config.unfixable = Some(unfixable.clone());
+        }
+        if let Some(update_check) = &self.update_check {
+            config.update_check = Some(*update_check);
+        }
+        // Special-case: `extend_ignore` and `extend_select` are parallel arrays, so
+        // push an empty array if only one of the two is provided.
+        match (&self.extend_ignore, &self.extend_select) {
+            (Some(extend_ignore), Some(extend_select)) => {
+                config.extend_ignore.push(extend_ignore.clone());
+                config.extend_select.push(extend_select.clone());
+            }
+            (Some(extend_ignore), None) => {
+                config.extend_ignore.push(extend_ignore.clone());
+                config.extend_select.push(Vec::new());
+            }
+            (None, Some(extend_select)) => {
+                config.extend_ignore.push(Vec::new());
+                config.extend_select.push(extend_select.clone());
+            }
+            (None, None) => {}
+        }
+    }
+}
+
+/// Map the CLI settings to a `LogLevel`.
+pub fn extract_log_level(cli: &Arguments) -> LogLevel {
+    if cli.silent {
+        LogLevel::Silent
+    } else if cli.quiet {
+        LogLevel::Quiet
+    } else if cli.verbose {
+        LogLevel::Verbose
+    } else {
+        LogLevel::Default
+    }
+}
+
+/// Convert a list of `PatternPrefixPair` structs to `PerFileIgnore`.
+pub fn collect_per_file_ignores(pairs: Vec<PatternPrefixPair>) -> Vec<PerFileIgnore> {
+    let mut per_file_ignores: FxHashMap<String, Vec<RuleCodePrefix>> = FxHashMap::default();
+    for pair in pairs {
+        per_file_ignores
+            .entry(pair.pattern)
+            .or_insert_with(Vec::new)
+            .push(pair.prefix);
+    }
+    per_file_ignores
+        .into_iter()
+        .map(|(pattern, prefixes)| {
+            let absolute = fs::normalize_path(Path::new(&pattern));
+            PerFileIgnore::new(pattern, absolute, &prefixes)
+        })
+        .collect()
+}

ruff_cli/src/commands.rs

@@ -0,0 +1,340 @@
+use std::fs::remove_dir_all;
+use std::io::{self, Read};
+use std::path::{Path, PathBuf};
+use std::time::Instant;
+
+use anyhow::{bail, Result};
+use colored::Colorize;
+use ignore::Error;
+use itertools::Itertools;
+use log::{debug, error};
+use path_absolutize::path_dedot;
+#[cfg(not(target_family = "wasm"))]
+use rayon::prelude::*;
+use ruff::cache::CACHE_DIR_NAME;
+use ruff::linter::add_noqa_to_path;
+use ruff::logging::LogLevel;
+use ruff::message::{Location, Message};
+use ruff::registry::RuleCode;
+use ruff::resolver::{FileDiscovery, PyprojectDiscovery};
+use ruff::settings::flags;
+use ruff::settings::types::SerializationFormat;
+use ruff::{fix, fs, packaging, resolver, violations};
+use serde::Serialize;
+use walkdir::WalkDir;
+
+use crate::cli::Overrides;
+use crate::diagnostics::{lint_path, lint_stdin, Diagnostics};
+use crate::iterators::par_iter;
+use crate::{cache, warn_user_once};
+
+/// Run the linter over a collection of files.
+pub fn run(
+    files: &[PathBuf],
+    pyproject_strategy: &PyprojectDiscovery,
+    file_strategy: &FileDiscovery,
+    overrides: &Overrides,
+    cache: flags::Cache,
+    autofix: fix::FixMode,
+) -> Result<Diagnostics> {
+    // Collect all the Python files to check.
+    let start = Instant::now();
+    let (paths, resolver) =
+        resolver::python_files_in_path(files, pyproject_strategy, file_strategy, overrides)?;
+    let duration = start.elapsed();
+    debug!("Identified files to lint in: {:?}", duration);
+
+    if paths.is_empty() {
+        warn_user_once!("No Python files found under the given path(s)");
+        return Ok(Diagnostics::default());
+    }
+
+    // Validate the `Settings` and return any errors.
+    resolver.validate(pyproject_strategy)?;
+
+    // Initialize the cache.
+    if matches!(cache, flags::Cache::Enabled) {
+        match &pyproject_strategy {
+            PyprojectDiscovery::Fixed(settings) => {
+                if let Err(e) = cache::init(&settings.cache_dir) {
+                    error!(
+                        "Failed to initialize cache at {}: {e:?}",
+                        settings.cache_dir.to_string_lossy()
+                    );
+                }
+            }
+            PyprojectDiscovery::Hierarchical(default) => {
+                for settings in std::iter::once(default).chain(resolver.iter()) {
+                    if let Err(e) = cache::init(&settings.cache_dir) {
+                        error!(
+                            "Failed to initialize cache at {}: {e:?}",
+                            settings.cache_dir.to_string_lossy()
+                        );
+                    }
+                }
+            }
+        }
+    };
+
+    // Discover the package root for each Python file.
+    let package_roots = packaging::detect_package_roots(
+        &paths
+            .iter()
+            .flatten()
+            .map(ignore::DirEntry::path)
+            .collect::<Vec<_>>(),
+    );
+
+    let start = Instant::now();
+    let mut diagnostics: Diagnostics = par_iter(&paths)
+        .map(|entry| {
+            match entry {
+                Ok(entry) => {
+                    let path = entry.path();
+                    let package = path
+                        .parent()
+                        .and_then(|parent| package_roots.get(parent))
+                        .and_then(|package| *package);
+                    let settings = resolver.resolve(path, pyproject_strategy);
+                    lint_path(path, package, settings, cache, autofix)
+                        .map_err(|e| (Some(path.to_owned()), e.to_string()))
+                }
+                Err(e) => Err((
+                    if let Error::WithPath { path, .. } = e {
+                        Some(path.clone())
+                    } else {
+                        None
+                    },
+                    e.io_error()
+                        .map_or_else(|| e.to_string(), io::Error::to_string),
+                )),
+            }
+            .unwrap_or_else(|(path, message)| {
+                if let Some(path) = &path {
+                    let settings = resolver.resolve(path, pyproject_strategy);
+                    if settings.enabled.contains(&RuleCode::E902) {
+                        Diagnostics::new(vec![Message {
+                            kind: violations::IOError(message).into(),
+                            location: Location::default(),
+                            end_location: Location::default(),
+                            fix: None,
+                            filename: path.to_string_lossy().to_string(),
+                            source: None,
+                        }])
+                    } else {
+                        error!("Failed to check {}: {message}", path.to_string_lossy());
+                        Diagnostics::default()
+                    }
+                } else {
+                    error!("{message}");
+                    Diagnostics::default()
+                }
+            })
+        })
+        .reduce(Diagnostics::default, |mut acc, item| {
+            acc += item;
+            acc
+        });
+
+    diagnostics.messages.sort_unstable();
+    let duration = start.elapsed();
+    debug!("Checked files in: {:?}", duration);
+
+    Ok(diagnostics)
+}
+
+/// Read a `String` from `stdin`.
+fn read_from_stdin() -> Result<String> {
+    let mut buffer = String::new();
+    io::stdin().lock().read_to_string(&mut buffer)?;
+    Ok(buffer)
+}
+
+/// Run the linter over a single file, read from `stdin`.
+pub fn run_stdin(
+    filename: Option<&Path>,
+    pyproject_strategy: &PyprojectDiscovery,
+    file_strategy: &FileDiscovery,
+    overrides: &Overrides,
+    autofix: fix::FixMode,
+) -> Result<Diagnostics> {
+    if let Some(filename) = filename {
+        if !resolver::python_file_at_path(filename, pyproject_strategy, file_strategy, overrides)? {
+            return Ok(Diagnostics::default());
+        }
+    }
+    let settings = match pyproject_strategy {
+        PyprojectDiscovery::Fixed(settings) => settings,
+        PyprojectDiscovery::Hierarchical(settings) => settings,
+    };
+    let package_root = filename
+        .and_then(Path::parent)
+        .and_then(packaging::detect_package_root);
+    let stdin = read_from_stdin()?;
+    let mut diagnostics = lint_stdin(filename, package_root, &stdin, settings, autofix)?;
+    diagnostics.messages.sort_unstable();
+    Ok(diagnostics)
+}
+
+/// Add `noqa` directives to a collection of files.
+pub fn add_noqa(
+    files: &[PathBuf],
+    pyproject_strategy: &PyprojectDiscovery,
+    file_strategy: &FileDiscovery,
+    overrides: &Overrides,
+) -> Result<usize> {
+    // Collect all the files to check.
+    let start = Instant::now();
+    let (paths, resolver) =
+        resolver::python_files_in_path(files, pyproject_strategy, file_strategy, overrides)?;
+    let duration = start.elapsed();
+    debug!("Identified files to lint in: {:?}", duration);
+
+    if paths.is_empty() {
+        warn_user_once!("No Python files found under the given path(s)");
+        return Ok(0);
+    }
+
+    // Validate the `Settings` and return any errors.
+    resolver.validate(pyproject_strategy)?;
+
+    let start = Instant::now();
+    let modifications: usize = par_iter(&paths)
+        .flatten()
+        .filter_map(|entry| {
+            let path = entry.path();
+            let settings = resolver.resolve(path, pyproject_strategy);
+            match add_noqa_to_path(path, settings) {
+                Ok(count) => Some(count),
+                Err(e) => {
+                    error!("Failed to add noqa to {}: {e}", path.to_string_lossy());
+                    None
+                }
+            }
+        })
+        .sum();
+
+    let duration = start.elapsed();
+    debug!("Added noqa to files in: {:?}", duration);
+
+    Ok(modifications)
+}
+
+/// Print the user-facing configuration settings.
+pub fn show_settings(
+    files: &[PathBuf],
+    pyproject_strategy: &PyprojectDiscovery,
+    file_strategy: &FileDiscovery,
+    overrides: &Overrides,
+) -> Result<()> {
+    // Collect all files in the hierarchy.
+    let (paths, resolver) =
+        resolver::python_files_in_path(files, pyproject_strategy, file_strategy, overrides)?;
+
+    // Validate the `Settings` and return any errors.
+    resolver.validate(pyproject_strategy)?;
+
+    // Print the list of files.
+    let Some(entry) = paths
+        .iter()
+        .flatten()
+        .sorted_by(|a, b| a.path().cmp(b.path())).next() else {
+        bail!("No files found under the given path");
+    };
+    let path = entry.path();
+    let settings = resolver.resolve(path, pyproject_strategy);
+    println!("Resolved settings for: {path:?}");
+    println!("{settings:#?}");
+
+    Ok(())
+}
+
+/// Show the list of files to be checked based on current settings.
+pub fn show_files(
+    files: &[PathBuf],
+    pyproject_strategy: &PyprojectDiscovery,
+    file_strategy: &FileDiscovery,
+    overrides: &Overrides,
+) -> Result<()> {
+    // Collect all files in the hierarchy.
+    let (paths, resolver) =
+        resolver::python_files_in_path(files, pyproject_strategy, file_strategy, overrides)?;
+
+    if paths.is_empty() {
+        warn_user_once!("No Python files found under the given path(s)");
+        return Ok(());
+    }
+
+    // Validate the `Settings` and return any errors.
+    resolver.validate(pyproject_strategy)?;
+
+    // Print the list of files.
+    for entry in paths
+        .iter()
+        .flatten()
+        .sorted_by(|a, b| a.path().cmp(b.path()))
+    {
+        println!("{}", entry.path().to_string_lossy());
+    }
+
+    Ok(())
+}
+
+#[derive(Serialize)]
+struct Explanation<'a> {
+    code: &'a str,
+    origin: &'a str,
+    summary: &'a str,
+}
+
+/// Explain a `RuleCode` to the user.
+pub fn explain(code: &RuleCode, format: SerializationFormat) -> Result<()> {
+    match format {
+        SerializationFormat::Text | SerializationFormat::Grouped => {
+            println!(
+                "{} ({}): {}",
+                code.as_ref(),
+                code.origin().title(),
+                code.kind().summary()
+            );
+        }
+        SerializationFormat::Json => {
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&Explanation {
+                    code: code.as_ref(),
+                    origin: code.origin().title(),
+                    summary: &code.kind().summary(),
+                })?
+            );
+        }
+        SerializationFormat::Junit => {
+            bail!("`--explain` does not support junit format")
+        }
+        SerializationFormat::Github => {
+            bail!("`--explain` does not support GitHub format")
+        }
+        SerializationFormat::Gitlab => {
+            bail!("`--explain` does not support GitLab format")
+        }
+    };
+    Ok(())
+}
+
+/// Clear any caches in the current directory or any subdirectories.
+pub fn clean(level: &LogLevel) -> Result<()> {
+    for entry in WalkDir::new(&*path_dedot::CWD)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|entry| entry.file_type().is_dir())
+    {
+        let cache = entry.path().join(CACHE_DIR_NAME);
+        if cache.is_dir() {
+            if level >= &LogLevel::Default {
+                eprintln!("Removing cache at: {}", fs::relativize_path(&cache).bold());
+            }
+            remove_dir_all(&cache)?;
+        }
+    }
+    Ok(())
+}

ruff_cli/src/diagnostics.rs

@@ -0,0 +1,155 @@
+#![cfg_attr(target_family = "wasm", allow(dead_code))]
+use std::fs::write;
+use std::io;
+use std::io::Write;
+use std::ops::AddAssign;
+use std::path::Path;
+
+use anyhow::Result;
+use log::debug;
+use ruff::linter::{lint_fix, lint_only};
+use ruff::message::Message;
+use ruff::settings::{flags, Settings};
+use ruff::{fix, fs};
+use similar::TextDiff;
+
+use crate::cache;
+
+#[derive(Debug, Default)]
+pub struct Diagnostics {
+    pub messages: Vec<Message>,
+    pub fixed: usize,
+}
+
+impl Diagnostics {
+    pub fn new(messages: Vec<Message>) -> Self {
+        Self { messages, fixed: 0 }
+    }
+}
+
+impl AddAssign for Diagnostics {
+    fn add_assign(&mut self, other: Self) {
+        self.messages.extend(other.messages);
+        self.fixed += other.fixed;
+    }
+}
+
+/// Lint the source code at the given `Path`.
+pub fn lint_path(
+    path: &Path,
+    package: Option<&Path>,
+    settings: &Settings,
+    cache: flags::Cache,
+    autofix: fix::FixMode,
+) -> Result<Diagnostics> {
+    // Validate the `Settings` and return any errors.
+    settings.validate()?;
+
+    // Check the cache.
+    // TODO(charlie): `fixer::Mode::Apply` and `fixer::Mode::Diff` both have
+    // side-effects that aren't captured in the cache. (In practice, it's fine
+    // to cache `fixer::Mode::Apply`, since a file either has no fixes, or we'll
+    // write the fixes to disk, thus invalidating the cache. But it's a bit hard
+    // to reason about. We need to come up with a better solution here.)
+    let metadata = if matches!(cache, flags::Cache::Enabled)
+        && matches!(autofix, fix::FixMode::None | fix::FixMode::Generate)
+    {
+        let metadata = path.metadata()?;
+        if let Some(messages) = cache::get(path, &metadata, settings, autofix.into()) {
+            debug!("Cache hit for: {}", path.to_string_lossy());
+            return Ok(Diagnostics::new(messages));
+        }
+        Some(metadata)
+    } else {
+        None
+    };
+
+    // Read the file from disk.
+    let contents = fs::read_file(path)?;
+
+    // Lint the file.
+    let (messages, fixed) = if matches!(autofix, fix::FixMode::Apply | fix::FixMode::Diff) {
+        let (transformed, fixed, messages) = lint_fix(&contents, path, package, settings)?;
+        if fixed > 0 {
+            if matches!(autofix, fix::FixMode::Apply) {
+                write(path, transformed)?;
+            } else if matches!(autofix, fix::FixMode::Diff) {
+                let mut stdout = io::stdout().lock();
+                TextDiff::from_lines(&contents, &transformed)
+                    .unified_diff()
+                    .header(&fs::relativize_path(path), &fs::relativize_path(path))
+                    .to_writer(&mut stdout)?;
+                stdout.write_all(b"\n")?;
+                stdout.flush()?;
+            }
+        }
+        (messages, fixed)
+    } else {
+        let messages = lint_only(&contents, path, package, settings, autofix.into())?;
+        let fixed = 0;
+        (messages, fixed)
+    };
+
+    // Re-populate the cache.
+    if let Some(metadata) = metadata {
+        cache::set(path, &metadata, settings, autofix.into(), &messages);
+    }
+
+    Ok(Diagnostics { messages, fixed })
+}
+
+/// Generate `Diagnostic`s from source code content derived from
+/// stdin.
+pub fn lint_stdin(
+    path: Option<&Path>,
+    package: Option<&Path>,
+    contents: &str,
+    settings: &Settings,
+    autofix: fix::FixMode,
+) -> Result<Diagnostics> {
+    // Validate the `Settings` and return any errors.
+    settings.validate()?;
+
+    // Lint the inputs.
+    let (messages, fixed) = if matches!(autofix, fix::FixMode::Apply | fix::FixMode::Diff) {
+        let (transformed, fixed, messages) = lint_fix(
+            contents,
+            path.unwrap_or_else(|| Path::new("-")),
+            package,
+            settings,
+        )?;
+
+        if matches!(autofix, fix::FixMode::Apply) {
+            // Write the contents to stdout, regardless of whether any errors were fixed.
+            io::stdout().write_all(transformed.as_bytes())?;
+        } else if matches!(autofix, fix::FixMode::Diff) {
+            // But only write a diff if it's non-empty.
+            if fixed > 0 {
+                let text_diff = TextDiff::from_lines(contents, &transformed);
+                let mut unified_diff = text_diff.unified_diff();
+                if let Some(path) = path {
+                    unified_diff.header(&fs::relativize_path(path), &fs::relativize_path(path));
+                }
+
+                let mut stdout = io::stdout().lock();
+                unified_diff.to_writer(&mut stdout)?;
+                stdout.write_all(b"\n")?;
+                stdout.flush()?;
+            }
+        }
+
+        (messages, fixed)
+    } else {
+        let messages = lint_only(
+            contents,
+            path.unwrap_or_else(|| Path::new("-")),
+            package,
+            settings,
+            autofix.into(),
+        )?;
+        let fixed = 0;
+        (messages, fixed)
+    };
+
+    Ok(Diagnostics { messages, fixed })
+}

ruff_cli/src/iterators.rs

@@ -0,0 +1,16 @@
+#[cfg(not(target_family = "wasm"))]
+use rayon::prelude::*;
+
+/// Shim that calls `par_iter` except for wasm because there's no wasm support
+/// in rayon yet (there is a shim to be used for the web, but it requires js
+/// cooperation) Unfortunately, `ParallelIterator` does not implement `Iterator`
+/// so the signatures diverge
+#[cfg(not(target_family = "wasm"))]
+pub fn par_iter<T: Sync>(iterable: &[T]) -> impl ParallelIterator<Item = &T> {
+    iterable.par_iter()
+}
+
+#[cfg(target_family = "wasm")]
+pub fn par_iter<T: Sync>(iterable: &[T]) -> impl Iterator<Item = &T> {
+    iterable.iter()
+}

ruff_cli/src/lib.rs

@@ -0,0 +1,6 @@
+#![allow(clippy::must_use_candidate, dead_code)]
+
+mod cli;
+
+// used by ruff_dev::generate_cli_help
+pub use cli::Cli;

ruff_cli/src/main.rs

@@ -0,0 +1,309 @@
+#![allow(
+    clippy::match_same_arms,
+    clippy::missing_errors_doc,
+    clippy::module_name_repetitions,
+    clippy::too_many_lines
+)]
+#![forbid(unsafe_code)]
+
+use std::io::{self};
+use std::path::{Path, PathBuf};
+use std::process::ExitCode;
+use std::sync::mpsc::channel;
+
+use ::ruff::logging::{set_up_logging, LogLevel};
+use ::ruff::resolver::{
+    resolve_settings_with_processor, ConfigProcessor, FileDiscovery, PyprojectDiscovery, Relativity,
+};
+use ::ruff::settings::configuration::Configuration;
+use ::ruff::settings::types::SerializationFormat;
+use ::ruff::settings::{pyproject, Settings};
+#[cfg(feature = "update-informer")]
+use ::ruff::{fix, fs, warn_user_once};
+use anyhow::Result;
+use clap::{CommandFactory, Parser};
+use cli::{extract_log_level, Cli, Overrides};
+use colored::Colorize;
+use notify::{recommended_watcher, RecursiveMode, Watcher};
+use path_absolutize::path_dedot;
+use printer::{Printer, Violations};
+
+mod cache;
+mod cli;
+mod commands;
+mod diagnostics;
+mod iterators;
+mod printer;
+#[cfg(all(feature = "update-informer"))]
+pub mod updates;
+
+/// Resolve the relevant settings strategy and defaults for the current
+/// invocation.
+fn resolve(
+    isolated: bool,
+    config: Option<&Path>,
+    overrides: &Overrides,
+    stdin_filename: Option<&Path>,
+) -> Result<PyprojectDiscovery> {
+    if isolated {
+        // First priority: if we're running in isolated mode, use the default settings.
+        let mut config = Configuration::default();
+        overrides.process_config(&mut config);
+        let settings = Settings::from_configuration(config, &path_dedot::CWD)?;
+        Ok(PyprojectDiscovery::Fixed(settings))
+    } else if let Some(pyproject) = config {
+        // Second priority: the user specified a `pyproject.toml` file. Use that
+        // `pyproject.toml` for _all_ configuration, and resolve paths relative to the
+        // current working directory. (This matches ESLint's behavior.)
+        let settings = resolve_settings_with_processor(pyproject, &Relativity::Cwd, overrides)?;
+        Ok(PyprojectDiscovery::Fixed(settings))
+    } else if let Some(pyproject) = pyproject::find_settings_toml(
+        stdin_filename
+            .as_ref()
+            .unwrap_or(&path_dedot::CWD.as_path()),
+    )? {
+        // Third priority: find a `pyproject.toml` file in either an ancestor of
+        // `stdin_filename` (if set) or the current working path all paths relative to
+        // that directory. (With `Strategy::Hierarchical`, we'll end up finding
+        // the "closest" `pyproject.toml` file for every Python file later on,
+        // so these act as the "default" settings.)
+        let settings = resolve_settings_with_processor(&pyproject, &Relativity::Parent, overrides)?;
+        Ok(PyprojectDiscovery::Hierarchical(settings))
+    } else if let Some(pyproject) = pyproject::find_user_settings_toml() {
+        // Fourth priority: find a user-specific `pyproject.toml`, but resolve all paths
+        // relative the current working directory. (With `Strategy::Hierarchical`, we'll
+        // end up the "closest" `pyproject.toml` file for every Python file later on, so
+        // these act as the "default" settings.)
+        let settings = resolve_settings_with_processor(&pyproject, &Relativity::Cwd, overrides)?;
+        Ok(PyprojectDiscovery::Hierarchical(settings))
+    } else {
+        // Fallback: load Ruff's default settings, and resolve all paths relative to the
+        // current working directory. (With `Strategy::Hierarchical`, we'll end up the
+        // "closest" `pyproject.toml` file for every Python file later on, so these act
+        // as the "default" settings.)
+        let mut config = Configuration::default();
+        overrides.process_config(&mut config);
+        let settings = Settings::from_configuration(config, &path_dedot::CWD)?;
+        Ok(PyprojectDiscovery::Hierarchical(settings))
+    }
+}
+
+pub fn main() -> Result<ExitCode> {
+    // Extract command-line arguments.
+    let (cli, overrides) = Cli::parse().partition();
+    let log_level = extract_log_level(&cli);
+    set_up_logging(&log_level)?;
+
+    if let Some(shell) = cli.generate_shell_completion {
+        shell.generate(&mut Cli::command(), &mut io::stdout());
+        return Ok(ExitCode::SUCCESS);
+    }
+    if cli.clean {
+        commands::clean(&log_level)?;
+        return Ok(ExitCode::SUCCESS);
+    }
+
+    // Construct the "default" settings. These are used when no `pyproject.toml`
+    // files are present, or files are injected from outside of the hierarchy.
+    let pyproject_strategy = resolve(
+        cli.isolated,
+        cli.config.as_deref(),
+        &overrides,
+        cli.stdin_filename.as_deref(),
+    )?;
+
+    // Validate the `Settings` and return any errors.
+    match &pyproject_strategy {
+        PyprojectDiscovery::Fixed(settings) => settings.validate()?,
+        PyprojectDiscovery::Hierarchical(settings) => settings.validate()?,
+    };
+
+    // Extract options that are included in `Settings`, but only apply at the top
+    // level.
+    let file_strategy = FileDiscovery {
+        force_exclude: match &pyproject_strategy {
+            PyprojectDiscovery::Fixed(settings) => settings.force_exclude,
+            PyprojectDiscovery::Hierarchical(settings) => settings.force_exclude,
+        },
+        respect_gitignore: match &pyproject_strategy {
+            PyprojectDiscovery::Fixed(settings) => settings.respect_gitignore,
+            PyprojectDiscovery::Hierarchical(settings) => settings.respect_gitignore,
+        },
+    };
+    let (fix, fix_only, format, update_check) = match &pyproject_strategy {
+        PyprojectDiscovery::Fixed(settings) => (
+            settings.fix,
+            settings.fix_only,
+            settings.format,
+            settings.update_check,
+        ),
+        PyprojectDiscovery::Hierarchical(settings) => (
+            settings.fix,
+            settings.fix_only,
+            settings.format,
+            settings.update_check,
+        ),
+    };
+
+    if let Some(code) = cli.explain {
+        commands::explain(&code, format)?;
+        return Ok(ExitCode::SUCCESS);
+    }
+    if cli.show_settings {
+        commands::show_settings(&cli.files, &pyproject_strategy, &file_strategy, &overrides)?;
+        return Ok(ExitCode::SUCCESS);
+    }
+    if cli.show_files {
+        commands::show_files(&cli.files, &pyproject_strategy, &file_strategy, &overrides)?;
+        return Ok(ExitCode::SUCCESS);
+    }
+
+    // Autofix rules are as follows:
+    // - If `--fix` or `--fix-only` is set, always apply fixes to the filesystem (or
+    //   print them to stdout, if we're reading from stdin).
+    // - Otherwise, if `--format json` is set, generate the fixes (so we print them
+    //   out as part of the JSON payload), but don't write them to disk.
+    // - If `--diff` or `--fix-only` are set, don't print any violations (only
+    //   fixes).
+    // TODO(charlie): Consider adding ESLint's `--fix-dry-run`, which would generate
+    // but not apply fixes. That would allow us to avoid special-casing JSON
+    // here.
+    let autofix = if cli.diff {
+        fix::FixMode::Diff
+    } else if fix || fix_only {
+        fix::FixMode::Apply
+    } else if matches!(format, SerializationFormat::Json) {
+        fix::FixMode::Generate
+    } else {
+        fix::FixMode::None
+    };
+    let violations = if cli.diff || fix_only {
+        Violations::Hide
+    } else {
+        Violations::Show
+    };
+    let cache = !cli.no_cache;
+
+    #[cfg(debug_assertions)]
+    if cache {
+        // `--no-cache` doesn't respect code changes, and so is often confusing during
+        // development.
+        warn_user_once!("debug build without --no-cache.");
+    }
+
+    let printer = Printer::new(&format, &log_level, &autofix, &violations);
+    if cli.watch {
+        if !matches!(autofix, fix::FixMode::None) {
+            warn_user_once!("--fix is not enabled in watch mode.");
+        }
+        if format != SerializationFormat::Text {
+            warn_user_once!("--format 'text' is used in watch mode.");
+        }
+
+        // Perform an initial run instantly.
+        printer.clear_screen()?;
+        printer.write_to_user("Starting linter in watch mode...\n");
+
+        let messages = commands::run(
+            &cli.files,
+            &pyproject_strategy,
+            &file_strategy,
+            &overrides,
+            cache.into(),
+            fix::FixMode::None,
+        )?;
+        printer.write_continuously(&messages);
+
+        // Configure the file watcher.
+        let (tx, rx) = channel();
+        let mut watcher = recommended_watcher(tx)?;
+        for file in &cli.files {
+            watcher.watch(file, RecursiveMode::Recursive)?;
+        }
+
+        loop {
+            match rx.recv() {
+                Ok(event) => {
+                    let paths = event?.paths;
+                    let py_changed = paths.iter().any(|path| {
+                        path.extension()
+                            .map(|ext| ext == "py" || ext == "pyi")
+                            .unwrap_or_default()
+                    });
+                    if py_changed {
+                        printer.clear_screen()?;
+                        printer.write_to_user("File change detected...\n");
+
+                        let messages = commands::run(
+                            &cli.files,
+                            &pyproject_strategy,
+                            &file_strategy,
+                            &overrides,
+                            cache.into(),
+                            fix::FixMode::None,
+                        )?;
+                        printer.write_continuously(&messages);
+                    }
+                }
+                Err(err) => return Err(err.into()),
+            }
+        }
+    } else if cli.add_noqa {
+        let modifications =
+            commands::add_noqa(&cli.files, &pyproject_strategy, &file_strategy, &overrides)?;
+        if modifications > 0 && log_level >= LogLevel::Default {
+            println!("Added {modifications} noqa directives.");
+        }
+    } else {
+        let is_stdin = cli.files == vec![PathBuf::from("-")];
+
+        // Generate lint violations.
+        let diagnostics = if is_stdin {
+            commands::run_stdin(
+                cli.stdin_filename.map(fs::normalize_path).as_deref(),
+                &pyproject_strategy,
+                &file_strategy,
+                &overrides,
+                autofix,
+            )?
+        } else {
+            commands::run(
+                &cli.files,
+                &pyproject_strategy,
+                &file_strategy,
+                &overrides,
+                cache.into(),
+                autofix,
+            )?
+        };
+
+        // Always try to print violations (the printer itself may suppress output),
+        // unless we're writing fixes via stdin (in which case, the transformed
+        // source code goes to stdout).
+        if !(is_stdin && matches!(autofix, fix::FixMode::Apply | fix::FixMode::Diff)) {
+            printer.write_once(&diagnostics)?;
+        }
+
+        // Check for updates if we're in a non-silent log level.
+        #[cfg(feature = "update-informer")]
+        if update_check
+            && !is_stdin
+            && log_level >= LogLevel::Default
+            && atty::is(atty::Stream::Stdout)
+        {
+            drop(updates::check_for_updates());
+        }
+
+        if !cli.exit_zero {
+            if cli.diff || fix_only {
+                if diagnostics.fixed > 0 {
+                    return Ok(ExitCode::FAILURE);
+                }
+            } else if !diagnostics.messages.is_empty() {
+                return Ok(ExitCode::FAILURE);
+            }
+        }
+    }
+
+    Ok(ExitCode::SUCCESS)
+}

ruff_cli/src/printer.rs

@@ -0,0 +1,449 @@
+use std::collections::BTreeMap;
+use std::path::Path;
+
+use annotate_snippets::display_list::{DisplayList, FormatOptions};
+use annotate_snippets::snippet::{Annotation, AnnotationType, Slice, Snippet, SourceAnnotation};
+use anyhow::Result;
+use colored::Colorize;
+use itertools::iterate;
+use ruff::fs::relativize_path;
+use ruff::logging::LogLevel;
+use ruff::message::{Location, Message};
+use ruff::registry::RuleCode;
+use ruff::settings::types::SerializationFormat;
+use ruff::{fix, notify_user};
+use serde::Serialize;
+use serde_json::json;
+
+use crate::diagnostics::Diagnostics;
+
+/// Enum to control whether lint violations are shown to the user.
+pub enum Violations {
+    Show,
+    Hide,
+}
+
+#[derive(Serialize)]
+struct ExpandedFix<'a> {
+    content: &'a str,
+    message: Option<String>,
+    location: &'a Location,
+    end_location: &'a Location,
+}
+
+#[derive(Serialize)]
+struct ExpandedMessage<'a> {
+    code: &'a RuleCode,
+    message: String,
+    fix: Option<ExpandedFix<'a>>,
+    location: Location,
+    end_location: Location,
+    filename: &'a str,
+}
+
+pub struct Printer<'a> {
+    format: &'a SerializationFormat,
+    log_level: &'a LogLevel,
+    autofix: &'a fix::FixMode,
+    violations: &'a Violations,
+}
+
+impl<'a> Printer<'a> {
+    pub fn new(
+        format: &'a SerializationFormat,
+        log_level: &'a LogLevel,
+        autofix: &'a fix::FixMode,
+        violations: &'a Violations,
+    ) -> Self {
+        Self {
+            format,
+            log_level,
+            autofix,
+            violations,
+        }
+    }
+
+    pub fn write_to_user(&self, message: &str) {
+        if self.log_level >= &LogLevel::Default {
+            notify_user!("{}", message);
+        }
+    }
+
+    fn post_text(&self, diagnostics: &Diagnostics) {
+        if self.log_level >= &LogLevel::Default {
+            match self.violations {
+                Violations::Show => {
+                    let fixed = diagnostics.fixed;
+                    let remaining = diagnostics.messages.len();
+                    let total = fixed + remaining;
+                    if fixed > 0 {
+                        println!("Found {total} error(s) ({fixed} fixed, {remaining} remaining).");
+                    } else if remaining > 0 {
+                        println!("Found {remaining} error(s).");
+                    }
+
+                    if !matches!(self.autofix, fix::FixMode::Apply) {
+                        let num_fixable = diagnostics
+                            .messages
+                            .iter()
+                            .filter(|message| message.kind.fixable())
+                            .count();
+                        if num_fixable > 0 {
+                            println!("{num_fixable} potentially fixable with the --fix option.");
+                        }
+                    }
+                }
+                Violations::Hide => {
+                    let fixed = diagnostics.fixed;
+                    if fixed > 0 {
+                        if matches!(self.autofix, fix::FixMode::Apply) {
+                            println!("Fixed {fixed} error(s).");
+                        } else if matches!(self.autofix, fix::FixMode::Diff) {
+                            println!("Would fix {fixed} error(s).");
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn write_once(&self, diagnostics: &Diagnostics) -> Result<()> {
+        if matches!(self.log_level, LogLevel::Silent) {
+            return Ok(());
+        }
+
+        if matches!(self.violations, Violations::Hide) {
+            if matches!(
+                self.format,
+                SerializationFormat::Text | SerializationFormat::Grouped
+            ) {
+                self.post_text(diagnostics);
+            }
+            return Ok(());
+        }
+
+        match self.format {
+            SerializationFormat::Json => {
+                println!(
+                    "{}",
+                    serde_json::to_string_pretty(
+                        &diagnostics
+                            .messages
+                            .iter()
+                            .map(|message| ExpandedMessage {
+                                code: message.kind.code(),
+                                message: message.kind.body(),
+                                fix: message.fix.as_ref().map(|fix| ExpandedFix {
+                                    content: &fix.content,
+                                    location: &fix.location,
+                                    end_location: &fix.end_location,
+                                    message: message.kind.commit(),
+                                }),
+                                location: message.location,
+                                end_location: message.end_location,
+                                filename: &message.filename,
+                            })
+                            .collect::<Vec<_>>()
+                    )?
+                );
+            }
+            SerializationFormat::Junit => {
+                use quick_junit::{NonSuccessKind, Report, TestCase, TestCaseStatus, TestSuite};
+
+                let mut report = Report::new("ruff");
+                for (filename, messages) in group_messages_by_filename(&diagnostics.messages) {
+                    let mut test_suite = TestSuite::new(filename);
+                    test_suite
+                        .extra
+                        .insert("package".to_string(), "org.ruff".to_string());
+                    for message in messages {
+                        let mut status = TestCaseStatus::non_success(NonSuccessKind::Failure);
+                        status.set_message(message.kind.body());
+                        status.set_description(format!(
+                            "line {}, col {}, {}",
+                            message.location.row(),
+                            message.location.column(),
+                            message.kind.body()
+                        ));
+                        let mut case =
+                            TestCase::new(format!("org.ruff.{}", message.kind.code()), status);
+                        let file_path = Path::new(filename);
+                        let file_stem = file_path.file_stem().unwrap().to_str().unwrap();
+                        let classname = file_path.parent().unwrap().join(file_stem);
+                        case.set_classname(classname.to_str().unwrap());
+                        case.extra
+                            .insert("line".to_string(), message.location.row().to_string());
+                        case.extra
+                            .insert("column".to_string(), message.location.column().to_string());
+
+                        test_suite.add_test_case(case);
+                    }
+                    report.add_test_suite(test_suite);
+                }
+                println!("{}", report.to_string().unwrap());
+            }
+            SerializationFormat::Text => {
+                for message in &diagnostics.messages {
+                    print_message(message);
+                }
+
+                self.post_text(diagnostics);
+            }
+            SerializationFormat::Grouped => {
+                for (filename, messages) in group_messages_by_filename(&diagnostics.messages) {
+                    // Compute the maximum number of digits in the row and column, for messages in
+                    // this file.
+                    let row_length = num_digits(
+                        messages
+                            .iter()
+                            .map(|message| message.location.row())
+                            .max()
+                            .unwrap(),
+                    );
+                    let column_length = num_digits(
+                        messages
+                            .iter()
+                            .map(|message| message.location.column())
+                            .max()
+                            .unwrap(),
+                    );
+
+                    // Print the filename.
+                    println!("{}:", relativize_path(Path::new(&filename)).underline());
+
+                    // Print each message.
+                    for message in messages {
+                        print_grouped_message(message, row_length, column_length);
+                    }
+                    println!();
+                }
+
+                self.post_text(diagnostics);
+            }
+            SerializationFormat::Github => {
+                // Generate error workflow command in GitHub Actions format.
+                // See: https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#setting-an-error-message
+                diagnostics.messages.iter().for_each(|message| {
+                    let label = format!(
+                        "{}{}{}{}{}{} {} {}",
+                        relativize_path(Path::new(&message.filename)),
+                        ":",
+                        message.location.row(),
+                        ":",
+                        message.location.column(),
+                        ":",
+                        message.kind.code().as_ref(),
+                        message.kind.body(),
+                    );
+                    println!(
+                        "::error title=Ruff \
+                         ({}),file={},line={},col={},endLine={},endColumn={}::{}",
+                        message.kind.code(),
+                        message.filename,
+                        message.location.row(),
+                        message.location.column(),
+                        message.end_location.row(),
+                        message.end_location.column(),
+                        label,
+                    );
+                });
+            }
+            SerializationFormat::Gitlab => {
+                // Generate JSON with errors in GitLab CI format
+                // https://docs.gitlab.com/ee/ci/testing/code_quality.html#implementing-a-custom-tool
+                println!(
+                    "{}",
+                    serde_json::to_string_pretty(
+                        &diagnostics
+                            .messages
+                            .iter()
+                            .map(|message| {
+                                json!({
+                                    "description": format!("({}) {}", message.kind.code(), message.kind.body()),
+                                    "severity": "major",
+                                    "fingerprint": message.kind.code(),
+                                    "location": {
+                                        "path": message.filename,
+                                        "lines": {
+                                            "begin": message.location.row(),
+                                            "end": message.end_location.row()
+                                        }
+                                    }
+                                })
+                            }
+                        )
+                        .collect::<Vec<_>>()
+                    )?
+                );
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn write_continuously(&self, diagnostics: &Diagnostics) {
+        if matches!(self.log_level, LogLevel::Silent) {
+            return;
+        }
+
+        if self.log_level >= &LogLevel::Default {
+            notify_user!(
+                "Found {} error(s). Watching for file changes.",
+                diagnostics.messages.len()
+            );
+        }
+
+        if !diagnostics.messages.is_empty() {
+            if self.log_level >= &LogLevel::Default {
+                println!();
+            }
+            for message in &diagnostics.messages {
+                print_message(message);
+            }
+        }
+    }
+
+    #[allow(clippy::unused_self)]
+    pub fn clear_screen(&self) -> Result<()> {
+        #[cfg(not(target_family = "wasm"))]
+        clearscreen::clear()?;
+        Ok(())
+    }
+}
+
+fn group_messages_by_filename(messages: &[Message]) -> BTreeMap<&String, Vec<&Message>> {
+    let mut grouped_messages = BTreeMap::default();
+    for message in messages {
+        grouped_messages
+            .entry(&message.filename)
+            .or_insert_with(Vec::new)
+            .push(message);
+    }
+    grouped_messages
+}
+
+fn num_digits(n: usize) -> usize {
+    iterate(n, |&n| n / 10)
+        .take_while(|&n| n > 0)
+        .count()
+        .max(1)
+}
+
+/// Print a single `Message` with full details.
+fn print_message(message: &Message) {
+    let label = format!(
+        "{}{}{}{}{}{} {} {}",
+        relativize_path(Path::new(&message.filename)).bold(),
+        ":".cyan(),
+        message.location.row(),
+        ":".cyan(),
+        message.location.column(),
+        ":".cyan(),
+        message.kind.code().as_ref().red().bold(),
+        message.kind.body(),
+    );
+    println!("{label}");
+    if let Some(source) = &message.source {
+        let commit = message.kind.commit();
+        let footer = if commit.is_some() {
+            vec![Annotation {
+                id: None,
+                label: commit.as_deref(),
+                annotation_type: AnnotationType::Help,
+            }]
+        } else {
+            vec![]
+        };
+
+        let snippet = Snippet {
+            title: Some(Annotation {
+                label: None,
+                annotation_type: AnnotationType::Error,
+                // The ID (error number) is already encoded in the `label`.
+                id: None,
+            }),
+            footer,
+            slices: vec![Slice {
+                source: &source.contents,
+                line_start: message.location.row(),
+                annotations: vec![SourceAnnotation {
+                    label: message.kind.code().as_ref(),
+                    annotation_type: AnnotationType::Error,
+                    range: source.range,
+                }],
+                // The origin (file name, line number, and column number) is already encoded
+                // in the `label`.
+                origin: None,
+                fold: false,
+            }],
+            opt: FormatOptions {
+                color: true,
+                ..FormatOptions::default()
+            },
+        };
+        // Skip the first line, since we format the `label` ourselves.
+        let message = DisplayList::from(snippet).to_string();
+        let (_, message) = message.split_once('\n').unwrap();
+        println!("{message}\n");
+    }
+}
+
+/// Print a grouped `Message`, assumed to be printed in a group with others from
+/// the same file.
+fn print_grouped_message(message: &Message, row_length: usize, column_length: usize) {
+    let label = format!(
+        "  {}{}{}{}{}  {}  {}",
+        " ".repeat(row_length - num_digits(message.location.row())),
+        message.location.row(),
+        ":".cyan(),
+        message.location.column(),
+        " ".repeat(column_length - num_digits(message.location.column())),
+        message.kind.code().as_ref().red().bold(),
+        message.kind.body(),
+    );
+    println!("{label}");
+    if let Some(source) = &message.source {
+        let commit = message.kind.commit();
+        let footer = if commit.is_some() {
+            vec![Annotation {
+                id: None,
+                label: commit.as_deref(),
+                annotation_type: AnnotationType::Help,
+            }]
+        } else {
+            vec![]
+        };
+
+        let snippet = Snippet {
+            title: Some(Annotation {
+                label: None,
+                annotation_type: AnnotationType::Error,
+                // The ID (error number) is already encoded in the `label`.
+                id: None,
+            }),
+            footer,
+            slices: vec![Slice {
+                source: &source.contents,
+                line_start: message.location.row(),
+                annotations: vec![SourceAnnotation {
+                    label: message.kind.code().as_ref(),
+                    annotation_type: AnnotationType::Error,
+                    range: source.range,
+                }],
+                // The origin (file name, line number, and column number) is already encoded
+                // in the `label`.
+                origin: None,
+                fold: false,
+            }],
+            opt: FormatOptions {
+                color: true,
+                ..FormatOptions::default()
+            },
+        };
+        // Skip the first line, since we format the `label` ourselves.
+        let message = DisplayList::from(snippet).to_string();
+        let (_, message) = message.split_once('\n').unwrap();
+        let message = textwrap::indent(message, "  ");
+        println!("{message}");
+    }
+}

ruff_cli/src/updates.rs

@@ -0,0 +1,75 @@
+use std::fs::{create_dir_all, read_to_string, File};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+
+use anyhow::Result;
+use colored::Colorize;
+
+const CARGO_PKG_NAME: &str = env!("CARGO_PKG_NAME");
+const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+fn cache_dir() -> &'static str {
+    "./.ruff_cache"
+}
+
+fn file_path() -> PathBuf {
+    Path::new(cache_dir()).join(".update-informer")
+}
+
+/// Get the "latest" version for which the user has been informed.
+fn get_latest() -> Result<Option<String>> {
+    let path = file_path();
+    if path.exists() {
+        Ok(Some(read_to_string(path)?.trim().to_string()))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Set the "latest" version for which the user has been informed.
+fn set_latest(version: &str) -> Result<()> {
+    create_dir_all(cache_dir())?;
+    let path = file_path();
+    let mut file = File::create(path)?;
+    file.write_all(version.trim().as_bytes())?;
+    Ok(())
+}
+
+/// Update the user if a newer version is available.
+pub fn check_for_updates() -> Result<()> {
+    use update_informer::{registry, Check};
+
+    let informer = update_informer::new(registry::PyPI, CARGO_PKG_NAME, CARGO_PKG_VERSION);
+
+    if let Some(new_version) = informer
+        .check_version()
+        .ok()
+        .flatten()
+        .map(|version| version.to_string())
+    {
+        // If we've already notified the user about this version, return early.
+        if let Some(latest_version) = get_latest()? {
+            if latest_version == new_version {
+                return Ok(());
+            }
+        }
+        set_latest(&new_version)?;
+
+        let msg = format!(
+            "A new version of {pkg_name} is available: v{pkg_version} -> {new_version}",
+            pkg_name = CARGO_PKG_NAME.italic().cyan(),
+            pkg_version = CARGO_PKG_VERSION,
+            new_version = new_version.green()
+        );
+
+        let cmd = format!(
+            "Run to update: {cmd} {pkg_name}",
+            cmd = "pip3 install --upgrade".green(),
+            pkg_name = CARGO_PKG_NAME.green()
+        );
+
+        println!("\n{msg}\n{cmd}");
+    }
+
+    Ok(())
+}

ruff_cli/tests/black_compatibility_test.rs

@@ -0,0 +1,202 @@
+#![cfg(not(target_family = "wasm"))]
+
+use std::io::{ErrorKind, Read};
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpListener, TcpStream};
+use std::path::{Path, PathBuf};
+use std::process::Stdio;
+use std::thread::sleep;
+use std::time::Duration;
+use std::{fs, process, str};
+
+use anyhow::{anyhow, Context, Result};
+use assert_cmd::Command;
+use itertools::Itertools;
+use log::info;
+use ruff::logging::{set_up_logging, LogLevel};
+use ruff::registry::RuleOrigin;
+use strum::IntoEnumIterator;
+use walkdir::WalkDir;
+
+/// Handles `blackd` process and allows submitting code to it for formatting.
+struct Blackd {
+    address: SocketAddr,
+    server: process::Child,
+    client: ureq::Agent,
+}
+
+const BIN_NAME: &str = "ruff";
+
+impl Blackd {
+    pub fn new() -> Result<Self> {
+        // Get free TCP port to run on
+        let address = TcpListener::bind(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0))?.local_addr()?;
+
+        let server = process::Command::new("blackd")
+            .args([
+                "--bind-host",
+                &address.ip().to_string(),
+                "--bind-port",
+                &address.port().to_string(),
+            ])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+            .context("Starting blackd")?;
+
+        // Wait up to four seconds for `blackd` to be ready.
+        for _ in 0..20 {
+            match TcpStream::connect(address) {
+                Err(e) if e.kind() == ErrorKind::ConnectionRefused => {
+                    info!("`blackd` not ready yet; retrying...");
+                    sleep(Duration::from_millis(200));
+                }
+                Err(e) => return Err(e.into()),
+                Ok(_) => {
+                    info!("`blackd` ready");
+                    break;
+                }
+            }
+        }
+
+        Ok(Self {
+            address,
+            server,
+            client: ureq::agent(),
+        })
+    }
+
+    /// Format given code with blackd.
+    pub fn check(&self, code: &[u8]) -> Result<Vec<u8>> {
+        match self
+            .client
+            .post(&format!("http://{}/", self.address))
+            .set("X-Line-Length", "88")
+            .send_bytes(code)
+        {
+            // 204 indicates the input wasn't changed during formatting, so
+            // we return the original.
+            Ok(response) => {
+                if response.status() == 204 {
+                    Ok(code.to_vec())
+                } else {
+                    let mut buf = vec![];
+                    response
+                        .into_reader()
+                        .take((1024 * 1024) as u64)
+                        .read_to_end(&mut buf)?;
+                    Ok(buf)
+                }
+            }
+            Err(ureq::Error::Status(_, response)) => Err(anyhow::anyhow!(
+                "Formatting with `black` failed: {}",
+                response.into_string()?
+            )),
+            Err(e) => Err(e.into()),
+        }
+    }
+}
+
+impl Drop for Blackd {
+    fn drop(&mut self) {
+        self.server.kill().expect("Couldn't end `blackd` process");
+    }
+}
+
+fn run_test(path: &Path, blackd: &Blackd, ruff_args: &[&str]) -> Result<()> {
+    let input = fs::read(path)?;
+
+    // Step 1: Run `ruff` on the input.
+    let step_1 = &Command::cargo_bin(BIN_NAME)?
+        .args(ruff_args)
+        .write_stdin(input)
+        .assert()
+        .append_context("step", "running input through ruff");
+    if !step_1.get_output().status.success() {
+        return Err(anyhow!(
+            "Running input through ruff failed:\n{}",
+            str::from_utf8(&step_1.get_output().stderr)?
+        ));
+    }
+    let step_1_output = step_1.get_output().stdout.clone();
+
+    // Step 2: Run `blackd` on the input.
+    let step_2_output = blackd.check(&step_1_output)?;
+
+    // Step 3: Re-run `ruff` on the input.
+    let step_3 = &Command::cargo_bin(BIN_NAME)?
+        .args(ruff_args)
+        .write_stdin(step_2_output.clone())
+        .assert();
+    if !step_3.get_output().status.success() {
+        return Err(anyhow!(
+            "Running input through ruff after black failed:\n{}",
+            str::from_utf8(&step_3.get_output().stderr)?
+        ));
+    }
+    let step_3_output = step_3.get_output().stdout.clone();
+
+    assert_eq!(
+        str::from_utf8(&step_2_output),
+        str::from_utf8(&step_3_output),
+        "Mismatch found for {}",
+        path.display()
+    );
+
+    Ok(())
+}
+
+#[test]
+#[ignore]
+fn test_ruff_black_compatibility() -> Result<()> {
+    set_up_logging(&LogLevel::Default)?;
+
+    let blackd = Blackd::new()?;
+
+    let fixtures_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("resources")
+        .join("test")
+        .join("fixtures");
+
+    // Ignore some fixtures that currently trigger errors. `E999.py` especially, as
+    // that is triggering a syntax error on purpose.
+    let excludes = ["E999.py", "W605_1.py"];
+
+    let paths: Vec<walkdir::DirEntry> = WalkDir::new(fixtures_dir)
+        .into_iter()
+        .filter(|entry| {
+            entry.as_ref().map_or(true, |entry| {
+                entry
+                    .path()
+                    .extension()
+                    .map_or(false, |ext| ext == "py" || ext == "pyi")
+                    && !excludes.contains(&entry.path().file_name().unwrap().to_str().unwrap())
+            })
+        })
+        .filter_map(Result::ok)
+        .collect();
+
+    let codes = RuleOrigin::iter()
+        // Exclude ruff codes, specifically RUF100, because it causes differences that are not a
+        // problem. Ruff would add a `# noqa: W292`  after the first run, black introduces a
+        // newline, and ruff removes the `# noqa: W292` again.
+        .filter(|origin| *origin != RuleOrigin::Ruff)
+        .map(|origin| origin.codes().iter().map(AsRef::as_ref).join(","))
+        .join(",");
+    let ruff_args = [
+        "-",
+        "--silent",
+        "--exit-zero",
+        "--fix",
+        "--line-length",
+        "88",
+        "--select",
+        &codes,
+    ];
+
+    for entry in paths {
+        let path = entry.path();
+        run_test(path, &blackd, &ruff_args).context(format!("Testing {}", path.display()))?;
+    }
+
+    Ok(())
+}

ruff_cli/tests/integration_test.rs

@@ -0,0 +1,153 @@
+#![cfg(not(target_family = "wasm"))]
+
+use std::str;
+
+use anyhow::Result;
+use assert_cmd::Command;
+use path_absolutize::path_dedot;
+
+const BIN_NAME: &str = "ruff";
+
+#[test]
+fn test_stdin_success() -> Result<()> {
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
+    cmd.args(["-", "--format", "text"])
+        .write_stdin("")
+        .assert()
+        .success();
+    Ok(())
+}
+
+#[test]
+fn test_stdin_error() -> Result<()> {
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
+    let output = cmd
+        .args(["-", "--format", "text"])
+        .write_stdin("import os\n")
+        .assert()
+        .failure();
+    assert_eq!(
+        str::from_utf8(&output.get_output().stdout)?,
+        "-:1:8: F401 `os` imported but unused\nFound 1 error(s).\n1 potentially fixable with the \
+         --fix option.\n"
+    );
+    Ok(())
+}
+
+#[test]
+fn test_stdin_filename() -> Result<()> {
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
+    let output = cmd
+        .args(["-", "--format", "text", "--stdin-filename", "F401.py"])
+        .write_stdin("import os\n")
+        .assert()
+        .failure();
+    assert_eq!(
+        str::from_utf8(&output.get_output().stdout)?,
+        "F401.py:1:8: F401 `os` imported but unused\nFound 1 error(s).\n1 potentially fixable \
+         with the --fix option.\n"
+    );
+    Ok(())
+}
+
+#[test]
+fn test_stdin_json() -> Result<()> {
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
+    let output = cmd
+        .args(["-", "--format", "json", "--stdin-filename", "F401.py"])
+        .write_stdin("import os\n")
+        .assert()
+        .failure();
+    assert_eq!(
+        str::from_utf8(&output.get_output().stdout)?,
+        format!(
+            r#"[
+  {{
+    "code": "F401",
+    "message": "`os` imported but unused",
+    "fix": {{
+      "content": "",
+      "message": "Remove unused import: `os`",
+      "location": {{
+        "row": 1,
+        "column": 0
+      }},
+      "end_location": {{
+        "row": 2,
+        "column": 0
+      }}
+    }},
+    "location": {{
+      "row": 1,
+      "column": 8
+    }},
+    "end_location": {{
+      "row": 1,
+      "column": 10
+    }},
+    "filename": "{}/F401.py"
+  }}
+]
+"#,
+            path_dedot::CWD.to_str().unwrap()
+        )
+    );
+    Ok(())
+}
+
+#[test]
+fn test_stdin_autofix() -> Result<()> {
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
+    let output = cmd
+        .args(["-", "--format", "text", "--fix"])
+        .write_stdin("import os\nimport sys\n\nprint(sys.version)\n")
+        .assert()
+        .success();
+    assert_eq!(
+        str::from_utf8(&output.get_output().stdout)?,
+        "import sys\n\nprint(sys.version)\n"
+    );
+    Ok(())
+}
+
+#[test]
+fn test_stdin_autofix_when_not_fixable_should_still_print_contents() -> Result<()> {
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
+    let output = cmd
+        .args(["-", "--format", "text", "--fix"])
+        .write_stdin("import os\nimport sys\n\nif (1, 2):\n     print(sys.version)\n")
+        .assert()
+        .failure();
+    assert_eq!(
+        str::from_utf8(&output.get_output().stdout)?,
+        "import sys\n\nif (1, 2):\n     print(sys.version)\n"
+    );
+    Ok(())
+}
+
+#[test]
+fn test_stdin_autofix_when_no_issues_should_still_print_contents() -> Result<()> {
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
+    let output = cmd
+        .args(["-", "--format", "text", "--fix"])
+        .write_stdin("import sys\n\nprint(sys.version)\n")
+        .assert()
+        .success();
+    assert_eq!(
+        str::from_utf8(&output.get_output().stdout)?,
+        "import sys\n\nprint(sys.version)\n"
+    );
+    Ok(())
+}
+
+#[test]
+fn test_show_source() -> Result<()> {
+    let mut cmd = Command::cargo_bin(BIN_NAME)?;
+    let output = cmd
+        .args(["-", "--format", "text", "--show-source"])
+        .write_stdin("l = 1")
+        .assert()
+        .failure();
+    assert!(str::from_utf8(&output.get_output().stdout)?.contains("l = 1"));
+    Ok(())
+}