#[clap(flatten)]

log_level_args: LogLevelArgs,

/// Either a path to a TOML configuration file (`pyproject.toml` or `ruff.toml`),

/// or a TOML `<KEY> = <VALUE>` pair

/// (such as you might find in a `ruff.toml` configuration file)

/// overriding a specific configuration option

/// (e.g., `--config "lint.line-length = 100"` or `--config "format.quote-style = 'single'"`).

/// Overrides of individual settings using this option always take precedence

/// over all configuration files, including configuration files that were also

/// specified using `--config`.

#[arg(

config: Vec<SingleConfigArgument>,

/// Ignore all configuration files.

//

// Note: We can't mark this as conflicting with `--config` here

// as `--config` can be used for specifying configuration overrides

// as well as configuration files.

// Specifying a configuration file conflicts with `--isolated`;

// specifying a configuration override does not.

// If a user specifies `ruff check --isolated --config=ruff.toml`,

// we emit an error later on, after the initial parsing by clap.

#[arg(long, help_heading = "Global options", global = true)]

isolated: bool,

/// Control when colored output is used.

#[arg(

pub(crate) color: Option<TerminalColor>,

pub fn log_level(&self) -> LogLevel {

LogLevel::from(&self.log_level_args)

}

#[must_use]

fn partition(self) -> (LogLevel, Vec<SingleConfigArgument>, bool) {

(self.log_level(), self.config, self.isolated)

}

/// Display colors if the output goes to an interactive terminal.

#[default]

Auto,

/// Always display colors.

Always,

/// Never display colors.

Never,

.header(AnsiColor::Green.on_default().effects(Effects::BOLD))

.usage(AnsiColor::Green.on_default().effects(Effects::BOLD))

.literal(AnsiColor::Cyan.on_default().effects(Effects::BOLD))

#[command(subcommand)]

pub(crate) command: Command,

#[clap(flatten)]

pub(crate) global_options: GlobalConfigArgs,

/// Run Ruff on the given files or directories.

Check(CheckCommand),

/// Explain a rule (or all rules).

#[command(group = clap::ArgGroup::new("selector").multiple(false).required(true))]

Rule {

/// Rule to explain

#[arg(value_parser=RuleParser, group = "selector", hide_possible_values = true)]

rule: Option<Rule>,

/// Explain all rules

#[arg(long, conflicts_with = "rule", group = "selector")]

all: bool,

/// Output format

#[arg(long, value_enum, default_value = "text")]

output_format: HelpFormat,

},

/// List or describe the available configuration options.

Config {

/// Config key to show

#[arg(

option: Option<OptionString>,

/// Output format

#[arg(long, value_enum, default_value = "text")]

output_format: HelpFormat,

},

/// List all supported upstream linters.

Linter {

/// Output format

#[arg(long, value_enum, default_value = "text")]

output_format: HelpFormat,

},

/// Clear any caches in the current directory and any subdirectories.

Clean,

/// Generate shell completion.

#[clap(hide = true)]

GenerateShellCompletion { shell: clap_complete_command::Shell },

/// Run the Ruff formatter on the given files or directories.

Format(FormatCommand),

/// Run the language server.

Server(ServerCommand),

/// Run analysis over Python source code.

#[clap(subcommand)]

Analyze(AnalyzeCommand),

/// Display Ruff's version

Version {

#[arg(long, value_enum, default_value = "text")]

output_format: HelpFormat,

},

/// List of files or directories to include.

#[clap(help = "List of files or directories to include [default: .]")]

files: Vec<PathBuf>,

/// The direction of the import map. By default, generates a dependency map, i.e., a map from

/// file to files that it depends on. Use `--direction dependents` to generate a map from file

/// to files that depend on it.

#[clap(long, value_enum, default_value_t)]

direction: Direction,

/// Attempt to detect imports from string literals.

#[clap(long)]

detect_string_imports: bool,

/// The minimum number of dots in a string import to consider it a valid import.

#[clap(long)]

min_dots: Option<usize>,

/// Enable preview mode. Use `--no-preview` to disable.

