# radicle-surf

Welcome to `radicle-surf`!

## Contributing

Join our community disccussions at [radicle.community](https://radicle.community)!

# Example

To a taste for the capabilities of `radicle-surf` we provide an example below, but we also

keep our documentation and doc-tests up to date.

    .iter()

    {

        group.bench_with_input(BenchmarkId::new("", path), path, |b, path| {

        });

    }

}

use radicle_surf::{

    file_system::{Directory, DirectoryEntry},

};

use std::{env, time::Instant};

        },

    };

    let repo = Repository::discover(&repo_path).unwrap();

    let now = Instant::now();

    let head = repo.head_oid().unwrap();

    let root = repo.root_dir(head).unwrap();

    println!("browse with print: {} ms", elapsed_millis);

}

    let indent = " ".repeat(indent_level * 4);

    println!("{}{}/", &indent, d.name());

    for entry in d.contents(repo).unwrap().iter() {

    let options = get_options_or_exit();

    let repo = init_repository_or_exit(&options.path_to_repo);

    let head_oid = match options.head_revision {

        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();

    print_diff_summary(&diff, elapsed_nanos);

}

use crate::{

    diff,

    file_system,

    person::Person,

    revision::Revision,

};

///

/// Will return [`Error`] if the project doesn't exist or the surf interaction

/// fails.

    let commit = repo.commit(rev)?;

    let sha1 = commit.id;

    let header = Header::from(&commit);

///

/// Will return [`Error`] if the project doesn't exist or the surf interaction

/// fails.

    let commit = repo.commit(sha1)?;

    Ok(Header::from(&commit))

}

///

/// Will return [`Error`] if the project doesn't exist or the surf interaction

/// fails.

    let rev = match maybe_revision {

        Some(revision) => revision,

        None => Revision::Sha {

use crate::{

    file_system::{Directory, Path},

};

pub mod git;

    // TODO: Direction of comparison is not obvious with this signature.

    // For now using conventional approach with the right being "newer".

    #[allow(clippy::self_named_constructors)]

        // TODO: Some of the deleted files may actually be moved (renamed) to one of the

        // created files. Finding out which of the deleted files were deleted

        // and which were moved will probably require performing some variant of

use crate::{

    file_system::{error::LabelError, path::*, Error},

};

use git2::Blob;

use radicle_git_ext::Oid;

    }

    /// Returns a `DirectoryContent` for the current directory.

        let listing = repo.directory_get(self)?;

        Ok(DirectoryContent { listing })

    }

    pub fn get_path(

        &self,

        path: &path::Path,

    ) -> Result<DirectoryEntry, git::Error> {

        // Search the path in git2 tree.

        let entry = git2_tree.get_path(path)?;

        // Construct the DirectoryEntry.

    /// // We shouldn't be able to find a file that doesn't exist

    /// assert_eq!(directory.find_file(unsound::path::new("foo/bar/qux.rs")), None);

    /// ```

        let path_buf: std::path::PathBuf = (&path).into();

        let entry = match self.get_path(path_buf.as_path(), repo) {

            Ok(entry) => entry,

    /// // 'baz.rs' is a file and not a directory

    /// assert!(directory.find_directory(unsound::path::new("foo/bar/baz.rs")).is_none());

    /// ```

        let path_buf: std::path::PathBuf = (&path).into();

        let entry = match self.get_path(path_buf.as_path(), repo) {

            Ok(entry) => entry,

    /// Get the total size, in bytes, of a `Directory`. The size is

    /// the sum of all files that can be reached from this `Directory`.

        let mut size = 0;

        let contents = self.contents(repo)?;

        for item in contents.iter() {

impl Revision for Directory {

    type Error = Infallible;

        Ok(self.oid)

    }

}

pub use radicle_git_ext::Oid;

mod repo;

pub mod glob;

pub use glob::Glob;

    type Error: std::error::Error + Send + Sync + 'static;

    /// Returns the object id of this revision in `repo`.

}

impl Revision for RefString {

    type Error = git2::Error;

    }

}

impl Revision for &RefString {

    type Error = git2::Error;

    }

}

