Struct git_credentials::protocol::Context

pub struct Context {
    pub protocol: Option<String>,
    pub host: Option<String>,
    pub path: Option<BString>,
    pub username: Option<String>,
    pub password: Option<String>,
    pub url: Option<BString>,
    pub quit: Option<bool>,
}

Additional context to be passed to the credentials helper.

Fields

protocol: Option<String>

The protocol over which the credential will be used (e.g., https).

host: Option<String>

The remote hostname for a network credential. This includes the port number if one was specified (e.g., “example.com:8088”).

path: Option<BString>

The path with which the credential will be used. E.g., for accessing a remote https repository, this will be the repository’s path on the server. It can also be a path on the file system.

username: Option<String>

The credential’s username, if we already have one (e.g., from a URL, the configuration, the user, or from a previously run helper).

password: Option<String>

The credential’s password, if we are asking it to be stored.

url: Option<BString>

When this special attribute is read by git credential, the value is parsed as a URL and treated as if its constituent parts were read (e.g., url=https://example.com would behave as if protocol=https and host=example.com had been provided). This can help callers avoid parsing URLs themselves.

quit: Option<bool>

If true, the caller should stop asking for credentials immediately without calling more credential helpers in the chain.

Implementations

impl Context

pub fn to_url(&self) -> Option<BString>

Convert all relevant fields into a URL for consumption.

pub fn to_prompt(&self, field: &str) -> String

Compute a prompt to obtain the given value.

impl Context

In-place mutation

pub fn destructure_url_in_place(
    &mut self,
    use_http_path: bool
) -> Result<&mut Self, Error>

Destructure the url at our url field into parts like protocol, host, username and path and store them in our respective fields. If use_http_path is set, http paths are significant even though normally this isn’t the case.

impl Context

pub fn write_to(&self, out: impl Write) -> Result<()>

Write ourselves to out such that from_bytes() can decode it losslessly.

Examples found in repository

examples/invoke-git-credential.rs (line 12)

pub fn main() -> Result<(), Box<dyn std::error::Error>> {
    let out = git_credentials::builtin(git_credentials::helper::Action::get_for_url(
        std::env::args()
            .nth(1)
            .ok_or("First argument must be the URL to obtain credentials for")?,
    ))?
    .ok_or("Did not obtain credentials")?;
    let ctx: git_credentials::protocol::Context = (&out.next).try_into()?;
    ctx.write_to(std::io::stdout())?;
    Ok(())
}

pub fn to_bstring(&self) -> BString

Like write_to(), but writes infallibly into memory.

Examples found in repository

examples/git-credential-lite.rs (line 15)

pub fn main() -> Result<(), git_credentials::program::main::Error> {
    git_credentials::program::main(
        std::env::args_os().skip(1),
        std::io::stdin(),
        std::io::stdout(),
        |action, context| {
            use git_credentials::program::main::Action::*;
            git_credentials::helper::Cascade::default()
                .invoke(
                    match action {
                        Get => git_credentials::helper::Action::Get(context),
                        Erase => git_credentials::helper::Action::Erase(context.to_bstring()),
                        Store => git_credentials::helper::Action::Store(context.to_bstring()),
                    },
                    git_prompt::Options::default().apply_environment(true, true, true),
                )
                .map(|outcome| outcome.and_then(|outcome| (&outcome.next).try_into().ok()))
        },
    )
}

impl Context

pub fn from_bytes(input: &[u8]) -> Result<Self, Error>

Decode ourselves from input which is the format written by write_to().

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Context

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

Formats the value using the given formatter.

impl Default for Context

fn default() -> Context

Returns the “default value” for a type.

impl From<Context> for NextAction

fn from(ctx: Context) -> Self

Converts to this type from the input type.

impl PartialEq<Context> for Context

fn eq(&self, other: &Context) -> 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 TryFrom<&NextAction> for Context

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &NextAction) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for Context

impl StructuralEq for Context

impl StructuralPartialEq for Context