#[arg(long, overrides_with("no_preview"))]

preview: bool,

#[clap(long, overrides_with("preview"), hide = true)]

no_preview: bool,

/// The minimum Python version that should be supported.

#[arg(long, value_enum)]

target_version: Option<PythonVersion>,

/// Path to a virtual environment to use for resolving additional dependencies

#[arg(long)]

python: Option<PathBuf>,

/// Include imports that are only used for type checking (i.e., imports within `if TYPE_CHECKING:` blocks).

/// Use `--no-type-checking-imports` to exclude imports that are only used for type checking.

#[arg(long, overrides_with("no_type_checking_imports"))]

type_checking_imports: bool,

#[arg(long, overrides_with("type_checking_imports"), hide = true)]

no_type_checking_imports: bool,

/// List of files or directories to check.

#[clap(help = "List of files or directories to check, or `-` to read from stdin [default: .]")]

files: Vec<PathBuf>,

/// Apply fixes to resolve lint violations.

/// Use `--no-fix` to disable or `--unsafe-fixes` to include unsafe fixes.

#[arg(long, overrides_with("no_fix"))]

fix: bool,

#[clap(long, overrides_with("fix"), hide = true)]

no_fix: bool,

/// Include fixes that may not retain the original intent of the code.

/// Use `--no-unsafe-fixes` to disable.

#[arg(long, overrides_with("no_unsafe_fixes"))]

unsafe_fixes: bool,

#[arg(long, overrides_with("unsafe_fixes"), hide = true)]

no_unsafe_fixes: bool,

/// Show an enumeration of all fixed lint violations.

/// Use `--no-show-fixes` to disable.

#[arg(long, overrides_with("no_show_fixes"))]

show_fixes: bool,

#[clap(long, overrides_with("show_fixes"), hide = true)]

no_show_fixes: bool,

/// Avoid writing any fixed files back; instead, output a diff for each changed file to stdout, and exit 0 if there are no diffs.

/// Implies `--fix-only`.

#[arg(long, conflicts_with = "show_fixes")]

diff: bool,

/// Run in watch mode by re-running whenever files change.

#[arg(short, long)]

watch: bool,

/// Apply fixes to resolve lint violations, but don't report on, or exit non-zero for, leftover violations. Implies `--fix`.

/// Use `--no-fix-only` to disable or `--unsafe-fixes` to include unsafe fixes.

#[arg(long, overrides_with("no_fix_only"))]

fix_only: bool,

#[clap(long, overrides_with("fix_only"), hide = true)]

no_fix_only: bool,

/// Ignore any `# noqa` comments.

#[arg(long)]

ignore_noqa: bool,

/// Output serialization format for violations.

/// The default serialization format is "full".

#[arg(long, value_enum, env = "RUFF_OUTPUT_FORMAT")]

output_format: Option<OutputFormat>,

/// Specify file to write the linter output to (default: stdout).

#[arg(short, long, env = "RUFF_OUTPUT_FILE")]

output_file: Option<PathBuf>,

/// The minimum Python version that should be supported.

#[arg(long, value_enum)]

target_version: Option<PythonVersion>,

/// Enable preview mode; checks will include unstable rules and fixes.

/// Use `--no-preview` to disable.

#[arg(long, overrides_with("no_preview"))]

preview: bool,

#[clap(long, overrides_with("preview"), hide = true)]

no_preview: bool,

/// Comma-separated list of rule codes to enable (or ALL, to enable all rules).

#[arg(

select: Option<Vec<UnresolvedRuleSelector>>,

/// Comma-separated list of rule codes to disable.

#[arg(

ignore: Option<Vec<UnresolvedRuleSelector>>,

/// Like --select, but adds additional rule codes on top of those already specified.

#[arg(

extend_select: Option<Vec<UnresolvedRuleSelector>>,

/// Like --ignore. (Deprecated: You can just use --ignore instead.)

#[arg(

extend_ignore: Option<Vec<UnresolvedRuleSelector>>,

/// List of mappings from file pattern to code to exclude.

#[arg(long, value_delimiter = ',', help_heading = "Rule selection")]

