Bump version to 0.0.90

Use a single SourceCodeLocator everywhere (#510 )
Simplify SourceCodeLocator offset computation (#509 )
2022-10-29 18:34:38 -04:00 · 2022-10-29 18:23:24 -04:00 · 2022-10-29 18:13:42 -04:00 · 2022-10-29 17:40:50 -04:00 · 2022-10-29 17:07:46 -04:00 · 2022-10-29 17:00:30 -04:00
40 changed files with 865 additions and 289 deletions
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
 repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.87
+    rev: v0.0.90
    hooks:
      - id: ruff

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2054,7 +2054,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.0.87"
+version = "0.0.90"
 dependencies = [
 "anyhow",
 "assert_cmd",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.87"
+version = "0.0.90"
 edition = "2021"

 [lib]
--- a/README.md
+++ b/README.md
@@ -38,13 +38,25 @@ Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-mu
 1. [Installation and Usage](#installation-and-usage)
 2. [Configuration](#configuration)
 3. [Supported Rules](#supported-rules)
-4. [Editor Integrations](#editor-integrations)
-5. [FAQ](#faq)
-6. [Development](#development)
-7. [Releases](#releases)
-8. [Benchmarks](#benchmarks)
-9. [License](#license)
-10. [Contributing](#contributing)
+   1. [Pyflakes](#pyflakes)
+   2. [pycodestyle (error)](#pycodestyle-error)
+   3. [pycodestyle (warning)](#pycodestyle-warning)
+   4. [pydocstyle](#pydocstyle)
+   5. [pyupgrade](#pyupgrade)
+   6. [pep8-naming](#pep8-naming)
+   7. [flake8-comprehensions](#flake8-comprehensions)
+   8. [flake8-bugbear](#flake8-bugbear)
+   9. [flake8-builtins](#flake8-builtins)
+   10. [flake8-print](#flake8-print)
+   11. [flake8-quotes](#flake8-quotes)
+   12. [Meta rules](#meta-rules)
+5. [Editor Integrations](#editor-integrations)
+6. [FAQ](#faq)
+7. [Development](#development)
+8. [Releases](#releases)
+9. [Benchmarks](#benchmarks)
+10. [License](#license)
+11. [Contributing](#contributing)

 ## Installation and Usage

@@ -77,7 +89,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.87
+    rev: v0.0.90
    hooks:
      - id: ruff
 ```
@@ -94,10 +106,8 @@ For example, you could configure Ruff to only enforce a subset of rules with:
 ```toml
 [tool.ruff]
 line-length = 88
-select = [
-    "F401",
-    "F403",
-]
+select = ["E", "F"]
+ignore = ["E501"]
 per-file-ignores = [
    "__init__.py:F401",
    "path/to/file.py:F401"
@@ -236,8 +246,7 @@ add `noqa` directives to all failing lines, with the appropriate error codes.**

 ## Supported Rules

-By default, Ruff enables all `E`, `W`, and `F` error codes, which correspond to those built-in to
-Flake8.
+By default, Ruff enables all `E` and `F` error codes, which correspond to those built-in to Flake8.

 The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` command-line option.

@@ -371,12 +380,16 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | N803 | InvalidArgumentName | Argument name `...` should be lowercase |  |
 | N804 | InvalidFirstArgumentNameForClassMethod | First argument of a class method should be named `cls` |  |
 | N805 | InvalidFirstArgumentNameForMethod | First argument of a method should be named `self` |  |
+| N806 | NonLowercaseVariableInFunction | Variable `...` in function should be lowercase |  |
 | N807 | DunderFunctionName | Function name should not start and end with `__` |  |
 | N811 | ConstantImportedAsNonConstant | Constant `...` imported as non-constant `...` |  |
 | N812 | LowercaseImportedAsNonLowercase | Lowercase `...` imported as non-lowercase `...` |  |
 | N813 | CamelcaseImportedAsLowercase | Camelcase `...` imported as lowercase `...` |  |
 | N814 | CamelcaseImportedAsConstant | Camelcase `...` imported as constant `...` |  |
+| N815 | MixedCaseVariableInClassScope | Variable `mixedCase` in class scope should not be mixedCase |  |
+| N816 | MixedCaseVariableInGlobalScope | Variable `mixedCase` in global scope should not be mixedCase |  |
 | N817 | CamelcaseImportedAsAcronym | Camelcase `...` imported as acronym `...` |  |
+| N818 | ErrorSuffixOnExceptionName | Exception name `...` should be named with an Error suffix |  |

 ### flake8-comprehensions

@@ -396,7 +409,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | C413 | UnnecessaryCallAroundSorted | Unnecessary `(list\|reversed)` call around `sorted()` |  |
 | C414 | UnnecessaryDoubleCastOrProcess | Unnecessary `(list\|reversed\|set\|sorted\|tuple)` call within `(list\|set\|sorted\|tuple)()` |  |
 | C415 | UnnecessarySubscriptReversal | Unnecessary subscript reversal of iterable within `(reversed\|set\|sorted)()` |  |
-| C416 | UnnecessaryComprehension |  Unnecessary `(list\|set)` comprehension (rewrite using `(list\|set)()`) |  |
+| C416 | UnnecessaryComprehension | Unnecessary `(list\|set)` comprehension (rewrite using `(list\|set)()`) |  |
 | C417 | UnnecessaryMap | Unnecessary `map` usage (rewrite using a `(list\|set\|dict)` comprehension) |  |

 ### flake8-bugbear
@@ -406,6 +419,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | B002 | UnaryPrefixIncrement | Python does not support the unary prefix increment. |  |
 | B007 | UnusedLoopControlVariable | Loop control variable `i` not used within the loop body. | 🛠 |
 | B011 | DoNotAssertFalse | Do not `assert False` (`python -O` removes these calls), raise `AssertionError()` | 🛠 |
+| B013 | RedundantTupleInExceptionHandler | A length-one tuple literal is redundant. Write `except ValueError:` instead of `except (ValueError,):`. |  |
 | B014 | DuplicateHandlerException | Exception handler with duplicate exception: `ValueError` | 🛠 |
 | B017 | NoAssertRaisesException | `assertRaises(Exception):` should be considered evil. |  |
 | B025 | DuplicateTryBlockException | try-except block with duplicate exception `Exception` |  |
@@ -500,6 +514,7 @@ Ruff re-implements some of the most popular Flake8 plugins and related code qual
 including:

 - [`pydocstyle`](https://pypi.org/project/pydocstyle/)
+- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
 - [`yesqa`](https://github.com/asottile/yesqa)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
@@ -507,7 +522,7 @@ including:
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
 - [`flake8-quotes`](https://pypi.org/project/flake8-quotes/)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (9/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (10/32)
 - [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34)
 - [`autoflake`](https://pypi.org/project/autoflake/) (1/7)

@@ -522,6 +537,7 @@ Beyond rule-set parity, Ruff suffers from the following limitations vis-à-vis F

 Today, Ruff can be used to replace Flake8 when used with any of the following plugins:

+- [`pep8-naming`](https://pypi.org/project/pep8-naming/)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/)
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
@@ -557,35 +573,55 @@ Yes! To enable a specific docstring convention, start by enabling all `pydocstyl
 then selectively disabling based on your [preferred convention](https://www.pydocstyle.org/en/latest/error_codes.html#default-conventions).

 For example, if you're coming from `flake8-docstrings`, the following configuration is equivalent to
-`--docstring-convention numpy`:
+`--docstring-convention=numpy`:

 ```toml
 [tool.ruff]
-extend-select = [
-    "D100",
-    "D101",
-    "D102",
-    "D103",
-    "D104",
-    "D105",
-    "D106",
-    "D200",
-    "D201",
-    "D202",
+extend-select = ["D"]
+extend-ignore = [
+    "D107",
+    "D203",
+    "D212",
+    "D213",
+    "D402",
+    "D413",
+    "D415",
+    "D416",
+    "D417",
+]
+```
+
+Similarly, the following is equivalent to `--docstring-convention=google`:
+
+```toml
+[tool.ruff]
+extend-select = ["D"]
+extend-ignore = [
+    "D203",
    "D204",
-    "D205",
-    "D206",
-    "D207",
-    "D208",
-    "D209",
-    "D210",
-    "D211",
+    "D213",
+    "D215",
+    "D400",
+    "D404",
+    "D406",
+    "D407",
+    "D408",
+    "D409",
+    "D413",
+]
+```
+
+Similarly, the following is equivalent to `--docstring-convention=pep8`:
+
+```toml
+[tool.ruff]
+extend-select = ["D"]
+extend-ignore = [
+    "D203",
+    "D212",
+    "D213",
    "D214",
    "D215",
-    "D300",
-    "D400",
-    "D402",
-    "D403",
    "D404",
    "D405",
    "D406",
@@ -594,51 +630,10 @@ extend-select = [
    "D409",
    "D410",
    "D411",
-    "D412",
    "D413",
-    "D418",
-    "D419",
-]
-```
-
-Similarly, the following is equivalent to `--docstring-convention google`:
-
-```toml
-[tool.ruff]
-extend-select = [
-    "D100",
-    "D101",
-    "D102",
-    "D103",
-    "D104",
-    "D105",
-    "D106",
-    "D107",
-    "D200",
-    "D201",
-    "D202",
-    "D205",
-    "D206",
-    "D207",
-    "D208",
-    "D209",
-    "D210",
-    "D211",
-    "D212",
-    "D214",
-    "D300",
-    "D402",
-    "D403",
-    "D405",
-    "D410",
-    "D411",
-    "D412",
-    "D414",
    "D415",
    "D416",
    "D417",
-    "D418",
-    "D419",
 ]
 ```

--- a/resources/test/fixtures/B013.py
+++ b/resources/test/fixtures/B013.py
@@ -0,0 +1,8 @@
+try:
+    pass
+except (ValueError,):
+    pass
+except AttributeError:
+    pass
+except (ImportError, TypeError):
+    pass
--- a/resources/test/fixtures/N802.py
+++ b/resources/test/fixtures/N802.py
@@ -1,3 +1,6 @@
+import unittest
+
+
 def Bad():
    pass

@@ -24,3 +27,15 @@ def _good():

 def good_func():
    pass
+
+
+def tearDownModule():
+    pass
+
+
+class Test(unittest.TestCase):
+    def tearDown(self):
+        return super().tearDown()
+
+    def testTest(self):
+        assert True
--- a/resources/test/fixtures/N806.py
+++ b/resources/test/fixtures/N806.py
@@ -0,0 +1,4 @@
+def f():
+    lower = 0
+    Camel = 0
+    CONSTANT = 0
--- a/resources/test/fixtures/N815.py
+++ b/resources/test/fixtures/N815.py
@@ -0,0 +1,6 @@
+class C:
+    lower = 0
+    CONSTANT = 0
+    mixedCase = 0
+    _mixedCase = 0
+    mixed_Case = 0
--- a/resources/test/fixtures/N816.py
+++ b/resources/test/fixtures/N816.py
@@ -0,0 +1,5 @@
+lower = 0
+CONSTANT = 0
+mixedCase = 0
+_mixedCase = 0
+mixed_Case = 0
--- a/resources/test/fixtures/N818.py
+++ b/resources/test/fixtures/N818.py
@@ -0,0 +1,10 @@
+class Error(Exception):
+    pass
+
+
+class AnotherError(Exception):
+    pass
+
+
+class C(Exception):
+    pass
--- a/resources/test/fixtures/pyproject.toml
+++ b/resources/test/fixtures/pyproject.toml
@@ -14,3 +14,25 @@ inline-quotes = "single"
 multiline-quotes = "double"
 docstring-quotes = "double"
 avoid-escape = true
+
+[tool.ruff.pep8-naming]
+ignore-names = [
+    "setUp",
+    "tearDown",
+    "setUpClass",
+    "tearDownClass",
+    "setUpModule",
+    "tearDownModule",
+    "asyncSetUp",
+    "asyncTearDown",
+    "setUpTestData",
+    "failureException",
+    "longMessage",
+    "maxDiff",
+]
+classmethod-decorators = [
+    "classmethod",
+]
+staticmethod-decorators = [
+    "staticmethod",
+]
--- a/src/ast/operations.rs
+++ b/src/ast/operations.rs
@@ -1,3 +1,4 @@
+use once_cell::unsync::OnceCell;
 use rustpython_parser::ast::{Constant, Expr, ExprKind, Location, Stmt, StmtKind};

 use crate::ast::types::{BindingKind, Range, Scope};
@@ -120,45 +121,47 @@ pub fn is_unpacking_assignment(stmt: &Stmt) -> bool {

 /// Struct used to efficiently slice source code at (row, column) Locations.
 pub struct SourceCodeLocator<'a> {
-    content: &'a str,
-    offsets: Vec<Vec<usize>>,
+    contents: &'a str,
+    offsets: OnceCell<Vec<Vec<usize>>>,
 }

 impl<'a> SourceCodeLocator<'a> {
-    pub fn new(content: &'a str) -> Self {
+    pub fn new(contents: &'a str) -> Self {
        SourceCodeLocator {
-            content,
-            offsets: Self::compute_offsets(content),
+            contents,
+            offsets: OnceCell::new(),
        }
    }

    fn compute_offsets(content: &str) -> Vec<Vec<usize>> {
-        let mut offsets = vec![];
-        let mut offset = 0;
-        for line in content.lines() {
-            let mut newline = 0;
-            let mut line_offsets: Vec<usize> = vec![];
-            for (i, char) in line.char_indices() {
-                line_offsets.push(offset + i);
-                newline = i + char.len_utf8();
+        let mut offsets = vec![vec![]];
+        let mut line_index = 0;
+        for (i, char) in content.char_indices() {
+            offsets[line_index].push(i);
+            if char == '\n' {
+                line_index += 1;
+                offsets.push(vec![]);
            }
-            line_offsets.push(offset + newline);
-            offsets.push(line_offsets);
-            offset += newline + 1;
        }
-        offsets.push(vec![offset]);
        offsets
    }

+    fn get_or_init_offsets(&self) -> &Vec<Vec<usize>> {
+        self.offsets
+            .get_or_init(|| Self::compute_offsets(self.contents))
+    }
+
    pub fn slice_source_code_at(&self, location: &Location) -> &'a str {
-        let offset = self.offsets[location.row() - 1][location.column() - 1];
-        &self.content[offset..]
+        let offsets = self.get_or_init_offsets();
+        let offset = offsets[location.row() - 1][location.column() - 1];
+        &self.contents[offset..]
    }

    pub fn slice_source_code_range(&self, range: &Range) -> &'a str {
-        let start = self.offsets[range.location.row() - 1][range.location.column() - 1];
-        let end = self.offsets[range.end_location.row() - 1][range.end_location.column() - 1];
-        &self.content[start..end]
+        let offsets = self.get_or_init_offsets();
+        let start = offsets[range.location.row() - 1][range.location.column() - 1];
+        let end = offsets[range.end_location.row() - 1][range.end_location.column() - 1];
+        &self.contents[start..end]
    }

    pub fn partition_source_code_at(
@@ -166,14 +169,15 @@ impl<'a> SourceCodeLocator<'a> {
        outer: &Range,
        inner: &Range,
    ) -> (&'a str, &'a str, &'a str) {
-        let outer_start = self.offsets[outer.location.row() - 1][outer.location.column() - 1];
-        let outer_end = self.offsets[outer.end_location.row() - 1][outer.end_location.column() - 1];
-        let inner_start = self.offsets[inner.location.row() - 1][inner.location.column() - 1];
-        let inner_end = self.offsets[inner.end_location.row() - 1][inner.end_location.column() - 1];
+        let offsets = self.get_or_init_offsets();
+        let outer_start = offsets[outer.location.row() - 1][outer.location.column() - 1];
+        let outer_end = offsets[outer.end_location.row() - 1][outer.end_location.column() - 1];
+        let inner_start = offsets[inner.location.row() - 1][inner.location.column() - 1];
+        let inner_end = offsets[inner.end_location.row() - 1][inner.end_location.column() - 1];
        (
-            &self.content[outer_start..inner_start],
-            &self.content[inner_start..inner_end],
-            &self.content[inner_end..outer_end],
+            &self.contents[outer_start..inner_start],
+            &self.contents[inner_start..inner_end],
+            &self.contents[inner_end..outer_end],
        )
    }
 }
@@ -184,15 +188,21 @@ mod tests {

    #[test]
    fn source_code_locator_init() {
+        let content = "x = 1\ny = 2\nz = x + y\n";
+        let locator = SourceCodeLocator::new(content);
+        let offsets = locator.get_or_init_offsets();
+        assert_eq!(offsets.len(), 4);
+        assert_eq!(offsets[0], [0, 1, 2, 3, 4, 5]);
+        assert_eq!(offsets[1], [6, 7, 8, 9, 10, 11]);
+        assert_eq!(offsets[2], [12, 13, 14, 15, 16, 17, 18, 19, 20, 21]);
+        assert!(offsets[3].is_empty());
+
        let content = "# \u{4e9c}\nclass Foo:\n    \"\"\".\"\"\"";
        let locator = SourceCodeLocator::new(content);
-        assert_eq!(locator.offsets.len(), 4);
-        assert_eq!(locator.offsets[0], [0, 1, 2, 5]);
-        assert_eq!(locator.offsets[1], [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
-        assert_eq!(
-            locator.offsets[2],
-            [17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28]
-        );
-        assert_eq!(locator.offsets[3], [29]);
+        let offsets = locator.get_or_init_offsets();
+        assert_eq!(offsets.len(), 3);
+        assert_eq!(offsets[0], [0, 1, 2, 5]);
+        assert_eq!(offsets[1], [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+        assert_eq!(offsets[2], [17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]);
    }
 }
--- a/src/check_ast.rs
+++ b/src/check_ast.rs
@@ -5,7 +5,6 @@ use std::ops::Deref;
 use std::path::Path;

 use log::error;
-use once_cell::unsync::OnceCell;
 use rustpython_parser::ast::{
    Arg, Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind,
    KeywordData, Operator, Stmt, StmtKind, Suite,
@@ -39,13 +38,11 @@ pub const GLOBAL_SCOPE_INDEX: usize = 0;
 pub struct Checker<'a> {
    // Input data.
    path: &'a Path,
-    content: &'a str,
    autofix: &'a fixer::Mode,
    pub(crate) settings: &'a Settings,
+    pub(crate) locator: &'a SourceCodeLocator<'a>,
    // Computed checks.
    checks: Vec<Check>,
-    // Efficient source-code slicing.
-    locator: OnceCell<SourceCodeLocator<'a>>,
    // Docstring tracking.
    docstrings: Vec<(Definition<'a>, Visibility)>,
    // Edit tracking.
@@ -79,14 +76,13 @@ impl<'a> Checker<'a> {
        settings: &'a Settings,
        autofix: &'a fixer::Mode,
        path: &'a Path,
-        content: &'a str,
+        locator: &'a SourceCodeLocator,
    ) -> Checker<'a> {
        Checker {
            settings,
            autofix,
            path,
-            content,
-            locator: OnceCell::new(),
+            locator,
            checks: Default::default(),
            docstrings: Default::default(),
            deletions: Default::default(),
@@ -114,12 +110,6 @@ impl<'a> Checker<'a> {
        }
    }

-    /// Get access to a lazily-initialized `SourceCodeLocator` for the file contents.
-    pub fn get_locator(&self) -> &SourceCodeLocator {
-        self.locator
-            .get_or_init(|| SourceCodeLocator::new(self.content))
-    }
-
    /// Return `true` if a patch should be generated under the given autofix `Mode`.
    pub fn patch(&self) -> bool {
        self.autofix.patch()
@@ -236,7 +226,11 @@ where
                }

                if self.settings.enabled.contains(&CheckCode::N802) {
-                    if let Some(check) = pep8_naming::checks::invalid_function_name(stmt, name) {
+                    if let Some(check) = pep8_naming::checks::invalid_function_name(
+                        stmt,
+                        name,
+                        &self.settings.pep8_naming,
+                    ) {
                        self.checks.push(check);
                    }
                }
@@ -247,6 +241,7 @@ where
                            self.current_scope(),
                            decorator_list,
                            args,
+                            &self.settings.pep8_naming,
                        )
                    {
                        self.checks.push(check);
@@ -258,6 +253,7 @@ where
                        self.current_scope(),
                        decorator_list,
                        args,
+                        &self.settings.pep8_naming,
                    ) {
                        self.checks.push(check);
                    }
@@ -363,6 +359,14 @@ where
                    }
                }

+                if self.settings.enabled.contains(&CheckCode::N818) {
+                    if let Some(check) =
+                        pep8_naming::checks::error_suffix_on_exception_name(stmt, bases, name)
+                    {
+                        self.checks.push(check);
+                    }
+                }
+
                self.check_builtin_shadowing(
                    name,
                    self.locate_check(Range::from_located(stmt)),
@@ -706,6 +710,9 @@ where
                {
                    flake8_bugbear::plugins::duplicate_exceptions(self, stmt, handlers);
                }
+                if self.settings.enabled.contains(&CheckCode::B013) {
+                    flake8_bugbear::plugins::redundant_tuple_in_exception_handler(self, handlers);
+                }
            }
            StmtKind::Assign { targets, value, .. } => {
                if self.settings.enabled.contains(&CheckCode::E731) {
@@ -1799,6 +1806,30 @@ impl<'a> Checker<'a> {
                }
            }

+            if self.settings.enabled.contains(&CheckCode::N806) {
+                if let Some(check) =
+                    pep8_naming::checks::non_lowercase_variable_in_function(current, expr, id)
+                {
+                    self.checks.push(check);
+                }
+            }
+
+            if self.settings.enabled.contains(&CheckCode::N815) {
+                if let Some(check) =
+                    pep8_naming::checks::mixed_case_variable_in_class_scope(current, expr, id)
+                {
+                    self.checks.push(check);
+                }
+            }
+
+            if self.settings.enabled.contains(&CheckCode::N816) {
+                if let Some(check) =
+                    pep8_naming::checks::mixed_case_variable_in_global_scope(current, expr, id)
+                {
+                    self.checks.push(check);
+                }
+            }
+
            if matches!(parent.node, StmtKind::AnnAssign { value: None, .. }) {
                self.add_binding(
                    id.to_string(),
@@ -2105,7 +2136,7 @@ impl<'a> Checker<'a> {
                            ImportKind::ImportFrom => pyflakes::fixes::remove_unused_import_froms,
                        };

-                        match removal_fn(self.get_locator(), &full_names, child, parent, &deleted) {
+                        match removal_fn(self.locator, &full_names, child, parent, &deleted) {
                            Ok(fix) => Some(fix),
                            Err(e) => {
                                error!("Failed to fix unused imports: {}", e);
@@ -2265,12 +2296,12 @@ impl<'a> Checker<'a> {

 pub fn check_ast(
    python_ast: &Suite,
-    contents: &str,
+    locator: &SourceCodeLocator,
    settings: &Settings,
    autofix: &fixer::Mode,
    path: &Path,
 ) -> Vec<Check> {
-    let mut checker = Checker::new(settings, autofix, path, contents);
+    let mut checker = Checker::new(settings, autofix, path, locator);
    checker.push_scope(Scope::new(ScopeKind::Module));
    checker.bind_builtins();

--- a/src/check_tokens.rs
+++ b/src/check_tokens.rs
@@ -9,7 +9,7 @@ use crate::{flake8_quotes, pycodestyle, Settings};

 pub fn check_tokens(
    checks: &mut Vec<Check>,
-    contents: &str,
+    locator: &SourceCodeLocator,
    tokens: &[LexResult],
    settings: &Settings,
 ) {
@@ -19,16 +19,13 @@ pub fn check_tokens(
        | settings.enabled.contains(&CheckCode::Q002)
        | settings.enabled.contains(&CheckCode::Q003);

-    // TODO(charlie): Use a shared SourceCodeLocator between this site and the AST traversal.
-    let locator = SourceCodeLocator::new(contents);
-
    let mut state_machine = StateMachine::new();
    for (start, tok, end) in tokens.iter().flatten() {
        // W605
        if enforce_invalid_escape_sequence {
            if matches!(tok, Tok::String { .. }) {
                checks.extend(pycodestyle::checks::invalid_escape_sequence(
-                    &locator, start, end,
+                    locator, start, end,
                ));
            }
        }
@@ -38,7 +35,7 @@ pub fn check_tokens(
            let is_docstring = state_machine.consume(tok);
            if matches!(tok, Tok::String { .. }) {
                if let Some(check) = flake8_quotes::checks::quotes(
-                    &locator,
+                    locator,
                    start,
                    end,
                    is_docstring,
--- a/src/checks.rs
+++ b/src/checks.rs
@@ -80,6 +80,7 @@ pub enum CheckCode {
    B002,
    B007,
    B011,
+    B013,
    B014,
    B017,
    B025,
@@ -168,12 +169,16 @@ pub enum CheckCode {
    N803,
    N804,
    N805,
+    N806,
    N807,
    N811,
    N812,
    N813,
    N814,
+    N815,
+    N816,
    N817,
+    N818,
    // Meta
    M001,
 }
@@ -284,6 +289,7 @@ pub enum CheckKind {
    UnaryPrefixIncrement,
    UnusedLoopControlVariable(String),
    DoNotAssertFalse,
+    RedundantTupleInExceptionHandler(String),
    DuplicateHandlerException(Vec<String>),
    NoAssertRaisesException,
    DuplicateTryBlockException(String),
@@ -372,12 +378,16 @@ pub enum CheckKind {
    InvalidArgumentName(String),
    InvalidFirstArgumentNameForClassMethod,
    InvalidFirstArgumentNameForMethod,
+    NonLowercaseVariableInFunction(String),
    DunderFunctionName,
    ConstantImportedAsNonConstant(String, String),
    LowercaseImportedAsNonLowercase(String, String),
    CamelcaseImportedAsLowercase(String, String),
    CamelcaseImportedAsConstant(String, String),
+    MixedCaseVariableInClassScope(String),
+    MixedCaseVariableInGlobalScope(String),
    CamelcaseImportedAsAcronym(String, String),
+    ErrorSuffixOnExceptionName(String),
    // Meta
    UnusedNOQA(Option<Vec<String>>),
 }
@@ -457,6 +467,9 @@ impl CheckCode {
            CheckCode::B002 => CheckKind::UnaryPrefixIncrement,
            CheckCode::B007 => CheckKind::UnusedLoopControlVariable("i".to_string()),
            CheckCode::B011 => CheckKind::DoNotAssertFalse,
+            CheckCode::B013 => {
+                CheckKind::RedundantTupleInExceptionHandler("ValueError".to_string())
+            }
            CheckCode::B014 => CheckKind::DuplicateHandlerException(vec!["ValueError".to_string()]),
            CheckCode::B017 => CheckKind::NoAssertRaisesException,
            CheckCode::B025 => CheckKind::DuplicateTryBlockException("Exception".to_string()),
@@ -567,6 +580,7 @@ impl CheckCode {
            CheckCode::N803 => CheckKind::InvalidArgumentName("...".to_string()),
            CheckCode::N804 => CheckKind::InvalidFirstArgumentNameForClassMethod,
            CheckCode::N805 => CheckKind::InvalidFirstArgumentNameForMethod,
+            CheckCode::N806 => CheckKind::NonLowercaseVariableInFunction("...".to_string()),
            CheckCode::N807 => CheckKind::DunderFunctionName,
            CheckCode::N811 => {
                CheckKind::ConstantImportedAsNonConstant("...".to_string(), "...".to_string())
@@ -580,9 +594,12 @@ impl CheckCode {
            CheckCode::N814 => {
                CheckKind::CamelcaseImportedAsConstant("...".to_string(), "...".to_string())
            }
+            CheckCode::N815 => CheckKind::MixedCaseVariableInClassScope("mixedCase".to_string()),
+            CheckCode::N816 => CheckKind::MixedCaseVariableInGlobalScope("mixedCase".to_string()),
            CheckCode::N817 => {
                CheckKind::CamelcaseImportedAsAcronym("...".to_string(), "...".to_string())
            }
+            CheckCode::N818 => CheckKind::ErrorSuffixOnExceptionName("...".to_string()),
            // Meta
            CheckCode::M001 => CheckKind::UnusedNOQA(None),
        }
@@ -640,6 +657,7 @@ impl CheckCode {
            CheckCode::B002 => CheckCategory::Flake8Bugbear,
            CheckCode::B007 => CheckCategory::Flake8Bugbear,
            CheckCode::B011 => CheckCategory::Flake8Bugbear,
+            CheckCode::B013 => CheckCategory::Flake8Bugbear,
            CheckCode::B014 => CheckCategory::Flake8Bugbear,
            CheckCode::B017 => CheckCategory::Flake8Bugbear,
            CheckCode::B025 => CheckCategory::Flake8Bugbear,
@@ -722,12 +740,16 @@ impl CheckCode {
            CheckCode::N803 => CheckCategory::PEP8Naming,
            CheckCode::N804 => CheckCategory::PEP8Naming,
            CheckCode::N805 => CheckCategory::PEP8Naming,
+            CheckCode::N806 => CheckCategory::PEP8Naming,
            CheckCode::N807 => CheckCategory::PEP8Naming,
            CheckCode::N811 => CheckCategory::PEP8Naming,
            CheckCode::N812 => CheckCategory::PEP8Naming,
            CheckCode::N813 => CheckCategory::PEP8Naming,
            CheckCode::N814 => CheckCategory::PEP8Naming,
+            CheckCode::N815 => CheckCategory::PEP8Naming,
+            CheckCode::N816 => CheckCategory::PEP8Naming,
            CheckCode::N817 => CheckCategory::PEP8Naming,
+            CheckCode::N818 => CheckCategory::PEP8Naming,
            CheckCode::M001 => CheckCategory::Meta,
        }
    }
@@ -791,6 +813,7 @@ impl CheckKind {
            CheckKind::UnaryPrefixIncrement => &CheckCode::B002,
            CheckKind::UnusedLoopControlVariable(_) => &CheckCode::B007,
            CheckKind::DoNotAssertFalse => &CheckCode::B011,
+            CheckKind::RedundantTupleInExceptionHandler(_) => &CheckCode::B013,
            CheckKind::DuplicateHandlerException(_) => &CheckCode::B014,
            CheckKind::NoAssertRaisesException => &CheckCode::B017,
            CheckKind::DuplicateTryBlockException(_) => &CheckCode::B025,
@@ -879,12 +902,16 @@ impl CheckKind {
            CheckKind::InvalidArgumentName(_) => &CheckCode::N803,
            CheckKind::InvalidFirstArgumentNameForClassMethod => &CheckCode::N804,
            CheckKind::InvalidFirstArgumentNameForMethod => &CheckCode::N805,
+            CheckKind::NonLowercaseVariableInFunction(..) => &CheckCode::N806,
            CheckKind::DunderFunctionName => &CheckCode::N807,
            CheckKind::ConstantImportedAsNonConstant(..) => &CheckCode::N811,
            CheckKind::LowercaseImportedAsNonLowercase(..) => &CheckCode::N812,
            CheckKind::CamelcaseImportedAsLowercase(..) => &CheckCode::N813,
            CheckKind::CamelcaseImportedAsConstant(..) => &CheckCode::N814,
+            CheckKind::MixedCaseVariableInClassScope(..) => &CheckCode::N815,
+            CheckKind::MixedCaseVariableInGlobalScope(..) => &CheckCode::N816,
            CheckKind::CamelcaseImportedAsAcronym(..) => &CheckCode::N817,
+            CheckKind::ErrorSuffixOnExceptionName(..) => &CheckCode::N818,
            // Meta
            CheckKind::UnusedNOQA(_) => &CheckCode::M001,
        }
@@ -1045,6 +1072,9 @@ impl CheckKind {
                "Do not `assert False` (`python -O` removes these calls), raise `AssertionError()`"
                    .to_string()
            }
+            CheckKind::RedundantTupleInExceptionHandler(name) => {
+                format!("A length-one tuple literal is redundant. Write `except {name}:` instead of `except ({name},):`.")
+            }
            CheckKind::DuplicateHandlerException(names) => {
                if names.len() == 1 {
                    let name = &names[0];
@@ -1120,7 +1150,7 @@ impl CheckKind {
                format!("Unnecessary subscript reversal of iterable within `{func}()`")
            }
            CheckKind::UnnecessaryComprehension(obj_type) => {
-                format!(" Unnecessary `{obj_type}` comprehension (rewrite using `{obj_type}()`)")
+                format!("Unnecessary `{obj_type}` comprehension (rewrite using `{obj_type}()`)")
            }
            CheckKind::UnnecessaryMap(obj_type) => {
                if obj_type == "generator" {
@@ -1305,6 +1335,9 @@ impl CheckKind {
            CheckKind::InvalidFirstArgumentNameForMethod => {
                "First argument of a method should be named `self`".to_string()
            }
+            CheckKind::NonLowercaseVariableInFunction(name) => {
+                format!("Variable `{name}` in function should be lowercase")
+            }
            CheckKind::DunderFunctionName => {
                "Function name should not start and end with `__`".to_string()
            }
@@ -1320,9 +1353,18 @@ impl CheckKind {
            CheckKind::CamelcaseImportedAsConstant(name, asname) => {
                format!("Camelcase `{name}` imported as constant `{asname}`")
            }
+            CheckKind::MixedCaseVariableInClassScope(name) => {
+                format!("Variable `{name}` in class scope should not be mixedCase")
+            }
+            CheckKind::MixedCaseVariableInGlobalScope(name) => {
+                format!("Variable `{name}` in global scope should not be mixedCase")
+            }
            CheckKind::CamelcaseImportedAsAcronym(name, asname) => {
                format!("Camelcase `{name}` imported as acronym `{asname}`")
            }
+            CheckKind::ErrorSuffixOnExceptionName(name) => {
+                format!("Exception name `{name}` should be named with an Error suffix")
+            }
            // Meta
            CheckKind::UnusedNOQA(codes) => match codes {
                None => "Unused `noqa` directive".to_string(),
--- a/src/checks_gen.rs
+++ b/src/checks_gen.rs
@@ -20,6 +20,7 @@ pub enum CheckCodePrefix {
    B007,
    B01,
    B011,
+    B013,
    B014,
    B017,
    B02,
@@ -184,13 +185,24 @@ pub enum CheckCodePrefix {
    N803,
    N804,
    N805,
+    N806,
    N807,
    N81,
    N811,
    N812,
    N813,
    N814,
+    N815,
+    N816,
    N817,
+    N818,
+    Q,
+    Q0,
+    Q00,
+    Q000,
+    Q001,
+    Q002,
+    Q003,
    T,
    T2,
    T20,
@@ -237,6 +249,7 @@ impl CheckCodePrefix {
                CheckCode::B002,
                CheckCode::B007,
                CheckCode::B011,
+                CheckCode::B013,
                CheckCode::B014,
                CheckCode::B017,
                CheckCode::B025,
@@ -245,6 +258,7 @@ impl CheckCodePrefix {
                CheckCode::B002,
                CheckCode::B007,
                CheckCode::B011,
+                CheckCode::B013,
                CheckCode::B014,
                CheckCode::B017,
                CheckCode::B025,
@@ -252,8 +266,14 @@ impl CheckCodePrefix {
            CheckCodePrefix::B00 => vec![CheckCode::B002, CheckCode::B007],
            CheckCodePrefix::B002 => vec![CheckCode::B002],
            CheckCodePrefix::B007 => vec![CheckCode::B007],
-            CheckCodePrefix::B01 => vec![CheckCode::B011, CheckCode::B014, CheckCode::B017],
+            CheckCodePrefix::B01 => vec![
+                CheckCode::B011,
+                CheckCode::B013,
+                CheckCode::B014,
+                CheckCode::B017,
+            ],
            CheckCodePrefix::B011 => vec![CheckCode::B011],
+            CheckCodePrefix::B013 => vec![CheckCode::B013],
            CheckCodePrefix::B014 => vec![CheckCode::B014],
            CheckCodePrefix::B017 => vec![CheckCode::B017],
            CheckCodePrefix::B02 => vec![CheckCode::B025],
@@ -716,12 +736,16 @@ impl CheckCodePrefix {
                CheckCode::N803,
                CheckCode::N804,
                CheckCode::N805,
+                CheckCode::N806,
                CheckCode::N807,
                CheckCode::N811,
                CheckCode::N812,
                CheckCode::N813,
                CheckCode::N814,
+                CheckCode::N815,
+                CheckCode::N816,
                CheckCode::N817,
+                CheckCode::N818,
            ],
            CheckCodePrefix::N8 => vec![
                CheckCode::N801,
@@ -729,12 +753,16 @@ impl CheckCodePrefix {
                CheckCode::N803,
                CheckCode::N804,
                CheckCode::N805,
+                CheckCode::N806,
                CheckCode::N807,
                CheckCode::N811,
                CheckCode::N812,
                CheckCode::N813,
                CheckCode::N814,
+                CheckCode::N815,
+                CheckCode::N816,
                CheckCode::N817,
+                CheckCode::N818,
            ],
            CheckCodePrefix::N80 => vec![
                CheckCode::N801,
@@ -742,6 +770,7 @@ impl CheckCodePrefix {
                CheckCode::N803,
                CheckCode::N804,
                CheckCode::N805,
+                CheckCode::N806,
                CheckCode::N807,
            ],
            CheckCodePrefix::N801 => vec![CheckCode::N801],
@@ -749,19 +778,48 @@ impl CheckCodePrefix {
            CheckCodePrefix::N803 => vec![CheckCode::N803],
            CheckCodePrefix::N804 => vec![CheckCode::N804],
            CheckCodePrefix::N805 => vec![CheckCode::N805],
+            CheckCodePrefix::N806 => vec![CheckCode::N806],
            CheckCodePrefix::N807 => vec![CheckCode::N807],
            CheckCodePrefix::N81 => vec![
                CheckCode::N811,
                CheckCode::N812,
                CheckCode::N813,
                CheckCode::N814,
+                CheckCode::N815,
+                CheckCode::N816,
                CheckCode::N817,
+                CheckCode::N818,
            ],
            CheckCodePrefix::N811 => vec![CheckCode::N811],
            CheckCodePrefix::N812 => vec![CheckCode::N812],
            CheckCodePrefix::N813 => vec![CheckCode::N813],
            CheckCodePrefix::N814 => vec![CheckCode::N814],
+            CheckCodePrefix::N815 => vec![CheckCode::N815],
+            CheckCodePrefix::N816 => vec![CheckCode::N816],
            CheckCodePrefix::N817 => vec![CheckCode::N817],
+            CheckCodePrefix::N818 => vec![CheckCode::N818],
+            CheckCodePrefix::Q => vec![
+                CheckCode::Q000,
+                CheckCode::Q001,
+                CheckCode::Q002,
+                CheckCode::Q003,
+            ],
+            CheckCodePrefix::Q0 => vec![
+                CheckCode::Q000,
+                CheckCode::Q001,
+                CheckCode::Q002,
+                CheckCode::Q003,
+            ],
+            CheckCodePrefix::Q00 => vec![
+                CheckCode::Q000,
+                CheckCode::Q001,
+                CheckCode::Q002,
+                CheckCode::Q003,
+            ],
+            CheckCodePrefix::Q000 => vec![CheckCode::Q000],
+            CheckCodePrefix::Q001 => vec![CheckCode::Q001],
+            CheckCodePrefix::Q002 => vec![CheckCode::Q002],
+            CheckCodePrefix::Q003 => vec![CheckCode::Q003],
            CheckCodePrefix::T => vec![CheckCode::T201, CheckCode::T203],
            CheckCodePrefix::T2 => vec![CheckCode::T201, CheckCode::T203],
            CheckCodePrefix::T20 => vec![CheckCode::T201, CheckCode::T203],
@@ -832,6 +890,7 @@ impl CheckCodePrefix {
            CheckCodePrefix::B007 => PrefixSpecificity::Explicit,
            CheckCodePrefix::B01 => PrefixSpecificity::Tens,
            CheckCodePrefix::B011 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::B013 => PrefixSpecificity::Explicit,
            CheckCodePrefix::B014 => PrefixSpecificity::Explicit,
            CheckCodePrefix::B017 => PrefixSpecificity::Explicit,
            CheckCodePrefix::B02 => PrefixSpecificity::Tens,
@@ -996,13 +1055,24 @@ impl CheckCodePrefix {
            CheckCodePrefix::N803 => PrefixSpecificity::Explicit,
            CheckCodePrefix::N804 => PrefixSpecificity::Explicit,
            CheckCodePrefix::N805 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::N806 => PrefixSpecificity::Explicit,
            CheckCodePrefix::N807 => PrefixSpecificity::Explicit,
            CheckCodePrefix::N81 => PrefixSpecificity::Tens,
            CheckCodePrefix::N811 => PrefixSpecificity::Explicit,
            CheckCodePrefix::N812 => PrefixSpecificity::Explicit,
            CheckCodePrefix::N813 => PrefixSpecificity::Explicit,
            CheckCodePrefix::N814 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::N815 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::N816 => PrefixSpecificity::Explicit,
            CheckCodePrefix::N817 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::N818 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::Q => PrefixSpecificity::Category,
+            CheckCodePrefix::Q0 => PrefixSpecificity::Hundreds,
+            CheckCodePrefix::Q00 => PrefixSpecificity::Tens,
+            CheckCodePrefix::Q000 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::Q001 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::Q002 => PrefixSpecificity::Explicit,
+            CheckCodePrefix::Q003 => PrefixSpecificity::Explicit,
            CheckCodePrefix::T => PrefixSpecificity::Category,
            CheckCodePrefix::T2 => PrefixSpecificity::Hundreds,
            CheckCodePrefix::T20 => PrefixSpecificity::Tens,
--- a/src/docstrings/helpers.rs
+++ b/src/docstrings/helpers.rs
@@ -27,7 +27,7 @@ pub fn leading_space(line: &str) -> String {
 /// Extract the leading indentation from a docstring.
 pub fn indentation<'a>(checker: &'a Checker, docstring: &Expr) -> &'a str {
    let range = Range::from_located(docstring);
-    checker.get_locator().slice_source_code_range(&Range {
+    checker.locator.slice_source_code_range(&Range {
        location: Location::new(range.location.row(), 1),
        end_location: Location::new(range.location.row(), range.location.column()),
    })
--- a/src/flake8_bugbear/plugins/mod.rs
+++ b/src/flake8_bugbear/plugins/mod.rs
@@ -2,11 +2,13 @@ pub use assert_false::assert_false;
 pub use assert_raises_exception::assert_raises_exception;
 pub use duplicate_exceptions::duplicate_exceptions;
 pub use duplicate_exceptions::duplicate_handler_exceptions;
+pub use redundant_tuple_in_exception_handler::redundant_tuple_in_exception_handler;
 pub use unary_prefix_increment::unary_prefix_increment;
 pub use unused_loop_control_variable::unused_loop_control_variable;

 mod assert_false;
 mod assert_raises_exception;
 mod duplicate_exceptions;
+mod redundant_tuple_in_exception_handler;
 mod unary_prefix_increment;
 mod unused_loop_control_variable;
--- a/src/flake8_bugbear/plugins/redundant_tuple_in_exception_handler.rs
+++ b/src/flake8_bugbear/plugins/redundant_tuple_in_exception_handler.rs
@@ -0,0 +1,22 @@
+use rustpython_ast::{Excepthandler, ExcepthandlerKind, ExprKind};
+
+use crate::ast::types::{CheckLocator, Range};
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+/// B013
+pub fn redundant_tuple_in_exception_handler(checker: &mut Checker, handlers: &[Excepthandler]) {
+    for handler in handlers {
+        let ExcepthandlerKind::ExceptHandler { type_, .. } = &handler.node;
+        if let Some(type_) = type_ {
+            if let ExprKind::Tuple { elts, .. } = &type_.node {
+                if elts.len() == 1 {
+                    checker.add_check(Check::new(
+                        CheckKind::RedundantTupleInExceptionHandler(elts[0].to_string()),
+                        checker.locate_check(Range::from_located(type_)),
+                    ));
+                }
+            }
+        }
+    }
+}
--- a/src/flake8_quotes/settings.rs
+++ b/src/flake8_quotes/settings.rs
@@ -1,4 +1,4 @@
-//! Settings for the `flake_quotes` plugin.
+//! Settings for the `flake-quotes` plugin.

 use serde::{Deserialize, Serialize};

@@ -27,12 +27,12 @@ pub struct Settings {
 }

 impl Settings {
-    pub fn from_config(config: Options) -> Self {
+    pub fn from_options(options: Options) -> Self {
        Self {
-            inline_quotes: config.inline_quotes.unwrap_or(Quote::Single),
-            multiline_quotes: config.multiline_quotes.unwrap_or(Quote::Double),
-            docstring_quotes: config.docstring_quotes.unwrap_or(Quote::Double),
-            avoid_escape: config.avoid_escape.unwrap_or(true),
+            inline_quotes: options.inline_quotes.unwrap_or(Quote::Single),
+            multiline_quotes: options.multiline_quotes.unwrap_or(Quote::Double),
+            docstring_quotes: options.docstring_quotes.unwrap_or(Quote::Double),
+            avoid_escape: options.avoid_escape.unwrap_or(true),
        }
    }
 }
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -47,7 +47,7 @@ pub mod settings;
 pub mod visibility;

 /// Run ruff over Python source code directly.
-pub fn check(path: &Path, contents: &str, quiet: bool) -> Result<Vec<Message>> {
+pub fn check(path: &Path, contents: &str) -> Result<Vec<Message>> {
    // Find the project root and pyproject.toml.
    let project_root = pyproject::find_project_root(&[path.to_path_buf()]);
    match &project_root {
@@ -60,11 +60,8 @@ pub fn check(path: &Path, contents: &str, quiet: bool) -> Result<Vec<Message>> {
        None => debug!("Unable to find pyproject.toml; using default settings..."),
    };

-    let settings = Settings::from_configuration(Configuration::from_pyproject(
-        &pyproject,
-        &project_root,
-        quiet,
-    )?);
+    let settings =
+        Settings::from_configuration(Configuration::from_pyproject(&pyproject, &project_root)?);

    // Tokenize once.
    let tokens: Vec<LexResult> = tokenize(contents);
--- a/src/linter.rs
+++ b/src/linter.rs
@@ -9,6 +9,7 @@ use log::debug;
 use rustpython_parser::lexer::LexResult;
 use rustpython_parser::{lexer, parser};

+use crate::ast::operations::SourceCodeLocator;
 use crate::ast::types::Range;
 use crate::autofix::fixer;
 use crate::autofix::fixer::fix_file;
@@ -46,13 +47,16 @@ pub(crate) fn check_path(
    // Aggregate all checks.
    let mut checks: Vec<Check> = vec![];

+    // Initialize the SourceCodeLocator (which computes offsets lazily).
+    let locator = SourceCodeLocator::new(contents);
+
    // Run the token-based checks.
    if settings
        .enabled
        .iter()
        .any(|check_code| matches!(check_code.lint_source(), LintSource::Tokens))
    {
-        check_tokens(&mut checks, contents, &tokens, settings);
+        check_tokens(&mut checks, &locator, &tokens, settings);
    }

    // Run the AST-based checks.
@@ -63,7 +67,7 @@ pub(crate) fn check_path(
    {
        match parser::parse_program_tokens(tokens, "<filename>") {
            Ok(python_ast) => {
-                checks.extend(check_ast(&python_ast, contents, settings, autofix, path))
+                checks.extend(check_ast(&python_ast, &locator, settings, autofix, path))
            }
            Err(parse_error) => {
                if settings.enabled.contains(&CheckCode::E999) {
@@ -254,6 +258,7 @@ mod tests {
    #[test_case(CheckCode::B002, Path::new("B002.py"); "B002")]
    #[test_case(CheckCode::B007, Path::new("B007.py"); "B007")]
    #[test_case(CheckCode::B011, Path::new("B011.py"); "B011")]
+    #[test_case(CheckCode::B013, Path::new("B013.py"); "B013")]
    #[test_case(CheckCode::B014, Path::new("B014.py"); "B014")]
    #[test_case(CheckCode::B017, Path::new("B017.py"); "B017")]
    #[test_case(CheckCode::B025, Path::new("B025.py"); "B025")]
@@ -368,12 +373,16 @@ mod tests {
    #[test_case(CheckCode::N803, Path::new("N803.py"); "N803")]
    #[test_case(CheckCode::N804, Path::new("N804.py"); "N804")]
    #[test_case(CheckCode::N805, Path::new("N805.py"); "N805")]
+    #[test_case(CheckCode::N806, Path::new("N806.py"); "N806")]
    #[test_case(CheckCode::N807, Path::new("N807.py"); "N807")]
    #[test_case(CheckCode::N811, Path::new("N811.py"); "N811")]
    #[test_case(CheckCode::N812, Path::new("N812.py"); "N812")]
    #[test_case(CheckCode::N813, Path::new("N813.py"); "N813")]
    #[test_case(CheckCode::N814, Path::new("N814.py"); "N814")]
+    #[test_case(CheckCode::N815, Path::new("N815.py"); "N815")]
+    #[test_case(CheckCode::N816, Path::new("N816.py"); "N816")]
    #[test_case(CheckCode::N817, Path::new("N817.py"); "N817")]
+    #[test_case(CheckCode::N818, Path::new("N818.py"); "N818")]
    #[test_case(CheckCode::T201, Path::new("T201.py"); "T201")]
    #[test_case(CheckCode::T203, Path::new("T203.py"); "T203")]
    #[test_case(CheckCode::U001, Path::new("U001.py"); "U001")]
--- a/src/main.rs
+++ b/src/main.rs
@@ -261,7 +261,7 @@ fn inner_main() -> Result<ExitCode> {
        .map(|pair| PerFileIgnore::new(pair, &project_root))
        .collect();

-    let mut configuration = Configuration::from_pyproject(&pyproject, &project_root, cli.quiet)?;
+    let mut configuration = Configuration::from_pyproject(&pyproject, &project_root)?;
    if !exclude.is_empty() {
        configuration.exclude = exclude;
    }
--- a/src/pep8_naming/checks.rs
+++ b/src/pep8_naming/checks.rs
@@ -1,9 +1,11 @@
 use itertools::Itertools;
 use rustpython_ast::{Arguments, Expr, ExprKind, Stmt};

-use crate::ast::types::{Range, Scope, ScopeKind};
+use crate::ast::types::{FunctionScope, Range, Scope, ScopeKind};
 use crate::checks::{Check, CheckKind};
+use crate::pep8_naming::settings::Settings;

+/// N801
 pub fn invalid_class_name(class_def: &Stmt, name: &str) -> Option<Check> {
    let stripped = name.strip_prefix('_').unwrap_or(name);
    if !stripped
@@ -21,8 +23,14 @@ pub fn invalid_class_name(class_def: &Stmt, name: &str) -> Option<Check> {
    None
 }

-pub fn invalid_function_name(func_def: &Stmt, name: &str) -> Option<Check> {
-    if name.chars().any(|c| c.is_uppercase()) {
+/// N802
+pub fn invalid_function_name(func_def: &Stmt, name: &str, settings: &Settings) -> Option<Check> {
+    if !is_lower(name)
+        && !settings
+            .ignore_names
+            .iter()
+            .any(|ignore_name| ignore_name == name)
+    {
        return Some(Check::new(
            CheckKind::InvalidFunctionName(name.to_string()),
            Range::from_located(func_def),
@@ -31,8 +39,9 @@ pub fn invalid_function_name(func_def: &Stmt, name: &str) -> Option<Check> {
    None
 }

+/// N803
 pub fn invalid_argument_name(location: Range, name: &str) -> Option<Check> {
-    if name.chars().any(|c| c.is_uppercase()) {
+    if !is_lower(name) {
        return Some(Check::new(
            CheckKind::InvalidArgumentName(name.to_string()),
            location,
@@ -41,10 +50,12 @@ pub fn invalid_argument_name(location: Range, name: &str) -> Option<Check> {
    None
 }

+/// N804
 pub fn invalid_first_argument_name_for_class_method(
    scope: &Scope,
    decorator_list: &[Expr],
    args: &Arguments,
+    settings: &Settings,
 ) -> Option<Check> {
    if !matches!(scope.kind, ScopeKind::Class) {
        return None;
@@ -52,7 +63,7 @@ pub fn invalid_first_argument_name_for_class_method(

    if decorator_list.iter().any(|decorator| {
        if let ExprKind::Name { id, .. } = &decorator.node {
-            id == "classmethod"
+            settings.classmethod_decorators.contains(id)
        } else {
            false
        }
@@ -69,10 +80,12 @@ pub fn invalid_first_argument_name_for_class_method(
    None
 }

+/// N805
 pub fn invalid_first_argument_name_for_method(
    scope: &Scope,
    decorator_list: &[Expr],
    args: &Arguments,
+    settings: &Settings,
 ) -> Option<Check> {
    if !matches!(scope.kind, ScopeKind::Class) {
        return None;
@@ -80,7 +93,8 @@ pub fn invalid_first_argument_name_for_method(

    if decorator_list.iter().any(|decorator| {
        if let ExprKind::Name { id, .. } = &decorator.node {
-            id == "classmethod" || id == "staticmethod"
+            settings.classmethod_decorators.contains(id)
+                || settings.staticmethod_decorators.contains(id)
        } else {
            false
        }
@@ -99,6 +113,21 @@ pub fn invalid_first_argument_name_for_method(
    None
 }

+/// N806
+pub fn non_lowercase_variable_in_function(scope: &Scope, expr: &Expr, name: &str) -> Option<Check> {
+    if !matches!(scope.kind, ScopeKind::Function(FunctionScope { .. })) {
+        return None;
+    }
+    if !is_lower(name) {
+        return Some(Check::new(
+            CheckKind::NonLowercaseVariableInFunction(name.to_string()),
+            Range::from_located(expr),
+        ));
+    }
+    None
+}
+
+/// N807
 pub fn dunder_function_name(func_def: &Stmt, scope: &Scope, name: &str) -> Option<Check> {
    if matches!(scope.kind, ScopeKind::Class) {
        return None;
@@ -114,6 +143,136 @@ pub fn dunder_function_name(func_def: &Stmt, scope: &Scope, name: &str) -> Optio
    None
 }

+/// N811
+pub fn constant_imported_as_non_constant(
+    import_from: &Stmt,
+    name: &str,
+    asname: &str,
+) -> Option<Check> {
+    if is_upper(name) && !is_upper(asname) {
+        return Some(Check::new(
+            CheckKind::ConstantImportedAsNonConstant(name.to_string(), asname.to_string()),
+            Range::from_located(import_from),
+        ));
+    }
+    None
+}
+
+/// N812
+pub fn lowercase_imported_as_non_lowercase(
+    import_from: &Stmt,
+    name: &str,
+    asname: &str,
+) -> Option<Check> {
+    if is_lower(name) && asname.to_lowercase() != asname {
+        return Some(Check::new(
+            CheckKind::LowercaseImportedAsNonLowercase(name.to_string(), asname.to_string()),
+            Range::from_located(import_from),
+        ));
+    }
+    None
+}
+
+/// N813
+pub fn camelcase_imported_as_lowercase(
+    import_from: &Stmt,
+    name: &str,
+    asname: &str,
+) -> Option<Check> {
+    if is_camelcase(name) && is_lower(asname) {
+        return Some(Check::new(
+            CheckKind::CamelcaseImportedAsLowercase(name.to_string(), asname.to_string()),
+            Range::from_located(import_from),
+        ));
+    }
+    None
+}
+
+/// N814
+pub fn camelcase_imported_as_constant(
+    import_from: &Stmt,
+    name: &str,
+    asname: &str,
+) -> Option<Check> {
+    if is_camelcase(name) && is_upper(asname) && !is_acronym(name, asname) {
+        return Some(Check::new(
+            CheckKind::CamelcaseImportedAsConstant(name.to_string(), asname.to_string()),
+            Range::from_located(import_from),
+        ));
+    }
+    None
+}
+
+/// N815
+pub fn mixed_case_variable_in_class_scope(scope: &Scope, expr: &Expr, name: &str) -> Option<Check> {
+    if !matches!(scope.kind, ScopeKind::Class) {
+        return None;
+    }
+    if is_mixed_case(name) {
+        return Some(Check::new(
+            CheckKind::MixedCaseVariableInClassScope(name.to_string()),
+            Range::from_located(expr),
+        ));
+    }
+    None
+}
+
+/// N816
+pub fn mixed_case_variable_in_global_scope(
+    scope: &Scope,
+    expr: &Expr,
+    name: &str,
+) -> Option<Check> {
+    if !matches!(scope.kind, ScopeKind::Module) {
+        return None;
+    }
+    if is_mixed_case(name) {
+        return Some(Check::new(
+            CheckKind::MixedCaseVariableInGlobalScope(name.to_string()),
+            Range::from_located(expr),
+        ));
+    }
+    None
+}
+
+/// N817
+pub fn camelcase_imported_as_acronym(
+    import_from: &Stmt,
+    name: &str,
+    asname: &str,
+) -> Option<Check> {
+    if is_camelcase(name) && is_upper(asname) && is_acronym(name, asname) {
+        return Some(Check::new(
+            CheckKind::CamelcaseImportedAsAcronym(name.to_string(), asname.to_string()),
+            Range::from_located(import_from),
+        ));
+    }
+    None
+}
+
+/// N818
+pub fn error_suffix_on_exception_name(
+    class_def: &Stmt,
+    bases: &[Expr],
+    name: &str,
+) -> Option<Check> {
+    if bases.iter().any(|base| {
+        if let ExprKind::Name { id, .. } = &base.node {
+            id == "Exception"
+        } else {
+            false
+        }
+    }) {
+        if !name.ends_with("Error") {
+            return Some(Check::new(
+                CheckKind::ErrorSuffixOnExceptionName(name.to_string()),
+                Range::from_located(class_def),
+            ));
+        }
+    }
+    None
+}
+
 fn is_lower(s: &str) -> bool {
    let mut cased = false;
    for c in s.chars() {
@@ -138,86 +297,27 @@ fn is_upper(s: &str) -> bool {
    cased
 }

-pub fn constant_imported_as_non_constant(
-    import_from: &Stmt,
-    name: &str,
-    asname: &str,
-) -> Option<Check> {
-    if is_upper(name) && !is_upper(asname) {
-        return Some(Check::new(
-            CheckKind::ConstantImportedAsNonConstant(name.to_string(), asname.to_string()),
-            Range::from_located(import_from),
-        ));
-    }
-    None
-}
-
-pub fn lowercase_imported_as_non_lowercase(
-    import_from: &Stmt,
-    name: &str,
-    asname: &str,
-) -> Option<Check> {
-    if is_lower(name) && asname.to_lowercase() != asname {
-        return Some(Check::new(
-            CheckKind::LowercaseImportedAsNonLowercase(name.to_string(), asname.to_string()),
-            Range::from_located(import_from),
-        ));
-    }
-    None
-}
-
 fn is_camelcase(name: &str) -> bool {
    !is_lower(name) && !is_upper(name) && !name.contains('_')
 }
+
+fn is_mixed_case(name: &str) -> bool {
+    !is_lower(name)
+        && name
+            .strip_prefix('_')
+            .unwrap_or(name)
+            .chars()
+            .next()
+            .map_or_else(|| false, |c| c.is_lowercase())
+}
+
 fn is_acronym(name: &str, asname: &str) -> bool {
    name.chars().filter(|c| c.is_uppercase()).join("") == asname
 }

-pub fn camelcase_imported_as_lowercase(
-    import_from: &Stmt,
-    name: &str,
-    asname: &str,
-) -> Option<Check> {
-    if is_camelcase(name) && is_lower(asname) {
-        return Some(Check::new(
-            CheckKind::CamelcaseImportedAsLowercase(name.to_string(), asname.to_string()),
-            Range::from_located(import_from),
-        ));
-    }
-    None
-}
-
-pub fn camelcase_imported_as_constant(
-    import_from: &Stmt,
-    name: &str,
-    asname: &str,
-) -> Option<Check> {
-    if is_camelcase(name) && is_upper(asname) && !is_acronym(name, asname) {
-        return Some(Check::new(
-            CheckKind::CamelcaseImportedAsConstant(name.to_string(), asname.to_string()),
-            Range::from_located(import_from),
-        ));
-    }
-    None
-}
-
-pub fn camelcase_imported_as_acronym(
-    import_from: &Stmt,
-    name: &str,
-    asname: &str,
-) -> Option<Check> {
-    if is_camelcase(name) && is_upper(asname) && is_acronym(name, asname) {
-        return Some(Check::new(
-            CheckKind::CamelcaseImportedAsAcronym(name.to_string(), asname.to_string()),
-            Range::from_located(import_from),
-        ));
-    }
-    None
-}
-
 #[cfg(test)]
 mod tests {
-    use super::{is_acronym, is_camelcase, is_lower, is_upper};
+    use super::{is_acronym, is_camelcase, is_lower, is_mixed_case, is_upper};

    #[test]
    fn test_is_lower() -> () {
@@ -251,6 +351,17 @@ mod tests {
        assert!(!is_camelcase("CAMEL_CASE"));
    }

+    #[test]
+    fn test_is_mixed_case() -> () {
+        assert!(is_mixed_case("mixedCase"));
+        assert!(is_mixed_case("mixed_Case"));
+        assert!(is_mixed_case("_mixed_Case"));
+        assert!(!is_mixed_case("mixed_case"));
+        assert!(!is_mixed_case("MIXED_CASE"));
+        assert!(!is_mixed_case(""));
+        assert!(!is_mixed_case("_"));
+    }
+
    #[test]
    fn test_is_acronym() -> () {
        assert!(is_acronym("AB", "AB"));
--- a/src/pep8_naming/mod.rs
+++ b/src/pep8_naming/mod.rs
@@ -1 +1,2 @@
 pub mod checks;
+pub mod settings;
--- a/src/pep8_naming/settings.rs
+++ b/src/pep8_naming/settings.rs
@@ -0,0 +1,63 @@
+//! Settings for the `pep8-naming` plugin.
+
+use serde::Deserialize;
+
+const IGNORE_NAMES: [&str; 12] = [
+    "setUp",
+    "tearDown",
+    "setUpClass",
+    "tearDownClass",
+    "setUpModule",
+    "tearDownModule",
+    "asyncSetUp",
+    "asyncTearDown",
+    "setUpTestData",
+    "failureException",
+    "longMessage",
+    "maxDiff",
+];
+
+const CLASSMETHOD_DECORATORS: [&str; 1] = ["classmethod"];
+
+const STATICMETHOD_DECORATORS: [&str; 1] = ["staticmethod"];
+
+#[derive(Debug, PartialEq, Eq, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "kebab-case")]
+pub struct Options {
+    pub ignore_names: Option<Vec<String>>,
+    pub classmethod_decorators: Option<Vec<String>>,
+    pub staticmethod_decorators: Option<Vec<String>>,
+}
+
+#[derive(Debug)]
+pub struct Settings {
+    pub ignore_names: Vec<String>,
+    pub classmethod_decorators: Vec<String>,
+    pub staticmethod_decorators: Vec<String>,
+}
+
+impl Settings {
+    pub fn from_options(options: Options) -> Self {
+        Self {
+            ignore_names: options
+                .ignore_names
+                .unwrap_or_else(|| IGNORE_NAMES.map(String::from).to_vec()),
+            classmethod_decorators: options
+                .classmethod_decorators
+                .unwrap_or_else(|| CLASSMETHOD_DECORATORS.map(String::from).to_vec()),
+            staticmethod_decorators: options
+                .staticmethod_decorators
+                .unwrap_or_else(|| STATICMETHOD_DECORATORS.map(String::from).to_vec()),
+        }
+    }
+}
+
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            ignore_names: IGNORE_NAMES.map(String::from).to_vec(),
+            classmethod_decorators: CLASSMETHOD_DECORATORS.map(String::from).to_vec(),
+            staticmethod_decorators: STATICMETHOD_DECORATORS.map(String::from).to_vec(),
+        }
+    }
+}
--- a/src/pydocstyle/plugins.rs
+++ b/src/pydocstyle/plugins.rs
@@ -162,7 +162,7 @@ pub fn blank_before_after_function(checker: &mut Checker, definition: &Definitio
            } = &docstring.node
            {
                if checker.settings.enabled.contains(&CheckCode::D201) {
-                    let (before, _, _) = checker.get_locator().partition_source_code_at(
+                    let (before, _, _) = checker.locator.partition_source_code_at(
                        &Range::from_located(parent),
                        &Range::from_located(docstring),
                    );
@@ -190,7 +190,7 @@ pub fn blank_before_after_function(checker: &mut Checker, definition: &Definitio
                }

                if checker.settings.enabled.contains(&CheckCode::D202) {
-                    let (_, _, after) = checker.get_locator().partition_source_code_at(
+                    let (_, _, after) = checker.locator.partition_source_code_at(
                        &Range::from_located(parent),
                        &Range::from_located(docstring),
                    );
@@ -253,7 +253,7 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
                if checker.settings.enabled.contains(&CheckCode::D203)
                    || checker.settings.enabled.contains(&CheckCode::D211)
                {
-                    let (before, _, _) = checker.get_locator().partition_source_code_at(
+                    let (before, _, _) = checker.locator.partition_source_code_at(
                        &Range::from_located(parent),
                        &Range::from_located(docstring),
                    );
@@ -300,7 +300,7 @@ pub fn blank_before_after_class(checker: &mut Checker, definition: &Definition)
                }

                if checker.settings.enabled.contains(&CheckCode::D204) {
-                    let (_, _, after) = checker.get_locator().partition_source_code_at(
+                    let (_, _, after) = checker.locator.partition_source_code_at(
                        &Range::from_located(parent),
                        &Range::from_located(docstring),
                    );
@@ -530,7 +530,7 @@ pub fn newline_after_last_paragraph(checker: &mut Checker, definition: &Definiti
                }
                if line_count > 1 {
                    let content = checker
-                        .get_locator()
+                        .locator
                        .slice_source_code_range(&Range::from_located(docstring));
                    if let Some(last_line) = content.lines().last().map(|line| line.trim()) {
                        if last_line != "\"\"\"" && last_line != "'''" {
@@ -583,7 +583,7 @@ pub fn no_surrounding_whitespace(checker: &mut Checker, definition: &Definition)
                    );
                    if checker.patch() {
                        if let Some(first_line) = checker
-                            .get_locator()
+                            .locator
                            .slice_source_code_range(&Range::from_located(docstring))
                            .lines()
                            .next()
@@ -629,7 +629,7 @@ pub fn multi_line_summary_start(checker: &mut Checker, definition: &Definition)
        {
            if string.lines().nth(1).is_some() {
                if let Some(first_line) = checker
-                    .get_locator()
+                    .locator
                    .slice_source_code_range(&Range::from_located(docstring))
                    .lines()
                    .next()
@@ -665,7 +665,7 @@ pub fn triple_quotes(checker: &mut Checker, definition: &Definition) {
        } = &docstring.node
        {
            if let Some(first_line) = checker
-                .get_locator()
+                .locator
                .slice_source_code_range(&Range::from_located(docstring))
                .lines()
                .next()
--- a/src/pyupgrade/plugins/super_call_with_parameters.rs
+++ b/src/pyupgrade/plugins/super_call_with_parameters.rs
@@ -17,9 +17,7 @@ pub fn super_call_with_parameters(checker: &mut Checker, expr: &Expr, func: &Exp
            .collect();
        if let Some(mut check) = checks::super_args(scope, &parents, expr, func, args) {
            if checker.patch() {
-                if let Some(fix) =
-                    pyupgrade::fixes::remove_super_arguments(checker.get_locator(), expr)
-                {
+                if let Some(fix) = pyupgrade::fixes::remove_super_arguments(checker.locator, expr) {
                    check.amend(fix);
                }
            }
--- a/src/pyupgrade/plugins/useless_object_inheritance.rs
+++ b/src/pyupgrade/plugins/useless_object_inheritance.rs
@@ -15,7 +15,7 @@ pub fn useless_object_inheritance(
    if let Some(mut check) = checks::useless_object_inheritance(name, bases, scope) {
        if checker.patch() {
            if let Some(fix) = pyupgrade::fixes::remove_class_def_base(
-                checker.get_locator(),
+                checker.locator,
                &stmt.location,
                check.location,
                bases,
--- a/src/settings/configuration.rs
+++ b/src/settings/configuration.rs
@@ -8,9 +8,9 @@ use once_cell::sync::Lazy;
 use regex::Regex;

 use crate::checks_gen::CheckCodePrefix;
-use crate::flake8_quotes;
 use crate::settings::pyproject::load_options;
 use crate::settings::types::{FilePattern, PerFileIgnore, PythonVersion};
+use crate::{flake8_quotes, pep8_naming};

 #[derive(Debug)]
 pub struct Configuration {
@@ -26,6 +26,7 @@ pub struct Configuration {
    pub target_version: PythonVersion,
    // Plugins
    pub flake8_quotes: flake8_quotes::settings::Settings,
+    pub pep8_naming: pep8_naming::settings::Settings,
 }

 static DEFAULT_EXCLUDE: Lazy<Vec<FilePattern>> = Lazy::new(|| {
@@ -59,9 +60,8 @@ impl Configuration {
    pub fn from_pyproject(
        pyproject: &Option<PathBuf>,
        project_root: &Option<PathBuf>,
-        quiet: bool,
    ) -> Result<Self> {
-        let options = load_options(pyproject, quiet)?;
+        let options = load_options(pyproject)?;
        Ok(Configuration {
            dummy_variable_rgx: match options.dummy_variable_rgx {
                Some(pattern) => Regex::new(&pattern)
@@ -98,7 +98,11 @@ impl Configuration {
            // Plugins
            flake8_quotes: options
                .flake8_quotes
-                .map(flake8_quotes::settings::Settings::from_config)
+                .map(flake8_quotes::settings::Settings::from_options)
+                .unwrap_or_default(),
+            pep8_naming: options
+                .pep8_naming
+                .map(pep8_naming::settings::Settings::from_options)
                .unwrap_or_default(),
        })
    }
--- a/src/settings/mod.rs
+++ b/src/settings/mod.rs
@@ -8,9 +8,9 @@ use regex::Regex;

 use crate::checks::CheckCode;
 use crate::checks_gen::{CheckCodePrefix, PrefixSpecificity};
-use crate::flake8_quotes;
 use crate::settings::configuration::Configuration;
 use crate::settings::types::{FilePattern, PerFileIgnore, PythonVersion};
+use crate::{flake8_quotes, pep8_naming};

 pub mod configuration;
 pub mod options;
@@ -29,6 +29,7 @@ pub struct Settings {
    pub target_version: PythonVersion,
    // Plugins
    pub flake8_quotes: flake8_quotes::settings::Settings,
+    pub pep8_naming: pep8_naming::settings::Settings,
 }

 impl Settings {
@@ -45,6 +46,7 @@ impl Settings {
            extend_exclude: config.extend_exclude,
            flake8_quotes: config.flake8_quotes,
            line_length: config.line_length,
+            pep8_naming: config.pep8_naming,
            per_file_ignores: config.per_file_ignores,
            target_version: config.target_version,
        }
@@ -60,6 +62,7 @@ impl Settings {
            per_file_ignores: vec![],
            target_version: PythonVersion::Py310,
            flake8_quotes: Default::default(),
+            pep8_naming: Default::default(),
        }
    }

@@ -73,6 +76,7 @@ impl Settings {
            per_file_ignores: vec![],
            target_version: PythonVersion::Py310,
            flake8_quotes: Default::default(),
+            pep8_naming: Default::default(),
        }
    }
 }
--- a/src/settings/options.rs
+++ b/src/settings/options.rs
@@ -3,8 +3,8 @@
 use serde::Deserialize;

 use crate::checks_gen::CheckCodePrefix;
-use crate::flake8_quotes;
 use crate::settings::types::{PythonVersion, StrCheckCodePair};
+use crate::{flake8_quotes, pep8_naming};

 #[derive(Debug, PartialEq, Eq, Deserialize, Default)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
@@ -24,5 +24,7 @@ pub struct Options {
    pub per_file_ignores: Vec<StrCheckCodePair>,
    pub dummy_variable_rgx: Option<String>,
    pub target_version: Option<PythonVersion>,
+    // Plugins
    pub flake8_quotes: Option<flake8_quotes::settings::Options>,
+    pub pep8_naming: Option<pep8_naming::settings::Options>,
 }
--- a/src/settings/pyproject.rs
+++ b/src/settings/pyproject.rs
@@ -4,6 +4,7 @@ use std::path::{Path, PathBuf};

 use anyhow::Result;
 use common_path::common_path_all;
+use log::debug;
 use path_absolutize::Absolutize;
 use serde::Deserialize;

@@ -69,17 +70,15 @@ pub fn find_project_root(sources: &[PathBuf]) -> Option<PathBuf> {
    None
 }

-pub fn load_options(pyproject: &Option<PathBuf>, quiet: bool) -> Result<Options> {
+pub fn load_options(pyproject: &Option<PathBuf>) -> Result<Options> {
    match pyproject {
        Some(pyproject) => Ok(parse_pyproject_toml(pyproject)?
            .tool
            .and_then(|tool| tool.ruff)
            .unwrap_or_default()),
        None => {
-            if !quiet {
-                eprintln!("No pyproject.toml found.");
-                eprintln!("Falling back to default configuration...");
-            }
+            debug!("No pyproject.toml found.");
+            debug!("Falling back to default configuration...");
            Ok(Default::default())
        }
    }
@@ -94,12 +93,12 @@ mod tests {
    use anyhow::Result;

    use crate::checks_gen::CheckCodePrefix;
-    use crate::flake8_quotes;
    use crate::flake8_quotes::settings::Quote;
    use crate::settings::pyproject::{
        find_project_root, find_pyproject_toml, parse_pyproject_toml, Options, Pyproject, Tools,
    };
    use crate::settings::types::StrCheckCodePair;
+    use crate::{flake8_quotes, pep8_naming};

    #[test]
    fn deserialize() -> Result<()> {
@@ -133,7 +132,8 @@ mod tests {
                    per_file_ignores: vec![],
                    dummy_variable_rgx: None,
                    target_version: None,
-                    flake8_quotes: None
+                    flake8_quotes: None,
+                    pep8_naming: None,
                })
            })
        );
@@ -159,7 +159,8 @@ line-length = 79
                    per_file_ignores: vec![],
                    dummy_variable_rgx: None,
                    target_version: None,
-                    flake8_quotes: None
+                    flake8_quotes: None,
+                    pep8_naming: None,
                })
            })
        );
@@ -185,7 +186,8 @@ exclude = ["foo.py"]
                    per_file_ignores: vec![],
                    dummy_variable_rgx: None,
                    target_version: None,
-                    flake8_quotes: None
+                    flake8_quotes: None,
+                    pep8_naming: None,
                })
            })
        );
@@ -211,7 +213,8 @@ select = ["E501"]
                    per_file_ignores: vec![],
                    dummy_variable_rgx: None,
                    target_version: None,
-                    flake8_quotes: None
+                    flake8_quotes: None,
+                    pep8_naming: None,
                })
            })
        );
@@ -238,7 +241,8 @@ ignore = ["E501"]
                    per_file_ignores: vec![],
                    dummy_variable_rgx: None,
                    target_version: None,
-                    flake8_quotes: None
+                    flake8_quotes: None,
+                    pep8_naming: None,
                })
            })
        );
@@ -316,7 +320,25 @@ other-attribute = 1
                    multiline_quotes: Some(Quote::Double),
                    docstring_quotes: Some(Quote::Double),
                    avoid_escape: Some(true),
-                })
+                }),
+                pep8_naming: Some(pep8_naming::settings::Options {
+                    ignore_names: Some(vec![
+                        "setUp".to_string(),
+                        "tearDown".to_string(),
+                        "setUpClass".to_string(),
+                        "tearDownClass".to_string(),
+                        "setUpModule".to_string(),
+                        "tearDownModule".to_string(),
+                        "asyncSetUp".to_string(),
+                        "asyncTearDown".to_string(),
+                        "setUpTestData".to_string(),
+                        "failureException".to_string(),
+                        "longMessage".to_string(),
+                        "maxDiff".to_string(),
+                    ]),
+                    classmethod_decorators: Some(vec!["classmethod".to_string()]),
+                    staticmethod_decorators: Some(vec!["staticmethod".to_string()]),
+                }),
            }
        );

--- a/src/settings/user.rs
+++ b/src/settings/user.rs
@@ -6,7 +6,7 @@ use regex::Regex;

 use crate::checks_gen::CheckCodePrefix;
 use crate::settings::types::{FilePattern, PerFileIgnore, PythonVersion};
-use crate::{flake8_quotes, Configuration};
+use crate::{flake8_quotes, pep8_naming, Configuration};

 /// Struct to render user-facing exclusion patterns.
 #[derive(Debug)]
@@ -46,6 +46,7 @@ pub struct UserConfiguration {
    pub target_version: PythonVersion,
    // Plugins
    pub flake8_quotes: flake8_quotes::settings::Settings,
+    pub pep8_naming: pep8_naming::settings::Settings,
    // Non-settings exposed to the user
    pub project_root: Option<PathBuf>,
    pub pyproject: Option<PathBuf>,
@@ -53,30 +54,31 @@ pub struct UserConfiguration {

 impl UserConfiguration {
    pub fn from_configuration(
-        settings: Configuration,
+        configuration: Configuration,
        project_root: Option<PathBuf>,
        pyproject: Option<PathBuf>,
    ) -> Self {
        Self {
-            dummy_variable_rgx: settings.dummy_variable_rgx,
-            exclude: settings
+            dummy_variable_rgx: configuration.dummy_variable_rgx,
+            exclude: configuration
                .exclude
                .into_iter()
                .map(Exclusion::from_file_pattern)
                .collect(),
-            extend_exclude: settings
+            extend_exclude: configuration
                .extend_exclude
                .into_iter()
                .map(Exclusion::from_file_pattern)
                .collect(),
-            extend_ignore: settings.extend_ignore,
-            extend_select: settings.extend_select,
-            ignore: settings.ignore,
-            line_length: settings.line_length,
-            per_file_ignores: settings.per_file_ignores,
-            select: settings.select,
-            target_version: settings.target_version,
-            flake8_quotes: settings.flake8_quotes,
+            extend_ignore: configuration.extend_ignore,
+            extend_select: configuration.extend_select,
+            ignore: configuration.ignore,
+            line_length: configuration.line_length,
+            per_file_ignores: configuration.per_file_ignores,
+            select: configuration.select,
+            target_version: configuration.target_version,
+            flake8_quotes: configuration.flake8_quotes,
+            pep8_naming: configuration.pep8_naming,
            project_root,
            pyproject,
        }
--- a/src/snapshots/rufflintertests__B013_B013.py.snap
+++ b/src/snapshots/rufflintertests__B013_B013.py.snap
@@ -0,0 +1,14 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    RedundantTupleInExceptionHandler: ValueError
+  location:
+    row: 3
+    column: 9
+  end_location:
+    row: 3
+    column: 20
+  fix: ~
+
--- a/src/snapshots/rufflintertests__N802_N802.py.snap
+++ b/src/snapshots/rufflintertests__N802_N802.py.snap
@@ -5,37 +5,46 @@ expression: checks
 - kind:
    InvalidFunctionName: Bad
  location:
-    row: 1
+    row: 4
    column: 1
  end_location:
-    row: 5
+    row: 8
    column: 1
  fix: ~
 - kind:
    InvalidFunctionName: _Bad
  location:
-    row: 5
+    row: 8
    column: 1
  end_location:
-    row: 9
+    row: 12
    column: 1
  fix: ~
 - kind:
    InvalidFunctionName: BAD
  location:
-    row: 9
+    row: 12
    column: 1
  end_location:
-    row: 13
+    row: 16
    column: 1
  fix: ~
 - kind:
    InvalidFunctionName: BAD_FUNC
  location:
-    row: 13
+    row: 16
    column: 1
  end_location:
-    row: 17
+    row: 20
+    column: 1
+  fix: ~
+- kind:
+    InvalidFunctionName: testTest
+  location:
+    row: 40
+    column: 5
+  end_location:
+    row: 42
    column: 1
  fix: ~

--- a/src/snapshots/rufflintertests__N806_N806.py.snap
+++ b/src/snapshots/rufflintertests__N806_N806.py.snap
@@ -0,0 +1,23 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    NonLowercaseVariableInFunction: Camel
+  location:
+    row: 3
+    column: 5
+  end_location:
+    row: 3
+    column: 10
+  fix: ~
+- kind:
+    NonLowercaseVariableInFunction: CONSTANT
+  location:
+    row: 4
+    column: 5
+  end_location:
+    row: 4
+    column: 13
+  fix: ~
+
--- a/src/snapshots/rufflintertests__N815_N815.py.snap
+++ b/src/snapshots/rufflintertests__N815_N815.py.snap
@@ -0,0 +1,32 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    MixedCaseVariableInClassScope: mixedCase
+  location:
+    row: 4
+    column: 5
+  end_location:
+    row: 4
+    column: 14
+  fix: ~
+- kind:
+    MixedCaseVariableInClassScope: _mixedCase
+  location:
+    row: 5
+    column: 5
+  end_location:
+    row: 5
+    column: 15
+  fix: ~
+- kind:
+    MixedCaseVariableInClassScope: mixed_Case
+  location:
+    row: 6
+    column: 5
+  end_location:
+    row: 6
+    column: 15
+  fix: ~
+
--- a/src/snapshots/rufflintertests__N816_N816.py.snap
+++ b/src/snapshots/rufflintertests__N816_N816.py.snap
@@ -0,0 +1,32 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    MixedCaseVariableInGlobalScope: mixedCase
+  location:
+    row: 3
+    column: 1
+  end_location:
+    row: 3
+    column: 10
+  fix: ~
+- kind:
+    MixedCaseVariableInGlobalScope: _mixedCase
+  location:
+    row: 4
+    column: 1
+  end_location:
+    row: 4
+    column: 11
+  fix: ~
+- kind:
+    MixedCaseVariableInGlobalScope: mixed_Case
+  location:
+    row: 5
+    column: 1
+  end_location:
+    row: 5
+    column: 11
+  fix: ~
+
--- a/src/snapshots/rufflintertests__N818_N818.py.snap
+++ b/src/snapshots/rufflintertests__N818_N818.py.snap
@@ -0,0 +1,14 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    ErrorSuffixOnExceptionName: C
+  location:
+    row: 9
+    column: 1
+  end_location:
+    row: 11
+    column: 1
+  fix: ~
+
Author	SHA1	Message	Date
Charlie Marsh	5a3f06bab1	Bump version to 0.0.90	2022-10-29 18:34:38 -04:00
Charlie Marsh	db59d5b558	Use a single SourceCodeLocator everywhere (#510 )	2022-10-29 18:23:24 -04:00
Charlie Marsh	2fcbf3ab62	Simplify SourceCodeLocator offset computation (#509 )	2022-10-29 18:13:42 -04:00
Anders Kaseorg	fa9b10be72	Remove leading space from C416 message (#508 )	2022-10-29 17:40:50 -04:00
Charlie Marsh	c495cef529	Move pyproject.toml logging to debug (#506 )	2022-10-29 17:07:46 -04:00
Charlie Marsh	c0c8dff6ce	Implement configuration options for pep8-naming (#505 )	2022-10-29 17:00:30 -04:00
Charlie Marsh	80b00cc89f	Add error code categories to table of contents (#504 )	2022-10-29 16:39:55 -04:00
Charlie Marsh	934db3d179	Bump version to 0.0.89	2022-10-29 15:39:17 -04:00
Charlie Marsh	6a040a0405	Update checks_gen.rs	2022-10-29 15:39:02 -04:00
Harutaka Kawamura	2821ef0f69	Implement B013 (#503 )	2022-10-29 15:36:29 -04:00
Harutaka Kawamura	343d931ddb	Ignore unittest methods and functions in N802 (#502 )	2022-10-29 15:36:09 -04:00
Harutaka Kawamura	3fc257f71b	Implement N806, 815, 816, 818 (#501 )	2022-10-29 15:35:56 -04:00
Charlie Marsh	6dbb0a17e9	Update README to reflect selection groups	2022-10-28 19:15:46 -04:00
Charlie Marsh	ae5ad6a4ac	Bump version to 0.0.88	2022-10-28 19:11:04 -04:00
Charlie Marsh	549af6c584	Regenerate CheckCodePrefix	2022-10-28 19:10:45 -04:00