Struct git_repository::Remote

pub struct Remote<'repo> { /* private fields */ }

A remote which represents a way to interact with hosts for remote clones of the parent repository.

Implementations

impl Remote<'_>

Builder methods

pub fn push_url<Url, E>(self, url: Url) -> Result<Self, Error>where
    Url: TryInto<Url, Error = E>,
    Error: From<E>,

Set the url to be used when pushing data to a remote.

pub fn push_url_without_url_rewrite<Url, E>(
    self,
    url: Url
) -> Result<Self, Error>where
    Url: TryInto<Url, Error = E>,
    Error: From<E>,

Set the url to be used when pushing data to a remote, without applying rewrite rules in case these could be faulty, eliminating one failure mode.

pub fn with_refspec<'a>(
    self,
    spec: impl Into<&'a BStr>,
    direction: Direction
) -> Result<Self, Error>

Add spec as refspec for direction to our list if it’s unique.

impl<'repo> Remote<'repo>

Establishing connections to remote hosts (without performing a git-handshake).

pub fn to_connection_with_transport<T, P>(
    &self,
    transport: T,
    progress: P
) -> Connection<'_, 'repo, T, P>where
    T: Transport,
    P: Progress,

Available on crate features async-network-client or blocking-network-client only.

Create a new connection using transport to communicate, with progress to indicate changes.

Note that this method expects the transport to be created by the user, which would involve the url(). It’s meant to be used when async operation is needed with runtimes of the user’s choice.

pub fn connect<P>(
    &self,
    direction: Direction,
    progress: P
) -> Result<Connection<'_, 'repo, Box<dyn Transport + Send>, P>, Error>where
    P: Progress,

Available on (crate features async-network-client or blocking-network-client) and (crate features blocking-network-client or async-network-client-async-std) only.

Connect to the url suitable for direction and return a handle through which operations can be performed.

Note that the protocol.version configuration key affects the transport protocol used to connect, with 2 being the default.

The transport used for connection can be configured via transport_mut().configure() assuming the actually used transport is well known. If that’s not the case, the transport can be created by hand and passed to to_connection_with_transport().

pub fn sanitized_url_and_version(
    &self,
    direction: Direction
) -> Result<(Url, Protocol), Error>

Available on crate features async-network-client or blocking-network-client only.

Produce the sanitized URL and protocol version to use as obtained by querying the repository configuration.

This can be useful when using custom transports to allow additional configuration.

impl Remote<'_>

Serialize into git-config.

pub fn save_to(&self, config: &mut File<'static>) -> Result<(), Error>

Save ourselves to the given config if we are a named remote or fail otherwise.

Note that all sections named remote "<name>" will be cleared of all values we are about to write, and the last remote "<name>" section will be containing all relevant values so that reloading the remote from config would yield the same in-memory state.

pub fn save_as_to(
    &mut self,
    name: impl Into<String>,
    config: &mut File<'static>
) -> Result<(), AsError>

Forcefully set our name to name and write our state to config similar to save_to().

Note that this sets a name for anonymous remotes, but overwrites the name for those who were named before. If this name is different from the current one, the git configuration will still contain the previous name, and the caller should account for that.

impl<'repo> Remote<'repo>

Access

pub fn name(&self) -> Option<&str>

Return the name of this remote or None if it wasn’t persisted to disk yet.

pub fn repo(&self) -> &'repo Repository

Return our repository reference.

pub fn refspecs(&self, direction: Direction) -> &[RefSpec]

Return the set of ref-specs used for direction, which may be empty, in order of occurrence in the configuration.

pub fn url(&self, direction: Direction) -> Option<&Url>

Return the url used for the given direction with rewrites from url.<base>.insteadOf|pushInsteadOf, unless the instance was created with one of the _without_url_rewrite() methods. For pushing, this is the remote.<name>.pushUrl or the remote.<name>.url used for fetching, and for fetching it’s the remote.<name>.url. Note that it’s possible to only have the push url set, in which case there will be no way to fetch from the remote as the push-url isn’t used for that.

impl Remote<'_>

Modification

pub fn rewrite_urls(&mut self) -> Result<&mut Self, Error>

Read url.<base>.insteadOf|pushInsteadOf configuration variables and apply them to our urls, changing them in place.

This happens only once, and one if them may be changed even when reporting an error. If both urls fail, only the first error (for fetch urls) is reported.

pub fn replace_refspecs<Spec>(
    &mut self,
    specs: impl IntoIterator<Item = Spec>,
    direction: Direction
) -> Result<(), Error>where
    Spec: AsRef<BStr>,

Replace all currently set refspecs, typically from configuration, with the given specs for direction, or None if one of the input specs could not be parsed.

Trait Implementations

impl<'repo> Clone for Remote<'repo>

fn clone(&self) -> Remote<'repo>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'repo> Debug for Remote<'repo>

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

Formats the value using the given formatter.

impl<'repo> PartialEq<Remote<'repo>> for Remote<'repo>

fn eq(&self, other: &Remote<'repo>) -> 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<'repo> StructuralPartialEq for Remote<'repo>