per_file_ignores: Option<Vec<PatternPrefixPair>>,

/// Like `--per-file-ignores`, but adds additional ignores on top of those already specified.

#[arg(long, value_delimiter = ',', help_heading = "Rule selection")]

extend_per_file_ignores: Option<Vec<PatternPrefixPair>>,

/// List of paths, used to omit files and/or directories from analysis.

#[arg(

exclude: Option<Vec<FilePattern>>,

/// Like --exclude, but adds additional files and directories on top of those already excluded.

#[arg(

extend_exclude: Option<Vec<FilePattern>>,

/// List of rule codes to treat as eligible for fix. Only applicable when fix itself is enabled (e.g., via `--fix`).

#[arg(

fixable: Option<Vec<UnresolvedRuleSelector>>,

/// List of rule codes to treat as ineligible for fix. Only applicable when fix itself is enabled (e.g., via `--fix`).

#[arg(

unfixable: Option<Vec<UnresolvedRuleSelector>>,

/// Like --fixable, but adds additional rule codes on top of those already specified.

#[arg(

extend_fixable: Option<Vec<UnresolvedRuleSelector>>,

/// Like --unfixable. (Deprecated: You can just use --unfixable instead.)

#[arg(

extend_unfixable: Option<Vec<UnresolvedRuleSelector>>,

/// Respect file exclusions via `.gitignore` and other standard ignore files.

/// Use `--no-respect-gitignore` to disable.

#[arg(

respect_gitignore: bool,

#[clap(long, overrides_with("respect_gitignore"), hide = true)]

no_respect_gitignore: bool,

/// Enforce exclusions, even for paths passed to Ruff directly on the command-line.

/// Use `--no-force-exclude` to disable.

#[arg(

force_exclude: bool,

#[clap(long, overrides_with("force_exclude"), hide = true)]

no_force_exclude: bool,

/// Set the line-length for length-associated rules and automatic formatting.

#[arg(long, help_heading = "Rule configuration", hide = true)]

line_length: Option<LineLength>,

/// Regular expression matching the name of dummy variables.

#[arg(long, help_heading = "Rule configuration", hide = true)]

dummy_variable_rgx: Option<Regex>,

/// Disable cache reads.

#[arg(short, long, env = "RUFF_NO_CACHE", help_heading = "Miscellaneous")]

no_cache: bool,

/// Path to the cache directory.

#[arg(long, env = "RUFF_CACHE_DIR", help_heading = "Miscellaneous")]

cache_dir: Option<PathBuf>,

/// The name of the file when passing it through stdin.

#[arg(long, help_heading = "Miscellaneous")]

stdin_filename: Option<PathBuf>,

/// List of mappings from file extension to language (one of `python`, `ipynb`, `pyi`). For

/// example, to treat `.ipy` files as IPython notebooks, use `--extension ipy:ipynb`.

#[arg(long, value_delimiter = ',')]

extension: Option<Vec<ExtensionPair>>,

/// Exit with status code "0", even upon detecting lint violations.

#[arg(

exit_zero: bool,

/// Exit with a non-zero status code if any files were modified via fix, even if no lint violations remain.

#[arg(long, help_heading = "Miscellaneous", conflicts_with = "exit_zero")]

exit_non_zero_on_fix: bool,

/// Show counts for every rule with at least one violation.

#[arg(

statistics: bool,

/// Enable automatic additions of `noqa` directives to failing lines.

/// Optionally provide a reason to append after the codes.

#[arg(

add_noqa: Option<String>,

/// Enable automatic additions of `ruff: ignore` comments to failing lines.

/// Optionally provide a reason to append after the codes.

/// In preview, add suppression comments with rule names instead.

#[arg(

add_ignore: Option<String>,

/// See the files Ruff will be run against with the current settings.

#[arg(

show_files: bool,

/// See the settings Ruff will use to lint a given Python file.

#[arg(

show_settings: bool,

/// List of files or directories to format.

#[clap(

files: Vec<PathBuf>,

/// Avoid writing any formatted files back; instead, exit with a non-zero status code if any

