ruff_linter 0.16.4

This is an internal component crate of Ruff
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use ast::{Expr, StmtIf};
use ruff_macros::{ViolationMetadata, derive_message_formats};
use ruff_python_ast as ast;
use ruff_text_size::Ranged;

use crate::Violation;
use crate::checkers::ast::Checker;

/// ## What it does
/// Checks for too many Boolean expressions in an `if` statement.
///
/// By default, this rule allows up to 5 expressions. This can be configured
/// using the [`lint.pylint.max-bool-expr`] option.
///
/// ## Why is this bad?
/// `if` statements with many Boolean expressions are harder to understand
/// and maintain. Consider assigning the result of the Boolean expression,
/// or any of its sub-expressions, to a variable.
///
/// ## Example
/// ```python
/// if a and b and c and d and e and f and g and h:
///     ...
/// ```
///
/// ## Options
/// - `lint.pylint.max-bool-expr`
#[derive(ViolationMetadata)]
#[violation_metadata(preview_since = "v0.1.1")]
pub(crate) struct TooManyBooleanExpressions {
    expressions: usize,
    max_expressions: usize,
}

impl Violation for TooManyBooleanExpressions {
    #[derive_message_formats]
    fn message(&self) -> String {
        let TooManyBooleanExpressions {
            expressions,
            max_expressions,
        } = self;
        format!("Too many Boolean expressions ({expressions} > {max_expressions})")
    }
}

/// PLR0916
pub(crate) fn too_many_boolean_expressions(checker: &Checker, stmt: &StmtIf) {
    if let Some(bool_op) = stmt.test.as_bool_op_expr() {
        let expressions = count_bools(bool_op);
        if expressions > checker.settings().pylint.max_bool_expr {
            checker.report_diagnostic(
                TooManyBooleanExpressions {
                    expressions,
                    max_expressions: checker.settings().pylint.max_bool_expr,
                },
                bool_op.range(),
            );
        }
    }

    for elif in &stmt.elif_else_clauses {
        if let Some(bool_op) = elif.test.as_ref().and_then(Expr::as_bool_op_expr) {
            let expressions = count_bools(bool_op);
            if expressions > checker.settings().pylint.max_bool_expr {
                checker.report_diagnostic(
                    TooManyBooleanExpressions {
                        expressions,
                        max_expressions: checker.settings().pylint.max_bool_expr,
                    },
                    bool_op.range(),
                );
            }
        }
    }
}

/// Count the number of Boolean expressions in a `bool_op` expression.
fn count_bools(bool_op: &ast::ExprBoolOp) -> usize {
    bool_op
        .values
        .iter()
        .map(|expr| {
            if let Expr::BoolOp(bool_op) = expr {
                count_bools(bool_op)
            } else {
                1
            }
        })
        .sum::<usize>()
}