Match pylint logic

* Infer target-version from project metadata

* Fix requires-python with ">=3.8.16"

* Load requires-python at runtime

* Use upstream VersionSpecifiers

* Add debug information when parsing ruff.toml

* Display debug only if target_version is not set

* Bump pep440-rs to add impl Error for Pep440Error

.cargo/config.toml

@@ -0,0 +1,29 @@
+[alias]
+dev = "run --package ruff_dev --bin ruff_dev"
+benchmark = "bench -p ruff_benchmark --"
+
+[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",
+]

.editorconfig

@@ -0,0 +1,14 @@
+# Check http://editorconfig.org for more information
+# This is the main config file for this project:
+root = true
+
+[*]
+charset = utf-8
+trim_trailing_whitespace = true
+end_of_line = lf
+indent_style = space
+insert_final_newline = true
+indent_size = 2
+
+[*.{rs,py}]
+indent_size = 4

.gitattributes

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

.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/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "12:00"
+      timezone: "America/New_York"
+    commit-message:
+      prefix: "ci(deps)"

.github/release.yml

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

.github/workflows/benchmark.yaml

@@ -0,0 +1,133 @@
+name: Benchmark
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  run-benchmark:
+    if: github.event_name == 'pull_request'
+    name: "Run | ${{ matrix.os }}"
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: "PR - Checkout Branch"
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+
+      - name: "PR - Install Rust toolchain"
+        run: rustup show
+
+      - uses: Swatinem/rust-cache@v1
+
+      - name: "PR - Build benchmarks"
+        uses: actions-rs/cargo@v1
+        with:
+          command: bench
+          args: -p ruff_benchmark --no-run
+
+      - name: "PR - Run benchmarks"
+        run: cargo benchmark --save-baseline=pr
+
+      - name: "Main - Checkout Branch"
+        uses: actions/checkout@v3
+        with:
+          clean: false
+          ref: main
+
+      - name: "Main - Install Rust toolchain"
+        run: rustup show
+
+      - name: "Main - Build benchmarks"
+        uses: actions-rs/cargo@v1
+        with:
+          command: bench
+          args: -p ruff_benchmark --no-run
+
+      - name: "Main - Run benchmarks"
+        run: cargo benchmark --save-baseline=main
+
+      - name: "Upload benchmark results"
+        uses: actions/upload-artifact@v3
+        with:
+          name: benchmark-results-${{ matrix.os }}
+          path: ./target/criterion
+
+      # Cleanup
+      - name: Remove Criterion Artifact
+        uses: JesseTG/rm@v1.0.3
+        with:
+          path: ./target/criterion
+
+  benchmark-compare:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    name: Compare
+    needs:
+      - run-benchmark
+
+    steps:
+    - name: "Install Rust toolchain"
+      run: rustup show
+
+    - name: "Install critcmp"
+      # Use debug build: Building takes much longer than the "slowness" of using the debug build.
+      run: cargo install --debug critcmp
+
+    - name: "Linux | Download PR benchmark results"
+      uses: actions/download-artifact@v3
+      with:
+        name: benchmark-results-ubuntu-latest
+        path: ./target/criterion
+
+    - name: "Linux | Compare benchmark results"
+      shell: bash
+      run: |
+        echo "### Benchmark" >> summary.md
+        echo "#### Linux" >> summary.md
+        echo "\`\`\`" >> summary.md
+        critcmp main pr >> summary.md
+        echo "\`\`\`" >> summary.md
+        echo "" >> summary.md
+
+    - name: "Linux | Cleanup benchmark results"
+      run: rm -rf ./target/criterion
+
+    - name: "Windows | Download PR benchmark results"
+      uses: actions/download-artifact@v3
+      with:
+        name: benchmark-results-windows-latest
+        path: ./target/criterion
+
+    - name: "Windows | Compare benchmark results"
+      shell: bash
+      run: |
+        echo "#### Windows" >> summary.md
+        echo "\`\`\`" >> summary.md
+        critcmp main pr >> summary.md
+        echo "\`\`\`" >> summary.md
+        echo "" >> summary.md
+
+        echo ${{ github.event.pull_request.number }} > pr-number
+
+        cat summary.md > $GITHUB_STEP_SUMMARY
+
+    - uses: actions/upload-artifact@v3
+      name: Upload PR Number
+      with:
+        name: pr-number
+        path: pr-number
+
+    - uses: actions/upload-artifact@v3
+      name: Upload Summary
+      with:
+        name: summary
+        path: summary.md

.github/workflows/ci.yaml

@@ -4,119 +4,175 @@ 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
 
 jobs:
-  cargo_build:
-    name: "cargo build"
-    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 build --release
-
-  cargo_fmt:
+  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
+      - 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
+      - name: "Install Rust toolchain"
+        run: |
+          rustup component add clippy
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo clippy --workspace --all-targets --all-features -- -D warnings
 
-  cargo_test:
-    name: "cargo test"
+  cargo-clippy-wasm:
+    name: "cargo clippy (wasm)"
     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
+      - name: "Install Rust toolchain"
+        run: |
+          rustup component add clippy
+          rustup target add wasm32-unknown-unknown
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo clippy -p ruff_wasm --target wasm32-unknown-unknown --all-features -- -D warnings
 
-  maturin_build:
-    name: "maturin build"
+  cargo-test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    name: "cargo test | ${{ matrix.os }}"
+    steps:
+      - uses: actions/checkout@v3
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo install cargo-insta
+      - run: pip install black[d]==23.1.0
+      - name: "Run tests (Ubuntu)"
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        run: |
+          cargo insta test --all --all-features --delete-unreferenced-snapshots
+          git diff --exit-code
+      - name: "Run tests (Windows)"
+        if: ${{ matrix.os == 'windows-latest' }}
+        shell: bash
+        run: |
+          cargo insta test --all --all-features
+          git diff --exit-code
+      - run: cargo test --package ruff_cli --test black_compatibility_test -- --ignored
+      # 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-test-wasm:
+    runs-on: ubuntu-latest
+    name: "cargo test (wasm)"
+    steps:
+      - uses: actions/checkout@v3
+      - 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
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+      - run: ./scripts/add_rule.py --name DoTheThing --code PLC999 --linter pylint
+      - run: cargo check
+      - run: |
+          ./scripts/add_plugin.py test --url https://pypi.org/project/-test/0.1.0/ --prefix TST
+          ./scripts/add_rule.py --name FirstRule --code TST001 --linter test
+      - run: cargo check
+
+  typos:
+    name: "spell check"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: crate-ci/typos@master
         with:
-          toolchain: stable
+          files: .
+
+  ecosystem:
+    name: "ecosystem"
+    runs-on: ubuntu-latest
+    needs: cargo-test
+    # 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'
+    steps:
+      - uses: actions/checkout@v3
       - 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: "3.11"
+
+      - 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

.github/workflows/docs.yaml

@@ -0,0 +1,33 @@
+name: mkdocs
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  mkdocs:
+    runs-on: ubuntu-latest
+    env:
+      CF_API_TOKEN_EXISTS: ${{ secrets.CF_API_TOKEN != '' }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - uses: Swatinem/rust-cache@v2
+      - name: "Install dependencies"
+        run: |
+          pip install -r docs/requirements.txt
+      - name: "Copy README File"
+        run: |
+          python scripts/transform_readme.py --target mkdocs
+          python scripts/generate_mkdocs.py
+          mkdocs build --strict
+      - name: "Deploy to Cloudflare Pages"
+        if: ${{ env.CF_API_TOKEN_EXISTS == 'true' }}
+        uses: cloudflare/wrangler-action@2.0.0
+        with:
+          apiToken: ${{ secrets.CF_API_TOKEN }}
+          accountId: ${{ secrets.CF_ACCOUNT_ID }}
+          command: pages publish site --project-name=ruff-docs --branch ${GITHUB_HEAD_REF} --commit-hash ${GITHUB_SHA}

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

@@ -1,19 +1,19 @@
-name: Release
+name: "[flake8-to-ruff] Release"
 
-on:
-  pull_request:
-    branches: [main]
-  create:
-    tags:
-      - v*
+on: workflow_dispatch
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
 env:
-  PACKAGE_NAME: ruff
+  PACKAGE_NAME: flake8-to-ruff
+  CRATE_NAME: flake8_to_ruff
   PYTHON_VERSION: "3.7" # to build abi3 wheels
+  CARGO_INCREMENTAL: 0
+  CARGO_NET_RETRY: 10
+  CARGO_TERM_COLOR: always
+  RUSTUP_MAX_RETRIES: 10
 
 jobs:
   macos-x86_64:
@@ -24,23 +24,18 @@ jobs:
         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: "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
-          maturin-version: "v0.13.0"
-      - name: Install built wheel - x86_64
+          args: --release --out dist --sdist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: "Install built wheel - x86_64"
         run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
@@ -52,22 +47,17 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
-      - name: Install Rust toolchain
-        uses: actions-rs/toolchain@v1
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - 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 --universal2 --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: "Install built wheel - universal2"
         run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*universal2.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+          pip install dist/${{ env.CRATE_NAME }}-*universal2.whl --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
@@ -83,24 +73,19 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: ${{ matrix.target }}
-      - name: Install Rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          default: true
-      - name: Build wheels
-        uses: messense/maturin-action@v1
+      - name: "Install Rust toolchain"
+        run: rustup show
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
-          args: --release --out dist
-          maturin-version: "v0.13.0"
-      - name: Install built wheel
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: "Install built wheel"
         shell: bash
         run: |
-          python -m pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+          python -m pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
@@ -116,19 +101,18 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
-      - name: Build wheels
-        uses: messense/maturin-action@v1
+      - 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
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
+      - name: "Install built wheel"
         if: matrix.target == 'x86_64'
         run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
@@ -143,14 +127,13 @@ jobs:
       - uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-      - name: Build wheels
-        uses: messense/maturin-action@v1
+      - name: "Build wheels"
+        uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
           manylinux: auto
-          args: --no-default-features --release --out dist
-          maturin-version: "v0.13.0"
-      - uses: uraimo/run-on-arch-action@v2.0.5
+          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:
@@ -163,8 +146,8 @@ 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
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
@@ -182,14 +165,13 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           architecture: x64
-      - name: Build wheels
-        uses: messense/maturin-action@v1
+      - 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
+          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:
@@ -198,8 +180,8 @@ 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
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
@@ -218,14 +200,13 @@ jobs:
       - uses: actions/setup-python@v4
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-      - name: Build wheels
-        uses: messense/maturin-action@v1
+      - 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
+          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 }}
@@ -235,43 +216,8 @@ 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
-        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'
-        run: |
-          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
+      - name: "Upload wheels"
+        uses: actions/upload-artifact@v3
         with:
           name: wheels
           path: dist
@@ -287,17 +233,15 @@ jobs:
       - linux-cross
       - musllinux
       - musllinux-cross
-      - pypy
-    if: "startsWith(github.ref, 'refs/tags/')"
     steps:
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
         with:
           name: wheels
       - uses: actions/setup-python@v4
-      - name: Publish to PyPi
+      - name: "Publish to PyPi"
         env:
           TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.PYPI_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:
+  push:
+    branches: [main]
+
+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@v3
+      - 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@2.0.0
+        with:
+          apiToken: ${{ secrets.CF_API_TOKEN }}
+          accountId: ${{ secrets.CF_ACCOUNT_ID }}
+          command: pages publish playground/dist --project-name=ruff --branch ${GITHUB_HEAD_REF} --commit-hash ${GITHUB_SHA}

.github/workflows/pr-comment.yaml

@@ -0,0 +1,83 @@
+name: PR Check Comment
+
+on:
+  workflow_run:
+    workflows: [CI, Benchmark]
+    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
+
+      - uses: dawidd6/action-download-artifact@v2
+        name: "Download Benchmark Result"
+        id: download-benchmark-result
+        if: steps.pr-number.outputs.pr-number
+        with:
+          name: summary
+          workflow: benchmark.yaml
+          pr: ${{ steps.pr-number.outputs.pr-number }}
+          path: pr/benchmark
+          if_no_artifact_found: ignore
+
+      - name: Generate Comment
+        id: generate-comment
+        if: steps.download-ecosystem-result.outputs.found_artifact == 'true' || steps.download-benchmark-result.outputs.found_artifact == 'true'
+        run: |
+          echo 'comment<<EOF' >> $GITHUB_OUTPUT
+          echo '## PR Check Results' >> $GITHUB_OUTPUT
+
+          if [[ -f pr/ecosystem/ecosystem-result ]]
+          then
+            echo "### Ecosystem" >> $GITHUB_OUTPUT
+            cat pr/ecosystem/ecosystem-result >> $GITHUB_OUTPUT
+          fi
+
+          if [[ -f pr/benchmark/summary.md ]]
+          then
+            cat pr/benchmark/summary.md >> $GITHUB_OUTPUT
+          fi
+
+          echo 'EOF' >> $GITHUB_OUTPUT
+
+      - name: Create or update comment
+        if: steps.generate-comment.outputs.comment
+        uses: thollander/actions-comment-pull-request@v2
+        with:
+          pr_number: ${{ steps.pr-number.outputs.pr-number }}
+          message: ${{ steps.generate-comment.outputs.comment }}
+          comment_tag: PR Check Results

.github/workflows/ruff.yaml

