Bump version to 0.0.227

Closes #2008.

.github/workflows/ci.yaml

@@ -27,8 +27,8 @@ jobs:
           toolchain: nightly-2022-11-01
           override: true
       - uses: Swatinem/rust-cache@v1
-      - run: cargo build --all --release
-      - run: ./target/release/ruff_dev generate-all
+      - run: cargo build --all
+      - run: ./target/debug/ruff_dev generate-all
       - run: git diff --quiet README.md || echo "::error file=README.md::This file is outdated. Run 'cargo +nightly dev generate-all'."
       - run: git diff --quiet ruff.schema.json || echo "::error file=ruff.schema.json::This file is outdated. Run 'cargo +nightly dev generate-all'."
       - run: git diff --exit-code -- README.md ruff.schema.json
@@ -60,7 +60,7 @@ jobs:
           target: wasm32-unknown-unknown
       - uses: Swatinem/rust-cache@v1
       - run: cargo clippy --workspace --all-targets --all-features -- -D warnings -W clippy::pedantic
-      - run: cargo clippy --workspace --target wasm32-unknown-unknown --all-features -- -D warnings -W clippy::pedantic
+      - run: cargo clippy -p ruff --target wasm32-unknown-unknown --all-features -- -D warnings -W clippy::pedantic
 
   cargo-test:
     name: "cargo test"
@@ -79,7 +79,10 @@ jobs:
         run: |
           cargo insta test --all --delete-unreferenced-snapshots
           git diff --exit-code
-      - run: cargo test --package ruff --test black_compatibility_test -- --ignored
+      - run: cargo test --package ruff_cli --test black_compatibility_test -- --ignored
+      # Check for broken links in the documentation.
+      # Setting RUSTDOCFLAGS because `cargo doc --check` isn't yet implemented (https://github.com/rust-lang/cargo/issues/10025).
+      - run: RUSTDOCFLAGS="-D warnings" cargo doc --all --no-deps
 
 # TODO(charlie): Re-enable the `wasm-pack` tests.
 # See: https://github.com/charliermarsh/ruff/issues/1425

.github/workflows/playground.yaml

@@ -31,7 +31,7 @@ jobs:
       - uses: jetli/wasm-pack-action@v0.4.0
       - uses: jetli/wasm-bindgen-action@v0.2.0
       - name: "Run wasm-pack"
-        run: wasm-pack build --target web --out-dir playground/src/pkg
+        run: wasm-pack build --target web --out-dir playground/src/pkg . -- -p ruff
       - name: "Install Node dependencies"
         run: npm ci
         working-directory: playground

.github/workflows/ruff.yaml

@@ -293,3 +293,6 @@ jobs:
         run: |
           pip install --upgrade twine
           twine upload --skip-existing *
+      - name: Update pre-commit mirror
+        run: |
+          curl -X POST -H "Accept: application/vnd.github+json" -H "Authorization: Bearer ${{ secrets.RUFF_PRE_COMMIT_PAT }}" -H "X-GitHub-Api-Version: 2022-11-28" https://api.github.com/repos/charliermarsh/ruff-pre-commit/dispatches --data '{"event_type": "pypi_release"}'

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.217
+    rev: v0.0.227
     hooks:
       - id: ruff
 
@@ -8,3 +8,11 @@ repos:
     rev: v0.10.1
     hooks:
       - id: validate-pyproject
+
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        entry: cargo fmt --
+        language: rust
+        types: [rust]

BREAKING_CHANGES.md

@@ -1,5 +1,36 @@
 # Breaking Changes
 
+## 0.0.226
+
+### `misplaced-comparison-constant` (`PLC2201`) was deprecated in favor of `SIM300` ([#1980](https://github.com/charliermarsh/ruff/pull/1980))
+
+These two rules contain (nearly) identical logic. To deduplicate the rule set, we've upgraded
+`SIM300` to handle a few more cases, and deprecated `PLC2201` in favor of `SIM300`.
+
+## 0.0.225
+
+### `@functools.cache` rewrites have been moved to a standalone rule (`UP033`) ([#1938](https://github.com/charliermarsh/ruff/pull/1938))
+
+Previously, `UP011` handled both `@functools.lru_cache()`-to-`@functools.lru_cache` conversions,
+_and_ `@functools.lru_cache(maxsize=None)`-to-`@functools.cache` conversions. The latter has been
+moved out to its own rule (`UP033`). As such, some `# noqa: UP011` comments may need to be updated
+to reflect the change in rule code.
+
+## 0.0.222
+
+### `--max-complexity` has been removed from the CLI ([#1877](https://github.com/charliermarsh/ruff/pull/1877))
+
+The McCabe plugin's `--max-complexity` setting has been removed from the CLI, for consistency with
+the treatment of other, similar settings.
+
+To set the maximum complexity, use the `max-complexity` property in your `pyproject.toml` file,
+like so:
+
+```toml
+[tool.ruff.mccabe]
+max-complexity = 10
+```
+
 ## 0.0.181
 
 ### Files excluded by `.gitignore` are now ignored ([#1234](https://github.com/charliermarsh/ruff/pull/1234))

CONTRIBUTING.md

@@ -54,18 +54,22 @@ prior to merging.
 
 ### Example: Adding a new lint rule
 
-There are four phases to adding a new lint rule:
+At a high level, the steps involved in adding a new lint rule are as follows:
 
-1. Define the violation struct in `src/violations.rs` (e.g., `ModuleImportNotAtTopOfFile`).
-2. Map the violation struct to a rule code in `src/registry.rs` (e.g., `E402`).
-3. Define the logic for triggering the violation in `src/checkers/ast.rs` (for AST-based checks),
-   `src/checkers/tokens.rs` (for token-based checks), or `src/checkers/lines.rs` (for text-based checks).
-4. Add a test fixture.
-5. Update the generated files (documentation and generated code).
+1. Create a file for your rule (e.g., `src/rules/flake8_bugbear/rules/abstract_base_class.rs`).
+2. In that file, define a violation struct. You can grep for `define_violation!` to see examples.
+3. Map the violation struct to a rule code in `src/registry.rs` (e.g., `E402`).
+4. Define the logic for triggering the violation in `src/checkers/ast.rs` (for AST-based checks),
+   `src/checkers/tokens.rs` (for token-based checks), `src/checkers/lines.rs` (for text-based
+   checks), or `src/checkers/filesystem.rs` (for filesystem-based checks).
+5. Add a test fixture.
+6. Update the generated files (documentation and generated code).
 
-To define the violation, open up `src/violations.rs`, and define a new struct using the
-`define_violation!` macro. There are plenty of examples in that file, so feel free to pattern-match
-against the existing structs.
+To define the violation, start by creating a dedicated file for your rule under the appropriate
+rule origin (e.g., `src/rules/flake8_bugbear/rules/abstract_base_class.rs`). That file should
+contain a struct defined via `define_violation!`, along with a function that creates the violation
+based on any required inputs. (Many of the existing examples live in `src/violations.rs`, but we're
+looking to place new rules in their own files.)
 
 To trigger the violation, you'll likely want to augment the logic in `src/checkers/ast.rs`, which
 defines the Python AST visitor, responsible for iterating over the abstract syntax tree and

Cargo.lock

