Struct git_credentials::helper::Outcome

pub struct Outcome {
    pub username: Option<String>,
    pub password: Option<String>,
    pub quit: bool,
    pub next: NextAction,
}

The outcome of the credentials helper invocation.

Fields

username: Option<String>

The username to use in the identity, if set.

password: Option<String>

The username to use in the identity, if set.

quit: bool

If set, the helper asked to stop the entire process, whether the identity is complete or not.

next: NextAction

A handle to the action to perform next in another call to helper::invoke().

Implementations

impl Outcome

pub fn consume_identity(&mut self) -> Option<Account>

Try to fetch username and password to form an identity. This will fail if one of them is not set.

This does nothing if only one of the fields is set, or consume both.

Examples found in repository

src/protocol/mod.rs (line 70)

pub fn helper_outcome_to_result(outcome: Option<helper::Outcome>, action: helper::Action) -> Result {
    fn redact(mut ctx: Context) -> Context {
        if let Some(pw) = ctx.password.as_mut() {
            *pw = "<redacted>".into()
        }
        ctx
    }
    match (action, outcome) {
        (helper::Action::Get(ctx), None) => Err(Error::IdentityMissing { context: redact(ctx) }),
        (helper::Action::Get(ctx), Some(mut outcome)) => match outcome.consume_identity() {
            Some(identity) => Ok(Some(Outcome {
                identity,
                next: outcome.next,
            })),
            None => Err(if outcome.quit {
                Error::Quit
            } else {
                Error::IdentityMissing { context: redact(ctx) }
            }),
        },
        (helper::Action::Store(_) | helper::Action::Erase(_), _ignore) => Ok(None),
    }
}

Trait Implementations

impl Clone for Outcome

fn clone(&self) -> Outcome

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Outcome

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

Formats the value using the given formatter.

impl PartialEq<Outcome> for Outcome

fn eq(&self, other: &Outcome) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Outcome

impl StructuralEq for Outcome

impl StructuralPartialEq for Outcome