@@ -0,0 +1,374 @@
+name: "[ruff] Release"
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PACKAGE_NAME: ruff
+  PYTHON_VERSION: "3.7" # to build abi3 wheels
+  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@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - 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
+      - name: "Install built wheel - x86_64"
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - 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/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - name: "Prep README.md"
+        run: python scripts/transform_readme.py --target pypi
+      - name: "Build wheels - universal2"
+        uses: PyO3/maturin-action@v1
+        with:
+          args: --release --universal2 --out dist
+      - name: "Install built wheel - universal2"
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*universal2.whl --force-reinstall
+      - 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:
+        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/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          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:
+          target: ${{ matrix.platform.target }}
+          args: --release --out dist
+      - name: "Install built 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@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-unknown-linux-gnu
+          - i686-unknown-linux-gnu
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - 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
+      - name: "Install built wheel"
+        if: ${{ startsWith(matrix.target, 'x86_64') }}
+        run: |
+          pip install dist/${{ env.PACKAGE_NAME }}-*.whl --force-reinstall
+      - 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:
+        platform:
+          - target: aarch64-unknown-linux-gnu
+            arch: aarch64
+          - 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/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - 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: auto
+          args: --release --out dist
+      - uses: uraimo/run-on-arch-action@v2
+        if: matrix.platform.arch != 'ppc64'
+        name: Install built wheel
+        with:
+          arch: ${{ matrix.platform.arch }}
+          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
+      - 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
+    strategy:
+      matrix:
+        target:
+          - x86_64-unknown-linux-musl
+          - i686-unknown-linux-musl
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+      - 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
+      - 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
+      - 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
+    strategy:
+      matrix:
+        platform:
+          - target: aarch64-unknown-linux-musl
+            arch: aarch64
+          - target: armv7-unknown-linux-musleabihf
+            arch: armv7
+    steps:
+      - uses: actions/checkout@v3
+      - 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 wheels"
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.platform.target }}
+          manylinux: musllinux_1_2
+          args: --release --out dist
+      - 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
+      - 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
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    needs:
+      - macos-universal
+      - macos-x86_64
+      - windows
+      - linux
+      - linux-cross
+      - musllinux
+      - musllinux-cross
+    if: "startsWith(github.ref, 'refs/tags/')"
+    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.RUFF_TOKEN }}
+        run: |
+          pip install --upgrade twine
+          twine upload --skip-existing *
+      - name: "Update pre-commit mirror"
+        run: |
+          curl -X POST -H "Accept: application/vnd.github+json" -H "Authorization: Bearer ${{ secrets.RUFF_PRE_COMMIT_PAT }}" -H "X-GitHub-Api-Version: 2022-11-28" https://api.github.com/repos/charliermarsh/ruff-pre-commit/dispatches --data '{"event_type": "pypi_release"}'
+      - uses: actions/download-artifact@v3
+        with:
+          name: binaries
+          path: binaries
+      - name: Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: binaries/*

.gitignore

@@ -1,6 +1,8 @@
 # Local cache
 .ruff_cache
-resources/test/cpython
+crates/ruff/resources/test/cpython
+mkdocs.yml
+.overrides
 
 ###
 # Rust.gitignore
@@ -181,3 +183,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?

.pre-commit-config.yaml

@@ -1,5 +1,68 @@
+fail_fast: true
 repos:
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.40
+  - repo: https://github.com/abravalheri/validate-pyproject
+    rev: v0.12.1
     hooks:
-      - id: lint
+      - id: validate-pyproject
+
+  - repo: https://github.com/executablebooks/mdformat
+    rev: 0.7.16
+    hooks:
+      - id: mdformat
+        additional_dependencies:
+          - mdformat-black
+          - black==23.1.0 # Must be the latest version of Black
+
+  - repo: https://github.com/igorshubovych/markdownlint-cli
+    rev: v0.33.0
+    hooks:
+      - id: markdownlint-fix
+        args:
+          - --disable
+          - MD013 # line-length
+          - MD033 # no-inline-html
+          - --
+
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        entry: cargo fmt --
+        language: rust
+        types: [rust]
+      - id: clippy
+        name: clippy
+        entry: cargo clippy --workspace --all-targets --all-features -- -D warnings
+        language: rust
+        pass_filenames: false
+      - id: ruff
+        name: ruff
+        entry: cargo run -p ruff_cli -- check --no-cache --force-exclude --fix --exit-non-zero-on-fix
+        language: rust
+        types_or: [python, pyi]
+        require_serial: true
+        exclude: |
+          (?x)^(
+            crates/ruff/resources/.*|
+            crates/ruff_python_formatter/resources/.*
+          )$
+      - id: dev-generate-all
+        name: dev-generate-all
+        entry: cargo dev generate-all
+        language: rust
+        pass_filenames: false
+        exclude: target
+
+  # Black
+  - repo: https://github.com/psf/black
+    rev: 23.1.0
+    hooks:
+      - id: black
+        exclude: |
+          (?x)^(
+            crates/ruff/resources/.*|
+            crates/ruff_python_formatter/resources/.*
+          )$
+
+ci:
+  skip: [cargo-fmt, clippy, dev-generate-all]

BREAKING_CHANGES.md

@@ -0,0 +1,148 @@
+# Breaking Changes
+
+## 0.0.246
+
+### `multiple-statements-on-one-line-def` (`E704`) was removed ([#2773](https://github.com/charliermarsh/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/charliermarsh/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/charliermarsh/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/charliermarsh/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/charliermarsh/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/charliermarsh/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/charliermarsh/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/charliermarsh/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/charliermarsh/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/charliermarsh/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/charliermarsh/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 [README](https://github.com/charliermarsh/ruff#pyprojecttoml-discovery) for more.

CODE_OF_CONDUCT.md

@@ -0,0 +1,138 @@
+# 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
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+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
+
+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
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+charlie.r.marsh@gmail.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+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
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+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).
+
+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).
+
+[homepage]: https://www.contributor-covenant.org

CONTRIBUTING.md

@@ -0,0 +1,339 @@
+# Contributing to Ruff
+
+Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.
+
+- [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)
+  - [Example: Adding a new configuration option](#example-adding-a-new-configuration-option)
+- [MkDocs](#mkdocs)
+- [Release Process](#release-process)
+- [Benchmarks](#benchmarks)
+
+## 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/charliermarsh/ruff/issues) outlining your proposed
+change. You can also join us on [**Discord**](https://discord.gg/c9MhzV8aU5) to discuss your idea with
+the community.
+
+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/charliermarsh/ruff/issues/848)
+plugin, and looking to the originating [Python source](https://github.com/PyCQA/flake8-pyi)
+for guidance.
+
+### Prerequisites
+
+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:
+
+```shell
+cargo install cargo-insta
+```
+
+### Development
+
+After cloning the repository, run Ruff locally 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 fmt  # Auto-formatting...
+cargo clippy --fix --workspace --all-targets --all-features  # Linting...
+cargo test  # Testing...
+```
+
+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
+```
+
+If you have `pre-commit` [installed](https://pre-commit.com/#installation) then you can use it to
+assist with formatting and linting. The following command will run the `pre-commit` hooks:
+
+```shell
+pre-commit run --all-files
+```
+
+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`). 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`: library crate containing all lint rules and the core logic for running them.
+- `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`).
+- `crates/ruff_macros`: library crate containing macros used by Ruff.
+- `crates/ruff_python`: library crate implementing Python-specific functionality (e.g., lists of standard library modules by versionb).
+- `crates/flake8_to_ruff`: binary crate for generating Ruff configuration from Flake8 configuration.
+
+### Example: Adding a new lint rule
+
+At a high level, the steps involved in adding a new lint rule are as follows:
+
+1. Determine a name for the new rule as per our [rule naming convention](#rule-naming-convention).
+1. Create a file for your rule (e.g., `crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs`).
+1. In that file, define a violation struct. You can grep for `#[violation]` to see examples.
+1. Map the violation struct to a rule code in `crates/ruff/src/registry.rs` (e.g., `E402`).
+1. Define the logic for triggering the violation in `crates/ruff/src/checkers/ast.rs` (for AST-based
+   checks), `crates/ruff/src/checkers/tokens.rs` (for token-based checks), `crates/ruff/src/checkers/lines.rs`
+   (for text-based checks), or `crates/ruff/src/checkers/filesystem.rs` (for filesystem-based
+   checks).
+1. Add a test fixture.
+1. Update the generated files (documentation and generated code).
+
+To define the violation, start by creating a dedicated file for your rule under the appropriate
+rule linter (e.g., `crates/ruff/src/rules/flake8_bugbear/rules/abstract_base_class.rs`). That file should
+contain a struct defined via `#[violation]`, along with a function that creates the violation
+based on any required inputs. (Many of the existing examples live in `crates/ruff/src/violations.rs`,
+but we're looking to place new rules in their own files.)
+
+To trigger the violation, you'll likely want to augment the logic in `crates/ruff/src/checkers/ast.rs`,
+which defines the Python AST visitor, responsible for iterating over the abstract syntax tree and
+collecting diagnostics as it goes.
+
+If you need to inspect the AST, you can run `cargo dev print-ast` with a Python file. Grep
+for the `Check::new` invocations to understand how other, similar rules are implemented.
+
+To add a test fixture, create a file under `crates/ruff/resources/test/fixtures/[linter]`, named to match
+the code you defined earlier (e.g., `crates/ruff/resources/test/fixtures/pycodestyle/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 `cargo dev generate-all` to generate the code for your new fixture. Then run Ruff
+locally with (e.g.) `cargo run -p ruff_cli -- check crates/ruff/resources/test/fixtures/pycodestyle/E402.py --no-cache --select E402`.
+
+Once you're satisfied with the output, codify the behavior as a snapshot test by adding a new
+`test_case` macro in the relevant `crates/ruff/src/[linter]/mod.rs` file. 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.
+
+Finally, regenerate the documentation and generated code with `cargo dev generate-all`.
+
+#### Rule naming convention
+
+The rule name should make sense when read as "allow _rule-name_" or "allow _rule-name_ items".
+
+This implies that rule names:
+
+- should state the bad thing being checked for
+
+- should not contain instructions on what you what you should use instead
+  (these belong in the rule documentation and the `autofix_title` for rules that have autofix)
+
+When re-implementing rules from other linters, this convention is given more importance than
+preserving the original rule name.
+
+### Example: Adding a new configuration option
+
+Ruff's user-facing settings live in a few different places.
+
+First, the command-line options are defined via the `Cli` struct in `crates/ruff/src/cli.rs`.
+
+Second, the `pyproject.toml` options are defined in `crates/ruff/src/settings/options.rs` (via the
+`Options` struct), `crates/ruff/src/settings/configuration.rs` (via the `Configuration` struct), and
+`crates/ruff/src/settings/mod.rs` (via the `Settings` struct). 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.
+
+To add a new configuration option, you'll likely want to modify these latter few files (along with
+`cli.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.,
+`crates/ruff/src/flake8_unused_arguments/settings.rs`).
+
+You may also want to add the new configuration option to the `flake8-to-ruff` tool, which is
+responsible for converting `flake8` configuration files to Ruff's TOML format. This logic
+lives in `crates/ruff/src/flake8_to_ruff/converter.rs`.
+
+Finally, regenerate the documentation and generated code with `cargo dev generate-all`.
+
+## MkDocs
+
+To preview any changes to the documentation locally:
+
+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
+   mkdocs serve
+   ```
+
+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,
+even patch releases may contain [non-backwards-compatible changes](https://semver.org/#spec-item-4).
+
+## Benchmarks
+
+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/resources/test/cpython
+```
+
+To benchmark the release build:
+
+```shell
+cargo build --release && hyperfine --ignore-failure --warmup 10 \
+  "./target/release/ruff ./crates/ruff/resources/test/cpython/ --no-cache" \
+  "./target/release/ruff ./crates/ruff/resources/test/cpython/"
+
+Benchmark 1: ./target/release/ruff ./crates/ruff/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
+
+  Warning: Ignoring non-zero exit code.
+
+Benchmark 2: ./target/release/ruff ./crates/ruff/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
+
+  Warning: Ignoring non-zero exit code.
+
+Summary
+  './target/release/ruff ./crates/ruff/resources/test/cpython/' ran
+    6.12 ± 0.41 times faster than './target/release/ruff ./crates/ruff/resources/test/cpython/ --no-cache'
+```
+
+To benchmark against the ecosystem's existing tools:
+
+```shell
+hyperfine --ignore-failure --warmup 5 \
+  "./target/release/ruff ./crates/ruff/resources/test/cpython/ --no-cache" \
+  "pyflakes crates/ruff/resources/test/cpython" \
+  "autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython" \
+  "pycodestyle crates/ruff/resources/test/cpython" \
+  "flake8 crates/ruff/resources/test/cpython"
+
+Benchmark 1: ./target/release/ruff ./crates/ruff/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/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/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/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/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/resources/test/cpython'
+   53.64 ± 0.77 times faster than 'pyflakes crates/ruff/resources/test/cpython'
+  159.43 ± 2.48 times faster than 'pycodestyle crates/ruff/resources/test/cpython'
+```
+
+You can run `poetry install` from `./scripts` to create a working environment for the above. All
+reported benchmarks were computed using the versions specified by `./scripts/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/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/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
+```

Cargo.toml

@@ -1,44 +1,51 @@
-[package]
-name = "ruff"
-version = "0.0.40"
+[workspace]
+members = ["crates/*"]
+
+[workspace.package]
 edition = "2021"
+rust-version = "1.67"
+homepage = "https://beta.ruff.rs/docs/"
+documentation = "https://beta.ruff.rs/docs/"
+repository = "https://github.com/charliermarsh/ruff"
+authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
 
-[lib]
-name = "ruff"
-
-[dependencies]
-anyhow = { version = "1.0.60" }
-bincode = { version = "1.3.3" }
-cacache = { version = "10.0.1" }
-chrono = { version = "0.4.21" }
-clap = { version = "3.2.16", features = ["derive"] }
-clearscreen = { version = "1.0.10" }
+[workspace.dependencies]
+anyhow = { version = "1.0.69" }
+bitflags = { version = "1.3.2" }
+chrono = { version = "0.4.23", default-features = false, features = ["clock"] }
+clap = { version = "4.1.8", 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 = "0.3.0"
-itertools = "0.10.3"
+filetime = { version = "0.2.20" }
+glob = { version = "0.3.1" }
+globset = { version = "0.4.10" }
+ignore = { version = "0.4.20" }
+insta = { version = "1.28.0" }
+is-macro = { version = "0.2.2" }
+itertools = { version = "0.10.5" }
+libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "80e4c1399f95e5beb532fdd1e209ad2dbb470438" }
 log = { version = "0.4.17" }
-notify = { version = "4.0.17" }
-once_cell = { version = "1.13.1" }
-path-absolutize = { version = "3.0.13", features = ["once_cell_cache"] }
-rayon = { version = "1.5.3" }
-regex = { version = "1.6.0" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "7d21c6923a506e79cc041708d83cef925efd33f4" }
-serde = { version = "1.0.143", features = ["derive"] }
-serde_json = { version = "1.0.83" }
-toml = { version = "0.5.9" }
-update-informer = { version = "0.5.0", default_features = false, features = ["pypi"], optional = true }
-walkdir = { version = "2.3.2" }
-
-[dev-dependencies]
-insta = { version = "1.19.1", features = ["yaml"] }
-
-[features]
-default = ["update-informer"]
-update-informer = ["dep:update-informer"]
+once_cell = { version = "1.17.1" }
+path-absolutize = { version = "3.0.14" }
+proc-macro2 = { version = "1.0.51" }
+quote = { version = "1.0.23" }
+regex = { version = "1.7.1" }
+rustc-hash = { version = "1.1.0" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "c15f670f2c30cfae6b41a1874893590148c74bc4" }
+rustpython-parser = { features = [
+  "lalrpop",
+  "serde",
+], git = "https://github.com/RustPython/RustPython.git", rev = "c15f670f2c30cfae6b41a1874893590148c74bc4" }
+schemars = { version = "0.8.12" }
+serde = { version = "1.0.152", features = ["derive"] }
+serde_json = { version = "1.0.93" }
+shellexpand = { version = "3.0.0" }
+similar = { version = "2.2.1" }
+strum = { version = "0.24.1", features = ["strum_macros"] }
+strum_macros = { version = "0.24.3" }
+syn = { version = "1.0.109" }
+test-case = { version = "3.0.0" }
+textwrap = { version = "0.16.0" }
+toml = { version = "0.7.2" }
 
 [profile.release]
 panic = "abort"
@@ -51,3 +58,14 @@ 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.rustpython-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

README.md

@@ -1,380 +1,318 @@
-# ruff
+<!-- Begin section: Overview -->
 
+# Ruff
+
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)
 [![image](https://img.shields.io/pypi/v/ruff.svg)](https://pypi.python.org/pypi/ruff)
 [![image](https://img.shields.io/pypi/l/ruff.svg)](https://pypi.python.org/pypi/ruff)
 [![image](https://img.shields.io/pypi/pyversions/ruff.svg)](https://pypi.python.org/pypi/ruff)
 [![Actions status](https://github.com/charliermarsh/ruff/workflows/CI/badge.svg)](https://github.com/charliermarsh/ruff/actions)
 
+[**Discord**](https://discord.gg/c9MhzV8aU5) | [**Docs**](https://beta.ruff.rs/docs/) | [**Playground**](https://play.ruff.rs/)
+
 An extremely fast Python linter, written in Rust.
 
 <p align="center">
-  <img alt="Bar chart with benchmark results" src="https://user-images.githubusercontent.com/1309177/187504482-6d9df992-a81d-4e86-9f6a-d958741c8182.svg">
+  <picture align="center">
+    <source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/1309177/212613422-7faaf278-706b-4294-ad92-236ffcab3430.svg">
+    <source media="(prefers-color-scheme: light)" srcset="https://user-images.githubusercontent.com/1309177/212613257-5f4bca12-6d6b-4c79-9bac-51a4c6d08928.svg">
+    <img alt="Shows a bar chart with benchmark results." src="https://user-images.githubusercontent.com/1309177/212613257-5f4bca12-6d6b-4c79-9bac-51a4c6d08928.svg">
+  </picture>
 </p>
 
 <p align="center">
   <i>Linting the CPython codebase from scratch.</i>
 </p>
 
-- ⚡️ 10-100x faster than existing linters
-- 🐍 Installable via `pip`
-- 🤝 Python 3.10 compatibility
-- 🛠️ `pyproject.toml` support
-- 📦 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#caching)-inspired cache support
-- 🔧 [ESLint](https://eslint.org/docs/latest/user-guide/command-line-interface#caching)-inspired `--fix` support
-- 👀 [TypeScript](https://www.typescriptlang.org/docs/handbook/configuring-watch.html)-inspired `--watch` support
+- ⚡️  10-100x faster than existing linters
+- 🐍  Installable via `pip`
+- 🛠️  `pyproject.toml` support
+- 🤝  Python 3.11 compatibility
+- 📦  Built-in caching, to avoid re-analyzing unchanged files
+- 🔧  Autofix support, for automatic error correction (e.g., automatically remove unused imports)
+- 📏  Over [500 built-in rules](https://beta.ruff.rs/docs/rules/)
+- ⚖️  [Near-parity](https://beta.ruff.rs/docs/faq/#how-does-ruff-compare-to-flake8) with the built-in Flake8 rule set
+- 🔌  Native re-implementations of dozens of Flake8 plugins, like flake8-bugbear
+- ⌨️  First-party editor integrations for [VS Code](https://github.com/charliermarsh/ruff-vscode) and [more](https://github.com/charliermarsh/ruff-lsp)
+- 🌎  Monorepo-friendly, with [hierarchical and cascading configuration](https://beta.ruff.rs/docs/configuration/#pyprojecttoml-discovery)
 
-_ruff is a proof-of-concept and not yet intended for production use. It supports only a small subset
-of the Flake8 rules, and may crash on your codebase._
+Ruff aims to be orders of magnitude faster than alternative tools while integrating more
+functionality behind a single, common interface.
 
-Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).
+Ruff can be used to replace [Flake8](https://pypi.org/project/flake8/) (plus dozens of plugins),
+[isort](https://pypi.org/project/isort/), [pydocstyle](https://pypi.org/project/pydocstyle/),
+[yesqa](https://github.com/asottile/yesqa), [eradicate](https://pypi.org/project/eradicate/),
+[pyupgrade](https://pypi.org/project/pyupgrade/), and [autoflake](https://pypi.org/project/autoflake/),
+all while executing tens or hundreds of times faster than any individual tool.
 
-## Installation and usage
+Ruff is extremely actively developed and used in major open-source projects like:
+
+- [pandas](https://github.com/pandas-dev/pandas)
+- [FastAPI](https://github.com/tiangolo/fastapi)
+- [Transformers (Hugging Face)](https://github.com/huggingface/transformers)
+- [Apache Airflow](https://github.com/apache/airflow)
+- [SciPy](https://github.com/scipy/scipy)
+
+...and many more.
+
+Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster) or
+the most recent [project update](https://notes.crmarsh.com/ruff-the-first-200-releases).
+
+## Testimonials
+
+[**Sebastián Ramírez**](https://twitter.com/tiangolo/status/1591912354882764802), creator
+of [FastAPI](https://github.com/tiangolo/fastapi):
+
+> Ruff is so fast that sometimes I add an intentional bug in the code just to confirm it's actually
+> running and checking the code.
+
+[**Nick Schrock**](https://twitter.com/schrockn/status/1612615862904827904), founder of [Elementl](https://www.elementl.com/),
+co-creator of [GraphQL](https://graphql.org/):
+
+> Why is Ruff a gamechanger? Primarily because it is nearly 1000x faster. Literally. Not a typo. On
+> our largest module (dagster itself, 250k LOC) pylint takes about 2.5 minutes, parallelized across 4
+> cores on my M1. Running ruff against our _entire_ codebase takes .4 seconds.
+
+[**Bryan Van de Ven**](https://github.com/bokeh/bokeh/pull/12605), co-creator
+of [Bokeh](https://github.com/bokeh/bokeh/), original author
+of [Conda](https://docs.conda.io/en/latest/):
+
+> Ruff is ~150-200x faster than flake8 on my machine, scanning the whole repo takes ~0.2s instead of
+> ~20s. This is an enormous quality of life improvement for local dev. It's fast enough that I added
+> it as an actual commit hook, which is terrific.
+
+[**Timothy Crosley**](https://twitter.com/timothycrosley/status/1606420868514877440),
+creator of [isort](https://github.com/PyCQA/isort):
+
+> Just switched my first project to Ruff. Only one downside so far: it's so fast I couldn't believe it was working till I intentionally introduced some errors.
+
+[**Tim Abbott**](https://github.com/charliermarsh/ruff/issues/465#issuecomment-1317400028), lead
+developer of [Zulip](https://github.com/zulip/zulip):
+
+> This is just ridiculously fast... `ruff` is amazing.
+
+<!-- End section: Overview -->
+
+## Table of Contents
+
+For more, see the [documentation](https://beta.ruff.rs/docs/).
+
+1. [Getting Started](#getting-started)
+1. [Configuration](#configuration)
+1. [Rules](#rules)
+1. [Contributing](#contributing)
+1. [Support](#support)
+1. [Acknowledgements](#acknowledgements)
+1. [Who's Using Ruff?](#whos-using-ruff)
+1. [License](#license)
+
+## Getting Started
+
+For more, see the [documentation](https://beta.ruff.rs/docs/).
 
 ### Installation
 
-Available as [ruff](https://pypi.org/project/ruff/) on PyPI:
+Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
 
 ```shell
 pip install ruff
 ```
 
+You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
+and with [a variety of other package managers](https://beta.ruff.rs/docs/installation/).
+
 ### Usage
 
-To run ruff, try any of the following:
+To run Ruff, try any of the following:
 
 ```shell
-ruff path/to/code/to/check.py
-ruff path/to/code/
-ruff path/to/code/*.py
+ruff check .                        # Lint all files in the current directory (and any subdirectories)
+ruff check path/to/code/            # Lint all files in `/path/to/code` (and any subdirectories)
+ruff check path/to/code/*.py        # Lint all `.py` files in `/path/to/code`
+ruff check path/to/code/to/file.py  # Lint `file.py`
 ```
 
-You can run ruff in `--watch` mode to automatically re-run on-change:
-
-```shell
-ruff path/to/code/ --watch
-```
-
-ruff also works with [pre-commit](https://pre-commit.com):
+Ruff can also be used as a [pre-commit](https://pre-commit.com) hook:
 
 ```yaml
-repos:
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.40
-    hooks:
-      - id: lint
+- repo: https://github.com/charliermarsh/ruff-pre-commit
+  # Ruff version.
+  rev: 'v0.0.256'
+  hooks:
+    - id: ruff
 ```
 
-## Configuration
+Ruff can also be used as a [VS Code extension](https://github.com/charliermarsh/ruff-vscode) or
+alongside any other editor through the [Ruff LSP](https://github.com/charliermarsh/ruff-lsp).
 
-ruff is configurable both via `pyproject.toml` and the command line.
+### Configuration
 
-For example, you could configure ruff to only enforce a subset of rules with:
+Ruff can be configured through a `pyproject.toml`, `ruff.toml`, or `.ruff.toml` file (see:
+[_Configuration_](https://beta.ruff.rs/docs/configuration/), or [_Settings_](https://beta.ruff.rs/docs/settings/)
+for a complete list of all configuration options).
+
+If left unspecified, the default configuration is equivalent to:
 
 ```toml
 [tool.ruff]
-line-length = 88
-select = [
-    "F401",
-    "F403",
+# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
+select = ["E", "F"]
+ignore = []
+
+# Allow autofix for all enabled rules (when `--fix`) is provided.
+fixable = ["A", "B", "C", "D", "E", "F", "..."]
+unfixable = []
+
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
 ]
+
+# Same as Black.
+line-length = 88
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+# Assume Python 3.10.
+target-version = "py310"
+
+[tool.ruff.mccabe]
+# Unlike Flake8, default to a complexity level of 10.
+max-complexity = 10
 ```
 
-Alternatively, on the command-line:
+Some configuration options can be provided via the command-line, such as those related to
+rule enablement and disablement, file discovery, logging level, and more:
 
 ```shell
-ruff path/to/code/ --select F401 F403
+ruff check path/to/code/ --select F401 --select F403 --quiet
 ```
 
-See `ruff --help` for more:
-
-```shell
-ruff (v0.0.40)
-An extremely fast Python linter.
-
-USAGE:
-    ruff [OPTIONS] <FILES>...
-
-ARGS:
-    <FILES>...
-
-OPTIONS:
-    -e, --exit-zero
-            Exit with status code "0", even upon detecting errors
-        --exclude <EXCLUDE>...
-            List of paths, used to exclude files and/or directories from checks
-        --extend-exclude <EXTEND_EXCLUDE>...
-            Like --exclude, but adds additional files and directories on top of the excluded ones
-    -f, --fix
-            Attempt to automatically fix lint errors
-        --format <FORMAT>
-            Output serialization format for error messages [default: text] [possible values: text,
-            json]
-    -h, --help
-            Print help information
-        --ignore <IGNORE>...
-            List of error codes to ignore
-    -n, --no-cache
-            Disable cache reads
-    -q, --quiet
-            Disable all logging (but still exit with status code "1" upon detecting errors)
-        --select <SELECT>...
-            List of error codes to enable
-    -v, --verbose
-            Enable verbose logging
-    -V, --version
-            Print version information
-    -w, --watch
-            Run in watch mode by re-running whenever files change
-```
-
-Exclusions are based on globs, and can be either:
-
-- Single-path patterns, like `.mypy_cache` (to exclude any directory named `.mypy_cache` in the
-  tree), `foo.py` (to exclude any file named `foo.py`), or `foo_*.py` (to exclude any file matching
-  `foo_*.py` ).
-- Relative patterns, like `directory/foo.py` (to exclude that specific file) or `directory/*.py`
-  (to exclude any Python files in `directory`). Note that these paths are relative to the
-  project root (e.g., the directory containing your `pyproject.toml`).
-
-### Compatibility with Black
-
-ruff is intended to be compatible with [Black](https://github.com/psf/black), and should be
-compatible out-of-the-box as long as the `line-length` setting is consistent between the two.
-
-As a project, ruff is designed to be used alongside Black and, as such, will defer implementing
-lint rules that are obviated by Black (e.g., stylistic rules).
-
-### Parity with Flake8
-
-ruff's goal is to achieve feature-parity with Flake8 when used (1) without any plugins,
-(2) alongside Black, and (3) on Python 3 code. (Using Black obviates the need for many of Flake8's
-stylistic checks; limiting to Python 3 obviates the need for certain compatibility checks.)
-
-Under those conditions, Flake8 implements about 60 rules, give or take. At time of writing, ruff
-implements 42 rules. (Note that these 42 rules likely cover a disproportionate share of errors:
-unused imports, undefined variables, etc.)
-
-The unimplemented rules are tracked in #170, and include:
-
-- 14 rules related to string `.format` calls.
-- 4 logical rules.
-- 1 rule related to parsing.
-
-Beyond rule-set parity, ruff suffers from the following limitations vis-à-vis Flake8:
-
-1. Flake8 supports a wider range of `noqa` patterns, such as per-file ignores defined in `.flake8`.
-2. Flake8 has a plugin architecture and supports writing custom lint rules.
-3. ruff does not yet support parenthesized context managers.
+See `ruff help` for more on Ruff's top-level commands, or `ruff help check` for more on the
+linting command.
 
 ## Rules
 
-| Code | Name | Message |
-| ---- | ----- | ------- |
-| E402 | ModuleImportNotAtTopOfFile | Module level import not at top of file |
-| E501 | LineTooLong | Line too long (89 > 88 characters) |
-| E711 | NoneComparison | Comparison to `None` should be `cond is None` |
-| E712 | TrueFalseComparison | Comparison to `True` should be `cond is True` |
-| E713 | NotInTest | Test for membership should be `not in` |
-| E714 | NotIsTest | Test for object identity should be `is not` |
-| E721 | TypeComparison | do not compare types, use `isinstance()` |
-| E722 | DoNotUseBareExcept | Do not use bare `except` |
-| E731 | DoNotAssignLambda | Do not assign a lambda expression, use a def |
-| E741 | AmbiguousVariableName | ambiguous variable name '...' |
-| E742 | AmbiguousClassName | ambiguous class name '...' |
-| E743 | AmbiguousFunctionName | ambiguous function name '...' |
-| E902 | IOError | No such file or directory: `...` |
-| E999 | SyntaxError | SyntaxError: ... |
-| F401 | UnusedImport | `...` imported but unused |
-| F403 | ImportStarUsage | `from ... import *` used; unable to detect undefined names |
-| F404 | LateFutureImport | from __future__ imports must occur at the beginning of the file |
-| F406 | ImportStarNotPermitted | `from ... import *` only allowed at module level |
-| F407 | FutureFeatureNotDefined | future feature '...' is not defined |
-| F541 | FStringMissingPlaceholders | f-string without any placeholders |
-| F601 | MultiValueRepeatedKeyLiteral | Dictionary key literal repeated |
-| F602 | MultiValueRepeatedKeyVariable | Dictionary key `...` repeated |
-| F621 | TooManyExpressionsInStarredAssignment | too many expressions in star-unpacking assignment |
-| F622 | TwoStarredExpressions | two starred expressions in assignment |
-| F631 | AssertTuple | Assert test is a non-empty tuple, which is always `True` |
-| F632 | IsLiteral | use ==/!= to compare constant literals |
-| F633 | InvalidPrintSyntax | use of >> is invalid with print function |
-| F634 | IfTuple | If test is a tuple, which is always `True` |
-| F701 | BreakOutsideLoop | `break` outside loop |
-| F702 | ContinueOutsideLoop | `continue` not properly in loop |
-| F704 | YieldOutsideFunction | a `yield` or `yield from` statement outside of a function/method |
-| F706 | ReturnOutsideFunction | a `return` statement outside of a function/method |
-| F707 | DefaultExceptNotLast | an `except:` block as not the last exception handler |
-| F722 | ForwardAnnotationSyntaxError | syntax error in forward annotation '...' |
-| F821 | UndefinedName | Undefined name `...` |
-| F822 | UndefinedExport | Undefined name `...` in `__all__` |
-| F823 | UndefinedLocal | Local variable `...` referenced before assignment |
-| F831 | DuplicateArgumentName | Duplicate argument name in function definition |
-| F841 | UnusedVariable | Local variable `...` is assigned to but never used |
-| F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` |
-| R001 | UselessObjectInheritance | Class `...` inherits from object |
-| R002 | NoAssertEquals | `assertEquals` is deprecated, use `assertEqual` instead |
+<!-- Begin section: Rules -->
 
-## Development
+**Ruff supports over 500 lint rules**, many of which are inspired by popular tools like Flake8,
+isort, pyupgrade, and others. Regardless of the rule's origin, Ruff re-implements every rule in
+Rust as a first-party feature.
 
-ruff is written in Rust (1.63.0). You'll need to install the [Rust toolchain](https://www.rust-lang.org/tools/install)
-for development.
+By default, Ruff enables Flake8's `E` and `F` rules. Ruff supports all rules from the `F` category,
+and a [subset](https://beta.ruff.rs/docs/rules/#error-e) of the `E` category, omitting those
+stylistic rules made obsolete by the use of an autoformatter, like
+[Black](https://github.com/psf/black).
 
-Assuming you have `cargo` installed, you can run:
+If you're just getting started with Ruff, **the default rule set is a great place to start**: it
+catches a wide variety of common errors (like unused imports) with zero configuration.
 
-```shell
-cargo run resources/test/fixtures
-cargo fmt
-cargo clippy
-cargo test
-```
+<!-- End section: Rules -->
 
-## Deployment
+For a complete enumeration of the supported rules, see [_Rules_](https://beta.ruff.rs/docs/rules/).
 
-ruff is distributed on [PyPI](https://pypi.org/project/ruff/), and published via [`maturin`](https://github.com/PyO3/maturin).
+## Contributing
 
-See: `.github/workflows/release.yaml`.
+Contributions are welcome and highly appreciated. To get started, check out the
+[**contributing guidelines**](https://beta.ruff.rs/docs/contributing/).
 
-## Benchmarking
+You can also join us on [**Discord**](https://discord.gg/c9MhzV8aU5).
 
-First, clone [CPython](https://github.com/python/cpython). It's a large and diverse Python codebase,
-which makes it a good target for benchmarking.
+## Support
 
-```shell
-git clone --branch 3.10 https://github.com/python/cpython.git resources/test/cpython
-```
+Having trouble? Check out the existing issues on [**GitHub**](https://github.com/charliermarsh/ruff/issues),
+or feel free to [**open a new one**](https://github.com/charliermarsh/ruff/issues/new).
 
-Add this `pyproject.toml` to the CPython directory:
+You can also ask for help on [**Discord**](https://discord.gg/c9MhzV8aU5).
 
-```toml
-[tool.ruff]
-line-length = 88
-exclude = [
-    "./resources/test/cpython/Lib/lib2to3/tests/data/bom.py",
-    "./resources/test/cpython/Lib/lib2to3/tests/data/crlf.py",
-    "./resources/test/cpython/Lib/lib2to3/tests/data/different_encoding.py",
-    "./resources/test/cpython/Lib/lib2to3/tests/data/false_encoding.py",
-    "./resources/test/cpython/Lib/lib2to3/tests/data/py2_test_grammar.py",
-    "./resources/test/cpython/Lib/test/bad_coding2.py",
-    "./resources/test/cpython/Lib/test/badsyntax_3131.py",
-    "./resources/test/cpython/Lib/test/badsyntax_pep3120.py",
-    "./resources/test/cpython/Lib/test/encoded_modules/module_iso_8859_1.py",
-    "./resources/test/cpython/Lib/test/encoded_modules/module_koi8_r.py",
-    "./resources/test/cpython/Lib/test/test_fstring.py",
-    "./resources/test/cpython/Lib/test/test_grammar.py",
-    "./resources/test/cpython/Lib/test/test_importlib/test_util.py",
-    "./resources/test/cpython/Lib/test/test_named_expressions.py",
-    "./resources/test/cpython/Lib/test/test_patma.py",
-    "./resources/test/cpython/Lib/test/test_source_encoding.py",
-    "./resources/test/cpython/Tools/c-analyzer/c_parser/parser/_delim.py",
-    "./resources/test/cpython/Tools/i18n/pygettext.py",
-    "./resources/test/cpython/Tools/test2to3/maintest.py",
-    "./resources/test/cpython/Tools/test2to3/setup.py",
-    "./resources/test/cpython/Tools/test2to3/test/test_foo.py",
-    "./resources/test/cpython/Tools/test2to3/test2to3/hello.py",
-]
-```
+## Acknowledgements
 
-Next, to benchmark the release build:
+Ruff's linter draws on both the APIs and implementation details of many other
+tools in the Python ecosystem, especially [Flake8](https://github.com/PyCQA/flake8), [Pyflakes](https://github.com/PyCQA/pyflakes),
+[pycodestyle](https://github.com/PyCQA/pycodestyle), [pydocstyle](https://github.com/PyCQA/pydocstyle),
+[pyupgrade](https://github.com/asottile/pyupgrade), and [isort](https://github.com/PyCQA/isort).
 
-```shell
-cargo build --release
+In some cases, Ruff includes a "direct" Rust port of the corresponding tool.
+We're grateful to the maintainers of these tools for their work, and for all
+the value they've provided to the Python community.
 
-hyperfine --ignore-failure --warmup 1 \
-  "./target/release/ruff ./resources/test/cpython/ --no-cache" \
-  "./target/release/ruff ./resources/test/cpython/"
+Ruff's autoformatter is built on a fork of Rome's [`rome_formatter`](https://github.com/rome/tools/tree/main/crates/rome_formatter),
+and again draws on both the APIs and implementation details of [Rome](https://github.com/rome/tools),
+[Prettier](https://github.com/prettier/prettier), and [Black](https://github.com/psf/black).
 
-Benchmark 1: ./target/release/ruff ./resources/test/cpython/ --no-cache
-  Time (mean ± σ):     353.6 ms ±   7.6 ms    [User: 2868.8 ms, System: 171.5 ms]
-  Range (min … max):   344.4 ms … 367.3 ms    10 runs
+Ruff is also influenced by a number of tools outside the Python ecosystem, like
+[Clippy](https://github.com/rust-lang/rust-clippy) and [ESLint](https://github.com/eslint/eslint).
 
-Benchmark 2: ./target/release/ruff ./resources/test/cpython/
-  Time (mean ± σ):      59.6 ms ±   2.5 ms    [User: 36.4 ms, System: 345.6 ms]
-  Range (min … max):    55.9 ms …  67.0 ms    48 runs
-```
+Ruff is the beneficiary of a large number of [contributors](https://github.com/charliermarsh/ruff/graphs/contributors).
 
-To benchmark against the ecosystem's existing tools:
+Ruff is released under the MIT license.
 
-```shell
-hyperfine --ignore-failure --warmup 5 \
-  "./target/release/ruff ./resources/test/cpython/ --no-cache" \
-  "pylint --recursive=y resources/test/cpython/" \
-  "pyflakes resources/test/cpython" \
-  "autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython" \
-  "pycodestyle resources/test/cpython" \
-  "pycodestyle --select E501 resources/test/cpython" \
-  "flake8 resources/test/cpython" \
-  "flake8 --select=F831,F541,F634,F403,F706,F901,E501 resources/test/cpython" \
-  "python -m scripts.run_flake8 resources/test/cpython" \
-  "python -m scripts.run_flake8 resources/test/cpython --select=F831,F541,F634,F403,F706,F901,E501"
-```
+## Who's Using Ruff?
 
-In order, these evaluate:
+Ruff is used in a number of major open-source projects, including:
 
-- ruff
-- Pylint
-- PyFlakes
-- autoflake
-- pycodestyle
-- pycodestyle, limited to the checks supported by ruff
-- Flake8
-- Flake8, limited to the checks supported by ruff
-- Flake8, with a hack to enable multiprocessing on macOS
-- Flake8, with a hack to enable multiprocessing on macOS, limited to the checks supported by ruff
-
-(You can `poetry install` from `./scripts` to create a working environment for the above.)
-
-```shell
-Benchmark 1: ./target/release/ruff ./resources/test/cpython/ --no-cache
-  Time (mean ± σ):     469.3 ms ±  16.3 ms    [User: 2663.0 ms, System: 972.5 ms]
-  Range (min … max):   445.2 ms … 494.8 ms    10 runs
-
-Benchmark 2: pylint --recursive=y resources/test/cpython/
-  Time (mean ± σ):     27.211 s ±  0.097 s    [User: 26.405 s, System: 0.799 s]
-  Range (min … max):   27.056 s … 27.349 s    10 runs
-
-Benchmark 3: pyflakes resources/test/cpython
-  Time (mean ± σ):     27.309 s ±  0.033 s    [User: 27.137 s, System: 0.169 s]
-  Range (min … max):   27.267 s … 27.372 s    10 runs
-
-Benchmark 4: autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython
-  Time (mean ± σ):      8.027 s ±  0.024 s    [User: 74.255 s, System: 0.953 s]
-  Range (min … max):    7.969 s …  8.052 s    10 runs
-
-Benchmark 5: pycodestyle resources/test/cpython
-  Time (mean ± σ):     41.666 s ±  0.266 s    [User: 41.531 s, System: 0.132 s]
-  Range (min … max):   41.295 s … 41.980 s    10 runs
-
-Benchmark 6: pycodestyle --select E501 resources/test/cpython
-  Time (mean ± σ):     14.547 s ±  0.077 s    [User: 14.466 s, System: 0.079 s]
-  Range (min … max):   14.429 s … 14.695 s    10 runs
-
-Benchmark 7: flake8 resources/test/cpython
-  Time (mean ± σ):     75.700 s ±  0.152 s    [User: 75.254 s, System: 0.440 s]
-  Range (min … max):   75.513 s … 76.014 s    10 runs
-
-Benchmark 8: flake8 --select=F831,F541,F634,F403,F706,F901,E501 resources/test/cpython
-  Time (mean ± σ):     75.122 s ±  0.532 s    [User: 74.677 s, System: 0.440 s]
-  Range (min … max):   74.130 s … 75.606 s    10 runs
-
-Benchmark 9: python -m scripts.run_flake8 resources/test/cpython
-  Time (mean ± σ):     12.794 s ±  0.147 s    [User: 90.792 s, System: 0.738 s]
-  Range (min … max):   12.606 s … 13.030 s    10 runs
-
-Benchmark 10: python -m scripts.run_flake8 resources/test/cpython --select=F831,F541,F634,F403,F706,F901,E501
-  Time (mean ± σ):     12.487 s ±  0.118 s    [User: 90.052 s, System: 0.714 s]
-  Range (min … max):   12.265 s … 12.665 s    10 runs
-
-Summary
-  './target/release/ruff ./resources/test/cpython/ --no-cache' ran
-   17.10 ± 0.60 times faster than 'autoflake --recursive --expand-star-imports --remove-all-unused-imports --remove-unused-variables --remove-duplicate-keys resources/test/cpython'
-   26.60 ± 0.96 times faster than 'python -m scripts.run_flake8 resources/test/cpython --select=F831,F541,F634,F403,F706,F901,E501'
-   27.26 ± 1.00 times faster than 'python -m scripts.run_flake8 resources/test/cpython'
-   30.99 ± 1.09 times faster than 'pycodestyle --select E501 resources/test/cpython'
-   57.98 ± 2.03 times faster than 'pylint --recursive=y resources/test/cpython/'
-   58.19 ± 2.02 times faster than 'pyflakes resources/test/cpython'
-   88.77 ± 3.14 times faster than 'pycodestyle resources/test/cpython'
-  160.06 ± 5.68 times faster than 'flake8 --select=F831,F541,F634,F403,F706,F901,E501 resources/test/cpython'
-  161.29 ± 5.61 times faster than 'flake8 resources/test/cpython'
-```
+- [pandas](https://github.com/pandas-dev/pandas)
+- [FastAPI](https://github.com/tiangolo/fastapi)
+- [Transformers (Hugging Face)](https://github.com/huggingface/transformers)
+- [Diffusers (Hugging Face)](https://github.com/huggingface/diffusers)
+- [Apache Airflow](https://github.com/apache/airflow)
+- [SciPy](https://github.com/scipy/scipy)
+- [Zulip](https://github.com/zulip/zulip)
+- [Bokeh](https://github.com/bokeh/bokeh)
+- [Pydantic](https://github.com/pydantic/pydantic)
+- [Dagster](https://github.com/dagster-io/dagster)
+- [Dagger](https://github.com/dagger/dagger)
+- [Sphinx](https://github.com/sphinx-doc/sphinx)
+- [Hatch](https://github.com/pypa/hatch)
+- [PDM](https://github.com/pdm-project/pdm)
+- [Jupyter](https://github.com/jupyter-server/jupyter_server)
+- [Great Expectations](https://github.com/great-expectations/great_expectations)
+- [ONNX](https://github.com/onnx/onnx)
+- [Polars](https://github.com/pola-rs/polars)
+- [Ibis](https://github.com/ibis-project/ibis)
+- [Synapse (Matrix)](https://github.com/matrix-org/synapse)
+- [SnowCLI (Snowflake)](https://github.com/Snowflake-Labs/snowcli)
+- [Dispatch (Netflix)](https://github.com/Netflix/dispatch)
+- [Saleor](https://github.com/saleor/saleor)
+- [Pynecone](https://github.com/pynecone-io/pynecone)
+- [OpenBB](https://github.com/OpenBB-finance/OpenBBTerminal)
+- [Home Assistant](https://github.com/home-assistant/core)
+- [Pylint](https://github.com/PyCQA/pylint)
+- [Cryptography (PyCA)](https://github.com/pyca/cryptography)
+- [cibuildwheel (PyPA)](https://github.com/pypa/cibuildwheel)
+- [build (PyPA)](https://github.com/pypa/build)
+- [Babel](https://github.com/python-babel/babel)
+- [featuretools](https://github.com/alteryx/featuretools)
+- [meson-python](https://github.com/mesonbuild/meson-python)
+- [ZenML](https://github.com/zenml-io/zenml)
+- [delta-rs](https://github.com/delta-io/delta-rs)
+- [Starlite](https://github.com/starlite-api/starlite)
+- [telemetry-airflow (Mozilla)](https://github.com/mozilla/telemetry-airflow)
+- [Stable Baselines3](https://github.com/DLR-RM/stable-baselines3)
+- [PaddlePaddle](https://github.com/PaddlePaddle/Paddle)
+- [nox](https://github.com/wntrblm/nox)
+- [Neon](https://github.com/neondatabase/neon)
+- [The Algorithms](https://github.com/TheAlgorithms/Python)
 
 ## License
 

_typos.toml

@@ -0,0 +1,7 @@
+[files]
+extend-exclude = ["snapshots", "black"]
+
+[default.extend-words]
+trivias = "trivias"
+hel = "hel"
+whos = "whos"

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"
+}

clippy.toml

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

crates/flake8_to_ruff/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "flake8-to-ruff"
+version = "0.0.256"
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[dependencies]
+ruff = { path = "../ruff", default-features = false }
+
+anyhow = { workspace = true }
+clap = { workspace = true }
+colored = { workspace = true }
+configparser = { version = "3.0.2" }
+once_cell = { workspace = true }
+regex = { workspace = true }
+rustc-hash = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+strum = { workspace = true }
+strum_macros = { workspace = true }
+toml = { workspace = true }

crates/flake8_to_ruff/README.md

@@ -0,0 +1,98 @@
+# flake8-to-ruff
+
+Convert existing Flake8 configuration files (`setup.cfg`, `tox.ini`, or `.flake8`) for use with
+[Ruff](https://github.com/charliermarsh/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 [Ruff README](https://github.com/charliermarsh/ruff#user-content-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/charliermarsh/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/charliermarsh/ruff#subdirectory=crates/flake8_to_ruff"
+
+[build-system]
+requires = ["maturin>=0.14,<0.15"]
+build-backend = "maturin"
+
+[tool.maturin]
+bindings = "bin"
+strip = true

crates/flake8_to_ruff/src/main.rs

@@ -0,0 +1,68 @@
+//! Utility to generate Ruff's `pyproject.toml` section from a Flake8 INI file.
+
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+use configparser::ini::Ini;
+
+use ruff::flake8_to_ruff::{self, ExternalConfig};
+use ruff::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<flake8_to_ruff::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(flake8_to_ruff::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 = flake8_to_ruff::convert(&config, &external_config, args.plugin)?;
+
+    #[allow(clippy::print_stdout)]
+    {
+        println!("{}", toml::to_string_pretty(&pyproject)?);
+    }
+
+    Ok(())
+}

crates/ruff/Cargo.toml

@@ -0,0 +1,77 @@
+[package]
+name = "ruff"
+version = "0.0.256"
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+documentation.workspace = true
+homepage.workspace = true
+repository.workspace = true
+readme = "README.md"
+license = "MIT"
+
+[lib]
+name = "ruff"
+
+[dependencies]
+ruff_cache = { path = "../ruff_cache" }
+ruff_diagnostics = { path = "../ruff_diagnostics", features = ["serde"] }
+ruff_macros = { path = "../ruff_macros" }
+ruff_python_ast = { path = "../ruff_python_ast" }
+ruff_python_stdlib = { path = "../ruff_python_stdlib" }
+ruff_rustpython = { path = "../ruff_rustpython" }
+
+anyhow = { workspace = true }
+bisection = { version = "0.1.0" }
+bitflags = { workspace = true }
+chrono = { workspace = true }
+clap = { workspace = true, features = ["derive", "string"], optional = true }
+colored = { workspace = true }
+dirs = { version = "4.0.0" }
+fern = { version = "0.6.1" }
+glob = { workspace = true }
+globset = { workspace = true }
+ignore = { workspace = true }
+imperative = { version = "1.0.4" }
+is-macro = { workspace = true }
+itertools = { workspace = true }
+libcst = { workspace = true }
+log = { workspace = true }
+natord = { version = "1.0.9" }
+nohash-hasher = { version = "0.2.0" }
+num-bigint = { version = "0.4.3" }
+num-traits = { version = "0.2.15" }
+once_cell = { workspace = true }
+path-absolutize = { workspace = true, features = [
+  "once_cell_cache",
+  "use_unix_paths_on_wasm",
+] }
+pathdiff = { version = "0.2.1" }
+pep440_rs = { git = "https://github.com/konstin/pep440-rs.git", features = [
+  "serde",
+], rev = "a8fef4ec47f4c25b070b39cdbe6a0b9847e49941" }
+regex = { workspace = true }
+result-like = { version = "0.4.6" }
+rustc-hash = { workspace = true }
+rustpython-common = { workspace = true }
+rustpython-parser = { workspace = true }
+schemars = { workspace = true }
+semver = { version = "1.0.16" }
+serde = { workspace = true }
+shellexpand = { workspace = true }
+smallvec = { version = "1.10.0" }
+strum = { workspace = true }
+strum_macros = { workspace = true }
+textwrap = { workspace = true }
+thiserror = { version = "1.0.38" }
+toml = { workspace = true }
+
+[dev-dependencies]
+criterion = { version = "0.4.0" }
+insta = { workspace = true, features = ["yaml", "redactions"] }
+pretty_assertions = "1.3.0"
+test-case = { workspace = true }
+
+[features]
+default = []
+logical_lines = []

crates/ruff/resources/test/disallowed_rule_names.txt

@@ -0,0 +1,4 @@
+avoid-*
+do-not-*
+uses-*
+*-used

crates/ruff/resources/test/fixtures/README.md

@@ -0,0 +1,3 @@
+# fixtures
+
+Fixture files used for snapshot testing.

crates/ruff/resources/test/fixtures/eradicate/ERA001.py

@@ -0,0 +1,15 @@
+#import os
+# from foo import junk
+#a = 3
+a = 4
+#foo(1, 2, 3)
+
+def foo(x, y, z):
+    content = 1 # print('hello')
+    print(x, y, z)
+
+    # This is a real comment.
+    #return True
+    return False
+
+#import os  # noqa: ERA001

crates/ruff/resources/test/fixtures/flake8_2020/YTT101.py

@@ -0,0 +1,12 @@
+import sys
+from sys import version, version as v
+
+print(sys.version)
+
+print(sys.version[:3])
+print(version[:3])
+print(v[:3])
+
+# the tool is timid and only flags certain numeric slices
+i = 3
+print(sys.version[:i])

crates/ruff/resources/test/fixtures/flake8_2020/YTT102.py

@@ -0,0 +1,5 @@
+import sys
+from sys import version
+
+py_minor = sys.version[2]
+py_minor = version[2]

crates/ruff/resources/test/fixtures/flake8_2020/YTT103.py

@@ -0,0 +1,8 @@
+import sys
+from sys import version
+
+version < "3.5"
+sys.version < "3.5"
+sys.version <= "3.5"
+sys.version > "3.5"
+sys.version >= "3.5"

crates/ruff/resources/test/fixtures/flake8_2020/YTT201.py

@@ -0,0 +1,10 @@
+import sys
+from sys import version_info
+
+print("{}.{}".format(*sys.version_info))
+PY3 = sys.version_info[0] >= 3
+
+PY3 = sys.version_info[0] == 3
+PY3 = version_info[0] == 3
+PY2 = sys.version_info[0] != 3
+PY2 = version_info[0] != 3

crates/ruff/resources/test/fixtures/flake8_2020/YTT202.py

@@ -0,0 +1,7 @@
+import six
+from six import PY3
+
+if six.PY3:
+    print("3")
+if PY3:
+    print("3")

crates/ruff/resources/test/fixtures/flake8_2020/YTT203.py

@@ -0,0 +1,5 @@
+import sys
+from sys import version_info
+
+sys.version_info[1] >= 5
+version_info[1] < 6

crates/ruff/resources/test/fixtures/flake8_2020/YTT204.py

@@ -0,0 +1,5 @@
+import sys
+from sys import version_info
+
+sys.version_info.minor <= 7
+version_info.minor > 8

crates/ruff/resources/test/fixtures/flake8_2020/YTT301.py

@@ -0,0 +1,5 @@
+import sys
+from sys import version
+
+py_major = sys.version[0]
+py_major = version[0]

crates/ruff/resources/test/fixtures/flake8_2020/YTT302.py

@@ -0,0 +1,8 @@
+import sys
+from sys import version
+
+version < "3"
+sys.version < "3"
+sys.version <= "3"
+sys.version > "3"
+sys.version >= "3"

crates/ruff/resources/test/fixtures/flake8_2020/YTT303.py

@@ -0,0 +1,5 @@
+import sys
+from sys import version
+
+print(sys.version[:1])
+print(version[:1])

crates/ruff/resources/test/fixtures/flake8_annotations/allow_nested_overload.py

@@ -0,0 +1,9 @@
+class C:
+    from typing import overload
+
+    @overload
+    def f(self, x: int, y: int) -> None:
+        ...
+
+    def f(self, x, y):
+        pass

crates/ruff/resources/test/fixtures/flake8_annotations/allow_overload.py

@@ -0,0 +1,49 @@
+from typing import overload
+
+
+@overload
+def foo(i: int) -> "int":
+    ...
+
+
+@overload
+def foo(i: "str") -> "str":
+    ...
+
+
+def foo(i):
+    return i
+
+
+@overload
+def bar(i: int) -> "int":
+    ...
+
+
+@overload
+def bar(i: "str") -> "str":
+    ...
+
+
+class X:
+    def bar(i):
+        return i
+
+
+# TODO(charlie): This third case should raise an error (as in Mypy), because we have a
+# statement between the interfaces and implementation.
+@overload
+def baz(i: int) -> "int":
+    ...
+
+
+@overload
+def baz(i: "str") -> "str":
+    ...
+
+
+x = 1
+
+
+def baz(i):
+    return i

crates/ruff/resources/test/fixtures/flake8_annotations/allow_star_arg_any.py

@@ -0,0 +1,57 @@
+from typing import Any
+
+
+# OK
+def foo(a: int, *args: str, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: Any, *args: str, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: str, **kwargs: str) -> Any:
+    pass
+
+
+# OK
+def foo(a: int, *args: Any, **kwargs: Any) -> int:
+    pass
+
+
+# OK
+def foo(a: int, *args: Any, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: str, **kwargs: Any) -> int:
+    pass
+
+
+class Bar:
+    # OK
+    def foo_method(self, a: int, *params: str, **options: str) -> int:
+        pass
+
+    # ANN401
+    def foo_method(self, a: Any, *params: str, **options: str) -> int:
+        pass
+
+    # ANN401
+    def foo_method(self, a: int, *params: str, **options: str) -> Any:
+        pass
+
+    # OK
+    def foo_method(self, a: int, *params: Any, **options: Any) -> int:
+        pass
+
+    # OK
+    def foo_method(self, a: int, *params: Any, **options: str) -> int:
+        pass
+
+    # OK
+    def foo_method(self, a: int, *params: str, **options: Any) -> int:
+        pass

crates/ruff/resources/test/fixtures/flake8_annotations/annotation_presence.py

@@ -0,0 +1,113 @@
+from typing import Any, Type
+
+# Error
+def foo(a, b):
+    pass
+
+
+# Error
+def foo(a: int, b):
+    pass
+
+
+# Error
+def foo(a: int, b) -> int:
+    pass
+
+
+# Error
+def foo(a: int, b: int):
+    pass
+
+
+# Error
+def foo():
+    pass
+
+
+# OK
+def foo(a: int, b: int) -> int:
+    pass
+
+
+# OK
+def foo() -> int:
+    pass
+
+
+# OK
+def foo(a: int, *args: str, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: Any, *args: str, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: str, **kwargs: str) -> Any:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: Any, **kwargs: Any) -> int:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: Any, **kwargs: str) -> int:
+    pass
+
+
+# ANN401
+def foo(a: int, *args: str, **kwargs: Any) -> int:
+    pass
+
+
+class Foo:
+    # OK
+    def foo(self: "Foo", a: int, b: int) -> int:
+        pass
+
+    # ANN101
+    def foo(self, a: int, b: int) -> int:
+        pass
+
+    # ANN401
+    def foo(self: "Foo", a: Any, *params: str, **options: str) -> int:
+        pass
+
+    # ANN401
+    def foo(self: "Foo", a: int, *params: str, **options: str) -> Any:
+        pass
+
+    # ANN401
+    def foo(self: "Foo", a: int, *params: Any, **options: Any) -> int:
+        pass
+
+    # ANN401
+    def foo(self: "Foo", a: int, *params: Any, **options: str) -> int:
+        pass
+
+    # ANN401
+    def foo(self: "Foo", a: int, *params: str, **options: Any) -> int:
+        pass
+
+    # OK
+    @classmethod
+    def foo(cls: Type["Foo"], a: int, b: int) -> int:
+        pass
+
+    # ANN102
+    @classmethod
+    def foo(cls, a: int, b: int) -> int:
+        pass
+
+    # ANN101
+    def foo(self, /, a: int, b: int) -> int:
+        pass
+
+
+# OK
+def f(*args: *tuple[int]) -> None: ...

crates/ruff/resources/test/fixtures/flake8_annotations/ignore_fully_untyped.py

@@ -0,0 +1,44 @@
+"""Test case expected to be run with `ignore_fully_untyped = True`."""
+
+
+def ok_fully_untyped_1(a, b):
+    pass
+
+
+def ok_fully_untyped_2():
+    pass
+
+
+def ok_fully_typed_1(a: int, b: int) -> int:
+    pass
+
+
+def ok_fully_typed_2() -> int:
+    pass
+
+
+def ok_fully_typed_3(a: int, *args: str, **kwargs: str) -> int:
+    pass
+
+
+def error_partially_typed_1(a: int, b):
+    pass
+
+
+def error_partially_typed_2(a: int, b) -> int:
+    pass
+
+
+def error_partially_typed_3(a: int, b: int):
+    pass
+
+
+class X:
+    def ok_untyped_method_with_arg(self, a):
+        pass
+
+    def ok_untyped_method(self):
+        pass
+
+    def error_typed_self(self: X):
+        pass

crates/ruff/resources/test/fixtures/flake8_annotations/mypy_init_return.py

@@ -0,0 +1,48 @@
+"""Test case expected to be run with `mypy_init_return = True`."""
+
+# Error
+class Foo:
+    def __init__(self):
+        ...
+
+
+# Error
+class Foo:
+    def __init__(self, foo):
+        ...
+
+
+# OK
+class Foo:
+    def __init__(self, foo) -> None:
+        ...
+
+
+# OK
+class Foo:
+    def __init__(self) -> None:
+        ...
+
+
+# OK
+class Foo:
+    def __init__(self, foo: int):
+        ...
+
+
+# OK
+class Foo:
+    def __init__(self, foo: int) -> None:
+        ...
+
+
+# Error
+def __init__(self, foo: int):
+    ...
+
+
+# Error – used to be ok for a moment since the mere presence
+# of a vararg falsely indicated that the function has a typed argument.
+class Foo:
+    def __init__(self, *arg):
+        ...

crates/ruff/resources/test/fixtures/flake8_annotations/suppress_dummy_args.py

@@ -0,0 +1,26 @@
+"""Test case expected to be run with `suppress_dummy_args = True`."""
+
+# OK
+def foo(_) -> None:
+    ...
+
+
+# OK
+def foo(*_) -> None:
+    ...
+
+
+# OK
+def foo(**_) -> None:
+    ...
+
+
+# OK
+def foo(a: int, _) -> None:
+    ...
+
+
+# OK
+def foo() -> None:
+    def bar(_) -> None:
+        ...

crates/ruff/resources/test/fixtures/flake8_annotations/suppress_none_returning.py

@@ -0,0 +1,60 @@
+"""Test case expected to be run with `suppress_none_returning = True`."""
+
+# OK
+def foo():
+    a = 2 + 2
+
+
+# OK
+def foo():
+    return
+
+
+# OK
+def foo():
+    return None
+
+
+# OK
+def foo():
+    a = 2 + 2
+    if a == 4:
+        return
+    else:
+        return
+
+
+# OK
+def foo():
+    a = 2 + 2
+    if a == 4:
+        return None
+    else:
+        return
+
+
+# OK
+def foo():
+    def bar() -> bool:
+        return True
+
+    bar()
+
+
+# Error
+def foo():
+    return True
+
+
+# Error
+def foo():
+    a = 2 + 2
+    if a == 4:
+        return True
+    else:
+        return
+
+
+# Error (on the argument, but not the return type)
+def foo(a):
+    a = 2 + 2

crates/ruff/resources/test/fixtures/flake8_bandit/S101.py

@@ -0,0 +1,11 @@
+# Error
+assert True
+
+def fn():
+    x = 1
+
+    # Error
+    assert x == 1
+
+    # Error
+    assert x == 2

crates/ruff/resources/test/fixtures/flake8_bandit/S102.py

@@ -0,0 +1,5 @@
+def fn():
+    # Error
+    exec('x = 2')
+
+exec('y = 3')

crates/ruff/resources/test/fixtures/flake8_bandit/S103.py

@@ -0,0 +1,22 @@
+import os
+import stat
+
+keyfile = "foo"
+
+os.chmod("/etc/passwd", 0o227)  # Error
+os.chmod("/etc/passwd", 0o7)  # Error
+os.chmod("/etc/passwd", 0o664)  # OK
+os.chmod("/etc/passwd", 0o777)  # Error
+os.chmod("/etc/passwd", 0o770)  # Error
+os.chmod("/etc/passwd", 0o776)  # Error
+os.chmod("/etc/passwd", 0o760)  # OK
+os.chmod("~/.bashrc", 511)  # Error
+os.chmod("/etc/hosts", 0o777)  # Error
+os.chmod("/tmp/oh_hai", 0x1FF)  # Error
+os.chmod("/etc/passwd", stat.S_IRWXU)  # OK
+os.chmod(keyfile, 0o777)  # Error
+os.chmod(keyfile, 0o7 | 0o70 | 0o700)  # Error
+os.chmod(keyfile, stat.S_IRWXO | stat.S_IRWXG | stat.S_IRWXU)  # Error
+os.chmod("~/hidden_exec", stat.S_IXGRP)  # Error
+os.chmod("~/hidden_exec", stat.S_IXOTH)  # OK
+os.chmod("/etc/passwd", stat.S_IWOTH)  # Error

crates/ruff/resources/test/fixtures/flake8_bandit/S104.py

@@ -0,0 +1,19 @@
+def func(address):
+    print(address)
+
+
+# OK
+"OK"
+
+# Error
+"0.0.0.0"
+'0.0.0.0'
+
+
+# Error
+func("0.0.0.0")
+
+
+def my_func():
+    x = "0.0.0.0"
+    print(x)

crates/ruff/resources/test/fixtures/flake8_bandit/S105.py

@@ -0,0 +1,77 @@
+d = {}
+
+# OK
+safe = "s3cr3t"
+password = True
+password = safe
+password = ""
+password is True
+password == 1
+d["safe"] = "s3cr3t"
+
+# Errors
+password = "s3cr3t"
+_pass = "s3cr3t"
+passwd = "s3cr3t"
+pwd = "s3cr3t"
+secret = "s3cr3t"
+token = "s3cr3t"
+secrete = "s3cr3t"
+safe = password = "s3cr3t"
+password = safe = "s3cr3t"
+PASSWORD = "s3cr3t"
+PassWord = "s3cr3t"
+
+d["password"] = "s3cr3t"
+d["pass"] = "s3cr3t"
+d["passwd"] = "s3cr3t"
+d["pwd"] = "s3cr3t"
+d["secret"] = "s3cr3t"
+d["token"] = "s3cr3t"
+d["secrete"] = "s3cr3t"
+safe = d["password"] = "s3cr3t"
+d["password"] = safe = "s3cr3t"
+
+
+class MyClass:
+    password = "s3cr3t"
+    safe = password
+
+
+MyClass.password = "s3cr3t"
+MyClass._pass = "s3cr3t"
+MyClass.passwd = "s3cr3t"
+MyClass.pwd = "s3cr3t"
+MyClass.secret = "s3cr3t"
+MyClass.token = "s3cr3t"
+MyClass.secrete = "s3cr3t"
+
+password == "s3cr3t"
+_pass == "s3cr3t"
+passwd == "s3cr3t"
+pwd == "s3cr3t"
+secret == "s3cr3t"
+token == "s3cr3t"
+secrete == "s3cr3t"
+password == safe == "s3cr3t"
+
+if token == "1\n2":
+    pass
+
+if token == "3\t4":
+    pass
+
+if token == "5\r6":
+    pass
+
+
+# These should not be flagged
+passed_msg = "You have passed!"
+compassion = "Please don't match!"
+impassable = "You shall not pass!"
+passwords = ""
+PASSWORDS = ""
+passphrases = ""
+PassPhrases = ""
+tokens = ""
+secrets = ""

crates/ruff/resources/test/fixtures/flake8_bandit/S106.py

@@ -0,0 +1,14 @@
+def func(pos, password):
+    pass
+
+
+string = "Hello World"
+
+# OK
+func("s3cr3t")
+func(1, password=string)
+func(1, password="")
+func(pos="s3cr3t", password=string)
+
+# Error
+func(1, password="s3cr3t")

crates/ruff/resources/test/fixtures/flake8_bandit/S107.py

@@ -0,0 +1,34 @@
+def ok(first, default="default"):
+    pass
+
+
+def default(first, password="default"):
+    pass
+
+
+def ok_posonly(first, /, pos, default="posonly"):
+    pass
+
+
+def default_posonly(first, /, pos, password="posonly"):
+    pass
+
+
+def ok_kwonly(first, *, default="kwonly"):
+    pass
+
+
+def default_kwonly(first, *, password="kwonly"):
+    pass
+
+
+def ok_all(first, /, pos, default="posonly", *, kwonly="kwonly"):
+    pass
+
+
+def default_all(first, /, pos, secret="posonly", *, password="kwonly"):
+    pass
+
+
+def ok_empty(first, password=""):
+    pass

crates/ruff/resources/test/fixtures/flake8_bandit/S108.py

@@ -0,0 +1,16 @@
+# ok
+with open("/abc/tmp", "w") as f:
+    f.write("def")
+
+with open("/tmp/abc", "w") as f:
+    f.write("def")
+
+with open("/var/tmp/123", "w") as f:
+    f.write("def")
+
+with open("/dev/shm/unit/test", "w") as f:
+    f.write("def")
+
+# not ok by config
+with open("/foo/bar", "w") as f:
+    f.write("def")

crates/ruff/resources/test/fixtures/flake8_bandit/S110.py

@@ -0,0 +1,14 @@
+try:
+    pass
+except Exception:
+    pass
+
+try:
+    pass
+except:
+    pass
+
+try:
+    pass
+except ValueError:
+    pass

crates/ruff/resources/test/fixtures/flake8_bandit/S112.py

@@ -0,0 +1,29 @@
+try:
+    pass
+except Exception:
+    continue
+
+try:
+    pass
+except:
+    continue
+
+try:
+    pass
+except (Exception,):
+    continue
+
+try:
+    pass
+except (Exception, ValueError):
+    continue
+
+try:
+    pass
+except ValueError:
+    continue
+
+try:
+    pass
+except (ValueError,):
+    continue

crates/ruff/resources/test/fixtures/flake8_bandit/S113.py

@@ -0,0 +1,23 @@
+import requests
+
+requests.get('https://gmail.com')
+requests.get('https://gmail.com', timeout=None)
+requests.get('https://gmail.com', timeout=5)
+requests.post('https://gmail.com')
+requests.post('https://gmail.com', timeout=None)
+requests.post('https://gmail.com', timeout=5)
+requests.put('https://gmail.com')
+requests.put('https://gmail.com', timeout=None)
+requests.put('https://gmail.com', timeout=5)
+requests.delete('https://gmail.com')
+requests.delete('https://gmail.com', timeout=None)
+requests.delete('https://gmail.com', timeout=5)
+requests.patch('https://gmail.com')
+requests.patch('https://gmail.com', timeout=None)
+requests.patch('https://gmail.com', timeout=5)
+requests.options('https://gmail.com')
+requests.options('https://gmail.com', timeout=None)
+requests.options('https://gmail.com', timeout=5)
+requests.head('https://gmail.com')
+requests.head('https://gmail.com', timeout=None)
+requests.head('https://gmail.com', timeout=5)

crates/ruff/resources/test/fixtures/flake8_bandit/S324.py

@@ -0,0 +1,52 @@
+import hashlib
+from hashlib import new as hashlib_new
+from hashlib import sha1 as hashlib_sha1
+
+# Invalid
+
+hashlib.new('md5')
+
+hashlib.new('md4', b'test')
+
+hashlib.new(name='md5', data=b'test')
+
+hashlib.new('MD4', data=b'test')
+
+hashlib.new('sha1')
+
+hashlib.new('sha1', data=b'test')
+
+hashlib.new('sha', data=b'test')
+
+hashlib.new(name='SHA', data=b'test')
+
+hashlib.sha(data=b'test')
+
+hashlib.md5()
+
+hashlib_new('sha1')
+
+hashlib_sha1('sha1')
+
+# usedforsecurity arg only available in Python 3.9+
+hashlib.new('sha1', usedforsecurity=True)
+
+# Valid
+
+hashlib.new('sha256')
+
+hashlib.new('SHA512')
+
+hashlib.sha256(data=b'test')
+
+# usedforsecurity arg only available in Python 3.9+
+hashlib_new(name='sha1', usedforsecurity=False)
+
+# usedforsecurity arg only available in Python 3.9+
+hashlib_sha1(name='sha1', usedforsecurity=False)
+
+# usedforsecurity arg only available in Python 3.9+
+hashlib.md4(usedforsecurity=False)
+
+# usedforsecurity arg only available in Python 3.9+
+hashlib.new(name='sha256', usedforsecurity=False)

crates/ruff/resources/test/fixtures/flake8_bandit/S501.py

@@ -0,0 +1,40 @@
+import httpx
+import requests
+
+requests.get('https://gmail.com', timeout=30, verify=True)
+requests.get('https://gmail.com', timeout=30, verify=False)
+requests.post('https://gmail.com', timeout=30, verify=True)
+requests.post('https://gmail.com', timeout=30, verify=False)
+requests.put('https://gmail.com', timeout=30, verify=True)
+requests.put('https://gmail.com', timeout=30, verify=False)
+requests.delete('https://gmail.com', timeout=30, verify=True)
+requests.delete('https://gmail.com', timeout=30, verify=False)
+requests.patch('https://gmail.com', timeout=30, verify=True)
+requests.patch('https://gmail.com', timeout=30, verify=False)
+requests.options('https://gmail.com', timeout=30, verify=True)
+requests.options('https://gmail.com', timeout=30, verify=False)
+requests.head('https://gmail.com', timeout=30, verify=True)
+requests.head('https://gmail.com', timeout=30, verify=False)
+
+httpx.request('GET', 'https://gmail.com', verify=True)
+httpx.request('GET', 'https://gmail.com', verify=False)
+httpx.get('https://gmail.com', verify=True)
+httpx.get('https://gmail.com', verify=False)
+httpx.options('https://gmail.com', verify=True)
+httpx.options('https://gmail.com', verify=False)
+httpx.head('https://gmail.com', verify=True)
+httpx.head('https://gmail.com', verify=False)
+httpx.post('https://gmail.com', verify=True)
+httpx.post('https://gmail.com', verify=False)
+httpx.put('https://gmail.com', verify=True)
+httpx.put('https://gmail.com', verify=False)
+httpx.patch('https://gmail.com', verify=True)
+httpx.patch('https://gmail.com', verify=False)
+httpx.delete('https://gmail.com', verify=True)
+httpx.delete('https://gmail.com', verify=False)
+httpx.stream('https://gmail.com', verify=True)
+httpx.stream('https://gmail.com', verify=False)
+httpx.Client()
+httpx.Client(verify=False)
+httpx.AsyncClient()
+httpx.AsyncClient(verify=False)

crates/ruff/resources/test/fixtures/flake8_bandit/S506.py

@@ -0,0 +1,31 @@
+import json
+import yaml
+from yaml import CSafeLoader
+from yaml import SafeLoader
+from yaml import SafeLoader as NewSafeLoader
+
+
+def test_yaml_load():
+    ystr = yaml.dump({"a": 1, "b": 2, "c": 3})
+    y = yaml.load(ystr)
+    yaml.dump(y)
+    try:
+        y = yaml.load(ystr, Loader=yaml.CSafeLoader)
+    except AttributeError:
+        # CSafeLoader only exists if you build yaml with LibYAML
+        y = yaml.load(ystr, Loader=yaml.SafeLoader)
+
+
+def test_json_load():
+    # no issue should be found
+    j = json.load("{}")
+
+
+yaml.load("{}", Loader=yaml.Loader)
+
+# no issue should be found
+yaml.load("{}", SafeLoader)
+yaml.load("{}", yaml.SafeLoader)
+yaml.load("{}", CSafeLoader)
+yaml.load("{}", yaml.CSafeLoader)
+yaml.load("{}", NewSafeLoader)

crates/ruff/resources/test/fixtures/flake8_bandit/S508.py

@@ -0,0 +1,6 @@
+from pysnmp.hlapi import CommunityData
+
+CommunityData("public", mpModel=0)  # S508
+CommunityData("public", mpModel=1)  # S508
+
+CommunityData("public", mpModel=2)  # OK

crates/ruff/resources/test/fixtures/flake8_bandit/S509.py

@@ -0,0 +1,7 @@
+from pysnmp.hlapi import UsmUserData
+
+
+insecure = UsmUserData("securityName")  # S509
+auth_no_priv = UsmUserData("securityName", "authName")  # S509
+
+less_insecure = UsmUserData("securityName", "authName", "privName")  # OK

crates/ruff/resources/test/fixtures/flake8_bandit/S608.py

@@ -0,0 +1,95 @@
+# single-line failures
+query1 = "SELECT %s FROM table" % (var,) # bad
+query2 = "SELECT var FROM " + table
+query3 = "SELECT " + val + " FROM " + table
+query4 = "SELECT {} FROM table;".format(var)
+query5 = f"SELECT * FROM table WHERE var = {var}"
+
+query6 = "DELETE FROM table WHERE var = %s" % (var,)
+query7 = "DELETE FROM table WHERE VAR = " + var
+query8 = "DELETE FROM " + table + "WHERE var = " + var
+query9 = "DELETE FROM table WHERE var = {}".format(var)
+query10 = f"DELETE FROM table WHERE var = {var}"
+
+query11 = "INSERT INTO table VALUES (%s)" % (var,)
+query12 = "INSERT INTO TABLE VALUES (" + var + ")"
+query13 = "INSERT INTO {} VALUES ({})".format(table, var)
+query14 = f"INSERT INTO {table} VALUES var = {var}"
+
+query15 = "UPDATE %s SET var = %s" % (table, var)
+query16 = "UPDATE " + table + " SET var = " + var
+query17 = "UPDATE {} SET var = {}".format(table, var)
+query18 = f"UPDATE {table} SET var = {var}"
+
+query19 = "select %s from table" % (var,)
+query20 = "select var from " + table
+query21 = "select " + val + " from " + table
+query22 = "select {} from table;".format(var)
+query23 = f"select * from table where var = {var}"
+
+query24 = "delete from table where var = %s" % (var,)
+query25 = "delete from table where var = " + var
+query26 = "delete from " + table + "where var = " + var
+query27 = "delete from table where var = {}".format(var)
+query28 = f"delete from table where var = {var}"
+
+query29 = "insert into table values (%s)" % (var,)
+query30 = "insert into table values (" + var + ")"
+query31 = "insert into {} values ({})".format(table, var)
+query32 = f"insert into {table} values var = {var}"
+
+query33 = "update %s set var = %s" % (table, var)
+query34 = "update " + table + " set var = " + var
+query35 = "update {} set var = {}".format(table, var)
+query36 = f"update {table} set var = {var}"
+
+# multi-line failures
+def query37():
+    return """
+    SELECT *
+    FROM table
+    WHERE var = %s
+    """ % var
+
+def query38():
+    return """
+    SELECT *
+    FROM TABLE
+    WHERE var =
+    """ + var
+
+def query39():
+    return """
+    SELECT *
+    FROM table
+    WHERE var = {}
+    """.format(var)
+
+def query40():
+    return f"""
+    SELECT *
+    FROM table
+    WHERE var = {var}
+    """
+
+def query41():
+    return (
+        "SELECT *"
+        "FROM table"
+        f"WHERE var = {var}"
+    )
+
+# # cursor-wrapped failures
+query42 = cursor.execute("SELECT * FROM table WHERE var = %s" % var)
+query43 = cursor.execute(f"SELECT * FROM table WHERE var = {var}")
+query44 = cursor.execute("SELECT * FROM table WHERE var = {}".format(var))
+query45 = cursor.executemany("SELECT * FROM table WHERE var = %s" % var, [])
+ 
+# # pass
+query = "SELECT * FROM table WHERE id = 1"
+query = "DELETE FROM table WHERE id = 1"
+query = "INSERT INTO table VALUES (1)"
+query = "UPDATE table SET id = 1"
+cursor.execute('SELECT * FROM table WHERE id = %s', var)
+cursor.execute('SELECT * FROM table WHERE id = 1')
+cursor.executemany('SELECT * FROM table WHERE id = %s', [var, var2])

crates/ruff/resources/test/fixtures/flake8_bandit/S612.py

@@ -0,0 +1,8 @@
+import logging.config
+
+t = logging.config.listen(9999)
+
+def verify_func():
+    pass
+
+l = logging.config.listen(9999, verify=verify_func)

crates/ruff/resources/test/fixtures/flake8_bandit/S701.py

@@ -0,0 +1,29 @@
+import jinja2
+from jinja2 import Environment, select_autoescape
+templateLoader = jinja2.FileSystemLoader( searchpath="/" )
+something = ''
+
+Environment(loader=templateLoader, load=templateLoader, autoescape=True)
+templateEnv = jinja2.Environment(autoescape=True,
+        loader=templateLoader )
+Environment(loader=templateLoader, load=templateLoader, autoescape=something)  # S701
+templateEnv = jinja2.Environment(autoescape=False, loader=templateLoader )  # S701
+Environment(loader=templateLoader,
+            load=templateLoader,
+            autoescape=False)  # S701
+
+Environment(loader=templateLoader,  # S701
+            load=templateLoader)
+
+Environment(loader=templateLoader, autoescape=select_autoescape())
+
+Environment(loader=templateLoader,
+            autoescape=select_autoescape(['html', 'htm', 'xml']))
+
+Environment(loader=templateLoader,
+            autoescape=jinja2.select_autoescape(['html', 'htm', 'xml']))
+
+
+def fake_func():
+    return 'foobar'
+Environment(loader=templateLoader, autoescape=fake_func())  # S701

crates/ruff/resources/test/fixtures/flake8_blind_except/BLE.py

@@ -0,0 +1,94 @@
+try:
+    pass
+except ValueError:
+    pass
+except Exception as e:
+    raise e
+finally:
+    pass
+
+
+try:
+    pass
+except BaseException as e:
+    raise e
+except TypeError:
+    pass
+else:
+    pass
+
+
+try:
+    pass
+except Exception as e:
+    raise e
+except BaseException:
+    pass
+
+
+try:
+    pass
+except Exception:
+    pass
+finally:
+    try:
+        pass
+    except BaseException as e:
+        raise e
+
+
+try:
+    pass
+except Exception as e:
+    try:
+        raise e
+    except BaseException:
+        pass
+
+
+try:
+    try:
+        pass
+    except BaseException as e:
+        raise e
+except Exception:
+    pass
+
+
+try:
+    pass
+except Exception as e:
+    raise bad
+except BaseException:
+    pass
+
+import logging
+
+try:
+    pass
+except Exception:
+    logging.error("...")
+
+
+try:
+    pass
+except Exception:
+    logging.error("...", exc_info=False)
+
+
+try:
+    pass
+except Exception:
+    logging.error("...", exc_info=None)
+
+
+try:
+    pass
+except Exception:
+    logging.exception("...")
+
+
+try:
+    pass
+except Exception:
+    logging.error("...", exc_info=True)

crates/ruff/resources/test/fixtures/flake8_boolean_trap/FBT.py

@@ -0,0 +1,82 @@
+def function(
+    posonly_nohint,
+    posonly_nonboolhint: int,
+    posonly_boolhint: bool,
+    posonly_boolstrhint: "bool",
+    /,
+    offset,
+    posorkw_nonvalued_nohint,
+    posorkw_nonvalued_nonboolhint: int,
+    posorkw_nonvalued_boolhint: bool,
+    posorkw_nonvalued_boolstrhint: "bool",
+    posorkw_boolvalued_nohint=True,
+    posorkw_boolvalued_nonboolhint: int = True,
+    posorkw_boolvalued_boolhint: bool = True,
+    posorkw_boolvalued_boolstrhint: "bool" = True,
+    posorkw_nonboolvalued_nohint=1,
+    posorkw_nonboolvalued_nonboolhint: int = 2,
+    posorkw_nonboolvalued_boolhint: bool = 3,
+    posorkw_nonboolvalued_boolstrhint: "bool" = 4,
+    *,
+    kwonly_nonvalued_nohint,
+    kwonly_nonvalued_nonboolhint: int,
+    kwonly_nonvalued_boolhint: bool,
+    kwonly_nonvalued_boolstrhint: "bool",
+    kwonly_boolvalued_nohint=True,
+    kwonly_boolvalued_nonboolhint: int = False,
+    kwonly_boolvalued_boolhint: bool = True,
+    kwonly_boolvalued_boolstrhint: "bool" = True,
+    kwonly_nonboolvalued_nohint=5,
+    kwonly_nonboolvalued_nonboolhint: int = 1,
+    kwonly_nonboolvalued_boolhint: bool = 1,
+    kwonly_nonboolvalued_boolstrhint: "bool" = 1,
+    **kw,
+):
+    ...
+
+
+def used(do):
+    return do
+
+
+used("a", True)
+used(do=True)
+
+
+# Avoid FBT003 for explicitly allowed methods.
+"""
+FBT003 Boolean positional value on dict
+"""
+a = {"a": "b"}
+a.get("hello", False)
+{}.get("hello", False)
+{}.setdefault("hello", True)
+{}.pop("hello", False)
+{}.pop(True, False)
+dict.fromkeys(("world",), True)
+{}.deploy(True, False)
+getattr(someobj, attrname, False)
+mylist.index(True)
+int(True)
+str(int(False))
+cfg.get("hello", True)
+cfg.getint("hello", True)
+cfg.getfloat("hello", True)
+cfg.getboolean("hello", True)
+
+
+class Registry:
+    def __init__(self) -> None:
+        self._switches = [False] * len(Switch)
+
+    # FBT001: Boolean positional arg in function definition
+    def __setitem__(self, switch: Switch, value: bool) -> None:
+        self._switches[switch.value] = value
+
+    @foo.setter
+    def foo(self, value: bool) -> None:
+        pass
+
+    # FBT001: Boolean positional arg in function definition
+    def foo(self, value: bool) -> None:
+        pass

crates/ruff/resources/test/fixtures/flake8_bugbear/B002.py

@@ -0,0 +1,20 @@
+"""
+Should emit:
+B002 - on lines 15 and 20
+"""
+
+
+def this_is_all_fine(n):
+    x = n + 1
+    y = 1 + n
+    z = +x + y
+    return +z
+
+
+def this_is_buggy(n):
+    x = ++n
+    return x
+
+
+def this_is_buggy_too(n):
+    return ++n

crates/ruff/resources/test/fixtures/flake8_bugbear/B003.py

@@ -0,0 +1,18 @@
+"""
+Should emit:
+B003 - on line 9
+"""
+
+import os
+from os import environ
+
+os.environ = {}
+environ = {}  # that's fine, assigning a new meaning to the module-level name
+
+
+class Object:
+    os = None
+
+
+o = Object()
+o.os.environ = {}

crates/ruff/resources/test/fixtures/flake8_bugbear/B004.py

@@ -0,0 +1,12 @@
+def this_is_a_bug():
+    o = object()
+    if hasattr(o, "__call__"):
+        print("Ooh, callable! Or is it?")
+    if getattr(o, "__call__", False):
+        print("Ooh, callable! Or is it?")
+
+
+def this_is_fine():
+    o = object()
+    if callable(o):
+        print("Ooh, this is actually callable.")

crates/ruff/resources/test/fixtures/flake8_bugbear/B005.py

@@ -0,0 +1,31 @@
+s = "qwe"
+s.strip(s)  # no warning
+s.strip("we")  # no warning
+s.strip(".facebook.com")  # warning
+s.strip("e")  # no warning
+s.strip("\n\t ")  # no warning
+s.strip(r"\n\t ")  # warning
+s.lstrip(s)  # no warning
+s.lstrip("we")  # no warning
+s.lstrip(".facebook.com")  # warning
+s.lstrip("e")  # no warning
+s.lstrip("\n\t ")  # no warning
+s.lstrip(r"\n\t ")  # warning
+s.rstrip(s)  # no warning
+s.rstrip("we")  # warning
+s.rstrip(".facebook.com")  # warning
+s.rstrip("e")  # no warning
+s.rstrip("\n\t ")  # no warning
+s.rstrip(r"\n\t ")  # warning
+s.strip("a")  # no warning
+s.strip("あ")  # no warning
+s.strip("ああ")  # warning
+s.strip("\ufeff")  # no warning
+s.strip("\u0074\u0065\u0073\u0074")  # warning
+
+from somewhere import other_type, strip
+
+strip("we")  # no warning
+other_type().lstrip()  # no warning
+other_type().rstrip(["a", "b", "c"])  # no warning
+other_type().strip("a", "b")  # no warning

crates/ruff/resources/test/fixtures/flake8_bugbear/B006_B008.py

@@ -0,0 +1,207 @@
+import collections
+import datetime as dt
+import logging
+import operator
+import random
+import re
+import time
+import types
+from operator import attrgetter, itemgetter, methodcaller
+from types import MappingProxyType
+
+
+# B006
+# Allow immutable literals/calls/comprehensions
+def this_is_okay(value=(1, 2, 3)):
+    ...
+
+
+async def and_this_also(value=tuple()):
+    pass
+
+
+def frozenset_also_okay(value=frozenset()):
+    pass
+
+
+def mappingproxytype_okay(
+    value=MappingProxyType({}), value2=types.MappingProxyType({})
+):
+    pass
+
+
+def re_compile_ok(value=re.compile("foo")):
+    pass
+
+
+def operators_ok(
+    v=operator.attrgetter("foo"),
+    v2=operator.itemgetter("foo"),
+    v3=operator.methodcaller("foo"),
+):
+    pass
+
+
+def operators_ok_unqualified(
+    v=attrgetter("foo"),
+    v2=itemgetter("foo"),
+    v3=methodcaller("foo"),
+):
+    pass
+
+
+def kwonlyargs_immutable(*, value=()):
+    ...
+
+
+# Flag mutable literals/comprehensions
+
+
+def this_is_wrong(value=[1, 2, 3]):
+    ...
+
+
+def this_is_also_wrong(value={}):
+    ...
+
+
+def and_this(value=set()):
+    ...
+
+
+def this_too(value=collections.OrderedDict()):
+    ...
+
+
+async def async_this_too(value=collections.defaultdict()):
+    ...
+
+
+def dont_forget_me(value=collections.deque()):
+    ...
+
+
+# N.B. we're also flagging the function call in the comprehension
+def list_comprehension_also_not_okay(default=[i**2 for i in range(3)]):
+    pass
+
+
+def dict_comprehension_also_not_okay(default={i: i**2 for i in range(3)}):
+    pass
+
+
+def set_comprehension_also_not_okay(default={i**2 for i in range(3)}):
+    pass
+
+
+def kwonlyargs_mutable(*, value=[]):
+    ...
+
+
+# Recommended approach for mutable defaults
+def do_this_instead(value=None):
+    if value is None:
+        value = set()
+
+
+# B008
+# Flag function calls as default args (including if they are part of a sub-expression)
+def in_fact_all_calls_are_wrong(value=time.time()):
+    ...
+
+
+def f(when=dt.datetime.now() + dt.timedelta(days=7)):
+    pass
+
+
+def can_even_catch_lambdas(a=(lambda x: x)()):
+    ...
+
+
+# Recommended approach for function calls as default args
+LOGGER = logging.getLogger(__name__)
+
+
+def do_this_instead_of_calls_in_defaults(logger=LOGGER):
+    # That makes it more obvious that this one value is reused.
+    ...
+
+
+# Handle inf/infinity/nan special case
+def float_inf_okay(value=float("inf")):
+    pass
+
+
+def float_infinity_okay(value=float("infinity")):
+    pass
+
+
+def float_plus_infinity_okay(value=float("+infinity")):
+    pass
+
+
+def float_minus_inf_okay(value=float("-inf")):
+    pass
+
+
+def float_nan_okay(value=float("nan")):
+    pass
+
+
+def float_minus_NaN_okay(value=float("-NaN")):
+    pass
+
+
+def float_infinity_literal(value=float("1e999")):
+    pass
+
+
+# But don't allow standard floats
+def float_int_is_wrong(value=float(3)):
+    pass
+
+
+def float_str_not_inf_or_nan_is_wrong(value=float("3.14")):
+    pass
+
+
+# B006 and B008
+# We should handle arbitrary nesting of these B008.
+def nested_combo(a=[float(3), dt.datetime.now()]):
+    pass
+
+
+# Don't flag nested B006 since we can't guarantee that
+# it isn't made mutable by the outer operation.
+def no_nested_b006(a=map(lambda s: s.upper(), ["a", "b", "c"])):
+    pass
+
+
+# B008-ception.
+def nested_b008(a=random.randint(0, dt.datetime.now().year)):
+    pass
+
+
+# Ignore lambda contents since they are evaluated at call time.
+def foo(f=lambda x: print(x)):
+    f(1)
+
+
+from collections import abc
+from typing import Annotated, Dict, Optional, Sequence, Union, Set
+
+
+def immutable_annotations(
+    a: Sequence[int] | None = [],
+    b: Optional[abc.Mapping[int, int]] = {},
+    c: Annotated[Union[abc.Set[str], abc.Sized], "annotation"] = set(),
+):
+    pass
+
+
+def mutable_annotations(
+    a: list[int] | None = [],
+    b: Optional[Dict[int, int]] = {},
+    c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+):
+    pass

crates/ruff/resources/test/fixtures/flake8_bugbear/B007.py

@@ -0,0 +1,88 @@
+for i in range(10):
+    print(i)
+
+print(i)  # name no longer defined on Python 3; no warning yet
+
+for i in range(10):  # name not used within the loop; B007
+    print(10)
+
+print(i)  # name no longer defined on Python 3; no warning yet
+
+
+for _ in range(10):  # _ is okay for a throw-away variable
+    print(10)
+
+
+for i in range(10):
+    for j in range(10):
+        for k in range(10):  # k not used, i and j used transitively
+            print(i + j)
+
+
+def strange_generator():
+    for i in range(10):
+        for j in range(10):
+            for k in range(10):
+                for l in range(10):
+                    yield i, (j, (k, l))
+
+
+for i, (j, (k, l)) in strange_generator():  # i, k not used
+    print(j, l)
+
+FMT = "{foo} {bar}"
+for foo, bar in [(1, 2)]:
+    if foo:
+        print(FMT.format(**locals()))
+
+for foo, bar in [(1, 2)]:
+    if foo:
+        print(FMT.format(**globals()))
+
+for foo, bar in [(1, 2)]:
+    if foo:
+        print(FMT.format(**vars()))
+
+for foo, bar in [(1, 2)]:
+    print(FMT.format(foo=foo, bar=eval("bar")))
+
+
+def f():
+    # Fixable.
+    for foo, bar, baz in (["1", "2", "3"],):
+        if foo or baz:
+            break
+
+
+def f():
+    # Unfixable due to usage of `bar` outside of loop.
+    for foo, bar, baz in (["1", "2", "3"],):
+        if foo or baz:
+            break
+
+    print(bar)
+
+
+def f():
+    # Fixable.
+    for foo, bar, baz in (["1", "2", "3"],):
+        if foo or baz:
+            break
+
+    bar = 1
+
+
+def f():
+    # Fixable.
+    for foo, bar, baz in (["1", "2", "3"],):
+        if foo or baz:
+            break
+
+    bar = 1
+    print(bar)
+
+
+# Unfixable due to trailing underscore (`_line_` wouldn't be considered an ignorable
+# variable name).
+for line_ in range(self.header_lines):
+     fp.readline()

crates/ruff/resources/test/fixtures/flake8_bugbear/B008_extended.py

@@ -0,0 +1,20 @@
+from typing import List
+
+import fastapi
+from fastapi import Query
+
+
+def okay(db=fastapi.Depends(get_db)):
+    ...
+
+
+def okay(data: List[str] = fastapi.Query(None)):
+    ...
+
+
+def okay(data: List[str] = Query(None)):
+    ...
+
+
+def error_due_to_missing_import(data: List[str] = Depends(None)):
+    ...

crates/ruff/resources/test/fixtures/flake8_bugbear/B009_B010.py

@@ -0,0 +1,45 @@
+"""
+Should emit:
+B009 - Line 19, 20, 21, 22, 23, 24
+B010 - Line 40, 41, 42, 43, 44, 45
+"""
+
+# Valid getattr usage
+getattr(foo, bar)
+getattr(foo, "bar", None)
+getattr(foo, "bar{foo}".format(foo="a"), None)
+getattr(foo, "bar{foo}".format(foo="a"))
+getattr(foo, bar, None)
+getattr(foo, "123abc")
+getattr(foo, r"123\abc")
+getattr(foo, "except")
+getattr(foo, "__123abc")
+
+# Invalid usage
+getattr(foo, "bar")
+getattr(foo, "_123abc")
+getattr(foo, "__123abc__")
+getattr(foo, "abc123")
+getattr(foo, r"abc123")
+_ = lambda x: getattr(x, "bar")
+if getattr(x, "bar"):
+    pass
+
+# Valid setattr usage
+setattr(foo, bar, None)
+setattr(foo, "bar{foo}".format(foo="a"), None)
+setattr(foo, "123abc", None)
+setattr(foo, "__123abc", None)
+setattr(foo, r"123\abc", None)
+setattr(foo, "except", None)
+_ = lambda x: setattr(x, "bar", 1)
+if setattr(x, "bar", 1):
+    pass
+
+# Invalid usage
+setattr(foo, "bar", None)
+setattr(foo, "_123abc", None)
+setattr(foo, "__123abc__", None)
+setattr(foo, "abc123", None)
+setattr(foo, r"abc123", None)
+setattr(foo.bar, r"baz", None)

crates/ruff/resources/test/fixtures/flake8_bugbear/B011.py

@@ -0,0 +1,10 @@
+"""
+Should emit:
+B011 - on line 8
+B011 - on line 10
+"""
+
+assert 1 != 2
+assert False
+assert 1 != 2, "message"
+assert False, "message"

crates/ruff/resources/test/fixtures/flake8_bugbear/B012.py

@@ -0,0 +1,129 @@
+def a():
+    try:
+        pass
+    finally:
+        return  # warning
+
+
+def b():
+    try:
+        pass
+    finally:
+        if 1 + 0 == 2 - 1:
+            return  # warning
+
+
+def c():
+    try:
+        pass
+    finally:
+        try:
+            return  # warning
+        except Exception:
+            pass
+
+
+def d():
+    try:
+        try:
+            pass
+        finally:
+            return  # warning
+    finally:
+        pass
+
+
+def e():
+    if 1 == 2 - 1:
+        try:
+
+            def f():
+                try:
+                    pass
+                finally:
+                    return  # warning
+
+        finally:
+            pass
+
+
+def g():
+    try:
+        pass
+    finally:
+
+        def h():
+            return  # no warning
+
+        e()
+
+
+def i():
+    while True:
+        try:
+            pass
+        finally:
+            break  # warning
+
+            def j():
+                while True:
+                    break  # no warning
+
+
+def h():
+    while True:
+        try:
+            pass
+        finally:
+            continue  # warning
+
+            def j():
+                while True:
+                    continue  # no warning
+
+
+def k():
+    try:
+        pass
+    finally:
+        while True:
+            break  # no warning
+        while True:
+            continue  # no warning
+        while True:
+            return  # warning
+
+
+while True:
+    try:
+        pass
+    finally:
+        continue  # warning
+
+while True:
+    try:
+        pass
+    finally:
+        break  # warning
+
+
+while True:
+    try:
+        pass
+    finally:
+        match *0, 1, *2:
+            case 0,:
+                y = 0
+            case 0, *x:
+                break  # warning
+
+
+while True:
+    try:
+        pass
+    finally:
+        match *0, 1, *2:
+            case 0,:
+                y = 0
+            case 0, *x:
+                pass  # no warning

crates/ruff/resources/test/fixtures/flake8_bugbear/B013.py

@@ -0,0 +1,8 @@
+try:
+    pass
+except (ValueError,):
+    pass
+except AttributeError:
+    pass
+except (ImportError, TypeError):
+    pass

crates/ruff/resources/test/fixtures/flake8_bugbear/B014.py

@@ -0,0 +1,76 @@
+"""
+Should emit:
+B014 - on lines 11, 17, 28, 42, 49, 56, and 74.
+"""
+
+import binascii
+import re
+
+try:
+    pass
+except (Exception, TypeError):
+    # TypeError is a subclass of Exception, so it doesn't add anything
+    pass
+
+try:
+    pass
+except (OSError, OSError) as err:
+    # Duplicate exception types are useless
+    pass
+
+
+class MyError(Exception):
+    pass
+
+
+try:
+    pass
+except (MyError, MyError):
+    # Detect duplicate non-builtin errors
+    pass
+
+
+try:
+    pass
+except (MyError, Exception) as e:
+    # Don't assume that we're all subclasses of Exception
+    pass
+
+
+try:
+    pass
+except (MyError, BaseException) as e:
+    # But we *can* assume that everything is a subclass of BaseException
+    pass
+
+
+try:
+    pass
+except (re.error, re.error):
+    # Duplicate exception types as attributes
+    pass
+
+
+try:
+    pass
+except (IOError, EnvironmentError, OSError):
+    # Detect if a primary exception and any its aliases are present.
+    #
+    # Since Python 3.3, IOError, EnvironmentError, WindowsError, mmap.error,
+    # socket.error and select.error are aliases of OSError. See PEP 3151 for
+    # more info.
+    pass
+
+
+try:
+    pass
+except (MyException, NotImplemented):
+    # NotImplemented is not an exception, let's not crash on it.
+    pass
+
+
+try:
+    pass
+except (ValueError, binascii.Error):
+    # binascii.Error is a subclass of ValueError.
+    pass

crates/ruff/resources/test/fixtures/flake8_bugbear/B015.py

@@ -0,0 +1,27 @@
+assert 1 == 1
+
+1 == 1
+
+assert 1 in (1, 2)
+
+1 in (1, 2)
+
+
+if 1 == 2:
+    pass
+
+
+def test():
+    assert 1 in (1, 2)
+
+    1 in (1, 2)
+
+
+data = [x for x in [1, 2, 3] if x in (1, 2)]
+
+
+class TestClass:
+    1 == 1
+
+
+print(1 == 1)

crates/ruff/resources/test/fixtures/flake8_bugbear/B016.py

@@ -0,0 +1,11 @@
+"""
+Should emit:
+B016 - on lines 6, 7, and 8
+"""
+
+raise False
+raise 1
+raise "string"
+raise Exception(False)
+raise Exception(1)
+raise Exception("string")

crates/ruff/resources/test/fixtures/flake8_bugbear/B017.py

@@ -0,0 +1,36 @@
+"""
+Should emit:
+B017 - on lines 20
+"""
+import asyncio
+import unittest
+
+CONSTANT = True
+
+
+def something_else() -> None:
+    for i in (1, 2, 3):
+        print(i)
+
+
+class Foo:
+    pass
+
+
+class Foobar(unittest.TestCase):
+    def evil_raises(self) -> None:
+        with self.assertRaises(Exception):
+            raise Exception("Evil I say!")
+
+    def context_manager_raises(self) -> None:
+        with self.assertRaises(Exception) as ex:
+            raise Exception("Context manager is good")
+        self.assertEqual("Context manager is good", str(ex.exception))
+
+    def regex_raises(self) -> None:
+        with self.assertRaisesRegex(Exception, "Regex is good"):
+            raise Exception("Regex is good")
+
+    def raises_with_absolute_reference(self):
+        with self.assertRaises(asyncio.CancelledError):
+            Foo()