Bump version to 0.0.121

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.120
+    rev: v0.0.121
     hooks:
       - id: ruff
 

Cargo.lock

@@ -930,7 +930,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.120-dev.0"
+version = "0.0.121-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.22",
@@ -2238,10 +2238,11 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.120"
+version = "0.0.121"
 dependencies = [
  "anyhow",
  "assert_cmd",
+ "atty",
  "bincode",
  "bitflags",
  "cacache",
@@ -2286,7 +2287,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.120"
+version = "0.0.121"
 dependencies = [
  "anyhow",
  "clap 4.0.22",

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.120"
+version = "0.0.121"
 edition = "2021"
 
 [lib]
@@ -14,6 +14,7 @@ name = "ruff"
 
 [dependencies]
 anyhow = { version = "1.0.66" }
+atty = { version = "0.2.14" }
 bincode = { version = "1.3.3" }
 bitflags = { version = "1.3.2" }
 chrono = { version = "0.4.21", default-features = false, features = ["clock"] }

README.md

@@ -52,15 +52,16 @@ Read the [launch blog post](https://notes.crmarsh.com/python-tooling-could-be-mu
    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. [flake8-annotations](#flake8-annotations)
-   13. [flake8-2020](#flake8-2020)
-   14. [Ruff-specific rules](#ruff-specific-rules)
-   15. [Meta rules](#meta-rules)
+   7. [flake8-bandit](#flake8-bandit)
+   8. [flake8-comprehensions](#flake8-comprehensions)
+   9. [flake8-bugbear](#flake8-bugbear)
+   10. [flake8-builtins](#flake8-builtins)
+   11. [flake8-print](#flake8-print)
+   12. [flake8-quotes](#flake8-quotes)
+   13. [flake8-annotations](#flake8-annotations)
+   14. [flake8-2020](#flake8-2020)
+   15. [Ruff-specific rules](#ruff-specific-rules)
+   16. [Meta rules](#meta-rules)
 5. [Editor Integrations](#editor-integrations)
 6. [FAQ](#faq)
 7. [Development](#development)
@@ -236,6 +237,8 @@ Options:
           Regular expression matching the name of dummy variables
       --target-version <TARGET_VERSION>
           The minimum Python version that should be supported
+      --line-length <LINE_LENGTH>
+          Set the line-length for length-associated checks and automatic formatting
       --stdin-filename <STDIN_FILENAME>
           The name of the file when passing it through stdin
   -h, --help
@@ -528,6 +531,7 @@ For more, see [flake8-bugbear](https://pypi.org/project/flake8-bugbear/22.10.27/
 | B017 | NoAssertRaisesException | `assertRaises(Exception)` should be considered evil |  |
 | B018 | UselessExpression | Found useless expression. Either assign it to a variable or remove it. |  |
 | B019 | CachedInstanceMethod | Use of `functools.lru_cache` or `functools.cache` on methods can lead to memory leaks |  |
+| B020 | LoopVariableOverridesIterator | Loop control variable `...` overrides iterable it iterates |  |
 | B021 | FStringDocstring | f-string used as docstring. This will be interpreted by python as a joined string rather than a docstring. |  |
 | B022 | UselessContextlibSuppress | No arguments passed to `contextlib.suppress`. No exceptions will be suppressed and therefore this context manager is redundant |  |
 | B024 | AbstractBaseClassWithoutAbstractMethod | `...` is an abstract base class, but it has no abstract methods |  |
@@ -731,7 +735,7 @@ Today, Ruff can be used to replace Flake8 when used with any of the following pl
 - [`flake8-annotations`](https://pypi.org/project/flake8-annotations/)
 - [`flake8-bandit`](https://pypi.org/project/flake8-bandit/) (6/40)
 - [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/)
-- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (25/32)
+- [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (26/32)
 - [`flake8-2020`](https://pypi.org/project/flake8-2020/)
 
 Ruff can also replace [`isort`](https://pypi.org/project/isort/), [`yesqa`](https://github.com/asottile/yesqa),

flake8_to_ruff/Cargo.lock

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

flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.120-dev.0"
+version = "0.0.121-dev.0"
 edition = "2021"
 
 [lib]

resources/test/fixtures/B020.py

@@ -0,0 +1,40 @@
+"""
+Should emit:
+B020 - on lines 8, 21, and 36
+"""
+
+items = [1, 2, 3]
+
+for items in items:
+    print(items)
+
+items = [1, 2, 3]
+
+for item in items:
+    print(item)
+
+values = {"secret": 123}
+
+for key, value in values.items():
+    print(f"{key}, {value}")
+
+for key, values in values.items():
+    print(f"{key}, {values}")
+
+# Variables defined in a comprehension are local in scope
+# to that comprehension and are therefore allowed.
+for var in [var for var in range(10)]:
+    print(var)
+
+for var in (var for var in range(10)):
+    print(var)
+
+for k, v in {k: v for k, v in zip(range(10), range(10, 20))}.items():
+    print(k, v)
+
+# However we still call out reassigning the iterable in the comprehension.
+for vars in [i for i in vars]:
+    print(vars)
+
+for var in sorted(range(10), key=lambda var: var.real):
+    print(var)

resources/test/fixtures/F821_5.py

@@ -0,0 +1,14 @@
+"""Test: inner class annotation."""
+
+
+class RandomClass:
+    def random_func(self) -> "InnerClass":
+        pass
+
+
+class OuterClass:
+    class InnerClass:
+        pass
+
+    def failing_func(self) -> "InnerClass":
+        return self.InnerClass()

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.120"
+version = "0.0.121"
 edition = "2021"
 
 [dependencies]

src/cache.rs

@@ -23,7 +23,7 @@ use crate::autofix::fixer;
 use crate::message::Message;
 use crate::settings::Settings;
 
-const VERSION: &str = env!("CARGO_PKG_VERSION");
+const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
 
 #[derive(Serialize, Deserialize)]
 struct CacheMetadata {
@@ -89,7 +89,7 @@ fn cache_key(path: &Path, settings: &Settings, autofix: &fixer::Mode) -> String
     format!(
         "{}@{}@{}",
         path.absolutize().unwrap().to_string_lossy(),
-        VERSION,
+        CARGO_PKG_VERSION,
         hasher.finish()
     )
 }

src/check_ast.rs

@@ -65,7 +65,7 @@ pub struct Checker<'a> {
     scopes: Vec<Scope<'a>>,
     scope_stack: Vec<usize>,
     dead_scopes: Vec<usize>,
-    deferred_string_annotations: Vec<(Range, &'a str)>,
+    deferred_string_annotations: Vec<(Range, &'a str, Vec<usize>, Vec<usize>)>,
     deferred_annotations: Vec<(&'a Expr, Vec<usize>, Vec<usize>)>,
     deferred_functions: Vec<(&'a Stmt, Vec<usize>, Vec<usize>, VisibleScope)>,
     deferred_lambdas: Vec<(&'a Expr, Vec<usize>, Vec<usize>)>,
@@ -873,10 +873,15 @@ where
                     flake8_bugbear::plugins::assert_raises_exception(self, stmt, items);
                 }
             }
-            StmtKind::For { target, body, .. } => {
+            StmtKind::For {
+                target, body, iter, ..
+            } => {
                 if self.settings.enabled.contains(&CheckCode::B007) {
                     flake8_bugbear::plugins::unused_loop_control_variable(self, target, body);
                 }
+                if self.settings.enabled.contains(&CheckCode::B020) {
+                    flake8_bugbear::plugins::loop_variable_overrides_iterator(self, target, iter);
+                }
             }
             StmtKind::Try { handlers, .. } => {
                 if self.settings.enabled.contains(&CheckCode::F707) {
@@ -1042,8 +1047,12 @@ where
                 ..
             } = &expr.node
             {
-                self.deferred_string_annotations
-                    .push((Range::from_located(expr), value));
+                self.deferred_string_annotations.push((
+                    Range::from_located(expr),
+                    value,
+                    self.scope_stack.clone(),
+                    self.parent_stack.clone(),
+                ));
             } else {
                 self.deferred_annotations.push((
                     expr,
@@ -1059,7 +1068,7 @@ where
             ExprKind::Subscript { value, slice, .. } => {
                 // Ex) typing.List[...]
                 if self.settings.enabled.contains(&CheckCode::U007)
-                    && self.settings.target_version >= PythonVersion::Py39
+                    && self.settings.target_version >= PythonVersion::Py310
                 {
                     pyupgrade::plugins::use_pep604_annotation(self, expr, value, slice);
                 }
@@ -1569,8 +1578,12 @@ where
                 ..
             } => {
                 if self.in_annotation && !self.in_literal {
-                    self.deferred_string_annotations
-                        .push((Range::from_located(expr), value));
+                    self.deferred_string_annotations.push((
+                        Range::from_located(expr),
+                        value,
+                        self.scope_stack.clone(),
+                        self.parent_stack.clone(),
+                    ));
                 }
                 if self.settings.enabled.contains(&CheckCode::S104) {
                     if let Some(check) = flake8_bandit::plugins::hardcoded_bind_all_interfaces(
@@ -2128,6 +2141,7 @@ impl<'a> Checker<'a> {
             let mut import_starred = false;
             for scope_index in self.scope_stack.iter().rev() {
                 let scope = &mut self.scopes[*scope_index];
+
                 if matches!(scope.kind, ScopeKind::Class(_)) {
                     if id == "__class__" {
                         return;
@@ -2344,8 +2358,8 @@ impl<'a> Checker<'a> {
 
     fn check_deferred_annotations(&mut self) {
         while let Some((expr, scopes, parents)) = self.deferred_annotations.pop() {
-            self.parent_stack = parents;
             self.scope_stack = scopes;
+            self.parent_stack = parents;
             self.visit_expr(expr);
         }
     }
@@ -2354,10 +2368,14 @@ impl<'a> Checker<'a> {
     where
         'b: 'a,
     {
-        while let Some((range, expression)) = self.deferred_string_annotations.pop() {
+        let mut stacks = vec![];
+        while let Some((range, expression, scopes, parents)) =
+            self.deferred_string_annotations.pop()
+        {
             if let Ok(mut expr) = parser::parse_expression(expression, "<filename>") {
                 relocate_expr(&mut expr, range);
                 allocator.push(expr);
+                stacks.push((scopes, parents));
             } else {
                 if self.settings.enabled.contains(&CheckCode::F722) {
                     self.add_check(Check::new(
@@ -2367,7 +2385,9 @@ impl<'a> Checker<'a> {
                 }
             }
         }
-        for expr in allocator {
+        for (expr, (scopes, parents)) in allocator.iter().zip(stacks) {
+            self.scope_stack = scopes;
+            self.parent_stack = parents;
             self.visit_expr(expr);
         }
     }

src/checks.rs

@@ -95,6 +95,7 @@ pub enum CheckCode {
     B017,
     B018,
     B019,
+    B020,
     B021,
     B022,
     B024,
@@ -399,6 +400,7 @@ pub enum CheckKind {
     NoAssertRaisesException,
     UselessExpression,
     CachedInstanceMethod,
+    LoopVariableOverridesIterator(String),
     FStringDocstring,
     UselessContextlibSuppress,
     AbstractBaseClassWithoutAbstractMethod(String),
@@ -645,6 +647,7 @@ impl CheckCode {
             CheckCode::B017 => CheckKind::NoAssertRaisesException,
             CheckCode::B018 => CheckKind::UselessExpression,
             CheckCode::B019 => CheckKind::CachedInstanceMethod,
+            CheckCode::B020 => CheckKind::LoopVariableOverridesIterator("...".to_string()),
             CheckCode::B021 => CheckKind::FStringDocstring,
             CheckCode::B022 => CheckKind::UselessContextlibSuppress,
             CheckCode::B024 => CheckKind::AbstractBaseClassWithoutAbstractMethod("...".to_string()),
@@ -890,6 +893,7 @@ impl CheckCode {
             CheckCode::B017 => CheckCategory::Flake8Bugbear,
             CheckCode::B018 => CheckCategory::Flake8Bugbear,
             CheckCode::B019 => CheckCategory::Flake8Bugbear,
+            CheckCode::B020 => CheckCategory::Flake8Bugbear,
             CheckCode::B021 => CheckCategory::Flake8Bugbear,
             CheckCode::B022 => CheckCategory::Flake8Bugbear,
             CheckCode::B024 => CheckCategory::Flake8Bugbear,
@@ -1098,6 +1102,7 @@ impl CheckKind {
             CheckKind::NoAssertRaisesException => &CheckCode::B017,
             CheckKind::UselessExpression => &CheckCode::B018,
             CheckKind::CachedInstanceMethod => &CheckCode::B019,
+            CheckKind::LoopVariableOverridesIterator(_) => &CheckCode::B020,
             CheckKind::FStringDocstring => &CheckCode::B021,
             CheckKind::UselessContextlibSuppress => &CheckCode::B022,
             CheckKind::AbstractBaseClassWithoutAbstractMethod(_) => &CheckCode::B024,
@@ -1472,6 +1477,9 @@ impl CheckKind {
             CheckKind::CachedInstanceMethod => "Use of `functools.lru_cache` or `functools.cache` \
                                                 on methods can lead to memory leaks"
                 .to_string(),
+            CheckKind::LoopVariableOverridesIterator(name) => {
+                format!("Loop control variable `{name}` overrides iterable it iterates")
+            }
             CheckKind::FStringDocstring => "f-string used as docstring. This will be interpreted \
                                             by python as a joined string rather than a docstring."
                 .to_string(),

src/checks_gen.rs

@@ -56,6 +56,7 @@ pub enum CheckCodePrefix {
     B018,
     B019,
     B02,
+    B020,
     B021,
     B022,
     B024,
@@ -386,6 +387,7 @@ impl CheckCodePrefix {
                 CheckCode::B017,
                 CheckCode::B018,
                 CheckCode::B019,
+                CheckCode::B020,
                 CheckCode::B021,
                 CheckCode::B022,
                 CheckCode::B024,
@@ -412,6 +414,7 @@ impl CheckCodePrefix {
                 CheckCode::B017,
                 CheckCode::B018,
                 CheckCode::B019,
+                CheckCode::B020,
                 CheckCode::B021,
                 CheckCode::B022,
                 CheckCode::B024,
@@ -460,6 +463,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::B018 => vec![CheckCode::B018],
             CheckCodePrefix::B019 => vec![CheckCode::B019],
             CheckCodePrefix::B02 => vec![
+                CheckCode::B020,
                 CheckCode::B021,
                 CheckCode::B022,
                 CheckCode::B024,
@@ -467,6 +471,7 @@ impl CheckCodePrefix {
                 CheckCode::B026,
                 CheckCode::B027,
             ],
+            CheckCodePrefix::B020 => vec![CheckCode::B020],
             CheckCodePrefix::B021 => vec![CheckCode::B021],
             CheckCodePrefix::B022 => vec![CheckCode::B022],
             CheckCodePrefix::B024 => vec![CheckCode::B024],
@@ -1213,6 +1218,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::B018 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B019 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B02 => PrefixSpecificity::Tens,
+            CheckCodePrefix::B020 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B021 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B022 => PrefixSpecificity::Explicit,
             CheckCodePrefix::B024 => PrefixSpecificity::Explicit,

src/cli.rs

@@ -87,6 +87,10 @@ pub struct Cli {
     /// The minimum Python version that should be supported.
     #[arg(long)]
     pub target_version: Option<PythonVersion>,
+    /// Set the line-length for length-associated checks and automatic
+    /// formatting.
+    #[arg(long)]
+    pub line_length: Option<usize>,
     /// Round-trip auto-formatting.
     // TODO(charlie): This should be a sub-command.
     #[arg(long, hide = true)]
@@ -120,6 +124,8 @@ pub fn extract_log_level(cli: &Cli) -> LogLevel {
         LogLevel::Quiet
     } else if cli.verbose {
         LogLevel::Verbose
+    } else if matches!(cli.format, SerializationFormat::Json) {
+        LogLevel::Quiet
     } else {
         LogLevel::Default
     }

src/flake8_bugbear/plugins/loop_variable_overrides_iterator.rs

@@ -0,0 +1,64 @@
+use fnv::FnvHashMap;
+use rustpython_ast::{Expr, ExprKind};
+
+use crate::ast::types::Range;
+use crate::ast::visitor;
+use crate::ast::visitor::Visitor;
+use crate::check_ast::Checker;
+use crate::checks::{Check, CheckKind};
+
+#[derive(Default)]
+struct NameFinder<'a> {
+    names: FnvHashMap<&'a str, &'a Expr>,
+}
+
+impl<'a, 'b> Visitor<'b> for NameFinder<'a>
+where
+    'b: 'a,
+{
+    fn visit_expr(&mut self, expr: &'b Expr) {
+        match &expr.node {
+            ExprKind::Name { id, .. } => {
+                self.names.insert(id, expr);
+            }
+            ExprKind::ListComp { generators, .. }
+            | ExprKind::DictComp { generators, .. }
+            | ExprKind::SetComp { generators, .. }
+            | ExprKind::GeneratorExp { generators, .. } => {
+                for comp in generators {
+                    self.visit_expr(&comp.iter);
+                }
+            }
+            ExprKind::Lambda { args, body } => {
+                visitor::walk_expr(self, body);
+                for arg in args.args.iter() {
+                    self.names.remove(arg.node.arg.as_str());
+                }
+            }
+            _ => visitor::walk_expr(self, expr),
+        }
+    }
+}
+
+/// B020
+pub fn loop_variable_overrides_iterator(checker: &mut Checker, target: &Expr, iter: &Expr) {
+    let target_names = {
+        let mut target_finder = NameFinder::default();
+        target_finder.visit_expr(target);
+        target_finder.names
+    };
+    let iter_names = {
+        let mut iter_finder = NameFinder::default();
+        iter_finder.visit_expr(iter);
+        iter_finder.names
+    };
+
+    for (name, expr) in target_names {
+        if iter_names.contains_key(name) {
+            checker.add_check(Check::new(
+                CheckKind::LoopVariableOverridesIterator(name.to_string()),
+                Range::from_located(expr),
+            ));
+        }
+    }
+}

src/flake8_bugbear/plugins/mod.rs

@@ -9,6 +9,7 @@ pub use f_string_docstring::f_string_docstring;
 pub use function_call_argument_default::function_call_argument_default;
 pub use getattr_with_constant::getattr_with_constant;
 pub use jump_statement_in_finally::jump_statement_in_finally;
+pub use loop_variable_overrides_iterator::loop_variable_overrides_iterator;
 pub use mutable_argument_default::mutable_argument_default;
 pub use redundant_tuple_in_exception_handler::redundant_tuple_in_exception_handler;
 pub use setattr_with_constant::setattr_with_constant;
@@ -32,6 +33,7 @@ mod f_string_docstring;
 mod function_call_argument_default;
 mod getattr_with_constant;
 mod jump_statement_in_finally;
+mod loop_variable_overrides_iterator;
 mod mutable_argument_default;
 mod redundant_tuple_in_exception_handler;
 mod setattr_with_constant;

src/lib.rs

@@ -52,6 +52,8 @@ mod pyupgrade;
 mod rules;
 pub mod settings;
 pub mod source_code_locator;
+#[cfg(feature = "update-informer")]
+pub mod updates;
 pub mod visibility;
 
 /// Run Ruff over Python source code directly.

src/linter.rs

@@ -344,6 +344,7 @@ mod tests {
     #[test_case(CheckCode::B017, Path::new("B017.py"); "B017")]
     #[test_case(CheckCode::B018, Path::new("B018.py"); "B018")]
     #[test_case(CheckCode::B019, Path::new("B019.py"); "B019")]
+    #[test_case(CheckCode::B020, Path::new("B020.py"); "B020")]
     #[test_case(CheckCode::B021, Path::new("B021.py"); "B021")]
     #[test_case(CheckCode::B022, Path::new("B022.py"); "B022")]
     #[test_case(CheckCode::B024, Path::new("B024.py"); "B024")]
@@ -456,6 +457,7 @@ mod tests {
     #[test_case(CheckCode::F821, Path::new("F821_2.py"); "F821_2")]
     #[test_case(CheckCode::F821, Path::new("F821_3.py"); "F821_3")]
     #[test_case(CheckCode::F821, Path::new("F821_4.py"); "F821_4")]
+    #[test_case(CheckCode::F821, Path::new("F821_5.py"); "F821_5")]
     #[test_case(CheckCode::F822, Path::new("F822.py"); "F822")]
     #[test_case(CheckCode::F823, Path::new("F823.py"); "F823")]
     #[test_case(CheckCode::F831, Path::new("F831.py"); "F831")]

src/main.rs

@@ -17,6 +17,8 @@ use ::ruff::settings::configuration::Configuration;
 use ::ruff::settings::types::FilePattern;
 use ::ruff::settings::user::UserConfiguration;
 use ::ruff::settings::{pyproject, Settings};
+#[cfg(feature = "update-informer")]
+use ::ruff::updates;
 use anyhow::Result;
 use clap::Parser;
 use colored::Colorize;
@@ -26,11 +28,6 @@ use notify::{raw_watcher, RecursiveMode, Watcher};
 use rayon::prelude::*;
 use walkdir::DirEntry;
 
-#[cfg(feature = "update-informer")]
-const CARGO_PKG_NAME: &str = env!("CARGO_PKG_NAME");
-#[cfg(feature = "update-informer")]
-const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
-
 /// Shim that calls par_iter except for wasm because there's no wasm support in
 /// rayon yet (there is a shim to be used for the web, but it requires js
 /// cooperation) Unfortunately, ParallelIterator does not implement Iterator so
@@ -45,30 +42,6 @@ fn par_iter<T: Sync>(iterable: &Vec<T>) -> impl Iterator<Item = &T> {
     iterable.iter()
 }
 
-#[cfg(feature = "update-informer")]
-fn check_for_updates() {
-    use update_informer::{registry, Check};
-
-    let informer = update_informer::new(registry::PyPI, CARGO_PKG_NAME, CARGO_PKG_VERSION);
-
-    if let Some(new_version) = informer.check_version().ok().flatten() {
-        let msg = format!(
-            "A new version of {pkg_name} is available: v{pkg_version} -> {new_version}",
-            pkg_name = CARGO_PKG_NAME.italic().cyan(),
-            pkg_version = CARGO_PKG_VERSION,
-            new_version = new_version.to_string().green()
-        );
-
-        let cmd = format!(
-            "Run to update: {cmd} {pkg_name}",
-            cmd = "pip3 install --upgrade".green(),
-            pkg_name = CARGO_PKG_NAME.green()
-        );
-
-        println!("\n{msg}\n{cmd}");
-    }
-}
-
 fn show_settings(
     configuration: Configuration,
     project_root: Option<PathBuf>,
@@ -292,6 +265,9 @@ fn inner_main() -> Result<ExitCode> {
     if !cli.extend_ignore.is_empty() {
         configuration.extend_ignore = cli.extend_ignore;
     }
+    if let Some(line_length) = cli.line_length {
+        configuration.line_length = line_length;
+    }
     if let Some(target_version) = cli.target_version {
         configuration.target_version = target_version;
     }
@@ -402,8 +378,8 @@ fn inner_main() -> Result<ExitCode> {
 
         // Check for updates if we're in a non-silent log level.
         #[cfg(feature = "update-informer")]
-        if !is_stdin && log_level >= LogLevel::Default {
-            check_for_updates();
+        if !is_stdin && log_level >= LogLevel::Default && atty::is(atty::Stream::Stdout) {
+            let _ = updates::check_for_updates();
         }
 
         if messages.iter().any(|message| !message.fixed) && !cli.exit_zero {

src/snapshots/ruff__linter__tests__B020_B020.py.snap

@@ -0,0 +1,32 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    LoopVariableOverridesIterator: items
+  location:
+    row: 8
+    column: 4
+  end_location:
+    row: 8
+    column: 9
+  fix: ~
+- kind:
+    LoopVariableOverridesIterator: values
+  location:
+    row: 21
+    column: 9
+  end_location:
+    row: 21
+    column: 15
+  fix: ~
+- kind:
+    LoopVariableOverridesIterator: vars
+  location:
+    row: 36
+    column: 4
+  end_location:
+    row: 36
+    column: 8
+  fix: ~
+

src/snapshots/ruff__linter__tests__F821_F821_5.py.snap

@@ -0,0 +1,14 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UndefinedName: InnerClass
+  location:
+    row: 5
+    column: 29
+  end_location:
+    row: 5
+    column: 41
+  fix: ~
+

src/updates.rs

@@ -0,0 +1,75 @@
+use std::fs::{create_dir_all, read_to_string, File};
+use std::io::Write;
+use std::path::{Path, PathBuf};
+
+use anyhow::Result;
+use colored::Colorize;
+
+const CARGO_PKG_NAME: &str = env!("CARGO_PKG_NAME");
+const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+fn cache_dir() -> &'static str {
+    "./.ruff_cache"
+}
+
+fn file_path() -> PathBuf {
+    Path::new(cache_dir()).join(".update-informer")
+}
+
+/// Get the "latest" version for which the user has been informed.
+fn get_latest() -> Result<Option<String>> {
+    let path = file_path();
+    if path.exists() {
+        Ok(Some(read_to_string(path)?.trim().to_string()))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Set the "latest" version for which the user has been informed.
+fn set_latest(version: &str) -> Result<()> {
+    create_dir_all(cache_dir())?;
+    let path = file_path();
+    let mut file = File::create(path)?;
+    file.write_all(version.trim().as_bytes())
+        .map_err(|e| e.into())
+}
+
+/// Update the user if a newer version is available.
+pub fn check_for_updates() -> Result<()> {
+    use update_informer::{registry, Check};
+
+    let informer = update_informer::new(registry::PyPI, CARGO_PKG_NAME, CARGO_PKG_VERSION);
+
+    if let Some(new_version) = informer
+        .check_version()
+        .ok()
+        .flatten()
+        .map(|version| version.to_string())
+    {
+        // If we've already notified the user about this version, return early.
+        if let Some(latest_version) = get_latest()? {
+            if latest_version == new_version {
+                return Ok(());
+            }
+        }
+        set_latest(&new_version)?;
+
+        let msg = format!(
+            "A new version of {pkg_name} is available: v{pkg_version} -> {new_version}",
+            pkg_name = CARGO_PKG_NAME.italic().cyan(),
+            pkg_version = CARGO_PKG_VERSION,
+            new_version = new_version.green()
+        );
+
+        let cmd = format!(
+            "Run to update: {cmd} {pkg_name}",
+            cmd = "pip3 install --upgrade".green(),
+            pkg_name = CARGO_PKG_NAME.green()
+        );
+
+        println!("\n{msg}\n{cmd}");
+    }
+
+    Ok(())
+}