with:

          fetch-depth: 0

      # The 'main' branch is needed for radicle-surf vcs::git::tests::test_submodule_failure,

      - uses: actions-rs/toolchain@v1

        with:

          profile: minimal

      - uses: actions/checkout@master

        with:

          fetch-depth: 0

      - uses: actions-rs/toolchain@v1

        with:

          profile: minimal

extern crate radicle_surf;

use nonempty::NonEmpty;

use radicle_surf::{

    diff::Diff,

    file_system::Directory,

    vcs::git::{self, BranchName, Browser, Rev},

};

/// Commit statistics.

#[cfg_attr(feature = "serialize", derive(Serialize))]

#[derive(Clone)]

pub struct Header {

    /// Identifier of the commit in the form of a sha1 hash. Often referred to

    /// as oid or object id.

    /// The author of the commit.

    pub author: Person,

    /// The summary of the commit message body.

///

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

/// fails.

    browser.commit(sha1)?;

    let history = browser.get();

///

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

/// fails.

    browser.commit(sha1)?;

    let history = browser.get();

                },

                None => git::Branch::local(&name).into(),

            }),

        }

    }

}

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

//! use radicle_surf::vcs::git::*;

//! use std::collections::HashMap;

//! # use std::error::Error;

//!

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

//! ```

// Re-export git2 as sub-module

/// Provides ways of selecting a particular reference/revision.