impl Revision for Qualified<'_> {

    type Error = git2::Error;

    }

}

impl Revision for &Qualified<'_> {

    type Error = git2::Error;

    }

}

impl Revision for Oid {

    type Error = Infallible;

        Ok(*self)

    }

}

impl Revision for &str {

    type Error = git2::Error;

        Oid::from_str(self).map(Oid::from)

    }

}

impl Revision for &Branch {

    type Error = Error;

        let refname = repo.namespaced_refname(&self.refname())?;

    }

}

impl Revision for &Tag {

    type Error = Infallible;

        Ok(self.id())

    }

}

    type Error: std::error::Error + Send + Sync + 'static;

    /// Converts to a commit in `repo`.

}

impl ToCommit for Commit {

    type Error = Infallible;

        Ok(self)

    }

}

impl<R: Revision> ToCommit for R {

    type Error = Error;

        let oid = repo.object_id(&self)?;

        Ok(Commit::try_from(commit)?)

    }

}

use crate::{

    file_system,

};

use std::convert::TryFrom;

/// An iterator that produces the history of commits for a given `head`,

/// in the `repo`.

pub struct History<'a> {

    head: Commit,

    revwalk: git2::Revwalk<'a>,

    filter_by: Option<FilterBy>,

impl<'a> History<'a> {

    /// Creates a new history starting from `head`, in `repo`.

        let head = head

            .map_err(|err| Error::ToCommit(err.into()))?;

        revwalk.push(head.id.into())?;

        let history = Self {

            repo,

            let found = oid

                .map_err(Error::Git)

                .and_then(|oid| {

                    // Handles the optional filter_by.

                    if let Some(FilterBy::File { path }) = &self.filter_by {

/// Wrapper around the `git2`'s `git2::Repository` type.

/// This is to to limit the functionality that we can do

/// on the underlying object.

}

    /// What is the current namespace we're browsing in.

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

            .namespace_bytes()

            .map(|ns| Namespace::try_from(ns).map_err(Error::from))

            .transpose()

        let mut branches = Branches::default();

        for glob in pattern.globs() {

            let namespaced = self.namespaced_pattern(glob)?;

            branches.push(references);

        }

        Ok(branches)

        let mut tags = Tags::default();

        for glob in pattern.globs() {

            let namespaced = self.namespaced_pattern(glob)?;

            tags.push(references);

        }

        Ok(tags)

        let mut set = BTreeSet::new();

        for glob in pattern.globs() {

            let new_set = self

                .references_glob(glob)?

                .map(|reference| {

                    reference

    /// Parse an [`Oid`] from the given string.

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

    }

    /// Returns a top level `Directory` without nested sub-directories.

        let commit = commit

            .to_commit(self)

            .map_err(|err| Error::ToCommit(err.into()))?;

        let tree = git2_commit.as_object().peel_to_tree()?;

        Ok(Directory {

            name: Label::root(),

        &self,

        d: &Directory,

    ) -> Result<BTreeMap<Label, DirectoryEntry>, Error> {

        let map = self.tree_first_level(git2_tree)?;

        Ok(map)

    }

    /// Obtain the file content

    pub(crate) fn file_content(&self, object_id: Oid) -> Result<FileContent, Error> {

        Ok(FileContent::new(blob))

    }

    /// Return the size of a file

    pub(crate) fn file_size(&self, oid: Oid) -> Result<usize, Error> {

        Ok(blob.size())

    }

        let commit = self.get_git2_commit(id)?;

        let tree = commit.tree()?;

        let entry = tree.get_path(PathBuf::from(&path).as_ref())?;

        let blob = object.into_blob().map_err(|_| Error::PathNotFound(path))?;

        Ok(FileContent::new(blob))

    }

    /// Returns the Oid of the current HEAD

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

        let head_commit = head.peel_to_commit()?;

        Ok(head_commit.id().into())

    }

    /// Switch to a `namespace`

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

    }

    /// Returns a full reference name with namespace(s) included.

        &'a self,

        refname: &Qualified<'a>,

    ) -> Result<Qualified<'a>, Error> {

    }

    /// Returns a full reference name with namespace(s) included.

        &'a self,

        refname: &QualifiedPattern<'a>,

    ) -> Result<QualifiedPattern<'a>, Error> {

