Enum RulesCommand 

pub enum RulesCommand {
    Report {
        state: Option<String>,
        class: Option<String>,
        namespace: Option<String>,
        findings: bool,
        check: bool,
    },
    Show {
        id: String,
    },
    Proves {
        id: String,
    },
}

The subcommands of majordomus rules.

Example

use majordomus_cli::cli::{Cli, Command, RulesCommand};
use clap::Parser;
let cli = Cli::try_parse_from(["majordomus", "rules", "show", "project.x"]).unwrap();
let Command::Rules(args) = cli.command else { panic!("not the rules command") };
assert!(matches!(args.command, RulesCommand::Show { .. }));

Variants

Report

Every rule against the proof there is for it

Fields

state: Option<String>

Only rules in this proof state (proven, inputs_unchanged, stale, gated, failing, not_run, reviewed, unrunnable, dangling, unproven)

class: Option<String>

Only rules of this class (blocking, advisory)

namespace: Option<String>

Only rules of this namespace (project, majordomus)

findings: bool

Only the rules whose declared class the proof does not support

check: bool

Exit 10 when a rule declares a class the proof does not support

Show

One rule: what proves it, what it depends on, and what is missing

Fields

id: String

The rule id, with or without its version

Proves

One test: every rule it proves, and the rules that would be left with none

Fields

id: String

suite:<case>, crate:<binary>, or the path a rule names it with

Trait Implementations

impl Debug for RulesCommand

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

Formats the value using the given formatter.

impl FromArgMatches for RulesCommand

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<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for RulesCommand

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

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

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

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

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand