ruff 0.15.21

An extremely fast Python linter and code formatter
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::path::PathBuf;
use std::time::Instant;

use anyhow::{Result, bail};
use log::{debug, error};
#[cfg(not(target_family = "wasm"))]
use rayon::prelude::*;

use ruff_linter::SuppressionKind;
use ruff_linter::linter::add_suppressions_to_path;
use ruff_linter::preview::is_human_readable_names_enabled;
use ruff_linter::source_kind::SourceKind;
use ruff_linter::warn_user_once;
use ruff_python_ast::{PySourceType, SourceType};
use ruff_workspace::resolver::{
    PyprojectConfig, ResolvedFile, match_exclusion, project_files_in_path,
};

use crate::args::ConfigArguments;

/// Add suppression directives to a collection of files.
pub(crate) fn add_noqa(
    files: &[PathBuf],
    pyproject_config: &PyprojectConfig,
    config_arguments: &ConfigArguments,
    reason: Option<&str>,
    suppression_kind: SuppressionKind,
) -> Result<usize> {
    // Collect all the files to check.
    let start = Instant::now();
    let (mut paths, resolver) = project_files_in_path(files, pyproject_config, config_arguments)?;
    let duration = start.elapsed();
    debug!("Identified files to lint in: {duration:?}");

    // Filter out paths for file types not supported for linting
    paths.retain(|path| {
        if let Ok(ResolvedFile::Root(path) | ResolvedFile::Nested(path)) = path {
            matches!(
                SourceType::from(path),
                SourceType::Python(PySourceType::Python | PySourceType::Stub)
            )
        } else {
            true
        }
    });

    if paths.is_empty() {
        warn_user_once!("No Python files found under the given path(s)");
        return Ok(0);
    }

    // Discover the package root for each Python file.
    let package_roots = resolver.package_roots(
        &paths
            .iter()
            .flatten()
            .map(ResolvedFile::path)
            .collect::<Vec<_>>(),
    );

    let start = Instant::now();
    let modifications: usize = paths
        .par_iter()
        .flatten()
        .map(|resolved_file| -> Result<usize> {
            let source_type = SourceType::from(resolved_file.path());
            let path = resolved_file.path();
            let package = resolved_file
                .path()
                .parent()
                .and_then(|parent| package_roots.get(parent))
                .and_then(|package| *package);
            let settings = resolver.resolve(path);
            if (settings.file_resolver.force_exclude || !resolved_file.is_root())
                && match_exclusion(
                    resolved_file.path(),
                    resolved_file.file_name(),
                    &settings.linter.exclude,
                )
            {
                return Ok(0);
            }
            if matches!(suppression_kind, SuppressionKind::Ignore)
                && !is_human_readable_names_enabled(settings.linter.preview)
            {
                bail!(
                    "`--add-ignore` requires preview mode, but preview is disabled for `{}`",
                    path.display()
                );
            }
            let source_kind = match SourceKind::from_path(path, source_type) {
                Ok(Some(source_kind)) => source_kind,
                Ok(None) => return Ok(0),
                Err(e) => {
                    error!("Failed to extract source from {}: {e}", path.display());
                    return Ok(0);
                }
            };
            match add_suppressions_to_path(
                path,
                package,
                &source_kind,
                source_type.expect_python(),
                &settings.linter,
                reason,
                suppression_kind,
            ) {
                Ok(count) => Ok(count),
                Err(e) => {
                    error!("Failed to add suppression to {}: {e}", path.display());
                    Ok(0)
                }
            }
        })
        .sum::<Result<usize>>()?;

    let duration = start.elapsed();
    debug!("Added suppressions to files in: {duration:?}");

    Ok(modifications)
}