Struct Args 

pub struct Args {
    pub manifest_path: Option<PathBuf>,
    pub packages: Vec<String>,
    pub header_file: Option<PathBuf>,
    pub format: OutputFormat,
    pub offence_threshold: Option<usize>,
    pub list_rules: bool,
    pub rules: Vec<String>,
    pub fix: bool,
    pub baseline: Option<PathBuf>,
    pub write_baseline: bool,
    pub excludes: Vec<String>,
    pub skipped_rules: Vec<String>,
}

Fields

manifest_path: Option<PathBuf>

Workspace or package manifest to analyse. Defaults to the Cargo.toml in the current directory, which is what makes a bare cargo stern4rust work from inside the thing being judged.

packages: Vec<String>

Restrict the run to these packages; repeatable. Omit to take the manifest’s own package, or every member if it is a workspace root. Naming a package that the manifest does not scan is an error rather than an empty run, because a typo in a gate script otherwise reads as a pass.

header_file: Option<PathBuf>

File holding the header every .rs file must open with. It is data rather than a built-in constant because it is never the same twice: MIT here, Apache 2.0 in a sibling repository, and a different year again next year.

format: OutputFormat

How to report. The table is for a person; json is the same run as a document, for a gate script or an agent that would otherwise have to guess where one column of the table ends and the next begins.

offence_threshold: Option<usize>

How many offences the report prints. A first run against a large codebase can find a thousand, and a thousand rows is a wall rather than a report. The cap is on what is shown and never on what is counted: the summary, the omitted count and the exit code all see every offence. Use 0 for no limit. Option rather than a defaulted value so that “not passed” is distinguishable from “passed the default”: without that, a stern4rust.toml could never set the threshold, because every run would look like the reader had asked for 100 on the command line.

list_rules: bool

List every rule with a line saying what it wants, a scrap of source that breaks it and the same scrap put right, then exit without scanning. Answers the question a first run raises – what does this rule actually want – without needing a codebase to ask it against.

rules: Vec<String>

Apply only these rules; repeatable. Omit to apply every rule. Naming one makes the selection a whitelist, which is what lets a codebase facing hundreds of offences gate on one rule today and the rest as it goes.

fix: bool

Repair what can be repaired mechanically, then report what is left. Only test-file-structure offences are fixable today: item order, section order and blank lines. Everything else is reported unchanged, and the report says how many offences were fixed and how many were not.

baseline: Option<PathBuf>

Offences recorded here are not reported and do not fail the run. What lets a codebase with hundreds of existing offences enforce every rule against new code without first fixing the old. The count of suppressed offences is always in the summary, never hidden.

write_baseline: bool

Record the current offences as the baseline and exit clean, instead of judging against one. Writes to –baseline, or to stern4rust-baseline.json beside the manifest.

excludes: Vec<String>

Keep these paths out of the run; repeatable, matched as a glob against the package-relative path. For a tree the repository cannot move – vendored source, generated output. Every pattern is named in the report with how many files it removed, including zero, so an exclusion is something the reader can see rather than a silence.

skipped_rules: Vec<String>

Do not apply these rules; repeatable. Subtracted from whatever –rule selected, so skipping wins over selecting.

Implementations

impl Args

pub fn without_cargo_subcommand<I>(args: I) -> Vec<String>

where I: IntoIterator<Item = String>,

Cargo invokes cargo stern4rust as cargo-stern4rust stern4rust ..., so the subcommand name arrives as an extra leading argument that clap would otherwise reject. Running the binary directly does not repeat it, which is why the strip is conditional rather than unconditional.

Trait Implementations

impl Args for Args

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl Clone for Args

fn clone(&self) -> Args

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CommandFactory for Args

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for Args

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Args

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Args

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.