Struct radicle_surf::Repository

pub struct Repository { /* private fields */ }

Represents the state associated with a Git repository.

Many other types in this crate are derived from methods in this struct.

Implementations

impl Repository

pub fn open(repo_uri: impl AsRef<Path>) -> Result<Self, Error>

Open a git repository given its exact URI.

Errors

• Error::Git

Examples found in repository

examples/diff.rs (line 50)

fn init_repository_or_exit(path_to_repo: &str) -> Repository {
    match Repository::open(path_to_repo) {
        Ok(repo) => repo,
        Err(e) => {
            println!("Failed to create repository: {e:?}");
            std::process::exit(1);
        }
    }
}

pub fn discover(repo_uri: impl AsRef<Path>) -> Result<Self, Error>

Attempt to open a git repository at or above repo_uri in the file system.

Examples found in repository

examples/browsing.rs (line 41)

fn main() {
    let repo_path = match env::args().nth(1) {
        Some(path) => path,
        None => {
            print_usage();
            return;
        }
    };
    let repo = Repository::discover(repo_path).unwrap();
    let now = Instant::now();
    let head = repo.head().unwrap();
    let root = repo.root_dir(head).unwrap();
    print_directory(&root, &repo, 0);

    let elapsed_millis = now.elapsed().as_millis();
    println!("browse with print: {elapsed_millis} ms");
}

pub fn which_namespace(&self) -> Result<Option<Namespace>, Error>

What is the current namespace we’re browsing in.

pub fn switch_namespace(&self, namespace: &RefString) -> Result<(), Error>

Switch to a namespace

pub fn with_namespace<T, F>( &self, namespace: &RefString, f: F ) -> Result<T, Error>

where F: FnOnce() -> Result<T, Error>,

pub fn branches<G>(&self, pattern: G) -> Result<Branches<'_>, Error>

where G: Into<Glob<Branch>>,

Returns an iterator of branches that match pattern.

pub fn branch_names<G>(&self, filter: G) -> Result<BranchNames<'_>, Error>

where G: Into<Glob<Branch>>,

Lists branch names with filter.

pub fn tags(&self, pattern: &Glob<Tag>) -> Result<Tags<'_>, Error>

Returns an iterator of tags that match pattern.

pub fn tag_names(&self, filter: &Glob<Tag>) -> Result<TagNames<'_>, Error>

Lists tag names in the local RefScope.

pub fn categories( &self, pattern: &Glob<Qualified<'_>> ) -> Result<Categories<'_>, Error>

pub fn namespaces(&self, pattern: &Glob<Namespace>) -> Result<Namespaces, Error>

Returns an iterator of namespaces that match pattern.

pub fn diff( &self, from: impl Revision, to: impl Revision ) -> Result<Diff, Error>

Get the Diff between two commits.

Examples found in repository

examples/diff.rs (line 35)

fn main() {
    let options = get_options_or_exit();
    let repo = init_repository_or_exit(&options.path_to_repo);
    let head_oid = match options.head_revision {
        HeadRevision::Head => repo.head().unwrap(),
        HeadRevision::Commit(id) => Oid::from_str(&id).unwrap(),
    };
    let base_oid = Oid::from_str(&options.base_revision).unwrap();
    let now = Instant::now();
    let elapsed_nanos = now.elapsed().as_nanos();
    let diff = repo.diff(base_oid, head_oid).unwrap();
    print_diff_summary(&diff, elapsed_nanos);
}

pub fn diff_commit(&self, commit: impl ToCommit) -> Result<Diff, Error>

Get the Diff of a commit.

If the commit has a parent, then it the diff will be a comparison between itself and that parent. Otherwise, the left hand side of the diff will pass nothing.

pub fn diff_file<P: AsRef<Path>, R: Revision>( &self, path: &P, from: R, to: R ) -> Result<FileDiff, Error>

Get the FileDiff between two revisions for a file at path.

If path is only a directory name, not a file, returns a FileDiff for any file under path.

pub fn oid(&self, oid: &str) -> Result<Oid, Error>

Parse an Oid from the given string.

pub fn root_dir<C: ToCommit>(&self, commit: C) -> Result<Directory, Error>

Returns a top level Directory without nested sub-directories.

To visit inside any nested sub-directories, call directory.get(&repo) on the sub-directory.

Examples found in repository

examples/browsing.rs (line 44)

fn main() {
    let repo_path = match env::args().nth(1) {
        Some(path) => path,
        None => {
            print_usage();
            return;
        }
    };
    let repo = Repository::discover(repo_path).unwrap();
    let now = Instant::now();
    let head = repo.head().unwrap();
    let root = repo.root_dir(head).unwrap();
    print_directory(&root, &repo, 0);

    let elapsed_millis = now.elapsed().as_millis();
    println!("browse with print: {elapsed_millis} ms");
}

pub fn directory<C: ToCommit, P: AsRef<Path>>( &self, commit: C, path: &P ) -> Result<Directory, Error>

Returns a Directory for path in commit.

pub fn file<C: ToCommit, P: AsRef<Path>>( &self, commit: C, path: &P ) -> Result<File, Error>

Returns a File for path in commit.

pub fn tree<C: ToCommit, P: AsRef<Path>>( &self, commit: C, path: &P ) -> Result<Tree, Error>

Returns a Tree for path in commit.

pub fn blob<'a, C: ToCommit, P: AsRef<Path>>( &'a self, commit: C, path: &P ) -> Result<Blob<BlobRef<'a>>, Error>

