mirrors/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-09-26 20:10:09 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

refactor: Merge Settings.enabled and Settings.fixable

Browse source 
The Settings struct previously contained the fields:

     pub enabled: HashableHashSet<RuleCode>,
     pub fixable: HashableHashSet<RuleCode>,

This commit merges both fields into one by introducing a new
RuleTable type, wrapping HashableHashMap<RuleCode, bool>,
which has the following benefits:

1. It makes the invalid state that a rule is
   disabled but fixable unrepresentable.

2. It encapsulates the implementation details of the table.
   (It currently uses an FxHashMap but that may change.)

3. It results in more readable code.

       settings.rules.enabled(rule)
       settings.rules.should_fix(rule)

   is more readable than:

       settings.enabled.contains(rule)
       settings.fixable.contains(rule)
This commit is contained in:
Martin Fischer 2023-01-17 10:02:25 +01:00 • committed by Charlie Marsh
parent 580da1fa6b
commit a6566b1b34
30 changed files with 758 additions and 685 deletions
Download patch file Download diff file Expand all files Collapse all files

2
ruff_cli/src/commands.rs
View file

@ -114,7 +114,7 @@ pub fn run(
.unwrap_or_else(|(path, message)| { .unwrap_or_else(|(path, message)| {
if let Some(path) = &path { if let Some(path) = &path {
let settings = resolver.resolve(path, pyproject_strategy); let settings = resolver.resolve(path, pyproject_strategy);
if settings.enabled.contains(&RuleCode::E902) { if settings.rules.enabled(&RuleCode::E902) {
Diagnostics::new(vec![Message { Diagnostics::new(vec![Message {
kind: IOError(message).into(), kind: IOError(message).into(),
location: Location::default(), location: Location::default(),

890
src/checkers/ast.rs
View file

File diff suppressed because it is too large Load diff

4
src/checkers/imports.rs
View file

@ -36,7 +36,7 @@ pub fn check_imports(
// Enforce import rules. // Enforce import rules.
let mut diagnostics = vec![]; let mut diagnostics = vec![];
if settings.enabled.contains(&RuleCode::I001) { if settings.rules.enabled(&RuleCode::I001) {
for block in &blocks { for block in &blocks {
if !block.imports.is_empty() { if !block.imports.is_empty() {
if let Some(diagnostic) = isort::rules::organize_imports( if let Some(diagnostic) = isort::rules::organize_imports(
@ -47,7 +47,7 @@ pub fn check_imports(
} }
} }
} }
if settings.enabled.contains(&RuleCode::I002) { if settings.rules.enabled(&RuleCode::I002) {
diagnostics.extend(isort::rules::add_required_imports( diagnostics.extend(isort::rules::add_required_imports(
&blocks, python_ast, locator, settings, autofix, &blocks, python_ast, locator, settings, autofix,
)); ));

16
src/checkers/lines.rs
View file

@ -17,12 +17,12 @@ pub fn check_lines(
) -> Vec<Diagnostic> { ) -> Vec<Diagnostic> {
let mut diagnostics: Vec<Diagnostic> = vec![]; let mut diagnostics: Vec<Diagnostic> = vec![];
let enforce_blanket_noqa = settings.enabled.contains(&RuleCode::PGH004); let enforce_blanket_noqa = settings.rules.enabled(&RuleCode::PGH004);
let enforce_blanket_type_ignore = settings.enabled.contains(&RuleCode::PGH003); let enforce_blanket_type_ignore = settings.rules.enabled(&RuleCode::PGH003);
let enforce_doc_line_too_long = settings.enabled.contains(&RuleCode::W505); let enforce_doc_line_too_long = settings.rules.enabled(&RuleCode::W505);
let enforce_line_too_long = settings.enabled.contains(&RuleCode::E501); let enforce_line_too_long = settings.rules.enabled(&RuleCode::E501);
let enforce_no_newline_at_end_of_file = settings.enabled.contains(&RuleCode::W292); let enforce_no_newline_at_end_of_file = settings.rules.enabled(&RuleCode::W292);
let enforce_unnecessary_coding_comment = settings.enabled.contains(&RuleCode::UP009); let enforce_unnecessary_coding_comment = settings.rules.enabled(&RuleCode::UP009);
let mut commented_lines_iter = commented_lines.iter().peekable(); let mut commented_lines_iter = commented_lines.iter().peekable();
let mut doc_lines_iter = doc_lines.iter().peekable(); let mut doc_lines_iter = doc_lines.iter().peekable();
@ -37,7 +37,7 @@ pub fn check_lines(
index, index,
line, line,
matches!(autofix, flags::Autofix::Enabled) matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(&RuleCode::UP009), && settings.rules.should_fix(&RuleCode::UP009),
) { ) {
diagnostics.push(diagnostic); diagnostics.push(diagnostic);
} }
@ -79,7 +79,7 @@ pub fn check_lines(
if let Some(diagnostic) = no_newline_at_end_of_file( if let Some(diagnostic) = no_newline_at_end_of_file(
contents, contents,
matches!(autofix, flags::Autofix::Enabled) matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(&RuleCode::W292), && settings.rules.should_fix(&RuleCode::W292),
) { ) {
diagnostics.push(diagnostic); diagnostics.push(diagnostic);
} }

8
src/checkers/noqa.rs
View file

@ -24,7 +24,7 @@ pub fn check_noqa(
let mut noqa_directives: IntMap<usize, (Directive, Vec<&str>)> = IntMap::default(); let mut noqa_directives: IntMap<usize, (Directive, Vec<&str>)> = IntMap::default();
let mut ignored = vec![]; let mut ignored = vec![];
let enforce_noqa = settings.enabled.contains(&RuleCode::RUF100); let enforce_noqa = settings.rules.enabled(&RuleCode::RUF100);
let lines: Vec<&str> = contents.lines().collect(); let lines: Vec<&str> = contents.lines().collect();
for lineno in commented_lines { for lineno in commented_lines {
@ -108,7 +108,7 @@ pub fn check_noqa(
Range::new(Location::new(row + 1, start), Location::new(row + 1, end)), Range::new(Location::new(row + 1, start), Location::new(row + 1, end)),
); );
if matches!(autofix, flags::Autofix::Enabled) if matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(diagnostic.kind.code()) && settings.rules.should_fix(diagnostic.kind.code())
{ {
diagnostic.amend(Fix::deletion( diagnostic.amend(Fix::deletion(
Location::new(row + 1, start - spaces), Location::new(row + 1, start - spaces),
@ -135,7 +135,7 @@ pub fn check_noqa(
valid_codes.push(code); valid_codes.push(code);
} else { } else {
if let Ok(rule_code) = RuleCode::from_str(code) { if let Ok(rule_code) = RuleCode::from_str(code) {
if settings.enabled.contains(&rule_code) { if settings.rules.enabled(&rule_code) {
unmatched_codes.push(code); unmatched_codes.push(code);
} else { } else {
disabled_codes.push(code); disabled_codes.push(code);
@ -172,7 +172,7 @@ pub fn check_noqa(
Range::new(Location::new(row + 1, start), Location::new(row + 1, end)), Range::new(Location::new(row + 1, start), Location::new(row + 1, end)),
); );
if matches!(autofix, flags::Autofix::Enabled) if matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(diagnostic.kind.code()) && settings.rules.should_fix(diagnostic.kind.code())
{ {
if valid_codes.is_empty() { if valid_codes.is_empty() {
diagnostic.amend(Fix::deletion( diagnostic.amend(Fix::deletion(

36
src/checkers/tokens.rs
View file

@ -19,20 +19,20 @@ pub fn check_tokens(
) -> Vec<Diagnostic> { ) -> Vec<Diagnostic> {
let mut diagnostics: Vec<Diagnostic> = vec![]; let mut diagnostics: Vec<Diagnostic> = vec![];
let enforce_ambiguous_unicode_character = settings.enabled.contains(&RuleCode::RUF001) let enforce_ambiguous_unicode_character = settings.rules.enabled(&RuleCode::RUF001)
|| settings.enabled.contains(&RuleCode::RUF002) || settings.rules.enabled(&RuleCode::RUF002)
|| settings.enabled.contains(&RuleCode::RUF003); || settings.rules.enabled(&RuleCode::RUF003);
let enforce_quotes = settings.enabled.contains(&RuleCode::Q000) let enforce_quotes = settings.rules.enabled(&RuleCode::Q000)
|| settings.enabled.contains(&RuleCode::Q001) || settings.rules.enabled(&RuleCode::Q001)
|| settings.enabled.contains(&RuleCode::Q002) || settings.rules.enabled(&RuleCode::Q002)
|| settings.enabled.contains(&RuleCode::Q003); || settings.rules.enabled(&RuleCode::Q003);
let enforce_commented_out_code = settings.enabled.contains(&RuleCode::ERA001); let enforce_commented_out_code = settings.rules.enabled(&RuleCode::ERA001);
let enforce_invalid_escape_sequence = settings.enabled.contains(&RuleCode::W605); let enforce_invalid_escape_sequence = settings.rules.enabled(&RuleCode::W605);
let enforce_implicit_string_concatenation = settings.enabled.contains(&RuleCode::ISC001) let enforce_implicit_string_concatenation =
|| settings.enabled.contains(&RuleCode::ISC002); settings.rules.enabled(&RuleCode::ISC001) || settings.rules.enabled(&RuleCode::ISC002);
let enforce_trailing_comma = settings.enabled.contains(&RuleCode::COM812) let enforce_trailing_comma = settings.rules.enabled(&RuleCode::COM812)
|| settings.enabled.contains(&RuleCode::COM818) || settings.rules.enabled(&RuleCode::COM818)
|| settings.enabled.contains(&RuleCode::COM819); || settings.rules.enabled(&RuleCode::COM819);
let mut state_machine = StateMachine::default(); let mut state_machine = StateMachine::default();
for &(start, ref tok, end) in tokens.iter().flatten() { for &(start, ref tok, end) in tokens.iter().flatten() {
@ -75,7 +75,7 @@ pub fn check_tokens(
settings, settings,
autofix, autofix,
) { ) {
if settings.enabled.contains(diagnostic.kind.code()) { if settings.rules.enabled(diagnostic.kind.code()) {
diagnostics.push(diagnostic); diagnostics.push(diagnostic);
} }
} }
@ -101,7 +101,7 @@ pub fn check_tokens(
start, start,
end, end,
matches!(autofix, flags::Autofix::Enabled) matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(&RuleCode::W605), && settings.rules.should_fix(&RuleCode::W605),
)); ));
} }
} }
@ -112,7 +112,7 @@ pub fn check_tokens(
diagnostics.extend( diagnostics.extend(
flake8_implicit_str_concat::rules::implicit(tokens) flake8_implicit_str_concat::rules::implicit(tokens)
.into_iter() .into_iter()
.filter(|diagnostic| settings.enabled.contains(diagnostic.kind.code())), .filter(|diagnostic| settings.rules.enabled(diagnostic.kind.code())),
); );
} }
@ -121,7 +121,7 @@ pub fn check_tokens(
diagnostics.extend( diagnostics.extend(
flake8_commas::rules::trailing_commas(tokens, locator) flake8_commas::rules::trailing_commas(tokens, locator)
.into_iter() .into_iter()
.filter(|diagnostic| settings.enabled.contains(diagnostic.kind.code())), .filter(|diagnostic| settings.rules.enabled(diagnostic.kind.code())),
); );
} }

4
src/directives.rs
View file

@ -18,8 +18,8 @@ bitflags! {
impl Flags { impl Flags {
pub fn from_settings(settings: &Settings) -> Self { pub fn from_settings(settings: &Settings) -> Self {
if settings if settings
.enabled .rules
.iter() .iter_enabled()
.any(|rule_code| matches!(rule_code.lint_source(), LintSource::Imports)) .any(|rule_code| matches!(rule_code.lint_source(), LintSource::Imports))
{ {
Flags::NOQA | Flags::ISORT Flags::NOQA | Flags::ISORT

24
src/linter.rs
View file

@ -47,7 +47,7 @@ pub fn check_path(
// Collect doc lines. This requires a rare mix of tokens (for comments) and AST // Collect doc lines. This requires a rare mix of tokens (for comments) and AST
// (for docstrings), which demands special-casing at this level. // (for docstrings), which demands special-casing at this level.
let use_doc_lines = settings.enabled.contains(&RuleCode::W505); let use_doc_lines = settings.rules.enabled(&RuleCode::W505);
let mut doc_lines = vec![]; let mut doc_lines = vec![];
if use_doc_lines { if use_doc_lines {
doc_lines.extend(doc_lines_from_tokens(&tokens)); doc_lines.extend(doc_lines_from_tokens(&tokens));
@ -55,8 +55,8 @@ pub fn check_path(
// Run the token-based rules. // Run the token-based rules.
if settings if settings
.enabled .rules
.iter() .iter_enabled()
.any(|rule_code| matches!(rule_code.lint_source(), LintSource::Tokens)) .any(|rule_code| matches!(rule_code.lint_source(), LintSource::Tokens))
{ {
diagnostics.extend(check_tokens(locator, &tokens, settings, autofix)); diagnostics.extend(check_tokens(locator, &tokens, settings, autofix));
@ -64,13 +64,13 @@ pub fn check_path(
// Run the AST-based rules. // Run the AST-based rules.
let use_ast = settings let use_ast = settings
.enabled .rules
.iter() .iter_enabled()
.any(|rule_code| matches!(rule_code.lint_source(), LintSource::Ast)); .any(|rule_code| matches!(rule_code.lint_source(), LintSource::Ast));
let use_imports = !directives.isort.skip_file let use_imports = !directives.isort.skip_file
&& settings && settings
.enabled .rules
.iter() .iter_enabled()
.any(|rule_code| matches!(rule_code.lint_source(), LintSource::Imports)); .any(|rule_code| matches!(rule_code.lint_source(), LintSource::Imports));
if use_ast || use_imports || use_doc_lines { if use_ast || use_imports || use_doc_lines {
match rustpython_helpers::parse_program_tokens(tokens, "<filename>") { match rustpython_helpers::parse_program_tokens(tokens, "<filename>") {
@ -106,7 +106,7 @@ pub fn check_path(
} }
} }
Err(parse_error) => { Err(parse_error) => {
if settings.enabled.contains(&RuleCode::E999) { if settings.rules.enabled(&RuleCode::E999) {
diagnostics.push(Diagnostic::new( diagnostics.push(Diagnostic::new(
violations::SyntaxError(parse_error.error.to_string()), violations::SyntaxError(parse_error.error.to_string()),
Range::new(parse_error.location, parse_error.location), Range::new(parse_error.location, parse_error.location),
@ -124,8 +124,8 @@ pub fn check_path(
// Run the lines-based rules. // Run the lines-based rules.
if settings if settings
.enabled .rules
.iter() .iter_enabled()
.any(|rule_code| matches!(rule_code.lint_source(), LintSource::Lines)) .any(|rule_code| matches!(rule_code.lint_source(), LintSource::Lines))
{ {
diagnostics.extend(check_lines( diagnostics.extend(check_lines(
@ -140,8 +140,8 @@ pub fn check_path(
// Enforce `noqa` directives. // Enforce `noqa` directives.
if (matches!(noqa, flags::Noqa::Enabled) && !diagnostics.is_empty()) if (matches!(noqa, flags::Noqa::Enabled) && !diagnostics.is_empty())
|| settings || settings
.enabled .rules
.iter() .iter_enabled()
.any(|rule_code| matches!(rule_code.lint_source(), LintSource::NoQa)) .any(|rule_code| matches!(rule_code.lint_source(), LintSource::NoQa))
{ {
check_noqa( check_noqa(

2
src/rules/eradicate/rules.rs
View file

@ -35,7 +35,7 @@ pub fn commented_out_code(
if is_standalone_comment(&line) && comment_contains_code(&line, &settings.task_tags[..]) { if is_standalone_comment(&line) && comment_contains_code(&line, &settings.task_tags[..]) {
let mut diagnostic = Diagnostic::new(violations::CommentedOutCode, Range::new(start, end)); let mut diagnostic = Diagnostic::new(violations::CommentedOutCode, Range::new(start, end));
if matches!(autofix, flags::Autofix::Enabled) if matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(&RuleCode::ERA001) && settings.rules.should_fix(&RuleCode::ERA001)
{ {
diagnostic.amend(Fix::deletion(location, end_location)); diagnostic.amend(Fix::deletion(location, end_location));
} }

20
src/rules/flake8_2020/rules.rs
View file

@ -27,14 +27,13 @@ pub fn subscript(checker: &mut Checker, value: &Expr, slice: &Expr) {
.. ..
} = &upper.node } = &upper.node
{ {
if *i == BigInt::from(1) && checker.settings.enabled.contains(&RuleCode::YTT303) if *i == BigInt::from(1) && checker.settings.rules.enabled(&RuleCode::YTT303) {
{
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SysVersionSlice1Referenced, violations::SysVersionSlice1Referenced,
Range::from_located(value), Range::from_located(value),
)); ));
} else if *i == BigInt::from(3) } else if *i == BigInt::from(3)
&& checker.settings.enabled.contains(&RuleCode::YTT101) && checker.settings.rules.enabled(&RuleCode::YTT101)
{ {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SysVersionSlice3Referenced, violations::SysVersionSlice3Referenced,
@ -48,13 +47,12 @@ pub fn subscript(checker: &mut Checker, value: &Expr, slice: &Expr) {
value: Constant::Int(i), value: Constant::Int(i),
.. ..
} => { } => {
if *i == BigInt::from(2) && checker.settings.enabled.contains(&RuleCode::YTT102) { if *i == BigInt::from(2) && checker.settings.rules.enabled(&RuleCode::YTT102) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SysVersion2Referenced, violations::SysVersion2Referenced,
Range::from_located(value), Range::from_located(value),
)); ));
} else if *i == BigInt::from(0) } else if *i == BigInt::from(0) && checker.settings.rules.enabled(&RuleCode::YTT301)
&& checker.settings.enabled.contains(&RuleCode::YTT301)
{ {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SysVersion0Referenced, violations::SysVersion0Referenced,
@ -91,7 +89,7 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
) = (ops, comparators) ) = (ops, comparators)
{ {
if *n == BigInt::from(3) if *n == BigInt::from(3)
&& checker.settings.enabled.contains(&RuleCode::YTT201) && checker.settings.rules.enabled(&RuleCode::YTT201)
{ {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SysVersionInfo0Eq3Referenced, violations::SysVersionInfo0Eq3Referenced,
@ -112,7 +110,7 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
}], }],
) = (ops, comparators) ) = (ops, comparators)
{ {
if checker.settings.enabled.contains(&RuleCode::YTT203) { if checker.settings.rules.enabled(&RuleCode::YTT203) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SysVersionInfo1CmpInt, violations::SysVersionInfo1CmpInt,
Range::from_located(left), Range::from_located(left),
@ -138,7 +136,7 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
}], }],
) = (ops, comparators) ) = (ops, comparators)
{ {
if checker.settings.enabled.contains(&RuleCode::YTT204) { if checker.settings.rules.enabled(&RuleCode::YTT204) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SysVersionInfoMinorCmpInt, violations::SysVersionInfoMinorCmpInt,
Range::from_located(left), Range::from_located(left),
@ -164,13 +162,13 @@ pub fn compare(checker: &mut Checker, left: &Expr, ops: &[Cmpop], comparators: &
) = (ops, comparators) ) = (ops, comparators)
{ {
if s.len() == 1 { if s.len() == 1 {
if checker.settings.enabled.contains(&RuleCode::YTT302) { if checker.settings.rules.enabled(&RuleCode::YTT302) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SysVersionCmpStr10, violations::SysVersionCmpStr10,
Range::from_located(left), Range::from_located(left),
)); ));
} }
} else if checker.settings.enabled.contains(&RuleCode::YTT103) { } else if checker.settings.rules.enabled(&RuleCode::YTT103) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SysVersionCmpStr3, violations::SysVersionCmpStr3,
Range::from_located(left), Range::from_located(left),

48
src/rules/flake8_annotations/rules.rs
View file

@ -85,14 +85,14 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
.chain(args.kwonlyargs.iter()) .chain(args.kwonlyargs.iter())
{ {
if let Some(expr) = &arg.node.annotation { if let Some(expr) = &arg.node.annotation {
if checker.settings.enabled.contains(&RuleCode::ANN401) { if checker.settings.rules.enabled(&RuleCode::ANN401) {
check_dynamically_typed(checker, expr, || arg.node.arg.to_string()); check_dynamically_typed(checker, expr, || arg.node.arg.to_string());
}; };
} else { } else {
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&RuleCode::ANN001) { if checker.settings.rules.enabled(&RuleCode::ANN001) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeFunctionArgument(arg.node.arg.to_string()), violations::MissingTypeFunctionArgument(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -106,7 +106,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if let Some(arg) = &args.vararg { if let Some(arg) = &args.vararg {
if let Some(expr) = &arg.node.annotation { if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any { if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&RuleCode::ANN401) { if checker.settings.rules.enabled(&RuleCode::ANN401) {
let name = arg.node.arg.to_string(); let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("*{name}")); check_dynamically_typed(checker, expr, || format!("*{name}"));
} }
@ -115,7 +115,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&RuleCode::ANN002) { if checker.settings.rules.enabled(&RuleCode::ANN002) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeArgs(arg.node.arg.to_string()), violations::MissingTypeArgs(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -129,7 +129,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if let Some(arg) = &args.kwarg { if let Some(arg) = &args.kwarg {
if let Some(expr) = &arg.node.annotation { if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any { if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&RuleCode::ANN401) { if checker.settings.rules.enabled(&RuleCode::ANN401) {
let name = arg.node.arg.to_string(); let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("**{name}")); check_dynamically_typed(checker, expr, || format!("**{name}"));
} }
@ -138,7 +138,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&RuleCode::ANN003) { if checker.settings.rules.enabled(&RuleCode::ANN003) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeKwargs(arg.node.arg.to_string()), violations::MissingTypeKwargs(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -150,7 +150,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
// ANN201, ANN202, ANN401 // ANN201, ANN202, ANN401
if let Some(expr) = &returns { if let Some(expr) = &returns {
if checker.settings.enabled.contains(&RuleCode::ANN401) { if checker.settings.rules.enabled(&RuleCode::ANN401) {
check_dynamically_typed(checker, expr, || name.to_string()); check_dynamically_typed(checker, expr, || name.to_string());
}; };
} else { } else {
@ -164,7 +164,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
match visibility { match visibility {
Visibility::Public => { Visibility::Public => {
if checker.settings.enabled.contains(&RuleCode::ANN201) { if checker.settings.rules.enabled(&RuleCode::ANN201) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypePublicFunction(name.to_string()), violations::MissingReturnTypePublicFunction(name.to_string()),
helpers::identifier_range(stmt, checker.locator), helpers::identifier_range(stmt, checker.locator),
@ -172,7 +172,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} }
} }
Visibility::Private => { Visibility::Private => {
if checker.settings.enabled.contains(&RuleCode::ANN202) { if checker.settings.rules.enabled(&RuleCode::ANN202) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypePrivateFunction(name.to_string()), violations::MissingReturnTypePrivateFunction(name.to_string()),
helpers::identifier_range(stmt, checker.locator), helpers::identifier_range(stmt, checker.locator),
@ -203,14 +203,14 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
// ANN401 for dynamically typed arguments // ANN401 for dynamically typed arguments
if let Some(annotation) = &arg.node.annotation { if let Some(annotation) = &arg.node.annotation {
has_any_typed_arg = true; has_any_typed_arg = true;
if checker.settings.enabled.contains(&RuleCode::ANN401) { if checker.settings.rules.enabled(&RuleCode::ANN401) {
check_dynamically_typed(checker, annotation, || arg.node.arg.to_string()); check_dynamically_typed(checker, annotation, || arg.node.arg.to_string());
} }
} else { } else {
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&RuleCode::ANN001) { if checker.settings.rules.enabled(&RuleCode::ANN001) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeFunctionArgument(arg.node.arg.to_string()), violations::MissingTypeFunctionArgument(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -225,7 +225,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
has_any_typed_arg = true; has_any_typed_arg = true;
if let Some(expr) = &arg.node.annotation { if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any { if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&RuleCode::ANN401) { if checker.settings.rules.enabled(&RuleCode::ANN401) {
let name = arg.node.arg.to_string(); let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("*{name}")); check_dynamically_typed(checker, expr, || format!("*{name}"));
} }
@ -234,7 +234,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&RuleCode::ANN002) { if checker.settings.rules.enabled(&RuleCode::ANN002) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeArgs(arg.node.arg.to_string()), violations::MissingTypeArgs(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -249,7 +249,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
has_any_typed_arg = true; has_any_typed_arg = true;
if let Some(expr) = &arg.node.annotation { if let Some(expr) = &arg.node.annotation {
if !checker.settings.flake8_annotations.allow_star_arg_any { if !checker.settings.flake8_annotations.allow_star_arg_any {
if checker.settings.enabled.contains(&RuleCode::ANN401) { if checker.settings.rules.enabled(&RuleCode::ANN401) {
let name = arg.node.arg.to_string(); let name = arg.node.arg.to_string();
check_dynamically_typed(checker, expr, || format!("**{name}")); check_dynamically_typed(checker, expr, || format!("**{name}"));
} }
@ -258,7 +258,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if !(checker.settings.flake8_annotations.suppress_dummy_args if !(checker.settings.flake8_annotations.suppress_dummy_args
&& checker.settings.dummy_variable_rgx.is_match(&arg.node.arg)) && checker.settings.dummy_variable_rgx.is_match(&arg.node.arg))
{ {
if checker.settings.enabled.contains(&RuleCode::ANN003) { if checker.settings.rules.enabled(&RuleCode::ANN003) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeKwargs(arg.node.arg.to_string()), violations::MissingTypeKwargs(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -273,14 +273,14 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
if let Some(arg) = args.args.first() { if let Some(arg) = args.args.first() {
if arg.node.annotation.is_none() { if arg.node.annotation.is_none() {
if visibility::is_classmethod(checker, cast::decorator_list(stmt)) { if visibility::is_classmethod(checker, cast::decorator_list(stmt)) {
if checker.settings.enabled.contains(&RuleCode::ANN102) { if checker.settings.rules.enabled(&RuleCode::ANN102) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeCls(arg.node.arg.to_string()), violations::MissingTypeCls(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
)); ));
} }
} else { } else {
if checker.settings.enabled.contains(&RuleCode::ANN101) { if checker.settings.rules.enabled(&RuleCode::ANN101) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingTypeSelf(arg.node.arg.to_string()), violations::MissingTypeSelf(arg.node.arg.to_string()),
Range::from_located(arg), Range::from_located(arg),
@ -293,7 +293,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
// ANN201, ANN202 // ANN201, ANN202
if let Some(expr) = &returns { if let Some(expr) = &returns {
if checker.settings.enabled.contains(&RuleCode::ANN401) { if checker.settings.rules.enabled(&RuleCode::ANN401) {
check_dynamically_typed(checker, expr, || name.to_string()); check_dynamically_typed(checker, expr, || name.to_string());
} }
} else { } else {
@ -306,14 +306,14 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} }
if visibility::is_classmethod(checker, cast::decorator_list(stmt)) { if visibility::is_classmethod(checker, cast::decorator_list(stmt)) {
if checker.settings.enabled.contains(&RuleCode::ANN206) { if checker.settings.rules.enabled(&RuleCode::ANN206) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypeClassMethod(name.to_string()), violations::MissingReturnTypeClassMethod(name.to_string()),
helpers::identifier_range(stmt, checker.locator), helpers::identifier_range(stmt, checker.locator),
)); ));
} }
} else if visibility::is_staticmethod(checker, cast::decorator_list(stmt)) { } else if visibility::is_staticmethod(checker, cast::decorator_list(stmt)) {
if checker.settings.enabled.contains(&RuleCode::ANN205) { if checker.settings.rules.enabled(&RuleCode::ANN205) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypeStaticMethod(name.to_string()), violations::MissingReturnTypeStaticMethod(name.to_string()),
helpers::identifier_range(stmt, checker.locator), helpers::identifier_range(stmt, checker.locator),
@ -322,7 +322,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} else if visibility::is_init(cast::name(stmt)) { } else if visibility::is_init(cast::name(stmt)) {
// Allow omission of return annotation in `__init__` functions, as long as at // Allow omission of return annotation in `__init__` functions, as long as at
// least one argument is typed. // least one argument is typed.
if checker.settings.enabled.contains(&RuleCode::ANN204) { if checker.settings.rules.enabled(&RuleCode::ANN204) {
if !(checker.settings.flake8_annotations.mypy_init_return if !(checker.settings.flake8_annotations.mypy_init_return
&& has_any_typed_arg) && has_any_typed_arg)
{ {
@ -342,7 +342,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} }
} }
} else if visibility::is_magic(cast::name(stmt)) { } else if visibility::is_magic(cast::name(stmt)) {
if checker.settings.enabled.contains(&RuleCode::ANN204) { if checker.settings.rules.enabled(&RuleCode::ANN204) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypeSpecialMethod(name.to_string()), violations::MissingReturnTypeSpecialMethod(name.to_string()),
helpers::identifier_range(stmt, checker.locator), helpers::identifier_range(stmt, checker.locator),
@ -351,7 +351,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} else { } else {
match visibility { match visibility {
Visibility::Public => { Visibility::Public => {
if checker.settings.enabled.contains(&RuleCode::ANN201) { if checker.settings.rules.enabled(&RuleCode::ANN201) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypePublicFunction(name.to_string()), violations::MissingReturnTypePublicFunction(name.to_string()),
helpers::identifier_range(stmt, checker.locator), helpers::identifier_range(stmt, checker.locator),
@ -359,7 +359,7 @@ pub fn definition(checker: &mut Checker, definition: &Definition, visibility: &V
} }
} }
Visibility::Private => { Visibility::Private => {
if checker.settings.enabled.contains(&RuleCode::ANN202) { if checker.settings.rules.enabled(&RuleCode::ANN202) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MissingReturnTypePrivateFunction(name.to_string()), violations::MissingReturnTypePrivateFunction(name.to_string()),
helpers::identifier_range(stmt, checker.locator), helpers::identifier_range(stmt, checker.locator),

4
src/rules/flake8_bugbear/rules/abstract_base_class.rs
View file

@ -76,7 +76,7 @@ pub fn abstract_base_class(
let has_abstract_decorator = is_abstract(checker, decorator_list); let has_abstract_decorator = is_abstract(checker, decorator_list);
has_abstract_method |= has_abstract_decorator; has_abstract_method |= has_abstract_decorator;
if !checker.settings.enabled.contains(&RuleCode::B027) { if !checker.settings.rules.enabled(&RuleCode::B027) {
continue; continue;
} }
@ -87,7 +87,7 @@ pub fn abstract_base_class(
)); ));
} }
} }
if checker.settings.enabled.contains(&RuleCode::B024) { if checker.settings.rules.enabled(&RuleCode::B024) {
if !has_abstract_method { if !has_abstract_method {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::AbstractBaseClassWithoutAbstractMethod(name.to_string()), violations::AbstractBaseClassWithoutAbstractMethod(name.to_string()),

4
src/rules/flake8_bugbear/rules/duplicate_exceptions.rs
View file

@ -41,7 +41,7 @@ fn duplicate_handler_exceptions<'a>(
} }
} }
if checker.settings.enabled.contains(&RuleCode::B014) { if checker.settings.rules.enabled(&RuleCode::B014) {
// TODO(charlie): Handle "BaseException" and redundant exception aliases. // TODO(charlie): Handle "BaseException" and redundant exception aliases.
if !duplicates.is_empty() { if !duplicates.is_empty() {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
@ -105,7 +105,7 @@ pub fn duplicate_exceptions(checker: &mut Checker, handlers: &[Excepthandler]) {
} }
} }
if checker.settings.enabled.contains(&RuleCode::B025) { if checker.settings.rules.enabled(&RuleCode::B025) {
for (name, exprs) in duplicates { for (name, exprs) in duplicates {
for expr in exprs { for expr in exprs {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(

6
src/rules/flake8_errmsg/rules.rs
View file

@ -15,7 +15,7 @@ pub fn string_in_exception(checker: &mut Checker, exc: &Expr) {
value: Constant::Str(string), value: Constant::Str(string),
.. ..
} => { } => {
if checker.settings.enabled.contains(&RuleCode::EM101) { if checker.settings.rules.enabled(&RuleCode::EM101) {
if string.len() > checker.settings.flake8_errmsg.max_string_length { if string.len() > checker.settings.flake8_errmsg.max_string_length {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::RawStringInException, violations::RawStringInException,
@ -26,7 +26,7 @@ pub fn string_in_exception(checker: &mut Checker, exc: &Expr) {
} }
// Check for f-strings // Check for f-strings
ExprKind::JoinedStr { .. } => { ExprKind::JoinedStr { .. } => {
if checker.settings.enabled.contains(&RuleCode::EM102) { if checker.settings.rules.enabled(&RuleCode::EM102) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::FStringInException, violations::FStringInException,
Range::from_located(first), Range::from_located(first),
@ -35,7 +35,7 @@ pub fn string_in_exception(checker: &mut Checker, exc: &Expr) {
} }
// Check for .format() calls // Check for .format() calls
ExprKind::Call { func, .. } => { ExprKind::Call { func, .. } => {
if checker.settings.enabled.contains(&RuleCode::EM103) { if checker.settings.rules.enabled(&RuleCode::EM103) {
if let ExprKind::Attribute { value, attr, .. } = &func.node { if let ExprKind::Attribute { value, attr, .. } = &func.node {
if attr == "format" && matches!(value.node, ExprKind::Constant { .. }) { if attr == "format" && matches!(value.node, ExprKind::Constant { .. }) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(

2
src/rules/flake8_print/rules/print_call.rs
View file

@ -44,7 +44,7 @@ pub fn print_call(checker: &mut Checker, func: &Expr, keywords: &[Keyword]) {
} }
}; };
if !checker.settings.enabled.contains(diagnostic.kind.code()) { if !checker.settings.rules.enabled(diagnostic.kind.code()) {
return; return;
} }

40
src/rules/flake8_pytest_style/rules/fixture.rs
View file

@ -98,7 +98,7 @@ fn check_fixture_decorator(checker: &mut Checker, func_name: &str, decorator: &E
keywords, keywords,
.. ..
} => { } => {
if checker.settings.enabled.contains(&RuleCode::PT001) if checker.settings.rules.enabled(&RuleCode::PT001)
&& !checker.settings.flake8_pytest_style.fixture_parentheses && !checker.settings.flake8_pytest_style.fixture_parentheses
&& args.is_empty() && args.is_empty()
&& keywords.is_empty() && keywords.is_empty()
@ -111,14 +111,14 @@ fn check_fixture_decorator(checker: &mut Checker, func_name: &str, decorator: &E
pytest_fixture_parentheses(checker, decorator, fix, "", "()"); pytest_fixture_parentheses(checker, decorator, fix, "", "()");
} }
if checker.settings.enabled.contains(&RuleCode::PT002) && !args.is_empty() { if checker.settings.rules.enabled(&RuleCode::PT002) && !args.is_empty() {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::FixturePositionalArgs(func_name.to_string()), violations::FixturePositionalArgs(func_name.to_string()),
Range::from_located(decorator), Range::from_located(decorator),
)); ));
} }
if checker.settings.enabled.contains(&RuleCode::PT003) { if checker.settings.rules.enabled(&RuleCode::PT003) {
let scope_keyword = keywords let scope_keyword = keywords
.iter() .iter()
.find(|kw| kw.node.arg == Some("scope".to_string())); .find(|kw| kw.node.arg == Some("scope".to_string()));
@ -134,7 +134,7 @@ fn check_fixture_decorator(checker: &mut Checker, func_name: &str, decorator: &E
} }
} }
_ => { _ => {
if checker.settings.enabled.contains(&RuleCode::PT001) if checker.settings.rules.enabled(&RuleCode::PT001)
&& checker.settings.flake8_pytest_style.fixture_parentheses && checker.settings.flake8_pytest_style.fixture_parentheses
{ {
let fix = Fix::insertion("()".to_string(), decorator.end_location.unwrap()); let fix = Fix::insertion("()".to_string(), decorator.end_location.unwrap());
@ -152,7 +152,7 @@ fn check_fixture_returns(checker: &mut Checker, func: &Stmt, func_name: &str, bo
visitor.visit_stmt(stmt); visitor.visit_stmt(stmt);
} }
if checker.settings.enabled.contains(&RuleCode::PT005) if checker.settings.rules.enabled(&RuleCode::PT005)
&& visitor.has_return_with_value && visitor.has_return_with_value
&& func_name.starts_with('_') && func_name.starts_with('_')
{ {
@ -160,7 +160,7 @@ fn check_fixture_returns(checker: &mut Checker, func: &Stmt, func_name: &str, bo
violations::IncorrectFixtureNameUnderscore(func_name.to_string()), violations::IncorrectFixtureNameUnderscore(func_name.to_string()),
Range::from_located(func), Range::from_located(func),
)); ));
} else if checker.settings.enabled.contains(&RuleCode::PT004) } else if checker.settings.rules.enabled(&RuleCode::PT004)
&& !visitor.has_return_with_value && !visitor.has_return_with_value
&& !visitor.has_yield_from && !visitor.has_yield_from
&& !func_name.starts_with('_') && !func_name.starts_with('_')
@ -171,7 +171,7 @@ fn check_fixture_returns(checker: &mut Checker, func: &Stmt, func_name: &str, bo
)); ));
} }
if checker.settings.enabled.contains(&RuleCode::PT022) { if checker.settings.rules.enabled(&RuleCode::PT022) {
if let Some(stmt) = body.last() { if let Some(stmt) = body.last() {
if let StmtKind::Expr { value, .. } = &stmt.node { if let StmtKind::Expr { value, .. } = &stmt.node {
if let ExprKind::Yield { .. } = value.node { if let ExprKind::Yield { .. } = value.node {
@ -246,7 +246,7 @@ fn check_fixture_marks(checker: &mut Checker, decorators: &[Expr]) {
for mark in get_mark_decorators(decorators) { for mark in get_mark_decorators(decorators) {
let name = get_mark_name(mark); let name = get_mark_name(mark);
if checker.settings.enabled.contains(&RuleCode::PT024) { if checker.settings.rules.enabled(&RuleCode::PT024) {
if name == "asyncio" { if name == "asyncio" {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::UnnecessaryAsyncioMarkOnFixture, violations::UnnecessaryAsyncioMarkOnFixture,
@ -261,7 +261,7 @@ fn check_fixture_marks(checker: &mut Checker, decorators: &[Expr]) {
} }
} }
if checker.settings.enabled.contains(&RuleCode::PT025) { if checker.settings.rules.enabled(&RuleCode::PT025) {
if name == "usefixtures" { if name == "usefixtures" {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::ErroneousUseFixturesOnFixture, violations::ErroneousUseFixturesOnFixture,
@ -288,39 +288,39 @@ pub fn fixture(
) { ) {
let decorator = get_fixture_decorator(checker, decorators); let decorator = get_fixture_decorator(checker, decorators);
if let Some(decorator) = decorator { if let Some(decorator) = decorator {
if checker.settings.enabled.contains(&RuleCode::PT001) if checker.settings.rules.enabled(&RuleCode::PT001)
|| checker.settings.enabled.contains(&RuleCode::PT002) || checker.settings.rules.enabled(&RuleCode::PT002)
|| checker.settings.enabled.contains(&RuleCode::PT003) || checker.settings.rules.enabled(&RuleCode::PT003)
{ {
check_fixture_decorator(checker, func_name, decorator); check_fixture_decorator(checker, func_name, decorator);
} }
if checker.settings.enabled.contains(&RuleCode::PT020) if checker.settings.rules.enabled(&RuleCode::PT020)
&& checker.settings.flake8_pytest_style.fixture_parentheses && checker.settings.flake8_pytest_style.fixture_parentheses
{ {
check_fixture_decorator_name(checker, decorator); check_fixture_decorator_name(checker, decorator);
} }
if (checker.settings.enabled.contains(&RuleCode::PT004) if (checker.settings.rules.enabled(&RuleCode::PT004)
|| checker.settings.enabled.contains(&RuleCode::PT005) || checker.settings.rules.enabled(&RuleCode::PT005)
|| checker.settings.enabled.contains(&RuleCode::PT022)) || checker.settings.rules.enabled(&RuleCode::PT022))
&& !has_abstractmethod_decorator(decorators, checker) && !has_abstractmethod_decorator(decorators, checker)
{ {
check_fixture_returns(checker, func, func_name, body); check_fixture_returns(checker, func, func_name, body);
} }
if checker.settings.enabled.contains(&RuleCode::PT021) { if checker.settings.rules.enabled(&RuleCode::PT021) {
check_fixture_addfinalizer(checker, args, body); check_fixture_addfinalizer(checker, args, body);
} }
if checker.settings.enabled.contains(&RuleCode::PT024) if checker.settings.rules.enabled(&RuleCode::PT024)
|| checker.settings.enabled.contains(&RuleCode::PT025) || checker.settings.rules.enabled(&RuleCode::PT025)
{ {
check_fixture_marks(checker, decorators); check_fixture_marks(checker, decorators);
} }
} }
if checker.settings.enabled.contains(&RuleCode::PT019) && func_name.starts_with("test_") { if checker.settings.rules.enabled(&RuleCode::PT019) && func_name.starts_with("test_") {
check_test_function_args(checker, args); check_test_function_args(checker, args);
} }
} }

4
src/rules/flake8_pytest_style/rules/marks.rs
View file

@ -84,8 +84,8 @@ fn check_useless_usefixtures(checker: &mut Checker, decorator: &Expr) {
} }
pub fn marks(checker: &mut Checker, decorators: &[Expr]) { pub fn marks(checker: &mut Checker, decorators: &[Expr]) {
let enforce_parentheses = checker.settings.enabled.contains(&RuleCode::PT023); let enforce_parentheses = checker.settings.rules.enabled(&RuleCode::PT023);
let enforce_useless_usefixtures = checker.settings.enabled.contains(&RuleCode::PT026); let enforce_useless_usefixtures = checker.settings.rules.enabled(&RuleCode::PT026);
for mark in get_mark_decorators(decorators) { for mark in get_mark_decorators(decorators) {
if enforce_parentheses { if enforce_parentheses {

4
src/rules/flake8_pytest_style/rules/parametrize.rs
View file

@ -328,12 +328,12 @@ pub fn parametrize(checker: &mut Checker, decorators: &[Expr]) {
let decorator = get_parametrize_decorator(checker, decorators); let decorator = get_parametrize_decorator(checker, decorators);
if let Some(decorator) = decorator { if let Some(decorator) = decorator {
if let ExprKind::Call { args, .. } = &decorator.node { if let ExprKind::Call { args, .. } = &decorator.node {
if checker.settings.enabled.contains(&RuleCode::PT006) { if checker.settings.rules.enabled(&RuleCode::PT006) {
if let Some(arg) = args.get(0) { if let Some(arg) = args.get(0) {
check_names(checker, arg); check_names(checker, arg);
} }
} }
if checker.settings.enabled.contains(&RuleCode::PT007) { if checker.settings.rules.enabled(&RuleCode::PT007) {
if let Some(arg) = args.get(1) { if let Some(arg) = args.get(1) {
check_values(checker, arg); check_values(checker, arg);
} }

4
src/rules/flake8_pytest_style/rules/raises.rs
View file

@ -25,7 +25,7 @@ fn is_non_trivial_with_body(body: &[Stmt]) -> bool {
pub fn raises_call(checker: &mut Checker, func: &Expr, args: &[Expr], keywords: &[Keyword]) { pub fn raises_call(checker: &mut Checker, func: &Expr, args: &[Expr], keywords: &[Keyword]) {
if is_pytest_raises(checker, func) { if is_pytest_raises(checker, func) {
if checker.settings.enabled.contains(&RuleCode::PT010) { if checker.settings.rules.enabled(&RuleCode::PT010) {
if args.is_empty() && keywords.is_empty() { if args.is_empty() && keywords.is_empty() {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::RaisesWithoutException, violations::RaisesWithoutException,
@ -34,7 +34,7 @@ pub fn raises_call(checker: &mut Checker, func: &Expr, args: &[Expr], keywords:
} }
} }
if checker.settings.enabled.contains(&RuleCode::PT011) { if checker.settings.rules.enabled(&RuleCode::PT011) {
let match_keyword = keywords let match_keyword = keywords
.iter() .iter()
.find(|kw| kw.node.arg == Some("match".to_string())); .find(|kw| kw.node.arg == Some("match".to_string()));

8
src/rules/flake8_quotes/rules.rs
View file

@ -80,7 +80,7 @@ pub fn quotes(
violations::BadQuotesDocstring(quotes_settings.docstring_quotes.clone()), violations::BadQuotesDocstring(quotes_settings.docstring_quotes.clone()),
Range::new(start, end), Range::new(start, end),
); );
if matches!(autofix, flags::Autofix::Enabled) && settings.fixable.contains(&RuleCode::Q002) if matches!(autofix, flags::Autofix::Enabled) && settings.rules.should_fix(&RuleCode::Q002)
{ {
let quote_count = if is_multiline { 3 } else { 1 }; let quote_count = if is_multiline { 3 } else { 1 };
let string_contents = &raw_text[quote_count..raw_text.len() - quote_count]; let string_contents = &raw_text[quote_count..raw_text.len() - quote_count];
@ -110,7 +110,7 @@ pub fn quotes(
Range::new(start, end), Range::new(start, end),
); );
if matches!(autofix, flags::Autofix::Enabled) && settings.fixable.contains(&RuleCode::Q001) if matches!(autofix, flags::Autofix::Enabled) && settings.rules.should_fix(&RuleCode::Q001)
{ {
let string_contents = &raw_text[3..raw_text.len() - 3]; let string_contents = &raw_text[3..raw_text.len() - 3];
let quote = good_multiline(&quotes_settings.multiline_quotes); let quote = good_multiline(&quotes_settings.multiline_quotes);
@ -137,7 +137,7 @@ pub fn quotes(
let mut diagnostic = let mut diagnostic =
Diagnostic::new(violations::AvoidQuoteEscape, Range::new(start, end)); Diagnostic::new(violations::AvoidQuoteEscape, Range::new(start, end));
if matches!(autofix, flags::Autofix::Enabled) if matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(&RuleCode::Q003) && settings.rules.should_fix(&RuleCode::Q003)
{ {
let quote = bad_single(&quotes_settings.inline_quotes); let quote = bad_single(&quotes_settings.inline_quotes);
@ -193,7 +193,7 @@ pub fn quotes(
Range::new(start, end), Range::new(start, end),
); );
if matches!(autofix, flags::Autofix::Enabled) if matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(&RuleCode::Q000) && settings.rules.should_fix(&RuleCode::Q000)
{ {
let quote = good_single(&quotes_settings.inline_quotes); let quote = good_single(&quotes_settings.inline_quotes);
let mut fixed_contents = let mut fixed_contents =

24
src/rules/flake8_return/rules.rs
View file

@ -226,7 +226,7 @@ fn superfluous_else_node(checker: &mut Checker, stmt: &Stmt, branch: Branch) ->
}; };
for child in body { for child in body {
if matches!(child.node, StmtKind::Return { .. }) { if matches!(child.node, StmtKind::Return { .. }) {
if checker.settings.enabled.contains(&RuleCode::RET505) { if checker.settings.rules.enabled(&RuleCode::RET505) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SuperfluousElseReturn(branch), violations::SuperfluousElseReturn(branch),
elif_else_range(stmt, checker.locator) elif_else_range(stmt, checker.locator)
@ -236,7 +236,7 @@ fn superfluous_else_node(checker: &mut Checker, stmt: &Stmt, branch: Branch) ->
return true; return true;
} }
if matches!(child.node, StmtKind::Break) { if matches!(child.node, StmtKind::Break) {
if checker.settings.enabled.contains(&RuleCode::RET508) { if checker.settings.rules.enabled(&RuleCode::RET508) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SuperfluousElseBreak(branch), violations::SuperfluousElseBreak(branch),
elif_else_range(stmt, checker.locator) elif_else_range(stmt, checker.locator)
@ -246,7 +246,7 @@ fn superfluous_else_node(checker: &mut Checker, stmt: &Stmt, branch: Branch) ->
return true; return true;
} }
if matches!(child.node, StmtKind::Raise { .. }) { if matches!(child.node, StmtKind::Raise { .. }) {
if checker.settings.enabled.contains(&RuleCode::RET506) { if checker.settings.rules.enabled(&RuleCode::RET506) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SuperfluousElseRaise(branch), violations::SuperfluousElseRaise(branch),
elif_else_range(stmt, checker.locator) elif_else_range(stmt, checker.locator)
@ -256,7 +256,7 @@ fn superfluous_else_node(checker: &mut Checker, stmt: &Stmt, branch: Branch) ->
return true; return true;
} }
if matches!(child.node, StmtKind::Continue) { if matches!(child.node, StmtKind::Continue) {
if checker.settings.enabled.contains(&RuleCode::RET507) { if checker.settings.rules.enabled(&RuleCode::RET507) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::SuperfluousElseContinue(branch), violations::SuperfluousElseContinue(branch),
elif_else_range(stmt, checker.locator) elif_else_range(stmt, checker.locator)
@ -319,10 +319,10 @@ pub fn function(checker: &mut Checker, body: &[Stmt]) {
visitor.stack visitor.stack
}; };
if checker.settings.enabled.contains(&RuleCode::RET505) if checker.settings.rules.enabled(&RuleCode::RET505)
|| checker.settings.enabled.contains(&RuleCode::RET506) || checker.settings.rules.enabled(&RuleCode::RET506)
|| checker.settings.enabled.contains(&RuleCode::RET507) || checker.settings.rules.enabled(&RuleCode::RET507)
|| checker.settings.enabled.contains(&RuleCode::RET508) || checker.settings.rules.enabled(&RuleCode::RET508)
{ {
if superfluous_elif(checker, &stack) { if superfluous_elif(checker, &stack) {
return; return;
@ -338,20 +338,20 @@ pub fn function(checker: &mut Checker, body: &[Stmt]) {
} }
if !result_exists(&stack.returns) { if !result_exists(&stack.returns) {
if checker.settings.enabled.contains(&RuleCode::RET501) { if checker.settings.rules.enabled(&RuleCode::RET501) {
unnecessary_return_none(checker, &stack); unnecessary_return_none(checker, &stack);
} }
return; return;
} }
if checker.settings.enabled.contains(&RuleCode::RET502) { if checker.settings.rules.enabled(&RuleCode::RET502) {
implicit_return_value(checker, &stack); implicit_return_value(checker, &stack);
} }
if checker.settings.enabled.contains(&RuleCode::RET503) { if checker.settings.rules.enabled(&RuleCode::RET503) {
implicit_return(checker, last_stmt); implicit_return(checker, last_stmt);
} }
if checker.settings.enabled.contains(&RuleCode::RET504) { if checker.settings.rules.enabled(&RuleCode::RET504) {
for (_, expr) in &stack.returns { for (_, expr) in &stack.returns {
if let Some(expr) = expr { if let Some(expr) = expr {
unnecessary_assign(checker, &stack, expr); unnecessary_assign(checker, &stack, expr);

4
src/rules/flake8_simplify/rules/ast_for.rs
View file

@ -178,7 +178,7 @@ pub fn convert_for_loop_to_any_all(checker: &mut Checker, stmt: &Stmt, sibling:
Some(sibling) => return_values_for_siblings(stmt, sibling), Some(sibling) => return_values_for_siblings(stmt, sibling),
} { } {
if loop_info.return_value && !loop_info.next_return_value { if loop_info.return_value && !loop_info.next_return_value {
if checker.settings.enabled.contains(&RuleCode::SIM110) { if checker.settings.rules.enabled(&RuleCode::SIM110) {
let contents = return_stmt( let contents = return_stmt(
"any", "any",
loop_info.test, loop_info.test,
@ -211,7 +211,7 @@ pub fn convert_for_loop_to_any_all(checker: &mut Checker, stmt: &Stmt, sibling:
} }
if !loop_info.return_value && loop_info.next_return_value { if !loop_info.return_value && loop_info.next_return_value {
if checker.settings.enabled.contains(&RuleCode::SIM111) { if checker.settings.rules.enabled(&RuleCode::SIM111) {
// Invert the condition. // Invert the condition.
let test = { let test = {
if let ExprKind::UnaryOp { if let ExprKind::UnaryOp {

20
src/rules/flake8_unused_arguments/rules.rs
View file

@ -128,8 +128,8 @@ pub fn unused_arguments(
FunctionType::Function => { FunctionType::Function => {
if checker if checker
.settings .settings
.enabled .rules
.contains(Argumentable::Function.rule_code()) .enabled(Argumentable::Function.rule_code())
&& !visibility::is_overload(checker, decorator_list) && !visibility::is_overload(checker, decorator_list)
{ {
function( function(
@ -150,8 +150,8 @@ pub fn unused_arguments(
FunctionType::Method => { FunctionType::Method => {
if checker if checker
.settings .settings
.enabled .rules
.contains(Argumentable::Method.rule_code()) .enabled(Argumentable::Method.rule_code())
&& !helpers::is_empty(body) && !helpers::is_empty(body)
&& (!visibility::is_magic(name) && (!visibility::is_magic(name)
|| visibility::is_init(name) || visibility::is_init(name)
@ -179,8 +179,8 @@ pub fn unused_arguments(
FunctionType::ClassMethod => { FunctionType::ClassMethod => {
if checker if checker
.settings .settings
.enabled .rules
.contains(Argumentable::ClassMethod.rule_code()) .enabled(Argumentable::ClassMethod.rule_code())
&& !helpers::is_empty(body) && !helpers::is_empty(body)
&& (!visibility::is_magic(name) && (!visibility::is_magic(name)
|| visibility::is_init(name) || visibility::is_init(name)
@ -208,8 +208,8 @@ pub fn unused_arguments(
FunctionType::StaticMethod => { FunctionType::StaticMethod => {
if checker if checker
.settings .settings
.enabled .rules
.contains(Argumentable::StaticMethod.rule_code()) .enabled(Argumentable::StaticMethod.rule_code())
&& !helpers::is_empty(body) && !helpers::is_empty(body)
&& (!visibility::is_magic(name) && (!visibility::is_magic(name)
|| visibility::is_init(name) || visibility::is_init(name)
@ -239,8 +239,8 @@ pub fn unused_arguments(
ScopeKind::Lambda(Lambda { args, .. }) => { ScopeKind::Lambda(Lambda { args, .. }) => {
if checker if checker
.settings .settings
.enabled .rules
.contains(Argumentable::Lambda.rule_code()) .enabled(Argumentable::Lambda.rule_code())
{ {
function( function(
&Argumentable::Lambda, &Argumentable::Lambda,

2
src/rules/isort/rules/add_required_imports.rs
View file

@ -125,7 +125,7 @@ fn add_required_import(
violations::MissingRequiredImport(required_import.clone()), violations::MissingRequiredImport(required_import.clone()),
Range::new(Location::default(), Location::default()), Range::new(Location::default(), Location::default()),
); );
if matches!(autofix, flags::Autofix::Enabled) && settings.fixable.contains(&RuleCode::I002) { if matches!(autofix, flags::Autofix::Enabled) && settings.rules.should_fix(&RuleCode::I002) {
// Determine the location at which the import should be inserted. // Determine the location at which the import should be inserted.
let splice = helpers::find_splice_location(python_ast, locator); let splice = helpers::find_splice_location(python_ast, locator);

2
src/rules/isort/rules/organize_imports.rs
View file

@ -99,7 +99,7 @@ pub fn organize_imports(
} else { } else {
let mut diagnostic = Diagnostic::new(violations::UnsortedImports, range); let mut diagnostic = Diagnostic::new(violations::UnsortedImports, range);
if matches!(autofix, flags::Autofix::Enabled) if matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(diagnostic.kind.code()) && settings.rules.should_fix(diagnostic.kind.code())
{ {
diagnostic.amend(Fix::replacement( diagnostic.amend(Fix::replacement(
indent(&expected, indentation), indent(&expected, indentation),

82
src/rules/pydocstyle/rules.rs
View file

@ -34,7 +34,7 @@ pub fn not_missing(
match definition.kind { match definition.kind {
DefinitionKind::Module => { DefinitionKind::Module => {
if checker.settings.enabled.contains(&RuleCode::D100) { if checker.settings.rules.enabled(&RuleCode::D100) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::PublicModule, violations::PublicModule,
Range::new(Location::new(1, 0), Location::new(1, 0)), Range::new(Location::new(1, 0), Location::new(1, 0)),
@ -43,7 +43,7 @@ pub fn not_missing(
false false
} }
DefinitionKind::Package => { DefinitionKind::Package => {
if checker.settings.enabled.contains(&RuleCode::D104) { if checker.settings.rules.enabled(&RuleCode::D104) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::PublicPackage, violations::PublicPackage,
Range::new(Location::new(1, 0), Location::new(1, 0)), Range::new(Location::new(1, 0), Location::new(1, 0)),
@ -52,7 +52,7 @@ pub fn not_missing(
false false
} }
DefinitionKind::Class(stmt) => { DefinitionKind::Class(stmt) => {
if checker.settings.enabled.contains(&RuleCode::D101) { if checker.settings.rules.enabled(&RuleCode::D101) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::PublicClass, violations::PublicClass,
identifier_range(stmt, checker.locator), identifier_range(stmt, checker.locator),
@ -61,7 +61,7 @@ pub fn not_missing(
false false
} }
DefinitionKind::NestedClass(stmt) => { DefinitionKind::NestedClass(stmt) => {
if checker.settings.enabled.contains(&RuleCode::D106) { if checker.settings.rules.enabled(&RuleCode::D106) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::PublicNestedClass, violations::PublicNestedClass,
identifier_range(stmt, checker.locator), identifier_range(stmt, checker.locator),
@ -73,7 +73,7 @@ pub fn not_missing(
if is_overload(checker, cast::decorator_list(stmt)) { if is_overload(checker, cast::decorator_list(stmt)) {
true true
} else { } else {
if checker.settings.enabled.contains(&RuleCode::D103) { if checker.settings.rules.enabled(&RuleCode::D103) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::PublicFunction, violations::PublicFunction,
identifier_range(stmt, checker.locator), identifier_range(stmt, checker.locator),
@ -88,7 +88,7 @@ pub fn not_missing(
{ {
true true
} else if is_init(cast::name(stmt)) { } else if is_init(cast::name(stmt)) {
if checker.settings.enabled.contains(&RuleCode::D107) { if checker.settings.rules.enabled(&RuleCode::D107) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::PublicInit, violations::PublicInit,
identifier_range(stmt, checker.locator), identifier_range(stmt, checker.locator),
@ -96,7 +96,7 @@ pub fn not_missing(
} }
true true
} else if is_new(cast::name(stmt)) || is_call(cast::name(stmt)) { } else if is_new(cast::name(stmt)) || is_call(cast::name(stmt)) {
if checker.settings.enabled.contains(&RuleCode::D102) { if checker.settings.rules.enabled(&RuleCode::D102) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::PublicMethod, violations::PublicMethod,
identifier_range(stmt, checker.locator), identifier_range(stmt, checker.locator),
@ -104,7 +104,7 @@ pub fn not_missing(
} }
true true
} else if is_magic(cast::name(stmt)) { } else if is_magic(cast::name(stmt)) {
if checker.settings.enabled.contains(&RuleCode::D105) { if checker.settings.rules.enabled(&RuleCode::D105) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MagicMethod, violations::MagicMethod,
identifier_range(stmt, checker.locator), identifier_range(stmt, checker.locator),
@ -112,7 +112,7 @@ pub fn not_missing(
} }
true true
} else { } else {
if checker.settings.enabled.contains(&RuleCode::D102) { if checker.settings.rules.enabled(&RuleCode::D102) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::PublicMethod, violations::PublicMethod,
identifier_range(stmt, checker.locator), identifier_range(stmt, checker.locator),
@ -163,7 +163,7 @@ pub fn blank_before_after_function(checker: &mut Checker, docstring: &Docstring)
return; return;
}; };
if checker.settings.enabled.contains(&RuleCode::D201) { if checker.settings.rules.enabled(&RuleCode::D201) {
let (before, ..) = checker.locator.partition_source_code_at( let (before, ..) = checker.locator.partition_source_code_at(
&Range::from_located(parent), &Range::from_located(parent),
&Range::from_located(docstring.expr), &Range::from_located(docstring.expr),
@ -191,7 +191,7 @@ pub fn blank_before_after_function(checker: &mut Checker, docstring: &Docstring)
} }
} }
if checker.settings.enabled.contains(&RuleCode::D202) { if checker.settings.rules.enabled(&RuleCode::D202) {
let (_, _, after) = checker.locator.partition_source_code_at( let (_, _, after) = checker.locator.partition_source_code_at(
&Range::from_located(parent), &Range::from_located(parent),
&Range::from_located(docstring.expr), &Range::from_located(docstring.expr),
@ -242,8 +242,8 @@ pub fn blank_before_after_class(checker: &mut Checker, docstring: &Docstring) {
return; return;
}; };
if checker.settings.enabled.contains(&RuleCode::D203) if checker.settings.rules.enabled(&RuleCode::D203)
|| checker.settings.enabled.contains(&RuleCode::D211) || checker.settings.rules.enabled(&RuleCode::D211)
{ {
let (before, ..) = checker.locator.partition_source_code_at( let (before, ..) = checker.locator.partition_source_code_at(
&Range::from_located(parent), &Range::from_located(parent),
@ -256,7 +256,7 @@ pub fn blank_before_after_class(checker: &mut Checker, docstring: &Docstring) {
.skip(1) .skip(1)
.take_while(|line| line.trim().is_empty()) .take_while(|line| line.trim().is_empty())
.count(); .count();
if checker.settings.enabled.contains(&RuleCode::D211) { if checker.settings.rules.enabled(&RuleCode::D211) {
if blank_lines_before != 0 { if blank_lines_before != 0 {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::NoBlankLineBeforeClass(blank_lines_before), violations::NoBlankLineBeforeClass(blank_lines_before),
@ -272,7 +272,7 @@ pub fn blank_before_after_class(checker: &mut Checker, docstring: &Docstring) {
checker.diagnostics.push(diagnostic); checker.diagnostics.push(diagnostic);
} }
} }
if checker.settings.enabled.contains(&RuleCode::D203) { if checker.settings.rules.enabled(&RuleCode::D203) {
if blank_lines_before != 1 { if blank_lines_before != 1 {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::OneBlankLineBeforeClass(blank_lines_before), violations::OneBlankLineBeforeClass(blank_lines_before),
@ -291,7 +291,7 @@ pub fn blank_before_after_class(checker: &mut Checker, docstring: &Docstring) {
} }
} }
if checker.settings.enabled.contains(&RuleCode::D204) { if checker.settings.rules.enabled(&RuleCode::D204) {
let (_, _, after) = checker.locator.partition_source_code_at( let (_, _, after) = checker.locator.partition_source_code_at(
&Range::from_located(parent), &Range::from_located(parent),
&Range::from_located(docstring.expr), &Range::from_located(docstring.expr),
@ -409,7 +409,7 @@ pub fn indent(checker: &mut Checker, docstring: &Docstring) {
// yet. // yet.
has_seen_tab = has_seen_tab || line_indent.contains('\t'); has_seen_tab = has_seen_tab || line_indent.contains('\t');
if checker.settings.enabled.contains(&RuleCode::D207) { if checker.settings.rules.enabled(&RuleCode::D207) {
// We report under-indentation on every line. This isn't great, but enables // We report under-indentation on every line. This isn't great, but enables
// autofix. // autofix.
if (i == lines.len() - 1 || !is_blank) if (i == lines.len() - 1 || !is_blank)
@ -448,7 +448,7 @@ pub fn indent(checker: &mut Checker, docstring: &Docstring) {
} }
} }
if checker.settings.enabled.contains(&RuleCode::D206) { if checker.settings.rules.enabled(&RuleCode::D206) {
if has_seen_tab { if has_seen_tab {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::IndentWithSpaces, violations::IndentWithSpaces,
@ -457,7 +457,7 @@ pub fn indent(checker: &mut Checker, docstring: &Docstring) {
} }
} }
if checker.settings.enabled.contains(&RuleCode::D208) { if checker.settings.rules.enabled(&RuleCode::D208) {
// If every line (except the last) is over-indented... // If every line (except the last) is over-indented...
if is_over_indented { if is_over_indented {
for i in over_indented_lines { for i in over_indented_lines {
@ -605,14 +605,14 @@ pub fn multi_line_summary_start(checker: &mut Checker, docstring: &Docstring) {
return; return;
}; };
if constants::TRIPLE_QUOTE_PREFIXES.contains(&first_line) { if constants::TRIPLE_QUOTE_PREFIXES.contains(&first_line) {
if checker.settings.enabled.contains(&RuleCode::D212) { if checker.settings.rules.enabled(&RuleCode::D212) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MultiLineSummaryFirstLine, violations::MultiLineSummaryFirstLine,
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
)); ));
} }
} else { } else {
if checker.settings.enabled.contains(&RuleCode::D213) { if checker.settings.rules.enabled(&RuleCode::D213) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::MultiLineSummarySecondLine, violations::MultiLineSummarySecondLine,
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
@ -907,7 +907,7 @@ pub fn not_empty(checker: &mut Checker, docstring: &Docstring) -> bool {
return true; return true;
} }
if checker.settings.enabled.contains(&RuleCode::D419) { if checker.settings.rules.enabled(&RuleCode::D419) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::NonEmpty, violations::NonEmpty,
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
@ -970,7 +970,7 @@ fn blanks_and_section_underline(
// Nothing but blank lines after the section header. // Nothing but blank lines after the section header.
if blank_lines_after_header == context.following_lines.len() { if blank_lines_after_header == context.following_lines.len() {
if checker.settings.enabled.contains(&RuleCode::D407) { if checker.settings.rules.enabled(&RuleCode::D407) {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::DashedUnderlineAfterSection(context.section_name.to_string()), violations::DashedUnderlineAfterSection(context.section_name.to_string()),
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
@ -992,7 +992,7 @@ fn blanks_and_section_underline(
} }
checker.diagnostics.push(diagnostic); checker.diagnostics.push(diagnostic);
} }
if checker.settings.enabled.contains(&RuleCode::D414) { if checker.settings.rules.enabled(&RuleCode::D414) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::NonEmptySection(context.section_name.to_string()), violations::NonEmptySection(context.section_name.to_string()),
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
@ -1008,7 +1008,7 @@ fn blanks_and_section_underline(
if dash_line_found { if dash_line_found {
if blank_lines_after_header > 0 { if blank_lines_after_header > 0 {
if checker.settings.enabled.contains(&RuleCode::D408) { if checker.settings.rules.enabled(&RuleCode::D408) {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::SectionUnderlineAfterName(context.section_name.to_string()), violations::SectionUnderlineAfterName(context.section_name.to_string()),
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
@ -1040,7 +1040,7 @@ fn blanks_and_section_underline(
.count() .count()
!= context.section_name.len() != context.section_name.len()
{ {
if checker.settings.enabled.contains(&RuleCode::D409) { if checker.settings.rules.enabled(&RuleCode::D409) {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::SectionUnderlineMatchesSectionLength( violations::SectionUnderlineMatchesSectionLength(
context.section_name.to_string(), context.section_name.to_string(),
@ -1077,7 +1077,7 @@ fn blanks_and_section_underline(
} }
} }
if checker.settings.enabled.contains(&RuleCode::D215) { if checker.settings.rules.enabled(&RuleCode::D215) {
let leading_space = whitespace::leading_space(non_empty_line); let leading_space = whitespace::leading_space(non_empty_line);
if leading_space.len() > docstring.indentation.len() { if leading_space.len() > docstring.indentation.len() {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
@ -1119,14 +1119,14 @@ fn blanks_and_section_underline(
.take_while(|line| line.trim().is_empty()) .take_while(|line| line.trim().is_empty())
.count(); .count();
if blank_lines_after_dashes == rest_of_lines.len() { if blank_lines_after_dashes == rest_of_lines.len() {
if checker.settings.enabled.contains(&RuleCode::D414) { if checker.settings.rules.enabled(&RuleCode::D414) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::NonEmptySection(context.section_name.to_string()), violations::NonEmptySection(context.section_name.to_string()),
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
)); ));
} }
} else { } else {
if checker.settings.enabled.contains(&RuleCode::D412) { if checker.settings.rules.enabled(&RuleCode::D412) {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::NoBlankLinesBetweenHeaderAndContent( violations::NoBlankLinesBetweenHeaderAndContent(
context.section_name.to_string(), context.section_name.to_string(),
@ -1158,7 +1158,7 @@ fn blanks_and_section_underline(
} }
} }
} else { } else {
if checker.settings.enabled.contains(&RuleCode::D414) { if checker.settings.rules.enabled(&RuleCode::D414) {
checker.diagnostics.push(Diagnostic::new( checker.diagnostics.push(Diagnostic::new(
violations::NonEmptySection(context.section_name.to_string()), violations::NonEmptySection(context.section_name.to_string()),
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
@ -1166,7 +1166,7 @@ fn blanks_and_section_underline(
} }
} }
} else { } else {
if checker.settings.enabled.contains(&RuleCode::D407) { if checker.settings.rules.enabled(&RuleCode::D407) {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::DashedUnderlineAfterSection(context.section_name.to_string()), violations::DashedUnderlineAfterSection(context.section_name.to_string()),
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
@ -1189,7 +1189,7 @@ fn blanks_and_section_underline(
checker.diagnostics.push(diagnostic); checker.diagnostics.push(diagnostic);
} }
if blank_lines_after_header > 0 { if blank_lines_after_header > 0 {
if checker.settings.enabled.contains(&RuleCode::D412) { if checker.settings.rules.enabled(&RuleCode::D412) {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::NoBlankLinesBetweenHeaderAndContent( violations::NoBlankLinesBetweenHeaderAndContent(
context.section_name.to_string(), context.section_name.to_string(),
@ -1224,7 +1224,7 @@ fn common_section(
context: &SectionContext, context: &SectionContext,
style: &SectionStyle, style: &SectionStyle,
) { ) {
if checker.settings.enabled.contains(&RuleCode::D405) { if checker.settings.rules.enabled(&RuleCode::D405) {
if !style.section_names().contains(&context.section_name) { if !style.section_names().contains(&context.section_name) {
let capitalized_section_name = titlecase::titlecase(context.section_name); let capitalized_section_name = titlecase::titlecase(context.section_name);
if style if style
@ -1260,7 +1260,7 @@ fn common_section(
} }
} }
if checker.settings.enabled.contains(&RuleCode::D214) { if checker.settings.rules.enabled(&RuleCode::D214) {
let leading_space = whitespace::leading_space(context.line); let leading_space = whitespace::leading_space(context.line);
if leading_space.len() > docstring.indentation.len() { if leading_space.len() > docstring.indentation.len() {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
@ -1288,7 +1288,7 @@ fn common_section(
.map_or(true, |line| !line.trim().is_empty()) .map_or(true, |line| !line.trim().is_empty())
{ {
if context.is_last_section { if context.is_last_section {
if checker.settings.enabled.contains(&RuleCode::D413) { if checker.settings.rules.enabled(&RuleCode::D413) {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::BlankLineAfterLastSection(context.section_name.to_string()), violations::BlankLineAfterLastSection(context.section_name.to_string()),
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
@ -1309,7 +1309,7 @@ fn common_section(
checker.diagnostics.push(diagnostic); checker.diagnostics.push(diagnostic);
} }
} else { } else {
if checker.settings.enabled.contains(&RuleCode::D410) { if checker.settings.rules.enabled(&RuleCode::D410) {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::BlankLineAfterSection(context.section_name.to_string()), violations::BlankLineAfterSection(context.section_name.to_string()),
Range::from_located(docstring.expr), Range::from_located(docstring.expr),
@ -1332,7 +1332,7 @@ fn common_section(
} }
} }
if checker.settings.enabled.contains(&RuleCode::D411) { if checker.settings.rules.enabled(&RuleCode::D411) {
if !context.previous_line.is_empty() { if !context.previous_line.is_empty() {
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
violations::BlankLineBeforeSection(context.section_name.to_string()), violations::BlankLineBeforeSection(context.section_name.to_string()),
@ -1516,7 +1516,7 @@ fn parameters_section(checker: &mut Checker, docstring: &Docstring, context: &Se
fn numpy_section(checker: &mut Checker, docstring: &Docstring, context: &SectionContext) { fn numpy_section(checker: &mut Checker, docstring: &Docstring, context: &SectionContext) {
common_section(checker, docstring, context, &SectionStyle::Numpy); common_section(checker, docstring, context, &SectionStyle::Numpy);
if checker.settings.enabled.contains(&RuleCode::D406) { if checker.settings.rules.enabled(&RuleCode::D406) {
let suffix = context let suffix = context
.line .line
.trim() .trim()
@ -1551,7 +1551,7 @@ fn numpy_section(checker: &mut Checker, docstring: &Docstring, context: &Section
} }
} }
if checker.settings.enabled.contains(&RuleCode::D417) { if checker.settings.rules.enabled(&RuleCode::D417) {
let capitalized_section_name = titlecase::titlecase(context.section_name); let capitalized_section_name = titlecase::titlecase(context.section_name);
if capitalized_section_name == "Parameters" { if capitalized_section_name == "Parameters" {
parameters_section(checker, docstring, context); parameters_section(checker, docstring, context);
@ -1562,7 +1562,7 @@ fn numpy_section(checker: &mut Checker, docstring: &Docstring, context: &Section
fn google_section(checker: &mut Checker, docstring: &Docstring, context: &SectionContext) { fn google_section(checker: &mut Checker, docstring: &Docstring, context: &SectionContext) {
common_section(checker, docstring, context, &SectionStyle::Google); common_section(checker, docstring, context, &SectionStyle::Google);
if checker.settings.enabled.contains(&RuleCode::D416) { if checker.settings.rules.enabled(&RuleCode::D416) {
let suffix = context let suffix = context
.line .line
.trim() .trim()
@ -1598,7 +1598,7 @@ fn google_section(checker: &mut Checker, docstring: &Docstring, context: &Sectio
} }
} }
if checker.settings.enabled.contains(&RuleCode::D417) { if checker.settings.rules.enabled(&RuleCode::D417) {
let capitalized_section_name = titlecase::titlecase(context.section_name); let capitalized_section_name = titlecase::titlecase(context.section_name);
if capitalized_section_name == "Args" || capitalized_section_name == "Arguments" { if capitalized_section_name == "Args" || capitalized_section_name == "Arguments" {
args_section(checker, docstring, context); args_section(checker, docstring, context);

4
src/rules/pyflakes/rules/repeated_keys.rs
View file

@ -37,7 +37,7 @@ pub fn repeated_keys(checker: &mut Checker, keys: &[Expr], values: &[Expr]) {
if let Some(seen_values) = seen.get_mut(&key) { if let Some(seen_values) = seen.get_mut(&key) {
match key { match key {
DictionaryKey::Constant(..) => { DictionaryKey::Constant(..) => {
if checker.settings.enabled.contains(&RuleCode::F601) { if checker.settings.rules.enabled(&RuleCode::F601) {
let comparable_value: ComparableExpr = (&values[i]).into(); let comparable_value: ComparableExpr = (&values[i]).into();
let is_duplicate_value = seen_values.contains(&comparable_value); let is_duplicate_value = seen_values.contains(&comparable_value);
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(
@ -61,7 +61,7 @@ pub fn repeated_keys(checker: &mut Checker, keys: &[Expr], values: &[Expr]) {
} }
} }
DictionaryKey::Variable(key) => { DictionaryKey::Variable(key) => {
if checker.settings.enabled.contains(&RuleCode::F602) { if checker.settings.rules.enabled(&RuleCode::F602) {
let comparable_value: ComparableExpr = (&values[i]).into(); let comparable_value: ComparableExpr = (&values[i]).into();
let is_duplicate_value = seen_values.contains(&comparable_value); let is_duplicate_value = seen_values.contains(&comparable_value);
let mut diagnostic = Diagnostic::new( let mut diagnostic = Diagnostic::new(

4
src/rules/ruff/rules.rs
View file

@ -1650,9 +1650,9 @@ pub fn ambiguous_unicode_character(
}, },
Range::new(location, end_location), Range::new(location, end_location),
); );
if settings.enabled.contains(diagnostic.kind.code()) { if settings.rules.enabled(diagnostic.kind.code()) {
if matches!(autofix, flags::Autofix::Enabled) if matches!(autofix, flags::Autofix::Enabled)
&& settings.fixable.contains(diagnostic.kind.code()) && settings.rules.should_fix(diagnostic.kind.code())
{ {
diagnostic.amend(Fix::replacement( diagnostic.amend(Fix::replacement(
representant.to_string(), representant.to_string(),

116
src/settings/mod.rs
View file

@ -16,6 +16,7 @@ use regex::Regex;
use rustc_hash::FxHashSet; use rustc_hash::FxHashSet;
use self::hashable::{HashableGlobMatcher, HashableGlobSet, HashableHashSet, HashableRegex}; use self::hashable::{HashableGlobMatcher, HashableGlobSet, HashableHashSet, HashableRegex};
use self::rule_table::RuleTable;
use crate::cache::cache_dir; use crate::cache::cache_dir;
use crate::registry::{RuleCode, RuleCodePrefix, SuffixLength, CATEGORIES, INCOMPATIBLE_CODES}; use crate::registry::{RuleCode, RuleCodePrefix, SuffixLength, CATEGORIES, INCOMPATIBLE_CODES};
use crate::rules::{ use crate::rules::{
@ -35,6 +36,7 @@ pub mod hashable;
pub mod options; pub mod options;
pub mod options_base; pub mod options_base;
pub mod pyproject; pub mod pyproject;
mod rule_table;
pub mod types; pub mod types;
const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION"); const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
@ -77,8 +79,7 @@ pub struct CliSettings {
#[derive(Debug, Hash)] #[derive(Debug, Hash)]
#[allow(clippy::struct_excessive_bools)] #[allow(clippy::struct_excessive_bools)]
pub struct Settings { pub struct Settings {
pub enabled: HashableHashSet<RuleCode>, pub rules: RuleTable,
pub fixable: HashableHashSet<RuleCode>,
pub per_file_ignores: Vec<( pub per_file_ignores: Vec<(
HashableGlobMatcher, HashableGlobMatcher,
HashableGlobMatcher, HashableGlobMatcher,
@ -154,6 +155,15 @@ static DEFAULT_DUMMY_VARIABLE_RGX: Lazy<Regex> =
impl Settings { impl Settings {
pub fn from_configuration(config: Configuration, project_root: &Path) -> Result<Self> { pub fn from_configuration(config: Configuration, project_root: &Path) -> Result<Self> {
Ok(Self { Ok(Self {
rules: build_rule_table(
config.fixable,
config.unfixable,
config.select,
config.ignore,
&config.extend_select,
&config.extend_ignore,
&config.pydocstyle,
),
allowed_confusables: config allowed_confusables: config
.allowed_confusables .allowed_confusables
.map(FxHashSet::from_iter) .map(FxHashSet::from_iter)
@ -164,53 +174,14 @@ impl Settings {
.dummy_variable_rgx .dummy_variable_rgx
.unwrap_or_else(|| DEFAULT_DUMMY_VARIABLE_RGX.clone()) .unwrap_or_else(|| DEFAULT_DUMMY_VARIABLE_RGX.clone())
.into(), .into(),
enabled: validate_enabled(resolve_codes(
[RuleCodeSpec {
select: &config
.select
.unwrap_or_else(|| vec![RuleCodePrefix::E, RuleCodePrefix::F]),
ignore: &config.ignore.unwrap_or_default(),
}]
.into_iter()
.chain(
config
.extend_select
.iter()
.zip(config.extend_ignore.iter())
.map(|(select, ignore)| RuleCodeSpec { select, ignore }),
)
.chain(
// If a docstring convention is specified, force-disable any incompatible error
// codes.
if let Some(convention) = config
.pydocstyle
.as_ref()
.and_then(|pydocstyle| pydocstyle.convention)
{
Left(iter::once(RuleCodeSpec {
select: &[],
ignore: convention.codes(),
}))
} else {
Right(iter::empty())
},
),
))
.into(),
exclude: HashableGlobSet::new( exclude: HashableGlobSet::new(
config.exclude.unwrap_or_else(|| DEFAULT_EXCLUDE.clone()), config.exclude.unwrap_or_else(|| DEFAULT_EXCLUDE.clone()),
)?, )?,
extend_exclude: HashableGlobSet::new(config.extend_exclude)?, extend_exclude: HashableGlobSet::new(config.extend_exclude)?,
external: FxHashSet::from_iter(config.external.unwrap_or_default()).into(), external: FxHashSet::from_iter(config.external.unwrap_or_default()).into(),
fixable: resolve_codes(
[RuleCodeSpec {
select: &config.fixable.unwrap_or_else(|| CATEGORIES.to_vec()),
ignore: &config.unfixable.unwrap_or_default(),
}]
.into_iter(),
)
.into(),
force_exclude: config.force_exclude.unwrap_or(false), force_exclude: config.force_exclude.unwrap_or(false),
ignore_init_module_imports: config.ignore_init_module_imports.unwrap_or_default(), ignore_init_module_imports: config.ignore_init_module_imports.unwrap_or_default(),
line_length: config.line_length.unwrap_or(88), line_length: config.line_length.unwrap_or(88),
namespace_packages: config.namespace_packages.unwrap_or_default(), namespace_packages: config.namespace_packages.unwrap_or_default(),
@ -265,16 +236,15 @@ impl Settings {
#[cfg(test)] #[cfg(test)]
pub fn for_rule(rule_code: RuleCode) -> Self { pub fn for_rule(rule_code: RuleCode) -> Self {
Self { Self {
rules: [rule_code].into(),
allowed_confusables: FxHashSet::from_iter([]).into(), allowed_confusables: FxHashSet::from_iter([]).into(),
builtins: vec![], builtins: vec![],
dummy_variable_rgx: Regex::new("^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$") dummy_variable_rgx: Regex::new("^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$")
.unwrap() .unwrap()
.into(), .into(),
enabled: FxHashSet::from_iter([rule_code.clone()]).into(),
exclude: HashableGlobSet::empty(), exclude: HashableGlobSet::empty(),
extend_exclude: HashableGlobSet::empty(), extend_exclude: HashableGlobSet::empty(),
external: HashableHashSet::default(), external: HashableHashSet::default(),
fixable: FxHashSet::from_iter([rule_code]).into(),
force_exclude: false, force_exclude: false,
ignore_init_module_imports: false, ignore_init_module_imports: false,
line_length: 88, line_length: 88,
@ -308,16 +278,15 @@ impl Settings {
#[cfg(test)] #[cfg(test)]
pub fn for_rules(rule_codes: Vec<RuleCode>) -> Self { pub fn for_rules(rule_codes: Vec<RuleCode>) -> Self {
Self { Self {
rules: rule_codes.into(),
allowed_confusables: HashableHashSet::default(), allowed_confusables: HashableHashSet::default(),
builtins: vec![], builtins: vec![],
dummy_variable_rgx: Regex::new("^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$") dummy_variable_rgx: Regex::new("^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$")
.unwrap() .unwrap()
.into(), .into(),
enabled: FxHashSet::from_iter(rule_codes.clone()).into(),
exclude: HashableGlobSet::empty(), exclude: HashableGlobSet::empty(),
extend_exclude: HashableGlobSet::empty(), extend_exclude: HashableGlobSet::empty(),
external: HashableHashSet::default(), external: HashableHashSet::default(),
fixable: FxHashSet::from_iter(rule_codes).into(),
force_exclude: false, force_exclude: false,
ignore_init_module_imports: false, ignore_init_module_imports: false,
line_length: 88, line_length: 88,
@ -362,6 +331,59 @@ impl Settings {
} }
} }
fn build_rule_table(
fixable: Option<Vec<RuleCodePrefix>>,
unfixable: Option<Vec<RuleCodePrefix>>,
select: Option<Vec<RuleCodePrefix>>,
ignore: Option<Vec<RuleCodePrefix>>,
extend_select: &[Vec<RuleCodePrefix>],
extend_ignore: &[Vec<RuleCodePrefix>],
pydocstyle: &Option<pydocstyle::settings::Options>,
) -> RuleTable {
let mut rules = RuleTable::empty();
let fixable = resolve_codes(
[RuleCodeSpec {
select: &fixable.unwrap_or_else(|| CATEGORIES.to_vec()),
ignore: &unfixable.unwrap_or_default(),
}]
.into_iter(),
);
for code in validate_enabled(resolve_codes(
[RuleCodeSpec {
select: &select.unwrap_or_else(|| vec![RuleCodePrefix::E, RuleCodePrefix::F]),
ignore: &ignore.unwrap_or_default(),
}]
.into_iter()
.chain(
extend_select
.iter()
.zip(extend_ignore.iter())
.map(|(select, ignore)| RuleCodeSpec { select, ignore }),
)
.chain(
// If a docstring convention is specified, force-disable any incompatible error
// codes.
if let Some(convention) = pydocstyle
.as_ref()
.and_then(|pydocstyle| pydocstyle.convention)
{
Left(iter::once(RuleCodeSpec {
select: &[],
ignore: convention.codes(),
}))
} else {
Right(iter::empty())
},
),
)) {
let fix = fixable.contains(&code);
rules.enable(code, fix);
}
rules
}
/// Given a list of patterns, create a `GlobSet`. /// Given a list of patterns, create a `GlobSet`.
pub fn resolve_per_file_ignores( pub fn resolve_per_file_ignores(
per_file_ignores: Vec<PerFileIgnore>, per_file_ignores: Vec<PerFileIgnore>,

55
src/settings/rule_table.rs Normal file
View file

@ -0,0 +1,55 @@
use std::collections::hash_map;
use rustc_hash::FxHashMap;
use super::hashable::HashableHashMap;
use crate::registry::RuleCode;
/// A table to keep track of which rules are enabled
/// and whether or not they should be autofixed.
#[derive(Debug, Hash)]
pub struct RuleTable {
/// Maps rule codes to a boolean indicating if the rule should be autofixed.
enabled: HashableHashMap<RuleCode, bool>,
}
impl RuleTable {
/// Creates a new empty rule table.
pub fn empty() -> Self {
Self {
enabled: HashableHashMap::default(),
}
}
/// Returns whether the given rule should be checked.
pub fn enabled(&self, code: &RuleCode) -> bool {
self.enabled.contains_key(code)
}
/// Returns whether violations of the given rule should be autofixed.
pub fn should_fix(&self, code: &RuleCode) -> bool {
*self.enabled.get(code).unwrap_or(&false)
}
/// Returns an iterator over all enabled rules.
pub fn iter_enabled(&self) -> hash_map::Keys<RuleCode, bool> {
self.enabled.keys()
}
/// Enables the given rule.
pub fn enable(&mut self, code: RuleCode, should_fix: bool) {
self.enabled.insert(code, should_fix);
}
}
impl<I: IntoIterator<Item = RuleCode>> From<I> for RuleTable {
fn from(codes: I) -> Self {
let mut enabled = FxHashMap::default();
for code in codes {
enabled.insert(code, true);
}
Self {
enabled: enabled.into(),
}
}
}