/// files would have been modified, and zero otherwise.

#[arg(long)]

check: bool,

/// Avoid writing any formatted files back; instead, exit with a non-zero status code and the

/// difference between the current file and how the formatted file would look like.

#[arg(long)]

diff: bool,

/// Disable cache reads.

#[arg(short, long, env = "RUFF_NO_CACHE", help_heading = "Miscellaneous")]

no_cache: bool,

/// Path to the cache directory.

#[arg(long, env = "RUFF_CACHE_DIR", help_heading = "Miscellaneous")]

cache_dir: Option<PathBuf>,

/// Respect file exclusions via `.gitignore` and other standard ignore files.

/// Use `--no-respect-gitignore` to disable.

#[arg(

respect_gitignore: bool,

#[clap(long, overrides_with("respect_gitignore"), hide = true)]

no_respect_gitignore: bool,

/// List of paths, used to omit files and/or directories from analysis.

#[arg(

exclude: Option<Vec<FilePattern>>,

/// Like --exclude, but adds additional files and directories on top of those already excluded.

#[arg(

pub extend_exclude: Option<Vec<FilePattern>>,

/// Enforce exclusions, even for paths passed to Ruff directly on the command-line.

/// Use `--no-force-exclude` to disable.

#[arg(

force_exclude: bool,

#[clap(long, overrides_with("force_exclude"), hide = true)]

no_force_exclude: bool,

/// Set the line-length.

#[arg(long, help_heading = "Format configuration")]

line_length: Option<LineLength>,

/// The name of the file when passing it through stdin.

#[arg(long, help_heading = "Miscellaneous")]

stdin_filename: Option<PathBuf>,

/// List of mappings from file extension to language (one of `python`, `ipynb`, `pyi`). For

/// example, to treat `.ipy` files as IPython notebooks, use `--extension ipy:ipynb`.

#[arg(long, value_delimiter = ',')]

extension: Option<Vec<ExtensionPair>>,

/// The minimum Python version that should be supported.

#[arg(long, value_enum)]

target_version: Option<PythonVersion>,

/// Enable preview mode; enables unstable formatting.

/// Use `--no-preview` to disable.

#[arg(long, overrides_with("no_preview"))]

preview: bool,

#[clap(long, overrides_with("preview"), hide = true)]

no_preview: bool,

/// When specified, Ruff will try to only format the code in the given range.

/// It might be necessary to extend the start backwards or the end forwards, to fully enclose a logical line.

/// The `<RANGE>` uses the format `<start_line>:<start_column>-<end_line>:<end_column>`.

///

/// - The line and column numbers are 1 based.

/// - The column specifies the nth-unicode codepoint on that line.

/// - The end offset is exclusive.

/// - The column numbers are optional. You can write `--range=1-2` instead of `--range=1:1-2:1`.

/// - The end position is optional. You can write `--range=2` to format the entire document starting from the second line.

/// - The start position is optional. You can write `--range=-3` to format the first three lines of the document.

///

/// The option can only be used when formatting a single file. Range formatting of notebooks is unsupported.

#[clap(long, help_heading = "Editor options", verbatim_doc_comment)]

range: Option<FormatRange>,

/// Exit with a non-zero status code if any files were modified via format, even if all files were formatted successfully.

#[arg(long, help_heading = "Miscellaneous", alias = "exit-non-zero-on-fix")]

exit_non_zero_on_format: bool,

/// Output serialization format for violations, when used with `--check`.

/// The default serialization format is "full".

#[arg(long, value_enum, env = "RUFF_OUTPUT_FORMAT")]

output_format: Option<OutputFormat>,

/// Enable preview mode. Use `--no-preview` to disable.

///

/// This enables unstable server features and turns on the preview mode for the linter

/// and the formatter.

#[arg(long, overrides_with("no_preview"))]

preview: bool,

#[clap(long, overrides_with("preview"), hide = true)]

no_preview: bool,

pub(crate) fn resolve_preview(self) -> Option<bool> {

resolve_bool_arg(self.preview, self.no_preview)

}