    /// Get a particular `git2::Commit` of `oid`.

    pub(crate) fn get_git2_commit(&self, oid: Oid) -> Result<git2::Commit, Error> {

    }

    /// Extract the signature from a commit

        // git_commit_extract_signature at

        // https://libgit2.org/libgit2/#HEAD/group/commit/git_commit_extract_signature

        // the return value for a commit without a signature will be GIT_ENOTFOUND

            Err(error) => {

                if error.code() == git2::ErrorCode::NotFound {

                    Ok(None)

        for branch in self.branches(&glob)? {

            let branch = branch?;

            let namespaced = self.namespaced_refname(&branch.refname())?;

            if self.reachable_from(&reference, oid)? {

                contained_branches.push(branch);

            }

    fn reachable_from(&self, reference: &git2::Reference, oid: &Oid) -> Result<bool, Error> {

        let git2_oid = (*oid).into();

        let other = reference.peel_to_commit()?.id();

        Ok(other == git2_oid || is_descendant)

    }

        }

        let mut diff =

                .diff_tree_to_tree(old_tree.as_ref(), Some(&new_tree), Some(&mut opts))?;

        // Detect renames by default.

    /// Returns the history with the `head` commit.

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

    }

    pub(super) fn object_id<R: Revision>(&self, r: &R) -> Result<Oid, Error> {

        r.object_id(self).map_err(|err| Error::Revision(err.into()))

    }

    /// Open a git repository given its exact URI.

    ///

    /// # Errors

    ///

    /// * [`Error::Git`]

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

    }

    /// Attempt to open a git repository at or above `repo_uri` in the file

    /// system.

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

    }

    }

}

impl From<git2::Repository> for Repository {

    fn from(repo: git2::Repository) -> Self {

    }

}

//

// Copyright (C) 2019-2020 The Radicle Team <dev@radicle.xyz>

//

//! Welcome to `radicle-surf`!

//!

//!

//! Let's start surfing (and apologies for the `expect`s):

//!

//! ```

//! use radicle_surf::file_system::{Label, Path, SystemType};

//! use radicle_surf::file_system::unsound;

//! use pretty_assertions::assert_eq;

//!

//! # fn main() -> Result<(), Box<dyn Error>> {

//! // We're going to point to this repo.

//!

//! // Get the snapshot of the directory for our current HEAD of history.

//!

//! // Let's get a Path to the memory.rs file

//! let memory = unsound::path::new("src/memory.rs");

use crate::{

    commit,

    file_system,

    object::{Error, Info, ObjectType},

    revision::Revision,

};

/// Will return [`Error`] if the project doesn't exist or a surf interaction

/// fails.

pub fn blob(

    maybe_revision: Option<Revision>,

    path: &str,

) -> Result<Blob, Error> {

}