mod reference;

    /// use nonempty::NonEmpty;

    /// use radicle_surf::vcs::History;

    /// use radicle_surf::vcs::git::{TagName, Branch, Browser, Oid, Repository};

    /// # use std::error::Error;

    ///

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

    /// ```

    /// use radicle_surf::vcs::git::{Branch, RefScope, Browser, Namespace, Oid, Repository, Tag, TagName, Author, Time};

    /// use std::convert::TryFrom;

    /// # use std::error::Error;

    ///

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

    ///

    /// ```

    /// use radicle_surf::vcs::git::{Branch, Browser, Repository, Oid, error};

    /// # use std::error::Error;

    ///

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

    /// ```

    /// use radicle_surf::vcs::git::{Browser, Repository, Branch, BranchName, Namespace, Oid};

    /// use std::convert::TryFrom;

    /// # use std::error::Error;

    ///

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

    /// ```

    pub fn revision_branches(&self, rev: impl Into<Rev>) -> Result<Vec<Branch>, Error> {

        let commit = self.repository.rev_to_commit(&rev.into())?;

    }

    /// Get the [`Stats`] of the underlying [`Repository`].

            Error,

        > = Ok(HashMap::new());

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

        tree.walk(

    ///

    /// See [`git2::Repository::merge_base`] for details.

    pub fn merge_base(&self, one: Oid, two: Oid) -> Result<Option<Oid>, Error> {

            Err(err) => {

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

                    Ok(None)

    #[cfg(test)]

    mod rev {

        use super::{Branch, Browser, Error, Oid, Repository, TagName};

        // **FIXME**: This seems to break occasionally on

        // buildkite. For some reason the commit

            file_system::{unsound, Path},

            vcs::git::{Branch, Browser, Oid, Repository},

        };

        #[test]

        fn readme_missing_and_memory() {

    #[cfg(test)]

    mod diff {

        use crate::{diff::*, vcs::git::*};

        #[test]

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

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

            let repo = Repository::new("./data/git-platinum")?;

            assert!(commit.parents().count() == 0);

            assert!(commit.parent(0).is_err());

            let repo = Repository::new("./data/git-platinum")?;

            let commit = repo

                .0

                .unwrap();

            let parent = commit.parent(0)?;

            let bro = Browser::new(&repo, Branch::local("master"))?;

            let expected_diff = Diff {

                created: vec![],

// along with this program. If not, see <https://www.gnu.org/licenses/>.

use crate::vcs::git::error::Error;

use std::{convert::TryFrom, str};

#[cfg(feature = "serialize")]

#[cfg_attr(feature = "serialize", derive(Deserialize))]

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]

pub struct Commit {

    pub id: Oid,

    /// The author of the commit.

    pub author: Author,

    /// The summary message of the commit.

    pub summary: String,

    /// The parents of this commit.

    pub parents: Vec<Oid>,

}

    }

}

impl<'repo> TryFrom<git2::Commit<'repo>> for Commit {

    type Error = Error;

    fn try_from(commit: git2::Commit) -> Result<Self, Self::Error> {

        let author = Author::try_from(commit.author())?;

        let committer = Author::try_from(commit.committer())?;

        let message_raw = commit.message_bytes();

        let message = str::from_utf8(message_raw)?.into();

        let summary_raw = commit.summary_bytes().ok_or(Error::MissingSummary)?;

        let summary = str::from_utf8(summary_raw)?.into();

        Ok(Commit {

            id,

#[cfg(feature = "serialize")]

#[cfg(test)]

pub mod tests {

    use proptest::prelude::*;

    use test_helpers::roundtrip;

    use super::{Author, Commit};

// along with this program. If not, see <https://www.gnu.org/licenses/>.

use crate::vcs::git::error::Error;

use nonempty::NonEmpty;

use std::{convert::TryFrom, fmt, str};

/// A `Namespace` value allows us to switch the git namespace of

use thiserror::Error;

use crate::vcs::git::{repo::RepositoryRef, BranchName, Namespace, TagName};

pub(super) mod glob;

/// A revision within the repository.

    /// A reference to a branch or tag.

    Ref(Ref),

    /// A particular commit identifier.

}

impl<R> From<R> for Rev

    }

}

        Self::Oid(other)

    }

}

        Vcs,

    },

};

use nonempty::NonEmpty;

use std::{collections::HashSet, convert::TryFrom, str};

/// This is for flagging to the `file_history` function that it should

    /// Get the [`Diff`] between two commits.

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

            .and_then(|diff| Diff::try_from(diff).map_err(Error::from))

    }

    /// Get the [`Diff`] of a commit with no parents.

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

            .and_then(|diff| Diff::try_from(diff).map_err(Error::from))

    }

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

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

    }

    pub(super) fn rev_to_commit(&self, rev: &Rev) -> Result<git2::Commit, Error> {

        match rev {

            Rev::Ref(reference) => Ok(reference.find_ref(self)?.peel_to_commit()?),

        }

    }

    /// Get a particular `Commit`.

    pub(super) fn get_commit(&self, oid: Oid) -> Result<git2::Commit<'a>, Error> {

        Ok(commit)

    }

        for commit_result_id in revwalk {

            // The revwalk iter returns results so

            // we unpack these and push them to the history

            // Skip the head commit since we have processed it

            if commit_id == head_id {

    }

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

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

    }

    /// Get the history of the file system where the head of the [`NonEmpty`] is

        let mut commits = vec![];

        // Set the revwalk to the head commit

        for commit in revwalk {

            let parent = self.repo_ref.find_commit(parent_id)?;

            let paths = self.diff_commit_and_parents(path, &parent)?;

            if let Some(_path) = paths {

    fn diff_commits(

        &self,

        path: Option<&file_system::Path>,

    ) -> Result<git2::Diff, Error> {

        let new_tree = self.repo_ref.find_commit(to)?.tree()?;

        let old_tree = from.map_or(Ok(None), |oid| {

// You should have received a copy of the GNU General Public License

// along with this program. If not, see <https://www.gnu.org/licenses/>.

#[cfg(feature = "serialize")]

use serde::Serialize;

// along with this program. If not, see <https://www.gnu.org/licenses/>.

use crate::vcs::git::{self, error::Error, reference::Ref, Author};

use std::{convert::TryFrom, fmt, str};

/// A newtype wrapper over `String` to separate out the fact that a caller wants

    type Error = str::Utf8Error;

    fn try_from(tag: git2::Tag) -> Result<Self, Self::Error> {

        let name = TagName::try_from(tag.name_bytes())?;

                {

                    let commit = reference.peel_to_commit()?;

                    Ok(Tag::Light {

                        name,

                        remote,

                    })