/// Enable verbose logging.

#[arg(

verbose: bool,

/// Print diagnostics, but nothing else.

#[arg(

quiet: bool,

/// Disable all logging (but still exit with status code "1" upon detecting diagnostics).

#[arg(

silent: bool,

fn from(args: &LogLevelArgs) -> Self {

if args.silent {

Self::Silent

} else if args.quiet {

Self::Quiet

} else if args.verbose {

Self::Verbose

} else {

Self::Default

}

}

/// Whether the user specified --isolated on the command line

pub(crate) isolated: bool,

/// The logging level to be used, derived from command-line arguments passed

pub(crate) log_level: LogLevel,

/// Path to a pyproject.toml or ruff.toml configuration file (etc.).

/// Either 0 or 1 configuration file paths may be provided on the command line.

config_file: Option<PathBuf>,

/// Overrides provided via the `--config "KEY=VALUE"` option.

/// An arbitrary number of these overrides may be provided on the command line.

/// These overrides take precedence over all configuration files,

/// even configuration files that were also specified using `--config`.

overrides: Configuration,

/// Overrides provided via dedicated flags such as `--line-length` etc.

/// These overrides take precedence over all configuration files,

/// and also over all overrides specified using any `--config "KEY=VALUE"` flags.

per_flag_overrides: ExplicitConfigOverrides,

pub(crate) fn config_file(&self) -> Option<&Path> {

self.config_file.as_deref()

}

fn from_cli_arguments(

global_options: GlobalConfigArgs,

per_flag_overrides: ExplicitConfigOverrides,

) -> anyhow::Result<Self> {

let (log_level, config_options, isolated) = global_options.partition();

let mut config_file: Option<PathBuf> = None;

let mut overrides = Configuration::default();

for option in config_options {

match option {

SingleConfigArgument::SettingsOverride(overridden_option) => {

let overridden_option = Arc::try_unwrap(overridden_option)

.unwrap_or_else(|option| option.deref().clone());

overrides = overrides.combine(Configuration::from_options(

overridden_option,

None,

&path_dedot::CWD,

)?);

}

SingleConfigArgument::FilePath(path) => {

if isolated {

bail!(

"\

path.display()

);

}

if let Some(ref config_file) = config_file {

let (first, second) = (config_file.display(), path.display());

bail!(

"\

);

}

config_file = Some(path);

}

}

}

Ok(Self {

isolated,

log_level,

config_file,

overrides,

per_flag_overrides,

})

}

fn transform(&self, config: Configuration) -> Configuration {

let with_config_overrides = self.overrides.clone().combine(config);

self.per_flag_overrides.transform(with_config_overrides)

}

/// Partition the CLI into command-line arguments and configuration

/// overrides.

pub(crate) fn partition(

self,

global_options: GlobalConfigArgs,

) -> anyhow::Result<(CheckArguments, ConfigArguments)> {

let check_arguments = CheckArguments {

add_noqa: self.add_noqa,

add_ignore: self.add_ignore,

diff: self.diff,

exit_non_zero_on_fix: self.exit_non_zero_on_fix,

exit_zero: self.exit_zero,

files: self.files,

ignore_noqa: self.ignore_noqa,

no_cache: self.no_cache,

output_file: self.output_file,

show_files: self.show_files,

show_settings: self.show_settings,

statistics: self.statistics,

stdin_filename: self.stdin_filename,

watch: self.watch,

};

let cli_overrides = ExplicitConfigOverrides {

dummy_variable_rgx: self.dummy_variable_rgx,

exclude: self.exclude,

extend_exclude: self.extend_exclude,

extend_fixable: self.extend_fixable,

extend_ignore: self.extend_ignore,

extend_per_file_ignores: self.extend_per_file_ignores,

extend_select: self.extend_select,

extend_unfixable: self.extend_unfixable,

fixable: self.fixable,

ignore: self.ignore,

line_length: self.line_length,

per_file_ignores: self.per_file_ignores,

preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),

respect_gitignore: resolve_bool_arg(self.respect_gitignore, self.no_respect_gitignore),

select: self.select,

target_version: self.target_version.map(ast::PythonVersion::from),

unfixable: self.unfixable,

// TODO(charlie): Included in `pyproject.toml`, but not inherited.

cache_dir: self.cache_dir,

fix: resolve_bool_arg(self.fix, self.no_fix),

fix_only: resolve_bool_arg(self.fix_only, self.no_fix_only),

unsafe_fixes: resolve_bool_arg(self.unsafe_fixes, self.no_unsafe_fixes)

.map(UnsafeFixes::from),

force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),