fn make_blob<C>(

    maybe_revision: Option<Revision>,

    path: &str,

    content: C,

use crate::{

    commit,

    file_system::{self, DirectoryEntry},

    object::{Error, Info, ObjectType},

    revision::Revision,

};

///

/// Will return [`Error`] if any of the surf interactions fail.

pub fn tree(

    maybe_revision: Option<Revision>,

    maybe_prefix: Option<String>,

) -> Result<Tree, Error> {

use radicle_git_ext::Oid;

/// Types of a peer.

pub enum Category<P, U> {

impl git::Revision for &Revision {

    type Error = git2::Error;

        match self {

            Revision::Tag { name } => match name.qualified() {

                None => Qualified::from(lit::refs_tags(name)).object_id(repo),

/// # Errors

///

///   * If we cannot get the branches from the `Browser`

where

    P: Clone + ToString,

{

/// # Errors

///

///   * If we cannot get the branches from the `Browser`

where

    P: Clone + ToString,

{

/// # Errors

///

///   * If we cannot get the branches from the `Browser`

where

    P: Clone + ToString,

{

    #[test]

    fn directory_get_path() {

        let repo = Repository::open(GIT_PLATINUM).unwrap();

        let root = repo.root_dir(&Branch::local(refname!("master"))).unwrap();

        // get_path for a file.

    #[test]

    fn directory_size() {

        let repo = Repository::open(GIT_PLATINUM).unwrap();

        let root = repo.root_dir(&Branch::local(refname!("master"))).unwrap();

        /*

    use git_ref_format::refname;

    let repo = Repository::discover(".").unwrap();

}

#[cfg(test)]

    #[test]

    fn switch_to_banana() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let history_master = repo.history(&Branch::local(refname!("master")))?;

        repo.switch_namespace("golden")?;

        let history_banana = repo.history(&Branch::local(refname!("banana")))?;

    #[test]

    fn me_namespace() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let history = repo.history(&Branch::local(refname!("master")))?;

        assert_eq!(repo.which_namespace().unwrap(), None);

    #[test]

    fn golden_namespace() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let history = repo.history(&Branch::local(refname!("master")))?;

        assert_eq!(repo.which_namespace().unwrap(), None);

    #[test]

    fn silver_namespace() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let history = repo.history(&Branch::local(refname!("master")))?;

        assert_eq!(repo.which_namespace().unwrap(), None);

    #[test]

    fn _master() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let mut history =

            repo.history(&Branch::remote(component!("origin"), refname!("master")))?;

    #[test]

    fn commit() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let rev = Oid::from_str("3873745c8f6ffb45c990eb23b491d4b4b6182f95")?;

        let mut history = repo.history(rev)?;

    #[test]

    fn commit_parents() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let rev = Oid::from_str("3873745c8f6ffb45c990eb23b491d4b4b6182f95")?;

        let history = repo.history(rev)?;

        let commit = history.head();

    #[test]

    fn commit_short() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let rev = repo.oid("3873745c8")?;

        let mut history = repo.history(rev)?;

    #[test]

    fn tag() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let rev = refname!("refs/tags/v0.2.0");

        let history = repo.history(&rev)?;

        // memory.rs is commited later so it should not exist here.

        let memory_last_commit_oid = repo

            .last_commit(

                Path::with_root(&[unsound::label::new("src"), unsound::label::new("memory.rs")]),

                oid,

        // README.md exists in this commit.

        let readme_last_commit = repo

            .last_commit(Path::with_root(&[unsound::label::new("README.md")]), oid)

            .expect("Failed to get last commit")

            .map(|commit| commit.id);

        let expected_commit_id = Oid::from_str("f3a089488f4cfd1a240a9c01b3fcc4c34a4e97b2").unwrap();

        let folder_svelte = repo

            .last_commit(unsound::path::new("~/examples/Folder.svelte"), oid)

            .expect("Failed to get last commit")

            .map(|commit| commit.id);

        let expected_commit_id = Oid::from_str("2429f097664f9af0c5b7b389ab998b2199ffa977").unwrap();

        let nested_directory_tree_commit_id = repo

            .last_commit(

                unsound::path::new("~/this/is/a/really/deeply/nested/directory/tree"),

                oid,

        let expected_commit_id = Oid::from_str("a0dd9122d33dff2a35f564d564db127152c88e02").unwrap();

        let backslash_commit_id = repo

            .last_commit(unsound::path::new("~/special/faux\\path"), oid)

            .expect("Failed to get last commit")

            .map(|commit| commit.id);

        assert_eq!(backslash_commit_id, Some(expected_commit_id));

        let ogre_commit_id = repo

            .last_commit(unsound::path::new("~/special/👹👹👹"), oid)

            .expect("Failed to get last commit")

            .map(|commit| commit.id);

            .expect("Could not retrieve ./data/git-platinum as git repository");

        let rev = Branch::local(refname!("master"));

        let root_last_commit_id = repo

            .last_commit(Path::root(), &rev)

            .expect("Failed to get last commit")

            .map(|commit| commit.id);

        let expected_oid = repo

            .history(&Branch::local(refname!("master")))

            .unwrap()

            .head()

    fn binary_file() {

        let repo = Repository::open(GIT_PLATINUM)

            .expect("Could not retrieve ./data/git-platinum as git repository");

        let history = repo.history(&Branch::local(refname!("dev"))).unwrap();

        let file_commit = history.by_path(unsound::path::new("~/bin/cat")).next();

        assert!(file_commit.is_some());

    #[test]

    fn test_initial_diff() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let oid = Oid::from_str("d3464e33d75c75c99bfb90fa2e9d16efc0b7d0e3")?;

        let commit = repo.commit(oid).unwrap();

        assert!(commit.parents.is_empty());

    #[test]

    fn test_diff_of_rev() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let diff = repo.diff_from_parent("80bacafba303bf0cdf6142921f430ff265f25095")?;

        assert_eq!(diff.created.len(), 0);

        assert_eq!(diff.deleted.len(), 0);

    #[test]

    fn test_diff() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let oid = "80bacafba303bf0cdf6142921f430ff265f25095";

        let commit = repo.commit(oid).unwrap();

        let parent_oid = commit.parents.get(0).unwrap();

    #[test]

    fn test_branch_diff() -> Result<(), Error> {

        let repo = Repository::open(GIT_PLATINUM)?;

        let diff = repo.diff(

            &Branch::local(refname!("master")),

            &Branch::local(refname!("dev")),

        let shared_repo = Mutex::new(Repository::open(GIT_PLATINUM)?);

        let locked_repo: MutexGuard<Repository> = shared_repo.lock().unwrap();

        let mut branches = locked_repo

            .branches(&Glob::heads("*")?.and_remotes("*")?)?

            .collect::<Result<Vec<_>, _>>()?;

        branches.sort();

    #[test]

    fn test_branches() {

        let repo = Repository::open(GIT_PLATINUM).unwrap();

        let branches = repo.branches(&Glob::heads("*").unwrap()).unwrap();

        for b in branches {

            println!("{}", b.unwrap().refname());

    #[test]

    fn test_tag_snapshot() {

        let repo = Repository::open(GIT_PLATINUM).unwrap();

            .tags(&Glob::tags("*").unwrap())

            .unwrap()

            .collect::<Result<Vec<_>, _>>()

            .unwrap();

        assert_eq!(tags.len(), 6);

    }

    #[test]

    fn test_namespaces() {

        let repo = Repository::open(GIT_PLATINUM).unwrap();

        let namespaces = repo.namespaces(&Glob::namespaces("*").unwrap()).unwrap();

        assert_eq!(namespaces.count(), 3);

        let namespaces = repo

    use super::*;

    use git_ref_format::refname;

    #[test]

    fn iterate_root_dir_recursive() {

        let repo = Repository::open(GIT_PLATINUM).unwrap();

        let root_dir = repo.root_dir(&Branch::local(refname!("master"))).unwrap();

        let count = println_dir(&root_dir, &repo, 0);

        /// For sub-directories, will do Depth-First-Search and print

        /// recursively.

        /// Returns the number of items visited (i.e. printed)

            let mut count = 0;

            for item in dir.contents(repo).unwrap().iter() {

                println!("> {}{}", " ".repeat(indent_level * 4), &item.label());

    #[test]

    fn browse_repo_lazily() {

        let repo = Repository::open(GIT_PLATINUM).unwrap();

        let root_dir = repo.root_dir(&Branch::local(refname!("master"))).unwrap();

        let count = root_dir.contents(&repo).unwrap().iter().count();

        assert_eq!(count, 8);

        let count = traverse(&root_dir, &repo);

        assert_eq!(count, 36);

            let mut count = 0;

            for item in dir.contents(repo).unwrap().iter() {

                count += 1;

    #[test]

    fn test_file_history() {

        let repo = Repository::open(GIT_PLATINUM).unwrap();

        let history = repo.history(&Branch::local(refname!("dev"))).unwrap();

        let path = unsound::path::new("README.md");

        let mut file_history = history.by_path(path);