Try out rust-python-parser (nom-based)

.cargo/config.toml

@@ -1,2 +0,0 @@
-[alias]
-dev = "run --package ruff_dev --bin ruff_dev"

.github/workflows/ci.yaml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          profile: minimal
+          toolchain: stable
       - uses: actions/cache@v3
         env:
           cache-name: cache-cargo
@@ -27,7 +27,7 @@ jobs:
             ${{ runner.os }}-build-${{ env.cache-name }}-
             ${{ runner.os }}-build-
             ${{ runner.os }}-
-      - run: cargo build --all --release
+      - run: cargo build --release
 
   cargo_fmt:
     name: "cargo fmt"
@@ -36,10 +36,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          profile: minimal
-          toolchain: nightly-2022-11-01
-          override: true
-          components: rustfmt
+          toolchain: stable
       - uses: actions/cache@v3
         env:
           cache-name: cache-cargo
@@ -52,7 +49,7 @@ jobs:
             ${{ runner.os }}-build-${{ env.cache-name }}-
             ${{ runner.os }}-build-
             ${{ runner.os }}-
-      - run: cargo fmt --all --check
+      - run: cargo fmt --check
 
   cargo_clippy:
     name: "cargo clippy"
@@ -61,10 +58,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          profile: minimal
-          toolchain: nightly-2022-11-01
-          override: true
-          components: clippy
+          toolchain: stable
       - uses: actions/cache@v3
         env:
           cache-name: cache-cargo
@@ -77,7 +71,7 @@ jobs:
             ${{ runner.os }}-build-${{ env.cache-name }}-
             ${{ runner.os }}-build-
             ${{ runner.os }}-
-      - run: cargo clippy --all -- -D warnings
+      - run: cargo clippy -- -D warnings
 
   cargo_test:
     name: "cargo test"
@@ -86,9 +80,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          profile: minimal
-          toolchain: nightly-2022-11-01
-          override: true
+          toolchain: stable
       - uses: actions/cache@v3
         env:
           cache-name: cache-cargo
@@ -101,7 +93,7 @@ jobs:
             ${{ runner.os }}-build-${{ env.cache-name }}-
             ${{ runner.os }}-build-
             ${{ runner.os }}-
-      - run: cargo test --all
+      - run: cargo test
 
   maturin_build:
     name: "maturin build"
@@ -110,9 +102,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions-rs/toolchain@v1
         with:
-          profile: minimal
-          toolchain: nightly-2022-11-01
-          override: true
+          toolchain: stable
       - uses: actions/setup-python@v4
         with:
           python-version: "3.10"

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

@@ -1,298 +0,0 @@
-name: "[flake8-to-ruff] Release"
-
-on: workflow_dispatch
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-env:
-  PACKAGE_NAME: flake8-to-ruff
-  CRATE_NAME: flake8_to_ruff
-  PYTHON_VERSION: "3.7" # to build abi3 wheels
-
-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: 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
-        with:
-          target: x86_64
-          args: --release --out dist --sdist -m ./${{ env.CRATE_NAME }}/Cargo.toml
-          maturin-version: "v0.13.0"
-      - name: Install built wheel - x86_64
-        run: |
-          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
-        with:
-          name: wheels
-          path: dist
-  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: Install Rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          default: true
-      - name: Build wheels - universal2
-        uses: messense/maturin-action@v1
-        with:
-          args: --release --universal2 --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
-          maturin-version: "v0.13.0"
-      - name: Install built wheel - universal2
-        run: |
-          pip install dist/${{ env.CRATE_NAME }}-*universal2.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
-        with:
-          name: wheels
-          path: dist
-
-  windows:
-    runs-on: windows-latest
-    strategy:
-      matrix:
-        target: [x64, x86]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        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
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
-          maturin-version: "v0.13.0"
-      - name: Install built wheel
-        shell: bash
-        run: |
-          python -m pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
-        with:
-          name: wheels
-          path: dist
-
-  linux:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target: [x86_64, i686]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - name: Build wheels
-        uses: messense/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          manylinux: auto
-          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
-          maturin-version: "v0.13.0"
-      - name: Install built wheel
-        if: matrix.target == 'x86_64'
-        run: |
-          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
-        with:
-          name: wheels
-          path: dist
-
-  linux-cross:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target: [aarch64, armv7, s390x, ppc64le, ppc64]
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Build wheels
-        uses: messense/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          manylinux: auto
-          args: --no-default-features --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
-          maturin-version: "v0.13.0"
-      - uses: uraimo/run-on-arch-action@v2.0.5
-        if: matrix.target != 'ppc64'
-        name: Install built wheel
-        with:
-          arch: ${{ matrix.target }}
-          distro: ubuntu20.04
-          githubToken: ${{ github.token }}
-          install: |
-            apt-get update
-            apt-get install -y --no-install-recommends python3 python3-pip
-            pip3 install -U pip
-          run: |
-            pip3 install ${{ env.PACKAGE_NAME }} --no-index --find-links dist/ --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
-        with:
-          name: wheels
-          path: dist
-
-  musllinux:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target:
-          - x86_64-unknown-linux-musl
-          - i686-unknown-linux-musl
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          architecture: x64
-      - name: Build wheels
-        uses: messense/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          manylinux: musllinux_1_2
-          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
-          maturin-version: "v0.13.0"
-      - 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@v2
-        with:
-          name: wheels
-          path: dist
-
-  musllinux-cross:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        platform:
-          - target: aarch64-unknown-linux-musl
-            arch: aarch64
-          - target: armv7-unknown-linux-musleabihf
-            arch: armv7
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Build wheels
-        uses: messense/maturin-action@v1
-        with:
-          target: ${{ matrix.platform.target }}
-          manylinux: musllinux_1_2
-          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
-          maturin-version: "v0.13.0"
-      - uses: uraimo/run-on-arch-action@master
-        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@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 }} -m ./${{ env.CRATE_NAME }}/Cargo.toml
-      - name: Install built wheel
-        if: matrix.target == 'x86_64'
-        run: |
-          pip install dist/${{ env.CRATE_NAME }}-*.whl --force-reinstall
-      - name: Upload wheels
-        uses: actions/upload-artifact@v2
-        with:
-          name: wheels
-          path: dist
-
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    needs:
-      - macos-universal
-      - macos-x86_64
-      - windows
-      - linux
-      - linux-cross
-      - musllinux
-      - musllinux-cross
-      - pypy
-    steps:
-      - uses: actions/download-artifact@v2
-        with:
-          name: wheels
-      - uses: actions/setup-python@v4
-      - name: Publish to PyPi
-        env:
-          TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.FLAKE8_TO_RUFF_TOKEN }}
-        run: |
-          pip install --upgrade twine
-          twine upload --skip-existing *

.github/workflows/release.yaml

@@ -1,6 +1,8 @@
-name: "[ruff] Release"
+name: Release
 
 on:
+  pull_request:
+    branches: [main]
   create:
     tags:
       - v*
@@ -295,7 +297,7 @@ jobs:
       - name: Publish to PyPi
         env:
           TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.RUFF_TOKEN }}
+          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
         run: |
           pip install --upgrade twine
           twine upload --skip-existing *

.pre-commit-config.yaml

@@ -1,8 +1,8 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.105
+    rev: v0.0.40
     hooks:
-      - id: ruff
+      - id: lint
 
   - repo: https://github.com/abravalheri/validate-pyproject
     rev: v0.10.1

CONTRIBUTING.md

@@ -1,28 +1,22 @@
-# Contributing to Ruff
+# Contributing to ruff
 
-Welcome! We're happy to have you here. Thank you in advance for your contribution to Ruff.
+Welcome! We're happy to have you here. Thank you in advance for your contribution to ruff.
 
 ## The basics
 