@@ -735,7 +735,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.217-dev.0"
+version = "0.0.227"
 dependencies = [
  "anyhow",
  "clap 4.0.32",
@@ -1364,6 +1364,27 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "num_enum"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf5395665662ef45796a4ff5486c5d41d29e0c09640af4c5f17fd94ee2c119c9"
+dependencies = [
+ "num_enum_derive",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0498641e53dd6ac1a4f22547548caa6864cc4933784319cd1775271c5a46ce"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.17.0"
@@ -1621,6 +1642,17 @@ dependencies = [
  "termtree",
 ]
 
+[[package]]
+name = "proc-macro-crate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eda0fc3b0fb7c975631757e14d9049da17374063edb6ebbcbc54d880d4fe94e9"
+dependencies = [
+ "once_cell",
+ "thiserror",
+ "toml",
+]
+
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -1874,27 +1906,19 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.217"
+version = "0.0.227"
 dependencies = [
- "annotate-snippets 0.9.1",
  "anyhow",
- "assert_cmd",
- "atty",
- "bincode",
  "bitflags",
- "cachedir",
  "cfg-if 1.0.0",
  "chrono",
  "clap 4.0.32",
- "clap_complete_command",
- "clearscreen",
  "colored",
  "console_error_panic_hook",
  "console_log",
  "criterion",
  "dirs 4.0.0",
  "fern",
- "filetime",
  "getrandom 0.2.8",
  "glob",
  "globset",
@@ -1906,13 +1930,10 @@ dependencies = [
  "log",
  "natord",
  "nohash-hasher",
- "notify",
  "num-bigint",
  "num-traits",
  "once_cell",
  "path-absolutize",
- "quick-junit",
- "rayon",
  "regex",
  "ropey",
  "ruff_macros",
@@ -1924,25 +1945,59 @@ dependencies = [
  "semver",
  "serde",
  "serde-wasm-bindgen",
- "serde_json",
  "shellexpand",
- "similar",
+ "smallvec",
  "strum",
  "strum_macros",
  "test-case",
  "textwrap",
+ "thiserror",
  "titlecase",
  "toml_edit",
- "update-informer",
- "ureq",
- "walkdir",
  "wasm-bindgen",
  "wasm-bindgen-test",
 ]
 
+[[package]]
+name = "ruff_cli"
+version = "0.0.227"
+dependencies = [
+ "annotate-snippets 0.9.1",
+ "anyhow",
+ "assert_cmd",
+ "atty",
+ "bincode",
+ "cachedir",
+ "chrono",
+ "clap 4.0.32",
+ "clap_complete_command",
+ "clearscreen",
+ "colored",
+ "filetime",
+ "glob",
+ "ignore",
+ "itertools",
+ "log",
+ "notify",
+ "path-absolutize",
+ "quick-junit",
+ "rayon",
+ "regex",
+ "ruff",
+ "rustc-hash",
+ "serde",
+ "serde_json",
+ "similar",
+ "strum",
+ "textwrap",
+ "update-informer",
+ "ureq",
+ "walkdir",
+]
+
 [[package]]
 name = "ruff_dev"
-version = "0.0.217"
+version = "0.0.227"
 dependencies = [
  "anyhow",
  "clap 4.0.32",
@@ -1950,6 +2005,7 @@ dependencies = [
  "libcst",
  "once_cell",
  "ruff",
+ "ruff_cli",
  "rustpython-ast",
  "rustpython-common",
  "rustpython-parser",
@@ -1962,7 +2018,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_macros"
-version = "0.0.217"
+version = "0.0.227"
 dependencies = [
  "once_cell",
  "proc-macro2",
@@ -2005,8 +2061,8 @@ dependencies = [
 
 [[package]]
 name = "rustpython-ast"
-version = "0.1.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=d532160333ffeb6dbeca2c2728c2391cd1e53b7f#d532160333ffeb6dbeca2c2728c2391cd1e53b7f"
+version = "0.2.0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=ff90fe52eea578c8ebdd9d95e078cc041a5959fa#ff90fe52eea578c8ebdd9d95e078cc041a5959fa"
 dependencies = [
  "num-bigint",
  "rustpython-common",
@@ -2015,8 +2071,8 @@ dependencies = [
 
 [[package]]
 name = "rustpython-common"
-version = "0.0.0"
-source = "git+https://github.com/RustPython/RustPython.git?rev=d532160333ffeb6dbeca2c2728c2391cd1e53b7f#d532160333ffeb6dbeca2c2728c2391cd1e53b7f"
+version = "0.2.0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=ff90fe52eea578c8ebdd9d95e078cc041a5959fa#ff90fe52eea578c8ebdd9d95e078cc041a5959fa"
 dependencies = [
  "ascii",
  "bitflags",
@@ -2040,8 +2096,8 @@ dependencies = [
 
 [[package]]
 name = "rustpython-compiler-core"
-version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=d532160333ffeb6dbeca2c2728c2391cd1e53b7f#d532160333ffeb6dbeca2c2728c2391cd1e53b7f"
+version = "0.2.0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=ff90fe52eea578c8ebdd9d95e078cc041a5959fa#ff90fe52eea578c8ebdd9d95e078cc041a5959fa"
 dependencies = [
  "bincode",
  "bitflags",
@@ -2050,15 +2106,15 @@ dependencies = [
  "lz4_flex",
  "num-bigint",
  "num-complex",
+ "num_enum",
  "serde",
- "static_assertions",
  "thiserror",
 ]
 
 [[package]]
 name = "rustpython-parser"
-version = "0.1.2"
-source = "git+https://github.com/RustPython/RustPython.git?rev=d532160333ffeb6dbeca2c2728c2391cd1e53b7f#d532160333ffeb6dbeca2c2728c2391cd1e53b7f"
+version = "0.2.0"
+source = "git+https://github.com/RustPython/RustPython.git?rev=ff90fe52eea578c8ebdd9d95e078cc041a5959fa#ff90fe52eea578c8ebdd9d95e078cc041a5959fa"
 dependencies = [
  "ahash",
  "anyhow",
@@ -2496,6 +2552,15 @@ dependencies = [
  "regex",
 ]
 
+[[package]]
+name = "toml"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1333c76748e868a4d9d1017b5ab53171dfd095f70c712fdb4653a406547f598f"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "toml_datetime"
 version = "0.5.0"

Cargo.toml

@@ -2,11 +2,13 @@
 members = [
   "flake8_to_ruff",
   "ruff_dev",
+  "ruff_cli",
 ]
+default-members = [".", "ruff_cli"]
 
 [package]
 name = "ruff"
-version = "0.0.217"
+version = "0.0.227"
 authors = ["Charlie Marsh <charlie.r.marsh@gmail.com>"]
 edition = "2021"
 rust-version = "1.65.0"
@@ -19,22 +21,17 @@ license = "MIT"
 [lib]
 name = "ruff"
 crate-type = ["cdylib", "rlib"]
+doctest = false
 
 [dependencies]
-annotate-snippets = { version = "0.9.1", features = ["color"] }
 anyhow = { version = "1.0.66" }
-atty = { version = "0.2.14" }
-bincode = { version = "1.3.3" }
 bitflags = { version = "1.3.2" }
-cachedir = { version = "0.3.0" }
 cfg-if = { version = "1.0.0" }
 chrono = { version = "0.4.21", default-features = false, features = ["clock"] }
 clap = { version = "4.0.1", features = ["derive", "env"] }
-clap_complete_command = { version = "0.4.0" }
 colored = { version = "2.0.0" }
 dirs = { version = "4.0.0" }
 fern = { version = "0.6.1" }
-filetime = { version = "0.2.17" }
 glob = { version = "0.3.0" }
 globset = { version = "0.4.9" }
 ignore = { version = "0.4.18" }
@@ -43,36 +40,28 @@ libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "f2f0b7a487a87
 log = { version = "0.4.17" }
 natord = { version = "1.0.9" }
 nohash-hasher = { version = "0.2.0" }
-notify = { version = "5.0.0" }
 num-bigint = { version = "0.4.3" }
 num-traits = "0.2.15"
 once_cell = { version = "1.16.0" }
 path-absolutize = { version = "3.0.14", features = ["once_cell_cache", "use_unix_paths_on_wasm"] }
-quick-junit = { version = "0.3.2" }
 regex = { version = "1.6.0" }
 ropey = { version = "1.5.0", features = ["cr_lines", "simd"], default-features = false }
-ruff_macros = { version = "0.0.217", path = "ruff_macros" }
+ruff_macros = { version = "0.0.227", path = "ruff_macros" }
 rustc-hash = { version = "1.1.0" }
-rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
-rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "d532160333ffeb6dbeca2c2728c2391cd1e53b7f" }
+rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "ff90fe52eea578c8ebdd9d95e078cc041a5959fa" }
+rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "ff90fe52eea578c8ebdd9d95e078cc041a5959fa" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/RustPython/RustPython.git", rev = "ff90fe52eea578c8ebdd9d95e078cc041a5959fa" }
 schemars = { version = "0.8.11" }
 semver = { version = "1.0.16" }
 serde = { version = "1.0.147", features = ["derive"] }
-serde_json = { version = "1.0.87" }
 shellexpand = { version = "3.0.0" }
-similar = { version = "2.2.1" }
+smallvec = { version = "1.10.0" }
 strum = { version = "0.24.1", features = ["strum_macros"] }
 strum_macros = { version = "0.24.3" }
 textwrap = { version = "0.16.0" }
 titlecase = { version = "2.2.1" }
 toml_edit = { version = "0.17.1", features = ["easy"] }
-walkdir = { version = "2.3.2" }
-
-[target.'cfg(not(target_family = "wasm"))'.dependencies]
-clearscreen = { version = "2.0.0" }
-rayon = { version = "1.5.3" }
-update-informer = { version = "0.6.0", default-features = false, features = ["pypi"], optional = true }
+thiserror = { version = "1.0" }
 
 # https://docs.rs/getrandom/0.2.7/getrandom/#webassembly-support
 # For (future) wasm-pack support
@@ -87,17 +76,11 @@ wasm-bindgen = { version = "0.2.83" }
 [dev-dependencies]
 insta = { version = "1.19.1", features = ["yaml"] }
 test-case = { version = "2.2.2" }
-ureq = { version = "2.5.0", features = [] }
 wasm-bindgen-test = { version = "0.3.33" }
 
 [target.'cfg(not(target_family = "wasm"))'.dev-dependencies]
-assert_cmd = { version = "2.0.4" }
 criterion = { version = "0.4.0" }
 
-[features]
-default = ["update-informer"]
-update-informer = ["dep:update-informer"]
-
 [profile.release]
 panic = "abort"
 lto = "thin"

build.rs

@@ -0,0 +1,84 @@
+use std::fs;
+use std::io::{BufRead, BufReader, BufWriter, Write};
+use std::path::{Path, PathBuf};
+
+fn main() {
+    let out_dir = PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
+    generate_origin_name_and_url(&out_dir);
+}
+
+const RULES_SUBMODULE_DOC_PREFIX: &str = "//! Rules from ";
+
+/// The `src/rules/*/mod.rs` files are expected to have a first line such as the
+/// following:
+///
+///     //! Rules from [Pyflakes](https://pypi.org/project/pyflakes/2.5.0/).
+///
+/// This function extracts the link label and url from these comments and
+/// generates the `name` and `url` functions for the `RuleOrigin` enum
+/// accordingly, so that they can be used by `ruff_dev::generate_rules_table`.
+fn generate_origin_name_and_url(out_dir: &Path) {
+    println!("cargo:rerun-if-changed=src/rules/");
+
+    let mut name_match_arms: String = r#"RuleOrigin::Ruff => "Ruff-specific rules","#.into();
+    let mut url_match_arms: String = r#"RuleOrigin::Ruff => None,"#.into();
+
+    for file in fs::read_dir("src/rules/")
+        .unwrap()
+        .flatten()
+        .filter(|f| f.file_type().unwrap().is_dir() && f.file_name() != "ruff")
+    {
+        let mod_rs_path = file.path().join("mod.rs");
+        let mod_rs_path = mod_rs_path.to_str().unwrap();
+        let first_line = BufReader::new(fs::File::open(mod_rs_path).unwrap())
+            .lines()
+            .next()
+            .unwrap()
+            .unwrap();
+
+        let Some(comment) = first_line.strip_prefix(RULES_SUBMODULE_DOC_PREFIX) else {
+                panic!("expected first line in {mod_rs_path} to start with `{RULES_SUBMODULE_DOC_PREFIX}`")
+            };
+        let md_link = comment.trim_end_matches('.');
+
+        let (name, url) = md_link
+            .strip_prefix('[')
+            .unwrap()
+            .strip_suffix(')')
+            .unwrap()
+            .split_once("](")
+            .unwrap();
+
+        let dirname = file.file_name();
+        let dirname = dirname.to_str().unwrap();
+
+        let variant_name = dirname
+            .split('_')
+            .map(|part| match part {
+                "errmsg" => "ErrMsg".to_string(),
+                "mccabe" => "McCabe".to_string(),
+                "pep8" => "PEP8".to_string(),
+                _ => format!("{}{}", part[..1].to_uppercase(), &part[1..]),
+            })
+            .collect::<String>();
+
+        name_match_arms.push_str(&format!(r#"RuleOrigin::{variant_name} => "{name}","#));
+        url_match_arms.push_str(&format!(r#"RuleOrigin::{variant_name} => Some("{url}"),"#));
+    }
+
+    write!(
+        BufWriter::new(fs::File::create(out_dir.join("origin.rs")).unwrap()),
+        "
+        impl RuleOrigin {{
+            pub fn name(&self) -> &'static str {{
+                match self {{ {name_match_arms} }}
+            }}
+
+            pub fn url(&self) -> Option<&'static str> {{
+                match self {{ {url_match_arms} }}
+            }}
+        }}
+        "
+    )
+    .unwrap();
+}

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.217"
+version = "0.0.227"
 dependencies = [
  "anyhow",
  "clap",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.217"
+version = "0.0.227"
 dependencies = [
  "anyhow",
  "bincode",

flake8_to_ruff/Cargo.toml

@@ -1,11 +1,8 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.217-dev.0"
+version = "0.0.227"
 edition = "2021"
 
-[lib]
-name = "flake8_to_ruff"
-
 [dependencies]
 anyhow = { version = "1.0.66" }
 clap = { version = "4.0.1", features = ["derive"] }

flake8_to_ruff/src/lib.rs

@@ -1,18 +0,0 @@
-#![allow(
-    clippy::collapsible_else_if,
-    clippy::collapsible_if,
-    clippy::implicit_hasher,
-    clippy::match_same_arms,
-    clippy::missing_errors_doc,
-    clippy::missing_panics_doc,
-    clippy::module_name_repetitions,
-    clippy::must_use_candidate,
-    clippy::similar_names,
-    clippy::too_many_lines
-)]
-#![forbid(unsafe_code)]
-
-pub mod black;
-pub mod converter;
-mod parser;
-pub mod plugin;

flake8_to_ruff/src/main.rs

@@ -1,4 +1,4 @@
-//! Utility to generate Ruff's pyproject.toml section from a Flake8 INI file.
+//! Utility to generate Ruff's `pyproject.toml` section from a Flake8 INI file.
 #![allow(
     clippy::collapsible_else_if,
     clippy::collapsible_if,
@@ -18,9 +18,7 @@ use std::path::PathBuf;
 use anyhow::Result;
 use clap::Parser;
 use configparser::ini::Ini;
-use flake8_to_ruff::black::parse_black_options;
-use flake8_to_ruff::converter;
-use flake8_to_ruff::plugin::Plugin;
+use ruff::flake8_to_ruff;
 
 #[derive(Parser)]
 #[command(
@@ -38,7 +36,7 @@ struct Cli {
     pyproject: Option<PathBuf>,
     /// List of plugins to enable.
     #[arg(long, value_delimiter = ',')]
-    plugin: Option<Vec<Plugin>>,
+    plugin: Option<Vec<flake8_to_ruff::Plugin>>,
 }
 
 fn main() -> Result<()> {
@@ -52,12 +50,12 @@ fn main() -> Result<()> {
     // Read the pyproject.toml file.
     let black = cli
         .pyproject
-        .map(parse_black_options)
+        .map(flake8_to_ruff::parse_black_options)
         .transpose()?
         .flatten();
 
     // Create Ruff's pyproject.toml section.
-    let pyproject = converter::convert(&config, black.as_ref(), cli.plugin)?;
+    let pyproject = flake8_to_ruff::convert(&config, black.as_ref(), cli.plugin)?;
     println!("{}", toml_edit::easy::to_string_pretty(&pyproject)?);
 
     Ok(())

licenses/LICENSE_PyCQA_flake8-commas

@@ -0,0 +1,45 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Thomas Grainger.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+
+Portions of this flake8-commas Software may utilize the following
+copyrighted material, the use of which is hereby acknowledged.
+
+Original flake8-commas: https://github.com/trevorcreech/flake8-commas/commit/e8563b71b1d5442e102c8734c11cb5202284293d
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

licenses/LICENSE_adamchainz_flake8-no-pep420

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Adam Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyproject.toml

@@ -1,10 +1,13 @@
 [build-system]
-requires = ["maturin>=0.14,<0.15"]
+requires = ["maturin>=0.14.10,<0.15"]
+# We depend on >=0.14.10 because we specify name in
+# [package.metadata.maturin] in ruff_cli/Cargo.toml.
+
 build-backend = "maturin"
 
 [project]
 name = "ruff"
-version = "0.0.217"
+version = "0.0.227"
 description = "An extremely fast Python linter, written in Rust."
 authors = [
   { name = "Charlie Marsh", email = "charlie.r.marsh@gmail.com" },
@@ -35,10 +38,6 @@ urls = { repository = "https://github.com/charliermarsh/ruff" }
 
 [tool.maturin]
 bindings = "bin"
+manifest-path = "ruff_cli/Cargo.toml"
+python-source = "python"
 strip = true
-
-[tool.setuptools]
-license-files = [
-  "LICENSE",
-  "licenses/*",
-]

resources/test/fixtures/flake8_annotations/allow_nested_overload.py

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

resources/test/fixtures/flake8_bandit/S508.py

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

resources/test/fixtures/flake8_bandit/S509.py

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

resources/test/fixtures/flake8_bandit/S701.py

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

resources/test/fixtures/flake8_bugbear/B023.py

@@ -25,10 +25,10 @@ for x in range(3):
 
 
 def check_inside_functions_too():
-    ls = [lambda: x for x in range(2)]
-    st = {lambda: x for x in range(2)}
-    gn = (lambda: x for x in range(2))
-    dt = {x: lambda: x for x in range(2)}
+    ls = [lambda: x for x in range(2)]  # error
+    st = {lambda: x for x in range(2)}  # error
+    gn = (lambda: x for x in range(2))  # error
+    dt = {x: lambda: x for x in range(2)}  # error
 
 
 async def pointless_async_iterable():
@@ -37,9 +37,9 @@ async def pointless_async_iterable():
 
 async def container_for_problems():
     async for x in pointless_async_iterable():
-        functions.append(lambda: x)
+        functions.append(lambda: x)  # error
 
-    [lambda: x async for x in pointless_async_iterable()]
+    [lambda: x async for x in pointless_async_iterable()]  # error
 
 
 a = 10
@@ -47,10 +47,10 @@ b = 0
 while True:
     a = a_ = a - 1
     b += 1
-    functions.append(lambda: a)
-    functions.append(lambda: a_)
-    functions.append(lambda: b)
-    functions.append(lambda: c)  # not a name error because of late binding!
+    functions.append(lambda: a)  # error
+    functions.append(lambda: a_)  # error
+    functions.append(lambda: b)  # error
+    functions.append(lambda: c)  # error, but not a name error due to late binding
     c: bool = a > 3
     if not c:
         break
@@ -58,7 +58,7 @@ while True:
 # Nested loops should not duplicate reports
 for j in range(2):
     for k in range(3):
-        lambda: j * k
+        lambda: j * k  # error
 
 
 for j, k, l in [(1, 2, 3)]:
@@ -80,3 +80,95 @@ for var in range(2):
 
 for i in range(3):
     lambda: f"{i}"
+
+
+# `query` is defined in the function, so also defining it in the loop should be OK.
+for name in ["a", "b"]:
+    query = name
+
+    def myfunc(x):
+        query = x
+        query_post = x
+        _ = query
+        _ = query_post
+
+    query_post = name  # in case iteration order matters
+
+
+# Bug here because two dict comprehensions reference `name`, one of which is inside
+# the lambda.  This should be totally fine, of course.
+_ = {
+    k: v
+    for k, v in reduce(
+        lambda data, event: merge_mappings(
+            [data, {name: f(caches, data, event) for name, f in xx}]
+        ),
+        events,
+        {name: getattr(group, name) for name in yy},
+    ).items()
+    if k in backfill_fields
+}
+
+
+# OK to define lambdas if they're immediately consumed, typically as the `key=`
+# argument or in a consumed `filter()` (even if a comprehension is better style)
+for x in range(2):
+    # It's not a complete get-out-of-linting-free construct - these should fail:
+    min([None, lambda: x], key=repr)
+    sorted([None, lambda: x], key=repr)
+    any(filter(bool, [None, lambda: x]))
+    list(filter(bool, [None, lambda: x]))
+    all(reduce(bool, [None, lambda: x]))
+
+    # But all these should be OK:
+    min(range(3), key=lambda y: x * y)
+    max(range(3), key=lambda y: x * y)
+    sorted(range(3), key=lambda y: x * y)
+
+    any(map(lambda y: x < y, range(3)))
+    all(map(lambda y: x < y, range(3)))
+    set(map(lambda y: x < y, range(3)))
+    list(map(lambda y: x < y, range(3)))
+    tuple(map(lambda y: x < y, range(3)))
+    sorted(map(lambda y: x < y, range(3)))
+    frozenset(map(lambda y: x < y, range(3)))
+
+    any(filter(lambda y: x < y, range(3)))
+    all(filter(lambda y: x < y, range(3)))
+    set(filter(lambda y: x < y, range(3)))
+    list(filter(lambda y: x < y, range(3)))
+    tuple(filter(lambda y: x < y, range(3)))
+    sorted(filter(lambda y: x < y, range(3)))
+    frozenset(filter(lambda y: x < y, range(3)))
+
+    any(reduce(lambda y: x | y, range(3)))
+    all(reduce(lambda y: x | y, range(3)))
+    set(reduce(lambda y: x | y, range(3)))
+    list(reduce(lambda y: x | y, range(3)))
+    tuple(reduce(lambda y: x | y, range(3)))
+    sorted(reduce(lambda y: x | y, range(3)))
+    frozenset(reduce(lambda y: x | y, range(3)))
+
+    import functools
+
+    any(functools.reduce(lambda y: x | y, range(3)))
+    all(functools.reduce(lambda y: x | y, range(3)))
+    set(functools.reduce(lambda y: x | y, range(3)))
+    list(functools.reduce(lambda y: x | y, range(3)))
+    tuple(functools.reduce(lambda y: x | y, range(3)))
+    sorted(functools.reduce(lambda y: x | y, range(3)))
+    frozenset(functools.reduce(lambda y: x | y, range(3)))
+
+# OK because the lambda which references a loop variable is defined in a `return`
+# statement, and after we return the loop variable can't be redefined.
+# In principle we could do something fancy with `break`, but it's not worth it.
+def iter_f(names):
+    for name in names:
+        if exists(name):
+            return lambda: name if exists(name) else None
+
+        if foo(name):
+            return [lambda: name]  # known false alarm
+
+        if False:
+            return [lambda: i for i in range(3)]  # error

resources/test/fixtures/flake8_bugbear/B024.py

@@ -1,15 +1,16 @@
 """
 Should emit:
-B024 - on lines 17, 34, 52, 58, 69, 74, 79, 84, 89
+B024 - on lines 18, 71, 82, 87, 92, 141
 """
 
 import abc
 import abc as notabc
 from abc import ABC, ABCMeta
-from abc import abstractmethod
+from abc import abstractmethod, abstractproperty
 from abc import abstractmethod as abstract
 from abc import abstractmethod as abstractaoeuaoeuaoeu
 from abc import abstractmethod as notabstract
+from abc import abstractproperty as notabstract_property
 
 import foo
 
@@ -49,12 +50,24 @@ class Base_6(ABC):
         foo()
 
 
-class Base_7(ABC):  # error
+class Base_7(ABC):
     @notabstract
     def method(self):
         foo()
 
 
+class Base_8(ABC):
+    @notabstract_property
+    def method(self):
+        foo()
+
+
+class Base_9(ABC):
+    @abstractproperty
+    def method(self):
+        foo()
+
+
 class MetaBase_1(metaclass=ABCMeta):  # error
     def method(self):
         foo()

resources/test/fixtures/flake8_bugbear/B027.py

@@ -1,11 +1,12 @@
 """
 Should emit:
-B027 - on lines 12, 15, 18, 22, 30
+B027 - on lines 13, 16, 19, 23
 """
 import abc
 from abc import ABC
-from abc import abstractmethod
+from abc import abstractmethod, abstractproperty
 from abc import abstractmethod as notabstract
+from abc import abstractproperty as notabstract_property
 
 
 class AbstractClass(ABC):
@@ -42,6 +43,18 @@ class AbstractClass(ABC):
     def abstract_3(self):
         ...
 
+    @abc.abstractproperty
+    def abstract_4(self):
+        ...
+
+    @abstractproperty
+    def abstract_5(self):
+        ...
+
+    @notabstract_property
+    def abstract_6(self):
+        ...
+
     def body_1(self):
         print("foo")
         ...

resources/test/fixtures/flake8_commas/COM81.py

@@ -0,0 +1,628 @@
+# ==> bad_function_call.py <==
+bad_function_call(
+    param1='test',
+    param2='test'
+)
+# ==> bad_list.py <==
+bad_list = [
+    1,
+    2,
+    3
+]
+
+bad_list_with_comment = [
+    1,
+    2,
+    3
+    # still needs a comma!
+]
+
+bad_list_with_extra_empty = [
+    1,
+    2,
+    3
+
+
+
+]
+
+# ==> bare.py <==
+bar = 1, 2
+
+foo = 1
+
+foo = (1,)
+
+foo = 1,
+
+bar = 1; foo = bar,
+
+foo = (
+3,
+4,
+)
+
+foo = 3, 
+
+class A(object):
+ foo = 3
+ bar = 10,
+ foo_bar = 2
+
+a = ('a',)
+
+from foo import bar, baz
+
+group_by = function_call('arg'),
+
+group_by = ('foobar' * 3),
+
+def foo():
+    return False,
+
+==> callable_before_parenth_form.py <==
+def foo(
+    bar,
+):
+    pass
+
+{'foo': foo}['foo'](
+    bar
+)
+
+{'foo': foo}['foo'](
+    bar,
+)
+
+(foo)(
+    bar
+)
+
+(foo)[0](
+    bar,
+)
+
+[foo][0](
+    bar
+)
+
+[foo][0](
+    bar,
+)
+
+# ==> comment_good_dict.py <==
+multiline_good_dict = {
+    "good": 123,  # this is a good number
+}
+
+# ==> dict_comprehension.py <==
+not_a_dict = {
+    x: y
+    for x, y in ((1, 2), (3, 4))
+}
+
+# ==> good_empty_comma_context.py <==
+def func2(
+):
+    pass
+
+
+func2(
+
+)
+
+func2(
+)
+
+[
+]
+
+[
+
+]
+
+(
+)
+
+(
+
+)
+
+{
+
+}
+
+# ==> good_list.py <==
+stuff = [
+   'a',
+   'b',
+   # more stuff will go here
+]
+
+more_stuff = [
+    'a',
+    'b',
+
+
+
+]
+
+# ==> keyword_before_parenth_form/base_bad.py <==
+from x import (
+    y
+)
+
+assert(
+    SyntaxWarning,
+    ThrownHere,
+    Anyway
+)
+
+# async await is fine outside an async def
+# ruff: RustPython tokenizer treats async/await as keywords, not applicable.
+
+# def await(
+#     foo
+# ):
+#     async(
+#         foo
+#     )
+
+# def async(
+#     foo
+# ):
+#     await(
+#         foo
+#     )
+
+# ==> keyword_before_parenth_form/base.py <==
+from x import (
+    y,
+)
+
+assert(
+    SyntaxWarning,
+    ThrownHere,
+    Anyway,
+)
+
+assert (
+    foo
+)
+
+assert (
+    foo and
+    bar
+)
+
+if(
+    foo and
+    bar
+):
+    pass
+elif(
+    foo and
+    bar
+):
+    pass
+
+for x in(
+    [1,2,3]
+):
+    print(x)
+
+
+(x for x in (
+    [1, 2, 3]
+))
+
+(
+    'foo'
+) is (
+    'foo'
+)
+
+if (
+    foo and
+    bar
+) or not (
+    foo
+) or (
+    spam
+):
+    pass
+
+def xyz():
+    raise(
+        Exception()
+    )
+
+def abc():
+    return(
+        3
+    )
+
+while(
+    False
+):
+    pass
+
+with(
+    loop
+):
+    pass
+
+def foo():
+    yield (
+        "foo"
+    )
+
+# async await is fine outside an async def
+# ruff: RustPython tokenizer treats async/await as keywords, not applicable.
+
+# def await(
+#     foo,
+# ):
+#     async(
+#         foo,
+#     )
+
+# def async(
+#     foo,
+# ):
+#     await(
+#         foo,
+#     )
+
+# ==> keyword_before_parenth_form/py3.py <==
+# Syntax error in Py2
+
+def foo():
+    yield from (
+        foo
+    )
+
+# ==> list_comprehension.py <==
+not_a_list = [
+    s.strip()
+    for s in 'foo, bar, baz'.split(',')
+]
+
+# ==> multiline_bad_dict.py <==
+multiline_bad_dict = {
+    "bad": 123
+}
+# ==> multiline_bad_function_def.py <==
+def func_good(
+        a = 3,
+        b = 2):
+    pass
+
+
+def func_bad(
+        a = 3,
+        b = 2
+    ):
+    pass
+
+# ==> multiline_bad_function_one_param.py <==
+def func(
+        a = 3
+    ):
+    pass
+
+
+func(
+    a = 3
+)
+
+# ==> multiline_bad_or_dict.py <==
+multiline_bad_or_dict = {
+    "good": True or False,
+    "bad": 123
+}
+
+# ==> multiline_good_dict.py <==
+multiline_good_dict = {
+    "good": 123,
+}
+# ==> multiline_good_single_keyed_for_dict.py <==
+good_dict = {
+    "good": x for x in y
+}
+
+# ==> multiline_if.py <==
+if (
+    foo
+    and bar
+):
+    print("Baz")
+
+# ==> multiline_index_access.py <==
+multiline_index_access[
+    "good"
+]
+
+multiline_index_access_after_function()[
+    "good"
+]
+
+multiline_index_access_after_inline_index_access['first'][
+    "good"
+]
+
+multiline_index_access[
+    "probably fine",
+]
+
+[0, 1, 2][
+    "good"
+]
+
+[0, 1, 2][
+    "probably fine",
+]
+
+multiline_index_access[
+    "probably fine",
+    "not good"
+]
+
+multiline_index_access[
+    "fine",
+    "fine",
+    :
+    "not good"
+]
+
+# ==> multiline_string.py <==
+s = (
+    'this' +
+    'is a string'
+)
+
+s2 = (
+    'this'
+    'is a also a string'
+)
+
+t = (
+    'this' +
+    'is a tuple',
+)
+
+t2 = (
+    'this'
+    'is also a tuple',
+)
+
+# ==> multiline_subscript_slice.py <==
+multiline_index_access[
+    "fine",
+    "fine"
+    :
+    "not fine"
+]
+
+multiline_index_access[
+    "fine"
+    "fine"
+    :
+    "fine"
+    :
+    "fine"
+]
+
+multiline_index_access[
+    "fine"
+    "fine",
+    :
+    "fine",
+    :
+    "fine",
+]
+
+multiline_index_access[
+    "fine"
+    "fine",
+    :
+    "fine"
+    :
+    "fine",
+    "not fine"
+]
+
+multiline_index_access[
+    "fine"
+    "fine",
+    :
+    "fine",
+    "fine"
+    :
+    "fine",
+]
+
+multiline_index_access[
+    lambda fine,
+    fine,
+    fine: (0,)
+    :
+    lambda fine,
+    fine,
+    fine: (0,),
+    "fine"
+    :
+    "fine",
+]
+
+# ==> one_line_dict.py <==
+one_line_dict = {"good": 123}
+# ==> parenth_form.py <==
+parenth_form = (
+    a +
+    b +
+    c
+)
+
+parenth_form_with_lambda = (
+    lambda x, y: 0
+)
+
+parenth_form_with_default_lambda = (
+    lambda x=(
+        lambda
+        x,
+        y,
+        :
+        0
+    ),
+    y = {a: b},
+    :
+    0
+)
+
+# ==> prohibited.py <==
+foo = ['a', 'b', 'c',]
+
+bar = { a: b,}
+
+def bah(ham, spam,):
+    pass
+
+(0,)
+
+(0, 1,)
+
+foo = ['a', 'b', 'c', ]
+
+bar = { a: b, }
+
+def bah(ham, spam, ):
+    pass
+
+(0, )
+
+(0, 1, )
+
+image[:, :, 0]
+
+image[:,]
+
+image[:,:,]
+
+lambda x, :
+
+# ==> unpack.py <==
+def function(
+    foo,
+    bar,
+    **kwargs
+):
+    pass
+
+def function(
+    foo,
+    bar,
+    *args
+):
+    pass
+
+def function(
+    foo,
+    bar,
+    *args,
+    extra_kwarg
+    ):
+    pass
+
+result = function(
+    foo,
+    bar,
+    **kwargs
+)
+
+result = function(
+    foo,
+    bar,
+    **not_called_kwargs
+)
+
+def foo(
+    ham,
+    spam,
+    *args,
+    kwarg_only
+    ):
+    pass
+
+# In python 3.5 if it's not a function def, commas are mandatory.
+
+foo(
+    **kwargs
+)
+
+{
+    **kwargs
+}
+
+(
+    *args
+)
+
+{
+    *args
+}
+
+[
+    *args
+]
+
+def foo(
+    ham,
+    spam,
+    *args
+    ):
+    pass
+
+def foo(
+    ham,
+    spam,
+    **kwargs
+    ):
+    pass
+
+def foo(
+    ham,
+    spam,
+    *args,
+    kwarg_only
+    ):
+    pass
+
+# In python 3.5 if it's not a function def, commas are mandatory.
+
+foo(
+    **kwargs,
+)
+
+{
+    **kwargs,
+}
+
+(
+    *args,
+)
+
+{
+    *args,
+}
+
+[
+    *args,
+]
+
+result = function(
+    foo,
+    bar,
+    **{'ham': spam}
+)

resources/test/fixtures/flake8_comprehensions/C400.py

@@ -2,3 +2,10 @@ x = list(x for x in range(3))
 x = list(
     x for x in range(3)
 )
+
+
+def list(*args, **kwargs):
+    return None
+
+
+list(x for x in range(3))

resources/test/fixtures/flake8_comprehensions/C401.py

@@ -2,3 +2,10 @@ x = set(x for x in range(3))
 x = set(
     x for x in range(3)
 )
+
+
+def set(*args, **kwargs):
+    return None
+
+
+set(x for x in range(3))

resources/test/fixtures/flake8_comprehensions/C405.py

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

resources/test/fixtures/flake8_comprehensions/C408.py

@@ -3,3 +3,10 @@ l = list()
 d1 = dict()
 d2 = dict(a=1)
 d3 = dict(**d2)
+
+
+def list():
+    return [1, 2, 3]
+
+
+a = list()

resources/test/fixtures/flake8_comprehensions/C413.py

@@ -4,3 +4,10 @@ list(sorted(x))
 reversed(sorted(x))
 reversed(sorted(x, key=lambda e: e))
 reversed(sorted(x, reverse=True))
+
+
+def reversed(*args, **kwargs):
+    return None
+
+
+reversed(sorted(x, reverse=True))

resources/test/fixtures/flake8_no_pep420/test_fail_nonempty/example.py

@@ -0,0 +1 @@
+print('hi')

resources/test/fixtures/flake8_no_pep420/test_fail_shebang/example.py

@@ -0,0 +1,2 @@
+#!/bin/env/python
+print('hi')

resources/test/fixtures/flake8_no_pep420/test_ignored/example.py

@@ -0,0 +1 @@
+import os  # noqa: INP001

resources/test/fixtures/flake8_pie/PIE794.py

@@ -31,3 +31,10 @@ class User(BaseModel):
     @buzz.setter
     def buzz(self, value: str | int) -> None:
         ...
+
+
+class User:
+    bar: str = StringField()
+    foo: bool = BooleanField()
+    # ...
+    bar = StringField()  # PIE794

resources/test/fixtures/flake8_pie/PIE796.py

@@ -0,0 +1,66 @@
+import enum
+from enum import Enum, unique
+
+
+class FakeEnum1(enum.Enum):
+    A = "A"
+    B = "B"
+    C = "B"  # PIE796
+
+
+class FakeEnum2(Enum):
+    A = 1
+    B = 2
+    C = 2  # PIE796
+
+
+class FakeEnum3(str, Enum):
+    A = "1"
+    B = "2"
+    C = "2"  # PIE796
+
+
+class FakeEnum4(Enum):
+    A = 1.0
+    B = 2.5
+    C = 2.5  # PIE796
+
+
+class FakeEnum5(Enum):
+    A = 1.0
+    B = True
+    C = False
+    D = False  # PIE796
+
+
+class FakeEnum6(Enum):
+    A = 1
+    B = 2
+    C = None
+    D = None  # PIE796
+
+
+@enum.unique
+class FakeEnum7(enum.Enum):
+    A = "A"
+    B = "B"
+    C = "C"
+
+
+@unique
+class FakeEnum8(Enum):
+    A = 1
+    B = 2
+    C = 2  # PIE796
+
+
+class FakeEnum9(enum.Enum):
+    A = "A"
+    B = "B"
+    C = "C"
+
+
+class FakeEnum10(enum.Enum):
+    A = enum.auto()
+    B = enum.auto()
+    C = enum.auto()

resources/test/fixtures/flake8_pytest_style/PT007.py

@@ -53,3 +53,25 @@ def test_list_of_tuples(param1, param2):
 )
 def test_list_of_lists(param1, param2):
     ...
+
+
+@pytest.mark.parametrize(
+    "param1,param2",
+    [
+        [1, 2],
+        [3, 4],
+    ],
+)
+def test_csv_name_list_of_lists(param1, param2):
+    ...
+
+
+@pytest.mark.parametrize(
+    "param",
+    [
+        [1, 2],
+        [3, 4],
+    ],
+)
+def test_single_list_of_lists(param):
+    ...

resources/test/fixtures/flake8_quotes/docstring_doubles_function.py

@@ -17,6 +17,15 @@ def fun_with_params_no_docstring(a, b="""
 """ """docstring"""):
     pass
 
+
 def fun_with_params_no_docstring2(a, b=c[foo():], c=\
     """ not a docstring """):
     pass
+
+
+def function_with_single_docstring(a):
+    "Single line docstring"
+
+
+def double_inside_single(a):
+    'Double inside "single "'

resources/test/fixtures/flake8_quotes/docstring_singles_function.py

@@ -13,11 +13,19 @@ def foo2():
 
 
 def fun_with_params_no_docstring(a, b='''
-    not a 
+    not a
 ''' '''docstring'''):
     pass
 
+
 def fun_with_params_no_docstring2(a, b=c[foo():], c=\
     ''' not a docstring '''):
     pass
 
+
+def function_with_single_docstring(a):
+    'Single line docstring'
+
+
+def double_inside_single(a):
+    "Double inside 'single '"

resources/test/fixtures/flake8_quotes/doubles_escaped.py

@@ -1,4 +1,5 @@
 this_should_raise_Q003 = 'This is a \'string\''
+this_should_raise_Q003 = 'This is \\ a \\\'string\''
 this_is_fine = '"This" is a \'string\''
 this_is_fine = "This is a 'string'"
 this_is_fine = "\"This\" is a 'string'"

resources/test/fixtures/flake8_simplify/SIM102.py

@@ -1,25 +1,88 @@
-if a:  # SIM102
+# SIM102
+if a:
     if b:
         c
 
-
+# SIM102
 if a:
     pass
-elif b:  # SIM102
+elif b:
     if c:
         d
 
+# SIM102
+if a:
+    # Unfixable due to placement of this comment.
+    if b:
+        c
+
+# SIM102
+if a:
+    if b:
+        # Fixable due to placement of this comment.
+        c
+
+# OK
 if a:
     if b:
         c
     else:
         d
 
+# OK
 if __name__ == "__main__":
     if foo():
         ...
 
+# OK
 if a:
     d
     if b:
         c
+
+while True:
+    # SIM102
+    if True:
+        if True:
+            """this
+is valid"""
+
+            """the indentation on
+            this line is significant"""
+
+            "this is" \
+"allowed too"
+
+            ("so is"
+"this for some reason")
+
+
+# SIM102
+if True:
+    if True:
+        """this
+is valid"""
+
+        """the indentation on
+        this line is significant"""
+
+        "this is" \
+"allowed too"
+
+        ("so is"
+"this for some reason")
+
+while True:
+    # SIM102
+    if node.module:
+        if node.module == "multiprocessing" or node.module.startswith(
+            "multiprocessing."
+        ):
+            print("Bad module!")
+
+# SIM102
+if node.module:
+    if node.module == "multiprocessing" or node.module.startswith(
+        "multiprocessing."
+    ):
+        print("Bad module!")

resources/test/fixtures/flake8_simplify/SIM103.py

@@ -1,12 +1,35 @@
 def f():
-    if a:  # SIM103
+    # SIM103
+    if a:
         return True
     else:
         return False
 
 
 def f():
-    if a:  # OK
+    # SIM103
+    if a:
+        return 1
+    elif b:
+        return True
+    else:
+        return False
+
+
+def f():
+    # SIM103
+    if a:
+        return 1
+    else:
+        if b:
+            return True
+        else:
+            return False
+
+
+def f():
+    # OK
+    if a:
         foo()
         return True
     else:
@@ -14,7 +37,8 @@ def f():
 
 
 def f():
-    if a:  # OK
+    # OK
+    if a:
         return "foo"
     else:
         return False

resources/test/fixtures/flake8_simplify/SIM105.py

@@ -41,3 +41,21 @@ except ValueError:
     pass
 finally:
     print('bar')
+
+try:
+    foo()
+    foo()
+except ValueError:
+    pass
+
+try:
+    for i in range(3):
+        foo()
+except ValueError:
+    pass
+
+def bar():
+    try:
+        return foo()
+    except ValueError:
+        pass

resources/test/fixtures/flake8_simplify/SIM108.py

@@ -1,13 +1,13 @@
-# Bad
+# SIM108
 if a:
     b = c
 else:
     b = d
 
-# Good
+# OK
 b = c if a else d
 
-# https://github.com/MartinThoma/flake8-simplify/issues/115
+# OK
 if a:
     b = c
 elif c:
@@ -15,6 +15,7 @@ elif c:
 else:
     b = d
 
+# OK
 if True:
     pass
 elif a:
@@ -22,6 +23,7 @@ elif a:
 else:
     b = 2
 
+# OK (false negative)
 if True:
     pass
 else:
@@ -30,19 +32,62 @@ else:
     else:
         b = 2
 
+
 import sys
 
+# OK
 if sys.version_info >= (3, 9):
     randbytes = random.randbytes
 else:
     randbytes = _get_random_bytes
 
+# OK
 if sys.platform == "darwin":
     randbytes = random.randbytes
 else:
     randbytes = _get_random_bytes
 
+# OK
 if sys.platform.startswith("linux"):
     randbytes = random.randbytes
 else:
     randbytes = _get_random_bytes
+
+
+# OK (includes comments)
+if x > 0:
+    # test test
+    abc = x
+else:
+    # test test test
+    abc = -x
+
+
+# OK (too long)
+if parser.errno == BAD_FIRST_LINE:
+    req = wrappers.Request(sock, server=self._server)
+else:
+    req = wrappers.Request(
+        sock,
+        parser.get_method(),
+        parser.get_scheme() or _scheme,
+        parser.get_path(),
+        parser.get_version(),
+        parser.get_query_string(),
+        server=self._server,
+    )
+
+
+# SIM108
+if a:
+    b = cccccccccccccccccccccccccccccccccccc
+else:
+    b = ddddddddddddddddddddddddddddddddddddd
+
+
+# OK (too long)
+if True:
+    if a:
+        b = cccccccccccccccccccccccccccccccccccc
+    else:
+        b = ddddddddddddddddddddddddddddddddddddd

resources/test/fixtures/flake8_simplify/SIM109.py

@@ -1,7 +1,31 @@
-# Bad
+# SIM109
 if a == b or a == c:
     d
 
-# Good
+# SIM109
+if (a == b or a == c) and None:
+    d
+
+# SIM109
+if a == b or a == c or None:
+    d
+
+# SIM109
+if a == b or None or a == c:
+    d
+
+# OK
 if a in (b, c):
-    d
+    d
+
+# OK
+if a == b or a == c():
+    d
+
+# OK
+if (
+    a == b
+    # This comment prevents us from raising SIM109
+    or a == c
+):
+    d

resources/test/fixtures/flake8_simplify/SIM110.py

@@ -1,5 +1,6 @@
 def f():
-    for x in iterable:  # SIM110
+    # SIM110
+    for x in iterable:
         if check(x):
             return True
     return False
@@ -20,14 +21,16 @@ def f():
 
 
 def f():
-    for x in iterable:  # SIM111
+    # SIM111
+    for x in iterable:
         if check(x):
             return False
     return True
 
 
 def f():
-    for x in iterable:  # SIM111
+    # SIM111
+    for x in iterable:
         if not x.is_empty():
             return False
     return True
@@ -45,3 +48,70 @@ def f():
         if check(x):
             return "foo"
     return "bar"
+
+
+def f():
+    # SIM110
+    for x in iterable:
+        if check(x):
+            return True
+    else:
+        return False
+
+
+def f():
+    # SIM111
+    for x in iterable:
+        if check(x):
+            return False
+    else:
+        return True
+
+
+def f():
+    # SIM110
+    for x in iterable:
+        if check(x):
+            return True
+    else:
+        return False
+    return True
+
+
+def f():
+    # SIM111
+    for x in iterable:
+        if check(x):
+            return False
+    else:
+        return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        elif x.is_empty():
+            return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        else:
+            return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        elif x.is_empty():
+            return True
+    else:
+        return True
+    return False

resources/test/fixtures/flake8_simplify/SIM111.py

@@ -1,10 +1,18 @@
 def f():
-    for x in iterable:  # SIM110
+    # SIM110
+    for x in iterable:
         if check(x):
             return True
     return False
 
 
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+    return True
+
+
 def f():
     for el in [1, 2, 3]:
         if is_true(el):
@@ -13,21 +21,97 @@ def f():
 
 
 def f():
-    for x in iterable:  # SIM111
+    # SIM111
+    for x in iterable:
         if check(x):
             return False
     return True
 
 
 def f():
-    for x in iterable:  # SIM 111
+    # SIM111
+    for x in iterable:
         if not x.is_empty():
             return False
     return True
 
 
+def f():
+    for x in iterable:
+        if check(x):
+            return False
+    return False
+
+
 def f():
     for x in iterable:
         if check(x):
             return "foo"
     return "bar"
+
+
+def f():
+    # SIM110
+    for x in iterable:
+        if check(x):
+            return True
+    else:
+        return False
+
+
+def f():
+    # SIM111
+    for x in iterable:
+        if check(x):
+            return False
+    else:
+        return True
+
+
+def f():
+    # SIM110
+    for x in iterable:
+        if check(x):
+            return True
+    else:
+        return False
+    return True
+
+
+def f():
+    # SIM111
+    for x in iterable:
+        if check(x):
+            return False
+    else:
+        return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        elif x.is_empty():
+            return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        else:
+            return True
+    return False
+
+
+def f():
+    for x in iterable:
+        if check(x):
+            return True
+        elif x.is_empty():
+            return True
+    else:
+        return True
+    return False

resources/test/fixtures/flake8_simplify/SIM112.py

@@ -0,0 +1,19 @@
+import os
+
+# Bad
+os.environ['foo']
+
+os.environ.get('foo')
+
+os.environ.get('foo', 'bar')
+
+os.getenv('foo')
+
+# Good
+os.environ['FOO']
+
+os.environ.get('FOO')
+
+os.environ.get('FOO', 'bar')
+
+os.getenv('FOO')

resources/test/fixtures/flake8_simplify/SIM115.py

@@ -0,0 +1,36 @@
+import contextlib
+
+# SIM115
+f = open("foo.txt")
+data = f.read()
+f.close()
+
+# OK
+with open("foo.txt") as f:
+    data = f.read()
+
+# OK
+with contextlib.ExitStack() as exit_stack:
+    f = exit_stack.enter_context(open("filename"))
+
+# OK
+with contextlib.ExitStack() as stack:
+    files = [stack.enter_context(open(fname)) for fname in filenames]
+    close_files = stack.pop_all().close
+
+# OK
+with contextlib.AsyncExitStack() as exit_stack:
+    f = await exit_stack.enter_async_context(open("filename"))
+
+# OK (false negative)
+with contextlib.ExitStack():
+    f = exit_stack.enter_context(open("filename"))
+
+# SIM115
+with contextlib.ExitStack():
+    f = open("filename")
+
+# OK
+with contextlib.ExitStack() as exit_stack:
+    exit_stack_ = exit_stack
+    f = exit_stack_.enter_context(open("filename"))

resources/test/fixtures/flake8_simplify/SIM117.py

@@ -1,13 +1,92 @@
-with A() as a:  # SIM117
+# SIM117
+with A() as a:
     with B() as b:
         print("hello")
 
+# SIM117
+with A():
+    with B():
+        with C():
+            print("hello")
+
+# SIM117
+with A() as a:
+    # Unfixable due to placement of this comment.
+    with B() as b:
+        print("hello")
+
+# SIM117
+with A() as a:
+    with B() as b:
+        # Fixable due to placement of this comment.
+        print("hello")
+
+# OK
 with A() as a:
     a()
     with B() as b:
         print("hello")
 
+# OK
 with A() as a:
     with B() as b:
         print("hello")
     a()
+
+# OK
+async with A() as a:
+    with B() as b:
+        print("hello")
+
+# OK
+with A() as a:
+    async with B() as b:
+        print("hello")
+
+# OK
+async with A() as a:
+    async with B() as b:
+        print("hello")
+
+while True:
+    # SIM117
+    with A() as a:
+        with B() as b:
+            """this
+is valid"""
+
+            """the indentation on
+            this line is significant"""
+
+            "this is" \
+"allowed too"
+
+            ("so is"
+"this for some reason")
+
+# SIM117
+with (
+    A() as a,
+    B() as b,
+):
+    with C() as c:
+        print("hello")
+
+# SIM117
+with A() as a:
+    with (
+        B() as b,
+        C() as c,
+    ):
+        print("hello")
+
+# SIM117
+with (
+    A() as a,
+    B() as b,
+):
+    with (
+        C() as c,
+        D() as d,
+    ):
+        print("hello")

resources/test/fixtures/flake8_simplify/SIM201.py

@@ -1,17 +1,27 @@
-if not a == b:  # SIM201
+# SIM201
+if not a == b:
     pass
 
-if not a == (b + c):  # SIM201
+# SIM201
+if not a == (b + c):
     pass
 
-if not (a + b) == c:  # SIM201
+# SIM201
+if not (a + b) == c:
     pass
 
-if not a != b:  # OK
+# OK
+if not a != b:
     pass
 
-if a == b:  # OK
+# OK
+if a == b:
     pass
 
-if not a == b:  # OK
+# OK
+if not a == b:
     raise ValueError()
+
+# OK
+def __ne__(self, other):
+    return not self == other

resources/test/fixtures/flake8_simplify/SIM202.py

@@ -1,14 +1,27 @@
-if not a != b:  # SIM202
+# SIM202
+if not a != b:
     pass
 
-if not a != (b + c):  # SIM202
+# SIM202
+if not a != (b + c):
     pass
 
-if not (a + b) != c:  # SIM202
+# SIM202
+if not (a + b) != c:
     pass
 
-if not a == b:  # OK
+# OK
+if not a == b:
     pass
 
-if a != b:  # OK
+# OK
+if a != b:
     pass
+
+# OK
+if not a != b:
+    raise ValueError()
+
+# OK
+def __eq__(self, other):
+    return not self != other

resources/test/fixtures/flake8_simplify/SIM222.py

@@ -7,8 +7,12 @@ if (a or b) or True:  # SIM223
 if a or (b or True):  # SIM223
     pass
 
-if a and True:
+if a and True:  # OK
     pass
 
-if True:
+if True:  # OK
     pass
+
+
+def validate(self, value):
+    return json.loads(value) or True  # OK

resources/test/fixtures/flake8_simplify/SIM300.py

@@ -2,6 +2,9 @@
 "yoda" == compare  # SIM300
 'yoda' == compare  # SIM300
 42 == age  # SIM300
+"yoda" <= compare  # SIM300
+'yoda' < compare  # SIM300
+42 > age  # SIM300
 
 # OK
 compare == "yoda"

resources/test/fixtures/flake8_simplify/SIM401.py

@@ -0,0 +1,110 @@
+###
+# Positive cases
+###
+
+# SIM401 (pattern-1)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    var = "default1"
+
+# SIM401 (pattern-2)
+if key not in a_dict:
+    var = "default2"
+else:
+    var = a_dict[key]
+
+# SIM401 (default with a complex expression)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    var = val1 + val2
+
+# SIM401 (complex expression in key)
+if keys[idx] in a_dict:
+    var = a_dict[keys[idx]]
+else:
+    var = "default"
+
+# SIM401 (complex expression in dict)
+if key in dicts[idx]:
+    var = dicts[idx][key]
+else:
+    var = "default"
+
+# SIM401 (complex expression in var)
+if key in a_dict:
+    vars[idx] = a_dict[key]
+else:
+    vars[idx] = "default"
+
+###
+# Negative cases
+###
+
+# OK (false negative)
+if not key in a_dict:
+    var = "default"
+else:
+    var = a_dict[key]
+
+# OK (different dict)
+if key in a_dict:
+    var = other_dict[key]
+else:
+    var = "default"
+
+# OK (different key)
+if key in a_dict:
+    var = a_dict[other_key]
+else:
+    var = "default"
+
+# OK (different var)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    other_var = "default"
+
+# OK (extra vars in body)
+if key in a_dict:
+    var = a_dict[key]
+    var2 = value2
+else:
+    var = "default"
+
+# OK (extra vars in orelse)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    var2 = value2
+    var = "default"
+
+# OK (complex default value)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    var = foo()
+
+# OK (complex default value)
+if key in a_dict:
+    var = a_dict[key]
+else:
+    var = a_dict["fallback"]
+
+# OK (false negative for elif)
+if foo():
+    pass
+elif key in a_dict:
+    vars[idx] = a_dict[key]
+else:
+    vars[idx] = "default"
+
+# OK (false negative for nested else)
+if foo():
+    pass
+else:
+    if key in a_dict:
+        vars[idx] = a_dict[key]
+    else:
+        vars[idx] = "default"

resources/test/fixtures/flake8_unused_arguments/ARG.py

@@ -181,3 +181,17 @@ def f(a: int, b: int) -> str:
 
 def f(a, b):
     return f"{a}{b}"
+
+
+###
+# Unused arguments on magic methods.
+###
+class C:
+    def __init__(self, x) -> None:
+        print("Hello, world!")
+
+    def __str__(self) -> str:
+        return "Hello, world!"
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        print("Hello, world!")

resources/test/fixtures/isort/no_lines_before.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from typing import Any
+
+from requests import Session
+
+from my_first_party import my_first_party_object
+
+from . import my_local_folder_object

resources/test/fixtures/isort/order_by_type_with_custom_classes.py

@@ -0,0 +1,4 @@
+from sklearn.svm import func, SVC, CONST, Klass
+from subprocess import N_CLASS, PIPE, Popen, STDOUT
+from module import CLASS, Class, CONSTANT, function, BASIC, Apple
+from torch.nn import SELU, AClass, A_CONSTANT

resources/test/fixtures/isort/order_by_type_with_custom_constants.py

@@ -0,0 +1,2 @@
+from sklearn.svm import XYZ, func, variable, Const, Klass, constant
+from subprocess import First, var, func, Class, konst, A_constant, Last, STDOUT

resources/test/fixtures/isort/order_by_type_with_custom_variables.py

@@ -0,0 +1,2 @@
+from sklearn.svm import VAR, Class, MyVar, CONST, abc
+from subprocess import utils, var_ABC, Variable, Klass, CONSTANT, exe

resources/test/fixtures/isort/relative_imports_order.py

@@ -0,0 +1,3 @@
+from ... import a
+from .. import b
+from . import c

resources/test/fixtures/isort/required_imports/comment.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python3
+
+x = 1

resources/test/fixtures/isort/required_imports/docstring.py

@@ -0,0 +1,3 @@
+"""Hello, world!"""
+
+x = 1

resources/test/fixtures/isort/required_imports/docstring_only.py

@@ -0,0 +1 @@
+"""Hello, world!"""

resources/test/fixtures/isort/required_imports/docstring_with_continuation.py

@@ -0,0 +1,2 @@
+"""Hello, world!"""; x = \
+    1; y = 2

resources/test/fixtures/isort/required_imports/docstring_with_semicolon.py

@@ -0,0 +1 @@
+"""Hello, world!"""; x = 1

resources/test/fixtures/isort/required_imports/existing_import.py

@@ -0,0 +1,2 @@
+from __future__ import generator_stop
+import os

resources/test/fixtures/pycodestyle/W505.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""Here's a top-level docstring that's over the limit."""
+
+
+def f():
+    """Here's a docstring that's also over the limit."""
+
+    x = 1  # Here's a comment that's over the limit, but it's not standalone.
+
+    # Here's a standalone comment that's over the limit.
+
+    print("Here's a string that's over the limit, but it's not a docstring.")
+
+
+"This is also considered a docstring, and is over the limit."

resources/test/fixtures/pydocstyle/D.py

@@ -579,3 +579,30 @@ def multiline_trailing_and_leading_space():
         "or exclamation point (not '\"')")
 def endswith_quote():
     """Whitespace at the end, but also a quote" """
+
+
+@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 asdfljdjgf24():
+    """Summary.
+
+    Description.  """
+
+
+@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 one_liner():
+    """
+
+    Wrong."""
+
+
+@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 one_liner():
+    r"""Wrong.
+
+    """

resources/test/fixtures/pydocstyle/setter.py

@@ -0,0 +1,17 @@
+class PropertyWithSetter:
+    @property
+    def foo(self) -> str:
+        """Docstring for foo."""
+        return "foo"
+
+    @foo.setter
+    def foo(self, value: str) -> None:
+        pass
+
+    @foo.deleter
+    def foo(self):
+        pass
+
+    @foo
+    def foo(self, value: str) -> None:
+        pass

resources/test/fixtures/pyflakes/F401_6.py

@@ -9,7 +9,6 @@ from .background import BackgroundTasks
 # F401 `datastructures.UploadFile` imported but unused
 from .datastructures import UploadFile as FileUpload
 
-
 # OK
 import applications as applications
 

resources/test/fixtures/pyflakes/F841_3.py

@@ -44,3 +44,25 @@ def f():
         1 / 0
     except (ValueError, ZeroDivisionError) as x2:
         pass
+
+
+def f(a, b):
+    x = (
+        a()
+        if a is not None
+        else b
+    )
+
+    y = \
+        a() if a is not None else b
+
+
+def f(a, b):
+    x = (
+        a
+        if a is not None
+        else b
+    )
+
+    y = \
+        a if a is not None else b

resources/test/fixtures/pygrep-hooks/PGH002_0.py

@@ -5,4 +5,3 @@ from warnings import warn
 warnings.warn("this is ok")
 warn("by itself is also ok")
 logging.warning("this is fine")
-log.warning("this is ok")

resources/test/fixtures/pygrep-hooks/PGH002_1.py

@@ -2,14 +2,4 @@ import logging
 from logging import warn
 
 logging.warn("this is not ok")
-log.warn("this is also not ok")
 warn("not ok")
-
-
-def foo():
-    from logging import warn
-
-    def warn():
-        pass
-
-    warn("has been redefined, but we will still report it")

resources/test/fixtures/pylint/constant_comparison.py

@@ -0,0 +1,59 @@
+"""Check that magic values are not used in comparisons"""
+
+if 100 == 100: # [comparison-of-constants]
+    pass
+
+if 1 == 3: # [comparison-of-constants]
+    pass
+
+if 1 != 3: # [comparison-of-constants]
+    pass
+
+x = 0
+if 4 == 3 == x: # [comparison-of-constants]
+    pass
+
+if x == 0: # correct
+    pass
+
+y = 1
+if x == y: # correct
+    pass
+
+if 1 > 0: # [comparison-of-constants]
+    pass
+
+if x > 0: # correct
+    pass
+
+if 1 >= 0: # [comparison-of-constants]
+    pass
+
+if x >= 0: # correct
+    pass
+
+if 1 < 0: # [comparison-of-constants]
+    pass
+
+if x < 0: # correct
+    pass
+
+if 1 <= 0: # [comparison-of-constants]
+    pass
+
+if x <= 0: # correct
+    pass
+
+word = "hello"
+if word == "": # correct
+    pass
+
+if "hello" == "": # [comparison-of-constants]
+    pass
+
+truthy = True
+if truthy == True: # correct
+    pass
+
+if True == False: # [comparison-of-constants]
+    pass

resources/test/fixtures/pylint/magic_value_comparison.py

@@ -0,0 +1,69 @@
+"""Check that magic values are not used in comparisons."""
+
+user_input = 10
+
+if 10 > user_input:  # [magic-value-comparison]
+    pass
+
+if 10 == 100:  # [comparison-of-constants] R0133
+    pass
+
+if 1 == 3:  # [comparison-of-constants] R0133
+    pass
+
+x = 0
+if 4 == 3 == x:  # [comparison-of-constants] R0133
+    pass
+
+time_delta = 7224
+ONE_HOUR = 3600
+
+if time_delta > ONE_HOUR:  # correct
+    pass
+
+argc = 1
+
+if argc != -1:  # correct
+    pass
+
+if argc != 0:  # correct
+    pass
+
+if argc != 1:  # correct
+    pass
+
+if argc != 2:  # [magic-value-comparison]
+    pass
+
+if __name__ == "__main__":  # correct
+    pass
+
+ADMIN_PASSWORD = "SUPERSECRET"
+input_password = "password"
+
+if input_password == "":  # correct
+    pass
+
+if input_password == ADMIN_PASSWORD:  # correct
+    pass
+
+if input_password == "Hunter2":  # [magic-value-comparison]
+    pass
+
+PI = 3.141592653589793238
+pi_estimation = 3.14
+
+if pi_estimation == 3.141592653589793238:  # [magic-value-comparison]
+    pass
+
+if pi_estimation == PI:  # correct
+    pass
+
+HELLO_WORLD = b"Hello, World!"
+user_input = b"Hello, There!"
+
+if user_input == b"something":  # [magic-value-comparison]
+    pass
+
+if user_input == HELLO_WORLD:  # correct
+    pass

resources/test/fixtures/pyupgrade/UP003.py

@@ -1,5 +1,12 @@
-type('')
-type(b'')
+type("")
+type(b"")
 type(0)
-type(0.)
+type(0.0)
 type(0j)
+
+# OK
+y = x.dtype.type(0.0)
+
+# OK
+type = lambda *args, **kwargs: None
+type("")

resources/test/fixtures/pyupgrade/UP011.py

@@ -0,0 +1,67 @@
+import functools
+from functools import lru_cache
+
+
+@functools.lru_cache()
+def fixme():
+    pass
+
+
+@lru_cache()
+def fixme():
+    pass
+
+
+@other_decorator
+@functools.lru_cache()
+def fixme():
+    pass
+
+
+@functools.lru_cache()
+@other_decorator
+def fixme():
+    pass
+
+
+@functools.lru_cache(maxsize=None)
+def ok():
+    pass
+
+
+@lru_cache(maxsize=None)
+def ok():
+    pass
+
+
+@functools.lru_cache(maxsize=64)
+def ok():
+    pass
+
+
+@lru_cache(maxsize=64)
+def ok():
+    pass
+
+
+def user_func():
+    pass
+
+
+@lru_cache(user_func)
+def ok():
+    pass
+
+
+@lru_cache(user_func, maxsize=None)
+def ok():
+    pass
+
+
+def lru_cache(maxsize=None):
+    pass
+
+
+@lru_cache(maxsize=None)
+def ok():
+    pass

resources/test/fixtures/pyupgrade/UP011_0.py

@@ -1,103 +0,0 @@
-import functools
-from functools import lru_cache
-
-
-@lru_cache()
-def fixme1():
-    pass
-
-
-@other_deco_after
-@functools.lru_cache()
-def fixme2():
-    pass
-
-
-@lru_cache(maxsize=None)
-def fixme3():
-    pass
-
-
-@functools.lru_cache(maxsize=None)
-@other_deco_before
-def fixme4():
-    pass
-
-
-@lru_cache( # A 
-) # B
-def fixme5():
-    pass
-
-
-@lru_cache(
-    # A
-)   # B
-def fixme6():
-    pass
-
-
-@functools.lru_cache(
-    # A
-    maxsize = None) # B
-def fixme7():
-    pass
-
-
-@functools.lru_cache(
-    # A1
-    maxsize = None
-    # A2
-) # B
-def fixme8():
-    pass
-
-
-@functools.lru_cache(
-    # A1
-    maxsize = 
-    None
-    # A2
-
-)
-def fixme9():
-    pass
-
-
-@functools.lru_cache(
-    # A1
-    maxsize = 
-    None
-    # A2
-)
-def fixme10():
-    pass
-
-
-@lru_cache
-def correct1():
-    pass
-
-
-@functools.lru_cache
-def correct2():
-    pass
-
-
-@functoools.lru_cache(maxsize=64)
-def correct3():
-    pass
-
-
-def user_func():
-    pass
-
-
-@lru_cache(user_func)
-def correct4():
-    pass
-
-
-@lru_cache(user_func, maxsize=None)
-def correct5():
-    pass

resources/test/fixtures/pyupgrade/UP011_1.py

@@ -1,15 +0,0 @@
-import functools
-
-
-def lru_cache(maxsize=None):
-    pass
-
-
-@lru_cache()
-def dont_fixme():
-    pass
-
-
-@lru_cache(maxsize=None)
-def dont_fixme():
-    pass

resources/test/fixtures/pyupgrade/UP024_3.py

@@ -0,0 +1,8 @@
+class SocketError(Exception):
+    pass
+
+
+try:
+    raise SocketError()
+except SocketError:
+    pass

resources/test/fixtures/pyupgrade/UP030_0.py

@@ -0,0 +1,36 @@
+# Invalid calls; errors expected.
+
+"{0}" "{1}" "{2}".format(1, 2, 3)
+
+"a {3} complicated {1} string with {0} {2}".format(
+    "first", "second", "third", "fourth"
+)
+
+'{0}'.format(1)
+
+'{0:x}'.format(30)
+
+x = '{0}'.format(1)
+
+'''{0}\n{1}\n'''.format(1, 2)
+
+x = "foo {0}" \
+    "bar {1}".format(1, 2)
+
+("{0}").format(1)
+
+"\N{snowman} {0}".format(1)
+
+'{' '0}'.format(1)
+
+# These will not change because we are waiting for libcst to fix this issue:
+# https://github.com/Instagram/LibCST/issues/846
+print(
+    'foo{0}'
+    'bar{1}'.format(1, 2)
+)
+
+print(
+    'foo{0}'  # ohai\n"
+    'bar{1}'.format(1, 2)
+)

resources/test/fixtures/pyupgrade/UP030_1.py

@@ -0,0 +1,23 @@
+# Valid calls; no errors expected.
+
+'{}'.format(1)
+
+
+x = ('{0} {1}',)
+
+'{0} {0}'.format(1)
+
+'{0:<{1}}'.format(1, 4)
+
+f"{0}".format(a)
+
+f"{0}".format(1)
+
+print(f"{0}".format(1))
+
+# I did not include the following tests because ruff does not seem to work with
+# invalid python syntax (which is a good thing)
+
+# "{0}"format(1)
+# '{'.format(1)", "'}'.format(1)
+# ("{0}" # {1}\n"{2}").format(1, 2, 3)

resources/test/fixtures/pyupgrade/UP032.py

@@ -0,0 +1,86 @@
+###
+# Errors
+###
+
+"{} {}".format(a, b)
+
+"{1} {0}".format(a, b)
+
+"{x.y}".format(x=z)
+
+"{.x} {.y}".format(a, b)
+
+"{} {}".format(a.b, c.d)
+
+"{}".format(a())
+
+"{}".format(a.b())
+
+"{}".format(a.b().c())
+
+"hello {}!".format(name)
+
+"{}{b}{}".format(a, c, b=b)
+
+"{}".format(0x0)
+
+"{} {}".format(a, b)
+
+"""{} {}""".format(a, b)
+
+"foo{}".format(1)
+
+r"foo{}".format(1)
+
+x = "{a}".format(a=1)
+
+print("foo {} ".format(x))
+
+"{a[b]}".format(a=a)
+
+"{a.a[b]}".format(a=a)
+
+"{}{{}}{}".format(escaped, y)
+
+"{}".format(a)
+
+###
+# Non-errors
+###
+
+# False-negative: RustPython doesn't parse the `\N{snowman}`.
+"\N{snowman} {}".format(a)
+
+"{".format(a)
+
+"}".format(a)
+
+"{} {}".format(*a)
+
+"{0} {0}".format(arg)
+
+"{x} {x}".format(arg)
+
+"{x.y} {x.z}".format(arg)
+
+b"{} {}".format(a, b)
+
+"{:{}}".format(x, y)
+
+"{}{}".format(a)
+
+"" "{}".format(a["\\"])
+
+"{}".format(a["b"])
+
+r'"\N{snowman} {}".format(a)'
+
+"{a}" "{b}".format(a=1, b=1)
+
+
+async def c():
+    return "{}".format(await 3)
+
+
+async def c():
+    return "{}".format(1 + await 3)

resources/test/fixtures/pyupgrade/UP033.py

@@ -0,0 +1,67 @@
+import functools
+from functools import lru_cache
+
+
+@functools.lru_cache(maxsize=None)
+def fixme():
+    pass
+
+
+@lru_cache(maxsize=None)
+def fixme():
+    pass
+
+
+@other_decorator
+@functools.lru_cache(maxsize=None)
+def fixme():
+    pass
+
+
+@functools.lru_cache(maxsize=None)
+@other_decorator
+def fixme():
+    pass
+
+
+@functools.lru_cache()
+def ok():
+    pass
+
+
+@lru_cache()
+def ok():
+    pass
+
+
+@functools.lru_cache(maxsize=64)
+def ok():
+    pass
+
+
+@lru_cache(maxsize=64)
+def ok():
+    pass
+
+
+def user_func():
+    pass
+
+
+@lru_cache(user_func)
+def ok():
+    pass
+
+
+@lru_cache(user_func, maxsize=None)
+def ok():
+    pass
+
+
+def lru_cache(maxsize=None):
+    pass
+
+
+@lru_cache(maxsize=None)
+def ok():
+    pass

resources/test/fixtures/ruff/RUF005.py

@@ -0,0 +1,22 @@
+class Fun:
+    words = ("how", "fun!")
+
+    def yay(self):
+        return self.words
+
+yay = Fun().yay
+
+foo = [4, 5, 6]
+bar = [1, 2, 3] + foo
+zoob = tuple(bar)
+quux = (7, 8, 9) + zoob
+spam = quux + (10, 11, 12)
+spom = list(spam)
+eggs = spom + [13, 14, 15]
+elatement = ("we all say", ) + yay()
+excitement = ("we all think", ) + Fun().yay()
+astonishment = ("we all feel", ) + Fun.words
+
+chain = ['a', 'b', 'c'] + eggs + list(('yes', 'no', 'pants') + zoob)
+
+baz = () + zoob

resources/test/project/README.md

@@ -17,7 +17,7 @@ resources/test/project/examples/docs/docs/file.py:8:5: F841 Local variable `x` i
 resources/test/project/project/file.py:1:8: F401 `os` imported but unused
 resources/test/project/project/import_file.py:1:1: I001 Import block is un-sorted or un-formatted
 Found 7 error(s).
-6 potentially fixable with the --fix option.
+7 potentially fixable with the --fix option.
 ```
 
 Running from the project directory itself should exhibit the same behavior:
@@ -32,7 +32,7 @@ examples/docs/docs/file.py:8:5: F841 Local variable `x` is assigned to but never
 project/file.py:1:8: F401 `os` imported but unused
 project/import_file.py:1:1: I001 Import block is un-sorted or un-formatted
 Found 7 error(s).
-6 potentially fixable with the --fix option.
+7 potentially fixable with the --fix option.
 ```
 
 Running from the sub-package directory should exhibit the same behavior, but omit the top-level
@@ -43,7 +43,7 @@ files:
 docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
 docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
 Found 2 error(s).
-1 potentially fixable with the --fix option.
+2 potentially fixable with the --fix option.
 ```
 
 `--config` should force Ruff to use the specified `pyproject.toml` for all files, and resolve
@@ -74,7 +74,7 @@ docs/docs/file.py:1:1: I001 Import block is un-sorted or un-formatted
 docs/docs/file.py:8:5: F841 Local variable `x` is assigned to but never used
 excluded/script.py:5:5: F841 Local variable `x` is assigned to but never used
 Found 4 error(s).
-1 potentially fixable with the --fix option.
+4 potentially fixable with the --fix option.
 ```
 
 Passing an excluded directory directly should report errors in the contained files:

ruff.schema.json

@@ -40,7 +40,7 @@
       ]
     },
     "exclude": {
-      "description": "A list of file patterns to exclude from linting.\n\nExclusions are based on globs, and can be either:\n\n- Single-path patterns, like `.mypy_cache` (to exclude any directory named `.mypy_cache` in the tree), `foo.py` (to exclude any file named `foo.py`), or `foo_*.py` (to exclude any file matching `foo_*.py` ). - Relative patterns, like `directory/foo.py` (to exclude that specific file) or `directory/*.py` (to exclude any Python files in `directory`). Note that these paths are relative to the project root (e.g., the directory containing your `pyproject.toml`).\n\nNote that you'll typically want to use [`extend-exclude`](#extend-exclude) to modify the excluded paths.",
+      "description": "A list of file patterns to exclude from linting.\n\nExclusions are based on globs, and can be either:\n\n- Single-path patterns, like `.mypy_cache` (to exclude any directory named `.mypy_cache` in the tree), `foo.py` (to exclude any file named `foo.py`), or `foo_*.py` (to exclude any file matching `foo_*.py` ). - Relative patterns, like `directory/foo.py` (to exclude that specific file) or `directory/*.py` (to exclude any Python files in `directory`). Note that these paths are relative to the project root (e.g., the directory containing your `pyproject.toml`).\n\nFor more information on the glob syntax, refer to the [`globset` documentation](https://docs.rs/globset/latest/globset/#syntax).\n\nNote that you'll typically want to use [`extend-exclude`](#extend-exclude) to modify the excluded paths.",
       "type": [
         "array",
         "null"
@@ -57,7 +57,7 @@
       ]
     },
     "extend-exclude": {
-      "description": "A list of file patterns to omit from linting, in addition to those specified by `exclude`.",
+      "description": "A list of file patterns to omit from linting, in addition to those specified by `exclude`.\n\nExclusions are based on globs, and can be either:\n\n- Single-path patterns, like `.mypy_cache` (to exclude any directory named `.mypy_cache` in the tree), `foo.py` (to exclude any file named `foo.py`), or `foo_*.py` (to exclude any file matching `foo_*.py` ). - Relative patterns, like `directory/foo.py` (to exclude that specific file) or `directory/*.py` (to exclude any Python files in `directory`). Note that these paths are relative to the project root (e.g., the directory containing your `pyproject.toml`).\n\nFor more information on the glob syntax, refer to the [`globset` documentation](https://docs.rs/globset/latest/globset/#syntax).",
       "type": [
         "array",
         "null"
@@ -67,7 +67,7 @@
       }
     },
     "extend-ignore": {
-      "description": "A list of rule codes or prefixes to ignore, in addition to those specified by `ignore`.",
+      "description": "A list of rule codes or prefixes to ignore, in addition to those specified by `ignore`.\n\nNote that `extend-ignore` is applied after resolving rules from `ignore`/`select` and a less specific rule in `extend-ignore` would overwrite a more specific rule in `select`. It is recommended to only use `extend-ignore` when extending a `pyproject.toml` file via `extend`.",
       "type": [
         "array",
         "null"
@@ -77,7 +77,7 @@
       }
     },
     "extend-select": {
-      "description": "A list of rule codes or prefixes to enable, in addition to those specified by `select`.",
+      "description": "A list of rule codes or prefixes to enable, in addition to those specified by `select`.\n\nNote that `extend-select` is applied after resolving rules from `ignore`/`select` and a less specific rule in `extend-select` would overwrite a more specific rule in `ignore`. It is recommended to only use `extend-select` when extending a `pyproject.toml` file via `extend`.",
       "type": [
         "array",
         "null"
@@ -227,7 +227,7 @@
       ]
     },
     "format": {
-      "description": "The style in which violation messages should be formatted: `\"text\"` (default), `\"grouped\"` (group messages by file), `\"json\"` (machine-readable), `\"junit\"` (machine-readable XML), `\"github\"` (GitHub Actions annotations) or `\"gitlab\"` (GitLab CI code quality report).",
+      "description": "The style in which violation messages should be formatted: `\"text\"` (default), `\"grouped\"` (group messages by file), `\"json\"` (machine-readable), `\"junit\"` (machine-readable XML), `\"github\"` (GitHub Actions annotations), `\"gitlab\"` (GitLab CI code quality report), or `\"pylint\"` (Pylint text format).",
       "anyOf": [
         {
           "$ref": "#/definitions/SerializationFormat"
@@ -285,6 +285,16 @@
         }
       ]
     },
+    "namespace-packages": {
+      "description": "Mark the specified directories as namespace packages. For the purpose of module resolution, Ruff will treat those directories as if they contained an `__init__.py` file.",
+      "type": [
+        "array",
+        "null"
+      ],
+      "items": {
+        "type": "string"
+      }
+    },
     "pep8-naming": {
       "description": "Options for the `pep8-naming` plugin.",
       "anyOf": [
@@ -331,6 +341,17 @@
         }
       ]
     },
+    "pylint": {
+      "description": "Options for the `pylint` plugin.",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/PylintOptions"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
     "pyupgrade": {
       "description": "Options for the `pyupgrade` plugin.",
       "anyOf": [
@@ -438,7 +459,7 @@
   },
   "additionalProperties": false,
   "definitions": {
-    "BannedApi": {
+    "ApiBan": {
       "type": "object",
       "required": [
         "msg"
@@ -451,6 +472,17 @@
       },
       "additionalProperties": false
     },
+    "ConstantType": {
+      "type": "string",
+      "enum": [
+        "bytes",
+        "complex",
+        "float",
+        "int",
+        "str",
+        "tuple"
+      ]
+    },
     "Convention": {
       "oneOf": [
         {
@@ -733,7 +765,7 @@
             "null"
           ],
           "additionalProperties": {
-            "$ref": "#/definitions/BannedApi"
+            "$ref": "#/definitions/ApiBan"
           }
         }
       },
@@ -752,9 +784,29 @@
       },
       "additionalProperties": false
     },
+    "ImportType": {
+      "type": "string",
+      "enum": [
+        "future",
+        "standard-library",
+        "third-party",
+        "first-party",
+        "local-folder"
+      ]
+    },
     "IsortOptions": {
       "type": "object",
       "properties": {
+        "classes": {
+          "description": "An override list of tokens to always recognize as a Class for `order-by-type` regardless of casing.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "type": "string"
+          }
+        },
         "combine-as-imports": {
           "description": "Combines as imports on the same line. See isort's [`combine-as-imports`](https://pycqa.github.io/isort/docs/configuration/options.html#combine-as-imports) option.",
           "type": [
@@ -762,6 +814,16 @@
             "null"
           ]
         },
+        "constants": {
+          "description": "An override list of tokens to always recognize as a CONSTANT for `order-by-type` regardless of casing.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "type": "string"
+          }
+        },
         "extra-standard-library": {
           "description": "A list of modules to consider standard-library, in addition to those known to Ruff in advance.",
           "type": [
@@ -813,6 +875,16 @@
             "type": "string"
           }
         },
+        "no-lines-before": {
+          "description": "A list of sections that should _not_ be delineated from the previous section via empty lines.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/ImportType"
+          }
+        },
         "order-by-type": {
           "description": "Order imports by type, which is determined by case, in addition to alphabetically.",
           "type": [
@@ -820,6 +892,27 @@
             "null"
           ]
         },
+        "relative-imports-order": {
+          "description": "Whether to place \"closer\" imports (fewer `.` characters, most local) before \"further\" imports (more `.` characters, least local), or vice versa.\n\nThe default (\"furthest-to-closest\") is equivalent to isort's `reverse-relative` default (`reverse-relative = false`); setting this to \"closest-to-furthest\" is equivalent to isort's `reverse-relative = true`.",
+          "anyOf": [
+            {
+              "$ref": "#/definitions/RelatveImportsOrder"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "required-imports": {
+          "description": "Add the specified import line to all files.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "type": "string"
+          }
+        },
         "single-line-exclusions": {
           "description": "One or more modules to exclude from the single line rule.",
           "type": [
@@ -836,6 +929,16 @@
             "boolean",
             "null"
           ]
+        },
+        "variables": {
+          "description": "An override list of tokens to always recognize as a var for `order-by-type` regardless of casing.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "type": "string"
+          }
         }
       },
       "additionalProperties": false
@@ -935,6 +1038,15 @@
             "boolean",
             "null"
           ]
+        },
+        "max-doc-length": {
+          "description": "The maximum line length to allow for line-length violations within documentation (`W505`), including standalone comments.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint",
+          "minimum": 0.0
         }
       },
       "additionalProperties": false
@@ -956,6 +1068,22 @@
       },
       "additionalProperties": false
     },
+    "PylintOptions": {
+      "type": "object",
+      "properties": {
+        "allow-magic-value-types": {
+          "description": "Constant types to ignore when used as \"magic values\".",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/ConstantType"
+          }
+        }
+      },
+      "additionalProperties": false
+    },
     "PythonVersion": {
       "type": "string",
       "enum": [
@@ -988,6 +1116,24 @@
         }
       ]
     },
+    "RelatveImportsOrder": {
+      "oneOf": [
+        {
+          "description": "Place \"closer\" imports (fewer `.` characters, most local) before \"further\" imports (more `.` characters, least local).",
+          "type": "string",
+          "enum": [
+            "closest-to-furthest"
+          ]
+        },
+        {
+          "description": "Place \"further\" imports (more `.` characters, least local) imports before \"closer\" imports (fewer `.` characters, most local).",
+          "type": "string",
+          "enum": [
+            "furthest-to-closest"
+          ]
+        }
+      ]
+    },
     "RuleCodePrefix": {
       "type": "string",
       "enum": [
@@ -1088,6 +1234,12 @@
         "C9",
         "C90",
         "C901",
+        "COM",
+        "COM8",
+        "COM81",
+        "COM812",
+        "COM818",
+        "COM819",
         "D",
         "D1",
         "D10",
@@ -1268,6 +1420,7 @@
         "I0",
         "I00",
         "I001",
+        "I002",
         "I2",
         "I25",
         "I252",
@@ -1281,6 +1434,10 @@
         "ICN0",
         "ICN00",
         "ICN001",
+        "INP",
+        "INP0",
+        "INP00",
+        "INP001",
         "ISC",
         "ISC0",
         "ISC00",
@@ -1356,6 +1513,7 @@
         "PIE79",
         "PIE790",
         "PIE794",
+        "PIE796",
         "PIE8",
         "PIE80",
         "PIE807",
@@ -1364,10 +1522,6 @@
         "PLC04",
         "PLC041",
         "PLC0414",
-        "PLC2",
-        "PLC22",
-        "PLC220",
-        "PLC2201",
         "PLC3",
         "PLC30",
         "PLC300",
@@ -1384,6 +1538,9 @@
         "PLE1142",
         "PLR",
         "PLR0",
+        "PLR01",
+        "PLR013",
+        "PLR0133",
         "PLR02",
         "PLR020",
         "PLR0206",
@@ -1396,6 +1553,10 @@
         "PLR1701",
         "PLR172",
         "PLR1722",
+        "PLR2",
+        "PLR20",
+        "PLR200",
+        "PLR2004",
         "PLW",
         "PLW0",
         "PLW01",
@@ -1470,6 +1631,7 @@
         "RUF002",
         "RUF003",
         "RUF004",
+        "RUF005",
         "RUF1",
         "RUF10",
         "RUF100",
@@ -1493,6 +1655,11 @@
         "S50",
         "S501",
         "S506",
+        "S508",
+        "S509",
+        "S7",
+        "S70",
+        "S701",
         "SIM",
         "SIM1",
         "SIM10",
@@ -1506,6 +1673,8 @@
         "SIM11",
         "SIM110",
         "SIM111",
+        "SIM112",
+        "SIM115",
         "SIM117",
         "SIM118",
         "SIM2",
@@ -1525,6 +1694,9 @@
         "SIM3",
         "SIM30",
         "SIM300",
+        "SIM4",
+        "SIM40",
+        "SIM401",
         "T",
         "T1",
         "T10",
@@ -1592,10 +1764,17 @@
         "UP027",
         "UP028",
         "UP029",
+        "UP03",
+        "UP030",
+        "UP032",
+        "UP033",
         "W",
         "W2",
         "W29",
         "W292",
+        "W5",
+        "W50",
+        "W505",
         "W6",
         "W60",
         "W605",
@@ -1626,7 +1805,8 @@
         "junit",
         "grouped",
         "github",
-        "gitlab"
+        "gitlab",
+        "pylint"
       ]
     },
     "Strictness": {

ruff_cli/Cargo.toml

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

ruff_cli/src/cache.rs

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

ruff_cli/src/cli.rs

@@ -2,17 +2,21 @@ use std::path::{Path, PathBuf};
 
 use clap::{command, Parser};
 use regex::Regex;
-use rustc_hash::FxHashMap;
-
-use crate::fs;
-use crate::logging::LogLevel;
-use crate::registry::{RuleCode, RuleCodePrefix};
-use crate::settings::types::{
+use ruff::fs;
+use ruff::logging::LogLevel;
+use ruff::registry::{Rule, RuleCodePrefix};
+use ruff::resolver::ConfigProcessor;
+use ruff::settings::types::{
     FilePattern, PatternPrefixPair, PerFileIgnore, PythonVersion, SerializationFormat,
 };
+use rustc_hash::FxHashMap;
 
 #[derive(Debug, Parser)]
-#[command(author, about = "Ruff: An extremely fast Python linter.")]
+#[command(
+    author,
+    name = "ruff",
+    about = "Ruff: An extremely fast Python linter."
+)]
 #[command(version)]
 #[allow(clippy::struct_excessive_bools)]
 pub struct Cli {
@@ -61,33 +65,33 @@ pub struct Cli {
     pub isolated: bool,
     /// Comma-separated list of rule codes to enable (or ALL, to enable all
     /// rules).
-    #[arg(long, value_delimiter = ',')]
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
     pub select: Option<Vec<RuleCodePrefix>>,
     /// Like --select, but adds additional rule codes on top of the selected
     /// ones.
-    #[arg(long, value_delimiter = ',')]
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
     pub extend_select: Option<Vec<RuleCodePrefix>>,
     /// Comma-separated list of rule codes to disable.
-    #[arg(long, value_delimiter = ',')]
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
     pub ignore: Option<Vec<RuleCodePrefix>>,
     /// Like --ignore, but adds additional rule codes on top of the ignored
     /// ones.
-    #[arg(long, value_delimiter = ',')]
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
     pub extend_ignore: Option<Vec<RuleCodePrefix>>,
     /// List of paths, used to omit files and/or directories from analysis.
-    #[arg(long, value_delimiter = ',')]
+    #[arg(long, value_delimiter = ',', value_name = "FILE_PATTERN")]
     pub exclude: Option<Vec<FilePattern>>,
     /// Like --exclude, but adds additional files and directories on top of
     /// those already excluded.
-    #[arg(long, value_delimiter = ',')]
+    #[arg(long, value_delimiter = ',', value_name = "FILE_PATTERN")]
     pub extend_exclude: Option<Vec<FilePattern>>,
     /// List of rule codes to treat as eligible for autofix. Only applicable
     /// when autofix itself is enabled (e.g., via `--fix`).
-    #[arg(long, value_delimiter = ',')]
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
     pub fixable: Option<Vec<RuleCodePrefix>>,
     /// List of rule codes to treat as ineligible for autofix. Only applicable
     /// when autofix itself is enabled (e.g., via `--fix`).
-    #[arg(long, value_delimiter = ',')]
+    #[arg(long, value_delimiter = ',', value_name = "RULE_CODE")]
     pub unfixable: Option<Vec<RuleCodePrefix>>,
     /// List of mappings from file pattern to code to exclude
     #[arg(long, value_delimiter = ',')]
@@ -133,9 +137,6 @@ pub struct Cli {
     /// formatting.
     #[arg(long)]
     pub line_length: Option<usize>,
-    /// Maximum McCabe complexity allowed for a given function.
-    #[arg(long)]
-    pub max_complexity: Option<usize>,
     /// Enable automatic additions of `noqa` directives to failing lines.
     #[arg(
         long,
@@ -168,6 +169,7 @@ pub struct Cli {
     /// Explain a rule.
     #[arg(
         long,
+        value_parser=Rule::from_code,
         // Fake subcommands.
         conflicts_with = "add_noqa",
         conflicts_with = "clean",
@@ -179,7 +181,7 @@ pub struct Cli {
         conflicts_with = "stdin_filename",
         conflicts_with = "watch",
     )]
-    pub explain: Option<RuleCode>,
+    pub explain: Option<&'static Rule>,
     /// Generate shell completion
     #[arg(
         long,
@@ -262,7 +264,6 @@ impl Cli {
                 fixable: self.fixable,
                 ignore: self.ignore,
                 line_length: self.line_length,
-                max_complexity: self.max_complexity,
                 per_file_ignores: self.per_file_ignores,
                 respect_gitignore: resolve_bool_arg(
                     self.respect_gitignore,
@@ -302,7 +303,7 @@ pub struct Arguments {
     pub config: Option<PathBuf>,
     pub diff: bool,
     pub exit_zero: bool,
-    pub explain: Option<RuleCode>,
+    pub explain: Option<&'static Rule>,
     pub files: Vec<PathBuf>,
     pub generate_shell_completion: Option<clap_complete_command::Shell>,
     pub isolated: bool,
@@ -328,7 +329,6 @@ pub struct Overrides {
     pub fixable: Option<Vec<RuleCodePrefix>>,
     pub ignore: Option<Vec<RuleCodePrefix>>,
     pub line_length: Option<usize>,
-    pub max_complexity: Option<usize>,
     pub per_file_ignores: Option<Vec<PatternPrefixPair>>,
     pub respect_gitignore: Option<bool>,
     pub select: Option<Vec<RuleCodePrefix>>,
@@ -344,6 +344,82 @@ pub struct Overrides {
     pub update_check: Option<bool>,
 }
 
+impl ConfigProcessor for &Overrides {
+    fn process_config(&self, config: &mut ruff::settings::configuration::Configuration) {
+        if let Some(cache_dir) = &self.cache_dir {
+            config.cache_dir = Some(cache_dir.clone());
+        }
+        if let Some(dummy_variable_rgx) = &self.dummy_variable_rgx {
+            config.dummy_variable_rgx = Some(dummy_variable_rgx.clone());
+        }
+        if let Some(exclude) = &self.exclude {
+            config.exclude = Some(exclude.clone());
+        }
+        if let Some(extend_exclude) = &self.extend_exclude {
+            config.extend_exclude.extend(extend_exclude.clone());
+        }
+        if let Some(fix) = &self.fix {
+            config.fix = Some(*fix);
+        }
+        if let Some(fix_only) = &self.fix_only {
+            config.fix_only = Some(*fix_only);
+        }
+        if let Some(fixable) = &self.fixable {
+            config.fixable = Some(fixable.clone());
+        }
+        if let Some(format) = &self.format {
+            config.format = Some(*format);
+        }
+        if let Some(force_exclude) = &self.force_exclude {
+            config.force_exclude = Some(*force_exclude);
+        }
+        if let Some(ignore) = &self.ignore {
+            config.ignore = Some(ignore.clone());
+        }
+        if let Some(line_length) = &self.line_length {
+            config.line_length = Some(*line_length);
+        }
+        if let Some(per_file_ignores) = &self.per_file_ignores {
+            config.per_file_ignores = Some(collect_per_file_ignores(per_file_ignores.clone()));
+        }
+        if let Some(respect_gitignore) = &self.respect_gitignore {
+            config.respect_gitignore = Some(*respect_gitignore);
+        }
+        if let Some(select) = &self.select {
+            config.select = Some(select.clone());
+        }
+        if let Some(show_source) = &self.show_source {
+            config.show_source = Some(*show_source);
+        }
+        if let Some(target_version) = &self.target_version {
+            config.target_version = Some(*target_version);
+        }
+        if let Some(unfixable) = &self.unfixable {
+            config.unfixable = Some(unfixable.clone());
+        }
+        if let Some(update_check) = &self.update_check {
+            config.update_check = Some(*update_check);
+        }
+        // Special-case: `extend_ignore` and `extend_select` are parallel arrays, so
+        // push an empty array if only one of the two is provided.
+        match (&self.extend_ignore, &self.extend_select) {
+            (Some(extend_ignore), Some(extend_select)) => {
+                config.extend_ignore.push(extend_ignore.clone());
+                config.extend_select.push(extend_select.clone());
+            }
+            (Some(extend_ignore), None) => {
+                config.extend_ignore.push(extend_ignore.clone());
+                config.extend_select.push(Vec::new());
+            }
+            (None, Some(extend_select)) => {
+                config.extend_ignore.push(Vec::new());
+                config.extend_select.push(extend_select.clone());
+            }
+            (None, None) => {}
+        }
+    }
+}
+
 /// Map the CLI settings to a `LogLevel`.
 pub fn extract_log_level(cli: &Arguments) -> LogLevel {
     if cli.silent {

ruff_cli/src/commands.rs

@@ -11,22 +11,22 @@ use log::{debug, error};
 use path_absolutize::path_dedot;
 #[cfg(not(target_family = "wasm"))]
 use rayon::prelude::*;
-use rustpython_ast::Location;
+use ruff::cache::CACHE_DIR_NAME;
+use ruff::linter::add_noqa_to_path;
+use ruff::logging::LogLevel;
+use ruff::message::{Location, Message};
+use ruff::registry::Rule;
+use ruff::resolver::{FileDiscovery, PyprojectDiscovery};
+use ruff::settings::flags;
+use ruff::settings::types::SerializationFormat;
+use ruff::{fix, fs, packaging, resolver, warn_user_once, AutofixAvailability, IOError};
 use serde::Serialize;
 use walkdir::WalkDir;
 
-use crate::autofix::fixer;
-use crate::cache::CACHE_DIR_NAME;
+use crate::cache;
 use crate::cli::Overrides;
+use crate::diagnostics::{lint_path, lint_stdin, Diagnostics};
 use crate::iterators::par_iter;
-use crate::linter::{add_noqa_to_path, lint_path, lint_stdin, Diagnostics};
-use crate::logging::LogLevel;
-use crate::message::Message;
-use crate::registry::RuleCode;
-use crate::resolver::{FileDiscovery, PyprojectDiscovery};
-use crate::settings::flags;
-use crate::settings::types::SerializationFormat;
-use crate::{cache, fs, packages, resolver, violations, warn_user_once};
 
 /// Run the linter over a collection of files.
 pub fn run(
@@ -35,7 +35,7 @@ pub fn run(
     file_strategy: &FileDiscovery,
     overrides: &Overrides,
     cache: flags::Cache,
-    autofix: fixer::Mode,
+    autofix: fix::FixMode,
 ) -> Result<Diagnostics> {
     // Collect all the Python files to check.
     let start = Instant::now();
@@ -56,19 +56,19 @@ pub fn run(
     if matches!(cache, flags::Cache::Enabled) {
         match &pyproject_strategy {
             PyprojectDiscovery::Fixed(settings) => {
-                if let Err(e) = cache::init(&settings.cache_dir) {
+                if let Err(e) = cache::init(&settings.cli.cache_dir) {
                     error!(
                         "Failed to initialize cache at {}: {e:?}",
-                        settings.cache_dir.to_string_lossy()
+                        settings.cli.cache_dir.to_string_lossy()
                     );
                 }
             }
             PyprojectDiscovery::Hierarchical(default) => {
                 for settings in std::iter::once(default).chain(resolver.iter()) {
-                    if let Err(e) = cache::init(&settings.cache_dir) {
+                    if let Err(e) = cache::init(&settings.cli.cache_dir) {
                         error!(
                             "Failed to initialize cache at {}: {e:?}",
-                            settings.cache_dir.to_string_lossy()
+                            settings.cli.cache_dir.to_string_lossy()
                         );
                     }
                 }
@@ -77,12 +77,14 @@ pub fn run(
     };
 
     // Discover the package root for each Python file.
-    let package_roots = packages::detect_package_roots(
+    let package_roots = packaging::detect_package_roots(
         &paths
             .iter()
             .flatten()
             .map(ignore::DirEntry::path)
             .collect::<Vec<_>>(),
+        &resolver,
+        pyproject_strategy,
     );
 
     let start = Instant::now();
@@ -95,7 +97,7 @@ pub fn run(
                         .parent()
                         .and_then(|parent| package_roots.get(parent))
                         .and_then(|package| *package);
-                    let settings = resolver.resolve(path, pyproject_strategy);
+                    let settings = resolver.resolve_all(path, pyproject_strategy);
                     lint_path(path, package, settings, cache, autofix)
                         .map_err(|e| (Some(path.to_owned()), e.to_string()))
                 }
@@ -112,9 +114,9 @@ pub fn run(
             .unwrap_or_else(|(path, message)| {
                 if let Some(path) = &path {
                     let settings = resolver.resolve(path, pyproject_strategy);
-                    if settings.enabled.contains(&RuleCode::E902) {
+                    if settings.rules.enabled(&Rule::IOError) {
                         Diagnostics::new(vec![Message {
-                            kind: violations::IOError(message).into(),
+                            kind: IOError(message).into(),
                             location: Location::default(),
                             end_location: Location::default(),
                             fix: None,
@@ -156,7 +158,7 @@ pub fn run_stdin(
     pyproject_strategy: &PyprojectDiscovery,
     file_strategy: &FileDiscovery,
     overrides: &Overrides,
-    autofix: fixer::Mode,
+    autofix: fix::FixMode,
 ) -> Result<Diagnostics> {
     if let Some(filename) = filename {
         if !resolver::python_file_at_path(filename, pyproject_strategy, file_strategy, overrides)? {
@@ -169,9 +171,9 @@ pub fn run_stdin(
     };
     let package_root = filename
         .and_then(Path::parent)
-        .and_then(packages::detect_package_root);
+        .and_then(|path| packaging::detect_package_root(path, &settings.lib.namespace_packages));
     let stdin = read_from_stdin()?;
-    let mut diagnostics = lint_stdin(filename, package_root, &stdin, settings, autofix)?;
+    let mut diagnostics = lint_stdin(filename, package_root, &stdin, &settings.lib, autofix)?;
     diagnostics.messages.sort_unstable();
     Ok(diagnostics)
 }
@@ -287,24 +289,34 @@ struct Explanation<'a> {
     summary: &'a str,
 }
 
-/// Explain a `RuleCode` to the user.
-pub fn explain(code: &RuleCode, format: &SerializationFormat) -> Result<()> {
+/// Explain a `Rule` to the user.
+pub fn explain(rule: &Rule, format: SerializationFormat) -> Result<()> {
     match format {
         SerializationFormat::Text | SerializationFormat::Grouped => {
-            println!(
-                "{} ({}): {}",
-                code.as_ref(),
-                code.origin().title(),
-                code.kind().summary()
-            );
+            println!("{}\n", rule.as_ref());
+            println!("Code: {} ({})\n", rule.code(), rule.origin().name());
+
+            if let Some(autofix) = rule.autofixable() {
+                println!(
+                    "{}",
+                    match autofix.available {
+                        AutofixAvailability::Sometimes => "Autofix is sometimes available.\n",
+                        AutofixAvailability::Always => "Autofix is always available.\n",
+                    }
+                );
+            }
+            println!("Message formats:\n");
+            for format in rule.message_formats() {
+                println!("* {format}");
+            }
         }
         SerializationFormat::Json => {
             println!(
                 "{}",
                 serde_json::to_string_pretty(&Explanation {
-                    code: code.as_ref(),
-                    origin: code.origin().title(),
-                    summary: &code.kind().summary(),
+                    code: rule.code(),
+                    origin: rule.origin().name(),
+                    summary: rule.message_formats()[0],
                 })?
             );
         }
@@ -317,6 +329,9 @@ pub fn explain(code: &RuleCode, format: &SerializationFormat) -> Result<()> {
         SerializationFormat::Gitlab => {
             bail!("`--explain` does not support GitLab format")
         }
+        SerializationFormat::Pylint => {
+            bail!("`--explain` does not support pylint format")
+        }
     };
     Ok(())
 }

ruff_cli/src/diagnostics.rs

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