Struct cucumber::cli::Compose

pub struct Compose<L: Args, R: Args> {
    pub left: L,
    pub right: R,
}

Composes two clap::Args derivers together.

Example

This struct is especially useful, when implementing custom Writer wrapping another one:

struct CustomWriter<Wr>(Wr);

#[derive(cli::Args)] // re-export of `clap::Args`
struct Cli {
    #[arg(long)]
    custom_option: Option<String>,
}

#[async_trait(?Send)]
impl<W, Wr> Writer<W> for CustomWriter<Wr>
where
    W: World,
    Wr: Writer<W>,
{
    type Cli = cli::Compose<Cli, Wr::Cli>;

    async fn handle_event(
        &mut self,
        ev: parser::Result<Event<event::Cucumber<W>>>,
        cli: &Self::Cli,
    ) {
        // Some custom logic including `cli.left.custom_option`.
        // ...
        self.0.handle_event(ev, &cli.right).await;
    }
}

// Useful blanket impls:

impl cli::Colored for Cli {}

#[async_trait(?Send)]
impl<'val, W, Wr, Val> writer::Arbitrary<'val, W, Val> for CustomWriter<Wr>
where
    Wr: writer::Arbitrary<'val, W, Val>,
    Val: 'val,
    Self: Writer<W>,
{
    async fn write(&mut self, val: Val)
    where
        'val: 'async_trait,
    {
        self.0.write(val).await;
    }
}

impl<W, Wr> writer::Stats<W> for CustomWriter<Wr>
where
    Wr: writer::Stats<W>,
    Self: Writer<W>,
{
    fn passed_steps(&self) -> usize {
        self.0.failed_steps()
    }

    fn skipped_steps(&self) -> usize {
        self.0.failed_steps()
    }

    fn failed_steps(&self) -> usize {
        self.0.failed_steps()
    }

    fn retried_steps(&self) -> usize {
        self.0.retried_steps()
    }

    fn parsing_errors(&self) -> usize {
        self.0.parsing_errors()
    }

    fn hook_errors(&self) -> usize {
        self.0.hook_errors()
    }
}

impl<Wr: writer::Normalized> writer::Normalized for CustomWriter<Wr> {}

impl<Wr: writer::NonTransforming> writer::NonTransforming
    for CustomWriter<Wr>
{}

Fields

left: L

Left clap::Args deriver.

right: R

Right clap::Args deriver.

Implementations

impl<L: Args, R: Args> Compose<L, R>

pub fn into_inner(self) -> (L, R)

Unpacks this Compose into the underlying CLIs.

Trait Implementations

impl<L: Args, R: Args> Args for Compose<L, R>

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.

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

Append to Command so it can update self.

impl<L: Clone + Args, R: Clone + Args> Clone for Compose<L, R>

fn clone(&self) -> Compose<L, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L, R> Colored for Compose<L, R>where
    L: Args + Colored,
    R: Args + Colored,

fn coloring(&self) -> Coloring

Returns Coloring indicating whether a Writer using CLI options supports colored output or not.

impl<L: Debug + Args, R: Debug + Args> Debug for Compose<L, R>

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

Formats the value using the given formatter.

impl<L: Default + Args, R: Default + Args> Default for Compose<L, R>

fn default() -> Compose<L, R>

Returns the “default value” for a type.

impl<L: Args, R: Args> FromArgMatches for Compose<L, R>

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<L: Copy + Args, R: Copy + Args> Copy for Compose<L, R>