-Ruff welcomes contributions in the form of Pull Requests. For small changes (e.g., bug fixes), feel
+ruff welcomes contributions in the form of Pull Requests. For small changes (e.g., bug fixes), feel
 free to submit a PR. For larger changes (e.g., new lint rules, new functionality, new configuration
 options), consider submitting an [Issue](https://github.com/charliermarsh/ruff/issues) outlining
 your proposed change.
 
 ### Prerequisites
 
-Ruff is written in Rust. You'll need to install the
+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.
 
-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:
+After cloning the repository, run ruff locally with:
 
 ```shell
 cargo run resources/test/fixtures --no-cache
@@ -32,9 +26,9 @@ Prior to opening a pull request, ensure that your code has been auto-formatted,
 both the lint and test validation checks:
 
 ```shell
-cargo +nightly fmt --all     # Auto-formatting...
-cargo +nightly clippy --all  # Linting...
-cargo +nightly test --all    # Testing...
+cargo fmt     # Auto-formatting...
+cargo clippy  # Linting...
+cargo test    # Testing...
 ```
 
 These checks will run on GitHub Actions when you open your Pull Request, but running them locally
@@ -45,13 +39,12 @@ prior to merging.
 
 ### Example: Adding a new lint rule
 
-There are four phases to adding a new lint rule:
+There are three phases to adding a new lint rule:
 
 1. Define the rule in `src/checks.rs`.
-2. Define the _logic_ for triggering the rule in `src/check_ast.rs` (for AST-based checks),
-   `src/check_tokens.rs` (for token-based checks), or `src/check_lines.rs` (for text-based checks).
+2. Define the _logic_ for triggering the rule in `src/check_ast.rs` (for AST-based checks)
+   or `src/check_lines.rs` (for text-based checks).
 3. Add a test fixture.
-4. Update the generated files (documentation and generated code).
 
 To define the rule, open up `src/checks.rs`. You'll need to define both a `CheckCode` and
 `CheckKind`. As an example, you can grep for `E402` and `ModuleImportNotAtTopOfFile`, and follow the
@@ -59,33 +52,37 @@ pattern implemented therein.
 
 To trigger the rule, you'll likely want to augment the logic in `src/check_ast.rs`, which defines
 the Python AST visitor, responsible for iterating over the abstract syntax tree and collecting
-lint-rule violations as it goes. 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.
+lint-rule violations as it goes. Grep for the `Check::new` invocations to understand how other,
+similar rules are implemented.
 
 To add a test fixture, create a file under `resources/test/fixtures`, named to match the `CheckCode`
 you defined earlier (e.g., `E402.py`). This file should contain a variety of violations and
-non-violations designed to evaluate and demonstrate the behavior of your lint rule. Run Ruff locally
-with (e.g.) `cargo run resources/test/fixtures/E402.py --no-cache`. Once you're satisfied with the
-output, codify the behavior as a snapshot test by adding a new `testcase` macro to the `mod tests`
-section of `src/linter.rs`, like so:
+non-violations designed to evaluate and demonstrate the behavior of your lint rule. Run ruff locally
+with (e.g.) `cargo run resources/test/fixtures/E402.py`. Once you're satisified with the output,
+codify the behavior as a snapshot test by adding a new function to the `mod tests` section of
+`src/linter.rs`, like so:
 
 ```rust
-#[test_case(CheckCode::A001, Path::new("A001.py"); "A001")]
-...
+#[test]
+fn e402() -> Result<()> {
+    let mut checks = check_path(
+        Path::new("./resources/test/fixtures/E402.py"),
+        &settings::Settings::for_rule(CheckCode::E402),
+        &fixer::Mode::Generate,
+    )?;
+    checks.sort_by_key(|check| check.location);
+    insta::assert_yaml_snapshot!(checks);
+    Ok(())
+}
 ```
 
 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, to update the documentation, run `cargo dev generate-rules-table` from the repo root. To
-update the generated prefix map, run `cargo dev generate-check-code-prefix`. Both of these commands
-should be run whenever a new check is added to the codebase.
-
 ### Example: Adding a new configuration option
 
-Ruff's user-facing settings live in two places: first, the command-line options defined with
+ruff's user-facing settings live in two places: first, the command-line options defined with
 [clap](https://docs.rs/clap/latest/clap/) via the `Cli` struct in `src/main.rs`; and second, the
 `Config` struct defined `src/pyproject.rs`, which is responsible for extracting user-defined
 settings from a `pyproject.toml` file.
@@ -100,9 +97,9 @@ acceptable unused variables (e.g., `_`).
 
 ## Release process
 
-As of now, Ruff has an ad hoc release process: releases are cut with high frequency via GitHub
+As of now, ruff has an ad hoc release process: releases are cut with high frequency via GitHub
 Actions, which automatically generates the appropriate wheels across architectures and publishes
 them to [PyPI](https://pypi.org/project/ruff/).
 
-Ruff follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
+ruff follows the [semver](https://semver.org/) versioning standard. However, as pre-1.0 software,
 even patch releases may contain [non-backwards-compatible changes](https://semver.org/#spec-item-4).

Cargo.toml

@@ -1,12 +1,6 @@
-[workspace]
-members = [
-  "flake8_to_ruff",
-  "ruff_dev",
-]
-
 [package]
 name = "ruff"
-version = "0.0.105"
+version = "0.0.56"
 edition = "2021"
 
 [lib]
@@ -15,8 +9,10 @@ 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 = "4.0.1", features = ["derive"] }
+clearscreen = { version = "1.0.10" }
 colored = { version = "2.0.0" }
 common-path = { version = "1.0.0" }
 dirs = { version = "4.0.0" }
@@ -27,39 +23,22 @@ itertools = { version = "0.10.5" }
 libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "32a044c127668df44582f85699358e67803b0d73" }
 log = { version = "0.4.17" }
 notify = { version = "4.0.17" }
-num-bigint = { version = "0.4.3" }
 once_cell = { version = "1.13.1" }
-path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
+path-absolutize = { version = "3.0.13", features = ["once_cell_cache"] }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
-ropey = { version = "1.5.0" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "77b821a1941019fe34f73ce17cea013ae1b98fd0" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/charliermarsh/RustPython.git", rev = "4f457893efc381ad5c432576b24bcc7e4a08c641" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "4f457893efc381ad5c432576b24bcc7e4a08c641" }
+rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "4f457893efc381ad5c432576b24bcc7e4a08c641" }
 serde = { version = "1.0.143", features = ["derive"] }
 serde_json = { version = "1.0.83" }
-strum = { version = "0.24.1", features = ["strum_macros"] }
-strum_macros = { version = "0.24.3" }
-textwrap = { version = "0.15.1" }
-titlecase = { version = "2.2.1" }
 toml = { version = "0.5.9" }
 update-informer = { version = "0.5.0", default_features = false, features = ["pypi"], optional = true }
 walkdir = { version = "2.3.2" }
-
-[target.'cfg(not(target_family = "wasm"))'.dependencies]
-cacache = { version = "10.0.1" } # uses async-std
-clearscreen = { version = "1.0.10" } # uses which
-
-# https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support
-# For (future) wasm-pack support
-[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dependencies]
-getrandom = { version = "0.2.7", features = ["js"] }
+python-parser = "0.2.0"
 
 [dev-dependencies]
-assert_cmd = { version = "2.0.4" }
-criterion = { version = "0.4.0" }
 insta = { version = "1.19.1", features = ["yaml"] }
-test-case = { version = "2.2.2" }
 
 [features]
 default = ["update-informer"]
@@ -76,7 +55,3 @@ opt-level = 3
 
 [profile.dev.package.similar]
 opt-level = 3
-
-[[bench]]
-name = "source_code_locator"
-harness = false

README.md

@@ -1,4 +1,4 @@
-# Ruff
+# 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)
@@ -15,62 +15,22 @@ An extremely fast Python linter, written in Rust.
   <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
-- 📦  Built-in caching, to avoid re-analyzing unchanged files
-- 🔧  `--fix` support, for automatic error correction (e.g., automatically remove unused imports)
-- 👀  `--watch` support, for continuous file monitoring
-- ⚖️  [Near-parity](#how-does-ruff-compare-to-flake8) with the built-in Flake8 rule set
-- 🔌  Native re-implementations of popular Flake8 plugins, like [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/) ([`pydocstyle`](https://pypi.org/project/pydocstyle/))
-
-Ruff aims to be orders of magnitude faster than alternative tools while integrating more
-functionality behind a single, common interface. Ruff can be used to replace Flake8 (plus a variety
-of plugins), [`pydocstyle`](https://pypi.org/project/pydocstyle/), [`yesqa`](https://github.com/asottile/yesqa),
-and even a subset of [`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.
-
-(Coming from Flake8? Try [`flake8-to-ruff`](https://pypi.org/project/flake8-to-ruff/) to
-automatically convert your existing configuration.)
-
-Ruff is actively developed and used in major open-source projects
-like [Zulip](https://github.com/zulip/zulip), [pydantic](https://github.com/pydantic/pydantic),
-and [Saleor](https://github.com/saleor/saleor).
+- ⚡️ 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#--fix)-inspired `--fix` support
+- 👀 [TypeScript](https://www.typescriptlang.org/docs/handbook/configuring-watch.html)-inspired `--watch` support
+- ⚖️ [Near-complete parity](#Parity-with-Flake8) with the built-in Flake8 rule set
 
 Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-much-much-faster).
 
-## Table of Contents
-
-1. [Installation and Usage](#installation-and-usage)
-2. [Configuration](#configuration)
-3. [Supported Rules](#supported-rules)
-   1. [Pyflakes](#pyflakes)
-   2. [pycodestyle](#pycodestyle)
-   3. [pydocstyle](#pydocstyle)
-   4. [pyupgrade](#pyupgrade)
-   5. [pep8-naming](#pep8-naming)
-   6. [flake8-comprehensions](#flake8-comprehensions)
-   7. [flake8-bugbear](#flake8-bugbear)
-   8. [flake8-builtins](#flake8-builtins)
-   9. [flake8-print](#flake8-print)
-   10. [flake8-quotes](#flake8-quotes)
-   11. [flake8-annotations](#flake8-annotations)
-   12. [Ruff-specific rules](#ruff-specific-rules)
-   13. [Meta rules](#meta-rules)
-5. [Editor Integrations](#editor-integrations)
-6. [FAQ](#faq)
-7. [Development](#development)
-8. [Releases](#releases)
-9. [Benchmarks](#benchmarks)
-10. [License](#license)
-11. [Contributing](#contributing)
-
-## Installation and Usage
+## Installation and usage
 
 ### Installation
 
-Available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
+Available as [ruff](https://pypi.org/project/ruff/) on PyPI:
 
 ```shell
 pip install ruff
@@ -78,7 +38,7 @@ pip install ruff
 
 ### 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
@@ -86,95 +46,38 @@ ruff path/to/code/
 ruff path/to/code/*.py
 ```
 
-You can run Ruff in `--watch` mode to automatically re-run on-change:
+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 also works with [pre-commit](https://pre-commit.com):
 
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.105
+    rev: v0.0.48
     hooks:
-      - id: ruff
+      - id: lint
 ```
 
-<!-- TODO(charlie): Remove this message a few versions after v0.0.86. -->
-_Note: prior to `v0.0.86`, `ruff-pre-commit` used `lint` (rather than `ruff`) as the hook ID._
-
 ## Configuration
 
-Ruff is configurable both via `pyproject.toml` and the command line. If left unspecified, the
-default configuration is equivalent to:
+ruff is configurable both via `pyproject.toml` and the command line.
+
+For example, you could configure ruff to only enforce a subset of rules with:
 
 ```toml
 [tool.ruff]
 line-length = 88
-
-# Enable Flake's "E" and "F" codes by default.
-select = ["E", "F"]
-ignore = []
-
-# Exclude a variety of commonly ignored directories.
-exclude = [
-    ".bzr",
-    ".direnv",
-    ".eggs",
-    ".git",
-    ".hg",
-    ".mypy_cache",
-    ".nox",
-    ".pants.d",
-    ".ruff_cache",
-    ".svn",
-    ".tox",
-    ".venv",
-    "__pypackages__",
-    "_build",
-    "buck-out",
-    "build",
-    "dist",
-    "node_modules",
-    "venv",
+select = [
+    "F401",
+    "F403",
 ]
-per-file-ignores = {}
-
-# Allow unused variables when underscore-prefixed.
-dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
-
-# Assume Python 3.10.
-target-version = "py310"
 ```
 
-As an example, the following would configure Ruff to (1) avoid checking for line-length
-violations (`E501`) and (2) ignore unused import rules in `__init__.py` files:
-
-```toml
-[tool.ruff]
-select = ["E", "F"]
-
-# Never enforce `E501`.
-ignore = ["E501"]
-
-# Ignore `F401` violations in any `__init__.py` file, and in `path/to/file.py`.
-per-file-ignores = {"__init__.py" = ["F401"], "path/to/file.py" = ["F401"]}
-```
-
-Plugin configurations should be expressed as subsections, e.g.:
-
-```toml
-[tool.ruff]
-# Add "Q" to the list of enabled codes.
-select = ["E", "F", "Q"]
-
-[tool.ruff.flake8-quotes]
-docstring-quotes = "double"
-```
-
-Alternatively, common configuration settings can be provided via the command-line:
+Alternatively, on the command-line:
 
 ```shell
 ruff path/to/code/ --select F401 --select F403
@@ -191,19 +94,15 @@ Arguments:
   <FILES>...
 
 Options:
-      --config <CONFIG>
-          Path to the `pyproject.toml` file to use for configuration
   -v, --verbose
           Enable verbose logging
   -q, --quiet
-          Only log errors
-  -s, --silent
           Disable all logging (but still exit with status code "1" upon detecting errors)
   -e, --exit-zero
           Exit with status code "0", even upon detecting errors
   -w, --watch
           Run in watch mode by re-running whenever files change
-      --fix
+  -f, --fix
           Attempt to automatically fix lint errors
   -n, --no-cache
           Disable cache reads
@@ -231,10 +130,6 @@ Options:
           Enable automatic additions of noqa directives to failing lines
       --dummy-variable-rgx <DUMMY_VARIABLE_RGX>
           Regular expression matching the name of dummy variables
-      --target-version <TARGET_VERSION>
-          The minimum Python version that should be supported
-      --stdin-filename <STDIN_FILENAME>
-          The name of the file when passing it through stdin
   -h, --help
           Print help information
   -V, --version
@@ -257,7 +152,7 @@ Exclusions are based on globs, and can be either:
 To omit a lint check entirely, add it to the "ignore" list via `--ignore` or `--extend-ignore`,
 either  on the command-line or in your `project.toml` file.
 
-To ignore an error in-line, Ruff uses a `noqa` system similar to [Flake8](https://flake8.pycqa.org/en/3.1.1/user/ignoring-errors.html).
+To ignore an error in-line, ruff uses a `noqa` system similar to [Flake8](https://flake8.pycqa.org/en/3.1.1/user/ignoring-errors.html).
 To ignore an individual error, add `# noqa: {code}` to the end of the line, like so:
 
 ```python
@@ -281,303 +176,129 @@ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor i
 """  # noqa: E501
 ```
 
-Ruff supports several workflows to aid in `noqa` management.
+ruff supports several (experimental) workflows to aid in `noqa` management.
 
-First, Ruff provides a special error code, `M001`, to enforce that your `noqa` directives are
+First, ruff provides a special error code, `M001`, to enforce that your `noqa` directives are
 "valid", in that the errors they _say_ they ignore are actually being triggered on that line (and
 thus suppressed). **You can run `ruff /path/to/file.py --extend-select M001` to flag unused `noqa`
 directives.**
 
-Second, Ruff can _automatically remove_ unused `noqa` directives via its autofix functionality.
+Second, ruff can _automatically remove_ unused `noqa` directives via its autofix functionality.
 **You can run `ruff /path/to/file.py --extend-select M001 --fix` to automatically remove unused
 `noqa` directives.**
 
-Third, Ruff can _automatically add_ `noqa` directives to all failing lines. This is useful when
-migrating a new codebase to Ruff. **You can run `ruff /path/to/file.py --add-noqa` to automatically
+Third, ruff can _automatically add_ `noqa` directives to all failing lines. This is useful when
+migrating a new codebase to ruff. **You can run `ruff /path/to/file.py --add-noqa` to automatically
 add `noqa` directives to all failing lines, with the appropriate error codes.**
 
-## Supported Rules
+### Compatibility with Black
 
-Regardless of the rule's origin, Ruff re-implements every rule in Rust as a first-party feature.
+ruff is compatible with [Black](https://github.com/psf/black) out-of-the-box, as long as
+the `line-length` setting is consistent between the two.
 
-By default, Ruff enables all `E` and `F` error codes, which correspond to those built-in to Flake8.
+As a project, ruff is designed to be used alongside Black and, as such, will defer implementing
+stylistic lint rules that are obviated by autoformatting.
+
+### Parity with Flake8
+
+ruff's goal is to achieve feature parity with Flake8 when used (1) without plugins, (2) alongside
+Black, and (3) on Python 3 code.
+
+**Under those conditions, ruff implements 44 out of 60 rules.** (ruff is missing: 14 rules related
+to string `.format` calls, 1 rule related to docstring parsing, and 1 rule related to redefined
+variables.)
+
+ruff also implements some of the most popular Flake8 plugins natively, including:
+
+- [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
+- [`flake8-super`](https://pypi.org/project/flake8-super/)
+- [`flake8-print`](https://pypi.org/project/flake8-print/)
+- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (partial)
+
+Beyond rule-set parity, ruff suffers from the following limitations vis-à-vis Flake8:
+
+1. ruff does not yet support a few Python 3.9 and 3.10 language features, including structural
+   pattern matching and parenthesized context managers.
+2. Flake8 has a plugin architecture and supports writing custom lint rules.
+
+## Rules
+
+The ✅ emoji indicates a rule is enabled by default.
 
 The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` command-line option.
 
-<!-- Sections automatically generated by `cargo dev generate-rules-table`. -->
-<!-- Begin auto-generated sections. -->
+| 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 | IOError: `...` | ✅ |  |
+| E999 | SyntaxError | SyntaxError: `...` | ✅ |  |
+| F401 | UnusedImport | `...` imported but unused | ✅ | 🛠 |
+| F402 | ImportShadowedByLoopVar | Import `...` from line 1 shadowed by loop variable | ✅ |  |
+| F403 | ImportStarUsed | `from ... import *` used; unable to detect undefined names | ✅ |  |
+| F404 | LateFutureImport | `from __future__` imports must occur at the beginning of the file | ✅ |  |
+| F405 | ImportStarUsage | `...` may be undefined, or defined from star imports: `...` | ✅ |  |
+| 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 | ExpressionsInStarAssignment | 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 `==` and `!=` 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 | `yield` or `yield from` statement outside of a function/method | ✅ |  |
+| F706 | ReturnOutsideFunction | `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` | ✅ |  |
+| A001 | BuiltinVariableShadowing | Variable `...` is shadowing a python builtin |  |  |
+| A002 | BuiltinArgumentShadowing | Argument `...` is shadowing a python builtin |  |  |
+| A003 | BuiltinAttributeShadowing | Class attribute `...` is shadowing a python builtin |  |  |
+| SPR001 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` |  | 🛠 |
+| T201 | PrintFound | `print` found |  | 🛠 |
+| T203 | PPrintFound | `pprint` found |  | 🛠 |
+| U001 | UselessMetaclassType | `__metaclass__ = type` is implied |  | 🛠 |
+| R001 | UselessObjectInheritance | Class `...` inherits from object |  | 🛠 |
+| R002 | NoAssertEquals | `assertEquals` is deprecated, use `assertEqual` instead |  | 🛠 |
+| M001 | UnusedNOQA | Unused `noqa` directive |  | 🛠 |
 
-### Pyflakes
-
-For more, see [Pyflakes](https://pypi.org/project/pyflakes/2.5.0/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| F401 | UnusedImport | `...` imported but unused | 🛠 |
-| F402 | ImportShadowedByLoopVar | Import `...` from line 1 shadowed by loop variable |  |
-| F403 | ImportStarUsed | `from ... import *` used; unable to detect undefined names |  |
-| F404 | LateFutureImport | `from __future__` imports must occur at the beginning of the file |  |
-| F405 | ImportStarUsage | `...` may be undefined, or defined from star imports: `...` |  |
-| 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 | ExpressionsInStarAssignment | 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 `==` and `!=` 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 | `yield` or `yield from` statement outside of a function |  |
-| F706 | ReturnOutsideFunction | `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` | 🛠 |
-
-### pycodestyle
-
-For more, see [pycodestyle](https://pypi.org/project/pycodestyle/2.9.1/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| 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 | IOError: `...` |  |
-| E999 | SyntaxError | SyntaxError: `...` |  |
-| W292 | NoNewLineAtEndOfFile | No newline at end of file |  |
-| W605 | InvalidEscapeSequence | Invalid escape sequence: '\c' |  |
-
-### pydocstyle
-
-For more, see [pydocstyle](https://pypi.org/project/pydocstyle/6.1.1/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| D100 | PublicModule | Missing docstring in public module |  |
-| D101 | PublicClass | Missing docstring in public class |  |
-| D102 | PublicMethod | Missing docstring in public method |  |
-| D103 | PublicFunction | Missing docstring in public function |  |
-| D104 | PublicPackage | Missing docstring in public package |  |
-| D105 | MagicMethod | Missing docstring in magic method |  |
-| D106 | PublicNestedClass | Missing docstring in public nested class |  |
-| D107 | PublicInit | Missing docstring in `__init__` |  |
-| D200 | FitsOnOneLine | One-line docstring should fit on one line |  |
-| D201 | NoBlankLineBeforeFunction | No blank lines allowed before function docstring (found 1) | 🛠 |
-| D202 | NoBlankLineAfterFunction | No blank lines allowed after function docstring (found 1) | 🛠 |
-| D203 | OneBlankLineBeforeClass | 1 blank line required before class docstring | 🛠 |
-| D204 | OneBlankLineAfterClass | 1 blank line required after class docstring | 🛠 |
-| D205 | BlankLineAfterSummary | 1 blank line required between summary line and description | 🛠 |
-| D206 | IndentWithSpaces | Docstring should be indented with spaces, not tabs |  |
-| D207 | NoUnderIndentation | Docstring is under-indented | 🛠 |
-| D208 | NoOverIndentation | Docstring is over-indented | 🛠 |
-| D209 | NewLineAfterLastParagraph | Multi-line docstring closing quotes should be on a separate line | 🛠 |
-| D210 | NoSurroundingWhitespace | No whitespaces allowed surrounding docstring text | 🛠 |
-| D211 | NoBlankLineBeforeClass | No blank lines allowed before class docstring | 🛠 |
-| D212 | MultiLineSummaryFirstLine | Multi-line docstring summary should start at the first line |  |
-| D213 | MultiLineSummarySecondLine | Multi-line docstring summary should start at the second line |  |
-| D214 | SectionNotOverIndented | Section is over-indented ("Returns") | 🛠 |
-| D215 | SectionUnderlineNotOverIndented | Section underline is over-indented ("Returns") | 🛠 |
-| D300 | UsesTripleQuotes | Use """triple double quotes""" |  |
-| D400 | EndsInPeriod | First line should end with a period |  |
-| D402 | NoSignature | First line should not be the function's signature |  |
-| D403 | FirstLineCapitalized | First word of the first line should be properly capitalized |  |
-| D404 | NoThisPrefix | First word of the docstring should not be 'This' |  |
-| D405 | CapitalizeSectionName | Section name should be properly capitalized ("returns") | 🛠 |
-| D406 | NewLineAfterSectionName | Section name should end with a newline ("Returns") | 🛠 |
-| D407 | DashedUnderlineAfterSection | Missing dashed underline after section ("Returns") | 🛠 |
-| D408 | SectionUnderlineAfterName | Section underline should be in the line following the section's name ("Returns") | 🛠 |
-| D409 | SectionUnderlineMatchesSectionLength | Section underline should match the length of its name ("Returns") | 🛠 |
-| D410 | BlankLineAfterSection | Missing blank line after section ("Returns") | 🛠 |
-| D411 | BlankLineBeforeSection | Missing blank line before section ("Returns") | 🛠 |
-| D412 | NoBlankLinesBetweenHeaderAndContent | No blank lines allowed between a section header and its content ("Returns") | 🛠 |
-| D413 | BlankLineAfterLastSection | Missing blank line after last section ("Returns") | 🛠 |
-| D414 | NonEmptySection | Section has no content ("Returns") |  |
-| D415 | EndsInPunctuation | First line should end with a period, question mark, or exclamation point |  |
-| D416 | SectionNameEndsInColon | Section name should end with a colon ("Returns") | 🛠 |
-| D417 | DocumentAllArguments | Missing argument descriptions in the docstring: `x`, `y` |  |
-| D418 | SkipDocstring | Function decorated with `@overload` shouldn't contain a docstring |  |
-| D419 | NonEmpty | Docstring is empty |  |
-
-### pyupgrade
-
-For more, see [pyupgrade](https://pypi.org/project/pyupgrade/3.2.0/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| U001 | UselessMetaclassType | `__metaclass__ = type` is implied | 🛠 |
-| U002 | UnnecessaryAbspath | `abspath(__file__)` is unnecessary in Python 3.9 and later | 🛠 |
-| U003 | TypeOfPrimitive | Use `str` instead of `type(...)` | 🛠 |
-| U004 | UselessObjectInheritance | Class `...` inherits from object | 🛠 |
-| U005 | DeprecatedUnittestAlias | `assertEquals` is deprecated, use `assertEqual` instead | 🛠 |
-| U006 | UsePEP585Annotation | Use `list` instead of `List` for type annotations | 🛠 |
-| U007 | UsePEP604Annotation | Use `X \| Y` for type annotations | 🛠 |
-| U008 | SuperCallWithParameters | Use `super()` instead of `super(__class__, self)` | 🛠 |
-| U009 | PEP3120UnnecessaryCodingComment | utf-8 encoding declaration is unnecessary | 🛠 |
-
-### pep8-naming
-
-For more, see [pep8-naming](https://pypi.org/project/pep8-naming/0.13.2/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| N801 | InvalidClassName | Class name `...` should use CapWords convention  |  |
-| N802 | InvalidFunctionName | Function name `...` should be lowercase |  |
-| N803 | InvalidArgumentName | Argument name `...` should be lowercase |  |
-| N804 | InvalidFirstArgumentNameForClassMethod | First argument of a class method should be named `cls` |  |
-| N805 | InvalidFirstArgumentNameForMethod | First argument of a method should be named `self` |  |
-| N806 | NonLowercaseVariableInFunction | Variable `...` in function should be lowercase |  |
-| N807 | DunderFunctionName | Function name should not start and end with `__` |  |
-| N811 | ConstantImportedAsNonConstant | Constant `...` imported as non-constant `...` |  |
-| N812 | LowercaseImportedAsNonLowercase | Lowercase `...` imported as non-lowercase `...` |  |
-| N813 | CamelcaseImportedAsLowercase | Camelcase `...` imported as lowercase `...` |  |
-| N814 | CamelcaseImportedAsConstant | Camelcase `...` imported as constant `...` |  |
-| N815 | MixedCaseVariableInClassScope | Variable `mixedCase` in class scope should not be mixedCase |  |
-| N816 | MixedCaseVariableInGlobalScope | Variable `mixedCase` in global scope should not be mixedCase |  |
-| N817 | CamelcaseImportedAsAcronym | Camelcase `...` imported as acronym `...` |  |
-| N818 | ErrorSuffixOnExceptionName | Exception name `...` should be named with an Error suffix |  |
-
-### flake8-comprehensions
-
-For more, see [flake8-comprehensions](https://pypi.org/project/flake8-comprehensions/3.10.1/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| C400 | UnnecessaryGeneratorList | Unnecessary generator (rewrite as a `list` comprehension) | 🛠 |
-| C401 | UnnecessaryGeneratorSet | Unnecessary generator (rewrite as a `set` comprehension) | 🛠 |
-| C402 | UnnecessaryGeneratorDict | Unnecessary generator (rewrite as a `dict` comprehension) | 🛠 |
-| C403 | UnnecessaryListComprehensionSet | Unnecessary `list` comprehension (rewrite as a `set` comprehension) | 🛠 |
-| C404 | UnnecessaryListComprehensionDict | Unnecessary `list` comprehension (rewrite as a `dict` comprehension) |  |
-| C405 | UnnecessaryLiteralSet | Unnecessary `(list\|tuple)` literal (rewrite as a `set` literal) | 🛠 |
-| C406 | UnnecessaryLiteralDict | Unnecessary `(list\|tuple)` literal (rewrite as a `dict` literal) | 🛠 |
-| C408 | UnnecessaryCollectionCall | Unnecessary `(dict\|list\|tuple)` call (rewrite as a literal) | 🛠 |
-| C409 | UnnecessaryLiteralWithinTupleCall | Unnecessary `(list\|tuple)` literal passed to `tuple()` (remove the outer call to `tuple()`) | 🛠 |
-| C410 | UnnecessaryLiteralWithinListCall | Unnecessary `(list\|tuple)` literal passed to `list()` (rewrite as a `list` literal) | 🛠 |
-| C411 | UnnecessaryListCall | Unnecessary `list` call (remove the outer call to `list()`) | 🛠 |
-| C413 | UnnecessaryCallAroundSorted | Unnecessary `(list\|reversed)` call around `sorted()` |  |
-| C414 | UnnecessaryDoubleCastOrProcess | Unnecessary `(list\|reversed\|set\|sorted\|tuple)` call within `(list\|set\|sorted\|tuple)()` |  |
-| C415 | UnnecessarySubscriptReversal | Unnecessary subscript reversal of iterable within `(reversed\|set\|sorted)()` |  |
-| C416 | UnnecessaryComprehension | Unnecessary `(list\|set)` comprehension (rewrite using `(list\|set)()`) | 🛠 |
-| C417 | UnnecessaryMap | Unnecessary `map` usage (rewrite using a `(list\|set\|dict)` comprehension) |  |
-
-### flake8-bugbear
-
-For more, see [flake8-bugbear](https://pypi.org/project/flake8-bugbear/22.10.27/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| B002 | UnaryPrefixIncrement | Python does not support the unary prefix increment. |  |
-| B003 | AssignmentToOsEnviron | Assigning to `os.environ` doesn't clear the environment. |  |
-| B004 | UnreliableCallableCheck |  Using `hasattr(x, '__call__')` to test if x is callable is unreliable. Use `callable(x)` for consistent results. |  |
-| B005 | StripWithMultiCharacters | Using `.strip()` with multi-character strings is misleading the reader. |  |
-| B006 | MutableArgumentDefault | Do not use mutable data structures for argument defaults. |  |
-| B007 | UnusedLoopControlVariable | Loop control variable `i` not used within the loop body. | 🛠 |
-| B008 | FunctionCallArgumentDefault | Do not perform function calls in argument defaults. |  |
-| B011 | DoNotAssertFalse | Do not `assert False` (`python -O` removes these calls), raise `AssertionError()` | 🛠 |
-| B013 | RedundantTupleInExceptionHandler | A length-one tuple literal is redundant. Write `except ValueError:` instead of `except (ValueError,):`. |  |
-| B014 | DuplicateHandlerException | Exception handler with duplicate exception: `ValueError` | 🛠 |
-| B015 | UselessComparison | Pointless comparison. This comparison does nothing but waste CPU instructions. Either prepend `assert` or remove it. |  |
-| B016 | CannotRaiseLiteral | Cannot raise a literal. Did you intend to return it or raise an Exception? |  |
-| B017 | NoAssertRaisesException | `assertRaises(Exception):` should be considered evil. |  |
-| B018 | UselessExpression | Found useless expression. Either assign it to a variable or remove it. |  |
-| B025 | DuplicateTryBlockException | try-except block with duplicate exception `Exception` |  |
-
-### flake8-builtins
-
-For more, see [flake8-builtins](https://pypi.org/project/flake8-builtins/2.0.1/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| A001 | BuiltinVariableShadowing | Variable `...` is shadowing a python builtin |  |
-| A002 | BuiltinArgumentShadowing | Argument `...` is shadowing a python builtin |  |
-| A003 | BuiltinAttributeShadowing | Class attribute `...` is shadowing a python builtin |  |
-
-### flake8-print
-
-For more, see [flake8-print](https://pypi.org/project/flake8-print/5.0.0/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| T201 | PrintFound | `print` found | 🛠 |
-| T203 | PPrintFound | `pprint` found | 🛠 |
-
-### flake8-quotes
-
-For more, see [flake8-quotes](https://pypi.org/project/flake8-quotes/3.3.1/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| Q000 | BadQuotesInlineString | Single quotes found but double quotes preferred |  |
-| Q001 | BadQuotesMultilineString | Single quote multiline found but double quotes preferred |  |
-| Q002 | BadQuotesDocstring | Single quote docstring found but double quotes preferred |  |
-| Q003 | AvoidQuoteEscape | Change outer quotes to avoid escaping inner quotes |  |
-
-### flake8-annotations
-
-For more, see [flake8-annotations](https://pypi.org/project/flake8-annotations/2.9.1/) on PyPI.
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| ANN001 | MissingTypeFunctionArgument | Missing type annotation for function argument |  |
-| ANN002 | MissingTypeArgs | Missing type annotation for `*args` |  |
-| ANN003 | MissingTypeKwargs | Missing type annotation for `**kwargs` |  |
-| ANN101 | MissingTypeSelf | Missing type annotation for `self` in method |  |
-| ANN102 | MissingTypeCls | Missing type annotation for `cls` in classmethod |  |
-| ANN201 | MissingReturnTypePublicFunction | Missing return type annotation for public function |  |
-| ANN202 | MissingReturnTypePrivateFunction | Missing return type annotation for private function |  |
-| ANN204 | MissingReturnTypeMagicMethod | Missing return type annotation for magic method |  |
-| ANN205 | MissingReturnTypeStaticMethod | Missing return type annotation for staticmethod |  |
-| ANN206 | MissingReturnTypeClassMethod | Missing return type annotation for classmethod |  |
-
-### Ruff-specific rules
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| RUF001 | AmbiguousUnicodeCharacterString | String contains ambiguous unicode character '𝐁' (did you mean 'B'?) | 🛠 |
-| RUF002 | AmbiguousUnicodeCharacterDocstring | Docstring contains ambiguous unicode character '𝐁' (did you mean 'B'?) | 🛠 |
-
-### Meta rules
-
-| Code | Name | Message | Fix |
-| ---- | ---- | ------- | --- |
-| M001 | UnusedNOQA | Unused `noqa` directive | 🛠 |
-
-<!-- End auto-generated sections. -->
-
-## Editor Integrations
+## Integrations
 
 ### PyCharm
 
-Ruff can be installed as an [External Tool](https://www.jetbrains.com/help/pycharm/configuring-third-party-tools.html)
+ruff can be installed as an [External Tool](https://www.jetbrains.com/help/pycharm/configuring-third-party-tools.html)
 in PyCharm. Open the Preferences pane, then navigate to "Tools", then "External Tools". From there,
 add a new tool with the following configuration:
 
-![Install Ruff as an External Tool](https://user-images.githubusercontent.com/1309177/193155720-336e43f0-1a8d-46b4-bc12-e60f9ae01f7e.png)
+![Install ruff as an External Tool](https://user-images.githubusercontent.com/1309177/193155720-336e43f0-1a8d-46b4-bc12-e60f9ae01f7e.png)
 
-Ruff should then appear as a runnable action:
+ruff should then appear as a runnable action:
 
-![Ruff as a runnable action](https://user-images.githubusercontent.com/1309177/193156026-732b0aaf-3dd9-4549-9b4d-2de6d2168a33.png)
+![ruff as a runnable action](https://user-images.githubusercontent.com/1309177/193156026-732b0aaf-3dd9-4549-9b4d-2de6d2168a33.png)
 
 ### GitHub Actions
 
-GitHub Actions has everything you need to run Ruff out-of-the-box:
+GitHub Actions has everything you need to run ruff out-of-the-box:
 
 ```yaml
 name: CI
@@ -586,195 +307,40 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
       - name: Install Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v2
         with:
           python-version: "3.10"
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
           pip install ruff
-      - name: Run Ruff
+      - name: Run ruff
         run: ruff .
 ```
 
-## FAQ
-
-### Is Ruff compatible with Black?
-
-Yes. Ruff is compatible with [Black](https://github.com/psf/black) 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
-stylistic lint rules that are obviated by autoformatting.
-
-### How does Ruff compare to Flake8?
-
-(Coming from Flake8? Try [`flake8-to-ruff`](https://pypi.org/project/flake8-to-ruff/) to
-automatically convert your existing configuration.)
-
-Ruff can be used as a (near) drop-in replacement for Flake8 when used (1) without or with a small
-number of plugins, (2) alongside Black, and (3) on Python 3 code.
-
-Under those conditions Ruff is missing 14 rules related to string `.format` calls, 1 rule related
-to docstring parsing, and 1 rule related to redefined variables.
-
-Ruff re-implements some of the most popular Flake8 plugins and related code quality tools natively,
-including:
-
-- [`pydocstyle`](https://pypi.org/project/pydocstyle/)
-- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
-- [`yesqa`](https://github.com/asottile/yesqa)
-- [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
-- [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
-- [`flake8-super`](https://pypi.org/project/flake8-super/)
-- [`flake8-print`](https://pypi.org/project/flake8-print/)
-- [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
-- [`flake8-annotations`](https://pypi.org/project/flake8-annotations/)
-- [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (17/32)
-- [`pyupgrade`](https://pypi.org/project/pyupgrade/) (11/34)
-- [`autoflake`](https://pypi.org/project/autoflake/) (1/7)
-
-Beyond rule-set parity, Ruff suffers from the following limitations vis-à-vis Flake8:
-
-1. Ruff does not yet support a few Python 3.9 and 3.10 language features, including structural
-   pattern matching and parenthesized context managers.
-2. Flake8 has a plugin architecture and supports writing custom lint rules. (To date, popular Flake8
-   plugins have been re-implemented within Ruff directly.)
-
-### Which tools does Ruff replace?
-
-Today, Ruff can be used to replace Flake8 when used with any of the following plugins:
-
-- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
-- [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
-- [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
-- [`flake8-super`](https://pypi.org/project/flake8-super/)
-- [`flake8-print`](https://pypi.org/project/flake8-print/)
-- [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
-- [`flake8-annotations`](https://pypi.org/project/flake8-annotations/)
-- [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (17/32)
-
-Ruff also implements the functionality that you get from [`yesqa`](https://github.com/asottile/yesqa),
-and a subset of the rules implemented in [`pyupgrade`](https://pypi.org/project/pyupgrade/) (11/34).
-
-If you're looking to use Ruff, but rely on an unsupported Flake8 plugin, free to file an Issue.
-
-### Do I need to install Rust to use Ruff?
-
-Nope! Ruff is available as [`ruff`](https://pypi.org/project/ruff/) on PyPI:
-
-```shell
-pip install ruff
-```
-
-Ruff ships with wheels for all major platforms, which enables `pip` to install Ruff without relying
-on Rust at all.
-
-### Can I write my own plugins for Ruff?
-
-Ruff does not yet support third-party plugins, though a plugin system is within-scope for the
-project. See [#283](https://github.com/charliermarsh/ruff/issues/283) for more.
-
-### Does Ruff support NumPy- or Google-style docstrings?
-
-Yes! To enable a specific docstring convention, start by enabling all `pydocstyle` error codes, and
-then selectively disabling based on your [preferred convention](https://www.pydocstyle.org/en/latest/error_codes.html#default-conventions).
-
-For example, if you're coming from `flake8-docstrings`, the following configuration is equivalent to
-`--docstring-convention=numpy`:
-
-```toml
-[tool.ruff]
-extend-select = ["D"]
-extend-ignore = [
-    "D107",
-    "D203",
-    "D212",
-    "D213",
-    "D402",
-    "D413",
-    "D415",
-    "D416",
-    "D417",
-]
-```
-
-Similarly, the following is equivalent to `--docstring-convention=google`:
-
-```toml
-[tool.ruff]
-extend-select = ["D"]
-extend-ignore = [
-    "D203",
-    "D204",
-    "D213",
-    "D215",
-    "D400",
-    "D404",
-    "D406",
-    "D407",
-    "D408",
-    "D409",
-    "D413",
-]
-```
-
-Similarly, the following is equivalent to `--docstring-convention=pep8`:
-
-```toml
-[tool.ruff]
-extend-select = ["D"]
-extend-ignore = [
-    "D203",
-    "D212",
-    "D213",
-    "D214",
-    "D215",
-    "D404",
-    "D405",
-    "D406",
-    "D407",
-    "D408",
-    "D409",
-    "D410",
-    "D411",
-    "D413",
-    "D415",
-    "D416",
-    "D417",
-]
-```
-
 ## Development
 
-Ruff is written in Rust (1.65.0). You'll need to install the [Rust toolchain](https://www.rust-lang.org/tools/install)
+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.
 
 Assuming you have `cargo` installed, you can run:
 
 ```shell
 cargo run resources/test/fixtures
+cargo fmt
+cargo clippy
+cargo test
 ```
 
-For development, we use [nightly Rust](https://rust-lang.github.io/rustup/concepts/channels.html#working-with-nightly-rust):
+## Deployment
 
-```shell
-cargo +nightly fmt
-cargo +nightly clippy
-cargo +nightly test
-```
-
-## Releases
-
-Ruff is distributed on [PyPI](https://pypi.org/project/ruff/), and published via [`maturin`](https://github.com/PyO3/maturin).
+ruff is distributed on [PyPI](https://pypi.org/project/ruff/), and published via [`maturin`](https://github.com/PyO3/maturin).
 
 See: `.github/workflows/release.yaml`.
 
-## Benchmarks
+## Benchmarking
 
 First, clone [CPython](https://github.com/python/cpython). It's a large and diverse Python codebase,
 which makes it a good target for benchmarking.
@@ -851,9 +417,9 @@ hyperfine --ignore-failure --warmup 5 \
 
 In order, these evaluate:
 
-- Ruff
+- ruff
 - Pylint
-- Pyflakes
+- PyFlakes
 - autoflake
 - pycodestyle
 - Flake8

benches/source_code_locator.rs

@@ -1,18 +0,0 @@
-use std::path::Path;
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use ropey::Rope;
-use ruff::fs;
-
-fn criterion_benchmark(c: &mut Criterion) {
-    let contents = fs::read_file(Path::new("resources/test/fixtures/D.py")).unwrap();
-    c.bench_function("rope", |b| {
-        b.iter(|| {
-            let rope = Rope::from_str(black_box(&contents));
-            rope.line_to_char(black_box(4));
-        })
-    });
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);

examples/generate_rules_table.rs

@@ -0,0 +1,27 @@
+/// Generate a Markdown-compatible table of supported lint rules.
+use ruff::checks::{CheckCode, ALL_CHECK_CODES, DEFAULT_CHECK_CODES};
+
+fn main() {
+    let mut check_codes: Vec<CheckCode> = ALL_CHECK_CODES.to_vec();
+    check_codes.sort();
+
+    println!("| Code | Name | Message |     |     |");
+    println!("| ---- | ---- | ------- | --- | --- |");
+    for check_code in check_codes {
+        let check_kind = check_code.kind();
+        let default_token = if DEFAULT_CHECK_CODES.contains(&check_code) {
+            "✅"
+        } else {
+            ""
+        };
+        let fix_token = if check_kind.fixable() { "🛠" } else { "" };
+        println!(
+            "| {} | {} | {} | {} | {} |",
+            check_kind.code().as_str(),
+            check_kind.name(),
+            check_kind.body(),
+            default_token,
+            fix_token
+        );
+    }
+}

examples/generate_source_code.rs

@@ -1,25 +1,26 @@
-//! Run round-trip source code generation on a given Python file.
-
-use std::fs;
 use std::path::PathBuf;
 
 use anyhow::Result;
-use clap::Args;
-use ruff::code_gen::SourceGenerator;
+use clap::Parser;
 use rustpython_parser::parser;
 
-#[derive(Args)]
-pub struct Cli {
-    /// Python file to round-trip.
+use ruff::code_gen::SourceGenerator;
+use ruff::fs;
+
+#[derive(Debug, Parser)]
+struct Cli {
     #[arg(required = true)]
     file: PathBuf,
 }
 
-pub fn main(cli: &Cli) -> Result<()> {
-    let contents = fs::read_to_string(&cli.file)?;
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    let contents = fs::read_file(&cli.file)?;
     let python_ast = parser::parse_program(&contents, &cli.file.to_string_lossy())?;
     let mut generator = SourceGenerator::new();
     generator.unparse_suite(&python_ast)?;
     println!("{}", generator.generate()?);
+
     Ok(())
 }

examples/parse_python.rs

@@ -0,0 +1,23 @@
+/// Print the AST for a given Python file.
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+
+use ruff::fs;
+
+#[derive(Debug, Parser)]
+struct Cli {
+    #[arg(required = true)]
+    file: PathBuf,
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    let contents = fs::read_file(&cli.file)?;
+    let ast = python_parser::file_input(python_parser::make_strspan(&contents))?.1;
+    println!("{:?}", ast);
+
+    Ok(())
+}

examples/print_ast.rs

@@ -1,22 +1,25 @@
-//! Print the AST for a given Python file.
-
-use std::fs;
+/// Print the AST for a given Python file.
 use std::path::PathBuf;
 
 use anyhow::Result;
-use clap::Args;
+use clap::Parser;
 use rustpython_parser::parser;
 
-#[derive(Args)]
-pub struct Cli {
-    /// Python file for which to generate the AST.
+use ruff::fs;
+
+#[derive(Debug, Parser)]
+struct Cli {
     #[arg(required = true)]
     file: PathBuf,
 }
 
-pub fn main(cli: &Cli) -> Result<()> {
-    let contents = fs::read_to_string(&cli.file)?;
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    let contents = fs::read_file(&cli.file)?;
     let python_ast = parser::parse_program(&contents, &cli.file.to_string_lossy())?;
+
     println!("{:#?}", python_ast);
+
     Ok(())
 }

examples/print_tokens.rs

@@ -0,0 +1,25 @@
+/// Print the token stream for a given Python file.
+use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+use rustpython_parser::lexer;
+
+use ruff::fs;
+
+#[derive(Debug, Parser)]
+struct Cli {
+    #[arg(required = true)]
+    file: PathBuf,
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+
+    let contents = fs::read_file(&cli.file)?;
+    for (_, tok, _) in lexer::make_tokenizer(&contents).flatten() {
+        println!("{:#?}", tok);
+    }
+
+    Ok(())
+}

flake8_to_ruff/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-name = "flake8-to-ruff"
-version = "0.0.105-dev.0"
-edition = "2021"
-
-[lib]
-name = "flake8_to_ruff"
-
-[dependencies]
-anyhow = { version = "1.0.60" }
-clap = { version = "4.0.1", features = ["derive"] }
-configparser = { version = "3.0.2" }
-once_cell = { version = "1.13.1" }
-regex = { version = "1.6.0" }
-ruff = { path = "..", default-features = false }
-serde = { version = "1.0.143", features = ["derive"] }
-serde_json = { version = "1.0.83" }
-toml = { version = "0.5.9" }
-
-[dev-dependencies]
-
-[features]

flake8_to_ruff/README.md

@@ -1,98 +0,0 @@
-# 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.)
-2. Ruff will omit any error codes that are unimplemented or unsupported by Ruff, including error
-   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).

flake8_to_ruff/examples/poetry.ini

@@ -1,36 +0,0 @@
-[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/*,

flake8_to_ruff/examples/python-discord.ini

@@ -1,19 +0,0 @@
-[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

flake8_to_ruff/examples/requests.ini

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

flake8_to_ruff/pyproject.toml

@@ -1,33 +0,0 @@
-[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 :: 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.13,<0.14"]
-build-backend = "maturin"
-
-[tool.maturin]
-bindings = "bin"
-strip = true

flake8_to_ruff/src/converter.rs

@@ -1,455 +0,0 @@
-use std::collections::{BTreeSet, HashMap};
-
-use anyhow::Result;
-use ruff::checks_gen::CheckCodePrefix;
-use ruff::flake8_quotes::settings::Quote;
-use ruff::settings::options::Options;
-use ruff::settings::pyproject::Pyproject;
-use ruff::{flake8_annotations, flake8_quotes, pep8_naming};
-
-use crate::plugin::Plugin;
-use crate::{parser, plugin};
-
-pub fn convert(
-    flake8: &HashMap<String, Option<String>>,
-    plugins: Option<Vec<Plugin>>,
-) -> Result<Pyproject> {
-    // Extract all referenced check code prefixes, to power plugin inference.
-    let mut referenced_codes: BTreeSet<CheckCodePrefix> = Default::default();
-    for (key, value) in flake8 {
-        if let Some(value) = value {
-            match key.as_str() {
-                "select" | "ignore" | "extend-select" | "extend_select" | "extend-ignore"
-                | "extend_ignore" => {
-                    referenced_codes.extend(parser::parse_prefix_codes(value.as_ref()));
-                }
-                "per-file-ignores" | "per_file_ignores" => {
-                    if let Ok(per_file_ignores) =
-                        parser::parse_files_to_codes_mapping(value.as_ref())
-                    {
-                        for (_, codes) in parser::collect_per_file_ignores(per_file_ignores) {
-                            referenced_codes.extend(codes);
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
-    // Check if the user has specified a `select`. If not, we'll add our own
-    // default `select`, and populate it based on user plugins.
-    let mut select = flake8
-        .get("select")
-        .and_then(|value| {
-            value
-                .as_ref()
-                .map(|value| BTreeSet::from_iter(parser::parse_prefix_codes(value)))
-        })
-        .unwrap_or_else(|| {
-            plugin::resolve_select(
-                flake8,
-                &plugins.unwrap_or_else(|| {
-                    plugin::infer_plugins_from_options(flake8)
-                        .into_iter()
-                        .chain(plugin::infer_plugins_from_codes(&referenced_codes))
-                        .collect()
-                }),
-            )
-        });
-    let mut ignore = flake8
-        .get("ignore")
-        .and_then(|value| {
-            value
-                .as_ref()
-                .map(|value| BTreeSet::from_iter(parser::parse_prefix_codes(value)))
-        })
-        .unwrap_or_default();
-
-    // Parse each supported option.
-    let mut options: Options = Default::default();
-    let mut flake8_annotations: flake8_annotations::settings::Options = Default::default();
-    let mut flake8_quotes: flake8_quotes::settings::Options = Default::default();
-    let mut pep8_naming: pep8_naming::settings::Options = Default::default();
-    for (key, value) in flake8 {
-        if let Some(value) = value {
-            match key.as_str() {
-                // flake8
-                "max-line-length" | "max_line_length" => match value.clone().parse::<usize>() {
-                    Ok(line_length) => options.line_length = Some(line_length),
-                    Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
-                },
-                "select" => {
-                    // No-op (handled above).
-                    select.extend(parser::parse_prefix_codes(value.as_ref()));
-                }
-                "ignore" => {
-                    // No-op (handled above).
-                }
-                "extend-select" | "extend_select" => {
-                    // Unlike Flake8, use a single explicit `select`.
-                    select.extend(parser::parse_prefix_codes(value.as_ref()));
-                }
-                "extend-ignore" | "extend_ignore" => {
-                    // Unlike Flake8, use a single explicit `ignore`.
-                    ignore.extend(parser::parse_prefix_codes(value.as_ref()));
-                }
-                "exclude" => {
-                    options.exclude = Some(parser::parse_strings(value.as_ref()));
-                }
-                "extend-exclude" | "extend_exclude" => {
-                    options.extend_exclude = Some(parser::parse_strings(value.as_ref()));
-                }
-                "per-file-ignores" | "per_file_ignores" => {
-                    match parser::parse_files_to_codes_mapping(value.as_ref()) {
-                        Ok(per_file_ignores) => {
-                            options.per_file_ignores =
-                                Some(parser::collect_per_file_ignores(per_file_ignores))
-                        }
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
-                    }
-                }
-                // flake8-annotations
-                "suppress-none-returning" | "suppress_none_returning" => {
-                    match parser::parse_bool(value.as_ref()) {
-                        Ok(bool) => flake8_annotations.suppress_none_returning = Some(bool),
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
-                    }
-                }
-                "suppress-dummy-args" | "suppress_dummy_args" => {
-                    match parser::parse_bool(value.as_ref()) {
-                        Ok(bool) => flake8_annotations.suppress_dummy_args = Some(bool),
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
-                    }
-                }
-                "mypy-init-return" | "mypy_init_return" => {
-                    match parser::parse_bool(value.as_ref()) {
-                        Ok(bool) => flake8_annotations.mypy_init_return = Some(bool),
-                        Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
-                    }
-                }
-                // flake8-quotes
-                "quotes" | "inline-quotes" | "inline_quotes" => match value.trim() {
-                    "'" | "single" => flake8_quotes.inline_quotes = Some(Quote::Single),
-                    "\"" | "double" => flake8_quotes.inline_quotes = Some(Quote::Single),
-                    _ => eprintln!("Unexpected '{key}' value: {value}"),
-                },
-                "multiline-quotes" | "multiline_quotes" => match value.trim() {
-                    "'" | "single" => flake8_quotes.multiline_quotes = Some(Quote::Single),
-                    "\"" | "double" => flake8_quotes.multiline_quotes = Some(Quote::Single),
-                    _ => eprintln!("Unexpected '{key}' value: {value}"),
-                },
-                "docstring-quotes" | "docstring_quotes" => match value.trim() {
-                    "'" | "single" => flake8_quotes.docstring_quotes = Some(Quote::Single),
-                    "\"" | "double" => flake8_quotes.docstring_quotes = Some(Quote::Single),
-                    _ => eprintln!("Unexpected '{key}' value: {value}"),
-                },
-                "avoid-escape" | "avoid_escape" => match parser::parse_bool(value.as_ref()) {
-                    Ok(bool) => flake8_quotes.avoid_escape = Some(bool),
-                    Err(e) => eprintln!("Unable to parse '{key}' property: {e}"),
-                },
-                // pep8-naming
-                "ignore-names" | "ignore_names" => {
-                    pep8_naming.ignore_names = Some(parser::parse_strings(value.as_ref()));
-                }
-                "classmethod-decorators" | "classmethod_decorators" => {
-                    pep8_naming.classmethod_decorators =
-                        Some(parser::parse_strings(value.as_ref()));
-                }
-                "staticmethod-decorators" | "staticmethod_decorators" => {
-                    pep8_naming.staticmethod_decorators =
-                        Some(parser::parse_strings(value.as_ref()));
-                }
-                // flake8-docstrings
-                "docstring-convention" => {
-                    // No-op (handled above).
-                }
-                // Unknown
-                _ => eprintln!("Skipping unsupported property: {key}"),
-            }
-        }
-    }
-
-    // Deduplicate and sort.
-    options.select = Some(Vec::from_iter(select));
-    options.ignore = Some(Vec::from_iter(ignore));
-    if flake8_quotes != Default::default() {
-        options.flake8_quotes = Some(flake8_quotes);
-    }
-    if pep8_naming != Default::default() {
-        options.pep8_naming = Some(pep8_naming);
-    }
-
-    // Create the pyproject.toml.
-    Ok(Pyproject::new(options))
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashMap;
-
-    use anyhow::Result;
-    use ruff::checks_gen::CheckCodePrefix;
-    use ruff::flake8_quotes;
-    use ruff::settings::options::Options;
-    use ruff::settings::pyproject::Pyproject;
-
-    use crate::converter::convert;
-    use crate::plugin::Plugin;
-
-    #[test]
-    fn it_converts_empty() -> Result<()> {
-        let actual = convert(&HashMap::from([]), None)?;
-        let expected = Pyproject::new(Options {
-            line_length: None,
-            exclude: None,
-            extend_exclude: None,
-            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
-            ]),
-            extend_select: None,
-            ignore: Some(vec![]),
-            extend_ignore: None,
-            per_file_ignores: None,
-            dummy_variable_rgx: None,
-            target_version: None,
-            flake8_annotations: None,
-            flake8_quotes: None,
-            pep8_naming: None,
-        });
-        assert_eq!(actual, expected);
-
-        Ok(())
-    }
-
-    #[test]
-    fn it_converts_dashes() -> Result<()> {
-        let actual = convert(
-            &HashMap::from([("max-line-length".to_string(), Some("100".to_string()))]),
-            Some(vec![]),
-        )?;
-        let expected = Pyproject::new(Options {
-            line_length: Some(100),
-            exclude: None,
-            extend_exclude: None,
-            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
-            ]),
-            extend_select: None,
-            ignore: Some(vec![]),
-            extend_ignore: None,
-            per_file_ignores: None,
-            dummy_variable_rgx: None,
-            target_version: None,
-            flake8_annotations: None,
-            flake8_quotes: None,
-            pep8_naming: None,
-        });
-        assert_eq!(actual, expected);
-
-        Ok(())
-    }
-
-    #[test]
-    fn it_converts_underscores() -> Result<()> {
-        let actual = convert(
-            &HashMap::from([("max_line_length".to_string(), Some("100".to_string()))]),
-            Some(vec![]),
-        )?;
-        let expected = Pyproject::new(Options {
-            line_length: Some(100),
-            exclude: None,
-            extend_exclude: None,
-            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
-            ]),
-            extend_select: None,
-            ignore: Some(vec![]),
-            extend_ignore: None,
-            per_file_ignores: None,
-            dummy_variable_rgx: None,
-            target_version: None,
-            flake8_annotations: None,
-            flake8_quotes: None,
-            pep8_naming: None,
-        });
-        assert_eq!(actual, expected);
-
-        Ok(())
-    }
-
-    #[test]
-    fn it_ignores_parse_errors() -> Result<()> {
-        let actual = convert(
-            &HashMap::from([("max_line_length".to_string(), Some("abc".to_string()))]),
-            Some(vec![]),
-        )?;
-        let expected = Pyproject::new(Options {
-            line_length: None,
-            exclude: None,
-            extend_exclude: None,
-            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
-            ]),
-            extend_select: None,
-            ignore: Some(vec![]),
-            extend_ignore: None,
-            per_file_ignores: None,
-            dummy_variable_rgx: None,
-            target_version: None,
-            flake8_annotations: None,
-            flake8_quotes: None,
-            pep8_naming: None,
-        });
-        assert_eq!(actual, expected);
-
-        Ok(())
-    }
-
-    #[test]
-    fn it_converts_plugin_options() -> Result<()> {
-        let actual = convert(
-            &HashMap::from([("inline-quotes".to_string(), Some("single".to_string()))]),
-            Some(vec![]),
-        )?;
-        let expected = Pyproject::new(Options {
-            line_length: None,
-            exclude: None,
-            extend_exclude: None,
-            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
-            ]),
-            extend_select: None,
-            ignore: Some(vec![]),
-            extend_ignore: None,
-            per_file_ignores: None,
-            dummy_variable_rgx: None,
-            target_version: None,
-            flake8_annotations: None,
-            flake8_quotes: Some(flake8_quotes::settings::Options {
-                inline_quotes: Some(flake8_quotes::settings::Quote::Single),
-                multiline_quotes: None,
-                docstring_quotes: None,
-                avoid_escape: None,
-            }),
-            pep8_naming: None,
-        });
-        assert_eq!(actual, expected);
-
-        Ok(())
-    }
-
-    #[test]
-    fn it_converts_docstring_conventions() -> Result<()> {
-        let actual = convert(
-            &HashMap::from([(
-                "docstring-convention".to_string(),
-                Some("numpy".to_string()),
-            )]),
-            Some(vec![Plugin::Flake8Docstrings]),
-        )?;
-        let expected = Pyproject::new(Options {
-            line_length: None,
-            exclude: None,
-            extend_exclude: None,
-            select: Some(vec![
-                CheckCodePrefix::D100,
-                CheckCodePrefix::D101,
-                CheckCodePrefix::D102,
-                CheckCodePrefix::D103,
-                CheckCodePrefix::D104,
-                CheckCodePrefix::D105,
-                CheckCodePrefix::D106,
-                CheckCodePrefix::D200,
-                CheckCodePrefix::D201,
-                CheckCodePrefix::D202,
-                CheckCodePrefix::D204,
-                CheckCodePrefix::D205,
-                CheckCodePrefix::D206,
-                CheckCodePrefix::D207,
-                CheckCodePrefix::D208,
-                CheckCodePrefix::D209,
-                CheckCodePrefix::D210,
-                CheckCodePrefix::D211,
-                CheckCodePrefix::D214,
-                CheckCodePrefix::D215,
-                CheckCodePrefix::D300,
-                CheckCodePrefix::D400,
-                CheckCodePrefix::D403,
-                CheckCodePrefix::D404,
-                CheckCodePrefix::D405,
-                CheckCodePrefix::D406,
-                CheckCodePrefix::D407,
-                CheckCodePrefix::D408,
-                CheckCodePrefix::D409,
-                CheckCodePrefix::D410,
-                CheckCodePrefix::D411,
-                CheckCodePrefix::D412,
-                CheckCodePrefix::D414,
-                CheckCodePrefix::D418,
-                CheckCodePrefix::D419,
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::W,
-            ]),
-            extend_select: None,
-            ignore: Some(vec![]),
-            extend_ignore: None,
-            per_file_ignores: None,
-            dummy_variable_rgx: None,
-            target_version: None,
-            flake8_annotations: None,
-            flake8_quotes: None,
-            pep8_naming: None,
-        });
-        assert_eq!(actual, expected);
-
-        Ok(())
-    }
-
-    #[test]
-    fn it_infers_plugins_if_omitted() -> Result<()> {
-        let actual = convert(
-            &HashMap::from([("inline-quotes".to_string(), Some("single".to_string()))]),
-            None,
-        )?;
-        let expected = Pyproject::new(Options {
-            line_length: None,
-            exclude: None,
-            extend_exclude: None,
-            select: Some(vec![
-                CheckCodePrefix::E,
-                CheckCodePrefix::F,
-                CheckCodePrefix::Q,
-                CheckCodePrefix::W,
-            ]),
-            extend_select: None,
-            ignore: Some(vec![]),
-            extend_ignore: None,
-            per_file_ignores: None,
-            dummy_variable_rgx: None,
-            target_version: None,
-            flake8_annotations: None,
-            flake8_quotes: Some(flake8_quotes::settings::Options {
-                inline_quotes: Some(flake8_quotes::settings::Quote::Single),
-                multiline_quotes: None,
-                docstring_quotes: None,
-                avoid_escape: None,
-            }),
-            pep8_naming: None,
-        });
-        assert_eq!(actual, expected);
-
-        Ok(())
-    }
-}

flake8_to_ruff/src/lib.rs

@@ -1,5 +0,0 @@
-#![allow(clippy::collapsible_if, clippy::collapsible_else_if)]
-
-pub mod converter;
-mod parser;
-pub mod plugin;

flake8_to_ruff/src/main.rs

@@ -1,44 +0,0 @@
-//! 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 flake8_to_ruff::converter;
-use flake8_to_ruff::plugin::Plugin;
-
-#[derive(Parser)]
-#[command(
-    about = "Convert existing Flake8 configuration to Ruff.",
-    long_about = None
-)]
-struct Cli {
-    /// Path to the Flake8 configuration file (e.g., 'setup.cfg', 'tox.ini', or
-    /// '.flake8').
-    #[arg(required = true)]
-    file: PathBuf,
-    /// List of plugins to enable.
-    #[arg(long, value_delimiter = ',')]
-    plugin: Option<Vec<Plugin>>,
-}
-
-fn main() -> Result<()> {
-    let cli = Cli::parse();
-
-    // Read the INI file.
-    let mut ini = Ini::new_cs();
-    ini.set_multiline(true);
-    let config = ini.load(cli.file).map_err(|msg| anyhow::anyhow!(msg))?;
-
-    // Extract the Flake8 section.
-    let flake8 = config
-        .get("flake8")
-        .expect("Unable to find flake8 section in INI file.");
-
-    // Create the pyproject.toml.
-    let pyproject = converter::convert(flake8, cli.plugin)?;
-    println!("{}", toml::to_string_pretty(&pyproject)?);
-
-    Ok(())
-}

flake8_to_ruff/src/parser.rs

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

flake8_to_ruff/src/plugin.rs

@@ -1,396 +0,0 @@
-use std::collections::{BTreeSet, HashMap};
-use std::str::FromStr;
-
-use anyhow::anyhow;
-use ruff::checks_gen::CheckCodePrefix;
-
-#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
-pub enum Plugin {
-    Flake8Bugbear,
-    Flake8Builtins,
-    Flake8Comprehensions,
-    Flake8Docstrings,
-    Flake8Print,
-    Flake8Quotes,
-    Flake8Annotations,
-    PEP8Naming,
-    Pyupgrade,
-}
-
-impl FromStr for Plugin {
-    type Err = anyhow::Error;
-
-    fn from_str(string: &str) -> Result<Self, Self::Err> {
-        match string {
-            "flake8-bugbear" => Ok(Plugin::Flake8Bugbear),
-            "flake8-builtins" => Ok(Plugin::Flake8Builtins),
-            "flake8-comprehensions" => Ok(Plugin::Flake8Comprehensions),
-            "flake8-docstrings" => Ok(Plugin::Flake8Docstrings),
-            "flake8-print" => Ok(Plugin::Flake8Print),
-            "flake8-quotes" => Ok(Plugin::Flake8Quotes),
-            "flake8-annotations" => Ok(Plugin::Flake8Annotations),
-            "pep8-naming" => Ok(Plugin::PEP8Naming),
-            "pyupgrade" => Ok(Plugin::Pyupgrade),
-            _ => Err(anyhow!("Unknown plugin: {}", string)),
-        }
-    }
-}
-
-impl Plugin {
-    pub fn default(&self) -> CheckCodePrefix {
-        match self {
-            Plugin::Flake8Bugbear => CheckCodePrefix::B,
-            Plugin::Flake8Builtins => CheckCodePrefix::A,
-            Plugin::Flake8Comprehensions => CheckCodePrefix::C,
-            Plugin::Flake8Docstrings => CheckCodePrefix::D,
-            Plugin::Flake8Print => CheckCodePrefix::T,
-            Plugin::Flake8Quotes => CheckCodePrefix::Q,
-            Plugin::Flake8Annotations => CheckCodePrefix::ANN,
-            Plugin::PEP8Naming => CheckCodePrefix::N,
-            Plugin::Pyupgrade => CheckCodePrefix::U,
-        }
-    }
-
-    pub fn select(&self, flake8: &HashMap<String, Option<String>>) -> Vec<CheckCodePrefix> {
-        match self {
-            Plugin::Flake8Bugbear => vec![CheckCodePrefix::B],
-            Plugin::Flake8Builtins => vec![CheckCodePrefix::A],
-            Plugin::Flake8Comprehensions => vec![CheckCodePrefix::C],
-            Plugin::Flake8Docstrings => {
-                // Use the user-provided docstring.
-                for key in ["docstring-convention", "docstring_convention"] {
-                    if let Some(Some(value)) = flake8.get(key) {
-                        match DocstringConvention::from_str(value) {
-                            Ok(convention) => return convention.select(),
-                            Err(e) => {
-                                eprintln!("Unexpected '{key}' value: {value} ({e}");
-                                return vec![];
-                            }
-                        }
-                    }
-                }
-                // Default to PEP8.
-                DocstringConvention::PEP8.select()
-            }
-            Plugin::Flake8Print => vec![CheckCodePrefix::T],
-            Plugin::Flake8Quotes => vec![CheckCodePrefix::Q],
-            Plugin::Flake8Annotations => vec![CheckCodePrefix::ANN],
-            Plugin::PEP8Naming => vec![CheckCodePrefix::N],
-            Plugin::Pyupgrade => vec![CheckCodePrefix::U],
-        }
-    }
-}
-
-pub enum DocstringConvention {
-    All,
-    PEP8,
-    NumPy,
-    Google,
-}
-
-impl FromStr for DocstringConvention {
-    type Err = anyhow::Error;
-
-    fn from_str(string: &str) -> Result<Self, Self::Err> {
-        match string {
-            "all" => Ok(DocstringConvention::All),
-            "pep8" => Ok(DocstringConvention::PEP8),
-            "numpy" => Ok(DocstringConvention::NumPy),
-            "google" => Ok(DocstringConvention::Google),
-            _ => Err(anyhow!("Unknown docstring convention: {}", string)),
-        }
-    }
-}
-
-impl DocstringConvention {
-    fn select(&self) -> Vec<CheckCodePrefix> {
-        match self {
-            DocstringConvention::All => vec![CheckCodePrefix::D],
-            DocstringConvention::PEP8 => vec![
-                // All errors except D203, D212, D213, D214, D215, D404, D405, D406, D407, D408,
-                // D409, D410, D411, D413, D415, D416 and D417.
-                CheckCodePrefix::D100,
-                CheckCodePrefix::D101,
-                CheckCodePrefix::D102,
-                CheckCodePrefix::D103,
-                CheckCodePrefix::D104,
-                CheckCodePrefix::D105,
-                CheckCodePrefix::D106,
-                CheckCodePrefix::D107,
-                CheckCodePrefix::D200,
-                CheckCodePrefix::D201,
-                CheckCodePrefix::D202,
-                // CheckCodePrefix::D203,
-                CheckCodePrefix::D204,
-                CheckCodePrefix::D205,
-                CheckCodePrefix::D206,
-                CheckCodePrefix::D207,
-                CheckCodePrefix::D208,
-                CheckCodePrefix::D209,
-                CheckCodePrefix::D210,
-                CheckCodePrefix::D211,
-                // CheckCodePrefix::D212,
-                // CheckCodePrefix::D213,
-                // CheckCodePrefix::D214,
-                // CheckCodePrefix::D215,
-                CheckCodePrefix::D300,
-                CheckCodePrefix::D400,
-                CheckCodePrefix::D402,
-                CheckCodePrefix::D403,
-                // CheckCodePrefix::D404,
-                // CheckCodePrefix::D405,
-                // CheckCodePrefix::D406,
-                // CheckCodePrefix::D407,
-                // CheckCodePrefix::D408,
-                // CheckCodePrefix::D409,
-                // CheckCodePrefix::D410,
-                // CheckCodePrefix::D411,
-                CheckCodePrefix::D412,
-                // CheckCodePrefix::D413,
-                CheckCodePrefix::D414,
-                // CheckCodePrefix::D415,
-                // CheckCodePrefix::D416,
-                // CheckCodePrefix::D417,
-                CheckCodePrefix::D418,
-                CheckCodePrefix::D419,
-            ],
-            DocstringConvention::NumPy => vec![
-                // All errors except D107, D203, D212, D213, D402, D413, D415, D416, and D417.
-                CheckCodePrefix::D100,
-                CheckCodePrefix::D101,
-                CheckCodePrefix::D102,
-                CheckCodePrefix::D103,
-                CheckCodePrefix::D104,
-                CheckCodePrefix::D105,
-                CheckCodePrefix::D106,
-                // CheckCodePrefix::D107,
-                CheckCodePrefix::D200,
-                CheckCodePrefix::D201,
-                CheckCodePrefix::D202,
-                // CheckCodePrefix::D203,
-                CheckCodePrefix::D204,
-                CheckCodePrefix::D205,
-                CheckCodePrefix::D206,
-                CheckCodePrefix::D207,
-                CheckCodePrefix::D208,
-                CheckCodePrefix::D209,
-                CheckCodePrefix::D210,
-                CheckCodePrefix::D211,
-                // CheckCodePrefix::D212,
-                // CheckCodePrefix::D213,
-                CheckCodePrefix::D214,
-                CheckCodePrefix::D215,
-                CheckCodePrefix::D300,
-                CheckCodePrefix::D400,
-                // CheckCodePrefix::D402,
-                CheckCodePrefix::D403,
-                CheckCodePrefix::D404,
-                CheckCodePrefix::D405,
-                CheckCodePrefix::D406,
-                CheckCodePrefix::D407,
-                CheckCodePrefix::D408,
-                CheckCodePrefix::D409,
-                CheckCodePrefix::D410,
-                CheckCodePrefix::D411,
-                CheckCodePrefix::D412,
-                // CheckCodePrefix::D413,
-                CheckCodePrefix::D414,
-                // CheckCodePrefix::D415,
-                // CheckCodePrefix::D416,
-                // CheckCodePrefix::D417,
-                CheckCodePrefix::D418,
-                CheckCodePrefix::D419,
-            ],
-            DocstringConvention::Google => vec![
-                // All errors except D203, D204, D213, D215, D400, D401, D404, D406, D407, D408,
-                // D409 and D413.
-                CheckCodePrefix::D100,
-                CheckCodePrefix::D101,
-                CheckCodePrefix::D102,
-                CheckCodePrefix::D103,
-                CheckCodePrefix::D104,
-                CheckCodePrefix::D105,
-                CheckCodePrefix::D106,
-                CheckCodePrefix::D107,
-                CheckCodePrefix::D200,
-                CheckCodePrefix::D201,
-                CheckCodePrefix::D202,
-                // CheckCodePrefix::D203,
-                // CheckCodePrefix::D204,
-                CheckCodePrefix::D205,
-                CheckCodePrefix::D206,
-                CheckCodePrefix::D207,
-                CheckCodePrefix::D208,
-                CheckCodePrefix::D209,
-                CheckCodePrefix::D210,
-                CheckCodePrefix::D211,
-                CheckCodePrefix::D212,
-                // CheckCodePrefix::D213,
-                CheckCodePrefix::D214,
-                // CheckCodePrefix::D215,
-                CheckCodePrefix::D300,
-                // CheckCodePrefix::D400,
-                CheckCodePrefix::D402,
-                CheckCodePrefix::D403,
-                // CheckCodePrefix::D404,
-                CheckCodePrefix::D405,
-                // CheckCodePrefix::D406,
-                // CheckCodePrefix::D407,
-                // CheckCodePrefix::D408,
-                // CheckCodePrefix::D409,
-                CheckCodePrefix::D410,
-                CheckCodePrefix::D411,
-                CheckCodePrefix::D412,
-                // CheckCodePrefix::D413,
-                CheckCodePrefix::D414,
-                CheckCodePrefix::D415,
-                CheckCodePrefix::D416,
-                CheckCodePrefix::D417,
-                CheckCodePrefix::D418,
-                CheckCodePrefix::D419,
-            ],
-        }
-    }
-}
-
-/// Infer the enabled plugins based on user-provided options.
-///
-/// For example, if the user specified a `mypy-init-return` setting, we should
-/// infer that `flake8-annotations` is active.
-pub fn infer_plugins_from_options(flake8: &HashMap<String, Option<String>>) -> Vec<Plugin> {
-    let mut plugins = BTreeSet::new();
-    for key in flake8.keys() {
-        match key.as_str() {
-            // flake8-docstrings
-            "docstring-convention" | "docstring_convention" => {
-                plugins.insert(Plugin::Flake8Docstrings);
-            }
-            // flake8-builtins
-            "builtins-ignorelist" | "builtins_ignorelist" => {
-                plugins.insert(Plugin::Flake8Builtins);
-            }
-            // flake8-quotes
-            "quotes" | "inline-quotes" | "inline_quotes" => {
-                plugins.insert(Plugin::Flake8Quotes);
-            }
-            "multiline-quotes" | "multiline_quotes" => {
-                plugins.insert(Plugin::Flake8Quotes);
-            }
-            "docstring-quotes" | "docstring_quotes" => {
-                plugins.insert(Plugin::Flake8Quotes);
-            }
-            "avoid-escape" | "avoid_escape" => {
-                plugins.insert(Plugin::Flake8Quotes);
-            }
-            // flake8-annotations
-            "suppress-none-returning" | "suppress_none_returning" => {
-                plugins.insert(Plugin::Flake8Annotations);
-            }
-            "suppress-dummy-args" | "suppress_dummy_args" => {
-                plugins.insert(Plugin::Flake8Annotations);
-            }
-            "allow-untyped-defs" | "allow_untyped_defs" => {
-                plugins.insert(Plugin::Flake8Annotations);
-            }
-            "allow-untyped-nested" | "allow_untyped_nested" => {
-                plugins.insert(Plugin::Flake8Annotations);
-            }
-            "mypy-init-return" | "mypy_init_return" => {
-                plugins.insert(Plugin::Flake8Annotations);
-            }
-            "dispatch-decorators" | "dispatch_decorators" => {
-                plugins.insert(Plugin::Flake8Annotations);
-            }
-            "overload-decorators" | "overload_decorators" => {
-                plugins.insert(Plugin::Flake8Annotations);
-            }
-            "allow-star-arg-any" | "allow_star_arg_any" => {
-                plugins.insert(Plugin::Flake8Annotations);
-            }
-            // pep8-naming
-            "ignore-names" | "ignore_names" => {
-                plugins.insert(Plugin::PEP8Naming);
-            }
-            "classmethod-decorators" | "classmethod_decorators" => {
-                plugins.insert(Plugin::PEP8Naming);
-            }
-            "staticmethod-decorators" | "staticmethod_decorators" => {
-                plugins.insert(Plugin::PEP8Naming);
-            }
-            _ => {}
-        }
-    }
-    Vec::from_iter(plugins)
-}
-
-/// Infer the enabled plugins based on the referenced prefixes.
-///
-/// For example, if the user ignores `ANN101`, we should infer that
-/// `flake8-annotations` is active.
-pub fn infer_plugins_from_codes(codes: &BTreeSet<CheckCodePrefix>) -> Vec<Plugin> {
-    [
-        Plugin::Flake8Bugbear,
-        Plugin::Flake8Builtins,
-        Plugin::Flake8Comprehensions,
-        Plugin::Flake8Docstrings,
-        Plugin::Flake8Print,
-        Plugin::Flake8Quotes,
-        Plugin::Flake8Annotations,
-        Plugin::PEP8Naming,
-        Plugin::Pyupgrade,
-    ]
-    .into_iter()
-    .filter(|plugin| {
-        for prefix in codes {
-            if prefix
-                .codes()
-                .iter()
-                .any(|code| plugin.default().codes().contains(code))
-            {
-                return true;
-            }
-        }
-        false
-    })
-    .collect()
-}
-
-/// Resolve the set of enabled `CheckCodePrefix` values for the given plugins.
-pub fn resolve_select(
-    flake8: &HashMap<String, Option<String>>,
-    plugins: &[Plugin],
-) -> BTreeSet<CheckCodePrefix> {
-    // Include default Pyflakes and pycodestyle checks.
-    let mut select = BTreeSet::from([CheckCodePrefix::E, CheckCodePrefix::F, CheckCodePrefix::W]);
-
-    // Add prefix codes for every plugin.
-    for plugin in plugins {
-        select.extend(plugin.select(flake8));
-    }
-
-    select
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashMap;
-
-    use crate::plugin::{infer_plugins_from_options, Plugin};
-
-    #[test]
-    fn it_infers_plugins() {
-        let actual = infer_plugins_from_options(&HashMap::from([(
-            "inline-quotes".to_string(),
-            Some("single".to_string()),
-        )]));
-        let expected = vec![Plugin::Flake8Quotes];
-        assert_eq!(actual, expected);
-
-        let actual = infer_plugins_from_options(&HashMap::from([(
-            "staticmethod-decorators".to_string(),
-            Some("[]".to_string()),
-        )]));
-        let expected = vec![Plugin::PEP8Naming];
-        assert_eq!(actual, expected);
-    }
-}

output.py

@@ -0,0 +1,37 @@
+from collections import Counter
+
+
+def f() -> None:
+    """Docstring goes here."""
+    for x in range(5):
+        print(x)
+    else:
+        print("Nope!")
+
+
+a = {
+    "a",
+    "b",
+    "c",
+    "a",
+    "b",
+    "c",
+    "a",
+    "b",
+    "c",
+    "a",
+    "b",
+    "c",
+    "a",
+    "b",
+    "c",
+    "a",
+    "b",
+    "c",
+    "a",
+    "b",
+    "c",
+}
+
+cls(title=title, before_text=before_text, after_text=after_text, before_description=before_description, after_description=after_description, transform_type=transform_type)
+

resources/test/fixtures/A001.py

@@ -1,6 +1,3 @@
-import os.path
-import ospath
-from os import path
 import some as sum
 from some import other as int
 

resources/test/fixtures/B002.py

@@ -1,20 +0,0 @@
-"""
-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

resources/test/fixtures/B003.py

@@ -1,18 +0,0 @@
-"""
-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 = {}

resources/test/fixtures/B004.py

@@ -1,12 +0,0 @@
-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.")

resources/test/fixtures/B005.py

@@ -1,26 +0,0 @@
-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
-
-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

resources/test/fixtures/B006_B008.py

@@ -1,187 +0,0 @@
-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)

resources/test/fixtures/B007.py

@@ -1,31 +0,0 @@
-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)

resources/test/fixtures/B011.py

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

resources/test/fixtures/B013.py

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

resources/test/fixtures/B014.py

@@ -1,76 +0,0 @@
-"""
-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

resources/test/fixtures/B015.py

@@ -1,27 +0,0 @@
-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)

resources/test/fixtures/B016.py

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

resources/test/fixtures/B017.py

@@ -1,36 +0,0 @@
-"""
-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()

resources/test/fixtures/B018.py

@@ -1,59 +0,0 @@
-class Foo1:
-    """abc"""
-
-
-class Foo2:
-    """abc"""
-
-    a = 2
-    "str"  # Str (no raise)
-    f"{int}"  # JoinedStr (no raise)
-    1j  # Number (complex)
-    1  # Number (int)
-    1.0  # Number (float)
-    b"foo"  # Binary
-    True  # NameConstant (True)
-    False  # NameConstant (False)
-    None  # NameConstant (None)
-    [1, 2]  # list
-    {1, 2}  # set
-    {"foo": "bar"}  # dict
-
-
-class Foo3:
-    123
-    a = 2
-    "str"
-    1
-
-
-def foo1():
-    """my docstring"""
-
-
-def foo2():
-    """my docstring"""
-    a = 2
-    "str"  # Str (no raise)
-    f"{int}"  # JoinedStr (no raise)
-    1j  # Number (complex)
-    1  # Number (int)
-    1.0  # Number (float)
-    b"foo"  # Binary
-    True  # NameConstant (True)
-    False  # NameConstant (False)
-    None  # NameConstant (None)
-    [1, 2]  # list
-    {1, 2}  # set
-    {"foo": "bar"}  # dict
-
-
-def foo3():
-    123
-    a = 2
-    "str"
-    3
-
-
-def foo4():
-    ...

resources/test/fixtures/B025.py

@@ -1,38 +0,0 @@
-"""
-Should emit:
-B025 - on lines 15, 22, 31
-"""
-
-import pickle
-
-try:
-    a = 1
-except ValueError:
-    a = 2
-finally:
-    a = 3
-
-try:
-    a = 1
-except ValueError:
-    a = 2
-except ValueError:
-    a = 2
-
-try:
-    a = 1
-except pickle.PickleError:
-    a = 2
-except ValueError:
-    a = 2
-except pickle.PickleError:
-    a = 2
-
-try:
-    a = 1
-except (ValueError, TypeError):
-    a = 2
-except ValueError:
-    a = 2
-except (OSError, TypeError):
-    a = 2

resources/test/fixtures/C400.py

@@ -1,4 +0,0 @@
-x = list(x for x in range(3))
-x = list(
-    x for x in range(3)
-)

resources/test/fixtures/C401.py

@@ -1,4 +0,0 @@
-x = set(x for x in range(3))
-x = set(
-    x for x in range(3)
-)

resources/test/fixtures/C402.py

@@ -1,5 +0,0 @@
-dict((x, x) for x in range(3))
-dict(
-    (x, x) for x in range(3)
-)
-dict(((x, x) for x in range(3)), z=3)

resources/test/fixtures/C403.py

@@ -1,4 +0,0 @@
-s = set([x for x in range(3)])
-s = set(
-    [x for x in range(3)]
-)

resources/test/fixtures/C404.py

@@ -1,2 +0,0 @@
-dict([(i, i) for i in range(3)])
-dict([(i, i) for i in range(3)], z=4)

resources/test/fixtures/C405.py

@@ -1,5 +0,0 @@
-s1 = set([1, 2])
-s2 = set((1, 2))
-s3 = set([])
-s4 = set(())
-s5 = set()

resources/test/fixtures/C406.py

@@ -1,5 +0,0 @@
-d1 = dict([(1, 2)])
-d2 = dict(((1, 2),))
-d3 = dict([])
-d4 = dict(())
-d5 = dict()

resources/test/fixtures/C408.py

@@ -1,5 +0,0 @@
-t = tuple()
-l = list()
-d1 = dict()
-d2 = dict(a=1)
-d3 = dict(**d2)

resources/test/fixtures/C409.py

@@ -1,10 +0,0 @@
-t1 = tuple([])
-t2 = tuple([1, 2])
-t3 = tuple((1, 2))
-t4 = tuple([
-    1,
-    2
-])
-t5 = tuple(
-    (1, 2)
-)

resources/test/fixtures/C410.py

@@ -1,4 +0,0 @@
-l1 = list([1, 2])
-l2 = list((1, 2))
-l3 = list([])
-l4 = list(())

resources/test/fixtures/C411.py

@@ -1,2 +0,0 @@
-x = [1, 2, 3]
-list([i for i in x])

resources/test/fixtures/C413.py

@@ -1,4 +0,0 @@
-x = [2, 3, 1]
-list(sorted(x))
-reversed(sorted(x))
-reversed(sorted(x, reverse=True))

resources/test/fixtures/C414.py

@@ -1,14 +0,0 @@
-x = [1, 2, 3]
-list(list(x))
-list(tuple(x))
-tuple(list(x))
-tuple(tuple(x))
-set(set(x))
-set(list(x))
-set(tuple(x))
-set(sorted(x))
-set(reversed(x))
-sorted(list(x))
-sorted(tuple(x))
-sorted(sorted(x))
-sorted(reversed(x))

resources/test/fixtures/C415.py

@@ -1,9 +0,0 @@
-lst = [2, 1, 3]
-a = set(lst[::-1])
-b = reversed(lst[::-1])
-c = sorted(lst[::-1])
-d = sorted(lst[::-1], reverse=True)
-e = set(lst[2:-1])
-f = set(lst[:1:-1])
-g = set(lst[::1])
-h = set(lst[::-2])

resources/test/fixtures/C416.py

@@ -1,6 +0,0 @@
-x = [1, 2, 3]
-[i for i in x]
-{i for i in x}
-
-[i for i in x if i > 1]
-[i for i in x for j in x]

resources/test/fixtures/C417.py

@@ -1,6 +0,0 @@
-nums = [1, 2, 3]
-map(lambda x: x + 1, nums)
-map(lambda x: str(x), nums)
-list(map(lambda x: x * 2, nums))
-set(map(lambda x: x % 2 == 0, nums))
-dict(map(lambda v: (v, v**2), nums))

resources/test/fixtures/D.py

@@ -1,534 +0,0 @@
-# No docstring, so we can test D100
-from functools import wraps
-import os
-from .expected import Expectation
-from typing import overload
-
-
-expectation = Expectation()
-expect = expectation.expect
-
-expect('class_', 'D101: Missing docstring in public class')
-
-
-class class_:
-
-    expect('meta', 'D419: Docstring is empty')
-
-    class meta:
-        """"""
-
-    @expect('D102: Missing docstring in public method')
-    def method(self=None):
-        pass
-
-    def _ok_since_private(self=None):
-        pass
-
-    @overload
-    def overloaded_method(self, a: int) -> str:
-        ...
-
-    @overload
-    def overloaded_method(self, a: str) -> str:
-        """Foo bar documentation."""
-        ...
-
-    def overloaded_method(a):
-        """Foo bar documentation."""
-        return str(a)
-
-    expect('overloaded_method',
-           "D418: Function/ Method decorated with @overload"
-           " shouldn't contain a docstring")
-
-    @property
-    def foo(self):
-        """The foo of the thing, which isn't in imperitive mood."""
-        return "hello"
-
-    @expect('D102: Missing docstring in public method')
-    def __new__(self=None):
-        pass
-
-    @expect('D107: Missing docstring in __init__')
-    def __init__(self=None):
-        pass
-
-    @expect('D105: Missing docstring in magic method')
-    def __str__(self=None):
-        pass
-
-    @expect('D102: Missing docstring in public method')
-    def __call__(self=None, x=None, y=None, z=None):
-        pass
-
-
-@expect('D419: Docstring is empty')
-def function():
-    """ """
-    def ok_since_nested():
-        pass
-
-    @expect('D419: Docstring is empty')
-    def nested():
-        ''
-
-
-def function_with_nesting():
-    """Foo bar documentation."""
-    @overload
-    def nested_overloaded_func(a: int) -> str:
-        ...
-
-    @overload
-    def nested_overloaded_func(a: str) -> str:
-        """Foo bar documentation."""
-        ...
-
-    def nested_overloaded_func(a):
-        """Foo bar documentation."""
-        return str(a)
-
-
-expect('nested_overloaded_func',
-       "D418: Function/ Method decorated with @overload"
-       " shouldn't contain a docstring")
-
-
-@overload
-def overloaded_func(a: int) -> str:
-    ...
-
-
-@overload
-def overloaded_func(a: str) -> str:
-    """Foo bar documentation."""
-    ...
-
-
-def overloaded_func(a):
-    """Foo bar documentation."""
-    return str(a)
-
-
-expect('overloaded_func',
-       "D418: Function/ Method decorated with @overload"
-       " shouldn't contain a docstring")
-
-
-@expect('D200: One-line docstring should fit on one line with quotes '
-        '(found 3)')
-@expect('D212: Multi-line docstring summary should start at the first line')
-def asdlkfasd():
-    """
-    Wrong.
-    """
-
-
-@expect('D201: No blank lines allowed before function docstring (found 1)')
-def leading_space():
-
-    """Leading space."""
-
-
-@expect('D202: No blank lines allowed after function docstring (found 1)')
-def trailing_space():
-    """Leading space."""
-
-    pass
-
-
-@expect('D201: No blank lines allowed before function docstring (found 1)')
-@expect('D202: No blank lines allowed after function docstring (found 1)')
-def trailing_and_leading_space():
-
-    """Trailing and leading space."""
-
-    pass
-
-
-expect('LeadingSpaceMissing',
-       'D203: 1 blank line required before class docstring (found 0)')
-
-
-class LeadingSpaceMissing:
-    """Leading space missing."""
-
-
-expect('WithLeadingSpace',
-       'D211: No blank lines allowed before class docstring (found 1)')
-
-
-class WithLeadingSpace:
-
-    """With leading space."""
-
-
-expect('TrailingSpace',
-       'D204: 1 blank line required after class docstring (found 0)')
-expect('TrailingSpace',
-       'D211: No blank lines allowed before class docstring (found 1)')
-
-
-class TrailingSpace:
-
-    """TrailingSpace."""
-    pass
-
-
-expect('LeadingAndTrailingSpaceMissing',
-       'D203: 1 blank line required before class docstring (found 0)')
-expect('LeadingAndTrailingSpaceMissing',
-       'D204: 1 blank line required after class docstring (found 0)')
-
-
-class LeadingAndTrailingSpaceMissing:
-    """Leading and trailing space missing."""
-    pass
-
-
-@expect('D205: 1 blank line required between summary line and description '
-        '(found 0)')
-@expect('D213: Multi-line docstring summary should start at the second line')
-def multi_line_zero_separating_blanks():
-    """Summary.
-    Description.
-
-    """
-
-
-@expect('D205: 1 blank line required between summary line and description '
-        '(found 2)')
-@expect('D213: Multi-line docstring summary should start at the second line')
-def multi_line_two_separating_blanks():
-    """Summary.
-
-
-    Description.
-
-    """
-
-
-@expect('D213: Multi-line docstring summary should start at the second line')
-def multi_line_one_separating_blanks():
-    """Summary.
-
-    Description.
-
-    """
-
-
-@expect('D207: Docstring is under-indented')
-@expect('D213: Multi-line docstring summary should start at the second line')
-def asdfsdf():
-    """Summary.
-
-Description.
-
-    """
-
-
-@expect('D207: Docstring is under-indented')
-@expect('D213: Multi-line docstring summary should start at the second line')
-def asdsdfsdffsdf():
-    """Summary.
-
-    Description.
-
-"""
-
-
-@expect('D208: Docstring is over-indented')
-@expect('D213: Multi-line docstring summary should start at the second line')
-def asdfsdsdf24():
-    """Summary.
-
-       Description.
-
-    """
-
-
-@expect('D208: Docstring is over-indented')
-@expect('D213: Multi-line docstring summary should start at the second line')
-def asdfsdsdfsdf24():
-    """Summary.
-
-    Description.
-
-        """
-
-
-@expect('D208: Docstring is over-indented')
-@expect('D213: Multi-line docstring summary should start at the second line')
-def asdfsdfsdsdsdfsdf24():
-    """Summary.
-
-        Description.
-
-    """
-
-
-@expect('D209: Multi-line docstring closing quotes should be on a separate '
-        'line')
-@expect('D213: Multi-line docstring summary should start at the second line')
-def asdfljdf24():
-    """Summary.
-
-    Description."""
-
-
-@expect('D210: No whitespaces allowed surrounding docstring text')
-def endswith():
-    """Whitespace at the end. """
-
-
-@expect('D210: No whitespaces allowed surrounding docstring text')
-def around():
-    """ Whitespace at everywhere. """
-
-
-@expect('D210: No whitespaces allowed surrounding docstring text')
-@expect('D213: Multi-line docstring summary should start at the second line')
-def multiline():
-    """ Whitespace at the beginning.
-
-    This is the end.
-    """
-
-
-@expect('D300: Use """triple double quotes""" (found \'\'\'-quotes)')
-def triple_single_quotes_raw():
-    r'''Summary.'''
-
-
-@expect('D300: Use """triple double quotes""" (found \'\'\'-quotes)')
-def triple_single_quotes_raw_uppercase():
-    R'''Summary.'''
-
-
-@expect('D300: Use """triple double quotes""" (found \'-quotes)')
-def single_quotes_raw():
-    r'Summary.'
-
-
-@expect('D300: Use """triple double quotes""" (found \'-quotes)')
-def single_quotes_raw_uppercase():
-    R'Summary.'
-
-
-@expect('D300: Use """triple double quotes""" (found \'-quotes)')
-@expect('D301: Use r""" if any backslashes in a docstring')
-def single_quotes_raw_uppercase_backslash():
-    R'Sum\mary.'
-
-
-@expect('D301: Use r""" if any backslashes in a docstring')
-def double_quotes_backslash():
-    """Sum\\mary."""
-
-
-@expect('D301: Use r""" if any backslashes in a docstring')
-def double_quotes_backslash_uppercase():
-    R"""Sum\\mary."""
-
-
-@expect('D213: Multi-line docstring summary should start at the second line')
-def exceptions_of_D301():
-    """Exclude some backslashes from D301.
-
-    In particular, line continuations \
-    and unicode literals \u0394 and \N{GREEK CAPITAL LETTER DELTA}.
-    They are considered to be intentionally unescaped.
-    """
-
-
-@expect("D400: First line should end with a period (not 'y')")
-@expect("D415: First line should end with a period, question mark, "
-        "or exclamation point (not 'y')")
-def lwnlkjl():
-    """Summary"""
-
-
-@expect("D401: First line should be in imperative mood "
-        "(perhaps 'Return', not 'Returns')")
-def liouiwnlkjl():
-    """Returns foo."""
-
-
-@expect("D401: First line should be in imperative mood; try rephrasing "
-        "(found 'Constructor')")
-def sdgfsdg23245():
-    """Constructor for a foo."""
-
-
-@expect("D401: First line should be in imperative mood; try rephrasing "
-        "(found 'Constructor')")
-def sdgfsdg23245777():
-    """Constructor."""
-
-
-@expect('D402: First line should not be the function\'s "signature"')
-def foobar():
-    """Signature: foobar()."""
-
-
-@expect('D213: Multi-line docstring summary should start at the second line')
-def new_209():
-    """First line.
-
-    More lines.
-    """
-    pass
-
-
-@expect('D213: Multi-line docstring summary should start at the second line')
-def old_209():
-    """One liner.
-
-    Multi-line comments. OK to have extra blank line
-
-    """
-
-
-@expect("D103: Missing docstring in public function")
-def oneliner_d102(): return
-
-
-@expect("D400: First line should end with a period (not 'r')")
-@expect("D415: First line should end with a period, question mark,"
-        " or exclamation point (not 'r')")
-def oneliner_withdoc(): """One liner"""
-
-
-def ignored_decorator(func):   # noqa: D400,D401,D415
-    """Runs something"""
-    func()
-    pass
-
-
-def decorator_for_test(func):   # noqa: D400,D401,D415
-    """Runs something"""
-    func()
-    pass
-
-
-@ignored_decorator
-def oneliner_ignored_decorator(): """One liner"""
-
-
-@decorator_for_test
-@expect("D400: First line should end with a period (not 'r')")
-@expect("D415: First line should end with a period, question mark,"
-        " or exclamation point (not 'r')")
-def oneliner_with_decorator_expecting_errors(): """One liner"""
-
-
-@decorator_for_test
-def valid_oneliner_with_decorator(): """One liner."""
-
-
-@expect("D207: Docstring is under-indented")
-@expect('D213: Multi-line docstring summary should start at the second line')
-def docstring_start_in_same_line(): """First Line.
-
-    Second Line
-    """
-
-
-def function_with_lambda_arg(x=lambda y: y):
-    """Wrap the given lambda."""
-
-
-@expect('D213: Multi-line docstring summary should start at the second line')
-def a_following_valid_function(x=None):
-    """Check for a bug where the previous function caused an assertion.
-
-    The assertion was caused in the next function, so this one is necessary.
-
-    """
-
-
-def outer_function():
-    """Do something."""
-    def inner_function():
-        """Do inner something."""
-        return 0
-
-
-@expect("D400: First line should end with a period (not 'g')")
-@expect("D401: First line should be in imperative mood "
-        "(perhaps 'Run', not 'Runs')")
-@expect("D415: First line should end with a period, question mark, "
-        "or exclamation point (not 'g')")
-def docstring_bad():
-    """Runs something"""
-    pass
-
-
-def docstring_bad_ignore_all():  # noqa
-    """Runs something"""
-    pass
-
-
-def docstring_bad_ignore_one():  # noqa: D400,D401,D415
-    """Runs something"""
-    pass
-
-
-@expect("D401: First line should be in imperative mood "
-        "(perhaps 'Run', not 'Runs')")
-def docstring_ignore_some_violations_but_catch_D401():  # noqa: E501,D400,D415
-    """Runs something"""
-    pass
-
-
-@expect(
-    "D401: First line should be in imperative mood "
-    "(perhaps 'Initiate', not 'Initiates')"
-)
-def docstring_initiates():
-    """Initiates the process."""
-
-
-@expect(
-    "D401: First line should be in imperative mood "
-    "(perhaps 'Initialize', not 'Initializes')"
-)
-def docstring_initializes():
-    """Initializes the process."""
-
-
-@wraps(docstring_bad_ignore_one)
-def bad_decorated_function():
-    """Bad (E501) but decorated"""
-    pass
-
-
-def valid_google_string():  # noqa: D400
-    """Test a valid something!"""
-
-
-@expect("D415: First line should end with a period, question mark, "
-        "or exclamation point (not 'g')")
-def bad_google_string():  # noqa: D400
-    """Test a valid something"""
-
-
-# This is reproducing a bug where AttributeError is raised when parsing class
-# parameters as functions for Google / Numpy conventions.
-class Blah:  # noqa: D203,D213
-    """A Blah.
-
-    Parameters
-    ----------
-    x : int
-
-    """
-
-    def __init__(self, x):
-        pass
-
-
-expect(os.path.normcase(__file__ if __file__[-1] != 'c' else __file__[:-1]),
-       'D100: Missing docstring in public module')

resources/test/fixtures/E501.py

@@ -14,38 +14,3 @@ Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor i
 
 _ = "---------------------------------------------------------------------------AAAAAAA"
 _ = "---------------------------------------------------------------------------亜亜亜亜亜亜亜"
-
-
-def caller(string: str) -> None:
-    assert string is not None
-
-
-caller(
-    """
-    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
-    """,
-)
-
-
-caller(
-    """
-    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
-    """,  # noqa: E501
-)
-
-multiple_strings_per_line = {
-    # OK
-    "Lorem ipsum dolor": "sit amet",
-    # E501 Line too long
-    "Lorem ipsum dolor": "sit amet consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
-    # E501 Line too long
-    "Lorem ipsum dolor": """
-sit amet  consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
-""",
-    # OK
-    "Lorem ipsum dolor": "sit amet consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",  # noqa: E501
-    # OK
-    "Lorem ipsum dolor": """
-sit amet  consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
-""",  # noqa: E501
-}

resources/test/fixtures/F401.py

@@ -61,28 +61,7 @@ Y = TypeVar("Y", bound="Dict")
 Z = TypeVar("Z", "List", "Set")
 
 a = list["Fruit"]
-b = Union["""Nut""", None]
+b = Union["Nut", None]
 c = cast("Vegetable", b)
 
 Field = lambda default=MISSING: field(default=default)
-
-
-# Test: access a sub-importation via an alias.
-import pyarrow as pa
-import pyarrow.csv
-
-print(pa.csv.read_csv("test.csv"))
-
-
-# Test: referencing an import via TypeAlias.
-import sys
-
-import numpy as np
-
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
-
-
-CustomInt: TypeAlias = "np.int8 | np.int16"

resources/test/fixtures/F401_1.py

@@ -1,5 +0,0 @@
-"""Access a sub-importation via an alias."""
-import pyarrow as pa
-import pyarrow.csv
-
-print(pa.csv.read_csv("test.csv"))

resources/test/fixtures/F401_2.py

@@ -1,12 +0,0 @@
-"""Test: referencing an import via TypeAlias."""
-import sys
-
-import numpy as np
-
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
-
-
-CustomInt: TypeAlias = "np.int8 | np.int16"

resources/test/fixtures/F401_3.py

@@ -1,14 +0,0 @@
-"""Test: referencing an import via TypeAlias (with future annotations)."""
-from __future__ import annotations
-
-import sys
-
-import numpy as np
-
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
-
-
-CustomInt: TypeAlias = np.int8 | np.int16

resources/test/fixtures/F401_4.py

@@ -1,14 +0,0 @@
-"""Test: referencing an import via TypeAlias (with future annotations and quotes)."""
-from __future__ import annotations
-
-import sys
-
-import numpy as np
-
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
-
-
-CustomInt: TypeAlias = "np.int8 | np.int16"

resources/test/fixtures/F401_5.py

@@ -1,5 +0,0 @@
-"""Test: removal of multi-segment and aliases imports."""
-from a.b import c
-from d.e import f as g
-import h.i
-import j.k as l

resources/test/fixtures/F404.py

@@ -1,3 +1,4 @@
+from __future__ import print_function
 """Docstring"""
 from __future__ import absolute_import
 

resources/test/fixtures/F632.py

@@ -3,6 +3,3 @@ if x is "abc":
 
 if 123 is not y:
     pass
-
-if "123" is x < 3:
-    pass

resources/test/fixtures/F821.py

@@ -89,45 +89,3 @@ A = (
     f'B'
     f'{B}'
 )
-
-
-from typing import Annotated, Literal
-
-
-def arbitrary_callable() -> None:
-    ...
-
-
-class PEP593Test:
-    field: Annotated[
-        int,
-        "base64",
-        arbitrary_callable(),
-        123,
-        (1, 2, 3),
-    ]
-    field_with_stringified_type: Annotated[
-        "PEP593Test",
-        123,
-    ]
-    field_with_undefined_stringified_type: Annotated[
-        "PEP593Test123",
-        123,
-    ]
-    field_with_nested_subscript: Annotated[
-        dict[Literal["foo"], str],
-        123,
-    ]
-    field_with_undefined_nested_subscript: Annotated[
-        dict["foo", "bar"],  # Expected to fail as undefined.
-        123,
-    ]
-
-
-def in_ipython_notebook() -> bool:
-    try:
-        # autoimported by notebooks
-        get_ipython()  # type: ignore[name-defined]
-    except NameError:
-        return False  # not in notebook
-    return True

resources/test/fixtures/F821_1.py

@@ -1,30 +0,0 @@
-"""Test: typing module imports."""
-from foo import cast
-
-# OK
-x = cast("Model")
-
-from typing import cast
-
-
-# F821 Undefined name `Model`
-x = cast("Model", x)
-
-
-import typing
-
-
-# F821 Undefined name `Model`
-x = typing.cast("Model", x)
-
-
-from typing import Pattern
-
-# F821 Undefined name `Model`
-x = Pattern["Model"]
-
-
-from typing.re import Match
-
-# F821 Undefined name `Model`
-x = Match["Model"]

resources/test/fixtures/F821_2.py

@@ -1,18 +0,0 @@
-"""Test: typing_extensions module imports."""
-from foo import Literal
-
-# F821 Undefined name `Model`
-x: Literal["Model"]
-
-from typing_extensions import Literal
-
-
-# OK
-x: Literal["Model"]
-
-
-import typing_extensions
-
-
-# OK
-x: typing_extensions.Literal["Model"]

resources/test/fixtures/F821_3.py

@@ -1,14 +0,0 @@
-"""Test (edge case): accesses of object named `dict`."""
-
-# OK
-dict = {"parameters": {}}
-dict["parameters"]["userId"] = "userId"
-dict["parameters"]["itemId"] = "itemId"
-del dict["parameters"]["itemId"]
-
-# F821 Undefined name `key`
-# F821 Undefined name `value`
-x: dict["key", "value"]
-
-# OK
-x: dict[str, str]

resources/test/fixtures/M001.py

@@ -15,9 +15,6 @@ def f() -> None:
     # Invalid
     d = 1  # noqa: F841, E501
 
-    # Invalid (and unimplemented)
-    d = 1  # noqa: F841, W191
-
 
 # Valid
 _ = """Lorem ipsum dolor sit amet.

resources/test/fixtures/N801.py

@@ -1,34 +0,0 @@
-class bad:
-    pass
-
-
-class _bad:
-    pass
-
-
-class bad_class:
-    pass
-
-
-class Bad_Class:
-    pass
-
-
-class BAD_CLASS:
-    pass
-
-
-class Good:
-    pass
-
-
-class _Good:
-    pass
-
-
-class GoodClass:
-    pass
-
-
-class GOOD:
-    pass

resources/test/fixtures/N802.py

@@ -1,41 +0,0 @@
-import unittest
-
-
-def Bad():
-    pass
-
-
-def _Bad():
-    pass
-
-
-def BAD():
-    pass
-
-
-def BAD_FUNC():
-    pass
-
-
-def good():
-    pass
-
-
-def _good():
-    pass
-
-
-def good_func():
-    pass
-
-
-def tearDownModule():
-    pass
-
-
-class Test(unittest.TestCase):
-    def tearDown(self):
-        return super().tearDown()
-
-    def testTest(self):
-        assert True

resources/test/fixtures/N803.py

@@ -1,7 +0,0 @@
-def func(_, a, A):
-    return _, a, A
-
-
-class Class:
-    def method(self, _, a, A):
-        return _, a, A

resources/test/fixtures/N804.py

@@ -1,43 +0,0 @@
-from abc import ABCMeta
-
-
-class Class:
-    def bad_method(this):
-        pass
-
-    if False:
-
-        def extra_bad_method(this):
-            pass
-
-    def good_method(self):
-        pass
-
-    @classmethod
-    def class_method(cls):
-        pass
-
-    @staticmethod
-    def static_method(x):
-        return x
-
-    def __init__(self):
-        ...
-
-    def __new__(cls, *args, **kwargs):
-        ...
-
-    def __init_subclass__(self, default_name, **kwargs):
-        ...
-
-
-class MetaClass(ABCMeta):
-    def bad_method(self):
-        pass
-
-    def good_method(cls):
-        pass
-
-
-def func(x):
-    return x

resources/test/fixtures/N805.py

@@ -1,43 +0,0 @@
-from abc import ABCMeta
-
-
-class Class:
-    def bad_method(this):
-        pass
-
-    if False:
-
-        def extra_bad_method(this):
-            pass
-
-    def good_method(self):
-        pass
-
-    @classmethod
-    def class_method(cls):
-        pass
-
-    @staticmethod
-    def static_method(x):
-        return x
-
-    def __init__(self):
-        ...
-
-    def __new__(cls, *args, **kwargs):
-        ...
-
-    def __init_subclass__(self, default_name, **kwargs):
-        ...
-
-
-class MetaClass(ABCMeta):
-    def bad_method(self):
-        pass
-
-    def good_method(cls):
-        pass
-
-
-def func(x):
-    return x

resources/test/fixtures/N806.py

@@ -1,5 +0,0 @@
-def f():
-    lower = 0
-    Camel = 0
-    CONSTANT = 0
-    _ = 0

resources/test/fixtures/N807.py

@@ -1,15 +0,0 @@
-def __bad__():
-    pass
-
-
-def __good():
-    pass
-
-
-def good__():
-    pass
-
-
-class Class:
-    def __good__(self):
-        pass

resources/test/fixtures/N811.py

@@ -1,3 +0,0 @@
-import mod.CONST as const
-from mod import CONSTANT as constant
-from mod import ANOTHER_CONSTANT as another_constant

resources/test/fixtures/N812.py

@@ -1,3 +0,0 @@
-import modl.lowercase as Lower
-from mod import lowercase as Lowercase
-from mod import another_lowercase as AnotherLowercase

resources/test/fixtures/N813.py

@@ -1,3 +0,0 @@
-import mod.Camel as camel
-from mod import CamelCase as camelcase
-from mod import AnotherCamelCase as another_camelcase

resources/test/fixtures/N814.py

@@ -1,3 +0,0 @@
-import mod.Camel as CAMEL
-from mod import CamelCase as CAMELCASE
-from mod import AnotherCamelCase as ANOTHER_CAMELCASE

resources/test/fixtures/N815.py

@@ -1,6 +0,0 @@
-class C:
-    lower = 0
-    CONSTANT = 0
-    mixedCase = 0
-    _mixedCase = 0
-    mixed_Case = 0

resources/test/fixtures/N816.py

@@ -1,5 +0,0 @@
-lower = 0
-CONSTANT = 0
-mixedCase = 0
-_mixedCase = 0
-mixed_Case = 0

resources/test/fixtures/N817.py

@@ -1,2 +0,0 @@
-import mod.CaMel as CM
-from mod import CamelCase as CC

resources/test/fixtures/N818.py

@@ -1,10 +0,0 @@
-class Error(Exception):
-    pass
-
-
-class AnotherError(Exception):
-    pass
-
-
-class C(Exception):
-    pass

resources/test/fixtures/R002.py

@@ -0,0 +1,3 @@
+self.assertEquals (1, 2)
+self.assertEquals(1, 2)
+self.assertEqual(3, 4)

resources/test/fixtures/RUF001.py

@@ -1,6 +0,0 @@
-x = "𝐁ad string"
-
-
-def f():
-    """Here's a comment with an unusual parenthesis: ）"""
-    ...

resources/test/fixtures/RUF002.py

@@ -1,6 +0,0 @@
-x = "𝐁ad string"
-
-
-def f():
-    """Here's a comment with an unusual parenthesis: ）"""
-    ...

resources/test/fixtures/U002.py

@@ -1,15 +0,0 @@
-from os.path import abspath
-
-x = abspath(__file__)
-
-
-import os
-
-
-y = os.path.abspath(__file__)
-
-
-from os import path
-
-
-z = path.abspath(__file__)

resources/test/fixtures/U003.py

@@ -1,5 +0,0 @@
-type('')
-type(b'')
-type(0)
-type(0.)
-type(0j)

resources/test/fixtures/U005.py

@@ -1,10 +0,0 @@
-import unittest
-
-
-class Suite(unittest.TestCase):
-    def test(self) -> None:
-        self.assertEquals (1, 2)
-        self.assertEquals(1, 2)
-        self.assertEqual(3, 4)
-        self.failUnlessAlmostEqual(1, 1.1)
-        self.assertNotRegexpMatches("a", "b")

resources/test/fixtures/U006.py

@@ -1,12 +0,0 @@
-from typing import List
-
-
-def f(x: List[str]) -> None:
-    ...
-
-
-import typing
-
-
-def f(x: typing.List[str]) -> None:
-    ...

resources/test/fixtures/U007.py

@@ -1,40 +0,0 @@
-from typing import Optional
-
-
-def f(x: Optional[str]) -> None:
-    ...
-
-
-import typing
-
-
-def f(x: typing.Optional[str]) -> None:
-    ...
-
-
-from typing import Union
-
-
-def f(x: Union[str, int, Union[float, bytes]]) -> None:
-    ...
-
-
-import typing
-
-
-def f(x: typing.Union[str, int]) -> None:
-    ...
-
-
-from typing import Union
-
-
-def f(x: "Union[str, int, Union[float, bytes]]") -> None:
-    ...
-
-
-import typing
-
-
-def f(x: "typing.Union[str, int]") -> None:
-    ...

resources/test/fixtures/U009_0.py

@@ -1,3 +0,0 @@
-# coding=utf8
-
-print('Hello world')