Returns a Blob for path in commit.

pub fn blob_ref(&self, oid: Oid) -> Result<BlobRef<'_>, Error>

pub fn last_commit<P, C>( &self, path: &P, rev: C ) -> Result<Option<Commit>, Error>

where P: AsRef<Path>, C: ToCommit,

Returns the last commit, if exists, for a path in the history of rev.

pub fn commit<R: Revision>(&self, rev: R) -> Result<Commit, Error>

Returns a commit for rev, if it exists.

pub fn stats(&self) -> Result<Stats, Error>

Gets the Stats of this repository starting from the HEAD (see Repository::head) of the repository.

pub fn stats_from<R>(&self, rev: &R) -> Result<Stats, Error>

where R: Revision,

Gets the Stats of this repository starting from the given rev.

pub fn get_commit_file<P, R>( &self, rev: &R, path: &P ) -> Result<FileContent<'_>, Error>

where P: AsRef<Path>, R: Revision,

Retrieves the file with path in this commit.

pub fn head(&self) -> Result<Oid, Error>

Returns the Oid of the current HEAD.

Examples found in repository

examples/browsing.rs (line 43)

fn main() {
    let repo_path = match env::args().nth(1) {
        Some(path) => path,
        None => {
            print_usage();
            return;
        }
    };
    let repo = Repository::discover(repo_path).unwrap();
    let now = Instant::now();
    let head = repo.head().unwrap();
    let root = repo.root_dir(head).unwrap();
    print_directory(&root, &repo, 0);

    let elapsed_millis = now.elapsed().as_millis();
    println!("browse with print: {elapsed_millis} ms");
}

examples/diff.rs (line 29)

fn main() {
    let options = get_options_or_exit();
    let repo = init_repository_or_exit(&options.path_to_repo);
    let head_oid = match options.head_revision {
        HeadRevision::Head => repo.head().unwrap(),
        HeadRevision::Commit(id) => Oid::from_str(&id).unwrap(),
    };
    let base_oid = Oid::from_str(&options.base_revision).unwrap();
    let now = Instant::now();
    let elapsed_nanos = now.elapsed().as_nanos();
    let diff = repo.diff(base_oid, head_oid).unwrap();
    print_diff_summary(&diff, elapsed_nanos);
}

pub fn extract_signature( &self, commit: impl ToCommit, field: Option<&str> ) -> Result<Option<Signature>, Error>

Extract the signature from a commit

Arguments

field - the name of the header field containing the signature block; pass None to extract the default ‘gpgsig’

pub fn history<C: ToCommit>(&self, head: C) -> Result<History<'_>, Error>

Returns the history with the head commit.

pub fn revision_branches( &self, rev: impl Revision, glob: Glob<Branch> ) -> Result<Vec<Branch>, Error>

Lists branches that are reachable from rev.

Trait Implementations

impl Debug for Repository

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

Formats the value using the given formatter.

impl From<Repository> for Repository

fn from(repo: Repository) -> Self

Converts to this type from the input type.