Add test cases

I got confused and refactored a bit

.cargo/config.toml

@@ -0,0 +1,37 @@
+[alias]
+dev = "run --package ruff_dev --bin ruff_dev"
+benchmark = "bench -p ruff_benchmark --bench linter --bench formatter --"
+
+[target.'cfg(all())']
+rustflags = [
+  # CLIPPY LINT SETTINGS
+  # This is a workaround to configure lints for the entire workspace, pending the ability to configure this via TOML.
+  # See: `https://github.com/rust-lang/cargo/issues/5034`
+  #      `https://github.com/EmbarkStudios/rust-ecosystem/issues/22#issuecomment-947011395`
+  "-Dunsafe_code",
+  "-Wclippy::pedantic",
+  # Allowed pedantic lints
+  "-Wclippy::char_lit_as_u8",
+  "-Aclippy::collapsible_else_if",
+  "-Aclippy::collapsible_if",
+  "-Aclippy::implicit_hasher",
+  "-Aclippy::match_same_arms",
+  "-Aclippy::missing_errors_doc",
+  "-Aclippy::missing_panics_doc",
+  "-Aclippy::module_name_repetitions",
+  "-Aclippy::must_use_candidate",
+  "-Aclippy::similar_names",
+  "-Aclippy::too_many_lines",
+  # Disallowed restriction lints
+  "-Wclippy::print_stdout",
+  "-Wclippy::print_stderr",
+  "-Wclippy::dbg_macro",
+  "-Wclippy::empty_drop",
+  "-Wclippy::empty_structs_with_brackets",
+  "-Wclippy::exit",
+  "-Wclippy::get_unwrap",
+  "-Wclippy::rc_buffer",
+  "-Wclippy::rc_mutex",
+  "-Wclippy::rest_pat_in_fully_bound_structs",
+  "-Wunreachable_pub"
+]

.devcontainer/devcontainer.json

@@ -0,0 +1,46 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/rust
+{
+	"name": "Ruff",
+	"image": "mcr.microsoft.com/devcontainers/rust:0-1-bullseye",
+	"mounts": [
+		{
+			"source": "devcontainer-cargo-cache-${devcontainerId}",
+			"target": "/usr/local/cargo",
+			"type": "volume"
+		}
+	],
+	"customizations": {
+		"codespaces": {
+			"openFiles": [
+				"CONTRIBUTING.md"
+			]
+		},
+		"vscode": {
+			"extensions": [
+				"ms-python.python",
+				"rust-lang.rust-analyzer",
+				"serayuzgur.crates",
+				"tamasfe.even-better-toml",
+				"Swellaby.vscode-rust-test-adapter",
+				"charliermarsh.ruff"
+			],
+			"settings": {
+				"rust-analyzer.updates.askBeforeDownload": false
+			}
+		}
+	},
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	"features": {
+		"ghcr.io/devcontainers/features/python": {
+			"installTools": false
+		}
+	},
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+	"postCreateCommand": ".devcontainer/post-create.sh"
+	// Configure tool-specific properties.
+	// "customizations": {},
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

.devcontainer/post-create.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+rustup default < rust-toolchain
+rustup component add clippy rustfmt
+cargo install cargo-insta
+cargo fetch
+
+pip install maturin pre-commit

.editorconfig

@@ -10,5 +10,11 @@ indent_style = space
 insert_final_newline = true
 indent_size = 2
 
-[*.{rs,py}]
+[*.{rs,py,pyi}]
 indent_size = 4
+
+[*.snap]
+trim_trailing_whitespace = false
+
+[*.md]
+max_line_length = 100

.gitattributes

@@ -0,0 +1,7 @@
+* text=auto eol=lf
+
+crates/ruff_linter/resources/test/fixtures/isort/line_ending_crlf.py text eol=crlf
+crates/ruff_linter/resources/test/fixtures/pycodestyle/W605_1.py text eol=crlf
+
+ruff.schema.json linguist-generated=true text=auto eol=lf
+*.md.snap linguist-language=Markdown

.github/CODEOWNERS

@@ -0,0 +1,9 @@
+# GitHub code owners file. For more info: https://help.github.com/articles/about-codeowners/
+#
+# - Comment lines begin with `#` character.
+# - Each line is a file pattern followed by one or more owners.
+# - The '*' pattern is global owners.
+# - Order is important. The last matching pattern has the most precedence.
+
+# Jupyter
+/crates/ruff_linter/src/jupyter/ @dhruvmanila

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,10 @@
+<!--
+Thank you for taking the time to report an issue! We're glad to have you involved with Ruff.
+
+If you're filing a bug report, please consider including the following information:
+
+* A minimal code snippet that reproduces the bug.
+* The command you invoked (e.g., `ruff /path/to/file.py --fix`), ideally including the `--isolated` flag.
+* The current Ruff settings (any relevant sections from your `pyproject.toml`).
+* The current Ruff version (`ruff --version`).
+-->

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,15 @@
+<!--
+Thank you for contributing to Ruff! To help us out with reviewing, please consider the following:
+
+- Does this pull request include a summary of the change? (See below.)
+- Does this pull request include a descriptive title?
+- Does this pull request include references to any relevant issues?
+-->
+
+## Summary
+
+<!-- What's the purpose of the change? What does it do, and why? -->
+
+## Test Plan
+
+<!-- How was it tested? -->

.github/dependabot.yml

@@ -0,0 +1,13 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    labels: ["internal"]
+
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    labels: ["internal"]

.github/release.yml

@@ -0,0 +1,28 @@
+# https://docs.github.com/en/repositories/releasing-projects-on-github/automatically-generated-release-notes#configuring-automatically-generated-release-notes
+changelog:
+  exclude:
+    labels:
+      - internal
+      - documentation
+      - formatter
+  categories:
+    - title: Breaking Changes
+      labels:
+        - breaking
+    - title: Rules
+      labels:
+        - rule
+        - autofix
+    - title: Settings
+      labels:
+        - configuration
+        - cli
+    - title: Bug Fixes
+      labels:
+        - bug
+    - title: Preview
+      labels:
+        - preview
+    - title: Other Changes
+      labels:
+        - "*"

.github/workflows/ci.yaml

@@ -4,119 +4,365 @@ on:
   push:
     branches: [main]
   pull_request:
-    branches: [main]
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+env:
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CARGO_TERM_COLOR: always
+  RUSTUP_MAX_RETRIES: 10
+  PACKAGE_NAME: ruff
+  PYTHON_VERSION: "3.11"
 
 jobs:
-  cargo_build:
-    name: "cargo build"
+  determine_changes:
+    name: "Determine changes"
     runs-on: ubuntu-latest
+    outputs:
+      linter: ${{ steps.changed.outputs.linter_any_changed }}
+      formatter: ${{ steps.changed.outputs.formatter_any_changed }}
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v4
         with:
-          toolchain: stable
-      - uses: actions/cache@v3
-        env:
-          cache-name: cache-cargo
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
-      - run: cargo build --release
+          fetch-depth: 0
 
-  cargo_fmt:
+      - uses: tj-actions/changed-files@v39
+        id: changed
+        with:
+          files_yaml: |
+            linter:
+              - Cargo.toml
+              - Cargo.lock
+              - crates/**
+              - "!crates/ruff_python_formatter/**"
+              - "!crates/ruff_formatter/**"
+              - "!crates/ruff_dev/**"
+              - "!crates/ruff_shrinking/**"
+              - scripts/*
+
+            formatter:
+              - Cargo.toml
+              - Cargo.lock
+              - crates/ruff_python_formatter/**
+              - crates/ruff_formatter/**
+              - crates/ruff_python_trivia/**
+              - crates/ruff_python_ast/**
+              - crates/ruff_source_file/**
+              - crates/ruff_python_index/**
+              - crates/ruff_text_size/**
+              - crates/ruff_python_parser/**
+              - crates/ruff_dev/**
+              - scripts/*
+
+  cargo-fmt:
     name: "cargo fmt"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - uses: actions/cache@v3
-        env:
-          cache-name: cache-cargo
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
-      - run: cargo fmt --check
+      - uses: actions/checkout@v4
+      - name: "Install Rust toolchain"
+        run: rustup component add rustfmt
+      - run: cargo fmt --all --check
 
-  cargo_clippy:
+  cargo-clippy:
     name: "cargo clippy"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - uses: actions/cache@v3
-        env:
-          cache-name: cache-cargo
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
-      - run: cargo clippy -- -D warnings
+      - uses: actions/checkout@v4
+      - name: "Install Rust toolchain"
+        run: |
+          rustup component add clippy
+          rustup target add wasm32-unknown-unknown
+      - uses: Swatinem/rust-cache@v2
+      - name: "Clippy"
+        run: cargo clippy --workspace --all-targets --all-features -- -D warnings
+      - name: "Clippy (wasm)"
+        run: cargo clippy -p ruff_wasm --target wasm32-unknown-unknown --all-features -- -D warnings
 
-  cargo_test:
-    name: "cargo test"
+  cargo-test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    name: "cargo test | ${{ matrix.os }}"
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - name: "Install cargo insta"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-insta
+      - run: pip install black[d]==23.1.0
+      - uses: Swatinem/rust-cache@v2
+      - name: "Run tests (Ubuntu)"
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        run: cargo insta test --all --all-features --unreferenced reject
+      - name: "Run tests (Windows)"
+        if: ${{ matrix.os == 'windows-latest' }}
+        shell: bash
+        # We can't reject unreferenced snapshots on windows because flake8_executable can't run on windows
+        run: cargo insta test --all --all-features
+      - run: cargo test --package ruff_cli --test black_compatibility_test -- --ignored
+        # TODO: Skipped as it's currently broken. The resource were moved from the
+        # ruff_cli to ruff crate, but this test was not updated.
+        if: false
+      # Check for broken links in the documentation.
+      - run: cargo doc --all --no-deps
+        env:
+          # Setting RUSTDOCFLAGS because `cargo doc --check` isn't yet implemented (https://github.com/rust-lang/cargo/issues/10025).
+          RUSTDOCFLAGS: "-D warnings"
+      - uses: actions/upload-artifact@v3
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        with:
+          name: ruff
+          path: target/debug/ruff
+
+  cargo-fuzz:
+    runs-on: ubuntu-latest
+    name: "cargo fuzz"
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: "fuzz -> target"
+      - name: "Install cargo-fuzz"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-fuzz@0.11
+      - run: cargo fuzz build -s none
+
+  cargo-test-wasm:
+    runs-on: ubuntu-latest
+    name: "cargo test (wasm)"
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Install Rust toolchain"
+        run: rustup target add wasm32-unknown-unknown
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          cache: "npm"
+          cache-dependency-path: playground/package-lock.json
+      - uses: jetli/wasm-pack-action@v0.4.0
+      - uses: Swatinem/rust-cache@v2
+      - name: "Run wasm-pack"
+        run: |
+          cd crates/ruff_wasm
+          wasm-pack test --node
+
+  scripts:
+    name: "test scripts"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - uses: actions/cache@v3
-        env:
-          cache-name: cache-cargo
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
-      - run: cargo test
+      - uses: actions/checkout@v4
+      - name: "Install Rust toolchain"
+        run: rustup component add rustfmt
+      - uses: Swatinem/rust-cache@v2
+      - run: ./scripts/add_rule.py --name DoTheThing --prefix PL --code C0999 --linter pylint
+      - run: cargo check
+      - run: cargo fmt --all --check
+      - run: |
+          ./scripts/add_plugin.py test --url https://pypi.org/project/-test/0.1.0/ --prefix TST
+          ./scripts/add_rule.py --name FirstRule --prefix TST --code 001 --linter test
+      - run: cargo check
+      - run: cargo fmt --all --check
 
-  maturin_build:
-    name: "maturin build"
+  ecosystem:
+    name: "ecosystem"
     runs-on: ubuntu-latest
+    needs:
+      - cargo-test
+      - determine_changes
+    # Only runs on pull requests, since that is the only we way we can find the base version for comparison.
+    if: github.event_name == 'pull_request' && needs.determine_changes.outputs.linter == 'true'
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
+      - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
         with:
-          python-version: "3.10"
-      - run: pip install maturin
-      - uses: actions/cache@v3
-        env:
-          cache-name: cache-cargo
+          python-version: ${{ env.PYTHON_VERSION }}
+
+      - uses: actions/download-artifact@v3
+        name: Download Ruff binary
+        id: ruff-target
         with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-          key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-build-${{ env.cache-name }}-
-            ${{ runner.os }}-build-
-            ${{ runner.os }}-
-      - run: maturin build -b bin
+          name: ruff
+          path: target/debug
+
+      - uses: dawidd6/action-download-artifact@v2
+        name: Download base results
+        with:
+          name: ruff
+          branch: ${{ github.event.pull_request.base.ref }}
+          check_artifacts: true
+
+      - name: Run ecosystem check
+        run: |
+          # Make executable, since artifact download doesn't preserve this
+          chmod +x ruff ${{ steps.ruff-target.outputs.download-path }}/ruff
+
+          scripts/check_ecosystem.py ruff ${{ steps.ruff-target.outputs.download-path }}/ruff | tee ecosystem-result
+          cat ecosystem-result > $GITHUB_STEP_SUMMARY
+
+          echo ${{ github.event.number }} > pr-number
+
+      - uses: actions/upload-artifact@v3
+        name: Upload PR Number
+        with:
+          name: pr-number
+          path: pr-number
+
+      - uses: actions/upload-artifact@v3
+        name: Upload Results
+        with:
+          name: ecosystem-result
+          path: ecosystem-result
+
+  cargo-udeps:
+    name: "cargo udeps"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Install nightly Rust toolchain"
+        # Only pinned to make caching work, update freely
+        run: rustup toolchain install nightly-2023-06-08
+      - uses: Swatinem/rust-cache@v2
+      - name: "Install cargo-udeps"
+        uses: taiki-e/install-action@cargo-udeps
+      - name: "Run cargo-udeps"
+        run: cargo +nightly-2023-06-08 udeps
+
+  python-package:
+    name: "python package"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - uses: Swatinem/rust-cache@v2
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
+        with:
+          args: --out dist
+      - name: "Test wheel"
+        run: |
+          pip install --force-reinstall --find-links dist ${{ env.PACKAGE_NAME }}
+          ruff --help
+          python -m ruff --help
+      - name: "Remove wheels from cache"
+        run: rm -rf target/wheels
+
+  pre-commit:
+    name: "pre-commit"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+      - name: "Install pre-commit"
+        run: pip install pre-commit
+      - name: "Cache pre-commit"
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/pre-commit
+          key: pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
+      - name: "Run pre-commit"
+        run: |
+          echo '```console' > $GITHUB_STEP_SUMMARY
+          # Enable color output for pre-commit and remove it for the summary
+          SKIP=cargo-fmt,clippy,dev-generate-all pre-commit run --all-files --show-diff-on-failure --color=always | \
+            tee >(sed -E 's/\x1B\[([0-9]{1,2}(;[0-9]{1,2})*)?[mGK]//g' >> $GITHUB_STEP_SUMMARY) >&1
+          exit_code=${PIPESTATUS[0]}
+          echo '```' >> $GITHUB_STEP_SUMMARY
+          exit $exit_code
+
+  docs:
+    name: "mkdocs"
+    runs-on: ubuntu-latest
+    env:
+      MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+      - name: "Add SSH key"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        uses: webfactory/ssh-agent@v0.8.0
+        with:
+          ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+      - name: "Install Insiders dependencies"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        run: pip install -r docs/requirements-insiders.txt
+      - name: "Install dependencies"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
+        run: pip install -r docs/requirements.txt
+      - name: "Update README File"
+        run: python scripts/transform_readme.py --target mkdocs
+      - name: "Generate docs"
+        run: python scripts/generate_mkdocs.py
+      - name: "Check docs formatting"
+        run: python scripts/check_docs_formatted.py
+      - name: "Build Insiders docs"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        run: mkdocs build --strict -f mkdocs.insiders.yml
+      - name: "Build docs"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
+        run: mkdocs build --strict -f mkdocs.generated.yml
+
+  check-formatter-ecosystem:
+    name: "Formatter ecosystem and progress checks"
+    runs-on: ubuntu-latest
+    needs: determine_changes
+    if: needs.determine_changes.outputs.formatter == 'true' || github.ref == 'refs/heads/main'
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - name: "Cache rust"
+        uses: Swatinem/rust-cache@v2
+      - name: "Formatter progress"
+        run: scripts/formatter_ecosystem_checks.sh
+      - name: "Github step summary"
+        run: cat target/progress_projects_stats.txt > $GITHUB_STEP_SUMMARY
+      - name: "Remove checkouts from cache"
+        run: rm -r target/progress_projects
+
+  benchmarks:
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Checkout Branch"
+        uses: actions/checkout@v4
+
+      - name: "Install Rust toolchain"
+        run: rustup show
+
+      - name: "Install codspeed"
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-codspeed
+
+      - uses: Swatinem/rust-cache@v2
+
+      - name: "Build benchmarks"
+        run: cargo codspeed build --features codspeed -p ruff_benchmark
+
+      - name: "Run benchmarks"
+        uses: CodSpeedHQ/action@v1
+        with:
+          run: cargo codspeed run
+          token: ${{ secrets.CODSPEED_TOKEN }}

.github/workflows/docs.yaml

@@ -0,0 +1,55 @@
+name: mkdocs
+
+on:
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: "The commit SHA, tag, or branch to publish. Uses the default branch if not specified."
+        default: ""
+        type: string
+  release:
+    types: [published]
+
+jobs:
+  mkdocs:
+    runs-on: ubuntu-latest
+    env:
+      CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
+      MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref }}
+      - uses: actions/setup-python@v4
+      - name: "Add SSH key"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        uses: webfactory/ssh-agent@v0.8.0
+        with:
+          ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+      - name: "Install Insiders dependencies"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        run: pip install -r docs/requirements-insiders.txt
+      - name: "Install dependencies"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
+        run: pip install -r docs/requirements.txt
+      - name: "Copy README File"
+        run: |
+          python scripts/transform_readme.py --target mkdocs
+          python scripts/generate_mkdocs.py
+      - name: "Build Insiders docs"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        run: mkdocs build --strict -f mkdocs.insiders.yml
+      - name: "Build docs"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
+        run: mkdocs build --strict -f mkdocs.generated.yml
+      - name: "Deploy to Cloudflare Pages"
+        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
+        uses: cloudflare/wrangler-action@v3.1.1
+        with:
+          apiToken: ${{ secrets.CF_API_TOKEN }}
+          accountId: ${{ secrets.CF_ACCOUNT_ID }}
+          # `github.head_ref` is only set during pull requests and for manual runs or tags we use `main` to deploy to production
+          command: pages deploy site --project-name=astral-docs --branch ${{ github.head_ref || 'main' }} --commit-hash ${GITHUB_SHA}

.github/workflows/flake8-to-ruff.yaml

@@ -0,0 +1,247 @@
+name: "[flake8-to-ruff] Release"
+
+on: workflow_dispatch
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PACKAGE_NAME: flake8-to-ruff
+  CRATE_NAME: flake8_to_ruff
+  PYTHON_VERSION: "3.11"
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CARGO_TERM_COLOR: always
+  RUSTUP_MAX_RETRIES: 10
+
+jobs:
+  macos-x86_64:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - name: "Build wheels - x86_64"
+        uses: PyO3/maturin-action@v1
+        with:
+          target: x86_64
+          args: --release --out dist --sdist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: "Install built wheel - x86_64"
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+  macos-universal:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - name: "Build wheels - universal2"
+        uses: PyO3/maturin-action@v1
+        with:
+          args: --release --target universal2-apple-darwin --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: "Install built wheel - universal2"
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*universal2.whl --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target: [x64, x86]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: ${{ matrix.target }}
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: "Install built wheel"
+        shell: bash
+        run: |
+          python -m pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64, i686]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: "Install built wheel"
+        if: matrix.target == 'x86_64'
+        run: |
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  linux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [aarch64, armv7, s390x, ppc64le, ppc64]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          args: --no-default-features --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - uses: uraimo/run-on-arch-action@v2
+        if: matrix.target != 'ppc64'
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.target }}
+          distro: ubuntu20.04
+          githubToken: ${{ github.token }}
+          install: |
+            apt-get update
+            apt-get install -y --no-install-recommends python3 python3-pip
+            pip3 install -U pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  musllinux:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target:
+          - x86_64-unknown-linux-musl
+          - i686-unknown-linux-musl
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: "Install built wheel"
+        if: matrix.target == 'x86_64-unknown-linux-musl'
+        uses: addnab/docker-run-action@v3
+        with:
+          image: alpine:latest
+          options: -v ${{ github.workspace }}:/io -w /io
+          run: |
+            apk add py3-pip
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links /io/dist/ --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  musllinux-cross:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        platform:
+          - target: aarch64-unknown-linux-musl
+            arch: aarch64
+          - target: armv7-unknown-linux-musleabihf
+            arch: armv7
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - uses: uraimo/run-on-arch-action@v2
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.platform.arch }}
+          distro: alpine_latest
+          githubToken: ${{ github.token }}
+          install: |
+            apk add py3-pip
+          run: |
+            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    needs:
+      - macos-universal
+      - macos-x86_64
+      - windows
+      - linux
+      - linux-cross
+      - musllinux
+      - musllinux-cross
+    steps:
+      - uses: actions/download-artifact@v3
+        with:
+          name: wheels
+      - uses: actions/setup-python@v4
+      - name: "Publish to PyPi"
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.FLAKE8_TO_RUFF_TOKEN }}
+        run: |
+          pip install --upgrade twine
+          twine upload --skip-existing *

.github/workflows/playground.yaml

@@ -0,0 +1,47 @@
+name: "[Playground] Release"
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+env:
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CARGO_TERM_COLOR: always
+  RUSTUP_MAX_RETRIES: 10
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    env:
+      CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Install Rust toolchain"
+        run: rustup target add wasm32-unknown-unknown
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+          cache: "npm"
+          cache-dependency-path: playground/package-lock.json
+      - uses: jetli/wasm-pack-action@v0.4.0
+      - uses: jetli/wasm-bindgen-action@v0.2.0
+      - name: "Run wasm-pack"
+        run: wasm-pack build --target web --out-dir ../../playground/src/pkg crates/ruff_wasm
+      - name: "Install Node dependencies"
+        run: npm ci
+        working-directory: playground
+      - name: "Run TypeScript checks"
+        run: npm run check
+        working-directory: playground
+      - name: "Build JavaScript bundle"
+        run: npm run build
+        working-directory: playground
+      - name: "Deploy to Cloudflare Pages"
+        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
+        uses: cloudflare/wrangler-action@v3.1.1
+        with:
+          apiToken: ${{ secrets.CF_API_TOKEN }}
+          accountId: ${{ secrets.CF_ACCOUNT_ID }}
+          command: pages deploy playground/dist --project-name=ruff-playground --branch ${GITHUB_HEAD_REF} --commit-hash ${GITHUB_SHA}

.github/workflows/pr-comment.yaml

@@ -0,0 +1,76 @@
+name: PR Check Comment
+
+on:
+  workflow_run:
+    workflows: [CI]
+    types: [completed]
+  workflow_dispatch:
+    inputs:
+      workflow_run_id:
+        description: The ecosystem workflow that triggers the workflow run
+        required: true
+
+permissions:
+  pull-requests: write
+
+jobs:
+  comment:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dawidd6/action-download-artifact@v2
+        name: Download PR Number
+        with:
+          name: pr-number
+          run_id: ${{ github.event.workflow_run.id ||  github.event.inputs.workflow_run_id }}
+          if_no_artifact_found: ignore
+
+      - name: Extract PR Number
+        id: pr-number
+        run: |
+          if [[ -f pr-number ]]
+          then
+            echo "pr-number=$(<pr-number)" >> $GITHUB_OUTPUT
+          fi
+
+      - uses: dawidd6/action-download-artifact@v2
+        name: "Download Ecosystem Result"
+        id: download-ecosystem-result
+        if: steps.pr-number.outputs.pr-number
+        with:
+          name: ecosystem-result
+          workflow: ci.yaml
+          pr: ${{ steps.pr-number.outputs.pr-number }}
+          path: pr/ecosystem
+          if_no_artifact_found: ignore
+
+      - name: Generate Comment
+        id: generate-comment
+        if: steps.download-ecosystem-result.outputs.found_artifact == 'true'
+        run: |
+          echo '## PR Check Results' >> comment.txt
+
+          echo "### Ecosystem" >> comment.txt
+          cat pr/ecosystem/ecosystem-result >> comment.txt
+          echo "" >> comment.txt
+
+          echo 'comment<<EOF' >> $GITHUB_OUTPUT
+          cat comment.txt >> $GITHUB_OUTPUT
+          echo 'EOF' >> $GITHUB_OUTPUT
+
+      - name: Find Comment
+        uses: peter-evans/find-comment@v2
+        if: steps.generate-comment.outcome == 'success'
+        id: find-comment
+        with:
+          issue-number: ${{ steps.pr-number.outputs.pr-number }}
+          comment-author: "github-actions[bot]"
+          body-includes: PR Check Results
+
+      - name: Create or update comment
+        if: steps.find-comment.outcome == 'success'
+        uses: peter-evans/create-or-update-comment@v3
+        with:
+          comment-id: ${{ steps.find-comment.outputs.comment-id }}
+          issue-number: ${{ steps.pr-number.outputs.pr-number }}
+          body-path: comment.txt
+          edit-mode: replace

.github/workflows/release.yaml

@@ -1,11 +1,21 @@
-name: Release
+name: "[ruff] Release"
 
 on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "The version to tag, without the leading 'v'. If omitted, will initiate a dry run (no uploads)."
+        type: string
+      sha:
+        description: "The full sha of the commit to be released. If omitted, the latest commit on the default branch will be used."
+        default: ""
+        type: string
   pull_request:
-    branches: [main]
-  create:
-    tags:
-      - v*
+    paths:
+      # When we change pyproject.toml, we want to ensure that the maturin builds still work
+      - pyproject.toml
+      # And when we change this workflow itself...
+      - .github/workflows/release.yaml
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -13,148 +23,259 @@ concurrency:
 
 env:
   PACKAGE_NAME: ruff
-  PYTHON_VERSION: "3.7" # to build abi3 wheels
+  PYTHON_VERSION: "3.11"
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CARGO_TERM_COLOR: always
+  RUSTUP_MAX_RETRIES: 10
 
 jobs:
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.sha }}
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build sdist"
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - name: "Test sdist"
+        run: |
+          rustup default $(cat rust-toolchain)
+          pip install dist/${{ env.PACKAGE_NAME }}-*.tar.gz --force-reinstall
+          ruff --help
+          python -m ruff --help
+      - name: "Upload sdist"
+        uses: actions/upload-artifact@v3
+        with:
+          name: wheels
+          path: dist
+
   macos-x86_64:
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.sha }}
       - uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
-      - name: Install Rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          default: true
-      - name: Build wheels - x86_64
-        uses: messense/maturin-action@v1
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build wheels - x86_64"
+        uses: PyO3/maturin-action@v1
         with:
           target: x86_64
-          args: --release --out dist --sdist
-          maturin-version: "v0.13.0"
-      - name: Install built wheel - x86_64
+          args: --release --out dist
+      - name: "Test wheel - x86_64"
         run: |
           pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+          ruff --help
+          python -m ruff --help
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
+      - name: "Archive binary"
+        run: |
+          ARCHIVE_FILE=ruff-x86_64-apple-darwin.tar.gz
+          tar czvf $ARCHIVE_FILE -C target/x86_64-apple-darwin/release ruff
+          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
+      - name: "Upload binary"
+        uses: actions/upload-artifact@v3
+        with:
+          name: binaries
+          path: |
+            *.tar.gz
+            *.sha256
+
   macos-universal:
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.sha }}
       - uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
-      - name: Install Rust toolchain
-        uses: actions-rs/toolchain@v1
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build wheels - universal2"
+        uses: PyO3/maturin-action@v1
         with:
-          toolchain: stable
-          profile: minimal
-          default: true
-      - name: Build wheels - universal2
-        uses: messense/maturin-action@v1
-        with:
-          args: --release --universal2 --out dist
-          maturin-version: "v0.13.0"
-      - name: Install built wheel - universal2
+          args: --release --target universal2-apple-darwin --out dist
+      - name: "Test wheel - universal2"
         run: |
           pip install dist/${{ env.PACKAGE_NAME }}-*universal2.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+          ruff --help
+          python -m ruff --help
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
+      - name: "Archive binary"
+        run: |
+          ARCHIVE_FILE=ruff-aarch64-apple-darwin.tar.gz
+          tar czvf $ARCHIVE_FILE -C target/aarch64-apple-darwin/release ruff
+          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
+      - name: "Upload binary"
+        uses: actions/upload-artifact@v3
+        with:
+          name: binaries
+          path: |
+            *.tar.gz
+            *.sha256
 
   windows:
     runs-on: windows-latest
     strategy:
       matrix:
-        target: [x64, x86]
+        platform:
+          - target: x86_64-pc-windows-msvc
+            arch: x64
+          - target: i686-pc-windows-msvc
+            arch: x86
+          - target: aarch64-pc-windows-msvc
+            arch: x64
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.sha }}
       - uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          architecture: ${{ matrix.target }}
-      - name: Install Rust toolchain
-        uses: actions-rs/toolchain@v1
+          architecture: ${{ matrix.platform.arch }}
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
         with:
-          toolchain: stable
-          profile: minimal
-          default: true
-      - name: Build wheels
-        uses: messense/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
+          target: ${{ matrix.platform.target }}
           args: --release --out dist
-          maturin-version: "v0.13.0"
-      - name: Install built wheel
+      - name: "Test wheel"
+        if: ${{ !startsWith(matrix.platform.target, 'aarch64') }}
         shell: bash
         run: |
           python -m pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+          ruff --help
+          python -m ruff --help
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
+      - name: "Archive binary"
+        shell: bash
+        run: |
+          ARCHIVE_FILE=ruff-${{ matrix.platform.target }}.zip
+          7z a $ARCHIVE_FILE ./target/${{ matrix.platform.target }}/release/ruff.exe
+          sha256sum $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
+      - name: "Upload binary"
+        uses: actions/upload-artifact@v3
+        with:
+          name: binaries
+          path: |
+            *.zip
+            *.sha256
 
   linux:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        target: [x86_64, i686]
+        target:
+          - x86_64-unknown-linux-gnu
+          - i686-unknown-linux-gnu
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.sha }}
       - uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
-      - name: Build wheels
-        uses: messense/maturin-action@v1
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
           manylinux: auto
           args: --release --out dist
-          maturin-version: "v0.13.0"
-      - name: Install built wheel
-        if: matrix.target == 'x86_64'
+      - name: "Test wheel"
+        if: ${{ startsWith(matrix.target, 'x86_64') }}
         run: |
           pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+          ruff --help
+          python -m ruff --help
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
+      - name: "Archive binary"
+        run: |
+          ARCHIVE_FILE=ruff-${{ matrix.target }}.tar.gz
+          tar czvf $ARCHIVE_FILE -C target/${{ matrix.target }}/release ruff
+          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
+      - name: "Upload binary"
+        uses: actions/upload-artifact@v3
+        with:
+          name: binaries
+          path: |
+            *.tar.gz
+            *.sha256
 
   linux-cross:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        target: [aarch64, armv7, s390x, ppc64le, ppc64]
+        platform:
+          - target: aarch64-unknown-linux-gnu
+            arch: aarch64
+            # see https://github.com/astral-sh/ruff/issues/3791
+            # and https://github.com/gnzlbg/jemallocator/issues/170#issuecomment-1503228963
+            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
+          - target: armv7-unknown-linux-gnueabihf
+            arch: armv7
+          - target: s390x-unknown-linux-gnu
+            arch: s390x
+          - target: powerpc64le-unknown-linux-gnu
+            arch: ppc64le
+          - target: powerpc64-unknown-linux-gnu
+            arch: ppc64
+
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.sha }}
       - uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-      - name: Build wheels
-        uses: messense/maturin-action@v1
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
         with:
-          target: ${{ matrix.target }}
+          target: ${{ matrix.platform.target }}
           manylinux: auto
-          args: --no-default-features --release --out dist
-          maturin-version: "v0.13.0"
-      - uses: uraimo/run-on-arch-action@v2.0.5
-        if: matrix.target != 'ppc64'
-        name: Install built wheel
+          docker-options: ${{ matrix.platform.maturin_docker_options }}
+          args: --release --out dist
+      - uses: uraimo/run-on-arch-action@v2
+        if: matrix.platform.arch != 'ppc64'
+        name: Test wheel
         with:
-          arch: ${{ matrix.target }}
+          arch: ${{ matrix.platform.arch }}
           distro: ubuntu20.04
           githubToken: ${{ github.token }}
           install: |
@@ -163,11 +284,24 @@ jobs:
             pip3 install -U pip
           run: |
             pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+            ruff --help
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
+      - name: "Archive binary"
+        run: |
+          ARCHIVE_FILE=ruff-${{ matrix.platform.target }}.tar.gz
+          tar czvf $ARCHIVE_FILE -C target/${{ matrix.platform.target }}/release ruff
+          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
+      - name: "Upload binary"
+        uses: actions/upload-artifact@v3
+        with:
+          name: binaries
+          path: |
+            *.tar.gz
+            *.sha256
 
   musllinux:
     runs-on: ubuntu-latest
@@ -177,19 +311,22 @@ jobs:
           - x86_64-unknown-linux-musl
           - i686-unknown-linux-musl
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.sha }}
       - uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
-      - name: Build wheels
-        uses: messense/maturin-action@v1
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
           manylinux: musllinux_1_2
           args: --release --out dist
-          maturin-version: "v0.13.0"
-      - name: Install built wheel
+      - name: "Test wheel"
         if: matrix.target == 'x86_64-unknown-linux-musl'
         uses: addnab/docker-run-action@v3
         with:
@@ -198,11 +335,25 @@ jobs:
           run: |
             apk add py3-pip
             pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links /io/dist/ --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+            ruff --help
+            python -m ruff --help
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
+      - name: "Archive binary"
+        run: |
+          ARCHIVE_FILE=ruff-${{ matrix.target }}.tar.gz
+          tar czvf $ARCHIVE_FILE -C target/${{ matrix.target }}/release ruff
+          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
+      - name: "Upload binary"
+        uses: actions/upload-artifact@v3
+        with:
+          name: binaries
+          path: |
+            *.tar.gz
+            *.sha256
 
   musllinux-cross:
     runs-on: ubuntu-latest
@@ -211,22 +362,28 @@ jobs:
         platform:
           - target: aarch64-unknown-linux-musl
             arch: aarch64
+            maturin_docker_options: -e JEMALLOC_SYS_WITH_LG_PAGE=16
           - target: armv7-unknown-linux-musleabihf
             arch: armv7
+
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.sha }}
       - uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-      - name: Build wheels
-        uses: messense/maturin-action@v1
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2
           args: --release --out dist
-          maturin-version: "v0.13.0"
-      - uses: uraimo/run-on-arch-action@master
-        name: Install built wheel
+          docker-options: ${{ matrix.platform.maturin_docker_options }}
+      - uses: uraimo/run-on-arch-action@v2
+        name: Test wheel
         with:
           arch: ${{ matrix.platform.arch }}
           distro: alpine_latest
@@ -235,49 +392,59 @@ jobs:
             apk add py3-pip
           run: |
             pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+            ruff check --help
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
-
-  pypy:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-        target: [x86_64, aarch64]
-        python-version:
-          - "3.7"
-          - "3.8"
-          - "3.9"
-        exclude:
-          - os: macos-latest
-            target: aarch64
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: pypy${{ matrix.python-version }}
-      - name: Build wheels
-        uses: messense/maturin-action@v1
-        with:
-          maturin-version: "v0.13.0"
-          target: ${{ matrix.target }}
-          manylinux: auto
-          args: --release --out dist -i pypy${{ matrix.python-version }}
-      - name: Install built wheel
-        if: matrix.target == 'x86_64'
+      - name: "Archive binary"
         run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+          ARCHIVE_FILE=ruff-${{ matrix.platform.target }}.tar.gz
+          tar czvf $ARCHIVE_FILE -C target/${{ matrix.platform.target }}/release ruff
+          shasum -a 256 $ARCHIVE_FILE > $ARCHIVE_FILE.sha256
+      - name: "Upload binary"
+        uses: actions/upload-artifact@v3
         with:
-          name: wheels
-          path: dist
+          name: binaries
+          path: |
+            *.tar.gz
+            *.sha256
 
-  release:
-    name: Release
+  validate-tag:
+    name: Validate tag
+    runs-on: ubuntu-latest
+    # If you don't set an input tag, it's a dry run (no uploads).
+    if: ${{ inputs.tag }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main # We checkout the main branch to check for the commit
+      - name: Check main branch
+        if: ${{ inputs.sha }}
+        run: |
+          # Fetch the main branch since a shallow checkout is used by default
+          git fetch origin main --unshallow
+          if ! git branch --contains ${{ inputs.sha }} | grep -E '(^|\s)main$'; then
+            echo "The specified sha is not on the main branch" >&2
+            exit 1
+          fi
+      - name: Check tag consistency
+        run: |
+          # Switch to the commit we want to release
+          git checkout ${{ inputs.sha }}
+          version=$(grep "version = " pyproject.toml | sed -e 's/version = "\(.*\)"/\1/g')
+          if [ "${{ inputs.tag }}" != "${version}" ]; then
+            echo "The input tag does not match the version from pyproject.toml:" >&2
+            echo "${{ inputs.tag }}" >&2
+            echo "${version}" >&2
+            exit 1
+          else
+            echo "Releasing ${version}"
+          fi
+
+  upload-release:
+    name: Upload to PyPI
     runs-on: ubuntu-latest
     needs:
       - macos-universal
@@ -287,17 +454,84 @@ jobs:
       - linux-cross
       - musllinux
       - musllinux-cross
-      - pypy
-    if: "startsWith(github.ref, 'refs/tags/')"
+      - validate-tag
+    # If you don't set an input tag, it's a dry run (no uploads).
+    if: ${{ inputs.tag }}
+    environment:
+      name: release
+    permissions:
+      # For pypi trusted publishing
+      id-token: write
     steps:
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
         with:
           name: wheels
-      - uses: actions/setup-python@v4
+          path: wheels
       - name: Publish to PyPi
-        env:
-          TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true
+          packages-dir: wheels
+          verbose: true
+
+  tag-release:
+    name: Tag release
+    runs-on: ubuntu-latest
+    needs: upload-release
+    # If you don't set an input tag, it's a dry run (no uploads).
+    if: ${{ inputs.tag }}
+    permissions:
+      # For git tag
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.sha }}
+      - name: git tag
         run: |
-          pip install --upgrade twine
-          twine upload --skip-existing *
+          git config user.email "hey@astral.sh"
+          git config user.name "Ruff Release CI"
+          git tag -m "v${{ inputs.tag }}" "v${{ inputs.tag }}"
+          # If there is duplicate tag, this will fail. The publish to pypi action will have been a noop (due to skip
+          # existing), so we make a non-destructive exit here
+          git push --tags
+
+  publish-release:
+    name: Publish to GitHub
+    runs-on: ubuntu-latest
+    needs: tag-release
+    # If you don't set an input tag, it's a dry run (no uploads).
+    if: ${{ inputs.tag }}
+    permissions:
+      # For GitHub release publishing
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v3
+        with:
+          name: binaries
+          path: binaries
+      - name: "Publish to GitHub"
+        uses: softprops/action-gh-release@v1
+        with:
+          draft: true
+          files: binaries/*
+          tag_name: v${{ inputs.tag }}
+
+  # After the release has been published, we update downstream repositories
+  # This is separate because if this fails the release is still fine, we just need to do some manual workflow triggers
+  update-dependents:
+    name: Update dependents
+    runs-on: ubuntu-latest
+    needs: publish-release
+    steps:
+      - name: "Update pre-commit mirror"
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{ secrets.RUFF_PRE_COMMIT_PAT }}
+          script: |
+            github.rest.actions.createWorkflowDispatch({
+              owner: 'astral-sh',
+              repo: 'ruff-pre-commit',
+              workflow_id: 'main.yml',
+              ref: 'main',
+            })

.gitignore

@@ -1,6 +1,25 @@
-# Local cache
-.ruff_cache
-resources/test/cpython
+# Benchmarking cpython (CONTRIBUTING.md)
+crates/ruff_linter/resources/test/cpython
+# generate_mkdocs.py
+mkdocs.generated.yml
+# check_ecosystem.py
+ruff-old
+github_search*.jsonl
+# update_schemastore.py
+schemastore
+# `maturin develop` and ecosystem_all_check.sh
+.venv*
+# Formatter debugging (crates/ruff_python_formatter/README.md)
+scratch.*
+# Created by `perf` (CONTRIBUTING.md)
+perf.data
+perf.data.old
+# Created by `flamegraph` (CONTRIBUTING.md)
+flamegraph.svg
+# Additional target directories that don't invalidate the main compile cache when changing linker settings,
+# e.g. `CARGO_TARGET_DIR=target-maturin maturin build --release --strip` or
+# `CARGO_TARGET_DIR=target-llvm-lines RUSTFLAGS="-Csymbol-mangling-version=v0" cargo llvm-lines -p ruff --lib`
+/target*
 
 ###
 # Rust.gitignore
@@ -181,3 +200,11 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 .idea/
+.vimspector.json
+
+# Visual Studio Code
+.vscode/
+
+# VIM
+.*.sw?
+.sw?

.markdownlint.yaml

@@ -0,0 +1,15 @@
+# default to true for all rules
+default: true
+
+# MD007/unordered-list-indent
+MD007:
+  indent: 4
+
+# MD033/no-inline-html
+MD033: false
+
+# MD041/first-line-h1
+MD041: false
+
+# MD013/line-length
+MD013: false

.pre-commit-config.yaml

@@ -1,10 +1,71 @@
-repos:
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.87
-    hooks:
-      - id: ruff
+fail_fast: true
 
+exclude: |
+  (?x)^(
+    crates/ruff_linter/resources/.*|
+    crates/ruff_linter/src/rules/.*/snapshots/.*|
+    crates/ruff_cli/resources/.*|
+    crates/ruff_python_formatter/resources/.*|
+    crates/ruff_python_formatter/tests/snapshots/.*|
+    crates/ruff_python_resolver/resources/.*|
+    crates/ruff_python_resolver/tests/snapshots/.*
+  )$
+
+repos:
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.10.1
+    rev: v0.12.1
     hooks:
       - id: validate-pyproject
+
+  - repo: https://github.com/executablebooks/mdformat
+    rev: 0.7.16
+    hooks:
+      - id: mdformat
+        additional_dependencies:
+          - mdformat-mkdocs
+
+  - repo: https://github.com/igorshubovych/markdownlint-cli
+    rev: v0.33.0
+    hooks:
+      - id: markdownlint-fix
+
+  - repo: https://github.com/crate-ci/typos
+    rev: v1.14.12
+    hooks:
+      - id: typos
+
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        entry: cargo fmt --
+        language: system
+        types: [rust]
+        pass_filenames: false # This makes it a lot faster
+      - id: ruff
+        name: ruff
+        entry: cargo run --bin ruff -- check --no-cache --force-exclude --fix --exit-non-zero-on-fix
+        language: system
+        types_or: [python, pyi]
+        require_serial: true
+        exclude: |
+          (?x)^(
+            crates/ruff_linter/resources/.*|
+            crates/ruff_python_formatter/resources/.*
+          )$
+
+  # Black
+  - repo: https://github.com/psf/black
+    rev: 23.1.0
+    hooks:
+      - id: black
+
+  # Prettier
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v3.0.0
+    hooks:
+      - id: prettier
+        types: [yaml]
+
+ci:
+  skip: [cargo-fmt, dev-generate-all]

BREAKING_CHANGES.md

@@ -0,0 +1,302 @@
+# Breaking Changes
+
+## 0.0.288
+
+### Remove support for emoji identifiers ([#7212](https://github.com/astral-sh/ruff/pull/7212))
+
+Previously, Ruff supported the non-standard compliant emoji identifiers e.g. `📦 = 1`.
+We decided to remove this non-standard language extension, and Ruff now reports syntax errors for emoji identifiers in your code, the same as CPython.
+
+### Improved GitLab fingerprints ([#7203](https://github.com/astral-sh/ruff/pull/7203))
+
+GitLab uses fingerprints to identify new, existing, or fixed violations. Previously, Ruff included the violation's position in the fingerprint. Using the location has the downside that changing any code before the violation causes the fingerprint to change, resulting in GitLab reporting one fixed and one new violation even though it is a pre-existing violation.
+
+Ruff now uses a more stable location-agnostic fingerprint to minimize that existing violations incorrectly get marked as fixed and re-reported as new violations.
+
+Expect GitLab to report each pre-existing violation in your project as fixed and a new violation in your Ruff upgrade PR.
+
+## 0.0.283 / 0.284
+
+### The target Python version now defaults to 3.8 instead of 3.10 ([#6397](https://github.com/astral-sh/ruff/pull/6397))
+
+Previously, when a target Python version was not specified, Ruff would use a default of Python 3.10. However, it is safer to default to an _older_ Python version to avoid assuming the availability of new features. We now default to the oldest supported Python version which is currently Python 3.8.
+
+(We still support Python 3.7 but since [it has reached EOL](https://devguide.python.org/versions/#unsupported-versions) we've decided not to make it the default here.)
+
+Note this change was announced in 0.0.283 but not active until 0.0.284.
+
+## 0.0.277
+
+### `.ipynb_checkpoints`, `.pyenv`, `.pytest_cache`, and `.vscode` are now excluded by default ([#5513](https://github.com/astral-sh/ruff/pull/5513))
+
+Ruff maintains a list of default exclusions, which now consists of the following patterns:
+
+- `.bzr`
+- `.direnv`
+- `.eggs`
+- `.git`
+- `.git-rewrite`
+- `.hg`
+- `.ipynb_checkpoints`
+- `.mypy_cache`
+- `.nox`
+- `.pants.d`
+- `.pyenv`
+- `.pytest_cache`
+- `.pytype`
+- `.ruff_cache`
+- `.svn`
+- `.tox`
+- `.venv`
+- `.vscode`
+- `__pypackages__`
+- `_build`
+- `buck-out`
+- `build`
+- `dist`
+- `node_modules`
+- `venv`
+
+Previously, the `.ipynb_checkpoints`, `.pyenv`, `.pytest_cache`, and `.vscode` directories were not
+excluded by default. This change brings Ruff's default exclusions in line with other tools like
+Black.
+
+## 0.0.276
+
+### The `keep-runtime-typing` setting has been reinstated ([#5470](https://github.com/astral-sh/ruff/pull/5470))
+
+The `keep-runtime-typing` setting has been reinstated with revised semantics. This setting was
+removed in [#4427](https://github.com/astral-sh/ruff/pull/4427), as it was equivalent to ignoring
+the `UP006` and `UP007` rules via Ruff's standard `ignore` mechanism.
+
+Taking `UP006` (rewrite `List[int]` to `list[int]`) as an example, the setting now behaves as
+follows:
+
+- On Python 3.7 and Python 3.8, setting `keep-runtime-typing = true` will cause Ruff to ignore
+    `UP006` violations, even if `from __future__ import annotations` is present in the file.
+    While such annotations are valid in Python 3.7 and Python 3.8 when combined with
+    `from __future__ import annotations`, they aren't supported by libraries like Pydantic and
+    FastAPI, which rely on runtime type checking.
+- On Python 3.9 and above, the setting has no effect, as `list[int]` is a valid type annotation,
+    and libraries like Pydantic and FastAPI support it without issue.
+
+In short: `keep-runtime-typing` can be used to ensure that Ruff doesn't introduce type annotations
+that are not supported at runtime by the current Python version, which are unsupported by libraries
+like Pydantic and FastAPI.
+
+Note that this is not a breaking change, but is included here to complement the previous removal
+of `keep-runtime-typing`.
+
+## 0.0.268
+
+### The `keep-runtime-typing` setting has been removed ([#4427](https://github.com/astral-sh/ruff/pull/4427))
+
+Enabling the `keep-runtime-typing` option, located under the `pyupgrade` section, is equivalent
+to ignoring the `UP006` and `UP007` rules via Ruff's standard `ignore` mechanism. As there's no
+need for a dedicated setting to disable these rules, the `keep-runtime-typing` option has been
+removed.
+
+## 0.0.267
+
+### `update-check` is no longer a valid configuration option ([#4313](https://github.com/astral-sh/ruff/pull/4313))
+
+The `update-check` functionality was deprecated in [#2530](https://github.com/astral-sh/ruff/pull/2530),
+in that the behavior itself was removed, and Ruff was changed to warn when that option was enabled.
+
+Now, Ruff will throw an error when `update-check` is provided via a configuration file (e.g.,
+`update-check = false`) or through the command-line, since it has no effect. Users should remove
+this option from their configuration.
+
+## 0.0.265
+
+### `--fix-only` now exits with a zero exit code, unless `--exit-non-zero-on-fix` is specified ([#4146](https://github.com/astral-sh/ruff/pull/4146))
+
+Previously, `--fix-only` would exit with a non-zero exit code if any fixes were applied. This
+behavior was inconsistent with `--fix`, and further, meant that `--exit-non-zero-on-fix` was
+effectively ignored when `--fix-only` was specified.
+
+Now, `--fix-only` will exit with a zero exit code, unless `--exit-non-zero-on-fix` is specified,
+in which case it will exit with a non-zero exit code if any fixes were applied.
+
+## 0.0.260
+
+### Fixes are now represented as a list of edits ([#3709](https://github.com/astral-sh/ruff/pull/3709))
+
+Previously, Ruff represented each fix as a single edit, which prohibited Ruff from automatically
+fixing violations that required multiple edits across a file. As such, Ruff now represents each
+fix as a list of edits.
+
+This primarily affects the JSON API. Ruff's JSON representation used to represent the `fix` field as
+a single edit, like so:
+
+```json
+{
+    "message": "Remove unused import: `sys`",
+    "content": "",
+    "location": {"row": 1, "column": 0},
+    "end_location": {"row": 2, "column": 0}
+}
+```
+
+The updated representation instead includes a list of edits:
+
+```json
+{
+    "message": "Remove unused import: `sys`",
+    "edits": [
+        {
+            "content": "",
+            "location": {"row": 1, "column": 0},
+            "end_location": {"row": 2, "column": 0},
+        }
+    ]
+}
+```
+
+## 0.0.246
+
+### `multiple-statements-on-one-line-def` (`E704`) was removed ([#2773](https://github.com/astral-sh/ruff/pull/2773))
+
+This rule was introduced in v0.0.245. However, it turns out that pycodestyle and Flake8 ignore this
+rule by default, as it is not part of PEP 8. As such, we've removed it from Ruff.
+
+## 0.0.245
+
+### Ruff's public `check` method was removed ([#2709](https://github.com/astral-sh/ruff/pull/2709))
+
+Previously, Ruff exposed a `check` method as a public Rust API. This method was used by few,
+if any clients, and was not well documented or supported. As such, it has been removed, with
+the intention of adding a stable public API in the future.
+
+## 0.0.238
+
+### `select`, `extend-select`, `ignore`, and `extend-ignore` have new semantics ([#2312](https://github.com/astral-sh/ruff/pull/2312))
+
+Previously, the interplay between `select` and its related options could lead to unexpected
+behavior. For example, `ruff --select E501 --ignore ALL` and `ruff --select E501 --extend-ignore ALL`
+behaved differently. (See [#2312](https://github.com/astral-sh/ruff/pull/2312) for more
+examples.)
+
+When Ruff determines the enabled rule set, it has to reconcile `select` and `ignore` from a variety
+of sources, including the current `pyproject.toml`, any inherited `pyproject.toml` files, and the
+CLI.
+
+The new semantics are such that Ruff uses the "highest-priority" `select` as the basis for the rule
+set, and then applies any `extend-select`, `ignore`, and `extend-ignore` adjustments. CLI options
+are given higher priority than `pyproject.toml` options, and the current `pyproject.toml` file is
+given higher priority than any inherited `pyproject.toml` files.
+
+`extend-select` and `extend-ignore` are no longer given "top priority"; instead, they merely append
+to the `select` and `ignore` lists, as in Flake8.
+
+This change is largely backwards compatible -- most users should experience no change in behavior.
+However, as an example of a breaking change, consider the following:
+
+```toml
+[tool.ruff]
+ignore = ["F401"]
+```
+
+Running `ruff --select F` would previously have enabled all `F` rules, apart from `F401`. Now, it
+will enable all `F` rules, including `F401`, as the command line's `--select` resets the resolution.
+
+### `remove-six-compat` (`UP016`) has been removed ([#2332](https://github.com/astral-sh/ruff/pull/2332))
+
+The `remove-six-compat` rule has been removed. This rule was only useful for one-time Python 2-to-3
+upgrades.
+
+## 0.0.237
+
+### `--explain`, `--clean`, and `--generate-shell-completion` are now subcommands ([#2190](https://github.com/astral-sh/ruff/pull/2190))
+
+`--explain`, `--clean`, and `--generate-shell-completion` are now implemented as subcommands:
+
+```console
+ruff .         # Still works! And will always work.
+ruff check .   # New! Also works.
+
+ruff --explain E402   # Still works.
+ruff rule E402        # New! Also works. (And preferred.)
+
+# Oops! The command has to come first.
+ruff --format json --explain E402   # No longer works.
+ruff --explain E402 --format json   # Still works!
+ruff rule E402   --format json      # Works! (And preferred.)
+```
+
+This change is largely backwards compatible -- most users should experience
+no change in behavior. However, please note the following exceptions:
+
+- Subcommands will now fail when invoked with unsupported arguments, instead
+    of silently ignoring them. For example, the following will now fail:
+
+    ```console
+    ruff --clean --respect-gitignore
+    ```
+
+    (the `clean` command doesn't support `--respect-gitignore`.)
+
+- The semantics of `ruff <arg>` have changed slightly when `<arg>` is a valid subcommand.
+    For example, prior to this release, running `ruff rule` would run `ruff` over a file or
+    directory called `rule`. Now, `ruff rule` would invoke the `rule` subcommand. This should
+    only impact projects with files or directories named `rule`, `check`, `explain`, `clean`,
+    or `generate-shell-completion`.
+
+- Scripts that invoke ruff should supply `--` before any positional arguments.
+    (The semantics of `ruff -- <arg>` have not changed.)
+
+- `--explain` previously treated `--format grouped` as a synonym for `--format text`.
+    This is no longer supported; instead, use `--format text`.
+
+## 0.0.226
+
+### `misplaced-comparison-constant` (`PLC2201`) was deprecated in favor of `SIM300` ([#1980](https://github.com/astral-sh/ruff/pull/1980))
+
+These two rules contain (nearly) identical logic. To deduplicate the rule set, we've upgraded
+`SIM300` to handle a few more cases, and deprecated `PLC2201` in favor of `SIM300`.
+
+## 0.0.225
+
+### `@functools.cache` rewrites have been moved to a standalone rule (`UP033`) ([#1938](https://github.com/astral-sh/ruff/pull/1938))
+
+Previously, `UP011` handled both `@functools.lru_cache()`-to-`@functools.lru_cache` conversions,
+_and_ `@functools.lru_cache(maxsize=None)`-to-`@functools.cache` conversions. The latter has been
+moved out to its own rule (`UP033`). As such, some `# noqa: UP011` comments may need to be updated
+to reflect the change in rule code.
+
+## 0.0.222
+
+### `--max-complexity` has been removed from the CLI ([#1877](https://github.com/astral-sh/ruff/pull/1877))
+
+The McCabe plugin's `--max-complexity` setting has been removed from the CLI, for consistency with
+the treatment of other, similar settings.
+
+To set the maximum complexity, use the `max-complexity` property in your `pyproject.toml` file,
+like so:
+
+```toml
+[tool.ruff.mccabe]
+max-complexity = 10
+```
+
+## 0.0.181
+
+### Files excluded by `.gitignore` are now ignored ([#1234](https://github.com/astral-sh/ruff/pull/1234))
+
+Ruff will now avoid checking files that are excluded by `.ignore`, `.gitignore`,
+`.git/info/exclude`, and global `gitignore` files. This behavior is powered by the [`ignore`](https://docs.rs/ignore/latest/ignore/struct.WalkBuilder.html#ignore-rules)
+crate, and is applied in addition to Ruff's built-in `exclude` system.
+
+To disable this behavior, set `respect-gitignore = false` in your `pyproject.toml` file.
+
+Note that hidden files (i.e., files and directories prefixed with a `.`) are _not_ ignored by
+default.
+
+## 0.0.178
+
+### Configuration files are now resolved hierarchically ([#1190](https://github.com/astral-sh/ruff/pull/1190))
+
+`pyproject.toml` files are now resolved hierarchically, such that for each Python file, we find
+the first `pyproject.toml` file in its path, and use that to determine its lint settings.
+
+See the [documentation](https://docs.astral.sh/ruff/configuration/#python-file-discovery) for more.

CODE_OF_CONDUCT.md

@@ -1,5 +1,17 @@
 # Contributor Covenant Code of Conduct
 
+- [Our Pledge](#our-pledge)
+- [Our Standards](#our-standards)
+- [Enforcement Responsibilities](#enforcement-responsibilities)
+- [Scope](#scope)
+- [Enforcement](#enforcement)
+- [Enforcement Guidelines](#enforcement-guidelines)
+    - [1. Correction](#1-correction)
+    - [2. Warning](#2-warning)
+    - [3. Temporary Ban](#3-temporary-ban)
+    - [4. Permanent Ban](#4-permanent-ban)
+- [Attribution](#attribution)
+
 ## Our Pledge
 
 We as members, contributors, and leaders pledge to make participation in our
@@ -17,24 +29,24 @@ diverse, inclusive, and healthy community.
 Examples of behavior that contributes to a positive environment for our
 community include:
 
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
+    and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the
+    overall community
 
 Examples of unacceptable behavior include:
 
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
+- The use of sexualized language or imagery, and sexual attention or
+    advances of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email
+    address, without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+    professional setting
 
 ## Enforcement Responsibilities
 
@@ -106,7 +118,7 @@ Violating these terms may lead to a permanent ban.
 ### 4. Permanent Ban
 
 **Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
+standards, including sustained inappropriate behavior, harassment of an
 individual, or aggression toward or disparagement of classes of individuals.
 
 **Consequence**: A permanent ban from any sort of public interaction within
@@ -115,14 +127,12 @@ the community.
 ## Attribution
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+version 2.0, available [here](https://www.contributor-covenant.org/version/2/0/code_of_conduct.html).
 
 Community Impact Guidelines were inspired by [Mozilla's code of conduct
 enforcement ladder](https://github.com/mozilla/diversity).
 
-[homepage]: https://www.contributor-covenant.org
+For answers to common questions about this code of conduct, see the [FAQ](https://www.contributor-covenant.org/faq).
+Translations are available [here](https://www.contributor-covenant.org/translations).
 
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.
+[homepage]: https://www.contributor-covenant.org

CONTRIBUTING.md

@@ -1,17 +1,60 @@
-# Contributing to ruff
+# Contributing to Ruff
 
-Welcome! We're happy to have you here. Thank you in advance for your contribution to ruff.
+Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.
 
-## The basics
+- [The Basics](#the-basics)
+    - [Prerequisites](#prerequisites)
+    - [Development](#development)
+    - [Project Structure](#project-structure)
+    - [Example: Adding a new lint rule](#example-adding-a-new-lint-rule)
+        - [Rule naming convention](#rule-naming-convention)
+        - [Rule testing: fixtures and snapshots](#rule-testing-fixtures-and-snapshots)
+    - [Example: Adding a new configuration option](#example-adding-a-new-configuration-option)
+- [MkDocs](#mkdocs)
+- [Release Process](#release-process)
+    - [Creating a new release](#creating-a-new-release)
+- [Ecosystem CI](#ecosystem-ci)
+- [Benchmarking and Profiling](#benchmarking-and-profiling)
+    - [CPython Benchmark](#cpython-benchmark)
+    - [Microbenchmarks](#microbenchmarks)
+        - [Benchmark-driven Development](#benchmark-driven-development)
+        - [PR Summary](#pr-summary)
+        - [Tips](#tips)
+    - [Profiling Projects](#profiling-projects)
+        - [Linux](#linux)
+        - [Mac](#mac)
+- [`cargo dev`](#cargo-dev)
+- [Subsystems](#subsystems)
+    - [Compilation Pipeline](#compilation-pipeline)
 
-ruff welcomes contributions in the form of Pull Requests. For small changes (e.g., bug fixes), feel
-free to submit a PR. For larger changes (e.g., new lint rules, new functionality, new configuration
-options), consider submitting an [Issue](https://github.com/charliermarsh/ruff/issues) outlining
-your proposed change.
+## The Basics
+
+Ruff welcomes contributions in the form of Pull Requests.
+
+For small changes (e.g., bug fixes), feel free to submit a PR.
+
+For larger changes (e.g., new lint rules, new functionality, new configuration options), consider
+creating an [**issue**](https://github.com/astral-sh/ruff/issues) outlining your proposed change.
+You can also join us on [**Discord**](https://discord.gg/c9MhzV8aU5) to discuss your idea with the
+community. We've labeled [beginner-friendly tasks](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)
+in the issue tracker, along with [bugs](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3Abug)
+and [improvements](https://github.com/astral-sh/ruff/issues?q=is%3Aissue+is%3Aopen+label%3Aaccepted)
+that are ready for contributions.
+
+If you're looking for a place to start, we recommend implementing a new lint rule (see:
+[_Adding a new lint rule_](#example-adding-a-new-lint-rule), which will allow you to learn from and
+pattern-match against the examples in the existing codebase. Many lint rules are inspired by
+existing Python plugins, which can be used as a reference implementation.
+
+As a concrete example: consider taking on one of the rules from the [`flake8-pyi`](https://github.com/astral-sh/ruff/issues/848)
+plugin, and looking to the originating [Python source](https://github.com/PyCQA/flake8-pyi) for
+guidance.
+
+If you have suggestions on how we might improve the contributing documentation, [let us know](https://github.com/astral-sh/ruff/discussions/5693)!
 
 ### Prerequisites
 
-ruff is written in Rust (1.63.0). You'll need to install the
+Ruff is written in Rust. You'll need to install the
 [Rust toolchain](https://www.rust-lang.org/tools/install) for development.
 
 You'll also need [Insta](https://insta.rs/docs/) to update snapshot tests:
@@ -20,92 +63,818 @@ You'll also need [Insta](https://insta.rs/docs/) to update snapshot tests:
 cargo install cargo-insta
 ```
 
-### Development
-
-After cloning the repository, run ruff locally with:
+and pre-commit to run some validation checks:
 
 ```shell
-cargo run resources/test/fixtures --no-cache
+pipx install pre-commit  # or `pip install pre-commit` if you have a virtualenv
 ```
 
-Prior to opening a pull request, ensure that your code has been auto-formatted, and that it passes
-both the lint and test validation checks:
+You can optionally install pre-commit hooks to automatically run the validation checks
+when making a commit:
 
 ```shell
-cargo fmt     # Auto-formatting...
-cargo clippy  # Linting...
-cargo test    # Testing...
+pre-commit install
+```
+
+### Development
+
+After cloning the repository, run Ruff locally from the repository root with:
+
+```shell
+cargo run -p ruff_cli -- check /path/to/file.py --no-cache
+```
+
+Prior to opening a pull request, ensure that your code has been auto-formatted,
+and that it passes both the lint and test validation checks:
+
+```shell
+cargo clippy --workspace --all-targets --all-features -- -D warnings  # Rust linting
+RUFF_UPDATE_SCHEMA=1 cargo test  # Rust testing and updating ruff.schema.json
+pre-commit run --all-files --show-diff-on-failure  # Rust and Python formatting, Markdown and Python linting, etc.
 ```
 
 These checks will run on GitHub Actions when you open your Pull Request, but running them locally
 will save you time and expedite the merge process.
 
+Note that many code changes also require updating the snapshot tests, which is done interactively
+after running `cargo test` like so:
+
+```shell
+cargo insta review
+```
+
 Your Pull Request will be reviewed by a maintainer, which may involve a few rounds of iteration
 prior to merging.
 
+### Project Structure
+
+Ruff is structured as a monorepo with a [flat crate structure](https://matklad.github.io/2021/08/22/large-rust-workspaces.html),
+such that all crates are contained in a flat `crates` directory.
+
+The vast majority of the code, including all lint rules, lives in the `ruff` crate (located at
+`crates/ruff_linter`). As a contributor, that's the crate that'll be most relevant to you.
+
+At time of writing, the repository includes the following crates:
+
+- `crates/ruff_linter`: library crate containing all lint rules and the core logic for running them.
+    If you're working on a rule, this is the crate for you.
+- `crates/ruff_benchmark`: binary crate for running micro-benchmarks.
+- `crates/ruff_cache`: library crate for caching lint results.
+- `crates/ruff_cli`: binary crate containing Ruff's command-line interface.
+- `crates/ruff_dev`: binary crate containing utilities used in the development of Ruff itself (e.g.,
+    `cargo dev generate-all`), see the [`cargo dev`](#cargo-dev) section below.
+- `crates/ruff_diagnostics`: library crate for the rule-independent abstractions in the lint
+    diagnostics APIs.
+- `crates/ruff_formatter`: library crate for language agnostic code formatting logic based on an
+    intermediate representation. The backend for `ruff_python_formatter`.
+- `crates/ruff_index`: library crate inspired by `rustc_index`.
+- `crates/ruff_macros`: proc macro crate containing macros used by Ruff.
+- `crates/ruff_notebook`: library crate for parsing and manipulating Jupyter notebooks.
+- `crates/ruff_python_ast`: library crate containing Python-specific AST types and utilities.
+- `crates/ruff_python_codegen`: library crate containing utilities for generating Python source code.
+- `crates/ruff_python_formatter`: library crate implementing the Python formatter. Emits an
+    intermediate representation for each node, which `ruff_formatter` prints based on the configured
+    line length.
+- `crates/ruff_python_semantic`: library crate containing Python-specific semantic analysis logic,
+    including Ruff's semantic model. Used to resolve queries like "What import does this variable
+    refer to?"
+- `crates/ruff_python_stdlib`: library crate containing Python-specific standard library data, e.g.
+    the names of all built-in exceptions and which standard library types are immutable.
+- `crates/ruff_python_trivia`: library crate containing Python-specific trivia utilities (e.g.,
+    for analyzing indentation, newlines, etc.).
+- `crates/ruff_python_parser`: library crate containing the Python parser.
+- `crates/ruff_wasm`: library crate for exposing Ruff as a WebAssembly module. Powers the
+    [Ruff Playground](https://play.ruff.rs/).
+
 ### Example: Adding a new lint rule
 
-There are three phases to adding a new lint rule:
+At a high level, the steps involved in adding a new lint rule are as follows:
 
-1. Define the rule in `src/checks.rs`.
-2. Define the _logic_ for triggering the rule in `src/check_ast.rs` (for AST-based checks)
-   or `src/check_lines.rs` (for text-based checks).
-3. Add a test fixture.
+1. Determine a name for the new rule as per our [rule naming convention](#rule-naming-convention)
+    (e.g., `AssertFalse`, as in, "allow `assert False`").
 
-To define the rule, open up `src/checks.rs`. You'll need to define both a `CheckCode` and
-`CheckKind`. As an example, you can grep for `E402` and `ModuleImportNotAtTopOfFile`, and follow the
-pattern implemented therein.
+1. Create a file for your rule (e.g., `crates/ruff_linter/src/rules/flake8_bugbear/rules/assert_false.rs`).
 
-To trigger the rule, you'll likely want to augment the logic in `src/check_ast.rs`, which defines
-the Python AST visitor, responsible for iterating over the abstract syntax tree and collecting
-lint-rule violations as it goes. Grep for the `Check::new` invocations to understand how other,
-similar rules are implemented.
+1. In that file, define a violation struct (e.g., `pub struct AssertFalse`). You can grep for
+    `#[violation]` to see examples.
 
-To add a test fixture, create a file under `resources/test/fixtures`, named to match the `CheckCode`
-you defined earlier (e.g., `E402.py`). This file should contain a variety of violations and
-non-violations designed to evaluate and demonstrate the behavior of your lint rule. Run ruff locally
-with (e.g.) `cargo run resources/test/fixtures/E402.py`. Once you're satisfied with the output,
-codify the behavior as a snapshot test by adding a new function to the `mod tests` section of
-`src/linter.rs`, like so:
+1. In that file, define a function that adds the violation to the diagnostic list as appropriate
+    (e.g., `pub(crate) fn assert_false`) based on whatever inputs are required for the rule (e.g.,
+    an `ast::StmtAssert` node).
 
-```rust
-#[test]
-fn e402() -> Result<()> {
-    let mut checks = check_path(
-        Path::new("./resources/test/fixtures/E402.py"),
-        &settings::Settings::for_rule(CheckCode::E402),
-        &fixer::Mode::Generate,
-    )?;
-    checks.sort_by_key(|check| check.location);
-    insta::assert_yaml_snapshot!(checks);
-    Ok(())
-}
-```
+1. Define the logic for invoking the diagnostic in `crates/ruff_linter/src/checkers/ast/analyze` (for
+    AST-based rules), `crates/ruff_linter/src/checkers/tokens.rs` (for token-based rules),
+    `crates/ruff_linter/src/checkers/physical_lines.rs` (for text-based rules),
+    `crates/ruff_linter/src/checkers/filesystem.rs` (for filesystem-based rules), etc. For AST-based rules,
+    you'll likely want to modify `analyze/statement.rs` (if your rule is based on analyzing
+    statements, like imports) or `analyze/expression.rs` (if your rule is based on analyzing
+    expressions, like function calls).
 
-Then, run `cargo test`. Your test will fail, but you'll be prompted to follow-up with
-`cargo insta review`. Accept the generated snapshot, then commit the snapshot file alongside the
-rest of your changes.
+1. Map the violation struct to a rule code in `crates/ruff_linter/src/codes.rs` (e.g., `B011`).
+
+1. Add proper [testing](#rule-testing-fixtures-and-snapshots) for your rule.
+
+1. Update the generated files (documentation and generated code).
+
+To trigger the violation, you'll likely want to augment the logic in `crates/ruff_linter/src/checkers/ast.rs`
+to call your new function at the appropriate time and with the appropriate inputs. The `Checker`
+defined therein is a Python AST visitor, which iterates over the AST, building up a semantic model,
+and calling out to lint rule analyzer functions as it goes.
+
+If you need to inspect the AST, you can run `cargo dev print-ast` with a Python file. Grep
+for the `Diagnostic::new` invocations to understand how other, similar rules are implemented.
+
+Once you're satisfied with your code, add tests for your rule. See [rule testing](#rule-testing-fixtures-and-snapshots)
+for more details.
+
+Finally, regenerate the documentation and other generated assets (like our JSON Schema) with:
+`cargo dev generate-all`.
+
+#### Rule naming convention
+
+Like Clippy, Ruff's rule names should make grammatical and logical sense when read as "allow
+${rule}" or "allow ${rule} items", as in the context of suppression comments.
+
+For example, `AssertFalse` fits this convention: it flags `assert False` statements, and so a
+suppression comment would be framed as "allow `assert False`".
+
+As such, rule names should...
+
+- Highlight the pattern that is being linted against, rather than the preferred alternative.
+    For example, `AssertFalse` guards against `assert False` statements.
+
+- _Not_ contain instructions on how to fix the violation, which instead belong in the rule
+    documentation and the `autofix_title`.
+
+- _Not_ contain a redundant prefix, like `Disallow` or `Banned`, which are already implied by the
+    convention.
+
+When re-implementing rules from other linters, we prioritize adhering to this convention over
+preserving the original rule name.
+
+#### Rule testing: fixtures and snapshots
+
+To test rules, Ruff uses snapshots of Ruff's output for a given file (fixture). Generally, there
+will be one file per rule (e.g., `E402.py`), and each file will contain all necessary examples of
+both violations and non-violations. `cargo insta review` will generate a snapshot file containing
+Ruff's output for each fixture, which you can then commit alongside your changes.
+
+Once you've completed the code for the rule itself, you can define tests with the following steps:
+
+1. Add a Python file to `crates/ruff_linter/resources/test/fixtures/[linter]` that contains the code you
+    want to test. The file name should match the rule name (e.g., `E402.py`), and it should include
+    examples of both violations and non-violations.
+
+1. Run Ruff locally against your file and verify the output is as expected. Once you're satisfied
+    with the output (you see the violations you expect, and no others), proceed to the next step.
+    For example, if you're adding a new rule named `E402`, you would run:
+
+    ```shell
+    cargo run -p ruff_cli -- check crates/ruff_linter/resources/test/fixtures/pycodestyle/E402.py --no-cache --select E402
+    ```
+
+    **Note:** Only a subset of rules are enabled by default. When testing a new rule, ensure that
+    you activate it by adding `--select ${rule_code}` to the command.
+
+1. Add the test to the relevant `crates/ruff_linter/src/rules/[linter]/mod.rs` file. If you're contributing
+    a rule to a pre-existing set, you should be able to find a similar example to pattern-match
+    against. If you're adding a new linter, you'll need to create a new `mod.rs` file (see,
+    e.g., `crates/ruff_linter/src/rules/flake8_bugbear/mod.rs`)
+
+1. Run `cargo test`. Your test will fail, but you'll be prompted to follow-up
+    with `cargo insta review`. Run `cargo insta review`, review and accept the generated snapshot,
+    then commit the snapshot file alongside the rest of your changes.
+
+1. Run `cargo test` again to ensure that your test passes.
 
 ### Example: Adding a new configuration option
 
-ruff's user-facing settings live in two places: first, the command-line options defined with
-[clap](https://docs.rs/clap/latest/clap/) via the `Cli` struct in `src/main.rs`; and second, the
-`Config` struct defined `src/pyproject.rs`, which is responsible for extracting user-defined
-settings from a `pyproject.toml` file.
+Ruff's user-facing settings live in a few different places.
 
-Ultimately, these two sources of configuration are merged into the `Settings` struct defined
-in `src/settings.rs`, which is then threaded through the codebase.
+First, the command-line options are defined via the `Args` struct in `crates/ruff_cli/src/args.rs`.
 
-To add a new configuration option, you'll likely want to _both_ add a CLI option to `src/main.rs`
-_and_ a `pyproject.toml` parameter to `src/pyproject.rs`. If you want to pattern-match against an
-existing example, grep for `dummy_variable_rgx`, which defines a regular expression to match against
-acceptable unused variables (e.g., `_`).
+Second, the `pyproject.toml` options are defined in `crates/ruff_workspace/src/options.rs` (via the
+`Options` struct), `crates/ruff_workspace/src/configuration.rs` (via the `Configuration` struct),
+and `crates/ruff_workspace/src/settings.rs` (via the `Settings` struct), which then includes
+the `LinterSettings` struct as a field.
 
-## Release process
+These represent, respectively: the schema used to parse the `pyproject.toml` file; an internal,
+intermediate representation; and the final, internal representation used to power Ruff.
 
-As of now, ruff has an ad hoc release process: releases are cut with high frequency via GitHub
+To add a new configuration option, you'll likely want to modify these latter few files (along with
+`arg.rs`, if appropriate). If you want to pattern-match against an existing example, grep for
+`dummy_variable_rgx`, which defines a regular expression to match against acceptable unused
+variables (e.g., `_`).
+
+Note that plugin-specific configuration options are defined in their own modules (e.g.,
+`Settings` in `crates/ruff_linter/src/flake8_unused_arguments/settings.rs` coupled with
+`Flake8UnusedArgumentsOptions` in `crates/ruff_workspace/src/options.rs`).
+
+Finally, regenerate the documentation and generated code with `cargo dev generate-all`.
+
+## MkDocs
+
+To preview any changes to the documentation locally:
+
+1. Install the [Rust toolchain](https://www.rust-lang.org/tools/install).
+
+1. Install MkDocs and Material for MkDocs with:
+
+    ```shell
+    pip install -r docs/requirements.txt
+    ```
+
+1. Generate the MkDocs site with:
+
+    ```shell
+    python scripts/generate_mkdocs.py
+    ```
+
+1. Run the development server with:
+
+    ```shell
+    # For contributors.
+    mkdocs serve -f mkdocs.generated.yml
+
+    # For members of the Astral org, which has access to MkDocs Insiders via sponsorship.
+    mkdocs serve -f mkdocs.insiders.yml
+    ```
+
+The documentation should then be available locally at
+[http://127.0.0.1:8000/docs/](http://127.0.0.1:8000/docs/).
+
+## Release Process
+
+As of now, Ruff has an ad hoc release process: releases are cut with high frequency via GitHub
 Actions, which automatically generates the appropriate wheels across architectures and publishes
 them to [PyPI](https://pypi.org/project/ruff/).
 
-ruff follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
+Ruff follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
 even patch releases may contain [non-backwards-compatible changes](https://semver.org/#spec-item-4).
+
+### Creating a new release
+
+1. Update the version with `rg 0.0.269 --files-with-matches | xargs sed -i 's/0.0.269/0.0.270/g'`
+1. Update `BREAKING_CHANGES.md`
+1. Create a PR with the version and `BREAKING_CHANGES.md` updated
+1. Merge the PR
+1. Run the release workflow with the version number (without starting `v`) as input. Make sure
+    main has your merged PR as last commit
+1. The release workflow will do the following:
+    1. Build all the assets. If this fails (even though we tested in step 4), we haven't tagged or
+        uploaded anything, you can restart after pushing a fix.
+    1. Upload to PyPI.
+    1. Create and push the Git tag (as extracted from `pyproject.toml`). We create the Git tag only
+        after building the wheels and uploading to PyPI, since we can't delete or modify the tag ([#4468](https://github.com/charliermarsh/ruff/issues/4468)).
+    1. Attach artifacts to draft GitHub release
+    1. Trigger downstream repositories. This can fail non-catastrophically, as we can run any
+        downstream jobs manually if needed.
+1. Create release notes in GitHub UI and promote from draft.
+1. If needed, [update the schemastore](https://github.com/charliermarsh/ruff/blob/main/scripts/update_schemastore.py)
+1. If needed, update the `ruff-lsp` and `ruff-vscode` repositories.
+
+## Ecosystem CI
+
+GitHub Actions will run your changes against a number of real-world projects from GitHub and
+report on any diagnostic differences. You can also run those checks locally via:
+
+```shell
+python scripts/check_ecosystem.py path/to/your/ruff path/to/older/ruff
+```
+
+You can also run the Ecosystem CI check in a Docker container across a larger set of projects by
+downloading the [`known-github-tomls.json`](https://github.com/akx/ruff-usage-aggregate/blob/master/data/known-github-tomls.jsonl)
+as `github_search.jsonl` and following the instructions in [scripts/Dockerfile.ecosystem](https://github.com/astral-sh/ruff/blob/main/scripts/Dockerfile.ecosystem).
+Note that this check will take a while to run.
+
+## Benchmarking and Profiling
+
+We have several ways of benchmarking and profiling Ruff:
+
+- Our main performance benchmark comparing Ruff with other tools on the CPython codebase
+- Microbenchmarks which the linter or the formatter on individual files. There run on pull requests.
+- Profiling the linter on either the microbenchmarks or entire projects
+
+### CPython Benchmark
+
+First, clone [CPython](https://github.com/python/cpython). It's a large and diverse Python codebase,
+which makes it a good target for benchmarking.
+
+```shell
+git clone --branch 3.10 https://github.com/python/cpython.git crates/ruff_linter/resources/test/cpython
+```
+
+To benchmark the release build:
+
+```shell
+cargo build --release && hyperfine --warmup 10 \
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache -e" \
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ -e"
+
+Benchmark 1: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache
+  Time (mean ± σ):     293.8 ms ±   3.2 ms    [User: 2384.6 ms, System: 90.3 ms]
+  Range (min … max):   289.9 ms … 301.6 ms    10 runs
+
+Benchmark 2: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/
+  Time (mean ± σ):      48.0 ms ±   3.1 ms    [User: 65.2 ms, System: 124.7 ms]
+  Range (min … max):    45.0 ms …  66.7 ms    62 runs
+
+Summary
+  './target/release/ruff ./crates/ruff_linter/resources/test/cpython/' ran
+    6.12 ± 0.41 times faster than './target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache'
+```
+
+To benchmark against the ecosystem's existing tools:
+
+```shell
+hyperfine --ignore-failure --warmup 5 \
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache" \
+  "pyflakes crates/ruff_linter/resources/test/cpython" \
+  "autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython" \
+  "pycodestyle crates/ruff_linter/resources/test/cpython" \
+  "flake8 crates/ruff_linter/resources/test/cpython"
+
+Benchmark 1: ./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache
+  Time (mean ± σ):     294.3 ms ±   3.3 ms    [User: 2467.5 ms, System: 89.6 ms]
+  Range (min … max):   291.1 ms … 302.8 ms    10 runs
+
+  Warning: Ignoring non-zero exit code.
+
+Benchmark 2: pyflakes crates/ruff_linter/resources/test/cpython
+  Time (mean ± σ):     15.786 s ±  0.143 s    [User: 15.560 s, System: 0.214 s]
+  Range (min … max):   15.640 s … 16.157 s    10 runs
+
+  Warning: Ignoring non-zero exit code.
+
+Benchmark 3: autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython
+  Time (mean ± σ):      6.175 s ±  0.169 s    [User: 54.102 s, System: 1.057 s]
+  Range (min … max):    5.950 s …  6.391 s    10 runs
+
+Benchmark 4: pycodestyle crates/ruff_linter/resources/test/cpython
+  Time (mean ± σ):     46.921 s ±  0.508 s    [User: 46.699 s, System: 0.202 s]
+  Range (min … max):   46.171 s … 47.863 s    10 runs
+
+  Warning: Ignoring non-zero exit code.
+
+Benchmark 5: flake8 crates/ruff_linter/resources/test/cpython
+  Time (mean ± σ):     12.260 s ±  0.321 s    [User: 102.934 s, System: 1.230 s]
+  Range (min … max):   11.848 s … 12.933 s    10 runs
+
+  Warning: Ignoring non-zero exit code.
+
+Summary
+  './target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache' ran
+   20.98 ± 0.62 times faster than 'autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython'
+   41.66 ± 1.18 times faster than 'flake8 crates/ruff_linter/resources/test/cpython'
+   53.64 ± 0.77 times faster than 'pyflakes crates/ruff_linter/resources/test/cpython'
+  159.43 ± 2.48 times faster than 'pycodestyle crates/ruff_linter/resources/test/cpython'
+```
+
+To benchmark a subset of rules, e.g. `LineTooLong` and `DocLineTooLong`:
+
+```shell
+cargo build --release && hyperfine --warmup 10 \
+  "./target/release/ruff ./crates/ruff_linter/resources/test/cpython/ --no-cache -e --select W505,E501"
+```
+
+You can run `poetry install` from `./scripts/benchmarks` to create a working environment for the
+above. All reported benchmarks were computed using the versions specified by
+`./scripts/benchmarks/pyproject.toml` on Python 3.11.
+
+To benchmark Pylint, remove the following files from the CPython repository:
+
+```shell
+rm Lib/test/bad_coding.py \
+  Lib/test/bad_coding2.py \
+  Lib/test/bad_getattr.py \
+  Lib/test/bad_getattr2.py \
+  Lib/test/bad_getattr3.py \
+  Lib/test/badcert.pem \
+  Lib/test/badkey.pem \
+  Lib/test/badsyntax_3131.py \
+  Lib/test/badsyntax_future10.py \
+  Lib/test/badsyntax_future3.py \
+  Lib/test/badsyntax_future4.py \
+  Lib/test/badsyntax_future5.py \
+  Lib/test/badsyntax_future6.py \
+  Lib/test/badsyntax_future7.py \
+  Lib/test/badsyntax_future8.py \
+  Lib/test/badsyntax_future9.py \
+  Lib/test/badsyntax_pep3120.py \
+  Lib/test/test_asyncio/test_runners.py \
+  Lib/test/test_copy.py \
+  Lib/test/test_inspect.py \
+  Lib/test/test_typing.py
+```
+
+Then, from `crates/ruff_linter/resources/test/cpython`, run: `time pylint -j 0 -E $(git ls-files '*.py')`. This
+will execute Pylint with maximum parallelism and only report errors.
+
+To benchmark Pyupgrade, run the following from `crates/ruff_linter/resources/test/cpython`:
+
+```shell
+hyperfine --ignore-failure --warmup 5 --prepare "git reset --hard HEAD" \
+  "find . -type f -name \"*.py\" | xargs -P 0 pyupgrade --py311-plus"
+
+Benchmark 1: find . -type f -name "*.py" | xargs -P 0 pyupgrade --py311-plus
+  Time (mean ± σ):     30.119 s ±  0.195 s    [User: 28.638 s, System: 0.390 s]
+  Range (min … max):   29.813 s … 30.356 s    10 runs
+```
+
+### Microbenchmarks
+
+The `ruff_benchmark` crate benchmarks the linter and the formatter on individual files.
+
+You can run the benchmarks with
+
+```shell
+cargo benchmark
+```
+
+#### Benchmark-driven Development
+
+Ruff uses [Criterion.rs](https://bheisler.github.io/criterion.rs/book/) for benchmarks. You can use
+`--save-baseline=<name>` to store an initial baseline benchmark (e.g. on `main`) and then use
+`--benchmark=<name>` to compare against that benchmark. Criterion will print a message telling you
+if the benchmark improved/regressed compared to that baseline.
+
+```shell
+# Run once on your "baseline" code
+cargo benchmark --save-baseline=main
+
+# Then iterate with
+cargo benchmark --baseline=main
+```
+
+#### PR Summary
+
+You can use `--save-baseline` and `critcmp` to get a pretty comparison between two recordings.
+This is useful to illustrate the improvements of a PR.
+
+```shell
+# On main
+cargo benchmark --save-baseline=main
+
+# After applying your changes
+cargo benchmark --save-baseline=pr
+
+critcmp main pr
+```
+
+You must install [`critcmp`](https://github.com/BurntSushi/critcmp) for the comparison.
+
+```bash
+cargo install critcmp
+```
+
+#### Tips
+
+- Use `cargo benchmark <filter>` to only run specific benchmarks. For example: `cargo benchmark linter/pydantic`
+    to only run the pydantic tests.
+- Use `cargo benchmark --quiet` for a more cleaned up output (without statistical relevance)
+- Use `cargo benchmark --quick` to get faster results (more prone to noise)
+
+### Profiling Projects
+
+You can either use the microbenchmarks from above or a project directory for benchmarking. There
+are a lot of profiling tools out there,
+[The Rust Performance Book](https://nnethercote.github.io/perf-book/profiling.html) lists some
+examples.
+
+#### Linux
+
+Install `perf` and build `ruff_benchmark` with the `release-debug` profile and then run it with perf
+
+```shell
+cargo bench -p ruff_benchmark --no-run --profile=release-debug && perf record --call-graph dwarf -F 9999 cargo bench -p ruff_benchmark --profile=release-debug -- --profile-time=1
+```
+
+You can also use the `ruff_dev` launcher to run `ruff check` multiple times on a repository to
+gather enough samples for a good flamegraph (change the 999, the sample rate, and the 30, the number
+of checks, to your liking)
+
+```shell
+cargo build --bin ruff_dev --profile=release-debug
+perf record -g -F 999 target/release-debug/ruff_dev repeat --repeat 30 --exit-zero --no-cache path/to/cpython > /dev/null
+```
+
+Then convert the recorded profile
+
+```shell
+perf script -F +pid > /tmp/test.perf
+```
+
+You can now view the converted file with [firefox profiler](https://profiler.firefox.com/), with a
+more in-depth guide [here](https://profiler.firefox.com/docs/#/./guide-perf-profiling)
+
+An alternative is to convert the perf data to `flamegraph.svg` using
+[flamegraph](https://github.com/flamegraph-rs/flamegraph) (`cargo install flamegraph`):
+
+```shell
+flamegraph --perfdata perf.data --no-inline
+```
+
+#### Mac
+
+Install [`cargo-instruments`](https://crates.io/crates/cargo-instruments):
+
+```shell
+cargo install cargo-instruments
+```
+
+Then run the profiler with
+
+```shell
+cargo instruments -t time --bench linter --profile release-debug -p ruff_benchmark -- --profile-time=1
+```
+
+- `-t`: Specifies what to profile. Useful options are `time` to profile the wall time and `alloc`
+    for profiling the allocations.
+- You may want to pass an additional filter to run a single test file
+
+Otherwise, follow the instructions from the linux section.
+
+## `cargo dev`
+
+`cargo dev` is a shortcut for `cargo run --package ruff_dev --bin ruff_dev`. You can run some useful
+utils with it:
+
+- `cargo dev print-ast <file>`: Print the AST of a python file using the
+    [RustPython parser](https://github.com/astral-sh/RustPython-Parser/tree/main/parser) that is
+    mainly used in Ruff. For `if True: pass # comment`, you can see the syntax tree, the byte offsets
+    for start and stop of each node and also how the `:` token, the comment and whitespace are not
+    represented anymore:
+
+```text
+[
+    If(
+        StmtIf {
+            range: 0..13,
+            test: Constant(
+                ExprConstant {
+                    range: 3..7,
+                    value: Bool(
+                        true,
+                    ),
+                    kind: None,
+                },
+            ),
+            body: [
+                Pass(
+                    StmtPass {
+                        range: 9..13,
+                    },
+                ),
+            ],
+            orelse: [],
+        },
+    ),
+]
+```
+
+- `cargo dev print-tokens <file>`: Print the tokens that the AST is built upon. Again for
+    `if True: pass # comment`:
+
+```text
+0 If 2
+3 True 7
+7 Colon 8
+9 Pass 13
+14 Comment(
+    "# comment",
+) 23
+23 Newline 24
+```
+
+- `cargo dev print-cst <file>`: Print the CST of a python file using
+    [LibCST](https://github.com/Instagram/LibCST), which is used in addition to the RustPython parser
+    in Ruff. E.g. for `if True: pass # comment` everything including the whitespace is represented:
+
+```text
+Module {
+    body: [
+        Compound(
+            If(
+                If {
+                    test: Name(
+                        Name {
+                            value: "True",
+                            lpar: [],
+                            rpar: [],
+                        },
+                    ),
+                    body: SimpleStatementSuite(
+                        SimpleStatementSuite {
+                            body: [
+                                Pass(
+                                    Pass {
+                                        semicolon: None,
+                                    },
+                                ),
+                            ],
+                            leading_whitespace: SimpleWhitespace(
+                                " ",
+                            ),
+                            trailing_whitespace: TrailingWhitespace {
+                                whitespace: SimpleWhitespace(
+                                    " ",
+                                ),
+                                comment: Some(
+                                    Comment(
+                                        "# comment",
+                                    ),
+                                ),
+                                newline: Newline(
+                                    None,
+                                    Real,
+                                ),
+                            },
+                        },
+                    ),
+                    orelse: None,
+                    leading_lines: [],
+                    whitespace_before_test: SimpleWhitespace(
+                        " ",
+                    ),
+                    whitespace_after_test: SimpleWhitespace(
+                        "",
+                    ),
+                    is_elif: false,
+                },
+            ),
+        ),
+    ],
+    header: [],
+    footer: [],
+    default_indent: "    ",
+    default_newline: "\n",
+    has_trailing_newline: true,
+    encoding: "utf-8",
+}
+```
+
+- `cargo dev generate-all`: Update `ruff.schema.json`, `docs/configuration.md` and `docs/rules`.
+    You can also set `RUFF_UPDATE_SCHEMA=1` to update `ruff.schema.json` during `cargo test`.
+- `cargo dev generate-cli-help`, `cargo dev generate-docs` and `cargo dev generate-json-schema`:
+    Update just `docs/configuration.md`, `docs/rules` and `ruff.schema.json` respectively.
+- `cargo dev generate-options`: Generate a markdown-compatible table of all `pyproject.toml`
+    options. Used for <https://docs.astral.sh/ruff/settings/>.
+- `cargo dev generate-rules-table`: Generate a markdown-compatible table of all rules. Used for <https://docs.astral.sh/ruff/rules/>.
+- `cargo dev round-trip <python file or jupyter notebook>`: Read a Python file or Jupyter Notebook,
+    parse it, serialize the parsed representation and write it back. Used to check how good our
+    representation is so that fixes don't rewrite irrelevant parts of a file.
+- `cargo dev format_dev`: See ruff_python_formatter README.md
+
+## Subsystems
+
+### Compilation Pipeline
+
+If we view Ruff as a compiler, in which the inputs are paths to Python files and the outputs are
+diagnostics, then our current compilation pipeline proceeds as follows:
+
+1. **File discovery**: Given paths like `foo/`, locate all Python files in any specified subdirectories, taking into account our hierarchical settings system and any `exclude` options.
+
+1. **Package resolution**: Determine the "package root" for every file by traversing over its parent directories and looking for `__init__.py` files.
+
+1. **Cache initialization**: For every "package root", initialize an empty cache.
+
+1. **Analysis**: For every file, in parallel:
+
+    1. **Cache read**: If the file is cached (i.e., its modification timestamp hasn't changed since it was last analyzed), short-circuit, and return the cached diagnostics.
+
+    1. **Tokenization**: Run the lexer over the file to generate a token stream.
+
+    1. **Indexing**: Extract metadata from the token stream, such as: comment ranges, `# noqa` locations, `# isort: off` locations, "doc lines", etc.
+
+    1. **Token-based rule evaluation**: Run any lint rules that are based on the contents of the token stream (e.g., commented-out code).
+
+    1. **Filesystem-based rule evaluation**: Run any lint rules that are based on the contents of the filesystem (e.g., lack of `__init__.py` file in a package).
+
+    1. **Logical line-based rule evaluation**: Run any lint rules that are based on logical lines (e.g., stylistic rules).
+
+    1. **Parsing**: Run the parser over the token stream to produce an AST. (This consumes the token stream, so anything that relies on the token stream needs to happen before parsing.)
+
+    1. **AST-based rule evaluation**: Run any lint rules that are based on the AST. This includes the vast majority of lint rules. As part of this step, we also build the semantic model for the current file as we traverse over the AST. Some lint rules are evaluated eagerly, as we iterate over the AST, while others are evaluated in a deferred manner (e.g., unused imports, since we can't determine whether an import is unused until we've finished analyzing the entire file), after we've finished the initial traversal.
+
+    1. **Import-based rule evaluation**: Run any lint rules that are based on the module's imports (e.g., import sorting). These could, in theory, be included in the AST-based rule evaluation phase — they're just separated for simplicity.
+
+    1. **Physical line-based rule evaluation**: Run any lint rules that are based on physical lines (e.g., line-length).
+
+    1. **Suppression enforcement**: Remove any violations that are suppressed via `# noqa` directives or `per-file-ignores`.
+
+    1. **Cache write**: Write the generated diagnostics to the package cache using the file as a key.
+
+1. **Reporting**: Print diagnostics in the specified format (text, JSON, etc.), to the specified output channel (stdout, a file, etc.).
+
+### Import Categorization
+
+To understand Ruff's import categorization system, we first need to define two concepts:
+
+- "Project root": The directory containing the `pyproject.toml`, `ruff.toml`, or `.ruff.toml` file,
+    discovered by identifying the "closest" such directory for each Python file. (If you're running
+    via `ruff --config /path/to/pyproject.toml`, then the current working directory is used as the
+    "project root".)
+- "Package root": The top-most directory defining the Python package that includes a given Python
+    file. To find the package root for a given Python file, traverse up its parent directories until
+    you reach a parent directory that doesn't contain an `__init__.py` file (and isn't marked as
+    a [namespace package](https://docs.astral.sh/ruff/settings/#namespace-packages)); take the directory
+    just before that, i.e., the first directory in the package.
+
+For example, given:
+
+```text
+my_project
+├── pyproject.toml
+└── src
+    └── foo
+        ├── __init__.py
+        └── bar
+            ├── __init__.py
+            └── baz.py
+```
+
+Then when analyzing `baz.py`, the project root would be the top-level directory (`./my_project`),
+and the package root would be `./my_project/src/foo`.
+
+#### Project root
+
+The project root does not have a significant impact beyond that all relative paths within the loaded
+configuration file are resolved relative to the project root.
+
+For example, to indicate that `bar` above is a namespace package (it isn't, but let's run with it),
+the `pyproject.toml` would list `namespace-packages = ["./src/bar"]`, which would resolve
+to `my_project/src/bar`.
+
+The same logic applies when providing a configuration file via `--config`. In that case, the
+_current working directory_ is used as the project root, and so all paths in that configuration file
+are resolved relative to the current working directory. (As a general rule, we want to avoid relying
+on the current working directory as much as possible, to ensure that Ruff exhibits the same behavior
+regardless of where and how you invoke it — but that's hard to avoid in this case.)
+
+Additionally, if a `pyproject.toml` file _extends_ another configuration file, Ruff will still use
+the directory containing that `pyproject.toml` file as the project root. For example, if
+`./my_project/pyproject.toml` contains:
+
+```toml
+[tool.ruff]
+extend = "/path/to/pyproject.toml"
+```
+
+Then Ruff will use `./my_project` as the project root, even though the configuration file extends
+`/path/to/pyproject.toml`. As such, if the configuration file at `/path/to/pyproject.toml` contains
+any relative paths, they will be resolved relative to `./my_project`.
+
+If a project uses nested configuration files, then Ruff would detect multiple project roots, one for
+each configuration file.
+
+#### Package root
+
+The package root is used to determine a file's "module path". Consider, again, `baz.py`. In that
+case, `./my_project/src/foo` was identified as the package root, so the module path for `baz.py`
+would resolve to  `foo.bar.baz` — as computed by taking the relative path from the package root
+(inclusive of the root itself). The module path can be thought of as "the path you would use to
+import the module" (e.g., `import foo.bar.baz`).
+
+The package root and module path are used to, e.g., convert relative to absolute imports, and for
+import categorization, as described below.
+
+#### Import categorization
+
+When sorting and formatting import blocks, Ruff categorizes every import into one of five
+categories:
+
+1. **"Future"**: the import is a `__future__` import. That's easy: just look at the name of the
+    imported module!
+1. **"Standard library"**: the import comes from the Python standard library (e.g., `import os`).
+    This is easy too: we include a list of all known standard library modules in Ruff itself, so it's
+    a simple lookup.
+1. **"Local folder"**: the import is a relative import (e.g., `from .foo import bar`). This is easy
+    too: just check if the import includes a `level` (i.e., a dot-prefix).
+1. **"First party"**: the import is part of the current project. (More on this below.)
+1. **"Third party"**: everything else.
+
+The real challenge lies in determining whether an import is first-party — everything else is either
+trivial, or (as in the case of third-party) merely defined as "not first-party".
+
+There are three ways in which an import can be categorized as "first-party":
+
+1. **Explicit settings**: the import is marked as such via the `known-first-party` setting. (This
+    should generally be seen as an escape hatch.)
+1. **Same-package**: the imported module is in the same package as the current file. This gets back
+    to the importance of the "package root" and the file's "module path". Imagine that we're
+    analyzing `baz.py` above. If `baz.py` contains any imports that appear to come from the `foo`
+    package (e.g., `from foo import bar` or `import foo.bar`), they'll be classified as first-party
+    automatically. This check is as simple as comparing the first segment of the current file's
+    module path to the first segment of the import.
+1. **Source roots**: Ruff supports a `[src](https://docs.astral.sh/ruff/settings/#src)` setting, which
+    sets the directories to scan when identifying first-party imports. The algorithm is
+    straightforward: given an import, like `import foo`, iterate over the directories enumerated in
+    the `src` setting and, for each directory, check for the existence of a subdirectory `foo` or a
+    file `foo.py`.
+
+By default, `src` is set to the project root. In the above example, we'd want to set
+`src = ["./src"]` to ensure that we locate `./my_project/src/foo` and thus categorize `import foo`
+as first-party in `baz.py`. In practice, for this limited example, setting `src = ["./src"]` is
+unnecessary, as all imports within `./my_project/src/foo` would be categorized as first-party via
+the same-package heuristic; but your project contains multiple packages, you'll want to set `src`
+explicitly.

Cargo.toml

@@ -1,71 +1,80 @@
-[package]
-name = "ruff"
-version = "0.0.87"
+[workspace]
+members = ["crates/*"]
+resolver = "2"
+
+[workspace.package]
 edition = "2021"
+rust-version = "1.71"
+homepage = "https://docs.astral.sh/ruff"
+documentation = "https://docs.astral.sh/ruff"
+repository = "https://github.com/astral-sh/ruff"
+authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
+license = "MIT"
 
-[lib]
-name = "ruff"
-
-[dependencies]
-anyhow = { version = "1.0.60" }
-bincode = { version = "1.3.3" }
-chrono = { version = "0.4.21" }
-clap = { version = "4.0.1", features = ["derive"] }
+[workspace.dependencies]
+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"] }
 colored = { version = "2.0.0" }
-common-path = { version = "1.0.0" }
-dirs = { version = "4.0.0" }
-fern = { version = "0.6.1" }
-filetime = { version = "0.2.17" }
-glob = { version = "0.3.0" }
-itertools = { version = "0.10.5" }
-libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "32a044c127668df44582f85699358e67803b0d73" }
+filetime = { version = "0.2.20" }
+glob = { version = "0.3.1" }
+globset = { version = "0.4.10" }
+ignore = { version = "0.4.20" }
+insta = { version = "1.32.0", feature = ["filters", "glob"] }
+is-macro = { version = "0.3.0" }
+itertools = { version = "0.11.0" }
 log = { version = "0.4.17" }
-notify = { version = "4.0.17" }
+memchr = "2.6.3"
 num-bigint = { version = "0.4.3" }
-once_cell = { version = "1.13.1" }
-path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
-rayon = { version = "1.5.3" }
-regex = { version = "1.6.0" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/charliermarsh/RustPython.git", rev = "1b253a12705f84972cd76e8dc1cdaaccb233e5a5" }
-rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "1b253a12705f84972cd76e8dc1cdaaccb233e5a5" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "1b253a12705f84972cd76e8dc1cdaaccb233e5a5" }
-serde = { version = "1.0.143", features = ["derive"] }
-serde_json = { version = "1.0.83" }
-strum = { version = "0.24.1", features = ["strum_macros"] }
-strum_macros = { version = "0.24.3" }
-textwrap = { version = "0.15.1" }
-titlecase = { version = "2.2.1" }
-toml = { version = "0.5.9" }
-update-informer = { version = "0.5.0", default_features = false, features = ["pypi"], optional = true }
-walkdir = { version = "2.3.2" }
+num-traits = { version = "0.2.15" }
+once_cell = { version = "1.17.1" }
+path-absolutize = { version = "3.1.1" }
+proc-macro2 = { version = "1.0.67" }
+quote = { version = "1.0.23" }
+regex = { version = "1.9.5" }
+rustc-hash = { version = "1.1.0" }
+schemars = { version = "0.8.15" }
+serde = { version = "1.0.152", features = ["derive"] }
+serde_json = { version = "1.0.107" }
+shellexpand = { version = "3.0.0" }
+similar = { version = "2.2.1", features = ["inline"] }
+smallvec = { version = "1.11.1" }
+static_assertions = "1.1.0"
+strum = { version = "0.25.0", features = ["strum_macros"] }
+strum_macros = { version = "0.25.2" }
+syn = { version = "2.0.37" }
+test-case = { version = "3.2.1" }
+thiserror = { version = "1.0.48" }
+toml = { version = "0.7.8" }
+tracing = "0.1.37"
+tracing-indicatif = "0.3.4"
+tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
+unicode-ident = "1.0.12"
+unicode-width = "0.1.11"
+uuid = { version = "1.4.1", features = ["v4", "fast-rng", "macro-diagnostics", "js"] }
+wsl = { version = "0.1.0" }
 
-[target.'cfg(not(target_family = "wasm"))'.dependencies]
-cacache = { version = "10.0.1" } # uses async-std
-clearscreen = { version = "1.0.10" } # uses which
-
-# https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support
-# For (future) wasm-pack support
-[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
-getrandom = { version = "0.2.7", features = ["js"] }
-
-[dev-dependencies]
-assert_cmd = { version = "2.0.4" }
-codegen = { version = "0.2.0" }
-insta = { version = "1.19.1", features = ["yaml"] }
-test-case = { version = "2.2.2" }
-
-[features]
-default = ["update-informer"]
-update-informer = ["dep:update-informer"]
+# v1.0.1
+libcst = { version = "0.1.0", default-features = false }
 
 [profile.release]
-panic = "abort"
-lto = "thin"
+lto = "fat"
 codegen-units = 1
-opt-level = 3
 
 [profile.dev.package.insta]
 opt-level = 3
 
 [profile.dev.package.similar]
 opt-level = 3
+
+# Reduce complexity of a parser function that would trigger a locals limit in a wasm tool.
+# https://github.com/bytecodealliance/wasm-tools/blob/b5c3d98e40590512a3b12470ef358d5c7b983b15/crates/wasmparser/src/limits.rs#L29
+[profile.dev.package.ruff_python_parser]
+opt-level = 1
+
+# Use the `--profile release-debug` flag to show symbols in release mode.
+# e.g. `cargo build --profile release-debug`
+[profile.release-debug]
+inherits = "release"
+debug = 1

_typos.toml

@@ -0,0 +1,10 @@
+[files]
+extend-exclude = ["resources", "snapshots"]
+
+[default.extend-words]
+hel = "hel"
+whos = "whos"
+spawnve = "spawnve"
+ned = "ned"
+poit = "poit"
+BA = "BA" # acronym for "Bad Allowed", used in testing.

assets/badge/v0.json

@@ -0,0 +1,8 @@
+{
+  "label": "",
+  "message": "Ruff",
+  "logoSvg": "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"128\" height=\"128\"><path d=\"M115.36 61.84 70.22 50.49 114.45 2.4a1.222 1.222 0 0 0-1.54-1.87L12.3 61.98c-.41.25-.64.72-.57 1.2.06.48.4.87.87 1.01l45.07 13.25-44.29 48.16c-.42.46-.44 1.15-.04 1.61.24.29.58.44.94.44.22 0 .45-.06.65-.19l100.78-63.41c.42-.26.64-.75.56-1.22-.08-.49-.43-.88-.91-.99z\" style=\"fill:#fcc21b\"/></svg>",
+  "logoWidth": 10,
+  "labelColor": "grey",
+  "color": "#E15759"
+}

assets/badge/v1.json

@@ -0,0 +1,8 @@
+{
+  "label": "",
+  "message": "Ruff",
+  "logoSvg": "<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"109\" height=\"132\" fill=\"none\"><g filter=\"url(#a)\"><path fill=\"#FCC21B\" d=\"m103.642 61.492-45.14-11.35 44.23-48.09a1.222 1.222 0 0 0-1.54-1.87L.582 61.632c-.41.25-.64.72-.57 1.2.06.48.4.87.87 1.01l45.07 13.25-44.29 48.16c-.42.46-.44 1.15-.04 1.61.24.29.58.44.94.44.22 0 .45-.06.65-.19l100.78-63.41c.42-.26.64-.75.56-1.22-.08-.49-.43-.88-.91-.99Z\"/></g><defs><filter id=\"a\" width=\"108.569\" height=\"131.302\" x=\"0\" y=\"0\" color-interpolation-filters=\"sRGB\" filterUnits=\"userSpaceOnUse\"><feFlood flood-opacity=\"0\" result=\"BackgroundImageFix\"/><feColorMatrix in=\"SourceAlpha\" result=\"hardAlpha\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0\"/><feOffset dx=\"4\" dy=\"4\"/><feComposite in2=\"hardAlpha\" operator=\"out\"/><feColorMatrix values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0\"/><feBlend in2=\"BackgroundImageFix\" result=\"effect1_dropShadow_7_4\"/><feBlend in=\"SourceGraphic\" in2=\"effect1_dropShadow_7_4\" result=\"shape\"/></filter></defs></svg>",
+  "logoWidth": 10,
+  "labelColor": "grey",
+  "color": "#E15759"
+}

assets/badge/v2.json

@@ -0,0 +1,8 @@
+{
+  "label": "",
+  "message": "Ruff",
+  "logoSvg": "<svg width=\"510\" height=\"622\" viewBox=\"0 0 510 622\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path fill-rule=\"evenodd\" clip-rule=\"evenodd\" d=\"M206.701 0C200.964 0 196.314 4.64131 196.314 10.3667V41.4667C196.314 47.192 191.663 51.8333 185.927 51.8333H156.843C151.107 51.8333 146.456 56.4746 146.456 62.2V145.133C146.456 150.859 141.806 155.5 136.069 155.5H106.986C101.249 155.5 96.5988 160.141 96.5988 165.867V222.883C96.5988 228.609 91.9484 233.25 86.2118 233.25H57.1283C51.3917 233.25 46.7413 237.891 46.7413 243.617V300.633C46.7413 306.359 42.0909 311 36.3544 311H10.387C4.6504 311 0 315.641 0 321.367V352.467C0 358.192 4.6504 362.833 10.387 362.833H145.418C151.154 362.833 155.804 367.475 155.804 373.2V430.217C155.804 435.942 151.154 440.583 145.418 440.583H116.334C110.597 440.583 105.947 445.225 105.947 450.95V507.967C105.947 513.692 101.297 518.333 95.5601 518.333H66.4766C60.74 518.333 56.0896 522.975 56.0896 528.7V611.633C56.0896 617.359 60.74 622 66.4766 622H149.572C155.309 622 159.959 617.359 159.959 611.633V570.167H201.507C207.244 570.167 211.894 565.525 211.894 559.8V528.7C211.894 522.975 216.544 518.333 222.281 518.333H251.365C257.101 518.333 261.752 513.692 261.752 507.967V476.867C261.752 471.141 266.402 466.5 272.138 466.5H301.222C306.959 466.5 311.609 461.859 311.609 456.133V425.033C311.609 419.308 316.259 414.667 321.996 414.667H351.079C356.816 414.667 361.466 410.025 361.466 404.3V373.2C361.466 367.475 366.117 362.833 371.853 362.833H400.937C406.673 362.833 411.324 358.192 411.324 352.467V321.367C411.324 315.641 415.974 311 421.711 311H450.794C456.531 311 461.181 306.359 461.181 300.633V217.7C461.181 211.975 456.531 207.333 450.794 207.333H420.672C414.936 207.333 410.285 202.692 410.285 196.967V165.867C410.285 160.141 414.936 155.5 420.672 155.5H449.756C455.492 155.5 460.143 150.859 460.143 145.133V114.033C460.143 108.308 464.793 103.667 470.53 103.667H499.613C505.35 103.667 510 99.0253 510 93.3V10.3667C510 4.64132 505.35 0 499.613 0H206.701ZM168.269 440.583C162.532 440.583 157.882 445.225 157.882 450.95V507.967C157.882 513.692 153.231 518.333 147.495 518.333H118.411C112.675 518.333 108.024 522.975 108.024 528.7V559.8C108.024 565.525 112.675 570.167 118.411 570.167H159.959V528.7C159.959 522.975 164.61 518.333 170.346 518.333H199.43C205.166 518.333 209.817 513.692 209.817 507.967V476.867C209.817 471.141 214.467 466.5 220.204 466.5H249.287C255.024 466.5 259.674 461.859 259.674 456.133V425.033C259.674 419.308 264.325 414.667 270.061 414.667H299.145C304.881 414.667 309.532 410.025 309.532 404.3V373.2C309.532 367.475 314.182 362.833 319.919 362.833H349.002C354.739 362.833 359.389 358.192 359.389 352.467V321.367C359.389 315.641 364.039 311 369.776 311H398.859C404.596 311 409.246 306.359 409.246 300.633V269.533C409.246 263.808 404.596 259.167 398.859 259.167H318.88C313.143 259.167 308.493 254.525 308.493 248.8V217.7C308.493 211.975 313.143 207.333 318.88 207.333H347.963C353.7 207.333 358.35 202.692 358.35 196.967V165.867C358.35 160.141 363.001 155.5 368.737 155.5H397.821C403.557 155.5 408.208 150.859 408.208 145.133V114.033C408.208 108.308 412.858 103.667 418.595 103.667H447.678C453.415 103.667 458.065 99.0253 458.065 93.3V62.2C458.065 56.4746 453.415 51.8333 447.678 51.8333H208.778C203.041 51.8333 198.391 56.4746 198.391 62.2V145.133C198.391 150.859 193.741 155.5 188.004 155.5H158.921C153.184 155.5 148.534 160.141 148.534 165.867V222.883C148.534 228.609 143.883 233.25 138.147 233.25H109.063C103.327 233.25 98.6762 237.891 98.6762 243.617V300.633C98.6762 306.359 103.327 311 109.063 311H197.352C203.089 311 207.739 315.641 207.739 321.367V430.217C207.739 435.942 203.089 440.583 197.352 440.583H168.269Z\" fill=\"#D7FF64\"/></svg>",
+  "logoWidth": 10,
+  "labelColor": "grey",
+  "color": "#261230"
+}

assets/svg/Astral.svg

@@ -0,0 +1,24 @@
+<svg width="139" height="24" viewBox="0 0 139 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <rect width="138.764" height="24" rx="2.18182" fill="#261230"/>
+  <path
+    d="M8.72798 15.2726H9.91316V11.8697L9.6887 10.4062L9.8952 10.3343L12.1309 15.1649L14.3486 10.3343L14.5461 10.4062L14.3486 11.8607V15.2726H15.5248V8.72714H13.9535L12.2117 12.7137H12.0142L10.2723 8.72714H8.72798V15.2726Z"
+    fill="#D7FF64"/>
+  <path
+    d="M22.3432 15.2726H23.6631L21.3017 8.72714H19.7574L17.4589 15.2726H18.7069L19.1558 13.9797H21.9033L22.3432 15.2726ZM19.497 13.0279L19.901 11.8607L20.4308 10.0021H20.6463L21.176 11.8607L21.5711 13.0279H19.497Z"
+    fill="#D7FF64"/>
+  <path
+    d="M25.4209 15.2726H28.1234C30.1077 15.2726 30.9876 14.1413 30.9876 12.0044C30.9876 9.92131 30.1706 8.72714 28.1234 8.72714H25.4209V15.2726ZM26.624 14.2131V9.77765H28.0965C29.147 9.77765 29.7306 10.1907 29.7306 11.4477V12.5521C29.7306 13.6923 29.2817 14.2131 28.0965 14.2131H26.624Z"
+    fill="#D7FF64"/>
+  <path
+    d="M33.079 15.2726H37.6491V14.2131H34.2822V12.3815H37.2002V11.3938H34.2822V9.77765H37.6491V8.72714H33.079V15.2726Z"
+    fill="#D7FF64"/>
+  <path
+    d="M42.923 15.2726H46.2451C47.4572 15.2726 48.2025 14.5812 48.2025 13.5487C48.2025 12.7675 47.8343 12.175 47.0532 11.9954V11.7799C47.6637 11.5734 48.0319 11.0436 48.0319 10.3433C48.0319 9.38259 47.4572 8.72714 46.281 8.72714H42.923V15.2726ZM44.0992 11.4746V9.65195H45.9578C46.4875 9.65195 46.7928 9.92131 46.7928 10.3523V10.7653C46.7928 11.1873 46.4965 11.4746 45.9758 11.4746H44.0992ZM44.0992 14.3388V12.3904H46.0296C46.5863 12.3904 46.9365 12.6418 46.9365 13.1806V13.5666C46.9365 14.0425 46.5684 14.3388 45.9309 14.3388H44.0992Z"
+    fill="#D7FF64"/>
+  <path
+    d="M49.6959 8.72714L52.174 12.579V14.1952H50.1898V15.2726H53.3772V12.579L55.8553 8.72714H54.4456L53.5119 10.2535L52.8744 11.3759H52.6679L52.0483 10.2715L51.1056 8.72714H49.6959Z"
+    fill="#D7FF64"/>
+  <path fill-rule="evenodd" clip-rule="evenodd"
+    d="M74.1824 7.63626C74.1824 7.03377 74.6708 6.54535 75.2733 6.54535H84.0006C84.6031 6.54535 85.0915 7.03377 85.0915 7.63626V9.81808H80.0733V8.94535H79.2006V10.6908H84.0006C84.6031 10.6908 85.0915 11.1792 85.0915 11.7817V16.3635C85.0915 16.966 84.6031 17.4544 84.0006 17.4544H75.2733C74.6708 17.4544 74.1824 16.966 74.1824 16.3635V14.1817L79.2006 14.1817V15.0544H80.0733V13.309L75.2733 13.309C74.6708 13.309 74.1824 12.8206 74.1824 12.2181V7.63626ZM63.4912 6.54545C62.8887 6.54545 62.4003 7.03387 62.4003 7.63636V17.4545H67.4185V14.1818H68.2912V17.4545H73.3094V7.63636C73.3094 7.03387 72.821 6.54545 72.2185 6.54545H63.4912ZM69.164 10.6909V11.5636H66.5458V10.6909H69.164ZM110.619 6.54545C110.016 6.54545 109.528 7.03387 109.528 7.63636V17.4545H114.546V14.1818H115.419V17.4545H120.437V7.63636C120.437 7.03387 119.948 6.54545 119.346 6.54545H110.619ZM116.291 10.6909V11.5636H113.673V10.6909H116.291ZM91.8549 8.29091H96.8731V11.3455C96.8731 11.9479 96.3847 12.4364 95.7822 12.4364H91.8549V13.3091H96.8731V17.4545H87.9276C87.3251 17.4545 86.8367 16.9661 86.8367 16.3636V12.4364H85.964V8.29091H86.8367V6.54545H91.8549V8.29091ZM108.655 7.63636C108.655 7.03387 108.166 6.54545 107.564 6.54545H97.7458V17.4545H102.764V14.1818H103.637V17.4545H108.655V13.3091H106.473V12.4364H107.564C108.166 12.4364 108.655 11.9479 108.655 11.3455V7.63636ZM104.509 10.6909V11.5636H101.891V10.6909H104.509ZM132.218 13.3091L126.327 13.3091V6.54547L121.309 6.54547V17.4546H132.218V13.3091Z"
+    fill="#D7FF64"/>
+</svg>

clippy.toml

@@ -0,0 +1,7 @@
+doc-valid-idents = [
+  "StackOverflow",
+  "CodeQL",
+  "IPython",
+  "NumPy",
+  "..",
+]

crates/flake8_to_ruff/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "flake8-to-ruff"
+version = "0.0.290"
+description = """
+Convert Flake8 configuration files to Ruff configuration files.
+"""
+authors = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+documentation = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
+
+[dependencies]
+ruff_linter = { path = "../ruff_linter", default-features = false }
+ruff_workspace = { path = "../ruff_workspace" }
+
+anyhow = { workspace = true }
+clap = { workspace = true }
+colored = { workspace = true }
+configparser = { version = "3.0.2" }
+itertools = { workspace = true }
+log = { workspace = true }
+once_cell = { workspace = true }
+pep440_rs = { version = "0.3.1", features = ["serde"] }
+regex = { workspace = true }
+rustc-hash = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+strum = { workspace = true }
+strum_macros = { workspace = true }
+toml = { workspace = true }
+
+[dev-dependencies]
+pretty_assertions = "1.3.0"

crates/flake8_to_ruff/README.md

@@ -0,0 +1,99 @@
+# flake8-to-ruff
+
+Convert existing Flake8 configuration files (`setup.cfg`, `tox.ini`, or `.flake8`) for use with
+[Ruff](https://github.com/astral-sh/ruff).
+
+Generates a Ruff-compatible `pyproject.toml` section.
+
+## Installation and Usage
+
+### Installation
+
+Available as [`flake8-to-ruff`](https://pypi.org/project/flake8-to-ruff/) on PyPI:
+
+```shell
+pip install flake8-to-ruff
+```
+
+### Usage
+
+To run `flake8-to-ruff`:
+
+```shell
+flake8-to-ruff path/to/setup.cfg
+flake8-to-ruff path/to/tox.ini
+flake8-to-ruff path/to/.flake8
+```
+
+`flake8-to-ruff` will print the relevant `pyproject.toml` sections to standard output, like so:
+
+```toml
+[tool.ruff]
+exclude = [
+    '.svn',
+    'CVS',
+    '.bzr',
+    '.hg',
+    '.git',
+    '__pycache__',
+    '.tox',
+    '.idea',
+    '.mypy_cache',
+    '.venv',
+    'node_modules',
+    '_state_machine.py',
+    'test_fstring.py',
+    'bad_coding2.py',
+    'badsyntax_*.py',
+]
+select = [
+    'A',
+    'E',
+    'F',
+    'Q',
+]
+ignore = []
+
+[tool.ruff.flake8-quotes]
+inline-quotes = 'single'
+
+[tool.ruff.pep8-naming]
+ignore-names = [
+    'foo',
+    'bar',
+]
+```
+
+### Plugins
+
+`flake8-to-ruff` will attempt to infer any activated plugins based on the settings provided in your
+configuration file.
+
+For example, if your `.flake8` file includes a `docstring-convention` property, `flake8-to-ruff`
+will enable the appropriate [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
+checks.
+
+Alternatively, you can manually specify plugins on the command-line:
+
+```shell
+flake8-to-ruff path/to/.flake8 --plugin flake8-builtins --plugin flake8-quotes
+```
+
+## Limitations
+
+1. Ruff only supports a subset of the Flake configuration options. `flake8-to-ruff` will warn on and
+    ignore unsupported options in the `.flake8` file (or equivalent). (Similarly, Ruff has a few
+    configuration options that don't exist in Flake8.)
+1. Ruff will omit any rule codes that are unimplemented or unsupported by Ruff, including rule
+    codes from unsupported plugins. (See the
+    [documentation](https://docs.astral.sh/ruff/faq/#how-does-ruff-compare-to-flake8) for the complete
+    list of supported plugins.)
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome and hugely appreciated. To get started, check out the
+[contributing guidelines](https://github.com/astral-sh/ruff/blob/main/CONTRIBUTING.md).

crates/flake8_to_ruff/examples/cryptography/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = [
+    # The minimum setuptools version is specific to the PEP 517 backend,
+    # and may be stricter than the version required in `setup.cfg`
+    "setuptools>=40.6.0,!=60.9.0",
+    "wheel",
+    # Must be kept in sync with the `install_requirements` in `setup.cfg`
+    "cffi>=1.12; platform_python_implementation != 'PyPy'",
+    "setuptools-rust>=0.11.4",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 79
+target-version = ["py36"]
+
+[tool.pytest.ini_options]
+addopts = "-r s --capture=no --strict-markers --benchmark-disable"
+markers = [
+    "skip_fips: this test is not executed in FIPS mode",
+    "supported: parametrized test requiring only_if and skip_message",
+]
+
+[tool.mypy]
+show_error_codes = true
+check_untyped_defs = true
+no_implicit_reexport = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_unused_configs = true
+strict_equality = true
+
+[[tool.mypy.overrides]]
+module = [
+    "pretend"
+]
+ignore_missing_imports = true
+
+[tool.coverage.run]
+branch = true
+relative_files = true
+source = [
+    "cryptography",
+    "tests/",
+]
+
+[tool.coverage.paths]
+source = [
+   "src/cryptography",
+   "*.tox/*/lib*/python*/site-packages/cryptography",
+   "*.tox\\*\\Lib\\site-packages\\cryptography",
+   "*.tox/pypy/site-packages/cryptography",
+]
+tests =[
+   "tests/",
+   "*tests\\",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "@abc.abstractmethod",
+    "@abc.abstractproperty",
+    "@typing.overload",
+    "if typing.TYPE_CHECKING",
+]

crates/flake8_to_ruff/examples/cryptography/setup.cfg

@@ -0,0 +1,91 @@
+[metadata]
+name = cryptography
+version = attr: cryptography.__version__
+description = cryptography is a package which provides cryptographic recipes and primitives to Python developers.
+long_description = file: README.rst
+long_description_content_type = text/x-rst
+license = BSD-3-Clause OR Apache-2.0
+url = https://github.com/pyca/cryptography
+author = The Python Cryptographic Authority and individual contributors
+author_email = cryptography-dev@python.org
+project_urls =
+    Documentation=https://cryptography.io/
+    Source=https://github.com/pyca/cryptography/
+    Issues=https://github.com/pyca/cryptography/issues
+    Changelog=https://cryptography.io/en/latest/changelog/
+classifiers =
+    Development Status :: 5 - Production/Stable
+    Intended Audience :: Developers
+    License :: OSI Approved :: Apache Software License
+    License :: OSI Approved :: BSD License
+    Natural Language :: English
+    Operating System :: MacOS :: MacOS X
+    Operating System :: POSIX
+    Operating System :: POSIX :: BSD
+    Operating System :: POSIX :: Linux
+    Operating System :: Microsoft :: Windows
+    Programming Language :: Python
+    Programming Language :: Python :: 3
+    Programming Language :: Python :: 3 :: Only
+    Programming Language :: Python :: 3.6
+    Programming Language :: Python :: 3.7
+    Programming Language :: Python :: 3.8
+    Programming Language :: Python :: 3.9
+    Programming Language :: Python :: 3.10
+    Programming Language :: Python :: 3.11
+    Programming Language :: Python :: Implementation :: CPython
+    Programming Language :: Python :: Implementation :: PyPy
+    Topic :: Security :: Cryptography
+
+[options]
+python_requires = >=3.6
+include_package_data = True
+zip_safe = False
+package_dir =
+    =src
+packages = find:
+# `install_requires` must be kept in sync with `pyproject.toml`
+install_requires =
+    cffi >=1.12
+
+[options.packages.find]
+where = src
+exclude =
+    _cffi_src
+    _cffi_src.*
+
+[options.extras_require]
+test =
+    pytest>=6.2.0
+    pytest-benchmark
+    pytest-cov
+    pytest-subtests
+    pytest-xdist
+    pretend
+    iso8601
+    pytz
+    hypothesis>=1.11.4,!=3.79.2
+docs =
+    sphinx >= 1.6.5,!=1.8.0,!=3.1.0,!=3.1.1,!=5.2.0,!=5.2.0.post0
+    sphinx_rtd_theme
+docstest =
+    pyenchant >= 1.6.11
+    twine >= 1.12.0
+    sphinxcontrib-spelling >= 4.0.1
+sdist =
+    setuptools_rust >= 0.11.4
+pep8test =
+    black
+    flake8
+    flake8-import-order
+    pep8-naming
+# This extra is for OpenSSH private keys that use bcrypt KDF
+# Versions: v3.1.3 - ignore_few_rounds, v3.1.5 - abi3
+ssh =
+    bcrypt >= 3.1.5
+
+[flake8]
+ignore = E203,E211,W503,W504,N818
+exclude = .tox,*.egg,.git,_build,.hypothesis
+select = E,W,F,N,I
+application-import-names = cryptography,cryptography_vectors,tests

crates/flake8_to_ruff/examples/jupyterhub.ini

@@ -0,0 +1,19 @@
+[flake8]
+# Ignore style and complexity
+# E: style errors
+# W: style warnings
+# C: complexity
+# D: docstring warnings (unused pydocstyle extension)
+# F841: local variable assigned but never used
+ignore = E, C, W, D, F841
+builtins = c, get_config
+exclude =
+    .cache,
+    .github,
+    docs,
+    jupyterhub/alembic*,
+    onbuild,
+    scripts,
+    share,
+    tools,
+    setup.py

crates/flake8_to_ruff/examples/manim.ini

@@ -0,0 +1,43 @@
+[flake8]
+# Exclude the grpc generated code
+exclude = ./manim/grpc/gen/*
+max-complexity = 15
+max-line-length = 88
+statistics = True
+# Prevents some flake8-rst-docstrings errors
+rst-roles = attr,class,func,meth,mod,obj,ref,doc,exc
+rst-directives = manim, SEEALSO, seealso
+docstring-convention=numpy
+
+select = A,A00,B,B9,C4,C90,D,E,F,F,PT,RST,SIM,W
+
+                # General Compatibility
+extend-ignore = E203, W503, D202, D212, D213, D404
+
+                # Misc
+                F401, F403, F405, F841, E501, E731, E402, F811, F821,
+
+                # Plug-in: flake8-builtins
+                A001, A002, A003,
+
+                # Plug-in: flake8-bugbear
+                B006, B007, B008, B009, B010, B903, B950,
+
+                # Plug-in: flake8-simplify
+                SIM105, SIM106, SIM119,
+
+                # Plug-in: flake8-comprehensions
+                C901
+
+                # Plug-in: flake8-pytest-style
+                PT001, PT004, PT006, PT011, PT018, PT022, PT023,
+
+                # Plug-in: flake8-docstrings
+                D100, D101, D102, D103, D104, D105, D106, D107,
+                D200, D202, D204, D205, D209,
+                D301,
+                D400, D401, D402, D403, D405, D406, D407, D409, D411, D412, D414,
+
+                # Plug-in: flake8-rst-docstrings
+                RST201, RST203, RST210, RST212, RST213, RST215,
+                RST301, RST303,

crates/flake8_to_ruff/examples/poetry.ini

@@ -0,0 +1,36 @@
+[flake8]
+min_python_version = 3.7.0
+max-line-length = 88
+ban-relative-imports = true
+# flake8-use-fstring: https://github.com/MichaelKim0407/flake8-use-fstring#--percent-greedy-and---format-greedy
+format-greedy = 1
+inline-quotes = double
+enable-extensions = TC, TC1
+type-checking-strict = true
+eradicate-whitelist-extend = ^-.*;
+extend-ignore =
+    # E203: Whitespace before ':' (pycqa/pycodestyle#373)
+    E203,
+    # SIM106: Handle error-cases first
+    SIM106,
+    # ANN101: Missing type annotation for self in method
+    ANN101,
+    # ANN102: Missing type annotation for cls in classmethod
+    ANN102,
+    # PIE781: assign-and-return
+    PIE781,
+    # PIE798 no-unnecessary-class: Consider using a module for namespacing instead
+    PIE798,
+per-file-ignores =
+    # TC002: Move third-party import '...' into a type-checking block
+    __init__.py:TC002,
+    # ANN201: Missing return type annotation for public function
+    tests/test_*:ANN201
+    tests/**/test_*:ANN201
+extend-exclude =
+    # Frozen and not subject to change in this repo:
+    get-poetry.py,
+    install-poetry.py,
+    # External to the project's coding standards:
+    tests/fixtures/*,
+    tests/**/fixtures/*,

crates/flake8_to_ruff/examples/python-discord.ini

@@ -0,0 +1,19 @@
+[flake8]
+max-line-length=120
+docstring-convention=all
+import-order-style=pycharm
+application_import_names=bot,tests
+exclude=.cache,.venv,.git,constants.py
+extend-ignore=
+    B311,W503,E226,S311,T000,E731
+    # Missing Docstrings
+    D100,D104,D105,D107,
+    # Docstring Whitespace
+    D203,D212,D214,D215,
+    # Docstring Quotes
+    D301,D302,
+    # Docstring Content
+    D400,D401,D402,D404,D405,D406,D407,D408,D409,D410,D411,D412,D413,D414,D416,D417
+    # Type Annotations
+    ANN002,ANN003,ANN101,ANN102,ANN204,ANN206,ANN401
+per-file-ignores=tests/*:D,ANN

crates/flake8_to_ruff/examples/requests.ini

@@ -0,0 +1,6 @@
+[flake8]
+ignore = E203, E501, W503
+per-file-ignores =
+    requests/__init__.py:E402, F401
+    requests/compat.py:E402, F401
+    tests/compat.py:F401

crates/flake8_to_ruff/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "flake8-to-ruff"
+keywords = ["automation", "flake8", "pycodestyle", "pyflakes", "pylint", "clippy"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Quality Assurance",
+]
+author = "Charlie Marsh"
+author_email = "charlie.r.marsh@gmail.com"
+description = "Convert existing Flake8 configuration to Ruff."
+requires-python = ">=3.7"
+
+[project.urls]
+repository = "https://github.com/astral-sh/ruff#subdirectory=crates/flake8_to_ruff"
+
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[tool.maturin]
+bindings = "bin"
+strip = true

crates/flake8_to_ruff/src/black.rs

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

crates/flake8_to_ruff/src/converter.rs

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

crates/flake8_to_ruff/src/external_config.rs

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

crates/flake8_to_ruff/src/isort.rs

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

crates/flake8_to_ruff/src/main.rs

@@ -0,0 +1,80 @@
+//! Utility to generate Ruff's `pyproject.toml` section from a Flake8 INI file.
+
+mod black;
+mod converter;
+mod external_config;
+mod isort;
+mod parser;
+mod pep621;
+mod plugin;
+mod pyproject;
+
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+use configparser::ini::Ini;
+
+use crate::converter::convert;
+use crate::external_config::ExternalConfig;
+use crate::plugin::Plugin;
+use crate::pyproject::parse;
+use ruff_linter::logging::{set_up_logging, LogLevel};
+
+#[derive(Parser)]
+#[command(
+    about = "Convert existing Flake8 configuration to Ruff.",
+    long_about = None
+)]
+struct Args {
+    /// Path to the Flake8 configuration file (e.g., `setup.cfg`, `tox.ini`, or
+    /// `.flake8`).
+    #[arg(required = true)]
+    file: PathBuf,
+    /// Optional path to a `pyproject.toml` file, used to ensure compatibility
+    /// with Black.
+    #[arg(long)]
+    pyproject: Option<PathBuf>,
+    /// List of plugins to enable.
+    #[arg(long, value_delimiter = ',')]
+    plugin: Option<Vec<Plugin>>,
+}
+
+fn main() -> Result<()> {
+    set_up_logging(&LogLevel::Default)?;
+
+    let args = Args::parse();
+
+    // Read the INI file.
+    let mut ini = Ini::new_cs();
+    ini.set_multiline(true);
+    let config = ini.load(args.file).map_err(|msg| anyhow::anyhow!(msg))?;
+
+    // Read the pyproject.toml file.
+    let pyproject = args.pyproject.map(parse).transpose()?;
+    let external_config = pyproject
+        .as_ref()
+        .and_then(|pyproject| pyproject.tool.as_ref())
+        .map(|tool| ExternalConfig {
+            black: tool.black.as_ref(),
+            isort: tool.isort.as_ref(),
+            ..Default::default()
+        })
+        .unwrap_or_default();
+    let external_config = ExternalConfig {
+        project: pyproject
+            .as_ref()
+            .and_then(|pyproject| pyproject.project.as_ref()),
+        ..external_config
+    };
+
+    // Create Ruff's pyproject.toml section.
+    let pyproject = convert(&config, &external_config, args.plugin);
+
+    #[allow(clippy::print_stdout)]
+    {
+        println!("{}", toml::to_string_pretty(&pyproject)?);
+    }
+
+    Ok(())
+}

crates/flake8_to_ruff/src/parser.rs

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

crates/flake8_to_ruff/src/pep621.rs

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

crates/flake8_to_ruff/src/plugin.rs

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

crates/flake8_to_ruff/src/pyproject.rs

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

crates/ruff_benchmark/Cargo.toml

@@ -0,0 +1,56 @@
+[package]
+name = "ruff_benchmark"
+version = "0.0.0"
+description = "Ruff Micro-benchmarks"
+publish = false
+authors = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+documentation = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
+
+[lib]
+bench = false
+
+[[bench]]
+name = "linter"
+harness = false
+
+[[bench]]
+name = "lexer"
+harness = false
+
+[[bench]]
+name = "parser"
+harness = false
+
+[[bench]]
+name = "formatter"
+harness = false
+
+[dependencies]
+once_cell.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+url = "2.3.1"
+ureq = "2.6.2"
+criterion = { version = "0.5.1", default-features = false }
+codspeed-criterion-compat = { version="2.2.0", default-features = false, optional = true}
+
+[dev-dependencies]
+ruff_linter.path = "../ruff_linter"
+ruff_python_ast.path = "../ruff_python_ast"
+ruff_python_formatter = { path = "../ruff_python_formatter" }
+ruff_python_index = { path = "../ruff_python_index" }
+ruff_python_parser = { path = "../ruff_python_parser" }
+
+[features]
+codspeed = ["codspeed-criterion-compat"]
+
+[target.'cfg(target_os = "windows")'.dev-dependencies]
+mimalloc = "0.1.39"
+
+[target.'cfg(all(not(target_os = "windows"), not(target_os = "openbsd"), any(target_arch = "x86_64", target_arch = "aarch64", target_arch = "powerpc64")))'.dev-dependencies]
+tikv-jemallocator = "0.5.0"

crates/ruff_benchmark/README.md

@@ -0,0 +1,5 @@
+# Ruff Benchmarks
+
+The `ruff_benchmark` crate benchmarks the linter and the formatter on individual files.
+
+See [CONTRIBUTING.md](../../CONTRIBUTING.md) on how to use these benchmarks.

crates/ruff_benchmark/benches/formatter.rs

@@ -0,0 +1,87 @@
+use std::path::Path;
+
+use ruff_benchmark::criterion::{
+    criterion_group, criterion_main, BenchmarkId, Criterion, Throughput,
+};
+use ruff_benchmark::{TestCase, TestFile, TestFileDownloadError};
+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};
+
+#[cfg(target_os = "windows")]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "openbsd"),
+    any(
+        target_arch = "x86_64",
+        target_arch = "aarch64",
+        target_arch = "powerpc64"
+    )
+))]
+#[global_allocator]
+static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
+fn create_test_cases() -> Result<Vec<TestCase>, TestFileDownloadError> {
+    Ok(vec![
+        TestCase::fast(TestFile::try_download("numpy/globals.py", "https://raw.githubusercontent.com/numpy/numpy/89d64415e349ca75a25250f22b874aa16e5c0973/numpy/_globals.py")?),
+        TestCase::fast(TestFile::try_download("unicode/pypinyin.py", "https://raw.githubusercontent.com/mozillazg/python-pinyin/9521e47d96e3583a5477f5e43a2e82d513f27a3f/pypinyin/standard.py")?),
+        TestCase::normal(TestFile::try_download(
+            "pydantic/types.py",
+            "https://raw.githubusercontent.com/pydantic/pydantic/83b3c49e99ceb4599d9286a3d793cea44ac36d4b/pydantic/types.py",
+        )?),
+        TestCase::normal(TestFile::try_download("numpy/ctypeslib.py", "https://raw.githubusercontent.com/numpy/numpy/e42c9503a14d66adfd41356ef5640c6975c45218/numpy/ctypeslib.py")?),
+        TestCase::slow(TestFile::try_download(
+            "large/dataset.py",
+            "https://raw.githubusercontent.com/DHI/mikeio/b7d26418f4db2909b0aa965253dbe83194d7bb5b/tests/test_dataset.py",
+        )?),
+    ])
+}
+
+fn benchmark_formatter(criterion: &mut Criterion) {
+    let mut group = criterion.benchmark_group("formatter");
+    let test_cases = create_test_cases().unwrap();
+
+    for case in test_cases {
+        group.throughput(Throughput::Bytes(case.code().len() as u64));
+
+        group.bench_with_input(
+            BenchmarkId::from_parameter(case.name()),
+            &case,
+            |b, case| {
+                let mut tokens = Vec::new();
+                let mut comment_ranges = CommentRangesBuilder::default();
+
+                for result in lex(case.code(), Mode::Module) {
+                    let (token, range) = result.expect("Input to be a valid python program.");
+
+                    comment_ranges.visit_token(&token, range);
+                    tokens.push(Ok((token, range)));
+                }
+
+                let comment_ranges = comment_ranges.finish();
+
+                // Parse the AST.
+                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_module_ast(&module, &comment_ranges, case.code(), options)
+                            .expect("Formatting to succeed");
+
+                    formatted.print().expect("Printing to succeed")
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(formatter, benchmark_formatter);
+criterion_main!(formatter);

crates/ruff_benchmark/benches/lexer.rs

@@ -0,0 +1,62 @@
+use ruff_benchmark::criterion::{
+    criterion_group, criterion_main, measurement::WallTime, BenchmarkId, Criterion, Throughput,
+};
+use ruff_benchmark::{TestCase, TestFile, TestFileDownloadError};
+use ruff_python_parser::{lexer, Mode};
+
+#[cfg(target_os = "windows")]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "openbsd"),
+    any(
+        target_arch = "x86_64",
+        target_arch = "aarch64",
+        target_arch = "powerpc64"
+    )
+))]
+#[global_allocator]
+static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
+fn create_test_cases() -> Result<Vec<TestCase>, TestFileDownloadError> {
+    Ok(vec![
+        TestCase::fast(TestFile::try_download("numpy/globals.py", "https://raw.githubusercontent.com/numpy/numpy/89d64415e349ca75a25250f22b874aa16e5c0973/numpy/_globals.py")?),
+        TestCase::fast(TestFile::try_download("unicode/pypinyin.py", "https://raw.githubusercontent.com/mozillazg/python-pinyin/9521e47d96e3583a5477f5e43a2e82d513f27a3f/pypinyin/standard.py")?),
+        TestCase::normal(TestFile::try_download(
+            "pydantic/types.py",
+            "https://raw.githubusercontent.com/pydantic/pydantic/83b3c49e99ceb4599d9286a3d793cea44ac36d4b/pydantic/types.py",
+        )?),
+        TestCase::normal(TestFile::try_download("numpy/ctypeslib.py", "https://raw.githubusercontent.com/numpy/numpy/e42c9503a14d66adfd41356ef5640c6975c45218/numpy/ctypeslib.py")?),
+        TestCase::slow(TestFile::try_download(
+            "large/dataset.py",
+            "https://raw.githubusercontent.com/DHI/mikeio/b7d26418f4db2909b0aa965253dbe83194d7bb5b/tests/test_dataset.py",
+        )?),
+    ])
+}
+
+fn benchmark_lexer(criterion: &mut Criterion<WallTime>) {
+    let test_cases = create_test_cases().unwrap();
+    let mut group = criterion.benchmark_group("lexer");
+
+    for case in test_cases {
+        group.throughput(Throughput::Bytes(case.code().len() as u64));
+        group.bench_with_input(
+            BenchmarkId::from_parameter(case.name()),
+            &case,
+            |b, case| {
+                b.iter(|| {
+                    let result =
+                        lexer::lex(case.code(), Mode::Module).find(std::result::Result::is_err);
+                    assert_eq!(result, None, "Input to be a valid Python program");
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(lexer, benchmark_lexer);
+criterion_main!(lexer);

crates/ruff_benchmark/benches/linter.rs

@@ -0,0 +1,99 @@
+use ruff_benchmark::criterion::{
+    criterion_group, criterion_main, BenchmarkGroup, BenchmarkId, Criterion, Throughput,
+};
+use ruff_benchmark::{TestCase, TestFile, TestFileDownloadError};
+use ruff_linter::linter::lint_only;
+use ruff_linter::settings::rule_table::RuleTable;
+use ruff_linter::settings::{flags, LinterSettings};
+use ruff_linter::source_kind::SourceKind;
+use ruff_linter::{registry::Rule, RuleSelector};
+use ruff_python_ast::PySourceType;
+
+#[cfg(target_os = "windows")]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "openbsd"),
+    any(
+        target_arch = "x86_64",
+        target_arch = "aarch64",
+        target_arch = "powerpc64"
+    )
+))]
+#[global_allocator]
+static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
+fn create_test_cases() -> Result<Vec<TestCase>, TestFileDownloadError> {
+    Ok(vec![
+        TestCase::fast(TestFile::try_download("numpy/globals.py", "https://raw.githubusercontent.com/numpy/numpy/89d64415e349ca75a25250f22b874aa16e5c0973/numpy/_globals.py")?),
+        TestCase::fast(TestFile::try_download("unicode/pypinyin.py", "https://raw.githubusercontent.com/mozillazg/python-pinyin/9521e47d96e3583a5477f5e43a2e82d513f27a3f/pypinyin/standard.py")?),
+        TestCase::normal(TestFile::try_download(
+            "pydantic/types.py",
+            "https://raw.githubusercontent.com/pydantic/pydantic/83b3c49e99ceb4599d9286a3d793cea44ac36d4b/pydantic/types.py",
+        )?),
+        TestCase::normal(TestFile::try_download("numpy/ctypeslib.py", "https://raw.githubusercontent.com/numpy/numpy/e42c9503a14d66adfd41356ef5640c6975c45218/numpy/ctypeslib.py")?),
+        TestCase::slow(TestFile::try_download(
+            "large/dataset.py",
+            "https://raw.githubusercontent.com/DHI/mikeio/b7d26418f4db2909b0aa965253dbe83194d7bb5b/tests/test_dataset.py",
+        )?),
+    ])
+}
+
+fn benchmark_linter(mut group: BenchmarkGroup, settings: &LinterSettings) {
+    let test_cases = create_test_cases().unwrap();
+
+    for case in test_cases {
+        group.throughput(Throughput::Bytes(case.code().len() as u64));
+
+        group.bench_with_input(
+            BenchmarkId::from_parameter(case.name()),
+            &case,
+            |b, case| {
+                let kind = SourceKind::Python(case.code().to_string());
+                b.iter(|| {
+                    let path = case.path();
+                    let result = lint_only(
+                        &path,
+                        None,
+                        settings,
+                        flags::Noqa::Enabled,
+                        &kind,
+                        PySourceType::from(path.as_path()),
+                    );
+
+                    // Assert that file contains no parse errors
+                    assert_eq!(result.error, None);
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+fn benchmark_default_rules(criterion: &mut Criterion) {
+    let group = criterion.benchmark_group("linter/default-rules");
+    benchmark_linter(group, &LinterSettings::default());
+}
+
+fn benchmark_all_rules(criterion: &mut Criterion) {
+    let mut rules: RuleTable = RuleSelector::All.all_rules().collect();
+
+    // Disable IO based rules because it is a source of flakiness
+    rules.disable(Rule::ShebangMissingExecutableFile);
+    rules.disable(Rule::ShebangNotExecutable);
+
+    let settings = LinterSettings {
+        rules,
+        ..LinterSettings::default()
+    };
+
+    let group = criterion.benchmark_group("linter/all-rules");
+    benchmark_linter(group, &settings);
+}
+
+criterion_group!(default_rules, benchmark_default_rules);
+criterion_group!(all_rules, benchmark_all_rules);
+criterion_main!(default_rules, all_rules);

crates/ruff_benchmark/benches/parser.rs

@@ -0,0 +1,77 @@
+use ruff_benchmark::criterion::{
+    criterion_group, criterion_main, measurement::WallTime, BenchmarkId, Criterion, Throughput,
+};
+use ruff_benchmark::{TestCase, TestFile, TestFileDownloadError};
+use ruff_python_ast::statement_visitor::{walk_stmt, StatementVisitor};
+use ruff_python_ast::Stmt;
+use ruff_python_parser::parse_suite;
+
+#[cfg(target_os = "windows")]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "openbsd"),
+    any(
+        target_arch = "x86_64",
+        target_arch = "aarch64",
+        target_arch = "powerpc64"
+    )
+))]
+#[global_allocator]
+static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
+fn create_test_cases() -> Result<Vec<TestCase>, TestFileDownloadError> {
+    Ok(vec![
+        TestCase::fast(TestFile::try_download("numpy/globals.py", "https://raw.githubusercontent.com/numpy/numpy/89d64415e349ca75a25250f22b874aa16e5c0973/numpy/_globals.py")?),
+        TestCase::fast(TestFile::try_download("unicode/pypinyin.py", "https://raw.githubusercontent.com/mozillazg/python-pinyin/9521e47d96e3583a5477f5e43a2e82d513f27a3f/pypinyin/standard.py")?),
+        TestCase::normal(TestFile::try_download(
+            "pydantic/types.py",
+            "https://raw.githubusercontent.com/pydantic/pydantic/83b3c49e99ceb4599d9286a3d793cea44ac36d4b/pydantic/types.py",
+        )?),
+        TestCase::normal(TestFile::try_download("numpy/ctypeslib.py", "https://raw.githubusercontent.com/numpy/numpy/e42c9503a14d66adfd41356ef5640c6975c45218/numpy/ctypeslib.py")?),
+        TestCase::slow(TestFile::try_download(
+            "large/dataset.py",
+            "https://raw.githubusercontent.com/DHI/mikeio/b7d26418f4db2909b0aa965253dbe83194d7bb5b/tests/test_dataset.py",
+        )?),
+    ])
+}
+
+struct CountVisitor {
+    count: usize,
+}
+
+impl<'a> StatementVisitor<'a> for CountVisitor {
+    fn visit_stmt(&mut self, stmt: &'a Stmt) {
+        walk_stmt(self, stmt);
+        self.count += 1;
+    }
+}
+
+fn benchmark_parser(criterion: &mut Criterion<WallTime>) {
+    let test_cases = create_test_cases().unwrap();
+    let mut group = criterion.benchmark_group("parser");
+
+    for case in test_cases {
+        group.throughput(Throughput::Bytes(case.code().len() as u64));
+        group.bench_with_input(
+            BenchmarkId::from_parameter(case.name()),
+            &case,
+            |b, case| {
+                b.iter(|| {
+                    let parsed = parse_suite(case.code(), case.name()).unwrap();
+
+                    let mut visitor = CountVisitor { count: 0 };
+                    visitor.visit_body(&parsed);
+                    visitor.count
+                });
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(parser, benchmark_parser);
+criterion_main!(parser);

crates/ruff_benchmark/src/criterion.rs

@@ -0,0 +1,11 @@
+//! This module re-exports the criterion API but picks the right backend depending on whether
+//! the benchmarks are built to run locally or with codspeed
+
+#[cfg(not(codspeed))]
+pub use criterion::*;
+
+#[cfg(not(codspeed))]
+pub type BenchmarkGroup<'a> = criterion::BenchmarkGroup<'a, measurement::WallTime>;
+
+#[cfg(codspeed)]
+pub use codspeed_criterion_compat::*;

crates/ruff_benchmark/src/lib.rs

@@ -0,0 +1,170 @@
+pub mod criterion;
+
+use std::fmt::{Display, Formatter};
+use std::path::PathBuf;
+use std::process::Command;
+
+use url::Url;
+
+/// Relative size of a test case. Benchmarks can use it to configure the time for how long a benchmark should run to get stable results.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub enum TestCaseSpeed {
+    /// A test case that is fast to run
+    Fast,
+
+    /// A normal test case
+    Normal,
+
+    /// A slow test case
+    Slow,
+}
+
+#[derive(Debug, Clone)]
+pub struct TestCase {
+    file: TestFile,
+    speed: TestCaseSpeed,
+}
+
+impl TestCase {
+    pub fn fast(file: TestFile) -> Self {
+        Self {
+            file,
+            speed: TestCaseSpeed::Fast,
+        }
+    }
+
+    pub fn normal(file: TestFile) -> Self {
+        Self {
+            file,
+            speed: TestCaseSpeed::Normal,
+        }
+    }
+
+    pub fn slow(file: TestFile) -> Self {
+        Self {
+            file,
+            speed: TestCaseSpeed::Slow,
+        }
+    }
+}
+
+impl TestCase {
+    pub fn code(&self) -> &str {
+        &self.file.code
+    }
+
+    pub fn name(&self) -> &str {
+        &self.file.name
+    }
+
+    pub fn speed(&self) -> TestCaseSpeed {
+        self.speed
+    }
+
+    pub fn path(&self) -> PathBuf {
+        TARGET_DIR.join(self.name())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct TestFile {
+    name: String,
+    code: String,
+}
+
+static TARGET_DIR: once_cell::sync::Lazy<PathBuf> = once_cell::sync::Lazy::new(|| {
+    cargo_target_directory().unwrap_or_else(|| PathBuf::from("target"))
+});
+
+fn cargo_target_directory() -> Option<PathBuf> {
+    #[derive(serde::Deserialize)]
+    struct Metadata {
+        target_directory: PathBuf,
+    }
+
+    std::env::var_os("CARGO_TARGET_DIR")
+        .map(PathBuf::from)
+        .or_else(|| {
+            let output = Command::new(std::env::var_os("CARGO")?)
+                .args(["metadata", "--format-version", "1"])
+                .output()
+                .ok()?;
+            let metadata: Metadata = serde_json::from_slice(&output.stdout).ok()?;
+            Some(metadata.target_directory)
+        })
+}
+
+impl TestFile {
+    pub fn new(name: String, code: String) -> Self {
+        Self { name, code }
+    }
+
+    #[allow(clippy::print_stderr)]
+    pub fn try_download(name: &str, url: &str) -> Result<TestFile, TestFileDownloadError> {
+        let url = Url::parse(url)?;
+
+        let cached_filename = TARGET_DIR.join(name);
+
+        if let Ok(content) = std::fs::read_to_string(&cached_filename) {
+            Ok(TestFile::new(name.to_string(), content))
+        } else {
+            // File not yet cached, download and cache it in the target directory
+            let response = ureq::get(url.as_str()).call()?;
+
+            let content = response.into_string()?;
+
+            // SAFETY: There's always the `target` directory
+            let parent = cached_filename.parent().unwrap();
+            if let Err(error) = std::fs::create_dir_all(parent) {
+                eprintln!("Failed to crate the directory for the test case {name}: {error}");
+            } else if let Err(error) = std::fs::write(cached_filename, &content) {
+                eprintln!("Failed to cache test case file downloaded from {url}: {error}");
+            }
+
+            Ok(TestFile::new(name.to_string(), content))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum TestFileDownloadError {
+    UrlParse(url::ParseError),
+    Request(Box<ureq::Error>),
+    Download(std::io::Error),
+}
+
+impl From<url::ParseError> for TestFileDownloadError {
+    fn from(value: url::ParseError) -> Self {
+        Self::UrlParse(value)
+    }
+}
+
+impl From<ureq::Error> for TestFileDownloadError {
+    fn from(value: ureq::Error) -> Self {
+        Self::Request(Box::new(value))
+    }
+}
+
+impl From<std::io::Error> for TestFileDownloadError {
+    fn from(value: std::io::Error) -> Self {
+        Self::Download(value)
+    }
+}
+
+impl Display for TestFileDownloadError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TestFileDownloadError::UrlParse(inner) => {
+                write!(f, "Failed to parse url: {inner}")
+            }
+            TestFileDownloadError::Request(inner) => {
+                write!(f, "Failed to download file: {inner}")
+            }
+            TestFileDownloadError::Download(inner) => {
+                write!(f, "Failed to download file: {inner}")
+            }
+        }
+    }
+}
+
+impl std::error::Error for TestFileDownloadError {}

crates/ruff_cache/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "ruff_cache"
+version = "0.0.0"
+publish = false
+authors = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+documentation = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
+
+[dependencies]
+itertools = { workspace = true }
+glob = { workspace = true }
+globset = { workspace = true }
+regex = { workspace = true }
+filetime = { workspace = true }
+seahash = "4.1.0"
+
+[dev-dependencies]
+ruff_macros = { path = "../ruff_macros" }

crates/ruff_cache/src/cache_key.rs

@@ -0,0 +1,468 @@
+use std::borrow::Cow;
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::hash::{Hash, Hasher};
+use std::num::{
+    NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroU128, NonZeroU16,
+    NonZeroU32, NonZeroU64, NonZeroU8,
+};
+use std::path::{Path, PathBuf};
+
+use glob::Pattern;
+use itertools::Itertools;
+use regex::Regex;
+use seahash::SeaHasher;
+
+/// A type that be used as part of a cache key.
+///
+/// A cache looks up artefacts by a cache key. Many cache keys are composed of sub-keys. For example,
+/// caching the lint results of a file depend at least on the file content, the user settings, and linter version.
+/// Types implementing the [`CacheKey`] trait can be used as part of a cache key by which artefacts are queried.
+///
+/// ## Implementing `CacheKey`
+///
+/// You can derive [`CacheKey`] with `#[derive(CacheKey)]` if all fields implement [`CacheKey`]. The resulting
+/// cache key will be the combination of the values from calling `cache_key` on each field.
+///
+/// ```
+/// # use ruff_macros::CacheKey;
+///
+/// #[derive(CacheKey)]
+/// struct Test {
+///     name: String,
+///     version: u32,
+/// }
+/// ```
+///
+/// If you need more control over computing the cache key, you can of course implement the [`CacheKey]` yourself:
+///
+/// ```
+///  use ruff_cache::{CacheKey, CacheKeyHasher};
+///
+/// struct Test {
+///     name: String,
+///     version: u32,
+///     other: String
+/// }
+///
+/// impl CacheKey for Test {
+///     fn cache_key(&self, state: &mut CacheKeyHasher) {
+///         self.name.cache_key(state);
+///         self.version.cache_key(state);
+///     }
+/// }
+/// ```
+///
+/// ## Portability
+///
+/// Ideally, the cache key is portable across platforms but this is not yet a strict requirement.
+///
+/// ## Using [`Hash`]
+///
+/// You can defer to the [`Hash`] implementation for non-composite types.
+/// Be aware, that the [`Hash`] implementation may not be portable.
+///
+/// ## Why a new trait rather than reusing [`Hash`]?
+/// The main reason is that hashes and cache keys have different constraints:
+///
+/// * Cache keys are less performance sensitive: Hashes must be super fast to compute for performant hashed-collections. That's
+///   why some standard types don't implement [`Hash`] where it would be safe to to implement [`CacheKey`], e.g. `HashSet`
+/// * Cache keys must be deterministic where hash keys do not have this constraint. That's why pointers don't implement [`CacheKey`] but they implement [`Hash`].
+/// * Ideally, cache keys are portable
+///
+/// [`Hash`](Hash)
+pub trait CacheKey {
+    fn cache_key(&self, state: &mut CacheKeyHasher);
+
+    fn cache_key_slice(data: &[Self], state: &mut CacheKeyHasher)
+    where
+        Self: Sized,
+    {
+        for piece in data {
+            piece.cache_key(state);
+        }
+    }
+}
+
+impl CacheKey for bool {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_u8(u8::from(*self));
+    }
+}
+
+impl CacheKey for char {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_u32(*self as u32);
+    }
+}
+
+impl CacheKey for usize {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_usize(*self);
+    }
+}
+
+impl CacheKey for u128 {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_u128(*self);
+    }
+}
+
+impl CacheKey for u64 {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_u64(*self);
+    }
+}
+
+impl CacheKey for u32 {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_u32(*self);
+    }
+}
+
+impl CacheKey for u16 {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_u16(*self);
+    }
+}
+
+impl CacheKey for u8 {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_u8(*self);
+    }
+}
+
+impl CacheKey for isize {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_isize(*self);
+    }
+}
+
+impl CacheKey for i128 {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_i128(*self);
+    }
+}
+
+impl CacheKey for i64 {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_i64(*self);
+    }
+}
+
+impl CacheKey for i32 {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_i32(*self);
+    }
+}
+
+impl CacheKey for i16 {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_i16(*self);
+    }
+}
+
+impl CacheKey for i8 {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_i8(*self);
+    }
+}
+macro_rules! impl_cache_key_non_zero {
+    ($name:ident) => {
+        impl CacheKey for $name {
+            #[inline]
+            fn cache_key(&self, state: &mut CacheKeyHasher) {
+                self.get().cache_key(state)
+            }
+        }
+    };
+}
+
+impl_cache_key_non_zero!(NonZeroU8);
+impl_cache_key_non_zero!(NonZeroU16);
+impl_cache_key_non_zero!(NonZeroU32);
+impl_cache_key_non_zero!(NonZeroU64);
+impl_cache_key_non_zero!(NonZeroU128);
+
+impl_cache_key_non_zero!(NonZeroI8);
+impl_cache_key_non_zero!(NonZeroI16);
+impl_cache_key_non_zero!(NonZeroI32);
+impl_cache_key_non_zero!(NonZeroI64);
+impl_cache_key_non_zero!(NonZeroI128);
+
+macro_rules! impl_cache_key_tuple {
+    () => (
+        impl CacheKey for () {
+            #[inline]
+            fn cache_key(&self, _state: &mut CacheKeyHasher) {}
+        }
+    );
+
+    ( $($name:ident)+) => (
+        impl<$($name: CacheKey),+> CacheKey for ($($name,)+) where last_type!($($name,)+): ?Sized {
+            #[allow(non_snake_case)]
+            #[inline]
+            fn cache_key(&self, state: &mut CacheKeyHasher) {
+                let ($(ref $name,)+) = *self;
+                $($name.cache_key(state);)+
+            }
+        }
+    );
+}
+
+macro_rules! last_type {
+    ($a:ident,) => { $a };
+    ($a:ident, $($rest_a:ident,)+) => { last_type!($($rest_a,)+) };
+}
+
+impl_cache_key_tuple! {}
+impl_cache_key_tuple! { T }
+impl_cache_key_tuple! { T B }
+impl_cache_key_tuple! { T B C }
+impl_cache_key_tuple! { T B C D }
+impl_cache_key_tuple! { T B C D E }
+impl_cache_key_tuple! { T B C D E F }
+impl_cache_key_tuple! { T B C D E F G }
+impl_cache_key_tuple! { T B C D E F G H }
+impl_cache_key_tuple! { T B C D E F G H I }
+impl_cache_key_tuple! { T B C D E F G H I J }
+impl_cache_key_tuple! { T B C D E F G H I J K }
+impl_cache_key_tuple! { T B C D E F G H I J K L }
+
+impl CacheKey for str {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        self.hash(&mut *state);
+    }
+}
+
+impl CacheKey for String {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        self.hash(&mut *state);
+    }
+}
+
+impl<T: CacheKey> CacheKey for Option<T> {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        match self {
+            None => state.write_usize(0),
+            Some(value) => {
+                state.write_usize(1);
+                value.cache_key(state);
+            }
+        }
+    }
+}
+
+impl<T: CacheKey> CacheKey for [T] {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_usize(self.len());
+        CacheKey::cache_key_slice(self, state);
+    }
+}
+
+impl<T: ?Sized + CacheKey> CacheKey for &T {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        (**self).cache_key(state);
+    }
+}
+
+impl<T: ?Sized + CacheKey> CacheKey for &mut T {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        (**self).cache_key(state);
+    }
+}
+
+impl<T> CacheKey for Vec<T>
+where
+    T: CacheKey,
+{
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_usize(self.len());
+        CacheKey::cache_key_slice(self, state);
+    }
+}
+
+impl<K, V, S> CacheKey for HashMap<K, V, S>
+where
+    K: CacheKey + Ord,
+    V: CacheKey,
+{
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_usize(self.len());
+        for (key, value) in self
+            .iter()
+            .sorted_by(|(left, _), (right, _)| left.cmp(right))
+        {
+            key.cache_key(state);
+            value.cache_key(state);
+        }
+    }
+}
+
+impl<V: CacheKey + Ord, S> CacheKey for HashSet<V, S> {
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_usize(self.len());
+        for value in self.iter().sorted() {
+            value.cache_key(state);
+        }
+    }
+}
+
+impl<V: CacheKey> CacheKey for BTreeSet<V> {
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_usize(self.len());
+        for item in self {
+            item.cache_key(state);
+        }
+    }
+}
+
+impl<K: CacheKey + Ord, V: CacheKey> CacheKey for BTreeMap<K, V> {
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        state.write_usize(self.len());
+
+        for (key, value) in self {
+            key.cache_key(state);
+            value.cache_key(state);
+        }
+    }
+}
+
+impl CacheKey for Path {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        self.hash(&mut *state);
+    }
+}
+
+impl CacheKey for PathBuf {
+    #[inline]
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        self.as_path().cache_key(state);
+    }
+}
+
+impl<V: ?Sized> CacheKey for Cow<'_, V>
+where
+    V: CacheKey + ToOwned,
+{
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        (**self).cache_key(state);
+    }
+}
+
+impl CacheKey for Regex {
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        self.as_str().cache_key(state);
+    }
+}
+
+impl CacheKey for Pattern {
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        self.as_str().cache_key(state);
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct CacheKeyHasher {
+    inner: SeaHasher,
+}
+
+impl CacheKeyHasher {
+    pub fn new() -> Self {
+        Self {
+            inner: SeaHasher::new(),
+        }
+    }
+}
+
+impl Hasher for CacheKeyHasher {
+    #[inline]
+    fn finish(&self) -> u64 {
+        self.inner.finish()
+    }
+
+    #[inline]
+    fn write(&mut self, bytes: &[u8]) {
+        self.inner.write(bytes);
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.inner.write_u8(i);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.inner.write_u16(i);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.inner.write_u32(i);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.inner.write_u64(i);
+    }
+
+    #[inline]
+    fn write_u128(&mut self, i: u128) {
+        self.inner.write_u128(i);
+    }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.inner.write_usize(i);
+    }
+
+    #[inline]
+    fn write_i8(&mut self, i: i8) {
+        self.inner.write_i8(i);
+    }
+
+    #[inline]
+    fn write_i16(&mut self, i: i16) {
+        self.inner.write_i16(i);
+    }
+
+    #[inline]
+    fn write_i32(&mut self, i: i32) {
+        self.inner.write_i32(i);
+    }
+
+    #[inline]
+    fn write_i64(&mut self, i: i64) {
+        self.inner.write_i64(i);
+    }
+
+    #[inline]
+    fn write_i128(&mut self, i: i128) {
+        self.inner.write_i128(i);
+    }
+
+    #[inline]
+    fn write_isize(&mut self, i: isize) {
+        self.inner.write_isize(i);
+    }
+}

crates/ruff_cache/src/filetime.rs

@@ -0,0 +1,11 @@
+use std::hash::Hash;
+
+use filetime::FileTime;
+
+use crate::{CacheKey, CacheKeyHasher};
+
+impl CacheKey for FileTime {
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        self.hash(&mut *state);
+    }
+}

crates/ruff_cache/src/globset.rs

@@ -0,0 +1,15 @@
+use globset::{Glob, GlobMatcher};
+
+use crate::{CacheKey, CacheKeyHasher};
+
+impl CacheKey for GlobMatcher {
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        self.glob().cache_key(state);
+    }
+}
+
+impl CacheKey for Glob {
+    fn cache_key(&self, state: &mut CacheKeyHasher) {
+        self.glob().cache_key(state);
+    }
+}

crates/ruff_cache/src/lib.rs

@@ -0,0 +1,14 @@
+use std::path::{Path, PathBuf};
+
+pub use cache_key::{CacheKey, CacheKeyHasher};
+
+mod cache_key;
+pub mod filetime;
+pub mod globset;
+
+pub const CACHE_DIR_NAME: &str = ".ruff_cache";
+
+/// Return the cache directory for a given project root.
+pub fn cache_dir(project_root: &Path) -> PathBuf {
+    project_root.join(CACHE_DIR_NAME)
+}

crates/ruff_cache/tests/cache_key.rs

@@ -0,0 +1,139 @@
+use std::hash::{Hash, Hasher};
+
+use ruff_cache::{CacheKey, CacheKeyHasher};
+use ruff_macros::CacheKey;
+
+#[test]
+fn unit_struct_cache_key() {
+    #[derive(CacheKey, Hash)]
+    struct UnitStruct;
+
+    let mut key = CacheKeyHasher::new();
+
+    UnitStruct.cache_key(&mut key);
+
+    let mut hash = CacheKeyHasher::new();
+    UnitStruct.hash(&mut hash);
+
+    assert_eq!(hash.finish(), key.finish());
+}
+
+#[test]
+fn named_field_struct() {
+    #[derive(CacheKey, Hash)]
+    struct NamedFieldsStruct {
+        a: String,
+        b: String,
+    }
+
+    let mut key = CacheKeyHasher::new();
+
+    let named_fields = NamedFieldsStruct {
+        a: "Hello".into(),
+        b: "World".into(),
+    };
+
+    named_fields.cache_key(&mut key);
+
+    let mut hash = CacheKeyHasher::new();
+    named_fields.hash(&mut hash);
+
+    assert_eq!(hash.finish(), key.finish());
+}
+
+#[test]
+fn struct_ignored_fields() {
+    #[derive(CacheKey)]
+    struct NamedFieldsStruct {
+        a: String,
+        #[cache_key(ignore)]
+        #[allow(unused)]
+        b: String,
+    }
+
+    impl Hash for NamedFieldsStruct {
+        fn hash<H: Hasher>(&self, state: &mut H) {
+            self.a.hash(state);
+        }
+    }
+
+    let mut key = CacheKeyHasher::new();
+
+    let named_fields = NamedFieldsStruct {
+        a: "Hello".into(),
+        b: "World".into(),
+    };
+
+    named_fields.cache_key(&mut key);
+
+    let mut hash = CacheKeyHasher::new();
+    named_fields.hash(&mut hash);
+
+    assert_eq!(hash.finish(), key.finish());
+}
+
+#[test]
+fn unnamed_field_struct() {
+    #[derive(CacheKey, Hash)]
+    struct UnnamedFieldsStruct(String, String);
+
+    let mut key = CacheKeyHasher::new();
+
+    let unnamed_fields = UnnamedFieldsStruct("Hello".into(), "World".into());
+
+    unnamed_fields.cache_key(&mut key);
+
+    let mut hash = CacheKeyHasher::new();
+    unnamed_fields.hash(&mut hash);
+
+    assert_eq!(hash.finish(), key.finish());
+}
+
+#[derive(CacheKey, Hash)]
+enum Enum {
+    Unit,
+    UnnamedFields(String, String),
+    NamedFields { a: String, b: String },
+}
+
+#[test]
+fn enum_unit_variant() {
+    let mut key = CacheKeyHasher::new();
+
+    let variant = Enum::Unit;
+    variant.cache_key(&mut key);
+
+    let mut hash = CacheKeyHasher::new();
+    variant.hash(&mut hash);
+
+    assert_eq!(hash.finish(), key.finish());
+}
+
+#[test]
+fn enum_named_fields_variant() {
+    let mut key = CacheKeyHasher::new();
+
+    let variant = Enum::NamedFields {
+        a: "Hello".to_string(),
+        b: "World".to_string(),
+    };
+    variant.cache_key(&mut key);
+
+    let mut hash = CacheKeyHasher::new();
+    variant.hash(&mut hash);
+
+    assert_eq!(hash.finish(), key.finish());
+}
+
+#[test]
+fn enum_unnamed_fields_variant() {
+    let mut key = CacheKeyHasher::new();
+
+    let variant = Enum::UnnamedFields("Hello".to_string(), "World".to_string());
+    variant.cache_key(&mut key);
+
+    let mut hash = CacheKeyHasher::new();
+    variant.hash(&mut hash);
+
+    assert_eq!(hash.finish(), key.finish());
+}

crates/ruff_cli/Cargo.toml

@@ -0,0 +1,79 @@
+[package]
+name = "ruff_cli"
+version = "0.0.290"
+publish = false
+authors = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+documentation = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
+readme = "../../README.md"
+
+[[bin]]
+name = "ruff"
+
+[dependencies]
+ruff_linter = { path = "../ruff_linter", features = ["clap"] }
+ruff_cache = { path = "../ruff_cache" }
+ruff_diagnostics = { path = "../ruff_diagnostics" }
+ruff_formatter = { path = "../ruff_formatter" }
+ruff_notebook = { path = "../ruff_notebook" }
+ruff_macros = { path = "../ruff_macros" }
+ruff_python_ast = { path = "../ruff_python_ast" }
+ruff_python_formatter = { path = "../ruff_python_formatter" }
+ruff_source_file = { path = "../ruff_source_file" }
+ruff_python_trivia = { path = "../ruff_python_trivia" }
+ruff_workspace = { path = "../ruff_workspace" }
+ruff_text_size = { path = "../ruff_text_size" }
+
+annotate-snippets = { version = "0.9.1", features = ["color"] }
+anyhow = { workspace = true }
+argfile = { version = "0.1.6" }
+bincode = { version = "1.3.3" }
+bitflags = { workspace = true }
+cachedir = { version = "0.3.0" }
+chrono = { workspace = true }
+clap = { workspace = true, features = ["derive", "env"] }
+clap_complete_command = { version = "0.5.1" }
+clearscreen = { version = "2.0.0" }
+colored = { workspace = true }
+filetime = { workspace = true }
+glob = { workspace = true }
+ignore = { workspace = true }
+is-macro = { workspace = true }
+itertools = { workspace = true }
+itoa = { version = "1.0.6" }
+log = { workspace = true }
+notify = { version = "6.1.1" }
+path-absolutize = { workspace = true, features = ["once_cell_cache"] }
+rayon = { version = "1.8.0" }
+regex = { workspace = true }
+ruff_python_stdlib = { path = "../ruff_python_stdlib" }
+rustc-hash = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+shellexpand = { workspace = true }
+similar = { workspace = true }
+strum = { workspace = true, features = [] }
+thiserror = { workspace = true }
+tracing = { workspace = true, features = ["log"] }
+walkdir = { version = "2.3.2" }
+wild = { version = "2" }
+
+[dev-dependencies]
+assert_cmd = { version = "2.0.8" }
+# Avoid writing colored snapshots when running tests from the terminal
+colored = { workspace = true, features = ["no-color"]}
+insta = { workspace = true, features = ["filters"] }
+insta-cmd = { version = "0.4.0" }
+tempfile = "3.6.0"
+test-case = { workspace = true }
+ureq = { version = "2.6.2", features = [] }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+mimalloc = "0.1.39"
+
+[target.'cfg(all(not(target_os = "windows"), not(target_os = "openbsd"), any(target_arch = "x86_64", target_arch = "aarch64", target_arch = "powerpc64")))'.dependencies]
+tikv-jemallocator = "0.5.0"

crates/ruff_cli/resources/test/fixtures/cache_mutable/.gitignore

@@ -0,0 +1,2 @@
+# Modified by the cache tests.
+source.py

crates/ruff_cli/resources/test/fixtures/cache_mutable/source.py

@@ -0,0 +1,3 @@
+a = 1
+
+__all__ = list(["a", "b"])

crates/ruff_cli/resources/test/fixtures/cache_remove_old_files/source.py

@@ -0,0 +1,4 @@
+# NOTE: sync with cache::invalidation test
+a = 1
+
+__all__ = list(["a", "b"])

crates/ruff_cli/src/args.rs

@@ -0,0 +1,705 @@
+use std::path::PathBuf;
+
+use clap::{command, Parser};
+use regex::Regex;
+use rustc_hash::FxHashMap;
+
+use ruff_linter::line_width::LineLength;
+use ruff_linter::logging::LogLevel;
+use ruff_linter::registry::Rule;
+use ruff_linter::settings::types::{
+    FilePattern, PatternPrefixPair, PerFileIgnore, PreviewMode, PythonVersion, SerializationFormat,
+};
+use ruff_linter::{RuleParser, RuleSelector, RuleSelectorParser};
+use ruff_python_formatter::LspRowColumn;
+use ruff_workspace::configuration::{Configuration, RuleSelection};
+use ruff_workspace::resolver::ConfigurationTransformer;
+
+#[derive(Debug, Parser)]
+#[command(
+    author,
+    name = "ruff",
+    about = "Ruff: An extremely fast Python linter.",
+    after_help = "For help with a specific command, see: `ruff help <command>`."
+)]
+#[command(version)]
+pub struct Args {
+    #[command(subcommand)]
+    pub command: Command,
+    #[clap(flatten)]
+    pub log_level_args: LogLevelArgs,
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Debug, clap::Subcommand)]
+pub enum Command {
+    /// Run Ruff on the given files or directories (default).
+    Check(CheckCommand),
+    /// Explain a rule (or all rules).
+    #[clap(alias = "--explain")]
+    #[command(group = clap::ArgGroup::new("selector").multiple(false).required(true))]
+    Rule {
+        /// Rule to explain
+        #[arg(value_parser=RuleParser, group = "selector", hide_possible_values = true)]
+        rule: Option<Rule>,
+
+        /// Explain all rules
+        #[arg(long, conflicts_with = "rule", group = "selector")]
+        all: bool,
+
+        /// Output format
+        #[arg(long, value_enum, default_value = "text")]
+        format: HelpFormat,
+    },
+    /// List or describe the available configuration options.
+    Config { option: Option<String> },
+    /// List all supported upstream linters.
+    Linter {
+        /// Output format
+        #[arg(long, value_enum, default_value = "text")]
+        format: HelpFormat,
+    },
+    /// Clear any caches in the current directory and any subdirectories.
+    #[clap(alias = "--clean")]
+    Clean,
+    /// Generate shell completion.
+    #[clap(alias = "--generate-shell-completion", hide = true)]
+    GenerateShellCompletion { shell: clap_complete_command::Shell },
+    /// Run the Ruff formatter on the given files or directories.
+    #[doc(hidden)]
+    #[clap(hide = true)]
+    Format(FormatCommand),
+}
+
+// The `Parser` derive is for ruff_dev, for ruff_cli `Args` would be sufficient
+#[derive(Clone, Debug, clap::Parser)]
+#[allow(clippy::struct_excessive_bools)]
+pub struct CheckCommand {
+    /// List of files or directories to check.
+    pub files: Vec<PathBuf>,
+    /// Attempt to automatically fix lint violations.
+    /// Use `--no-fix` to disable.
+    #[arg(long, overrides_with("no_fix"))]
+    fix: bool,
+    #[clap(long, overrides_with("fix"), hide = true)]
+    no_fix: bool,
+    /// Show violations with source code.
+    /// Use `--no-show-source` to disable.
+    #[arg(long, overrides_with("no_show_source"))]
+    show_source: bool,
+    #[clap(long, overrides_with("show_source"), hide = true)]
+    no_show_source: bool,
+    /// Show an enumeration of all autofixed lint violations.
+    /// Use `--no-show-fixes` to disable.
+    #[arg(long, overrides_with("no_show_fixes"))]
+    show_fixes: bool,
+    #[clap(long, overrides_with("show_fixes"), hide = true)]
+    no_show_fixes: bool,
+    /// Avoid writing any fixed files back; instead, output a diff for each changed file to stdout. Implies `--fix-only`.
+    #[arg(long, conflicts_with = "show_fixes")]
+    pub diff: bool,
+    /// Run in watch mode by re-running whenever files change.
+    #[arg(short, long)]
+    pub watch: bool,
+    /// Fix any fixable lint violations, but don't report on leftover violations. Implies `--fix`.
+    /// Use `--no-fix-only` to disable.
+    #[arg(long, overrides_with("no_fix_only"))]
+    fix_only: bool,
+    #[clap(long, overrides_with("fix_only"), hide = true)]
+    no_fix_only: bool,
+    /// Ignore any `# noqa` comments.
+    #[arg(long)]
+    ignore_noqa: bool,
+
+    /// Output serialization format for violations. (Deprecated: Use `--output-format` instead).
+    #[arg(
+        long,
+        value_enum,
+        env = "RUFF_FORMAT",
+        conflicts_with = "output_format",
+        hide = true
+    )]
+    pub format: Option<SerializationFormat>,
+
+    /// Output serialization format for violations.
+    #[arg(long, value_enum, env = "RUFF_OUTPUT_FORMAT")]
+    pub output_format: Option<SerializationFormat>,
+
+    /// Specify file to write the linter output to (default: stdout).
+    #[arg(short, long)]
+    pub output_file: Option<PathBuf>,
+    /// The minimum Python version that should be supported.
+    #[arg(long, value_enum)]
+    pub target_version: Option<PythonVersion>,
+    /// Enable preview mode; checks will include unstable rules and fixes.
+    /// Use `--no-preview` to disable.
+    #[arg(long, overrides_with("no_preview"))]
+    preview: bool,
+    #[clap(long, overrides_with("preview"), hide = true)]
+    no_preview: bool,
+    /// Path to the `pyproject.toml` or `ruff.toml` file to use for
+    /// configuration.
+    #[arg(long, conflicts_with = "isolated")]
+    pub config: Option<PathBuf>,
+    /// Comma-separated list of rule codes to enable (or ALL, to enable all rules).
+    #[arg(
+        long,
+        value_delimiter = ',',
+        value_name = "RULE_CODE",
+        value_parser = RuleSelectorParser,
+        help_heading = "Rule selection",
+        hide_possible_values = true
+    )]
+    pub select: Option<Vec<RuleSelector>>,
+    /// Comma-separated list of rule codes to disable.
+    #[arg(
+        long,
+        value_delimiter = ',',
+        value_name = "RULE_CODE",
+        value_parser = RuleSelectorParser,
+        help_heading = "Rule selection",
+        hide_possible_values = true
+    )]
+    pub ignore: Option<Vec<RuleSelector>>,
+    /// Like --select, but adds additional rule codes on top of those already specified.
+    #[arg(
+        long,
+        value_delimiter = ',',
+        value_name = "RULE_CODE",
+        value_parser = RuleSelectorParser,
+        help_heading = "Rule selection",
+        hide_possible_values = true
+    )]
+    pub extend_select: Option<Vec<RuleSelector>>,
+    /// Like --ignore. (Deprecated: You can just use --ignore instead.)
+    #[arg(
+        long,
+        value_delimiter = ',',
+        value_name = "RULE_CODE",
+        value_parser = RuleSelectorParser,
+        help_heading = "Rule selection",
+        hide = true
+    )]
+    pub extend_ignore: Option<Vec<RuleSelector>>,
+    /// List of mappings from file pattern to code to exclude.
+    #[arg(long, value_delimiter = ',', help_heading = "Rule selection")]
+    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    /// Like `--per-file-ignores`, but adds additional ignores on top of those already specified.
+    #[arg(long, value_delimiter = ',', help_heading = "Rule selection")]
+    pub extend_per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    /// List of paths, used to omit files and/or directories from analysis.
+    #[arg(
+        long,
+        value_delimiter = ',',
+        value_name = "FILE_PATTERN",
+        help_heading = "File selection"
+    )]
+    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",
+        help_heading = "File selection"
+    )]
+    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",
+        value_parser = RuleSelectorParser,
+        help_heading = "Rule selection",
+        hide_possible_values = true
+    )]
+    pub fixable: Option<Vec<RuleSelector>>,
+    /// 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",
+        value_parser = RuleSelectorParser,
+        help_heading = "Rule selection",
+        hide_possible_values = true
+    )]
+    pub unfixable: Option<Vec<RuleSelector>>,
+    /// Like --fixable, but adds additional rule codes on top of those already specified.
+    #[arg(
+        long,
+        value_delimiter = ',',
+        value_name = "RULE_CODE",
+        value_parser = RuleSelectorParser,
+        help_heading = "Rule selection",
+        hide_possible_values = true
+    )]
+    pub extend_fixable: Option<Vec<RuleSelector>>,
+    /// Like --unfixable. (Deprecated: You can just use --unfixable instead.)
+    #[arg(
+        long,
+        value_delimiter = ',',
+        value_name = "RULE_CODE",
+        value_parser = RuleSelectorParser,
+        help_heading = "Rule selection",
+        hide = true
+    )]
+    pub extend_unfixable: Option<Vec<RuleSelector>>,
+    /// Respect file exclusions via `.gitignore` and other standard ignore files.
+    /// Use `--no-respect-gitignore` to disable.
+    #[arg(
+        long,
+        overrides_with("no_respect_gitignore"),
+        help_heading = "File selection"
+    )]
+    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.
+    /// Use `--no-force-exclude` to disable.
+    #[arg(
+        long,
+        overrides_with("no_force_exclude"),
+        help_heading = "File selection"
+    )]
+    force_exclude: bool,
+    #[clap(long, overrides_with("force_exclude"), hide = true)]
+    no_force_exclude: bool,
+    /// Set the line-length for length-associated rules and automatic formatting.
+    #[arg(long, help_heading = "Rule configuration", hide = true)]
+    pub line_length: Option<LineLength>,
+    /// Regular expression matching the name of dummy variables.
+    #[arg(long, help_heading = "Rule configuration", hide = true)]
+    pub dummy_variable_rgx: Option<Regex>,
+    /// Disable cache reads.
+    #[arg(short, long, help_heading = "Miscellaneous")]
+    pub no_cache: bool,
+    /// Ignore all configuration files.
+    #[arg(long, conflicts_with = "config", help_heading = "Miscellaneous")]
+    pub isolated: bool,
+    /// Path to the cache directory.
+    #[arg(long, env = "RUFF_CACHE_DIR", help_heading = "Miscellaneous")]
+    pub cache_dir: Option<PathBuf>,
+    /// The name of the file when passing it through stdin.
+    #[arg(long, help_heading = "Miscellaneous")]
+    pub stdin_filename: Option<PathBuf>,
+    /// Exit with status code "0", even upon detecting lint violations.
+    #[arg(
+        short,
+        long,
+        help_heading = "Miscellaneous",
+        conflicts_with = "exit_non_zero_on_fix"
+    )]
+    pub exit_zero: bool,
+    /// Exit with a non-zero status code if any files were modified via autofix, even if no lint violations remain.
+    #[arg(long, help_heading = "Miscellaneous", conflicts_with = "exit_zero")]
+    pub exit_non_zero_on_fix: bool,
+    /// Show counts for every rule with at least one violation.
+    #[arg(
+        long,
+        // Unsupported default-command arguments.
+        conflicts_with = "diff",
+        conflicts_with = "show_source",
+        conflicts_with = "watch",
+    )]
+    pub statistics: bool,
+    /// Enable automatic additions of `noqa` directives to failing lines.
+    #[arg(
+        long,
+        // conflicts_with = "add_noqa",
+        conflicts_with = "show_files",
+        conflicts_with = "show_settings",
+        // Unsupported default-command arguments.
+        conflicts_with = "ignore_noqa",
+        conflicts_with = "statistics",
+        conflicts_with = "stdin_filename",
+        conflicts_with = "watch",
+        conflicts_with = "fix",
+    )]
+    pub add_noqa: bool,
+    /// See the files Ruff will be run against with the current settings.
+    #[arg(
+        long,
+        // Fake subcommands.
+        conflicts_with = "add_noqa",
+        // conflicts_with = "show_files",
+        conflicts_with = "show_settings",
+        // Unsupported default-command arguments.
+        conflicts_with = "ignore_noqa",
+        conflicts_with = "statistics",
+        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 = "show_files",
+        // conflicts_with = "show_settings",
+        // Unsupported default-command arguments.
+        conflicts_with = "ignore_noqa",
+        conflicts_with = "statistics",
+        conflicts_with = "stdin_filename",
+        conflicts_with = "watch",
+    )]
+    pub show_settings: bool,
+    /// Dev-only argument to show fixes
+    #[arg(long, hide = true)]
+    pub ecosystem_ci: bool,
+}
+
+#[derive(Clone, Debug, clap::Parser)]
+#[allow(clippy::struct_excessive_bools)]
+pub struct FormatCommand {
+    /// List of files or directories to format.
+    pub files: Vec<PathBuf>,
+    /// Avoid writing any formatted files back; instead, exit with a non-zero status code if any
+    /// files would have been modified, and zero otherwise.
+    #[arg(long)]
+    pub check: bool,
+    /// Path to the `pyproject.toml` or `ruff.toml` file to use for configuration.
+    #[arg(long, conflicts_with = "isolated")]
+    pub config: Option<PathBuf>,
+    /// Respect file exclusions via `.gitignore` and other standard ignore files.
+    /// Use `--no-respect-gitignore` to disable.
+    #[arg(
+        long,
+        overrides_with("no_respect_gitignore"),
+        help_heading = "File selection"
+    )]
+    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.
+    /// Use `--no-force-exclude` to disable.
+    #[arg(
+        long,
+        overrides_with("no_force_exclude"),
+        help_heading = "File selection"
+    )]
+    force_exclude: bool,
+    #[clap(long, overrides_with("force_exclude"), hide = true)]
+    no_force_exclude: bool,
+    /// Set the line-length.
+    #[arg(long, help_heading = "Rule configuration", hide = true)]
+    pub line_length: Option<LineLength>,
+    /// Ignore all configuration files.
+    #[arg(long, conflicts_with = "config", help_heading = "Miscellaneous")]
+    pub isolated: bool,
+    /// The name of the file when passing it through stdin.
+    #[arg(long, help_heading = "Miscellaneous")]
+    pub stdin_filename: Option<PathBuf>,
+
+    /// Enable preview mode; checks will include unstable rules and fixes.
+    /// Use `--no-preview` to disable.
+    #[arg(long, overrides_with("no_preview"), hide = true)]
+    preview: bool,
+    #[clap(long, overrides_with("preview"), hide = true)]
+    no_preview: bool,
+    /// Range formatting start: Zero-indexed row and zero-indexed char-based column separated by
+    /// colon, e.g. `1:2`
+    #[clap(long)]
+    pub start: Option<LspRowColumn>,
+    /// Range formatting end: Zero-indexed row and zero-indexed char-based column separated by
+    /// colon, e.g. `3:4`
+    #[clap(long)]
+    pub end: Option<LspRowColumn>,
+}
+
+#[derive(Debug, Clone, Copy, clap::ValueEnum)]
+pub enum HelpFormat {
+    Text,
+    Json,
+}
+
+#[allow(clippy::module_name_repetitions)]
+#[derive(Debug, clap::Args)]
+pub struct LogLevelArgs {
+    /// Enable verbose logging.
+    #[arg(
+        short,
+        long,
+        global = true,
+        group = "verbosity",
+        help_heading = "Log levels"
+    )]
+    pub verbose: bool,
+    /// Print diagnostics, but nothing else.
+    #[arg(
+        short,
+        long,
+        global = true,
+        group = "verbosity",
+        help_heading = "Log levels"
+    )]
+    pub quiet: bool,
+    /// Disable all logging (but still exit with status code "1" upon detecting diagnostics).
+    #[arg(
+        short,
+        long,
+        global = true,
+        group = "verbosity",
+        help_heading = "Log levels"
+    )]
+    pub silent: bool,
+}
+
+impl From<&LogLevelArgs> for LogLevel {
+    fn from(args: &LogLevelArgs) -> Self {
+        if args.silent {
+            Self::Silent
+        } else if args.quiet {
+            Self::Quiet
+        } else if args.verbose {
+            Self::Verbose
+        } else {
+            Self::Default
+        }
+    }
+}
+
+impl CheckCommand {
+    /// Partition the CLI into command-line arguments and configuration
+    /// overrides.
+    pub fn partition(self) -> (CheckArguments, CliOverrides) {
+        (
+            CheckArguments {
+                add_noqa: self.add_noqa,
+                config: self.config,
+                diff: self.diff,
+                ecosystem_ci: self.ecosystem_ci,
+                exit_non_zero_on_fix: self.exit_non_zero_on_fix,
+                exit_zero: self.exit_zero,
+                files: self.files,
+                ignore_noqa: self.ignore_noqa,
+                isolated: self.isolated,
+                no_cache: self.no_cache,
+                output_file: self.output_file,
+                show_files: self.show_files,
+                show_settings: self.show_settings,
+                statistics: self.statistics,
+                stdin_filename: self.stdin_filename,
+                watch: self.watch,
+            },
+            CliOverrides {
+                dummy_variable_rgx: self.dummy_variable_rgx,
+                exclude: self.exclude,
+                extend_exclude: self.extend_exclude,
+                extend_fixable: self.extend_fixable,
+                extend_ignore: self.extend_ignore,
+                extend_select: self.extend_select,
+                extend_unfixable: self.extend_unfixable,
+                fixable: self.fixable,
+                ignore: self.ignore,
+                line_length: self.line_length,
+                per_file_ignores: self.per_file_ignores,
+                preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
+                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),
+                output_format: self.output_format.or(self.format),
+                show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),
+            },
+        )
+    }
+}
+
+impl FormatCommand {
+    /// Partition the CLI into command-line arguments and configuration
+    /// overrides.
+    pub fn partition(self) -> (FormatArguments, CliOverrides) {
+        (
+            FormatArguments {
+                check: self.check,
+                config: self.config,
+                files: self.files,
+                isolated: self.isolated,
+                stdin_filename: self.stdin_filename,
+                start: self.start,
+                end: self.end,
+            },
+            CliOverrides {
+                line_length: self.line_length,
+                respect_gitignore: resolve_bool_arg(
+                    self.respect_gitignore,
+                    self.no_respect_gitignore,
+                ),
+                preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),
+                force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),
+                // Unsupported on the formatter CLI, but required on `Overrides`.
+                ..CliOverrides::default()
+            },
+        )
+    }
+}
+
+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 CheckArguments {
+    pub add_noqa: bool,
+    pub config: Option<PathBuf>,
+    pub diff: bool,
+    pub ecosystem_ci: bool,
+    pub exit_non_zero_on_fix: bool,
+    pub exit_zero: bool,
+    pub files: Vec<PathBuf>,
+    pub ignore_noqa: bool,
+    pub isolated: bool,
+    pub no_cache: bool,
+    pub output_file: Option<PathBuf>,
+    pub show_files: bool,
+    pub show_settings: bool,
+    pub statistics: bool,
+    pub stdin_filename: Option<PathBuf>,
+    pub watch: bool,
+}
+
+/// CLI settings that are distinct from configuration (commands, lists of files,
+/// etc.).
+#[allow(clippy::struct_excessive_bools)]
+pub struct FormatArguments {
+    pub check: bool,
+    pub config: Option<PathBuf>,
+    pub files: Vec<PathBuf>,
+    pub isolated: bool,
+    pub stdin_filename: Option<PathBuf>,
+    pub start: Option<LspRowColumn>,
+    pub end: Option<LspRowColumn>,
+}
+
+/// CLI settings that function as configuration overrides.
+#[derive(Clone, Default)]
+#[allow(clippy::struct_excessive_bools)]
+pub struct CliOverrides {
+    pub dummy_variable_rgx: Option<Regex>,
+    pub exclude: Option<Vec<FilePattern>>,
+    pub extend_exclude: Option<Vec<FilePattern>>,
+    pub extend_fixable: Option<Vec<RuleSelector>>,
+    pub extend_ignore: Option<Vec<RuleSelector>>,
+    pub extend_select: Option<Vec<RuleSelector>>,
+    pub extend_unfixable: Option<Vec<RuleSelector>>,
+    pub fixable: Option<Vec<RuleSelector>>,
+    pub ignore: Option<Vec<RuleSelector>>,
+    pub line_length: Option<LineLength>,
+    pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
+    pub preview: Option<PreviewMode>,
+    pub respect_gitignore: Option<bool>,
+    pub select: Option<Vec<RuleSelector>>,
+    pub show_source: Option<bool>,
+    pub target_version: Option<PythonVersion>,
+    pub unfixable: Option<Vec<RuleSelector>>,
+    // 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 output_format: Option<SerializationFormat>,
+    pub show_fixes: Option<bool>,
+}
+
+impl ConfigurationTransformer for CliOverrides {
+    fn transform(&self, mut config: 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);
+        }
+        config.rule_selections.push(RuleSelection {
+            select: self.select.clone(),
+            ignore: self
+                .ignore
+                .iter()
+                .cloned()
+                .chain(self.extend_ignore.iter().cloned())
+                .flatten()
+                .collect(),
+            extend_select: self.extend_select.clone().unwrap_or_default(),
+            fixable: self.fixable.clone(),
+            unfixable: self
+                .unfixable
+                .iter()
+                .cloned()
+                .chain(self.extend_unfixable.iter().cloned())
+                .flatten()
+                .collect(),
+            extend_fixable: self.extend_fixable.clone().unwrap_or_default(),
+        });
+        if let Some(output_format) = &self.output_format {
+            config.output_format = Some(*output_format);
+        }
+        if let Some(force_exclude) = &self.force_exclude {
+            config.force_exclude = Some(*force_exclude);
+        }
+        if let Some(line_length) = &self.line_length {
+            config.line_length = Some(*line_length);
+        }
+        if let Some(preview) = &self.preview {
+            config.preview = Some(*preview);
+        }
+        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(show_source) = &self.show_source {
+            config.show_source = Some(*show_source);
+        }
+        if let Some(show_fixes) = &self.show_fixes {
+            config.show_fixes = Some(*show_fixes);
+        }
+        if let Some(target_version) = &self.target_version {
+            config.target_version = Some(*target_version);
+        }
+
+        config
+    }
+}
+
+/// 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<RuleSelector>> = 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)| PerFileIgnore::new(pattern, &prefixes, None))
+        .collect()
+}

crates/ruff_cli/src/bin/ruff.rs

@@ -0,0 +1,76 @@
+use std::process::ExitCode;
+
+use clap::{Parser, Subcommand};
+use colored::Colorize;
+
+use ruff_cli::args::{Args, Command};
+use ruff_cli::{run, ExitStatus};
+
+#[cfg(target_os = "windows")]
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "openbsd"),
+    any(
+        target_arch = "x86_64",
+        target_arch = "aarch64",
+        target_arch = "powerpc64"
+    )
+))]
+#[global_allocator]
+static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
+pub fn main() -> ExitCode {
+    let args = wild::args_os();
+    let mut args =
+        argfile::expand_args_from(args, argfile::parse_fromfile, argfile::PREFIX).unwrap();
+
+    // Clap doesn't support default subcommands but we want to run `check` by
+    // default for convenience and backwards-compatibility, so we just
+    // preprocess the arguments accordingly before passing them to Clap.
+    if let Some(arg) = args.get(1) {
+        if arg
+            .to_str()
+            .is_some_and(|arg| !Command::has_subcommand(rewrite_legacy_subcommand(arg)))
+            && arg != "-h"
+            && arg != "--help"
+            && arg != "-V"
+            && arg != "--version"
+            && arg != "help"
+        {
+            args.insert(1, "check".into());
+        }
+    }
+
+    let args = Args::parse_from(args);
+
+    match run(args) {
+        Ok(code) => code.into(),
+        Err(err) => {
+            #[allow(clippy::print_stderr)]
+            {
+                // This communicates that this isn't a linter error but ruff itself hard-errored for
+                // some reason (e.g. failed to resolve the configuration)
+                eprintln!("{}", "ruff failed".red().bold());
+                // Currently we generally only see one error, but e.g. with io errors when resolving
+                // the configuration it is help to chain errors ("resolving configuration failed" ->
+                // "failed to read file: subdir/pyproject.toml")
+                for cause in err.chain() {
+                    eprintln!("  {} {cause}", "Cause:".bold());
+                }
+            }
+            ExitStatus::Error.into()
+        }
+    }
+}
+
+fn rewrite_legacy_subcommand(cmd: &str) -> &str {
+    match cmd {
+        "--explain" => "rule",
+        "--clean" => "clean",
+        "--generate-shell-completion" => "generate-shell-completion",
+        cmd => cmd,
+    }
+}

crates/ruff_cli/src/cache.rs

@@ -0,0 +1,724 @@
+use std::collections::HashMap;
+use std::fs::{self, File};
+use std::hash::Hasher;
+use std::io::{self, BufReader, BufWriter, Write};
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Mutex;
+use std::time::{Duration, SystemTime};
+
+use anyhow::{Context, Result};
+use rustc_hash::FxHashMap;
+use serde::{Deserialize, Serialize};
+
+use ruff_cache::{CacheKey, CacheKeyHasher};
+use ruff_diagnostics::{DiagnosticKind, Fix};
+use ruff_linter::message::Message;
+use ruff_linter::warn_user;
+use ruff_notebook::NotebookIndex;
+use ruff_python_ast::imports::ImportMap;
+use ruff_source_file::SourceFileBuilder;
+use ruff_text_size::{TextRange, TextSize};
+use ruff_workspace::Settings;
+
+use crate::diagnostics::Diagnostics;
+
+/// Maximum duration for which we keep a file in cache that hasn't been seen.
+const MAX_LAST_SEEN: Duration = Duration::from_secs(30 * 24 * 60 * 60); // 30 days.
+
+/// [`Path`] that is relative to the package root in [`PackageCache`].
+pub(crate) type RelativePath = Path;
+/// [`PathBuf`] that is relative to the package root in [`PackageCache`].
+pub(crate) type RelativePathBuf = PathBuf;
+
+/// Cache.
+///
+/// `Cache` holds everything required to display the diagnostics for a single
+/// package. The on-disk representation is represented in [`PackageCache`] (and
+/// related) types.
+///
+/// This type manages the cache file, reading it from disk and writing it back
+/// to disk (if required).
+#[derive(Debug)]
+pub(crate) struct Cache {
+    /// Location of the cache.
+    path: PathBuf,
+    /// Package cache read from disk.
+    package: PackageCache,
+    /// Changes made compared to the (current) `package`.
+    ///
+    /// Files that are linted, but are not in `package.files` or are in
+    /// `package.files` but are outdated. This gets merged with `package.files`
+    /// when the cache is written back to disk in [`Cache::store`].
+    new_files: Mutex<HashMap<RelativePathBuf, FileCache>>,
+    /// The "current" timestamp used as cache for the updates of
+    /// [`FileCache::last_seen`]
+    last_seen_cache: u64,
+}
+
+impl Cache {
+    /// Open or create a new cache.
+    ///
+    /// `package_root` is the path to root of the package that is contained
+    /// within this cache and must be canonicalized (to avoid considering `./`
+    /// and `../project` being different).
+    ///
+    /// Finally `settings` is used to ensure we don't open a cache for different
+    /// settings. It also defines the directory where to store the cache.
+    pub(crate) fn open(package_root: PathBuf, settings: &Settings) -> Cache {
+        debug_assert!(package_root.is_absolute(), "package root not canonicalized");
+
+        let mut buf = itoa::Buffer::new();
+        let key = Path::new(buf.format(cache_key(&package_root, settings)));
+        let path = PathBuf::from_iter([&settings.cache_dir, Path::new("content"), key]);
+
+        let file = match File::open(&path) {
+            Ok(file) => file,
+            Err(err) if err.kind() == io::ErrorKind::NotFound => {
+                // No cache exist yet, return an empty cache.
+                return Cache::empty(path, package_root);
+            }
+            Err(err) => {
+                warn_user!("Failed to open cache file '{}': {err}", path.display());
+                return Cache::empty(path, package_root);
+            }
+        };
+
+        let mut package: PackageCache = match bincode::deserialize_from(BufReader::new(file)) {
+            Ok(package) => package,
+            Err(err) => {
+                warn_user!("Failed parse cache file '{}': {err}", path.display());
+                return Cache::empty(path, package_root);
+            }
+        };
+
+        // Sanity check.
+        if package.package_root != package_root {
+            warn_user!(
+                "Different package root in cache: expected '{}', got '{}'",
+                package_root.display(),
+                package.package_root.display(),
+            );
+            package.files.clear();
+        }
+        Cache::new(path, package)
+    }
+
+    /// Create an empty `Cache`.
+    fn empty(path: PathBuf, package_root: PathBuf) -> Cache {
+        let package = PackageCache {
+            package_root,
+            files: HashMap::new(),
+        };
+        Cache::new(path, package)
+    }
+
+    #[allow(clippy::cast_possible_truncation)]
+    fn new(path: PathBuf, package: PackageCache) -> Cache {
+        Cache {
+            path,
+            package,
+            new_files: Mutex::new(HashMap::new()),
+            // SAFETY: this will be truncated to the year ~2554 (so don't use
+            // this code after that!).
+            last_seen_cache: SystemTime::UNIX_EPOCH.elapsed().unwrap().as_millis() as u64,
+        }
+    }
+
+    /// Store the cache to disk, if it has been changed.
+    #[allow(clippy::cast_possible_truncation)]
+    pub(crate) fn store(mut self) -> Result<()> {
+        let new_files = self.new_files.into_inner().unwrap();
+        if new_files.is_empty() {
+            // No changes made, no need to write the same cache file back to
+            // disk.
+            return Ok(());
+        }
+
+        // Remove cached files that we haven't seen in a while.
+        let now = self.last_seen_cache;
+        self.package.files.retain(|_, file| {
+            // SAFETY: this will be truncated to the year ~2554.
+            (now - *file.last_seen.get_mut()) <= MAX_LAST_SEEN.as_millis() as u64
+        });
+
+        // Apply any changes made and keep track of when we last saw files.
+        self.package.files.extend(new_files);
+
+        let file = File::create(&self.path)
+            .with_context(|| format!("Failed to create cache file '{}'", self.path.display()))?;
+        let writer = BufWriter::new(file);
+        bincode::serialize_into(writer, &self.package).with_context(|| {
+            format!(
+                "Failed to serialise cache to file '{}'",
+                self.path.display()
+            )
+        })
+    }
+
+    /// Returns the relative path based on `path` and the package root.
+    ///
+    /// Returns `None` if `path` is not within the package.
+    pub(crate) fn relative_path<'a>(&self, path: &'a Path) -> Option<&'a RelativePath> {
+        path.strip_prefix(&self.package.package_root).ok()
+    }
+
+    /// Get the cached results for a single file at relative `path`. This
+    /// uses `key` to determine if the results are still accurate.
+    /// (i.e. if the file hasn't been modified since the cached run).
+    ///
+    /// This returns `None` if `key` differs from the cached key or if the
+    /// cache doesn't contain results for the file.
+    pub(crate) fn get<T: CacheKey>(&self, path: &RelativePath, key: &T) -> Option<&FileCache> {
+        let file = self.package.files.get(path)?;
+
+        let mut hasher = CacheKeyHasher::new();
+        key.cache_key(&mut hasher);
+
+        // Make sure the file hasn't changed since the cached run.
+        if file.key != hasher.finish() {
+            return None;
+        }
+
+        file.last_seen.store(self.last_seen_cache, Ordering::SeqCst);
+
+        Some(file)
+    }
+
+    /// Add or update a file cache at `path` relative to the package root.
+    pub(crate) fn update<T: CacheKey>(
+        &self,
+        path: RelativePathBuf,
+        key: T,
+        messages: &[Message],
+        imports: &ImportMap,
+        notebook_index: Option<&NotebookIndex>,
+    ) {
+        let source = if let Some(msg) = messages.first() {
+            msg.file.source_text().to_owned()
+        } else {
+            String::new() // No messages, no need to keep the source!
+        };
+
+        let messages = messages
+            .iter()
+            .map(|msg| {
+                // Make sure that all message use the same source file.
+                assert!(
+                    msg.file == messages.first().unwrap().file,
+                    "message uses a different source file"
+                );
+                CacheMessage {
+                    kind: msg.kind.clone(),
+                    range: msg.range,
+                    fix: msg.fix.clone(),
+                    noqa_offset: msg.noqa_offset,
+                }
+            })
+            .collect();
+
+        let mut hasher = CacheKeyHasher::new();
+        key.cache_key(&mut hasher);
+
+        let file = FileCache {
+            key: hasher.finish(),
+            last_seen: AtomicU64::new(self.last_seen_cache),
+            imports: imports.clone(),
+            messages,
+            source,
+            notebook_index: notebook_index.cloned(),
+        };
+        self.new_files.lock().unwrap().insert(path, file);
+    }
+}
+
+/// On disk representation of a cache of a package.
+#[derive(Deserialize, Debug, Serialize)]
+struct PackageCache {
+    /// Path to the root of the package.
+    ///
+    /// Usually this is a directory, but it can also be a single file in case of
+    /// single file "packages", e.g. scripts.
+    package_root: PathBuf,
+    /// Mapping of source file path to it's cached data.
+    files: HashMap<RelativePathBuf, FileCache>,
+}
+
+/// On disk representation of the cache per source file.
+#[derive(Deserialize, Debug, Serialize)]
+pub(crate) struct FileCache {
+    /// Key that determines if the cached item is still valid.
+    key: u64,
+    /// Timestamp when we last linted this file.
+    ///
+    /// Represented as the number of milliseconds since Unix epoch. This will
+    /// break in 1970 + ~584 years (~2554).
+    last_seen: AtomicU64,
+    /// Imports made.
+    imports: ImportMap,
+    /// Diagnostic messages.
+    messages: Vec<CacheMessage>,
+    /// Source code of the file.
+    ///
+    /// # Notes
+    ///
+    /// This will be empty if `messages` is empty.
+    source: String,
+    /// Notebook index if this file is a Jupyter Notebook.
+    notebook_index: Option<NotebookIndex>,
+}
+
+impl FileCache {
+    /// Convert the file cache into `Diagnostics`, using `path` as file name.
+    pub(crate) fn as_diagnostics(&self, path: &Path) -> Diagnostics {
+        let messages = if self.messages.is_empty() {
+            Vec::new()
+        } else {
+            let file = SourceFileBuilder::new(path.to_string_lossy(), &*self.source).finish();
+            self.messages
+                .iter()
+                .map(|msg| Message {
+                    kind: msg.kind.clone(),
+                    range: msg.range,
+                    fix: msg.fix.clone(),
+                    file: file.clone(),
+                    noqa_offset: msg.noqa_offset,
+                })
+                .collect()
+        };
+        let notebook_indexes = if let Some(notebook_index) = self.notebook_index.as_ref() {
+            FxHashMap::from_iter([(path.to_string_lossy().to_string(), notebook_index.clone())])
+        } else {
+            FxHashMap::default()
+        };
+        Diagnostics::new(messages, self.imports.clone(), notebook_indexes)
+    }
+}
+
+/// On disk representation of a diagnostic message.
+#[derive(Deserialize, Debug, Serialize)]
+struct CacheMessage {
+    kind: DiagnosticKind,
+    /// Range into the message's [`FileCache::source`].
+    range: TextRange,
+    fix: Option<Fix>,
+    noqa_offset: TextSize,
+}
+
+/// Returns a hash key based on the `package_root`, `settings` and the crate
+/// version.
+fn cache_key(package_root: &Path, settings: &Settings) -> u64 {
+    let mut hasher = CacheKeyHasher::new();
+    env!("CARGO_PKG_VERSION").cache_key(&mut hasher);
+    package_root.cache_key(&mut hasher);
+    settings.cache_key(&mut hasher);
+    hasher.finish()
+}
+
+/// Initialize the cache at the specified `Path`.
+pub(crate) fn init(path: &Path) -> Result<()> {
+    // Create the cache directories.
+    fs::create_dir_all(path.join("content"))?;
+
+    // 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(())
+}
+
+#[cfg(test)]
+mod tests {
+    use filetime::{set_file_mtime, FileTime};
+    use std::env::temp_dir;
+    use std::fs;
+    use std::io;
+    use std::io::Write;
+    use std::path::{Path, PathBuf};
+    use std::time::SystemTime;
+
+    use itertools::Itertools;
+    use ruff_cache::CACHE_DIR_NAME;
+    use ruff_linter::settings::flags;
+
+    use crate::cache::RelativePathBuf;
+    use crate::cache::{self, Cache, FileCache};
+    use crate::diagnostics::{lint_path, Diagnostics};
+
+    use std::sync::atomic::AtomicU64;
+
+    use anyhow::Result;
+    use ruff_python_ast::imports::ImportMap;
+
+    use ruff_workspace::Settings;
+    use test_case::test_case;
+
+    #[test_case("../ruff_linter/resources/test/fixtures", "ruff_tests/cache_same_results_ruff_linter"; "ruff_linter_fixtures")]
+    #[test_case("../ruff_notebook/resources/test/fixtures", "ruff_tests/cache_same_results_ruff_notebook"; "ruff_notebook_fixtures")]
+    fn same_results(package_root: &str, cache_dir_path: &str) {
+        let mut cache_dir = temp_dir();
+        cache_dir.push(cache_dir_path);
+        let _ = fs::remove_dir_all(&cache_dir);
+        cache::init(&cache_dir).unwrap();
+
+        let settings = Settings {
+            cache_dir,
+            ..Settings::default()
+        };
+
+        let package_root = fs::canonicalize(package_root).unwrap();
+        let cache = Cache::open(package_root.clone(), &settings);
+        assert_eq!(cache.new_files.lock().unwrap().len(), 0);
+
+        let mut paths = Vec::new();
+        let mut parse_errors = Vec::new();
+        let mut expected_diagnostics = Diagnostics::default();
+        for entry in fs::read_dir(&package_root).unwrap() {
+            let entry = entry.unwrap();
+            if !entry.file_type().unwrap().is_dir() {
+                continue;
+            }
+
+            let dir_path = entry.path();
+            if dir_path.ends_with(CACHE_DIR_NAME) {
+                continue;
+            }
+
+            for entry in fs::read_dir(dir_path).unwrap() {
+                let entry = entry.unwrap();
+                if !entry.file_type().unwrap().is_file() {
+                    continue;
+                }
+
+                let path = entry.path();
+                if path.ends_with("pyproject.toml") || path.ends_with("R.ipynb") {
+                    continue;
+                }
+
+                let diagnostics = lint_path(
+                    &path,
+                    Some(&package_root),
+                    &settings.linter,
+                    Some(&cache),
+                    flags::Noqa::Enabled,
+                    flags::FixMode::Generate,
+                )
+                .unwrap();
+                if diagnostics
+                    .messages
+                    .iter()
+                    .any(|m| m.kind.name == "SyntaxError")
+                {
+                    parse_errors.push(path.clone());
+                }
+                paths.push(path);
+                expected_diagnostics += diagnostics;
+            }
+        }
+        assert_ne!(paths, &[] as &[std::path::PathBuf], "no files checked");
+
+        cache.store().unwrap();
+
+        let cache = Cache::open(package_root.clone(), &settings);
+        assert_ne!(cache.package.files.len(), 0);
+
+        parse_errors.sort();
+
+        for path in &paths {
+            if parse_errors.binary_search(path).is_ok() {
+                continue; // We don't cache parsing errors.
+            }
+
+            let relative_path = cache.relative_path(path).unwrap();
+
+            assert!(
+                cache.package.files.contains_key(relative_path),
+                "missing file from cache: '{}'",
+                relative_path.display()
+            );
+        }
+
+        let mut got_diagnostics = Diagnostics::default();
+        for path in paths {
+            got_diagnostics += lint_path(
+                &path,
+                Some(&package_root),
+                &settings.linter,
+                Some(&cache),
+                flags::Noqa::Enabled,
+                flags::FixMode::Generate,
+            )
+            .unwrap();
+        }
+
+        assert_eq!(expected_diagnostics, got_diagnostics);
+    }
+
+    #[test]
+    fn cache_adds_file_on_lint() {
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+
+        let test_cache = TestCache::new("cache_adds_file_on_lint");
+        let cache = test_cache.open();
+        test_cache.write_source_file("source.py", source);
+        assert_eq!(cache.new_files.lock().unwrap().len(), 0);
+
+        cache.store().unwrap();
+        let cache = test_cache.open();
+
+        test_cache
+            .lint_file_with_cache("source.py", &cache)
+            .expect("Failed to lint test file");
+        assert_eq!(
+            cache.new_files.lock().unwrap().len(),
+            1,
+            "A single new file should be added to the cache"
+        );
+
+        cache.store().unwrap();
+    }
+
+    #[test]
+    fn cache_adds_files_on_lint() {
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+
+        let test_cache = TestCache::new("cache_adds_files_on_lint");
+        let cache = test_cache.open();
+        test_cache.write_source_file("source_1.py", source);
+        test_cache.write_source_file("source_2.py", source);
+        assert_eq!(cache.new_files.lock().unwrap().len(), 0);
+
+        cache.store().unwrap();
+        let cache = test_cache.open();
+
+        test_cache
+            .lint_file_with_cache("source_1.py", &cache)
+            .expect("Failed to lint test file");
+        test_cache
+            .lint_file_with_cache("source_2.py", &cache)
+            .expect("Failed to lint test file");
+        assert_eq!(
+            cache.new_files.lock().unwrap().len(),
+            2,
+            "Both files should be added to the cache"
+        );
+
+        cache.store().unwrap();
+    }
+
+    #[test]
+    fn cache_invalidated_on_file_modified_time() {
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+
+        let test_cache = TestCache::new("cache_invalidated_on_file_modified_time");
+        let cache = test_cache.open();
+        let source_path = test_cache.write_source_file("source.py", source);
+        assert_eq!(cache.new_files.lock().unwrap().len(), 0);
+
+        let expected_diagnostics = test_cache
+            .lint_file_with_cache("source.py", &cache)
+            .expect("Failed to lint test file");
+
+        cache.store().unwrap();
+        let cache = test_cache.open();
+
+        // Update the modified time of the file to a time in the future
+        set_file_mtime(
+            source_path,
+            FileTime::from_system_time(SystemTime::now() + std::time::Duration::from_secs(1)),
+        )
+        .unwrap();
+
+        let got_diagnostics = test_cache
+            .lint_file_with_cache("source.py", &cache)
+            .expect("Failed to lint test file");
+
+        assert_eq!(
+            cache.new_files.lock().unwrap().len(),
+            1,
+            "Cache should not be used, the file should be treated as new and added to the cache"
+        );
+
+        assert_eq!(
+            expected_diagnostics, got_diagnostics,
+            "The diagnostics should not change"
+        );
+    }
+
+    #[test]
+    fn cache_invalidated_on_permission_change() {
+        // Regression test for issue #3086.
+
+        #[cfg(unix)]
+        #[allow(clippy::items_after_statements)]
+        fn flip_execute_permission_bit(path: &Path) -> io::Result<()> {
+            use std::os::unix::fs::PermissionsExt;
+            let file = fs::OpenOptions::new().write(true).open(path)?;
+            let perms = file.metadata()?.permissions();
+            file.set_permissions(PermissionsExt::from_mode(perms.mode() ^ 0o111))
+        }
+
+        #[cfg(windows)]
+        #[allow(clippy::items_after_statements)]
+        fn flip_read_only_permission(path: &Path) -> io::Result<()> {
+            let file = fs::OpenOptions::new().write(true).open(path)?;
+            let mut perms = file.metadata()?.permissions();
+            perms.set_readonly(!perms.readonly());
+            file.set_permissions(perms)
+        }
+
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+
+        let test_cache = TestCache::new("cache_invalidated_on_permission_change");
+        let cache = test_cache.open();
+        let path = test_cache.write_source_file("source.py", source);
+        assert_eq!(cache.new_files.lock().unwrap().len(), 0);
+
+        let expected_diagnostics = test_cache
+            .lint_file_with_cache("source.py", &cache)
+            .unwrap();
+
+        cache.store().unwrap();
+        let cache = test_cache.open();
+
+        // Flip the permissions on the file
+        #[cfg(unix)]
+        flip_execute_permission_bit(&path).unwrap();
+        #[cfg(windows)]
+        flip_read_only_permission(&path).unwrap();
+
+        let got_diagnostics = test_cache
+            .lint_file_with_cache("source.py", &cache)
+            .unwrap();
+
+        assert_eq!(
+            cache.new_files.lock().unwrap().len(),
+            1,
+            "Cache should not be used, the file should be treated as new and added to the cache"
+        );
+
+        assert_eq!(
+            expected_diagnostics, got_diagnostics,
+            "The diagnostics should not change"
+        );
+    }
+
+    #[test]
+    fn cache_removes_stale_files_on_store() {
+        let test_cache = TestCache::new("cache_removes_stale_files_on_store");
+        let mut cache = test_cache.open();
+
+        // Add a file to the cache that hasn't been linted or seen since the '70s!
+        let old_path_key = RelativePathBuf::from("old.py");
+        cache.package.files.insert(
+            old_path_key,
+            FileCache {
+                key: 123,
+                last_seen: AtomicU64::new(123),
+                imports: ImportMap::new(),
+                messages: Vec::new(),
+                source: String::new(),
+                notebook_index: None,
+            },
+        );
+
+        // Now actually lint a file.
+        let source: &[u8] = b"a = 1\n\n__all__ = list([\"a\", \"b\"])\n";
+        test_cache.write_source_file("new.py", source);
+        let new_path_key = RelativePathBuf::from("new.py");
+        assert_eq!(cache.new_files.lock().unwrap().len(), 0);
+
+        test_cache
+            .lint_file_with_cache("new.py", &cache)
+            .expect("Failed to lint test file");
+
+        // Storing the cache should remove the old (`old.py`) file.
+        cache.store().unwrap();
+        // So we when we open the cache again it shouldn't contain `old.py`.
+        let cache = test_cache.open();
+
+        assert!(
+            cache.package.files.keys().collect_vec() == vec![&new_path_key],
+            "Only the new file should be present"
+        );
+    }
+
+    struct TestCache {
+        package_root: PathBuf,
+        settings: Settings,
+    }
+
+    impl TestCache {
+        fn new(name: &str) -> Self {
+            // Build a new cache directory and clear it
+            let mut test_dir = temp_dir();
+            test_dir.push("ruff_tests/cache");
+            test_dir.push(name);
+
+            let _ = fs::remove_dir_all(&test_dir);
+
+            // Create separate directories for the cache and the test package
+            let cache_dir = test_dir.join("cache");
+            let package_root = test_dir.join("package");
+
+            cache::init(&cache_dir).unwrap();
+            fs::create_dir(package_root.clone()).unwrap();
+
+            let settings = Settings {
+                cache_dir,
+                ..Settings::default()
+            };
+
+            Self {
+                package_root,
+                settings,
+            }
+        }
+
+        fn write_source_file(&self, path: &str, contents: &[u8]) -> PathBuf {
+            let path = self.package_root.join(path);
+            let mut file = fs::OpenOptions::new()
+                .write(true)
+                .create(true)
+                .truncate(true)
+                .open(&*path)
+                .unwrap();
+            file.write_all(contents).unwrap();
+            file.sync_data().unwrap();
+            path
+        }
+
+        fn open(&self) -> Cache {
+            Cache::open(self.package_root.clone(), &self.settings)
+        }
+
+        fn lint_file_with_cache(
+            &self,
+            path: &str,
+            cache: &Cache,
+        ) -> Result<Diagnostics, anyhow::Error> {
+            lint_path(
+                &self.package_root.join(path),
+                Some(&self.package_root),
+                &self.settings.linter,
+                Some(cache),
+                flags::Noqa::Enabled,
+                flags::FixMode::Generate,
+            )
+        }
+    }
+
+    impl Drop for TestCache {
+        fn drop(&mut self) {
+            let _ = fs::remove_dir_all(&self.settings.cache_dir);
+        }
+    }
+}

crates/ruff_cli/src/commands/add_noqa.rs

@@ -0,0 +1,82 @@
+use std::path::PathBuf;
+use std::time::Instant;
+
+use anyhow::Result;
+use log::{debug, error};
+#[cfg(not(target_family = "wasm"))]
+use rayon::prelude::*;
+
+use ruff_linter::linter::add_noqa_to_path;
+use ruff_linter::warn_user_once;
+use ruff_python_ast::{PySourceType, SourceType};
+use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig};
+
+use crate::args::CliOverrides;
+use crate::diagnostics::LintSource;
+
+/// Add `noqa` directives to a collection of files.
+pub(crate) fn add_noqa(
+    files: &[PathBuf],
+    pyproject_config: &PyprojectConfig,
+    overrides: &CliOverrides,
+) -> Result<usize> {
+    // Collect all the files to check.
+    let start = Instant::now();
+    let (paths, resolver) = python_files_in_path(files, pyproject_config, 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);
+    }
+
+    // Discover the package root for each Python file.
+    let package_roots = resolver.package_roots(
+        &paths
+            .iter()
+            .flatten()
+            .map(ignore::DirEntry::path)
+            .collect::<Vec<_>>(),
+        pyproject_config,
+    );
+
+    let start = Instant::now();
+    let modifications: usize = paths
+        .par_iter()
+        .flatten()
+        .filter_map(|entry| {
+            let path = entry.path();
+            let SourceType::Python(source_type @ (PySourceType::Python | PySourceType::Stub)) =
+                SourceType::from(path)
+            else {
+                return None;
+            };
+            let package = path
+                .parent()
+                .and_then(|parent| package_roots.get(parent))
+                .and_then(|package| *package);
+            let settings = resolver.resolve(path, pyproject_config);
+            let LintSource(source_kind) = match LintSource::try_from_path(path, source_type) {
+                Ok(Some(source)) => source,
+                Ok(None) => return None,
+                Err(e) => {
+                    error!("Failed to extract source from {}: {e}", path.display());
+                    return None;
+                }
+            };
+            match add_noqa_to_path(path, package, &source_kind, source_type, &settings.linter) {
+                Ok(count) => Some(count),
+                Err(e) => {
+                    error!("Failed to add noqa to {}: {e}", path.display());
+                    None
+                }
+            }
+        })
+        .sum();
+
+    let duration = start.elapsed();
+    debug!("Added noqa to files in: {:?}", duration);
+
+    Ok(modifications)
+}

crates/ruff_cli/src/commands/check.rs

@@ -0,0 +1,314 @@
+use std::collections::HashMap;
+use std::fmt::Write;
+use std::io;
+use std::path::{Path, PathBuf};
+use std::time::Instant;
+
+use anyhow::Result;
+use colored::Colorize;
+use ignore::Error;
+use itertools::Itertools;
+use log::{debug, error, warn};
+#[cfg(not(target_family = "wasm"))]
+use rayon::prelude::*;
+use rustc_hash::FxHashMap;
+
+use ruff_diagnostics::Diagnostic;
+use ruff_linter::message::Message;
+use ruff_linter::registry::Rule;
+use ruff_linter::settings::{flags, LinterSettings};
+use ruff_linter::{fs, warn_user_once, IOError};
+use ruff_python_ast::imports::ImportMap;
+use ruff_source_file::SourceFileBuilder;
+use ruff_text_size::{TextRange, TextSize};
+use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, PyprojectDiscoveryStrategy};
+
+use crate::args::CliOverrides;
+use crate::cache::{self, Cache};
+use crate::diagnostics::Diagnostics;
+use crate::panic::catch_unwind;
+
+/// Run the linter over a collection of files.
+pub(crate) fn check(
+    files: &[PathBuf],
+    pyproject_config: &PyprojectConfig,
+    overrides: &CliOverrides,
+    cache: flags::Cache,
+    noqa: flags::Noqa,
+    autofix: flags::FixMode,
+) -> Result<Diagnostics> {
+    // Collect all the Python files to check.
+    let start = Instant::now();
+    let (paths, resolver) = python_files_in_path(files, pyproject_config, 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());
+    }
+
+    // Initialize the cache.
+    if cache.into() {
+        fn init_cache(path: &Path) {
+            if let Err(e) = cache::init(path) {
+                error!("Failed to initialize cache at {}: {e:?}", path.display());
+            }
+        }
+
+        match pyproject_config.strategy {
+            PyprojectDiscoveryStrategy::Fixed => {
+                init_cache(&pyproject_config.settings.cache_dir);
+            }
+            PyprojectDiscoveryStrategy::Hierarchical => {
+                for settings in
+                    std::iter::once(&pyproject_config.settings).chain(resolver.settings())
+                {
+                    init_cache(&settings.cache_dir);
+                }
+            }
+        }
+    };
+
+    // Discover the package root for each Python file.
+    let package_roots = resolver.package_roots(
+        &paths
+            .iter()
+            .flatten()
+            .map(ignore::DirEntry::path)
+            .collect::<Vec<_>>(),
+        pyproject_config,
+    );
+
+    // Load the caches.
+    let caches = bool::from(cache).then(|| {
+        package_roots
+            .iter()
+            .map(|(package, package_root)| package_root.unwrap_or(package))
+            .unique()
+            .par_bridge()
+            .map(|cache_root| {
+                let settings = resolver.resolve(cache_root, pyproject_config);
+                let cache = Cache::open(cache_root.to_path_buf(), settings);
+                (cache_root, cache)
+            })
+            .collect::<HashMap<&Path, Cache>>()
+    });
+
+    let start = Instant::now();
+    let mut diagnostics: Diagnostics = paths
+        .par_iter()
+        .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_config);
+
+                    let cache_root = package.unwrap_or_else(|| path.parent().unwrap_or(path));
+                    let cache = caches.as_ref().and_then(|caches| {
+                        if let Some(cache) = caches.get(&cache_root) {
+                            Some(cache)
+                        } else {
+                            debug!("No cache found for {}", cache_root.display());
+                            None
+                        }
+                    });
+
+                    lint_path(path, package, &settings.linter, cache, noqa, autofix).map_err(|e| {
+                        (Some(path.to_owned()), {
+                            let mut error = e.to_string();
+                            for cause in e.chain() {
+                                write!(&mut error, "\n  Cause: {cause}").unwrap();
+                            }
+                            error
+                        })
+                    })
+                }
+                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_config);
+                    if settings.linter.rules.enabled(Rule::IOError) {
+                        let dummy =
+                            SourceFileBuilder::new(path.to_string_lossy().as_ref(), "").finish();
+
+                        Diagnostics::new(
+                            vec![Message::from_diagnostic(
+                                Diagnostic::new(IOError { message }, TextRange::default()),
+                                dummy,
+                                TextSize::default(),
+                            )],
+                            ImportMap::default(),
+                            FxHashMap::default(),
+                        )
+                    } else {
+                        warn!(
+                            "{}{}{} {message}",
+                            "Failed to lint ".bold(),
+                            fs::relativize_path(path).bold(),
+                            ":".bold()
+                        );
+                        Diagnostics::default()
+                    }
+                } else {
+                    warn!("{} {message}", "Encountered error:".bold());
+                    Diagnostics::default()
+                }
+            })
+        })
+        .reduce(Diagnostics::default, |mut acc, item| {
+            acc += item;
+            acc
+        });
+
+    diagnostics.messages.sort();
+
+    // Store the caches.
+    if let Some(caches) = caches {
+        caches
+            .into_par_iter()
+            .try_for_each(|(_, cache)| cache.store())?;
+    }
+
+    let duration = start.elapsed();
+    debug!("Checked {:?} files in: {:?}", paths.len(), duration);
+
+    Ok(diagnostics)
+}
+
+/// Wraps [`lint_path`](crate::diagnostics::lint_path) in a [`catch_unwind`](std::panic::catch_unwind) and emits
+/// a diagnostic if the linting the file panics.
+fn lint_path(
+    path: &Path,
+    package: Option<&Path>,
+    settings: &LinterSettings,
+    cache: Option<&Cache>,
+    noqa: flags::Noqa,
+    autofix: flags::FixMode,
+) -> Result<Diagnostics> {
+    let result = catch_unwind(|| {
+        crate::diagnostics::lint_path(path, package, settings, cache, noqa, autofix)
+    });
+
+    match result {
+        Ok(inner) => inner,
+        Err(error) => {
+            let message = r#"This indicates a bug in Ruff. If you could open an issue at:
+
+    https://github.com/astral-sh/ruff/issues/new?title=%5BLinter%20panic%5D
+
+...with the relevant file contents, the `pyproject.toml` settings, and the following stack trace, we'd be very appreciative!
+"#;
+
+            error!(
+                "{}{}{} {message}\n{error}",
+                "Panicked while linting ".bold(),
+                fs::relativize_path(path).bold(),
+                ":".bold()
+            );
+
+            Ok(Diagnostics::default())
+        }
+    }
+}
+
+#[cfg(test)]
+#[cfg(unix)]
+mod test {
+    use std::fs;
+    use std::os::unix::fs::OpenOptionsExt;
+
+    use anyhow::Result;
+    use rustc_hash::FxHashMap;
+    use tempfile::TempDir;
+
+    use ruff_linter::message::{Emitter, EmitterContext, TextEmitter};
+    use ruff_linter::registry::Rule;
+    use ruff_linter::settings::{flags, LinterSettings};
+    use ruff_workspace::resolver::{PyprojectConfig, PyprojectDiscoveryStrategy};
+    use ruff_workspace::Settings;
+
+    use crate::args::CliOverrides;
+
+    use super::check;
+
+    /// We check that regular python files, pyproject.toml and jupyter notebooks all handle io
+    /// errors gracefully
+    #[test]
+    fn unreadable_files() -> Result<()> {
+        let path = "E902.py";
+        let rule_code = Rule::IOError;
+
+        // Create inaccessible files
+        let tempdir = TempDir::new()?;
+        let pyproject_toml = tempdir.path().join("pyproject.toml");
+        let python_file = tempdir.path().join("code.py");
+        let notebook = tempdir.path().join("notebook.ipynb");
+        for file in [&pyproject_toml, &python_file, &notebook] {
+            fs::OpenOptions::new()
+                .create(true)
+                .write(true)
+                .mode(0o000)
+                .open(file)?;
+        }
+
+        // Configure
+        let snapshot = format!("{}_{}", rule_code.noqa_code(), path);
+        // invalid pyproject.toml is not active by default
+        let settings = Settings {
+            linter: LinterSettings::for_rules(vec![rule_code, Rule::InvalidPyprojectToml]),
+            ..Settings::default()
+        };
+        let pyproject_config =
+            PyprojectConfig::new(PyprojectDiscoveryStrategy::Fixed, settings, None);
+
+        // Run
+        let diagnostics = check(
+            // Notebooks are not included by default
+            &[tempdir.path().to_path_buf(), notebook],
+            &pyproject_config,
+            &CliOverrides::default(),
+            flags::Cache::Disabled,
+            flags::Noqa::Disabled,
+            flags::FixMode::Generate,
+        )
+        .unwrap();
+        let mut output = Vec::new();
+
+        TextEmitter::default()
+            .with_show_fix_status(true)
+            .emit(
+                &mut output,
+                &diagnostics.messages,
+                &EmitterContext::new(&FxHashMap::default()),
+            )
+            .unwrap();
+
+        let messages = String::from_utf8(output).unwrap();
+
+        insta::with_settings!({
+            omit_expression => true,
+            filters => vec![
+                // The tempdir is always different (and platform dependent)
+                (tempdir.path().to_str().unwrap(), "/home/ferris/project"),
+            ]
+        }, {
+            insta::assert_snapshot!(snapshot, messages);
+        });
+        Ok(())
+    }
+}

crates/ruff_cli/src/commands/check_stdin.rs

@@ -0,0 +1,40 @@
+use std::path::Path;
+
+use anyhow::Result;
+
+use ruff_linter::packaging;
+use ruff_linter::settings::flags;
+use ruff_workspace::resolver::{python_file_at_path, PyprojectConfig};
+
+use crate::args::CliOverrides;
+use crate::diagnostics::{lint_stdin, Diagnostics};
+use crate::stdin::read_from_stdin;
+
+/// Run the linter over a single file, read from `stdin`.
+pub(crate) fn check_stdin(
+    filename: Option<&Path>,
+    pyproject_config: &PyprojectConfig,
+    overrides: &CliOverrides,
+    noqa: flags::Noqa,
+    autofix: flags::FixMode,
+) -> Result<Diagnostics> {
+    if let Some(filename) = filename {
+        if !python_file_at_path(filename, pyproject_config, overrides)? {
+            return Ok(Diagnostics::default());
+        }
+    }
+    let package_root = filename.and_then(Path::parent).and_then(|path| {
+        packaging::detect_package_root(path, &pyproject_config.settings.linter.namespace_packages)
+    });
+    let stdin = read_from_stdin()?;
+    let mut diagnostics = lint_stdin(
+        filename,
+        package_root,
+        stdin,
+        &pyproject_config.settings,
+        noqa,
+        autofix,
+    )?;
+    diagnostics.messages.sort_unstable();
+    Ok(diagnostics)
+}

crates/ruff_cli/src/commands/clean.rs

@@ -0,0 +1,34 @@
+use std::fs::remove_dir_all;
+use std::io::{self, BufWriter, Write};
+
+use anyhow::Result;
+use colored::Colorize;
+use path_absolutize::path_dedot;
+use walkdir::WalkDir;
+
+use ruff_cache::CACHE_DIR_NAME;
+use ruff_linter::fs;
+use ruff_linter::logging::LogLevel;
+
+/// Clear any caches in the current directory or any subdirectories.
+pub(crate) fn clean(level: LogLevel) -> Result<()> {
+    let mut stderr = BufWriter::new(io::stderr().lock());
+    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 {
+                writeln!(
+                    stderr,
+                    "Removing cache at: {}",
+                    fs::relativize_path(&cache).bold()
+                )?;
+            }
+            remove_dir_all(&cache)?;
+        }
+    }
+    Ok(())
+}

crates/ruff_cli/src/commands/config.rs

@@ -0,0 +1,19 @@
+use anyhow::{anyhow, Result};
+
+use ruff_workspace::options::Options;
+
+#[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) {
+            None => {
+                return Err(anyhow!("Unknown option: {key}"));
+            }
+            Some(entry) => {
+                print!("{entry}");
+            }
+        },
+    }
+    Ok(())
+}

crates/ruff_cli/src/commands/format.rs

@@ -0,0 +1,343 @@
+use std::fmt::{Display, Formatter};
+use std::io;
+use std::path::{Path, PathBuf};
+use std::time::Instant;
+
+use anyhow::Result;
+use colored::Colorize;
+use log::error;
+use rayon::iter::Either::{Left, Right};
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use thiserror::Error;
+use tracing::debug;
+
+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_source, FormatModuleError, PyFormatOptions};
+use ruff_source_file::{find_newline, LineEnding};
+use ruff_workspace::resolver::python_files_in_path;
+
+use crate::args::{CliOverrides, FormatArguments};
+use crate::panic::{catch_unwind, PanicError};
+use crate::resolve::resolve;
+use crate::ExitStatus;
+
+#[derive(Debug, Copy, Clone, is_macro::Is)]
+pub(crate) enum FormatMode {
+    /// Write the formatted contents back to the file.
+    Write,
+    /// Check if the file is formatted, but do not write the formatted contents back.
+    Check,
+}
+
+/// Format a set of files, and return the exit status.
+pub(crate) fn format(
+    cli: &FormatArguments,
+    overrides: &CliOverrides,
+    log_level: LogLevel,
+) -> Result<ExitStatus> {
+    let pyproject_config = resolve(
+        cli.isolated,
+        cli.config.as_deref(),
+        overrides,
+        cli.stdin_filename.as_deref(),
+    )?;
+    let mode = if cli.check {
+        FormatMode::Check
+    } else {
+        FormatMode::Write
+    };
+    let (paths, resolver) = python_files_in_path(&cli.files, &pyproject_config, overrides)?;
+
+    if paths.is_empty() {
+        warn_user_once!("No Python files found under the given path(s)");
+        return Ok(ExitStatus::Success);
+    }
+
+    let start = Instant::now();
+    let (results, errors): (Vec<_>, Vec<_>) = paths
+        .into_par_iter()
+        .filter_map(|entry| {
+            match entry {
+                Ok(entry) => {
+                    let path = entry.path();
+
+                    let SourceType::Python(
+                        source_type @ (PySourceType::Python | PySourceType::Stub),
+                    ) = SourceType::from(path)
+                    else {
+                        // Ignore any non-Python files.
+                        return None;
+                    };
+
+                    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))
+                        }
+                    })
+                }
+                Err(err) => Some(Err(FormatCommandError::Ignore(err))),
+            }
+        })
+        .partition_map(|result| match result {
+            Ok(diagnostic) => Left(diagnostic),
+            Err(err) => Right(err),
+        });
+    let duration = start.elapsed();
+
+    debug!(
+        "Formatted {} files in {:.2?}",
+        results.len() + errors.len(),
+        duration
+    );
+
+    // Report on any errors.
+    for error in &errors {
+        error!("{error}");
+    }
+
+    let summary = FormatResultSummary::new(results, mode);
+
+    // Report on the formatting changes.
+    if log_level >= LogLevel::Default {
+        #[allow(clippy::print_stdout)]
+        {
+            println!("{summary}");
+        }
+    }
+
+    match mode {
+        FormatMode::Write => {
+            if errors.is_empty() {
+                Ok(ExitStatus::Success)
+            } else {
+                Ok(ExitStatus::Error)
+            }
+        }
+        FormatMode::Check => {
+            if errors.is_empty() {
+                if summary.formatted > 0 {
+                    Ok(ExitStatus::Failure)
+                } else {
+                    Ok(ExitStatus::Success)
+                }
+            } else {
+                Ok(ExitStatus::Error)
+            }
+        }
+    }
+}
+
+/// Format the file at the given [`Path`].
+#[tracing::instrument(skip_all, fields(path = %path.display()))]
+fn format_path(
+    path: &Path,
+    options: PyFormatOptions,
+    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 formatted = format_module_source(&unformatted, options)
+        .map_err(|err| FormatCommandError::FormatModule(Some(path.to_path_buf()), err))?;
+
+    let formatted = formatted.as_code();
+    if formatted.len() == unformatted.len() && formatted == unformatted {
+        Ok(FormatCommandResult::Unchanged)
+    } else {
+        if mode.is_write() {
+            std::fs::write(path, formatted.as_bytes())
+                .map_err(|err| FormatCommandError::Write(Some(path.to_path_buf()), err))?;
+        }
+        Ok(FormatCommandResult::Formatted)
+    }
+}
+
+#[derive(Debug, Clone, Copy, is_macro::Is)]
+pub(crate) enum FormatCommandResult {
+    /// The file was formatted.
+    Formatted,
+    /// The file was unchanged, as the formatted contents matched the existing contents.
+    Unchanged,
+}
+
+#[derive(Debug)]
+struct FormatResultSummary {
+    /// The format mode that was used.
+    mode: FormatMode,
+    /// The number of files that were formatted.
+    formatted: usize,
+    /// The number of files that were unchanged.
+    unchanged: usize,
+}
+
+impl FormatResultSummary {
+    fn new(diagnostics: Vec<FormatCommandResult>, mode: FormatMode) -> Self {
+        let mut summary = Self {
+            mode,
+            formatted: 0,
+            unchanged: 0,
+        };
+        for diagnostic in diagnostics {
+            match diagnostic {
+                FormatCommandResult::Formatted => summary.formatted += 1,
+                FormatCommandResult::Unchanged => summary.unchanged += 1,
+            }
+        }
+        summary
+    }
+}
+
+impl Display for FormatResultSummary {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        if self.formatted > 0 && self.unchanged > 0 {
+            write!(
+                f,
+                "{} file{} {}, {} file{} left unchanged",
+                self.formatted,
+                if self.formatted == 1 { "" } else { "s" },
+                match self.mode {
+                    FormatMode::Write => "reformatted",
+                    FormatMode::Check => "would be reformatted",
+                },
+                self.unchanged,
+                if self.unchanged == 1 { "" } else { "s" },
+            )
+        } else if self.formatted > 0 {
+            write!(
+                f,
+                "{} file{} {}",
+                self.formatted,
+                if self.formatted == 1 { "" } else { "s" },
+                match self.mode {
+                    FormatMode::Write => "reformatted",
+                    FormatMode::Check => "would be reformatted",
+                }
+            )
+        } else if self.unchanged > 0 {
+            write!(
+                f,
+                "{} file{} left unchanged",
+                self.unchanged,
+                if self.unchanged == 1 { "" } else { "s" },
+            )
+        } else {
+            Ok(())
+        }
+    }
+}
+
+/// An error that can occur while formatting a set of files.
+#[derive(Error, Debug)]
+pub(crate) enum FormatCommandError {
+    Ignore(#[from] ignore::Error),
+    Read(Option<PathBuf>, io::Error),
+    Write(Option<PathBuf>, io::Error),
+    FormatModule(Option<PathBuf>, FormatModuleError),
+    Panic(Option<PathBuf>, PanicError),
+}
+
+impl Display for FormatCommandError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Ignore(err) => {
+                if let ignore::Error::WithPath { path, .. } = err {
+                    write!(
+                        f,
+                        "{}{}{} {}",
+                        "Failed to format ".bold(),
+                        fs::relativize_path(path).bold(),
+                        ":".bold(),
+                        err.io_error()
+                            .map_or_else(|| err.to_string(), std::string::ToString::to_string)
+                    )
+                } else {
+                    write!(
+                        f,
+                        "{} {}",
+                        "Encountered error:".bold(),
+                        err.io_error()
+                            .map_or_else(|| err.to_string(), std::string::ToString::to_string)
+                    )
+                }
+            }
+            Self::Read(path, err) => {
+                if let Some(path) = path {
+                    write!(
+                        f,
+                        "{}{}{} {err}",
+                        "Failed to read ".bold(),
+                        fs::relativize_path(path).bold(),
+                        ":".bold()
+                    )
+                } else {
+                    write!(f, "{}{} {err}", "Failed to read".bold(), ":".bold())
+                }
+            }
+            Self::Write(path, err) => {
+                if let Some(path) = path {
+                    write!(
+                        f,
+                        "{}{}{} {err}",
+                        "Failed to write ".bold(),
+                        fs::relativize_path(path).bold(),
+                        ":".bold()
+                    )
+                } else {
+                    write!(f, "{}{} {err}", "Failed to write".bold(), ":".bold())
+                }
+            }
+            Self::FormatModule(path, err) => {
+                if let Some(path) = path {
+                    write!(
+                        f,
+                        "{}{}{} {err}",
+                        "Failed to format ".bold(),
+                        fs::relativize_path(path).bold(),
+                        ":".bold()
+                    )
+                } else {
+                    write!(f, "{}{} {err}", "Failed to format".bold(), ":".bold())
+                }
+            }
+            Self::Panic(path, err) => {
+                let message = r#"This indicates a bug in Ruff. If you could open an issue at:
+
+    https://github.com/astral-sh/ruff/issues/new?title=%5BFormatter%20panic%5D
+
+...with the relevant file contents, the `pyproject.toml` settings, and the following stack trace, we'd be very appreciative!
+"#;
+                if let Some(path) = path {
+                    write!(
+                        f,
+                        "{}{}{} {message}\n{err}",
+                        "Panicked while formatting ".bold(),
+                        fs::relativize_path(path).bold(),
+                        ":".bold()
+                    )
+                } else {
+                    write!(
+                        f,
+                        "{} {message}\n{err}",
+                        "Panicked while formatting.".bold()
+                    )
+                }
+            }
+        }
+    }
+}

crates/ruff_cli/src/commands/format_stdin.rs

@@ -0,0 +1,96 @@
+use std::io::{stdout, Write};
+use std::path::Path;
+
+use anyhow::Result;
+use log::warn;
+
+use ruff_python_ast::PySourceType;
+use ruff_python_formatter::{
+    format_module_source, format_module_source_range, LspRowColumn, PyFormatOptions,
+};
+use ruff_workspace::resolver::python_file_at_path;
+
+use crate::args::{CliOverrides, FormatArguments};
+use crate::commands::format::{FormatCommandError, FormatCommandResult, FormatMode};
+use crate::resolve::resolve;
+use crate::stdin::read_from_stdin;
+use crate::ExitStatus;
+
+/// Run the formatter over a single file, read from `stdin`.
+pub(crate) fn format_stdin(cli: &FormatArguments, overrides: &CliOverrides) -> Result<ExitStatus> {
+    let pyproject_config = resolve(
+        cli.isolated,
+        cli.config.as_deref(),
+        overrides,
+        cli.stdin_filename.as_deref(),
+    )?;
+    let mode = if cli.check {
+        FormatMode::Check
+    } else {
+        FormatMode::Write
+    };
+
+    if let Some(filename) = cli.stdin_filename.as_deref() {
+        if !python_file_at_path(filename, &pyproject_config, overrides)? {
+            return Ok(ExitStatus::Success);
+        }
+    }
+
+    // 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, cli.start, cli.end) {
+        Ok(result) => match mode {
+            FormatMode::Write => Ok(ExitStatus::Success),
+            FormatMode::Check => {
+                if result.is_formatted() {
+                    Ok(ExitStatus::Failure)
+                } else {
+                    Ok(ExitStatus::Success)
+                }
+            }
+        },
+        Err(err) => {
+            warn!("{err}");
+            Ok(ExitStatus::Error)
+        }
+    }
+}
+
+/// Format source code read from `stdin`.
+fn format_source(
+    path: Option<&Path>,
+    options: PyFormatOptions,
+    mode: FormatMode,
+    start: Option<LspRowColumn>,
+    end: Option<LspRowColumn>,
+) -> Result<FormatCommandResult, FormatCommandError> {
+    let unformatted = read_from_stdin()
+        .map_err(|err| FormatCommandError::Read(path.map(Path::to_path_buf), err))?;
+    let formatted = if start.is_some() || end.is_some() {
+        let formatted = format_module_source_range(&unformatted, options, start, end)
+            .map_err(|err| FormatCommandError::FormatModule(path.map(Path::to_path_buf), err))?;
+        formatted
+    } else {
+        let formatted = format_module_source(&unformatted, options)
+            .map_err(|err| FormatCommandError::FormatModule(path.map(Path::to_path_buf), err))?;
+        let formatted = formatted.as_code();
+        formatted.to_string()
+    };
+    if formatted.len() == unformatted.len() && formatted == unformatted {
+        Ok(FormatCommandResult::Unchanged)
+    } else {
+        if mode.is_write() {
+            stdout()
+                .lock()
+                .write_all(formatted.as_bytes())
+                .map_err(|err| FormatCommandError::Write(path.map(Path::to_path_buf), err))?;
+        }
+        Ok(FormatCommandResult::Formatted)
+    }
+}

crates/ruff_cli/src/commands/linter.rs

@@ -0,0 +1,71 @@
+use std::fmt::Write;
+use std::io;
+use std::io::BufWriter;
+
+use anyhow::Result;
+use itertools::Itertools;
+use serde::Serialize;
+use strum::IntoEnumIterator;
+
+use ruff_linter::registry::{Linter, RuleNamespace};
+
+use crate::args::HelpFormat;
+
+#[derive(Serialize)]
+struct LinterInfo {
+    prefix: &'static str,
+    name: &'static str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    categories: Option<Vec<LinterCategoryInfo>>,
+}
+
+#[derive(Serialize)]
+struct LinterCategoryInfo {
+    prefix: &'static str,
+    name: &'static str,
+}
+
+pub(crate) fn linter(format: HelpFormat) -> Result<()> {
+    let mut stdout = BufWriter::new(io::stdout().lock());
+    let mut output = String::new();
+
+    match format {
+        HelpFormat::Text => {
+            for linter in Linter::iter() {
+                let prefix = match linter.common_prefix() {
+                    "" => linter
+                        .upstream_categories()
+                        .unwrap()
+                        .iter()
+                        .map(|c| c.prefix)
+                        .join("/"),
+                    prefix => prefix.to_string(),
+                };
+                writeln!(output, "{:>4} {}", prefix, linter.name()).unwrap();
+            }
+        }
+
+        HelpFormat::Json => {
+            let linters: Vec<_> = Linter::iter()
+                .map(|linter_info| LinterInfo {
+                    prefix: linter_info.common_prefix(),
+                    name: linter_info.name(),
+                    categories: linter_info.upstream_categories().map(|cats| {
+                        cats.iter()
+                            .map(|c| LinterCategoryInfo {
+                                prefix: c.prefix,
+                                name: c.category,
+                            })
+                            .collect()
+                    }),
+                })
+                .collect();
+            output.push_str(&serde_json::to_string_pretty(&linters)?);
+            output.push('\n');
+        }
+    }
+
+    io::Write::write_fmt(&mut stdout, format_args!("{output}"))?;
+
+    Ok(())
+}

crates/ruff_cli/src/commands/mod.rs

@@ -0,0 +1,11 @@
+pub(crate) mod add_noqa;
+pub(crate) mod check;
+pub(crate) mod check_stdin;
+pub(crate) mod clean;
+pub(crate) mod config;
+pub(crate) mod format;
+pub(crate) mod format_stdin;
+pub(crate) mod linter;
+pub(crate) mod rule;
+pub(crate) mod show_files;
+pub(crate) mod show_settings;

crates/ruff_cli/src/commands/rule.rs

@@ -0,0 +1,115 @@
+use std::io::{self, BufWriter, Write};
+
+use anyhow::Result;
+use serde::ser::SerializeSeq;
+use serde::{Serialize, Serializer};
+use strum::IntoEnumIterator;
+
+use ruff_diagnostics::AutofixKind;
+use ruff_linter::registry::{Linter, Rule, RuleNamespace};
+
+use crate::args::HelpFormat;
+
+#[derive(Serialize)]
+struct Explanation<'a> {
+    name: &'a str,
+    code: String,
+    linter: &'a str,
+    summary: &'a str,
+    message_formats: &'a [&'a str],
+    autofix: String,
+    explanation: Option<&'a str>,
+    preview: bool,
+}
+
+impl<'a> Explanation<'a> {
+    fn from_rule(rule: &'a Rule) -> Self {
+        let code = rule.noqa_code().to_string();
+        let (linter, _) = Linter::parse_code(&code).unwrap();
+        let autofix = rule.autofixable().to_string();
+        Self {
+            name: rule.as_ref(),
+            code,
+            linter: linter.name(),
+            summary: rule.message_formats()[0],
+            message_formats: rule.message_formats(),
+            autofix,
+            explanation: rule.explanation(),
+            preview: rule.is_preview(),
+        }
+    }
+}
+
+fn format_rule_text(rule: Rule) -> String {
+    let mut output = String::new();
+    output.push_str(&format!("# {} ({})", rule.as_ref(), rule.noqa_code()));
+    output.push('\n');
+    output.push('\n');
+
+    let (linter, _) = Linter::parse_code(&rule.noqa_code().to_string()).unwrap();
+    output.push_str(&format!("Derived from the **{}** linter.", linter.name()));
+    output.push('\n');
+    output.push('\n');
+
+    let autofix = rule.autofixable();
+    if matches!(autofix, AutofixKind::Always | AutofixKind::Sometimes) {
+        output.push_str(&autofix.to_string());
+        output.push('\n');
+        output.push('\n');
+    }
+
+    if rule.is_preview() {
+        output.push_str(
+            r#"This rule is in preview and is not stable. The `--preview` flag is required for use."#,
+        );
+        output.push('\n');
+        output.push('\n');
+    }
+
+    if let Some(explanation) = rule.explanation() {
+        output.push_str(explanation.trim());
+    } else {
+        output.push_str("Message formats:");
+        for format in rule.message_formats() {
+            output.push('\n');
+            output.push_str(&format!("* {format}"));
+        }
+    }
+    output
+}
+
+/// Explain a `Rule` to the user.
+pub(crate) fn rule(rule: Rule, format: HelpFormat) -> Result<()> {
+    let mut stdout = BufWriter::new(io::stdout().lock());
+    match format {
+        HelpFormat::Text => {
+            writeln!(stdout, "{}", format_rule_text(rule))?;
+        }
+        HelpFormat::Json => {
+            serde_json::to_writer_pretty(stdout, &Explanation::from_rule(&rule))?;
+        }
+    };
+    Ok(())
+}
+
+/// Explain all rules to the user.
+pub(crate) fn rules(format: HelpFormat) -> Result<()> {
+    let mut stdout = BufWriter::new(io::stdout().lock());
+    match format {
+        HelpFormat::Text => {
+            for rule in Rule::iter() {
+                writeln!(stdout, "{}", format_rule_text(rule))?;
+                writeln!(stdout)?;
+            }
+        }
+        HelpFormat::Json => {
+            let mut serializer = serde_json::Serializer::pretty(stdout);
+            let mut seq = serializer.serialize_seq(None)?;
+            for rule in Rule::iter() {
+                seq.serialize_element(&Explanation::from_rule(&rule))?;
+            }
+            seq.end()?;
+        }
+    }
+    Ok(())
+}

crates/ruff_cli/src/commands/show_files.rs

@@ -0,0 +1,37 @@
+use std::io::Write;
+use std::path::PathBuf;
+
+use anyhow::Result;
+use itertools::Itertools;
+
+use ruff_linter::warn_user_once;
+use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig};
+
+use crate::args::CliOverrides;
+
+/// Show the list of files to be checked based on current settings.
+pub(crate) fn show_files(
+    files: &[PathBuf],
+    pyproject_config: &PyprojectConfig,
+    overrides: &CliOverrides,
+    writer: &mut impl Write,
+) -> Result<()> {
+    // Collect all files in the hierarchy.
+    let (paths, _resolver) = python_files_in_path(files, pyproject_config, overrides)?;
+
+    if paths.is_empty() {
+        warn_user_once!("No Python files found under the given path(s)");
+        return Ok(());
+    }
+
+    // Print the list of files.
+    for entry in paths
+        .iter()
+        .flatten()
+        .sorted_by(|a, b| a.path().cmp(b.path()))
+    {
+        writeln!(writer, "{}", entry.path().to_string_lossy())?;
+    }
+
+    Ok(())
+}

crates/ruff_cli/src/commands/show_settings.rs

@@ -0,0 +1,40 @@
+use std::io::Write;
+use std::path::PathBuf;
+
+use anyhow::{bail, Result};
+use itertools::Itertools;
+
+use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig};
+
+use crate::args::CliOverrides;
+
+/// Print the user-facing configuration settings.
+pub(crate) fn show_settings(
+    files: &[PathBuf],
+    pyproject_config: &PyprojectConfig,
+    overrides: &CliOverrides,
+    writer: &mut impl Write,
+) -> Result<()> {
+    // Collect all files in the hierarchy.
+    let (paths, resolver) = python_files_in_path(files, pyproject_config, overrides)?;
+
+    // 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_config);
+
+    writeln!(writer, "Resolved settings for: {path:?}")?;
+    if let Some(settings_path) = pyproject_config.path.as_ref() {
+        writeln!(writer, "Settings path: {settings_path:?}")?;
+    }
+    writeln!(writer, "{settings:#?}")?;
+
+    Ok(())
+}

crates/ruff_cli/src/commands/snapshots/ruff_cli__commands__check__test__E902_E902.py.snap

@@ -0,0 +1,7 @@
+---
+source: crates/ruff_cli/src/commands/check.rs
+---
+/home/ferris/project/code.py:1:1: E902 Permission denied (os error 13)
+/home/ferris/project/notebook.ipynb:1:1: E902 Permission denied (os error 13)
+/home/ferris/project/pyproject.toml:1:1: E902 Permission denied (os error 13)
+

crates/ruff_cli/src/diagnostics.rs

@@ -0,0 +1,564 @@
+#![cfg_attr(target_family = "wasm", allow(dead_code))]
+
+use std::fs::{write, File};
+use std::io;
+use std::io::{BufWriter, Write};
+use std::ops::AddAssign;
+#[cfg(unix)]
+use std::os::unix::fs::PermissionsExt;
+use std::path::Path;
+
+use anyhow::{anyhow, Context, Result};
+use colored::Colorize;
+use filetime::FileTime;
+use log::{debug, error, warn};
+use rustc_hash::FxHashMap;
+use similar::TextDiff;
+use thiserror::Error;
+
+use ruff_diagnostics::Diagnostic;
+use ruff_linter::linter::{lint_fix, lint_only, FixTable, FixerResult, LinterResult};
+use ruff_linter::logging::DisplayParseError;
+use ruff_linter::message::Message;
+use ruff_linter::pyproject_toml::lint_pyproject_toml;
+use ruff_linter::registry::AsRule;
+use ruff_linter::settings::{flags, LinterSettings};
+use ruff_linter::source_kind::SourceKind;
+use ruff_linter::{fs, IOError, SyntaxError};
+use ruff_macros::CacheKey;
+use ruff_notebook::{Cell, Notebook, NotebookError, NotebookIndex};
+use ruff_python_ast::imports::ImportMap;
+use ruff_python_ast::{PySourceType, SourceType, TomlSourceType};
+use ruff_source_file::{LineIndex, SourceCode, SourceFileBuilder};
+use ruff_text_size::{TextRange, TextSize};
+use ruff_workspace::Settings;
+
+use crate::cache::Cache;
+
+#[derive(CacheKey)]
+pub(crate) struct FileCacheKey {
+    /// Timestamp when the file was last modified before the (cached) check.
+    file_last_modified: FileTime,
+    /// Permissions of the file before the (cached) check.
+    file_permissions_mode: u32,
+}
+
+impl FileCacheKey {
+    fn from_path(path: &Path) -> io::Result<FileCacheKey> {
+        // Construct a cache key for the file
+        let metadata = path.metadata()?;
+
+        #[cfg(unix)]
+        let permissions = metadata.permissions().mode();
+        #[cfg(windows)]
+        let permissions: u32 = metadata.permissions().readonly().into();
+
+        Ok(FileCacheKey {
+            file_last_modified: FileTime::from_last_modification_time(&metadata),
+            file_permissions_mode: permissions,
+        })
+    }
+}
+
+#[derive(Debug, Default, PartialEq)]
+pub(crate) struct Diagnostics {
+    pub(crate) messages: Vec<Message>,
+    pub(crate) fixed: FxHashMap<String, FixTable>,
+    pub(crate) imports: ImportMap,
+    pub(crate) notebook_indexes: FxHashMap<String, NotebookIndex>,
+}
+
+impl Diagnostics {
+    pub(crate) fn new(
+        messages: Vec<Message>,
+        imports: ImportMap,
+        notebook_indexes: FxHashMap<String, NotebookIndex>,
+    ) -> Self {
+        Self {
+            messages,
+            fixed: FxHashMap::default(),
+            imports,
+            notebook_indexes,
+        }
+    }
+
+    /// Generate [`Diagnostics`] based on a [`SourceExtractionError`].
+    pub(crate) fn from_source_error(
+        err: &SourceExtractionError,
+        path: Option<&Path>,
+        settings: &LinterSettings,
+    ) -> Self {
+        let diagnostic = Diagnostic::from(err);
+        if settings.rules.enabled(diagnostic.kind.rule()) {
+            let name = path.map_or_else(|| "-".into(), std::path::Path::to_string_lossy);
+            let dummy = SourceFileBuilder::new(name, "").finish();
+            Self::new(
+                vec![Message::from_diagnostic(
+                    diagnostic,
+                    dummy,
+                    TextSize::default(),
+                )],
+                ImportMap::default(),
+                FxHashMap::default(),
+            )
+        } else {
+            match path {
+                Some(path) => {
+                    warn!(
+                        "{}{}{} {err}",
+                        "Failed to lint ".bold(),
+                        fs::relativize_path(path).bold(),
+                        ":".bold()
+                    );
+                }
+                None => {
+                    warn!("{}{} {err}", "Failed to lint".bold(), ":".bold());
+                }
+            }
+
+            Self::default()
+        }
+    }
+}
+
+impl AddAssign for Diagnostics {
+    fn add_assign(&mut self, other: Self) {
+        self.messages.extend(other.messages);
+        self.imports.extend(other.imports);
+        for (filename, fixed) in other.fixed {
+            if fixed.is_empty() {
+                continue;
+            }
+            let fixed_in_file = self.fixed.entry(filename).or_default();
+            for (rule, count) in fixed {
+                if count > 0 {
+                    *fixed_in_file.entry(rule).or_default() += count;
+                }
+            }
+        }
+        self.notebook_indexes.extend(other.notebook_indexes);
+    }
+}
+
+/// Lint the source code at the given `Path`.
+pub(crate) fn lint_path(
+    path: &Path,
+    package: Option<&Path>,
+    settings: &LinterSettings,
+    cache: Option<&Cache>,
+    noqa: flags::Noqa,
+    autofix: flags::FixMode,
+) -> Result<Diagnostics> {
+    // 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 caching = match cache {
+        Some(cache) if noqa.into() && autofix.is_generate() => {
+            let relative_path = cache
+                .relative_path(path)
+                .expect("wrong package cache for file");
+
+            let cache_key = FileCacheKey::from_path(path).context("Failed to create cache key")?;
+
+            if let Some(cache) = cache.get(relative_path, &cache_key) {
+                return Ok(cache.as_diagnostics(path));
+            }
+
+            // Stash the file metadata for later so when we update the cache it reflects the prerun
+            // information
+            Some((cache, relative_path, cache_key))
+        }
+        _ => None,
+    };
+
+    debug!("Checking: {}", path.display());
+
+    let source_type = match SourceType::from(path) {
+        SourceType::Toml(TomlSourceType::Pyproject) => {
+            let messages = if settings
+                .rules
+                .iter_enabled()
+                .any(|rule_code| rule_code.lint_source().is_pyproject_toml())
+            {
+                let contents =
+                    match std::fs::read_to_string(path).map_err(SourceExtractionError::Io) {
+                        Ok(contents) => contents,
+                        Err(err) => {
+                            return Ok(Diagnostics::from_source_error(&err, Some(path), settings));
+                        }
+                    };
+                let source_file = SourceFileBuilder::new(path.to_string_lossy(), contents).finish();
+                lint_pyproject_toml(source_file, settings)
+            } else {
+                vec![]
+            };
+            return Ok(Diagnostics {
+                messages,
+                ..Diagnostics::default()
+            });
+        }
+        SourceType::Toml(_) => return Ok(Diagnostics::default()),
+        SourceType::Python(source_type) => source_type,
+    };
+
+    // Extract the sources from the file.
+    let LintSource(source_kind) = match LintSource::try_from_path(path, source_type) {
+        Ok(Some(sources)) => sources,
+        Ok(None) => return Ok(Diagnostics::default()),
+        Err(err) => {
+            return Ok(Diagnostics::from_source_error(&err, Some(path), settings));
+        }
+    };
+
+    // Lint the file.
+    let (
+        LinterResult {
+            data: (messages, imports),
+            error: parse_error,
+        },
+        fixed,
+    ) = if matches!(autofix, flags::FixMode::Apply | flags::FixMode::Diff) {
+        if let Ok(FixerResult {
+            result,
+            transformed,
+            fixed,
+        }) = lint_fix(path, package, noqa, settings, &source_kind, source_type)
+        {
+            if !fixed.is_empty() {
+                match autofix {
+                    flags::FixMode::Apply => match transformed.as_ref() {
+                        SourceKind::Python(transformed) => {
+                            write(path, transformed.as_bytes())?;
+                        }
+                        SourceKind::IpyNotebook(notebook) => {
+                            let mut writer = BufWriter::new(File::create(path)?);
+                            notebook.write(&mut writer)?;
+                        }
+                    },
+                    flags::FixMode::Diff => {
+                        match transformed.as_ref() {
+                            SourceKind::Python(transformed) => {
+                                let mut stdout = io::stdout().lock();
+                                TextDiff::from_lines(source_kind.source_code(), transformed)
+                                    .unified_diff()
+                                    .header(&fs::relativize_path(path), &fs::relativize_path(path))
+                                    .to_writer(&mut stdout)?;
+                                stdout.write_all(b"\n")?;
+                                stdout.flush()?;
+                            }
+                            SourceKind::IpyNotebook(dest_notebook) => {
+                                // We need to load the notebook again, since we might've
+                                // 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()
+                                    .zip(dest_notebook.cells().iter())
+                                {
+                                    let (Cell::Code(src_code_cell), Cell::Code(dest_code_cell)) =
+                                        (src_cell, dest_cell)
+                                    else {
+                                        continue;
+                                    };
+                                    TextDiff::from_lines(
+                                        &src_code_cell.source.to_string(),
+                                        &dest_code_cell.source.to_string(),
+                                    )
+                                    .unified_diff()
+                                    // Jupyter notebook cells don't necessarily have a newline
+                                    // at the end. For example,
+                                    //
+                                    // ```python
+                                    // print("hello")
+                                    // ```
+                                    //
+                                    // For a cell containing the above code, there'll only be one line,
+                                    // and it won't have a newline at the end. If it did, there'd be
+                                    // two lines, and the second line would be empty:
+                                    //
+                                    // ```python
+                                    // print("hello")
+                                    //
+                                    // ```
+                                    .missing_newline_hint(false)
+                                    .header(
+                                        &format!("{}:cell {}", &fs::relativize_path(path), idx),
+                                        &format!("{}:cell {}", &fs::relativize_path(path), idx),
+                                    )
+                                    .to_writer(&mut stdout)?;
+                                }
+                                stdout.write_all(b"\n")?;
+                                stdout.flush()?;
+                            }
+                        }
+                    }
+                    flags::FixMode::Generate => {}
+                }
+            }
+            (result, fixed)
+        } else {
+            // If we fail to autofix, lint the original source code.
+            let result = lint_only(path, package, settings, noqa, &source_kind, source_type);
+            let fixed = FxHashMap::default();
+            (result, fixed)
+        }
+    } else {
+        let result = lint_only(path, package, settings, noqa, &source_kind, source_type);
+        let fixed = FxHashMap::default();
+        (result, fixed)
+    };
+
+    let imports = imports.unwrap_or_default();
+
+    if let Some((cache, relative_path, key)) = caching {
+        // We don't cache parsing errors.
+        if parse_error.is_none() {
+            cache.update(
+                relative_path.to_owned(),
+                key,
+                &messages,
+                &imports,
+                source_kind.as_ipy_notebook().map(Notebook::index),
+            );
+        }
+    }
+
+    if let Some(err) = parse_error {
+        error!(
+            "{}",
+            DisplayParseError::new(
+                err,
+                SourceCode::new(
+                    source_kind.source_code(),
+                    &LineIndex::from_source_text(source_kind.source_code())
+                ),
+                &source_kind,
+            )
+        );
+    }
+
+    let notebook_indexes = if let SourceKind::IpyNotebook(notebook) = source_kind {
+        FxHashMap::from_iter([(
+            path.to_str()
+                .ok_or_else(|| anyhow!("Unable to parse filename: {:?}", path))?
+                .to_string(),
+            // Index needs to be computed always to store in cache.
+            notebook.index().clone(),
+        )])
+    } else {
+        FxHashMap::default()
+    };
+
+    Ok(Diagnostics {
+        messages,
+        fixed: FxHashMap::from_iter([(fs::relativize_path(path), fixed)]),
+        imports,
+        notebook_indexes,
+    })
+}
+
+/// Generate `Diagnostic`s from source code content derived from
+/// stdin.
+pub(crate) fn lint_stdin(
+    path: Option<&Path>,
+    package: Option<&Path>,
+    contents: String,
+    settings: &Settings,
+    noqa: flags::Noqa,
+    autofix: flags::FixMode,
+) -> Result<Diagnostics> {
+    // TODO(charlie): Support `pyproject.toml`.
+    let SourceType::Python(source_type) = path.map(SourceType::from).unwrap_or_default() else {
+        return Ok(Diagnostics::default());
+    };
+
+    // Extract the sources from the file.
+    let LintSource(source_kind) = match LintSource::try_from_source_code(contents, source_type) {
+        Ok(Some(sources)) => sources,
+        Ok(None) => return Ok(Diagnostics::default()),
+        Err(err) => {
+            return Ok(Diagnostics::from_source_error(&err, path, &settings.linter));
+        }
+    };
+
+    // Lint the inputs.
+    let (
+        LinterResult {
+            data: (messages, imports),
+            error: parse_error,
+        },
+        fixed,
+    ) = if matches!(autofix, flags::FixMode::Apply | flags::FixMode::Diff) {
+        if let Ok(FixerResult {
+            result,
+            transformed,
+            fixed,
+        }) = lint_fix(
+            path.unwrap_or_else(|| Path::new("-")),
+            package,
+            noqa,
+            &settings.linter,
+            &source_kind,
+            source_type,
+        ) {
+            match autofix {
+                flags::FixMode::Apply => {
+                    // Write the contents to stdout, regardless of whether any errors were fixed.
+                    io::stdout().write_all(transformed.source_code().as_bytes())?;
+                }
+                flags::FixMode::Diff => {
+                    // But only write a diff if it's non-empty.
+                    if !fixed.is_empty() {
+                        let text_diff = TextDiff::from_lines(
+                            source_kind.source_code(),
+                            transformed.source_code(),
+                        );
+                        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()?;
+                    }
+                }
+                flags::FixMode::Generate => {}
+            }
+
+            (result, fixed)
+        } else {
+            // If we fail to autofix, lint the original source code.
+            let result = lint_only(
+                path.unwrap_or_else(|| Path::new("-")),
+                package,
+                &settings.linter,
+                noqa,
+                &source_kind,
+                source_type,
+            );
+            let fixed = FxHashMap::default();
+
+            // Write the contents to stdout anyway.
+            if autofix.is_apply() {
+                io::stdout().write_all(source_kind.source_code().as_bytes())?;
+            }
+
+            (result, fixed)
+        }
+    } else {
+        let result = lint_only(
+            path.unwrap_or_else(|| Path::new("-")),
+            package,
+            &settings.linter,
+            noqa,
+            &source_kind,
+            source_type,
+        );
+        let fixed = FxHashMap::default();
+        (result, fixed)
+    };
+
+    let imports = imports.unwrap_or_default();
+
+    if let Some(err) = parse_error {
+        error!(
+            "Failed to parse {}: {err}",
+            path.map_or_else(|| "-".into(), fs::relativize_path).bold()
+        );
+    }
+
+    Ok(Diagnostics {
+        messages,
+        fixed: FxHashMap::from_iter([(
+            fs::relativize_path(path.unwrap_or_else(|| Path::new("-"))),
+            fixed,
+        )]),
+        imports,
+        notebook_indexes: FxHashMap::default(),
+    })
+}
+
+#[derive(Debug)]
+pub(crate) struct LintSource(pub(crate) SourceKind);
+
+impl LintSource {
+    /// Extract the lint [`LintSource`] from the given file path.
+    pub(crate) fn try_from_path(
+        path: &Path,
+        source_type: PySourceType,
+    ) -> Result<Option<LintSource>, SourceExtractionError> {
+        if source_type.is_ipynb() {
+            let notebook = Notebook::from_path(path)?;
+            Ok(notebook
+                .is_python_notebook()
+                .then_some(LintSource(SourceKind::IpyNotebook(notebook))))
+        } else {
+            // This is tested by ruff_cli integration test `unreadable_file`
+            let contents = std::fs::read_to_string(path)?;
+            Ok(Some(LintSource(SourceKind::Python(contents))))
+        }
+    }
+
+    /// Extract the lint [`LintSource`] from the raw string contents, optionally accompanied by a
+    /// file path indicating the path to the file from which the contents were read. If provided,
+    /// the file path should be used for diagnostics, but not for reading the file from disk.
+    pub(crate) fn try_from_source_code(
+        source_code: String,
+        source_type: PySourceType,
+    ) -> Result<Option<LintSource>, SourceExtractionError> {
+        if source_type.is_ipynb() {
+            let notebook = Notebook::from_source_code(&source_code)?;
+            Ok(notebook
+                .is_python_notebook()
+                .then_some(LintSource(SourceKind::IpyNotebook(notebook))))
+        } else {
+            Ok(Some(LintSource(SourceKind::Python(source_code))))
+        }
+    }
+}
+
+#[derive(Error, Debug)]
+pub(crate) enum SourceExtractionError {
+    /// The extraction failed due to an [`io::Error`].
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    /// The extraction failed due to a [`NotebookError`].
+    #[error(transparent)]
+    Notebook(#[from] NotebookError),
+}
+
+impl From<&SourceExtractionError> for Diagnostic {
+    fn from(err: &SourceExtractionError) -> Self {
+        match err {
+            // IO errors.
+            SourceExtractionError::Io(_)
+            | SourceExtractionError::Notebook(NotebookError::Io(_) | NotebookError::Json(_)) => {
+                Diagnostic::new(
+                    IOError {
+                        message: err.to_string(),
+                    },
+                    TextRange::default(),
+                )
+            }
+            // Syntax errors.
+            SourceExtractionError::Notebook(
+                NotebookError::InvalidJson(_)
+                | NotebookError::InvalidSchema(_)
+                | NotebookError::InvalidFormat(_),
+            ) => Diagnostic::new(
+                SyntaxError {
+                    message: err.to_string(),
+                },
+                TextRange::default(),
+            ),
+        }
+    }
+}

crates/ruff_cli/src/lib.rs

@@ -0,0 +1,507 @@
+use std::fs::File;
+use std::io::{self, stdout, BufWriter, Write};
+use std::path::{Path, PathBuf};
+use std::process::ExitCode;
+use std::sync::mpsc::channel;
+
+use anyhow::Result;
+use clap::CommandFactory;
+use log::warn;
+use notify::{recommended_watcher, RecursiveMode, Watcher};
+
+use ruff_linter::logging::{set_up_logging, LogLevel};
+use ruff_linter::settings::flags;
+use ruff_linter::settings::types::SerializationFormat;
+use ruff_linter::{fs, warn_user, warn_user_once};
+use ruff_workspace::Settings;
+
+use crate::args::{Args, CheckCommand, Command, FormatCommand};
+use crate::printer::{Flags as PrinterFlags, Printer};
+
+pub mod args;
+mod cache;
+mod commands;
+mod diagnostics;
+mod panic;
+mod printer;
+pub mod resolve;
+mod stdin;
+
+#[derive(Copy, Clone)]
+pub enum ExitStatus {
+    /// Linting was successful and there were no linting errors.
+    Success,
+    /// Linting was successful but there were linting errors.
+    Failure,
+    /// Linting failed.
+    Error,
+}
+
+impl From<ExitStatus> for ExitCode {
+    fn from(status: ExitStatus) -> Self {
+        match status {
+            ExitStatus::Success => ExitCode::from(0),
+            ExitStatus::Failure => ExitCode::from(1),
+            ExitStatus::Error => ExitCode::from(2),
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+enum ChangeKind {
+    Configuration,
+    SourceFile,
+}
+
+/// Return the [`ChangeKind`] based on the list of modified file paths.
+///
+/// Returns `None` if no relevant changes were detected.
+fn change_detected(paths: &[PathBuf]) -> Option<ChangeKind> {
+    // If any `.toml` files were modified, return `ChangeKind::Configuration`. Otherwise, return
+    // `ChangeKind::SourceFile` if any `.py`, `.pyi`, `.pyw`, or `.ipynb` files were modified.
+    let mut source_file = false;
+    for path in paths {
+        if let Some(suffix) = path.extension() {
+            match suffix.to_str() {
+                Some("toml") => {
+                    return Some(ChangeKind::Configuration);
+                }
+                Some("py" | "pyi" | "pyw" | "ipynb") => source_file = true,
+                _ => {}
+            }
+        }
+    }
+    if source_file {
+        return Some(ChangeKind::SourceFile);
+    }
+    None
+}
+
+/// Returns true if the command should read from standard input.
+fn is_stdin(files: &[PathBuf], stdin_filename: Option<&Path>) -> bool {
+    // If the user provided a `--stdin-filename`, always read from standard input.
+    if stdin_filename.is_some() {
+        if let Some(file) = files.iter().find(|file| file.as_path() != Path::new("-")) {
+            warn_user_once!(
+                "Ignoring file {} in favor of standard input.",
+                file.display()
+            );
+        }
+        return true;
+    }
+
+    let [file] = files else {
+        return false;
+    };
+    // If the user provided exactly `-`, read from standard input.
+    file == Path::new("-")
+}
+
+pub fn run(
+    Args {
+        command,
+        log_level_args,
+    }: Args,
+) -> Result<ExitStatus> {
+    {
+        use colored::Colorize;
+
+        let default_panic_hook = std::panic::take_hook();
+        std::panic::set_hook(Box::new(move |info| {
+            #[allow(clippy::print_stderr)]
+            {
+                eprintln!(
+                    r#"
+{}{} {} If you could open an issue at:
+
+    https://github.com/astral-sh/ruff/issues/new?title=%5BPanic%5D
+
+...quoting the executed command, along with the relevant file contents and `pyproject.toml` settings, we'd be very appreciative!
+"#,
+                    "error".red().bold(),
+                    ":".bold(),
+                    "Ruff crashed.".bold(),
+                );
+            }
+            default_panic_hook(info);
+        }));
+    }
+
+    // Enabled ANSI colors on Windows 10.
+    #[cfg(windows)]
+    assert!(colored::control::set_virtual_terminal(true).is_ok());
+
+    let log_level = LogLevel::from(&log_level_args);
+    set_up_logging(&log_level)?;
+
+    match command {
+        Command::Rule { rule, all, format } => {
+            if all {
+                commands::rule::rules(format)?;
+            }
+            if let Some(rule) = rule {
+                commands::rule::rule(rule, format)?;
+            }
+            Ok(ExitStatus::Success)
+        }
+        Command::Config { option } => {
+            commands::config::config(option.as_deref())?;
+            Ok(ExitStatus::Success)
+        }
+        Command::Linter { format } => {
+            commands::linter::linter(format)?;
+            Ok(ExitStatus::Success)
+        }
+        Command::Clean => {
+            commands::clean::clean(log_level)?;
+            Ok(ExitStatus::Success)
+        }
+        Command::GenerateShellCompletion { shell } => {
+            shell.generate(&mut Args::command(), &mut stdout());
+            Ok(ExitStatus::Success)
+        }
+        Command::Check(args) => check(args, log_level),
+        Command::Format(args) => format(args, log_level),
+    }
+}
+
+fn format(args: FormatCommand, log_level: LogLevel) -> Result<ExitStatus> {
+    warn_user_once!(
+        "`ruff format` is a work-in-progress, subject to change at any time, and intended only for \
+        experimentation."
+    );
+
+    let (cli, overrides) = args.partition();
+
+    if is_stdin(&cli.files, cli.stdin_filename.as_deref()) {
+        commands::format_stdin::format_stdin(&cli, &overrides)
+    } else {
+        commands::format::format(&cli, &overrides, log_level)
+    }
+}
+
+pub fn check(args: CheckCommand, log_level: LogLevel) -> Result<ExitStatus> {
+    if args.format.is_some() {
+        if std::env::var("RUFF_FORMAT").is_ok() {
+            warn_user!("The environment variable `RUFF_FORMAT` is deprecated. Use `RUFF_OUTPUT_FORMAT` instead.");
+        } else {
+            warn_user!("The argument `--format=<FORMAT>` is deprecated. Use `--output-format=<FORMAT>` instead.");
+        }
+    }
+
+    let (cli, overrides) = args.partition();
+
+    // 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_config = resolve::resolve(
+        cli.isolated,
+        cli.config.as_deref(),
+        &overrides,
+        cli.stdin_filename.as_deref(),
+    )?;
+
+    let mut writer: Box<dyn Write> = match cli.output_file {
+        Some(path) if !cli.watch => {
+            colored::control::set_override(false);
+            let file = File::create(path)?;
+            Box::new(BufWriter::new(file))
+        }
+        _ => Box::new(BufWriter::new(io::stdout())),
+    };
+
+    if cli.show_settings {
+        commands::show_settings::show_settings(
+            &cli.files,
+            &pyproject_config,
+            &overrides,
+            &mut writer,
+        )?;
+        return Ok(ExitStatus::Success);
+    }
+    if cli.show_files {
+        commands::show_files::show_files(&cli.files, &pyproject_config, &overrides, &mut writer)?;
+        return Ok(ExitStatus::Success);
+    }
+
+    // Extract options that are included in `Settings`, but only apply at the top
+    // level.
+    let Settings {
+        fix,
+        fix_only,
+        output_format,
+        show_fixes,
+        show_source,
+        ..
+    } = pyproject_config.settings;
+
+    // Autofix rules are as follows:
+    // - By default, generate all fixes, but don't apply them to the filesystem.
+    // - If `--fix` or `--fix-only` is set, always apply fixes to the filesystem (or
+    //   print them to stdout, if we're reading from stdin).
+    // - If `--diff` or `--fix-only` are set, don't print any violations (only
+    //   fixes).
+    let autofix = if cli.diff {
+        flags::FixMode::Diff
+    } else if fix || fix_only {
+        flags::FixMode::Apply
+    } else {
+        flags::FixMode::Generate
+    };
+    let cache = !cli.no_cache;
+    let noqa = !cli.ignore_noqa;
+    let mut printer_flags = PrinterFlags::empty();
+    if !(cli.diff || fix_only) {
+        printer_flags |= PrinterFlags::SHOW_VIOLATIONS;
+    }
+    if show_fixes {
+        printer_flags |= PrinterFlags::SHOW_FIX_SUMMARY;
+    }
+    if show_source {
+        printer_flags |= PrinterFlags::SHOW_SOURCE;
+    }
+    if cli.ecosystem_ci {
+        warn_user!(
+            "The formatting of fixes emitted by this option is a work-in-progress, subject to \
+            change at any time, and intended only for internal use."
+        );
+        printer_flags |= PrinterFlags::SHOW_FIX_DIFF;
+    }
+
+    #[cfg(debug_assertions)]
+    if cache {
+        // `--no-cache` doesn't respect code changes, and so is often confusing during
+        // development.
+        warn_user!("Detected debug build without --no-cache.");
+    }
+
+    if cli.add_noqa {
+        if !autofix.is_generate() {
+            warn_user!("--fix is incompatible with --add-noqa.");
+        }
+        let modifications =
+            commands::add_noqa::add_noqa(&cli.files, &pyproject_config, &overrides)?;
+        if modifications > 0 && log_level >= LogLevel::Default {
+            let s = if modifications == 1 { "" } else { "s" };
+            #[allow(clippy::print_stderr)]
+            {
+                eprintln!("Added {modifications} noqa directive{s}.");
+            }
+        }
+        return Ok(ExitStatus::Success);
+    }
+
+    let printer = Printer::new(output_format, log_level, autofix, printer_flags);
+
+    if cli.watch {
+        if output_format != SerializationFormat::Text {
+            warn_user!("--format 'text' is used in watch mode.");
+        }
+
+        // Configure the file watcher.
+        let (tx, rx) = channel();
+        let mut watcher = recommended_watcher(tx)?;
+        for file in &cli.files {
+            watcher.watch(file, RecursiveMode::Recursive)?;
+        }
+        if let Some(file) = pyproject_config.path.as_ref() {
+            watcher.watch(file, RecursiveMode::Recursive)?;
+        }
+
+        // Perform an initial run instantly.
+        Printer::clear_screen()?;
+        printer.write_to_user("Starting linter in watch mode...\n");
+
+        let messages = commands::check::check(
+            &cli.files,
+            &pyproject_config,
+            &overrides,
+            cache.into(),
+            noqa.into(),
+            autofix,
+        )?;
+        printer.write_continuously(&mut writer, &messages)?;
+
+        // In watch mode, we may need to re-resolve the configuration.
+        // TODO(charlie): Re-compute other derivative values, like the `printer`.
+        let mut pyproject_config = pyproject_config;
+
+        loop {
+            match rx.recv() {
+                Ok(event) => {
+                    let Some(change_kind) = change_detected(&event?.paths) else {
+                        continue;
+                    };
+
+                    if matches!(change_kind, ChangeKind::Configuration) {
+                        pyproject_config = resolve::resolve(
+                            cli.isolated,
+                            cli.config.as_deref(),
+                            &overrides,
+                            cli.stdin_filename.as_deref(),
+                        )?;
+                    }
+                    Printer::clear_screen()?;
+                    printer.write_to_user("File change detected...\n");
+
+                    let messages = commands::check::check(
+                        &cli.files,
+                        &pyproject_config,
+                        &overrides,
+                        cache.into(),
+                        noqa.into(),
+                        autofix,
+                    )?;
+                    printer.write_continuously(&mut writer, &messages)?;
+                }
+                Err(err) => return Err(err.into()),
+            }
+        }
+    } else {
+        let is_stdin = is_stdin(&cli.files, cli.stdin_filename.as_deref());
+
+        // Generate lint violations.
+        let diagnostics = if is_stdin {
+            commands::check_stdin::check_stdin(
+                cli.stdin_filename.map(fs::normalize_path).as_deref(),
+                &pyproject_config,
+                &overrides,
+                noqa.into(),
+                autofix,
+            )?
+        } else {
+            commands::check::check(
+                &cli.files,
+                &pyproject_config,
+                &overrides,
+                cache.into(),
+                noqa.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, flags::FixMode::Apply | flags::FixMode::Diff)) {
+            if cli.statistics {
+                printer.write_statistics(&diagnostics, &mut writer)?;
+            } else {
+                printer.write_once(&diagnostics, &mut writer)?;
+            }
+        }
+
+        if !cli.exit_zero {
+            if cli.diff {
+                // If we're printing a diff, we always want to exit non-zero if there are
+                // any fixable violations (since we've printed the diff, but not applied the
+                // fixes).
+                if !diagnostics.fixed.is_empty() {
+                    return Ok(ExitStatus::Failure);
+                }
+            } else if fix_only {
+                // If we're only fixing, we want to exit zero (since we've fixed all fixable
+                // violations), unless we're explicitly asked to exit non-zero on fix.
+                if cli.exit_non_zero_on_fix {
+                    if !diagnostics.fixed.is_empty() {
+                        return Ok(ExitStatus::Failure);
+                    }
+                }
+            } else {
+                // If we're running the linter (not just fixing), we want to exit non-zero if
+                // there are any violations, unless we're explicitly asked to exit zero on
+                // fix.
+                if cli.exit_non_zero_on_fix {
+                    if !diagnostics.fixed.is_empty() || !diagnostics.messages.is_empty() {
+                        return Ok(ExitStatus::Failure);
+                    }
+                } else {
+                    if !diagnostics.messages.is_empty() {
+                        return Ok(ExitStatus::Failure);
+                    }
+                }
+            }
+        }
+    }
+    Ok(ExitStatus::Success)
+}
+
+#[cfg(test)]
+mod test_file_change_detector {
+    use std::path::PathBuf;
+
+    use crate::{change_detected, ChangeKind};
+
+    #[test]
+    fn detect_correct_file_change() {
+        assert_eq!(
+            Some(ChangeKind::Configuration),
+            change_detected(&[
+                PathBuf::from("tmp/pyproject.toml"),
+                PathBuf::from("tmp/bin/ruff.rs"),
+            ]),
+        );
+        assert_eq!(
+            Some(ChangeKind::Configuration),
+            change_detected(&[
+                PathBuf::from("pyproject.toml"),
+                PathBuf::from("tmp/bin/ruff.rs"),
+            ]),
+        );
+        assert_eq!(
+            Some(ChangeKind::Configuration),
+            change_detected(&[
+                PathBuf::from("tmp1/tmp2/tmp3/pyproject.toml"),
+                PathBuf::from("tmp/bin/ruff.rs"),
+            ]),
+        );
+        assert_eq!(
+            Some(ChangeKind::Configuration),
+            change_detected(&[
+                PathBuf::from("tmp/ruff.toml"),
+                PathBuf::from("tmp/bin/ruff.rs"),
+            ]),
+        );
+        assert_eq!(
+            Some(ChangeKind::Configuration),
+            change_detected(&[
+                PathBuf::from("tmp/.ruff.toml"),
+                PathBuf::from("tmp/bin/ruff.rs"),
+            ]),
+        );
+        assert_eq!(
+            Some(ChangeKind::SourceFile),
+            change_detected(&[
+                PathBuf::from("tmp/rule.py"),
+                PathBuf::from("tmp/bin/ruff.rs"),
+            ]),
+        );
+        assert_eq!(
+            Some(ChangeKind::SourceFile),
+            change_detected(&[
+                PathBuf::from("tmp/rule.pyi"),
+                PathBuf::from("tmp/bin/ruff.rs"),
+            ]),
+        );
+        assert_eq!(
+            Some(ChangeKind::Configuration),
+            change_detected(&[
+                PathBuf::from("pyproject.toml"),
+                PathBuf::from("tmp/rule.py"),
+            ]),
+        );
+        assert_eq!(
+            Some(ChangeKind::Configuration),
+            change_detected(&[
+                PathBuf::from("tmp/rule.py"),
+                PathBuf::from("pyproject.toml"),
+            ]),
+        );
+        assert_eq!(
+            None,
+            change_detected(&[
+                PathBuf::from("tmp/rule.js"),
+                PathBuf::from("tmp/bin/ruff.rs"),
+            ]),
+        );
+    }
+}

crates/ruff_cli/src/panic.rs

@@ -0,0 +1,46 @@
+#[derive(Default, Debug)]
+pub(crate) struct PanicError {
+    pub(crate) info: String,
+    pub(crate) backtrace: Option<std::backtrace::Backtrace>,
+}
+
+impl std::fmt::Display for PanicError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "{}", self.info)?;
+        if let Some(backtrace) = &self.backtrace {
+            writeln!(f, "Backtrace: {backtrace}")
+        } else {
+            Ok(())
+        }
+    }
+}
+
+thread_local! {
+    static LAST_PANIC: std::cell::Cell<Option<PanicError>> = std::cell::Cell::new(None);
+}
+
+/// [`catch_unwind`](std::panic::catch_unwind) wrapper that sets a custom [`set_hook`](std::panic::set_hook)
+/// to extract the backtrace. The original panic-hook gets restored before returning.
+pub(crate) fn catch_unwind<F, R>(f: F) -> Result<R, PanicError>
+where
+    F: FnOnce() -> R + std::panic::UnwindSafe,
+{
+    let prev = std::panic::take_hook();
+    std::panic::set_hook(Box::new(|info| {
+        let info = info.to_string();
+        let backtrace = std::backtrace::Backtrace::force_capture();
+        LAST_PANIC.with(|cell| {
+            cell.set(Some(PanicError {
+                info,
+                backtrace: Some(backtrace),
+            }));
+        });
+    }));
+
+    let result = std::panic::catch_unwind(f)
+        .map_err(|_| LAST_PANIC.with(std::cell::Cell::take).unwrap_or_default());
+
+    std::panic::set_hook(prev);
+
+    result
+}

crates/ruff_cli/src/printer.rs

@@ -0,0 +1,441 @@
+use std::cmp::Reverse;
+use std::fmt::Display;
+use std::hash::Hash;
+use std::io::Write;
+
+use anyhow::Result;
+use bitflags::bitflags;
+use colored::Colorize;
+use itertools::{iterate, Itertools};
+use rustc_hash::FxHashMap;
+use serde::Serialize;
+
+use ruff_linter::fs::relativize_path;
+use ruff_linter::linter::FixTable;
+use ruff_linter::logging::LogLevel;
+use ruff_linter::message::{
+    AzureEmitter, Emitter, EmitterContext, GithubEmitter, GitlabEmitter, GroupedEmitter,
+    JsonEmitter, JsonLinesEmitter, JunitEmitter, PylintEmitter, TextEmitter,
+};
+use ruff_linter::notify_user;
+use ruff_linter::registry::{AsRule, Rule};
+use ruff_linter::settings::flags;
+use ruff_linter::settings::types::SerializationFormat;
+
+use crate::diagnostics::Diagnostics;
+
+bitflags! {
+    #[derive(Default, Debug, Copy, Clone)]
+    pub(crate) struct Flags: u8 {
+        /// Whether to show violations when emitting diagnostics.
+        const SHOW_VIOLATIONS = 0b0000_0001;
+        /// Whether to show the source code when emitting diagnostics.
+        const SHOW_SOURCE = 0b000_0010;
+        /// Whether to show a summary of the fixed violations when emitting diagnostics.
+        const SHOW_FIX_SUMMARY = 0b0000_0100;
+        /// Whether to show a diff of each fixed violation when emitting diagnostics.
+        const SHOW_FIX_DIFF = 0b0000_1000;
+    }
+}
+
+#[derive(Serialize)]
+struct ExpandedStatistics<'a> {
+    code: SerializeRuleAsCode,
+    message: &'a str,
+    count: usize,
+    fixable: bool,
+}
+
+struct SerializeRuleAsCode(Rule);
+
+impl Serialize for SerializeRuleAsCode {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.0.noqa_code().to_string())
+    }
+}
+
+impl Display for SerializeRuleAsCode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0.noqa_code())
+    }
+}
+
+impl From<Rule> for SerializeRuleAsCode {
+    fn from(rule: Rule) -> Self {
+        Self(rule)
+    }
+}
+
+pub(crate) struct Printer {
+    format: SerializationFormat,
+    log_level: LogLevel,
+    autofix_level: flags::FixMode,
+    flags: Flags,
+}
+
+impl Printer {
+    pub(crate) const fn new(
+        format: SerializationFormat,
+        log_level: LogLevel,
+        autofix_level: flags::FixMode,
+        flags: Flags,
+    ) -> Self {
+        Self {
+            format,
+            log_level,
+            autofix_level,
+            flags,
+        }
+    }
+
+    pub(crate) fn write_to_user(&self, message: &str) {
+        if self.log_level >= LogLevel::Default {
+            notify_user!("{}", message);
+        }
+    }
+
+    fn write_summary_text(&self, writer: &mut dyn Write, diagnostics: &Diagnostics) -> Result<()> {
+        if self.log_level >= LogLevel::Default {
+            if self.flags.intersects(Flags::SHOW_VIOLATIONS) {
+                let fixed = diagnostics
+                    .fixed
+                    .values()
+                    .flat_map(std::collections::HashMap::values)
+                    .sum::<usize>();
+                let remaining = diagnostics.messages.len();
+                let total = fixed + remaining;
+                if fixed > 0 {
+                    let s = if total == 1 { "" } else { "s" };
+                    writeln!(
+                        writer,
+                        "Found {total} error{s} ({fixed} fixed, {remaining} remaining)."
+                    )?;
+                } else if remaining > 0 {
+                    let s = if remaining == 1 { "" } else { "s" };
+                    writeln!(writer, "Found {remaining} error{s}.")?;
+                }
+
+                if show_fix_status(self.autofix_level) {
+                    let num_fixable = diagnostics
+                        .messages
+                        .iter()
+                        .filter(|message| message.fix.is_some())
+                        .count();
+                    if num_fixable > 0 {
+                        writeln!(
+                            writer,
+                            "[{}] {num_fixable} potentially fixable with the --fix option.",
+                            "*".cyan(),
+                        )?;
+                    }
+                }
+            } else {
+                let fixed = diagnostics
+                    .fixed
+                    .values()
+                    .flat_map(std::collections::HashMap::values)
+                    .sum::<usize>();
+                if fixed > 0 {
+                    let s = if fixed == 1 { "" } else { "s" };
+                    if self.autofix_level.is_apply() {
+                        writeln!(writer, "Fixed {fixed} error{s}.")?;
+                    } else {
+                        writeln!(writer, "Would fix {fixed} error{s}.")?;
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn write_once(
+        &self,
+        diagnostics: &Diagnostics,
+        writer: &mut dyn Write,
+    ) -> Result<()> {
+        if matches!(self.log_level, LogLevel::Silent) {
+            return Ok(());
+        }
+
+        if !self.flags.intersects(Flags::SHOW_VIOLATIONS) {
+            if matches!(
+                self.format,
+                SerializationFormat::Text | SerializationFormat::Grouped
+            ) {
+                if self.flags.intersects(Flags::SHOW_FIX_SUMMARY) {
+                    if !diagnostics.fixed.is_empty() {
+                        writeln!(writer)?;
+                        print_fix_summary(writer, &diagnostics.fixed)?;
+                        writeln!(writer)?;
+                    }
+                }
+                self.write_summary_text(writer, diagnostics)?;
+            }
+            return Ok(());
+        }
+
+        let context = EmitterContext::new(&diagnostics.notebook_indexes);
+
+        match self.format {
+            SerializationFormat::Json => {
+                JsonEmitter.emit(writer, &diagnostics.messages, &context)?;
+            }
+            SerializationFormat::JsonLines => {
+                JsonLinesEmitter.emit(writer, &diagnostics.messages, &context)?;
+            }
+            SerializationFormat::Junit => {
+                JunitEmitter.emit(writer, &diagnostics.messages, &context)?;
+            }
+            SerializationFormat::Text => {
+                TextEmitter::default()
+                    .with_show_fix_status(show_fix_status(self.autofix_level))
+                    .with_show_fix_diff(self.flags.intersects(Flags::SHOW_FIX_DIFF))
+                    .with_show_source(self.flags.intersects(Flags::SHOW_SOURCE))
+                    .emit(writer, &diagnostics.messages, &context)?;
+
+                if self.flags.intersects(Flags::SHOW_FIX_SUMMARY) {
+                    if !diagnostics.fixed.is_empty() {
+                        writeln!(writer)?;
+                        print_fix_summary(writer, &diagnostics.fixed)?;
+                        writeln!(writer)?;
+                    }
+                }
+
+                self.write_summary_text(writer, diagnostics)?;
+            }
+            SerializationFormat::Grouped => {
+                GroupedEmitter::default()
+                    .with_show_source(self.flags.intersects(Flags::SHOW_SOURCE))
+                    .with_show_fix_status(show_fix_status(self.autofix_level))
+                    .emit(writer, &diagnostics.messages, &context)?;
+
+                if self.flags.intersects(Flags::SHOW_FIX_SUMMARY) {
+                    if !diagnostics.fixed.is_empty() {
+                        writeln!(writer)?;
+                        print_fix_summary(writer, &diagnostics.fixed)?;
+                        writeln!(writer)?;
+                    }
+                }
+                self.write_summary_text(writer, diagnostics)?;
+            }
+            SerializationFormat::Github => {
+                GithubEmitter.emit(writer, &diagnostics.messages, &context)?;
+            }
+            SerializationFormat::Gitlab => {
+                GitlabEmitter::default().emit(writer, &diagnostics.messages, &context)?;
+            }
+            SerializationFormat::Pylint => {
+                PylintEmitter.emit(writer, &diagnostics.messages, &context)?;
+            }
+            SerializationFormat::Azure => {
+                AzureEmitter.emit(writer, &diagnostics.messages, &context)?;
+            }
+        }
+
+        writer.flush()?;
+
+        Ok(())
+    }
+
+    pub(crate) fn write_statistics(
+        &self,
+        diagnostics: &Diagnostics,
+        writer: &mut dyn Write,
+    ) -> Result<()> {
+        let statistics: Vec<ExpandedStatistics> = diagnostics
+            .messages
+            .iter()
+            .map(|message| {
+                (
+                    message.kind.rule(),
+                    &message.kind.body,
+                    message.fix.is_some(),
+                )
+            })
+            .sorted()
+            .fold(vec![], |mut acc, (rule, body, fixable)| {
+                if let Some((prev_rule, _, _, count)) = acc.last_mut() {
+                    if *prev_rule == rule {
+                        *count += 1;
+                        return acc;
+                    }
+                }
+                acc.push((rule, body, fixable, 1));
+                acc
+            })
+            .iter()
+            .map(|(rule, message, fixable, count)| ExpandedStatistics {
+                code: (*rule).into(),
+                count: *count,
+                message,
+                fixable: *fixable,
+            })
+            .sorted_by_key(|statistic| Reverse(statistic.count))
+            .collect();
+
+        if statistics.is_empty() {
+            return Ok(());
+        }
+
+        match self.format {
+            SerializationFormat::Text => {
+                // Compute the maximum number of digits in the count and code, for all messages,
+                // to enable pretty-printing.
+                let count_width = num_digits(
+                    statistics
+                        .iter()
+                        .map(|statistic| statistic.count)
+                        .max()
+                        .unwrap(),
+                );
+                let code_width = statistics
+                    .iter()
+                    .map(|statistic| statistic.code.to_string().len())
+                    .max()
+                    .unwrap();
+                let any_fixable = statistics.iter().any(|statistic| statistic.fixable);
+
+                let fixable = format!("[{}] ", "*".cyan());
+                let unfixable = "[ ] ";
+
+                // By default, we mimic Flake8's `--statistics` format.
+                for statistic in statistics {
+                    writeln!(
+                        writer,
+                        "{:>count_width$}\t{:<code_width$}\t{}{}",
+                        statistic.count.to_string().bold(),
+                        statistic.code.to_string().red().bold(),
+                        if any_fixable {
+                            if statistic.fixable {
+                                &fixable
+                            } else {
+                                unfixable
+                            }
+                        } else {
+                            ""
+                        },
+                        statistic.message,
+                    )?;
+                }
+                return Ok(());
+            }
+            SerializationFormat::Json => {
+                writeln!(writer, "{}", serde_json::to_string_pretty(&statistics)?)?;
+            }
+            _ => {
+                anyhow::bail!(
+                    "Unsupported serialization format for statistics: {:?}",
+                    self.format
+                )
+            }
+        }
+
+        writer.flush()?;
+
+        Ok(())
+    }
+
+    pub(crate) fn write_continuously(
+        &self,
+        writer: &mut dyn Write,
+        diagnostics: &Diagnostics,
+    ) -> Result<()> {
+        if matches!(self.log_level, LogLevel::Silent) {
+            return Ok(());
+        }
+
+        if self.log_level >= LogLevel::Default {
+            let s = if diagnostics.messages.len() == 1 {
+                ""
+            } else {
+                "s"
+            };
+            notify_user!(
+                "Found {} error{s}. Watching for file changes.",
+                diagnostics.messages.len()
+            );
+        }
+
+        if !diagnostics.messages.is_empty() {
+            if self.log_level >= LogLevel::Default {
+                writeln!(writer)?;
+            }
+
+            let context = EmitterContext::new(&diagnostics.notebook_indexes);
+            TextEmitter::default()
+                .with_show_fix_status(show_fix_status(self.autofix_level))
+                .with_show_source(self.flags.intersects(Flags::SHOW_SOURCE))
+                .emit(writer, &diagnostics.messages, &context)?;
+        }
+        writer.flush()?;
+
+        Ok(())
+    }
+
+    pub(crate) fn clear_screen() -> Result<()> {
+        #[cfg(not(target_family = "wasm"))]
+        clearscreen::clear()?;
+        Ok(())
+    }
+}
+
+fn num_digits(n: usize) -> usize {
+    iterate(n, |&n| n / 10)
+        .take_while(|&n| n > 0)
+        .count()
+        .max(1)
+}
+
+/// Return `true` if the [`Printer`] should indicate that a rule is fixable.
+const fn show_fix_status(autofix_level: flags::FixMode) -> bool {
+    // If we're in application mode, avoid indicating that a rule is fixable.
+    // If the specific violation were truly fixable, it would've been fixed in
+    // this pass! (We're occasionally unable to determine whether a specific
+    // violation is fixable without trying to fix it, so if autofix is not
+    // enabled, we may inadvertently indicate that a rule is fixable.)
+    !autofix_level.is_apply()
+}
+
+fn print_fix_summary(writer: &mut dyn Write, fixed: &FxHashMap<String, FixTable>) -> Result<()> {
+    let total = fixed
+        .values()
+        .map(|table| table.values().sum::<usize>())
+        .sum::<usize>();
+    assert!(total > 0);
+    let num_digits = num_digits(
+        *fixed
+            .values()
+            .filter_map(|table| table.values().max())
+            .max()
+            .unwrap(),
+    );
+
+    let s = if total == 1 { "" } else { "s" };
+    let label = format!("Fixed {total} error{s}:");
+    writeln!(writer, "{}", label.bold().green())?;
+
+    for (filename, table) in fixed
+        .iter()
+        .sorted_by_key(|(filename, ..)| filename.as_str())
+    {
+        writeln!(
+            writer,
+            "{} {}{}",
+            "-".cyan(),
+            relativize_path(filename).bold(),
+            ":".cyan()
+        )?;
+        for (rule, count) in table.iter().sorted_by_key(|(.., count)| Reverse(*count)) {
+            writeln!(
+                writer,
+                "    {count:>num_digits$} × {} ({})",
+                rule.noqa_code().to_string().red().bold(),
+                rule.as_ref(),
+            )?;
+        }
+    }
+    Ok(())
+}

crates/ruff_cli/src/resolve.rs

@@ -0,0 +1,101 @@
+use std::path::{Path, PathBuf};
+
+use anyhow::Result;
+use log::debug;
+use path_absolutize::path_dedot;
+
+use ruff_workspace::configuration::Configuration;
+use ruff_workspace::pyproject;
+use ruff_workspace::resolver::{
+    resolve_root_settings, ConfigurationTransformer, PyprojectConfig, PyprojectDiscoveryStrategy,
+    Relativity,
+};
+
+use crate::args::CliOverrides;
+
+/// Resolve the relevant settings strategy and defaults for the current
+/// invocation.
+pub fn resolve(
+    isolated: bool,
+    config: Option<&Path>,
+    overrides: &CliOverrides,
+    stdin_filename: Option<&Path>,
+) -> Result<PyprojectConfig> {
+    // First priority: if we're running in isolated mode, use the default settings.
+    if isolated {
+        let config = overrides.transform(Configuration::default());
+        let settings = config.into_settings(&path_dedot::CWD)?;
+        debug!("Isolated mode, not reading any pyproject.toml");
+        return Ok(PyprojectConfig::new(
+            PyprojectDiscoveryStrategy::Fixed,
+            settings,
+            None,
+        ));
+    }
+
+    // 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.)
+    if let Some(pyproject) = config
+        .map(|config| config.display().to_string())
+        .map(|config| shellexpand::full(&config).map(|config| PathBuf::from(config.as_ref())))
+        .transpose()?
+    {
+        let settings = resolve_root_settings(&pyproject, Relativity::Cwd, overrides)?;
+        debug!(
+            "Using user specified pyproject.toml at {}",
+            pyproject.display()
+        );
+        return Ok(PyprojectConfig::new(
+            PyprojectDiscoveryStrategy::Fixed,
+            settings,
+            Some(pyproject),
+        ));
+    }
+
+    // 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.)
+    if let Some(pyproject) = pyproject::find_settings_toml(
+        stdin_filename
+            .as_ref()
+            .unwrap_or(&path_dedot::CWD.as_path()),
+    )? {
+        debug!("Using pyproject.toml (parent) at {}", pyproject.display());
+        let settings = resolve_root_settings(&pyproject, Relativity::Parent, overrides)?;
+        return Ok(PyprojectConfig::new(
+            PyprojectDiscoveryStrategy::Hierarchical,
+            settings,
+            Some(pyproject),
+        ));
+    }
+
+    // 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.)
+    if let Some(pyproject) = pyproject::find_user_settings_toml() {
+        debug!("Using pyproject.toml (cwd) at {}", pyproject.display());
+        let settings = resolve_root_settings(&pyproject, Relativity::Cwd, overrides)?;
+        return Ok(PyprojectConfig::new(
+            PyprojectDiscoveryStrategy::Hierarchical,
+            settings,
+            Some(pyproject),
+        ));
+    }
+
+    // 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.)
+    debug!("Using Ruff default settings");
+    let config = overrides.transform(Configuration::default());
+    let settings = config.into_settings(&path_dedot::CWD)?;
+    Ok(PyprojectConfig::new(
+        PyprojectDiscoveryStrategy::Hierarchical,
+        settings,
+        None,
+    ))
+}

crates/ruff_cli/src/stdin.rs

@@ -0,0 +1,9 @@
+use std::io;
+use std::io::Read;
+
+/// Read a string from `stdin`.
+pub(crate) fn read_from_stdin() -> Result<String, io::Error> {
+    let mut buffer = String::new();
+    io::stdin().lock().read_to_string(&mut buffer)?;
+    Ok(buffer)
+}

crates/ruff_cli/tests/black_compatibility_test.rs

@@ -0,0 +1,204 @@
+#![cfg(not(target_family = "wasm"))]
+
+use std::io::{ErrorKind, Read, Write};
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, TcpListener, TcpStream};
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+use std::thread::sleep;
+use std::time::Duration;
+use std::{fs, process, str};
+
+use anyhow::{anyhow, bail, Context, Result};
+use insta_cmd::get_cargo_bin;
+use log::info;
+use walkdir::WalkDir;
+
+use ruff_linter::logging::{set_up_logging, LogLevel};
+
+/// 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(crate) fn new() -> Result<Self> {
+        // Get free TCP port to run on
+        let address = TcpListener::bind(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0))?.local_addr()?;
+
+        let args = [
+            "--bind-host",
+            &address.ip().to_string(),
+            "--bind-port",
+            &address.port().to_string(),
+        ];
+        let server = Command::new("blackd")
+            .args(args)
+            .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");
+                    return Ok(Self {
+                        address,
+                        server,
+                        client: ureq::agent(),
+                    });
+                }
+            }
+        }
+
+        bail!("blackd {:?} failed to start", args)
+    }
+
+    /// Format given code with blackd.
+    pub(crate) 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 mut step_1 = Command::new(get_cargo_bin(BIN_NAME))
+        .args(ruff_args)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()?;
+    if let Some(mut stdin) = step_1.stdin.take() {
+        stdin.write_all(input.as_ref())?;
+    }
+    let step_1_output = step_1.wait_with_output()?;
+    if !step_1_output.status.success() {
+        return Err(anyhow!(
+            "Running input through ruff failed:\n{}",
+            str::from_utf8(&step_1_output.stderr)?
+        ));
+    }
+
+    // Step 2: Run `blackd` on the input.
+    let step_2_output = blackd.check(&step_1_output.stdout.clone())?;
+
+    // Step 3: Re-run `ruff` on the input.
+    let mut step_3 = Command::new(get_cargo_bin(BIN_NAME))
+        .args(ruff_args)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()?;
+    if let Some(mut stdin) = step_3.stdin.take() {
+        stdin.write_all(step_2_output.as_ref())?;
+    }
+    let step_3_output = step_3.wait_with_output()?;
+    if !step_3_output.status.success() {
+        return Err(anyhow!(
+            "Running input through ruff after black failed:\n{}",
+            str::from_utf8(&step_3_output.stderr)?
+        ));
+    }
+    let step_3_output = step_3_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 = WalkDir::new(fixtures_dir)
+        .into_iter()
+        .flatten()
+        .filter(|entry| {
+            entry
+                .path()
+                .extension()
+                .is_some_and(|ext| ext == "py" || ext == "pyi")
+                && !excludes.contains(&entry.path().file_name().unwrap().to_str().unwrap())
+        });
+
+    let ruff_args = [
+        "-",
+        "--silent",
+        "--exit-zero",
+        "--fix",
+        "--line-length",
+        "88",
+        "--select",
+        "ALL",
+        // 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.
+        "--ignore",
+        "RUF",
+    ];
+
+    for entry in paths {
+        let path = entry.path();
+        run_test(path, &blackd, &ruff_args).context(format!("Testing {}", path.display()))?;
+    }
+
+    Ok(())
+}

crates/ruff_cli/tests/integration_test.rs

@@ -0,0 +1,576 @@
+#![cfg(not(target_family = "wasm"))]
+
+#[cfg(unix)]
+use std::fs;
+#[cfg(unix)]
+use std::fs::Permissions;
+#[cfg(unix)]
+use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
+#[cfg(unix)]
+use std::path::Path;
+use std::process::Command;
+use std::str;
+
+#[cfg(unix)]
+use anyhow::Context;
+use anyhow::Result;
+#[cfg(unix)]
+use clap::Parser;
+use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
+#[cfg(unix)]
+use path_absolutize::path_dedot;
+#[cfg(unix)]
+use tempfile::TempDir;
+
+#[cfg(unix)]
+use ruff_cli::args::Args;
+#[cfg(unix)]
+use ruff_cli::run;
+
+const BIN_NAME: &str = "ruff";
+const STDIN_BASE_OPTIONS: &[&str] = &["--isolated", "--no-cache", "-", "--output-format", "text"];
+
+#[test]
+fn stdin_success() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .pass_stdin(""), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn stdin_error() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .pass_stdin("import os\n"), @r#"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:8: F401 [*] `os` imported but unused
+    Found 1 error.
+    [*] 1 potentially fixable with the --fix option.
+
+    ----- stderr -----
+    "#);
+}
+
+#[test]
+fn stdin_filename() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--stdin-filename", "F401.py"])
+        .pass_stdin("import os\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    F401.py:1:8: F401 [*] `os` imported but unused
+    Found 1 error.
+    [*] 1 potentially fixable with the --fix option.
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+/// Raise `TCH` errors in `.py` files ...
+fn stdin_source_type_py() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(["--stdin-filename", "TCH.py"])
+        .pass_stdin("import os\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    TCH.py:1:8: F401 [*] `os` imported but unused
+    Found 1 error.
+    [*] 1 potentially fixable with the --fix option.
+
+    ----- stderr -----
+    "###);
+}
+
+/// ... but not in `.pyi` files.
+#[test]
+fn stdin_source_type_pyi() {
+    let args = ["--stdin-filename", "TCH.pyi", "--select", "TCH"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("import os\n"), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    "###);
+}
+
+#[cfg(unix)]
+#[test]
+fn stdin_json() {
+    let args = [
+        "-",
+        "--isolated",
+        "--no-cache",
+        "--output-format",
+        "json",
+        "--stdin-filename",
+        "F401.py",
+    ];
+
+    let directory = path_dedot::CWD.to_str().unwrap();
+    let binding = Path::new(directory).join("F401.py");
+    let file_path = binding.display();
+
+    insta::with_settings!({filters => vec![
+        (file_path.to_string().as_str(), "/path/to/F401.py"),
+    ]}, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+            .args(args)
+            .pass_stdin("import os\n"));
+    });
+}
+
+#[test]
+fn stdin_autofix() {
+    let args = ["--fix"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("import os\nimport sys\n\nprint(sys.version)\n"), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    import sys
+
+    print(sys.version)
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn stdin_autofix_when_not_fixable_should_still_print_contents() {
+    let args = ["--fix"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("import os\nimport sys\n\nif (1, 2):\n     print(sys.version)\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    import sys
+
+    if (1, 2):
+         print(sys.version)
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn stdin_autofix_when_no_issues_should_still_print_contents() {
+    let args = ["--fix"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("import sys\n\nprint(sys.version)\n"), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+    import sys
+
+    print(sys.version)
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn show_source() {
+    let args = ["--show-source"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("l = 1"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `l`
+      |
+    1 | l = 1
+      | ^ E741
+      |
+
+    Found 1 error.
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn explain_status_codes_f401() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME)).args(["--explain", "F401"]));
+}
+#[test]
+fn explain_status_codes_ruf404() {
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME)).args(["--explain", "RUF404"]), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'RUF404' for '[RULE]'
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn show_statistics() {
+    let args = ["--select", "F401", "--statistics"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("import sys\nimport os\n\nprint(os.getuid())\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    1	F401	[*] `sys` imported but unused
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn nursery_prefix() {
+    // `--select E` should detect E741, but not E225, which is in the nursery.
+    let args = ["--select", "E"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `I`
+    Found 1 error.
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn nursery_all() {
+    // `--select ALL` should detect E741, but not E225, which is in the nursery.
+    let args = ["--select", "ALL"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `I`
+    -:1:1: D100 Missing docstring in public module
+    Found 2 errors.
+
+    ----- stderr -----
+    warning: `one-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible. Ignoring `one-blank-line-before-class`.
+    warning: `multi-line-summary-first-line` (D212) and `multi-line-summary-second-line` (D213) are incompatible. Ignoring `multi-line-summary-second-line`.
+    "###);
+}
+
+#[test]
+fn nursery_direct() {
+    // `--select E225` should detect E225.
+    let args = ["--select", "E225"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:2: E225 Missing whitespace around operator
+    Found 1 error.
+
+    ----- stderr -----
+    warning: Selection of nursery rule `E225` without the `--preview` flag is deprecated.
+    "###);
+}
+
+#[test]
+fn nursery_group_selector() {
+    // Only nursery rules should be detected e.g. E225 and a warning should be displayed
+    let args = ["--select", "NURSERY"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: CPY001 Missing copyright notice at top of file
+    -:1:2: E225 Missing whitespace around operator
+    Found 2 errors.
+
+    ----- stderr -----
+    warning: The `NURSERY` selector has been deprecated. Use the `--preview` flag instead.
+    "###);
+}
+
+#[test]
+fn nursery_group_selector_preview_enabled() {
+    // Only nursery rules should be detected e.g. E225 and a warning should be displayed
+    let args = ["--select", "NURSERY", "--preview"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: CPY001 Missing copyright notice at top of file
+    -:1:2: E225 Missing whitespace around operator
+    Found 2 errors.
+
+    ----- stderr -----
+    warning: The `NURSERY` selector has been deprecated.
+    "###);
+}
+
+#[test]
+fn preview_enabled_prefix() {
+    // E741 and E225 (preview) should both be detected
+    let args = ["--select", "E", "--preview"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `I`
+    -:1:2: E225 Missing whitespace around operator
+    Found 2 errors.
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn preview_enabled_all() {
+    let args = ["--select", "ALL", "--preview"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:1: E741 Ambiguous variable name: `I`
+    -:1:1: D100 Missing docstring in public module
+    -:1:1: CPY001 Missing copyright notice at top of file
+    -:1:2: E225 Missing whitespace around operator
+    Found 4 errors.
+
+    ----- stderr -----
+    warning: `one-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible. Ignoring `one-blank-line-before-class`.
+    warning: `multi-line-summary-first-line` (D212) and `multi-line-summary-second-line` (D213) are incompatible. Ignoring `multi-line-summary-second-line`.
+    "###);
+}
+
+#[test]
+fn preview_enabled_direct() {
+    // E225 should be detected without warning
+    let args = ["--select", "E225", "--preview"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 1
+    ----- stdout -----
+    -:1:2: E225 Missing whitespace around operator
+    Found 1 error.
+
+    ----- stderr -----
+    "###);
+}
+
+#[test]
+fn preview_disabled_direct() {
+    // FURB145 is preview not nursery so selecting should be empty
+    let args = ["--select", "FURB145"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("a = l[:]\n"), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    warning: Selection `FURB145` has no effect because the `--preview` flag was not included.
+    "###);
+}
+
+#[test]
+fn preview_disabled_prefix_empty() {
+    // Warns that the selection is empty since all of the CPY rules are in preview
+    let args = ["--select", "CPY"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    warning: Selection `CPY` has no effect because the `--preview` flag was not included.
+    "###);
+}
+
+#[test]
+fn preview_group_selector() {
+    // `--select PREVIEW` should error (selector was removed)
+    let args = ["--select", "PREVIEW", "--preview"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'PREVIEW' for '--select <RULE_CODE>'
+
+    For more information, try '--help'.
+    "###);
+}
+
+#[test]
+fn preview_enabled_group_ignore() {
+    // `--select E --ignore PREVIEW` should detect E741 and E225, which is in preview but "E" is more specific.
+    let args = ["--select", "E", "--ignore", "PREVIEW", "--preview"];
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(STDIN_BASE_OPTIONS)
+        .args(args)
+        .pass_stdin("I=42\n"), @r###"
+    success: false
+    exit_code: 2
+    ----- stdout -----
+
+    ----- stderr -----
+    error: invalid value 'PREVIEW' for '--ignore <RULE_CODE>'
+
+    For more information, try '--help'.
+    "###);
+}
+
+/// An unreadable pyproject.toml in non-isolated mode causes ruff to hard-error trying to build up
+/// configuration globs
+#[cfg(unix)]
+#[test]
+fn unreadable_pyproject_toml() -> Result<()> {
+    let tempdir = TempDir::new()?;
+    let pyproject_toml = tempdir.path().join("pyproject.toml");
+    // Create an empty file with 000 permissions
+    fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .mode(0o000)
+        .open(pyproject_toml)?;
+
+    // Don't `--isolated` since the configuration discovery is where the error happens
+    let args = Args::parse_from(["", "check", "--no-cache", tempdir.path().to_str().unwrap()]);
+    let err = run(args).err().context("Unexpected success")?;
+    assert_eq!(
+        err.chain()
+            .map(std::string::ToString::to_string)
+            .collect::<Vec<_>>(),
+        vec!["Permission denied (os error 13)".to_string()],
+    );
+    Ok(())
+}
+
+/// Check the output with an unreadable directory
+#[cfg(unix)]
+#[test]
+fn unreadable_dir() -> Result<()> {
+    // Create a directory with 000 (not iterable/readable) permissions
+    let tempdir = TempDir::new()?;
+    let unreadable_dir = tempdir.path().join("unreadable_dir");
+    fs::create_dir(&unreadable_dir)?;
+    fs::set_permissions(&unreadable_dir, Permissions::from_mode(0o000))?;
+
+    // We (currently?) have to use a subcommand to check exit status (currently wrong) and logging
+    // output
+    // TODO(konstin): This should be a failure, but we currently can't track that
+    assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+        .args(["--no-cache", "--isolated"])
+        .arg(&unreadable_dir), @r###"
+    success: true
+    exit_code: 0
+    ----- stdout -----
+
+    ----- stderr -----
+    warning: Encountered error: Permission denied (os error 13)
+    "###);
+    Ok(())
+}
+
+/// Check that reading arguments from an argfile works
+#[cfg(unix)]
+#[test]
+fn check_input_from_argfile() -> Result<()> {
+    let tempdir = TempDir::new()?;
+
+    // Create python files
+    let file_a_path = tempdir.path().join("a.py");
+    let file_b_path = tempdir.path().join("b.py");
+    fs::write(&file_a_path, b"import os")?;
+    fs::write(&file_b_path, b"print('hello, world!')")?;
+
+    // Create a the input file for argfile to expand
+    let input_file_path = tempdir.path().join("file_paths.txt");
+    fs::write(
+        &input_file_path,
+        format!("{}\n{}", file_a_path.display(), file_b_path.display()),
+    )?;
+
+    // Generate the args with the argfile notation
+    let args = vec![
+        "check".to_string(),
+        "--no-cache".to_string(),
+        "--isolated".to_string(),
+        format!("@{}", &input_file_path.display()),
+    ];
+
+    insta::with_settings!({filters => vec![
+        (file_a_path.display().to_string().as_str(), "/path/to/a.py"),
+    ]}, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+            .args(args)
+            .pass_stdin(""), @r###"
+        success: false
+        exit_code: 1
+        ----- stdout -----
+        /path/to/a.py:1:8: F401 [*] `os` imported but unused
+        Found 1 error.
+        [*] 1 potentially fixable with the --fix option.
+
+        ----- stderr -----
+        "###);
+    });
+
+    Ok(())
+}

crates/ruff_cli/tests/snapshots/integration_test__explain_status_codes_f401.snap

@@ -0,0 +1,61 @@
+---
+source: crates/ruff_cli/tests/integration_test.rs
+info:
+  program: ruff
+  args:
+    - "--explain"
+    - F401
+---
+success: true
+exit_code: 0
+----- stdout -----
+# unused-import (F401)
+
+Derived from the **Pyflakes** linter.
+
+Autofix is sometimes available.
+
+## What it does
+Checks for unused imports.
+
+## Why is this bad?
+Unused imports add a performance overhead at runtime, and risk creating
+import cycles. They also increase the cognitive load of reading the code.
+
+If an import statement is used to check for the availability or existence
+of a module, consider using `importlib.util.find_spec` instead.
+
+## Example
+```python
+import numpy as np  # unused import
+
+
+def area(radius):
+    return 3.14 * radius**2
+```
+
+Use instead:
+```python
+def area(radius):
+    return 3.14 * radius**2
+```
+
+To check the availability of a module, use `importlib.util.find_spec`:
+```python
+from importlib.util import find_spec
+
+if find_spec("numpy") is not None:
+    print("numpy is installed")
+else:
+    print("numpy is not installed")
+```
+
+## Options
+- `pyflakes.extend-generics`
+
+## References
+- [Python documentation: `import`](https://docs.python.org/3/reference/simple_stmts.html#the-import-statement)
+- [Python documentation: `importlib.util.find_spec`](https://docs.python.org/3/library/importlib.html#importlib.util.find_spec)
+
+----- stderr -----
+

crates/ruff_cli/tests/snapshots/integration_test__stdin_json.snap

@@ -0,0 +1,53 @@
+---
+source: crates/ruff_cli/tests/integration_test.rs
+info:
+  program: ruff
+  args:
+    - "-"
+    - "--isolated"
+    - "--no-cache"
+    - "--format"
+    - json
+    - "--stdin-filename"
+    - F401.py
+  stdin: "import os\n"
+---
+success: false
+exit_code: 1
+----- stdout -----
+[
+  {
+    "code": "F401",
+    "end_location": {
+      "column": 10,
+      "row": 1
+    },
+    "filename": "/path/to/F401.py",
+    "fix": {
+      "applicability": "Automatic",
+      "edits": [
+        {
+          "content": "",
+          "end_location": {
+            "column": 1,
+            "row": 2
+          },
+          "location": {
+            "column": 1,
+            "row": 1
+          }
+        }
+      ],
+      "message": "Remove unused import: `os`"
+    },
+    "location": {
+      "column": 8,
+      "row": 1
+    },
+    "message": "`os` imported but unused",
+    "noqa_row": 1,
+    "url": "https://docs.astral.sh/ruff/rules/unused-import"
+  }
+]
+----- stderr -----
+

crates/ruff_dev/Cargo.toml

@@ -0,0 +1,56 @@
+[package]
+name = "ruff_dev"
+version = "0.0.0"
+publish = false
+authors = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+homepage = { workspace = true }
+documentation = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
+
+[dependencies]
+ruff_linter = { path = "../ruff_linter", features = ["schemars"] }
+ruff_cli = { path = "../ruff_cli" }
+ruff_diagnostics = { path = "../ruff_diagnostics" }
+ruff_formatter = { path = "../ruff_formatter" }
+ruff_python_ast = { path = "../ruff_python_ast" }
+ruff_python_codegen = { path = "../ruff_python_codegen" }
+ruff_python_formatter = { path = "../ruff_python_formatter" }
+ruff_notebook = { path = "../ruff_notebook" }
+ruff_python_literal = { path = "../ruff_python_literal" }
+ruff_python_parser = { path = "../ruff_python_parser" }
+ruff_python_stdlib = { path = "../ruff_python_stdlib" }
+ruff_python_trivia = { path = "../ruff_python_trivia" }
+ruff_workspace = { path = "../ruff_workspace", features = ["schemars"]}
+
+anyhow = { workspace = true }
+clap = { workspace = true }
+ignore = { workspace = true }
+indicatif = "0.17.5"
+itertools = { workspace = true }
+libcst = { workspace = true }
+once_cell = { workspace = true }
+pretty_assertions = { version = "1.3.0" }
+rayon = "1.8.0"
+regex = { workspace = true }
+schemars = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+similar = { workspace = true }
+strum = { workspace = true }
+strum_macros = { workspace = true }
+tempfile = "3.6.0"
+toml = { workspace = true, features = ["parse"] }
+tracing = { workspace = true }
+tracing-indicatif = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
+imara-diff = "0.1.5"
+
+[features]
+# Turn off rayon for profiling
+singlethreaded = []
+
+[dev-dependencies]
+indoc = "2.0.4"

crates/ruff_dev/src/format_dev.rs

@@ -0,0 +1,987 @@
+use std::fmt::{Display, Formatter};
+use std::fs::File;
+use std::io::{BufWriter, Write};
+use std::num::NonZeroU16;
+use std::ops::{Add, AddAssign};
+use std::panic::catch_unwind;
+use std::path::{Path, PathBuf};
+use std::process::ExitCode;
+use std::time::{Duration, Instant};
+use std::{fmt, fs, io, iter};
+
+use anyhow::{bail, format_err, Context, Error};
+use clap::{CommandFactory, FromArgMatches};
+use ignore::DirEntry;
+use imara_diff::intern::InternedInput;
+use imara_diff::sink::Counter;
+use imara_diff::{diff, Algorithm};
+use indicatif::ProgressStyle;
+#[cfg_attr(feature = "singlethreaded", allow(unused_imports))]
+use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use serde::Deserialize;
+use similar::{ChangeTag, TextDiff};
+use tempfile::NamedTempFile;
+use tracing::{debug, error, info, info_span};
+use tracing_indicatif::span_ext::IndicatifSpanExt;
+use tracing_indicatif::IndicatifLayer;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
+use tracing_subscriber::EnvFilter;
+
+use ruff_cli::args::{FormatCommand, LogLevelArgs};
+use ruff_cli::resolve::resolve;
+use ruff_formatter::{FormatError, LineWidth, PrintError};
+use ruff_linter::logging::LogLevel;
+use ruff_linter::settings::types::{FilePattern, FilePatternSet};
+use ruff_python_formatter::{
+    format_module_source, FormatModuleError, MagicTrailingComma, PyFormatOptions,
+};
+use ruff_workspace::resolver::{python_files_in_path, PyprojectConfig, Resolver};
+
+/// Find files that ruff would check so we can format them. Adapted from `ruff_cli`.
+#[allow(clippy::type_complexity)]
+fn ruff_check_paths(
+    dirs: &[PathBuf],
+) -> anyhow::Result<(
+    Vec<Result<DirEntry, ignore::Error>>,
+    Resolver,
+    PyprojectConfig,
+)> {
+    let args_matches = FormatCommand::command()
+        .no_binary_name(true)
+        .get_matches_from(dirs);
+    let arguments: FormatCommand = FormatCommand::from_arg_matches(&args_matches)?;
+    let (cli, overrides) = arguments.partition();
+    let mut pyproject_config = resolve(
+        cli.isolated,
+        cli.config.as_deref(),
+        &overrides,
+        cli.stdin_filename.as_deref(),
+    )?;
+    // We don't want to format pyproject.toml
+    pyproject_config.settings.file_resolver.include = FilePatternSet::try_from_iter([
+        FilePattern::Builtin("*.py"),
+        FilePattern::Builtin("*.pyi"),
+    ])
+    .unwrap();
+    let (paths, resolver) = python_files_in_path(&cli.files, &pyproject_config, &overrides)?;
+    if paths.is_empty() {
+        bail!("no python files in {:?}", dirs)
+    }
+    Ok((paths, resolver, pyproject_config))
+}
+
+/// Collects statistics over the formatted files to compute the Jaccard index or the similarity
+/// index.
+///
+/// If we define `B` as the black formatted input and `R` as the ruff formatted output, then
+/// * `B∩R`: Unchanged lines, neutral in the diff
+/// * `B\R`: Black only lines, minus in the diff
+/// * `R\B`: Ruff only lines, plus in the diff
+///
+/// The [Jaccard index](https://en.wikipedia.org/wiki/Jaccard_index) can be defined as
+/// ```text
+/// J(B, R) = |B∩R| / (|B\R| + |R\B| + |B∩R|)
+/// ```
+/// which you can read as number unchanged lines in the diff divided by all lines in the diff. If
+/// the input is not black formatted, this only becomes a measure for the changes made to the
+/// codebase during the initial formatting.
+///
+/// Another measure is the similarity index, the percentage of unchanged lines. We compute it as
+/// ```text
+/// Sim(B, R) = |B∩R| / (|B\R| + |B∩R|)
+/// ```
+/// which you can alternatively read as all lines in the input
+#[derive(Default, Debug, Copy, Clone)]
+pub(crate) struct Statistics {
+    /// The size of `A\B`, the number of lines only in the input, which we assume to be black
+    /// formatted
+    black_input: u32,
+    /// The size of `B\A`, the number of lines only in the formatted output
+    ruff_output: u32,
+    /// The number of matching identical lines
+    intersection: u32,
+    /// Files that have differences
+    files_with_differences: u32,
+}
+
+impl Statistics {
+    pub(crate) fn from_versions(black: &str, ruff: &str) -> Self {
+        if black == ruff {
+            let intersection = u32::try_from(black.lines().count()).unwrap();
+            Self {
+                black_input: 0,
+                ruff_output: 0,
+                intersection,
+                files_with_differences: 0,
+            }
+        } else {
+            // `similar` was too slow (for some files >90% diffing instead of formatting)
+            let input = InternedInput::new(black, ruff);
+            let changes = diff(Algorithm::Histogram, &input, Counter::default());
+            assert_eq!(
+                input.before.len() - (changes.removals as usize),
+                input.after.len() - (changes.insertions as usize)
+            );
+            Self {
+                black_input: changes.removals,
+                ruff_output: changes.insertions,
+                intersection: u32::try_from(input.before.len()).unwrap() - changes.removals,
+                files_with_differences: 1,
+            }
+        }
+    }
+
+    /// We currently prefer the the similarity index, but i'd like to keep this around
+    #[allow(clippy::cast_precision_loss, unused)]
+    pub(crate) fn jaccard_index(&self) -> f32 {
+        self.intersection as f32 / (self.black_input + self.ruff_output + self.intersection) as f32
+    }
+
+    #[allow(clippy::cast_precision_loss)]
+    pub(crate) fn similarity_index(&self) -> f32 {
+        self.intersection as f32 / (self.black_input + self.intersection) as f32
+    }
+}
+
+impl Add<Statistics> for Statistics {
+    type Output = Statistics;
+
+    fn add(self, rhs: Statistics) -> Self::Output {
+        Statistics {
+            black_input: self.black_input + rhs.black_input,
+            ruff_output: self.ruff_output + rhs.ruff_output,
+            intersection: self.intersection + rhs.intersection,
+            files_with_differences: self.files_with_differences + rhs.files_with_differences,
+        }
+    }
+}
+
+impl AddAssign<Statistics> for Statistics {
+    fn add_assign(&mut self, rhs: Statistics) {
+        *self = *self + rhs;
+    }
+}
+
+/// Control the verbosity of the output
+#[derive(Copy, Clone, PartialEq, Eq, clap::ValueEnum, Default)]
+pub(crate) enum Format {
+    /// Filenames only
+    Minimal,
+    /// Filenames and reduced diff
+    #[default]
+    Default,
+    /// Full diff and invalid code
+    Full,
+}
+
+#[allow(clippy::struct_excessive_bools)]
+#[derive(clap::Args)]
+pub(crate) struct Args {
+    /// Like `ruff check`'s files. See `--multi-project` if you want to format an ecosystem
+    /// checkout.
+    pub(crate) files: Vec<PathBuf>,
+    /// Check stability
+    ///
+    /// We want to ensure that once formatted content stays the same when formatted again, which is
+    /// known as formatter stability or formatter idempotency, and that the formatter prints
+    /// syntactically valid code. As our test cases cover only a limited amount of code, this allows
+    /// checking entire repositories.
+    #[arg(long)]
+    pub(crate) stability_check: bool,
+    /// Format the files. Without this flag, the python files are not modified
+    #[arg(long)]
+    pub(crate) write: bool,
+    /// Control the verbosity of the output
+    #[arg(long, default_value_t, value_enum)]
+    pub(crate) format: Format,
+    /// Print only the first error and exit, `-x` is same as pytest
+    #[arg(long, short = 'x')]
+    pub(crate) exit_first_error: bool,
+    /// Checks each project inside a directory, useful e.g. if you want to check all of the
+    /// ecosystem checkouts.
+    #[arg(long)]
+    pub(crate) multi_project: bool,
+    /// Write all errors to this file in addition to stdout. Only used in multi-project mode.
+    #[arg(long)]
+    pub(crate) error_file: Option<PathBuf>,
+    /// Write all log messages (same as cli) to this file
+    #[arg(long)]
+    pub(crate) log_file: Option<PathBuf>,
+    /// Write a markdown table with the similarity indices to this file
+    #[arg(long)]
+    pub(crate) stats_file: Option<PathBuf>,
+    /// Assert that there are exactly this many input files with errors. This catches regressions
+    /// (or improvements) in the parser.
+    #[arg(long)]
+    pub(crate) files_with_errors: Option<u32>,
+    #[clap(flatten)]
+    pub(crate) log_level_args: LogLevelArgs,
+}
+
+pub(crate) fn main(args: &Args) -> anyhow::Result<ExitCode> {
+    setup_logging(&args.log_level_args, args.log_file.as_deref())?;
+
+    let mut error_file = match &args.error_file {
+        Some(error_file) => Some(BufWriter::new(
+            File::create(error_file).context("Couldn't open error file")?,
+        )),
+        None => None,
+    };
+
+    let all_success = if args.multi_project {
+        format_dev_multi_project(args, error_file)?
+    } else {
+        let result = format_dev_project(&args.files, args.stability_check, args.write)?;
+        let error_count = result.error_count();
+
+        if result.error_count() > 0 {
+            error!(parent: None, "{}", result.display(args.format));
+        }
+        if let Some(error_file) = &mut error_file {
+            write!(error_file, "{}", result.display(args.format)).unwrap();
+        }
+        info!(
+            parent: None,
+            "Done: {} stability errors, {} files, similarity index {:.5}), files with differences: {} took {:.2}s, {} input files contained syntax errors ",
+            error_count,
+            result.file_count,
+            result.statistics.similarity_index(),
+            result.statistics.files_with_differences,
+            result.duration.as_secs_f32(),
+            result.syntax_error_in_input,
+        );
+
+        if let Some(files_with_errors) = args.files_with_errors {
+            if result.syntax_error_in_input != files_with_errors {
+                error!(
+                    "Expected {files_with_errors} input files with errors, found {}",
+                    result.syntax_error_in_input
+                );
+                return Ok(ExitCode::FAILURE);
+            }
+        }
+
+        error_count == 0
+    };
+    if all_success {
+        Ok(ExitCode::SUCCESS)
+    } else {
+        Ok(ExitCode::FAILURE)
+    }
+}
+
+fn setup_logging(log_level_args: &LogLevelArgs, log_file: Option<&Path>) -> io::Result<()> {
+    // Custom translation since we need the tracing type for `EnvFilter`
+    let log_level = match LogLevel::from(log_level_args) {
+        LogLevel::Default => tracing::Level::INFO,
+        LogLevel::Verbose => tracing::Level::DEBUG,
+        LogLevel::Quiet => tracing::Level::WARN,
+        LogLevel::Silent => tracing::Level::ERROR,
+    };
+    // 1. `RUST_LOG=`, 2. explicit CLI log level, 3. info, the ruff_cli default
+    let filter_layer = EnvFilter::try_from_default_env().unwrap_or_else(|_| {
+        EnvFilter::builder()
+            .with_default_directive(log_level.into())
+            .parse_lossy("")
+    });
+    let indicatif_layer = IndicatifLayer::new().with_progress_style(
+        // Default without the spinner
+        ProgressStyle::with_template("{span_child_prefix} {span_name}{{{span_fields}}}").unwrap(),
+    );
+    let indicitif_compatible_writer_layer = tracing_subscriber::fmt::layer()
+        .with_writer(indicatif_layer.get_stderr_writer())
+        .with_target(false);
+    let log_layer = log_file.map(File::create).transpose()?.map(|log_file| {
+        tracing_subscriber::fmt::layer()
+            .with_writer(log_file)
+            .with_ansi(false)
+    });
+    tracing_subscriber::registry()
+        .with(filter_layer)
+        .with(indicitif_compatible_writer_layer)
+        .with(indicatif_layer)
+        .with(log_layer)
+        .init();
+    Ok(())
+}
+
+/// Checks a directory of projects
+fn format_dev_multi_project(
+    args: &Args,
+    mut error_file: Option<BufWriter<File>>,
+) -> anyhow::Result<bool> {
+    let mut total_errors = 0;
+    let mut total_files = 0;
+    let mut total_syntax_error_in_input = 0;
+    let start = Instant::now();
+
+    let mut project_paths = Vec::new();
+
+    for directory in &args.files {
+        for project_directory in directory
+            .read_dir()
+            .with_context(|| "Failed to read projects directory '{directory}'")?
+        {
+            project_paths.push(
+                project_directory
+                    .with_context(|| "Failed to read project directory '{project_directory}'")?
+                    .path(),
+            );
+        }
+    }
+
+    let pb_span = info_span!("format_dev_multi_project progress bar");
+    pb_span.pb_set_style(&ProgressStyle::default_bar());
+    pb_span.pb_set_length(project_paths.len() as u64);
+    let pb_span_enter = pb_span.enter();
+
+    let mut results = Vec::new();
+
+    for project_path in project_paths {
+        debug!(parent: None, "Starting {}", project_path.display());
+
+        match format_dev_project(&[project_path.clone()], args.stability_check, args.write) {
+            Ok(result) => {
+                total_errors += result.error_count();
+                total_files += result.file_count;
+                total_syntax_error_in_input += result.syntax_error_in_input;
+
+                info!(
+                    parent: None,
+                    "Finished {}: {} stability errors, {} files, similarity index {:.5}), files with differences {}, took {:.2}s, {} input files contained syntax errors ",
+                    project_path.display(),
+                    result.error_count(),
+                    result.file_count,
+                    result.statistics.similarity_index(),
+                    result.statistics.files_with_differences,
+                    result.duration.as_secs_f32(),
+                    result.syntax_error_in_input,
+                );
+                if result.error_count() > 0 {
+                    error!(
+                        parent: None,
+                        "{}",
+                        result.display(args.format).to_string().trim_end()
+                    );
+                }
+                if let Some(error_file) = &mut error_file {
+                    write!(error_file, "{}", result.display(args.format)).unwrap();
+                }
+                results.push(result);
+
+                pb_span.pb_inc(1);
+            }
+            Err(error) => {
+                error!(parent: None, "Failed {}: {}", project_path.display(), error);
+                pb_span.pb_inc(1);
+            }
+        }
+    }
+
+    drop(pb_span_enter);
+    drop(pb_span);
+
+    let duration = start.elapsed();
+
+    info!(
+        parent: None,
+        "Finished: {total_errors} stability errors, {total_files} files, tool {}s, {total_syntax_error_in_input} input files contained syntax errors ",
+        duration.as_secs_f32(),
+    );
+
+    if let Some(stats_file) = &args.stats_file {
+        results.sort_by(|result1, result2| result1.name.cmp(&result2.name));
+        let project_col_len = results
+            .iter()
+            .map(|result| result.name.len())
+            .chain(iter::once("project".len()))
+            .max()
+            .unwrap_or_default();
+        let mut stats_file = BufWriter::new(File::create(stats_file)?);
+        writeln!(
+            stats_file,
+            "| {:<project_col_len$} | similarity index  | total files       | changed files     |",
+            "project"
+        )?;
+        writeln!(
+            stats_file,
+            "|-{:-<project_col_len$}-|------------------:|------------------:|------------------:|",
+            ""
+        )?;
+        for result in results {
+            writeln!(
+                stats_file,
+                "| {:<project_col_len$} |           {:.5} |             {:5} |             {:5} |",
+                result.name,
+                result.statistics.similarity_index(),
+                result.file_count,
+                result.statistics.files_with_differences
+            )?;
+        }
+    }
+
+    if let Some(files_with_errors) = args.files_with_errors {
+        if total_syntax_error_in_input != files_with_errors {
+            error!(
+                "Expected {files_with_errors} input files with errors, found {}",
+                total_syntax_error_in_input
+            );
+            return Ok(false);
+        }
+    }
+
+    Ok(total_errors == 0)
+}
+
+#[tracing::instrument]
+fn format_dev_project(
+    files: &[PathBuf],
+    stability_check: bool,
+    write: bool,
+) -> anyhow::Result<CheckRepoResult> {
+    let start = Instant::now();
+
+    // TODO(konstin): The assumptions between this script (one repo) and ruff (pass in a bunch of
+    // files) mismatch.
+    let black_options = BlackOptions::from_file(&files[0])?;
+    debug!(
+        parent: None,
+        "Options for {}: {black_options:?}",
+        files[0].display()
+    );
+
+    // TODO(konstin): black excludes
+
+    // Find files to check (or in this case, format twice). Adapted from ruff_cli
+    // First argument is ignored
+    let (paths, resolver, pyproject_config) = ruff_check_paths(files)?;
+
+    let results = {
+        let pb_span =
+            info_span!("format_dev_project progress bar", first_file = %files[0].display());
+        pb_span.pb_set_style(&ProgressStyle::default_bar());
+        pb_span.pb_set_length(paths.len() as u64);
+        let _pb_span_enter = pb_span.enter();
+        #[cfg(not(feature = "singlethreaded"))]
+        let iter = { paths.into_par_iter() };
+        #[cfg(feature = "singlethreaded")]
+        let iter = { paths.into_iter() };
+        iter.map(|dir_entry| {
+            let result = format_dir_entry(
+                dir_entry,
+                stability_check,
+                write,
+                &black_options,
+                &resolver,
+                &pyproject_config,
+            );
+            pb_span.pb_inc(1);
+            result
+        })
+        .collect::<anyhow::Result<Vec<_>>>()?
+    };
+
+    let mut statistics = Statistics::default();
+    let mut formatted_counter = 0;
+    let mut syntax_error_in_input = 0;
+    let mut diagnostics = Vec::new();
+    for (result, file) in results {
+        formatted_counter += 1;
+        match result {
+            Ok(statistics_file) => statistics += statistics_file,
+            Err(error) => {
+                match error {
+                    CheckFileError::SyntaxErrorInInput(error) => {
+                        // This is not our error
+                        debug!(
+                            parent: None,
+                            "Syntax error in {}: {}",
+                            file.display(),
+                            error
+                        );
+                        syntax_error_in_input += 1;
+                    }
+                    _ => diagnostics.push(Diagnostic { file, error }),
+                }
+            }
+        }
+    }
+
+    let duration = start.elapsed();
+
+    let name = files[0]
+        .file_name()
+        .unwrap_or(files[0].as_os_str())
+        .to_string_lossy()
+        .to_string();
+    Ok(CheckRepoResult {
+        name,
+        duration,
+        file_count: formatted_counter,
+        diagnostics,
+        statistics,
+        syntax_error_in_input,
+    })
+}
+
+/// Error handling in between walkdir and `format_dev_file`
+fn format_dir_entry(
+    dir_entry: Result<DirEntry, ignore::Error>,
+    stability_check: bool,
+    write: bool,
+    options: &BlackOptions,
+    resolver: &Resolver,
+    pyproject_config: &PyprojectConfig,
+) -> anyhow::Result<(Result<Statistics, CheckFileError>, PathBuf), Error> {
+    let dir_entry = match dir_entry.context("Iterating the files in the repository failed") {
+        Ok(dir_entry) => dir_entry,
+        Err(err) => return Err(err),
+    };
+    let file = dir_entry.path().to_path_buf();
+    // For some reason it does not filter in the beginning
+    if dir_entry.file_name() == "pyproject.toml" {
+        return Ok((Ok(Statistics::default()), file));
+    }
+
+    let path = dir_entry.path().to_path_buf();
+    let mut options = options.to_py_format_options(&path);
+
+    let settings = resolver.resolve(&path, pyproject_config);
+    // That's a bad way of doing this but it's not worth doing something better for format_dev
+    // TODO(micha) use formatter settings instead
+    if settings.formatter.line_width != LineWidth::default() {
+        options = options.with_line_width(settings.formatter.line_width);
+    }
+
+    // Handle panics (mostly in `debug_assert!`)
+    let result = match catch_unwind(|| format_dev_file(&path, stability_check, write, options)) {
+        Ok(result) => result,
+        Err(panic) => {
+            if let Some(message) = panic.downcast_ref::<String>() {
+                Err(CheckFileError::Panic {
+                    message: message.clone(),
+                })
+            } else if let Some(&message) = panic.downcast_ref::<&str>() {
+                Err(CheckFileError::Panic {
+                    message: message.to_string(),
+                })
+            } else {
+                Err(CheckFileError::Panic {
+                    // This should not happen, but it can
+                    message: "(Panic didn't set a string message)".to_string(),
+                })
+            }
+        }
+    };
+    Ok((result, path))
+}
+
+/// A compact diff that only shows a header and changes, but nothing unchanged. This makes viewing
+/// multiple errors easier.
+fn diff_show_only_changes(
+    writer: &mut Formatter,
+    formatted: &str,
+    reformatted: &str,
+) -> fmt::Result {
+    for changes in TextDiff::from_lines(formatted, reformatted)
+        .unified_diff()
+        .iter_hunks()
+    {
+        for (idx, change) in changes
+            .iter_changes()
+            .filter(|change| change.tag() != ChangeTag::Equal)
+            .enumerate()
+        {
+            if idx == 0 {
+                writeln!(writer, "{}", changes.header())?;
+            }
+            write!(writer, "{}", change.tag())?;
+            writer.write_str(change.value())?;
+        }
+    }
+    Ok(())
+}
+
+struct CheckRepoResult {
+    name: String,
+    duration: Duration,
+    file_count: usize,
+    diagnostics: Vec<Diagnostic>,
+    statistics: Statistics,
+    syntax_error_in_input: u32,
+}
+
+impl CheckRepoResult {
+    fn display(&self, format: Format) -> DisplayCheckRepoResult {
+        DisplayCheckRepoResult {
+            result: self,
+            format,
+        }
+    }
+
+    /// Count the actual errors excluding invalid input files and io errors
+    fn error_count(&self) -> usize {
+        self.diagnostics
+            .iter()
+            .filter(|diagnostics| !diagnostics.error.is_success())
+            .count()
+    }
+}
+
+struct DisplayCheckRepoResult<'a> {
+    result: &'a CheckRepoResult,
+    format: Format,
+}
+
+impl Display for DisplayCheckRepoResult<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        for diagnostic in &self.result.diagnostics {
+            write!(f, "{}", diagnostic.display(self.format))?;
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+struct Diagnostic {
+    file: PathBuf,
+    error: CheckFileError,
+}
+
+impl Diagnostic {
+    fn display(&self, format: Format) -> DisplayDiagnostic {
+        DisplayDiagnostic {
+            diagnostic: self,
+            format,
+        }
+    }
+}
+
+struct DisplayDiagnostic<'a> {
+    format: Format,
+    diagnostic: &'a Diagnostic,
+}
+
+impl Display for DisplayDiagnostic<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let Diagnostic { file, error } = &self.diagnostic;
+
+        match error {
+            CheckFileError::Unstable {
+                formatted,
+                reformatted,
+            } => {
+                writeln!(f, "Unstable formatting {}", file.display())?;
+                match self.format {
+                    Format::Minimal => {}
+                    Format::Default => {
+                        diff_show_only_changes(f, formatted, reformatted)?;
+                    }
+                    Format::Full => {
+                        let diff = TextDiff::from_lines(formatted.as_str(), reformatted.as_str())
+                            .unified_diff()
+                            .header("Formatted once", "Formatted twice")
+                            .to_string();
+                        writeln!(
+                            f,
+                            r#"Reformatting the formatted code a second time resulted in formatting changes.
+---
+{diff}---
+
+Formatted once:
+---
+{formatted}---
+
+Formatted twice:
+---
+{reformatted}---\n"#,
+                        )?;
+                    }
+                }
+            }
+            CheckFileError::Panic { message } => {
+                writeln!(f, "Panic {}: {}", file.display(), message)?;
+            }
+            CheckFileError::SyntaxErrorInInput(error) => {
+                writeln!(f, "Syntax error in {}: {}", file.display(), error)?;
+            }
+            CheckFileError::SyntaxErrorInOutput { formatted, error } => {
+                writeln!(
+                    f,
+                    "Formatter generated invalid syntax {}: {}",
+                    file.display(),
+                    error
+                )?;
+                if self.format == Format::Full {
+                    writeln!(f, "---\n{formatted}\n---\n")?;
+                }
+            }
+            CheckFileError::FormatError(error) => {
+                writeln!(f, "Formatter error for {}: {}", file.display(), error)?;
+            }
+            CheckFileError::PrintError(error) => {
+                writeln!(f, "Printer error for {}: {}", file.display(), error)?;
+            }
+            CheckFileError::IoError(error) => {
+                writeln!(f, "Error reading {}: {}", file.display(), error)?;
+            }
+            #[cfg(not(debug_assertions))]
+            CheckFileError::Slow(duration) => {
+                writeln!(
+                    f,
+                    "Slow formatting {}: Formatting the file took {}ms",
+                    file.display(),
+                    duration.as_millis()
+                )?;
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+enum CheckFileError {
+    /// First and second pass of the formatter are different
+    Unstable {
+        formatted: String,
+        reformatted: String,
+    },
+    /// The input file was already invalid (not a bug)
+    SyntaxErrorInInput(FormatModuleError),
+    /// The formatter introduced a syntax error
+    SyntaxErrorInOutput {
+        formatted: String,
+        error: FormatModuleError,
+    },
+    /// The formatter failed (bug)
+    FormatError(FormatError),
+    /// The printer failed (bug)
+    PrintError(PrintError),
+    /// Failed to read the file, this sometimes happens e.g. with strange filenames (not a bug)
+    IoError(io::Error),
+    /// From `catch_unwind`
+    Panic { message: String },
+
+    /// Formatting a file took too long
+    #[cfg(not(debug_assertions))]
+    Slow(Duration),
+}
+
+impl CheckFileError {
+    /// Returns `false` if this is a formatter bug or `true` is if it is something outside of ruff
+    fn is_success(&self) -> bool {
+        match self {
+            CheckFileError::SyntaxErrorInInput(_) | CheckFileError::IoError(_) => true,
+            CheckFileError::Unstable { .. }
+            | CheckFileError::SyntaxErrorInOutput { .. }
+            | CheckFileError::FormatError(_)
+            | CheckFileError::PrintError(_)
+            | CheckFileError::Panic { .. } => false,
+            #[cfg(not(debug_assertions))]
+            CheckFileError::Slow(_) => false,
+        }
+    }
+}
+
+impl From<io::Error> for CheckFileError {
+    fn from(value: io::Error) -> Self {
+        Self::IoError(value)
+    }
+}
+
+#[tracing::instrument(skip_all, fields(input_path = % input_path.display()))]
+fn format_dev_file(
+    input_path: &Path,
+    stability_check: bool,
+    write: bool,
+    options: PyFormatOptions,
+) -> Result<Statistics, CheckFileError> {
+    let content = fs::read_to_string(input_path)?;
+    #[cfg(not(debug_assertions))]
+    let start = Instant::now();
+    let printed = match format_module_source(&content, options.clone()) {
+        Ok(printed) => printed,
+        Err(err @ (FormatModuleError::LexError(_) | FormatModuleError::ParseError(_))) => {
+            return Err(CheckFileError::SyntaxErrorInInput(err));
+        }
+        Err(FormatModuleError::FormatError(err)) => {
+            return Err(CheckFileError::FormatError(err));
+        }
+        Err(FormatModuleError::PrintError(err)) => {
+            return Err(CheckFileError::PrintError(err));
+        }
+    };
+    let formatted = printed.as_code();
+    #[cfg(not(debug_assertions))]
+    let format_duration = Instant::now() - start;
+
+    if write && content != formatted {
+        // Simple atomic write.
+        // The file is in a directory so it must have a parent. Surprisingly `DirEntry` doesn't
+        // give us access without unwrap
+        let mut file = NamedTempFile::new_in(input_path.parent().unwrap())?;
+        file.write_all(formatted.as_bytes())?;
+        // "If a file exists at the target path, persist will atomically replace it."
+        file.persist(input_path).map_err(|error| error.error)?;
+    }
+
+    if stability_check {
+        let reformatted = match format_module_source(formatted, options) {
+            Ok(reformatted) => reformatted,
+            Err(err @ (FormatModuleError::LexError(_) | FormatModuleError::ParseError(_))) => {
+                return Err(CheckFileError::SyntaxErrorInOutput {
+                    formatted: formatted.to_string(),
+                    error: err,
+                });
+            }
+            Err(FormatModuleError::FormatError(err)) => {
+                return Err(CheckFileError::FormatError(err));
+            }
+            Err(FormatModuleError::PrintError(err)) => {
+                return Err(CheckFileError::PrintError(err));
+            }
+        };
+
+        if reformatted.as_code() != formatted {
+            return Err(CheckFileError::Unstable {
+                formatted: formatted.to_string(),
+                reformatted: reformatted.into_code(),
+            });
+        }
+    }
+
+    #[cfg(not(debug_assertions))]
+    if format_duration > Duration::from_millis(50) {
+        return Err(CheckFileError::Slow(format_duration));
+    }
+
+    Ok(Statistics::from_versions(&content, formatted))
+}
+
+#[derive(Deserialize, Default)]
+struct PyprojectToml {
+    tool: Option<PyprojectTomlTool>,
+}
+
+#[derive(Deserialize, Default)]
+struct PyprojectTomlTool {
+    black: Option<BlackOptions>,
+}
+
+#[derive(Deserialize, Debug)]
+#[serde(default)]
+struct BlackOptions {
+    // Black actually allows both snake case and kebab case
+    #[serde(alias = "line-length")]
+    line_length: NonZeroU16,
+    #[serde(alias = "skip-magic-trailing-comma")]
+    skip_magic_trailing_comma: bool,
+    #[allow(unused)]
+    #[serde(alias = "force-exclude")]
+    force_exclude: Option<String>,
+}
+
+impl Default for BlackOptions {
+    fn default() -> Self {
+        Self {
+            line_length: NonZeroU16::new(88).unwrap(),
+            skip_magic_trailing_comma: false,
+            force_exclude: None,
+        }
+    }
+}
+
+impl BlackOptions {
+    /// TODO(konstin): For the real version, fix printing of error chains and remove the path
+    /// argument
+    fn from_toml(toml: &str, path: &Path) -> anyhow::Result<Self> {
+        let pyproject_toml: PyprojectToml = toml::from_str(toml).map_err(|e| {
+            format_err!(
+                "Not a valid pyproject.toml toml file at {}: {e}",
+                path.display()
+            )
+        })?;
+        let black_options = pyproject_toml
+            .tool
+            .unwrap_or_default()
+            .black
+            .unwrap_or_default();
+        debug!(
+            "Found {}, setting black options: {:?}",
+            path.display(),
+            &black_options
+        );
+        Ok(black_options)
+    }
+
+    fn from_file(repo: &Path) -> anyhow::Result<Self> {
+        let path = repo.join("pyproject.toml");
+        if !path.is_file() {
+            debug!(
+                "No pyproject.toml at {}, using black option defaults",
+                path.display()
+            );
+            return Ok(Self::default());
+        }
+        Self::from_toml(&fs::read_to_string(&path)?, repo)
+    }
+
+    fn to_py_format_options(&self, file: &Path) -> PyFormatOptions {
+        PyFormatOptions::from_extension(file)
+            .with_line_width(LineWidth::from(self.line_length))
+            .with_magic_trailing_comma(if self.skip_magic_trailing_comma {
+                MagicTrailingComma::Ignore
+            } else {
+                MagicTrailingComma::Respect
+            })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use indoc::indoc;
+
+    use ruff_formatter::{FormatOptions, LineWidth};
+    use ruff_python_formatter::MagicTrailingComma;
+
+    use crate::format_dev::BlackOptions;
+
+    #[test]
+    fn test_transformers() {
+        let toml = indoc! {"
+            [tool.black]
+            line-length = 119
+            target-version = ['py37']
+        "};
+        let options = BlackOptions::from_toml(toml, Path::new("pyproject.toml"))
+            .unwrap()
+            .to_py_format_options(Path::new("code_inline.py"));
+        assert_eq!(options.line_width(), LineWidth::try_from(119).unwrap());
+        assert!(matches!(
+            options.magic_trailing_comma(),
+            MagicTrailingComma::Respect
+        ));
+    }
+
+    #[test]
+    fn test_typeshed() {
+        let toml = indoc! {r#"
+            [tool.black]
+            line_length = 130
+            target_version = ["py310"]
+            skip_magic_trailing_comma = true
+            force-exclude = ".*_pb2.pyi"
+        "#};
+        let options = BlackOptions::from_toml(toml, Path::new("pyproject.toml"))
+            .unwrap()
+            .to_py_format_options(Path::new("code_inline.py"));
+        assert_eq!(options.line_width(), LineWidth::try_from(130).unwrap());
+        assert!(matches!(
+            options.magic_trailing_comma(),
+            MagicTrailingComma::Ignore
+        ));
+    }
+}

crates/ruff_dev/src/generate_all.rs

@@ -0,0 +1,41 @@
+//! Run all code and documentation generation steps.
+
+use anyhow::Result;
+
+use crate::{generate_cli_help, generate_docs, generate_json_schema};
+
+pub(crate) const REGENERATE_ALL_COMMAND: &str = "cargo dev generate-all";
+
+#[derive(clap::Args)]
+pub(crate) struct Args {
+    #[arg(long, default_value_t, value_enum)]
+    mode: Mode,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, clap::ValueEnum, Default)]
+pub(crate) enum Mode {
+    /// Update the content in the `configuration.md`.
+    #[default]
+    Write,
+
+    /// Don't write to the file, check if the file is up-to-date and error if not.
+    Check,
+
+    /// Write the generated help to stdout.
+    DryRun,
+}
+
+impl Mode {
+    pub(crate) const fn is_dry_run(self) -> bool {
+        matches!(self, Mode::DryRun)
+    }
+}
+
+pub(crate) fn main(args: &Args) -> Result<()> {
+    generate_json_schema::main(&generate_json_schema::Args { mode: args.mode })?;
+    generate_cli_help::main(&generate_cli_help::Args { mode: args.mode })?;
+    generate_docs::main(&generate_docs::Args {
+        dry_run: args.mode.is_dry_run(),
+    })?;
+    Ok(())
+}

crates/ruff_dev/src/generate_cli_help.rs

@@ -0,0 +1,133 @@
+//! Generate CLI help.
+#![allow(clippy::print_stdout)]
+
+use std::path::PathBuf;
+use std::{fs, str};
+
+use anyhow::{bail, Context, Result};
+use clap::CommandFactory;
+use pretty_assertions::StrComparison;
+
+use ruff_cli::args;
+
+use crate::generate_all::{Mode, REGENERATE_ALL_COMMAND};
+use crate::ROOT_DIR;
+
+const COMMAND_HELP_BEGIN_PRAGMA: &str = "<!-- Begin auto-generated command help. -->\n";
+const COMMAND_HELP_END_PRAGMA: &str = "<!-- End auto-generated command help. -->";
+
+const SUBCOMMAND_HELP_BEGIN_PRAGMA: &str = "<!-- Begin auto-generated subcommand help. -->\n";
+const SUBCOMMAND_HELP_END_PRAGMA: &str = "<!-- End auto-generated subcommand help. -->";
+
+#[derive(clap::Args)]
+pub(crate) struct Args {
+    #[arg(long, default_value_t, value_enum)]
+    pub(crate) mode: Mode,
+}
+
+fn trim_lines(s: &str) -> String {
+    s.lines().map(str::trim_end).collect::<Vec<_>>().join("\n")
+}
+
+/// Takes the existing file contents, inserts the section, returns the transformed content
+fn replace_docs_section(
+    existing: &str,
+    section: &str,
+    begin_pragma: &str,
+    end_pragma: &str,
+) -> Result<String> {
+    // Extract the prefix.
+    let index = existing
+        .find(begin_pragma)
+        .with_context(|| "Unable to find begin pragma")?;
+    let prefix = &existing[..index + begin_pragma.len()];
+
+    // Extract the suffix.
+    let index = existing
+        .find(end_pragma)
+        .with_context(|| "Unable to find end pragma")?;
+    let suffix = &existing[index..];
+
+    Ok(format!("{prefix}\n{section}{suffix}"))
+}
+
+pub(super) fn main(args: &Args) -> Result<()> {
+    // Generate `ruff help`.
+    let command_help = trim_lines(&help_text());
+
+    // Generate `ruff help check`.
+    let subcommand_help = trim_lines(&check_help_text());
+
+    if args.mode.is_dry_run() {
+        print!("{command_help}");
+        print!("{subcommand_help}");
+        return Ok(());
+    }
+
+    // Read the existing file.
+    let filename = "docs/configuration.md";
+    let file = PathBuf::from(ROOT_DIR).join(filename);
+    let existing = fs::read_to_string(&file)?;
+
+    let new = replace_docs_section(
+        &existing,
+        &format!("```text\n{command_help}\n```\n\n"),
+        COMMAND_HELP_BEGIN_PRAGMA,
+        COMMAND_HELP_END_PRAGMA,
+    )?;
+    let new = replace_docs_section(
+        &new,
+        &format!("```text\n{subcommand_help}\n```\n\n"),
+        SUBCOMMAND_HELP_BEGIN_PRAGMA,
+        SUBCOMMAND_HELP_END_PRAGMA,
+    )?;
+
+    match args.mode {
+        Mode::Check => {
+            if existing == new {
+                println!("up-to-date: {filename}");
+            } else {
+                let comparison = StrComparison::new(&existing, &new);
+                bail!("{filename} changed, please run `{REGENERATE_ALL_COMMAND}`:\n{comparison}");
+            }
+        }
+        _ => {
+            fs::write(file, &new)?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Returns the output of `ruff help`.
+fn help_text() -> String {
+    args::Args::command().render_help().to_string()
+}
+
+/// Returns the output of `ruff help check`.
+fn check_help_text() -> String {
+    let mut cmd = args::Args::command();
+
+    // The build call is necessary for the help output to contain `Usage: ruff
+    // check` instead of `Usage: check` see https://github.com/clap-rs/clap/issues/4685
+    cmd.build();
+
+    cmd.find_subcommand_mut("check")
+        .expect("`check` subcommand not found")
+        .render_help()
+        .to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::Result;
+
+    use crate::generate_all::Mode;
+
+    use super::{main, Args};
+
+    #[test]
+    fn test_generate_json_schema() -> Result<()> {
+        main(&Args { mode: Mode::Check })
+    }
+}