output_format: self.output_format,

show_fixes: resolve_bool_arg(self.show_fixes, self.no_show_fixes),

extension: self.extension,

..ExplicitConfigOverrides::default()

};

let config_args = ConfigArguments::from_cli_arguments(global_options, cli_overrides)?;

Ok((check_arguments, config_args))

}

/// Partition the CLI into command-line arguments and configuration

/// overrides.

pub fn partition(

self,

global_options: GlobalConfigArgs,

) -> anyhow::Result<(FormatArguments, ConfigArguments)> {

let format_arguments = FormatArguments {

check: self.check,

diff: self.diff,

files: self.files,

no_cache: self.no_cache,

stdin_filename: self.stdin_filename,

range: self.range,

exit_non_zero_on_format: self.exit_non_zero_on_format,

};

let cli_overrides = ExplicitConfigOverrides {

line_length: self.line_length,

respect_gitignore: resolve_bool_arg(self.respect_gitignore, self.no_respect_gitignore),

exclude: self.exclude,

extend_exclude: self.extend_exclude,

preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),

force_exclude: resolve_bool_arg(self.force_exclude, self.no_force_exclude),

target_version: self.target_version.map(ast::PythonVersion::from),

cache_dir: self.cache_dir,

extension: self.extension,

output_format: self.output_format,

..ExplicitConfigOverrides::default()

};

let config_args = ConfigArguments::from_cli_arguments(global_options, cli_overrides)?;

Ok((format_arguments, config_args))

}

/// Partition the CLI into command-line arguments and configuration

/// overrides.

pub(crate) fn partition(

self,

global_options: GlobalConfigArgs,

) -> anyhow::Result<(AnalyzeGraphArgs, ConfigArguments)> {

let format_arguments = AnalyzeGraphArgs {

files: self.files,

direction: self.direction,

python: self.python,

};

let cli_overrides = ExplicitConfigOverrides {

detect_string_imports: if self.detect_string_imports {

Some(true)

} else {

None

},

string_imports_min_dots: self.min_dots,

preview: resolve_bool_arg(self.preview, self.no_preview).map(PreviewMode::from),

target_version: self.target_version.map(ast::PythonVersion::from),

type_checking_imports: resolve_bool_arg(

self.type_checking_imports,

self.no_type_checking_imports,

),

..ExplicitConfigOverrides::default()

};

let config_args = ConfigArguments::from_cli_arguments(global_options, cli_overrides)?;

Ok((format_arguments, config_args))

}

match (yes, no) {

(true, false) => Some(true),

(false, true) => Some(false),

(false, false) => None,

(..) => unreachable!("Clap should make this impossible"),

}

InvalidToml(toml::de::Error),

/// It was valid TOML, but not a valid ruff config file.

/// E.g. the user tried to select a rule that doesn't exist,

/// or tried to enable a setting that doesn't exist

ValidTomlButInvalidRuffSchema(toml::de::Error),

/// It was a valid ruff config file, but the user tried to pass a

/// value for `extend` as part of the config override.

/// `extend` is special, because it affects which config files we look at

/// in the first place. We currently only parse --config overrides *after*

/// we've combined them with all the arguments from the various config files

/// that we found, so trying to override `extend` as part of a --config

/// override is forbidden.

ExtendPassedViaConfigFlag,

const fn description(&self) -> &'static str {

match self {

Self::InvalidToml(_) => "The supplied argument is not valid TOML",

Self::ValidTomlButInvalidRuffSchema(_) => {

"Could not parse the supplied argument as a `ruff.toml` configuration option"