pub type Commit = CommitData<Oid, Oid>;

impl Commit {

    /// Read the [`Commit`] from the `repo` that is expected to be found at

    /// `oid`.

    pub fn read(repo: &git2::Repository, oid: Oid) -> Result<Self, error::Read> {

        let odb = repo.odb()?;

        let object = odb.read(oid)?;

        Ok(Commit::try_from(object.data())?)

    }

    /// Write the given [`Commit`] to the `repo`. The resulting `Oid`

    /// is the identifier for this commit.

    pub fn write(&self, repo: &git2::Repository) -> Result<Oid, error::Write> {

        let odb = repo.odb().map_err(error::Write::Odb)?;

        self.verify_for_write(&odb)?;

        Ok(odb.write(ObjectType::Commit, self.to_string().as_bytes())?)

    }

    fn verify_for_write(&self, odb: &git2::Odb) -> Result<(), error::Write> {

        for parent in &self.parents {

            verify_object(odb, parent, ObjectType::Commit)?;

        }

        verify_object(odb, &self.tree, ObjectType::Tree)?;

        Ok(())

    }

}

pub struct CommitData<Tree, Parent> {

    tree: Tree,

    parents: Vec<Parent>,

impl<Tree, Parent> CommitData<Tree, Parent> {

        tree: Tree,

        P: IntoIterator<Item = Parent>,

    /// The tree this commit points to.

    pub fn tree(&self) -> &Tree {

        &self.tree

    /// The parents of this commit.

    pub fn parents(&self) -> impl Iterator<Item = Parent> + '_

    where

        Parent: Clone,

    {

        self.parents.iter().cloned()

    /// Convert the `CommitData::tree` into a value of type `U`. The

    /// conversion function `f` can be fallible.

    ///

    /// For example, `map_tree` can be used to turn raw tree data into

    /// an `Oid` by writing it to a repository.

    pub fn map_tree<U, E, F>(self, f: F) -> Result<CommitData<U, Parent>, E>

    where

        F: FnOnce(Tree) -> Result<U, E>,

    {

        Ok(CommitData {

            tree: f(self.tree)?,

            parents: self.parents,

            author: self.author,

            committer: self.committer,

            headers: self.headers,

            message: self.message,

            trailers: self.trailers,

        })

    }

    /// Convert the `CommitData::parents` into a vector containing

    /// values of type `U`. The conversion function `f` can be

    /// fallible.

    ///

    /// For example, `map_parents` can be used to resolve the `Oid`s

    /// to their respective `git2::Commit`s.

    pub fn map_parents<U, E, F>(self, f: F) -> Result<CommitData<Tree, U>, E>

    where

        F: FnMut(Parent) -> Result<U, E>,

    {

        Ok(CommitData {

            tree: self.tree,

            parents: self

                .parents

                .into_iter()

                .map(f)

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

            author: self.author,

            committer: self.committer,

            headers: self.headers,

            message: self.message,

            trailers: self.trailers,

        })

#[derive(Debug)]

[dependencies.test-helpers]

use proptest::proptest;

use test_helpers::tempdir::{self, WithTmpDir};

use crate::gen;

proptest! {

    #[test]

    fn valid_commits(commits in proptest::collection::vec(gen::commit::commit(), 5..20)) {

        let repo = tempdir::WithTmpDir::new(|path| {

            git2::Repository::init(path).map_err(|e| io::Error::new(io::ErrorKind::Other, e))

        }).unwrap();

        let commits = gen::commit::write_commits(&repo, commits).unwrap();

        repo.reference("refs/heads/master", *commits.last().unwrap(), true, "").unwrap();

        let mut walk = repo.revwalk().unwrap();

        walk.push_head().unwrap();

        for oid in walk.take(20) {

            let oid = oid.unwrap();

            let commit = Commit::read(&repo, oid);

            assert!(commit.is_ok(), "Oid: {oid}, Error: {commit:?}");

        }

use proptest::strategy::Strategy;

pub mod commit;

pub fn alphanumeric() -> impl Strategy<Value = String> {

    "[a-zA-Z0-9_]+"

}

pub fn alpha() -> impl Strategy<Value = String> {

    "[a-zA-Z]+"

}

use std::convert::Infallible;

use proptest::strategy::Strategy;

use radicle_git_ext::commit::{self, CommitData};

mod author;

mod headers;

mod trailers;

pub use author::author;

pub use headers::headers;

pub use trailers::{trailer, trailers};

use super::alphanumeric;

pub fn commit() -> impl Strategy<Value = CommitData<TreeData, Infallible>> {

    (

        TreeData::gen(),

        author(),

        author(),

        headers(),

        alphanumeric(),

        trailers(3),

    )

        .prop_map(|(tree, author, committer, headers, message, trailers)| {

            CommitData::new(tree, vec![], author, committer, headers, message, trailers)

        })

}

pub fn write_commits(

    repo: &git2::Repository,

    linear: Vec<CommitData<TreeData, Infallible>>,

) -> Result<Vec<git2::Oid>, commit::error::Write> {

    let mut parent = None;

    let mut commits = Vec::new();

    for commit in linear {

        let commit = commit.map_tree(|tree| tree.write(repo))?;

        let commit = match parent {

            Some(parent) => commit

                .map_parents::<git2::Oid, Infallible, _>(|_| Ok(parent))

                .unwrap(),

            None => commit

                .map_parents::<git2::Oid, Infallible, _>(|_| unreachable!("no parents"))

                .unwrap(),

        };

        let oid = commit.write(repo)?;

        commits.push(oid);

        parent = Some(oid);

    }

    Ok(commits)

}

#[derive(Clone, Debug)]

pub enum TreeData {

    Blob { name: String, data: String },

    Tree { name: String, inner: Vec<TreeData> },

}

impl TreeData {

    fn gen() -> impl Strategy<Value = Self> {

        let leaf =

            (alphanumeric(), alphanumeric()).prop_map(|(name, data)| Self::Blob { name, data });

        leaf.prop_recursive(8, 16, 5, |inner| {

            (proptest::collection::vec(inner, 1..5), alphanumeric())

                .prop_map(|(inner, name)| Self::Tree { name, inner })

        })

    }

    fn write(&self, repo: &git2::Repository) -> Result<git2::Oid, git2::Error> {

        let mut builder = repo.treebuilder(None)?;

        self.write_(repo, &mut builder)?;

        builder.write()

    }

    fn write_(

        &self,

        repo: &git2::Repository,

        builder: &mut git2::TreeBuilder,

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

        match self {

            Self::Blob { name, data } => {

                let oid = repo.blob(data.as_bytes())?;

                builder.insert(name, oid, git2::FileMode::Blob.into())?;

            }

            Self::Tree { name, inner } => {

                for data in inner {

                    let oid = data.write_(repo, builder)?;

                    builder.insert(name, oid, git2::FileMode::Tree.into())?;

                }

            }

        }

        builder.write()

    }

}

use proptest::strategy::{Just, Strategy};

use radicle_git_ext::author::{Author, Time};

use crate::gen;

pub fn author() -> impl Strategy<Value = Author> {

    gen::alphanumeric().prop_flat_map(move |name| {

        (Just(name), gen::alphanumeric()).prop_flat_map(|(name, domain)| {

            (Just(name), Just(domain), (0..1000i64)).prop_map(move |(name, domain, time)| {

                let email = format!("{name}@{domain}");

                Author {

                    name,

                    email,

                    time: Time::new(time, 0),

                }

            })

        })

    })

}

use proptest::{collection, prop_oneof, strategy::Strategy};

use radicle_git_ext::commit::headers::Headers;

use crate::gen;

pub fn headers() -> impl Strategy<Value = Headers> {

    collection::vec(prop_oneof![header(), signature()], 0..5).prop_map(|hs| {

        let mut headers = Headers::new();

        for (k, v) in hs {

            headers.push(&k, &v);

        }

        headers

    })

}

fn header() -> impl Strategy<Value = (String, String)> {

    (prop_oneof!["test", "foo", "foobar"], gen::alphanumeric())

}

pub fn signature() -> impl Strategy<Value = (String, String)> {

    ("gpgsig", prop_oneof![pgp(), ssh()])

}

pub fn pgp() -> impl Strategy<Value = String> {

    "-----BEGIN PGP SIGNATURE-----\r?\n([A-Za-z0-9+/=\r\n]+)\r?\n-----END PGP SIGNATURE-----"

}

pub fn ssh() -> impl Strategy<Value = String> {

    "-----BEGIN SSH SIGNATURE-----\r?\n([A-Za-z0-9+/=\r\n]+)\r?\n-----END SSH SIGNATURE-----"

}

use proptest::{collection, strategy::Strategy};

use radicle_git_ext::commit::trailers::{OwnedTrailer, Token, Trailer};

use crate::gen;

pub fn trailers(n: usize) -> impl Strategy<Value = Vec<OwnedTrailer>> {

    collection::vec(trailer(), 0..n)

}

pub fn trailer() -> impl Strategy<Value = OwnedTrailer> {

    (gen::alpha(), gen::alphanumeric()).prop_map(|(token, value)| {

        Trailer {

            token: Token::try_from(format!("X-{}", token).as_str()).unwrap(),

            value: value.into(),

        }

        .to_owned()

    })

}

#[cfg(any(test, feature = "test"))]

pub mod repository;

use std::{convert::Infallible, io, path::Path};

use git2::Oid;

use radicle_git_ext::{commit::CommitData, ref_format::RefString};

use test_helpers::tempdir::{self, WithTmpDir};

use crate::gen::commit::{self, TreeData};

pub struct Fixture {

    pub inner: WithTmpDir<git2::Repository>,

    pub head: Option<git2::Oid>,

}

/// Initialise a [`git2::Repository`] in a temporary directory.

///

/// The provided `commits` will be added to the repository, and the

/// head commit will be returned.

pub fn fixture(

    refname: &RefString,

    commits: Vec<CommitData<TreeData, Infallible>>,

) -> io::Result<Fixture> {

    let repo = tempdir::WithTmpDir::new(|path| git2::Repository::init(path).map_err(io_other))?;

    let commits = commit::write_commits(&repo, commits).map_err(io_other)?;

    let head = commits.last().copied();

    if let Some(head) = head {

        repo.reference(refname.as_str(), head, false, "Initialise repository")

            .map_err(io_other)?;

    }

    Ok(Fixture { inner: repo, head })

}

pub fn bare_fixture(

    refname: &RefString,

    commits: Vec<CommitData<TreeData, Infallible>>,

) -> io::Result<Fixture> {

    let repo =

        tempdir::WithTmpDir::new(|path| git2::Repository::init_bare(path).map_err(io_other))?;

    let commits = commit::write_commits(&repo, commits).map_err(io_other)?;

    let head = commits.last().copied();

    if let Some(head) = head {

        repo.reference(refname.as_str(), head, false, "Initialise repository")

            .map_err(io_other)?;

    }

    Ok(Fixture { inner: repo, head })

}

pub fn submodule<'a>(

    parent: &'a git2::Repository,

    child: &'a git2::Repository,

    refname: &RefString,

    head: Oid,

    author: &git2::Signature,

) -> io::Result<git2::Submodule<'a>> {

    let url = format!("file://{}", child.path().canonicalize()?.display());

    let mut sub = parent

        .submodule(url.as_str(), Path::new("submodule"), true)

        .map_err(io_other)?;

    sub.open().map_err(io_other)?;

    sub.clone(Some(&mut git2::SubmoduleUpdateOptions::default()))

        .map_err(io_other)?;

    sub.add_to_index(true).map_err(io_other)?;

    sub.add_finalize().map_err(io_other)?;

    {

        let mut ix = parent.index().map_err(io_other)?;

        let tree = ix.write_tree_to(parent).map_err(io_other)?;

        let tree = parent.find_tree(tree).map_err(io_other)?;

        let head = parent.find_commit(head).map_err(io_other)?;

        parent

            .commit(

                Some(refname.as_str()),

                author,

                author,

                "Commit submodule",

                &tree,

                &[&head],

            )

            .map_err(io_other)?;

    }

    Ok(sub)

}

fn io_other<E>(e: E) -> io::Error

where

    E: std::error::Error + Send + Sync + 'static,

{

    io::Error::new(io::ErrorKind::Other, e)

}

url = "2.5"

url = "2.5"

use std::{convert::Infallible, path::Path};

use proptest::{collection, proptest};

use radicle_git_ext::commit::CommitData;

use radicle_git_ext::ref_format::refname;

use radicle_git_ext_test::gen;

use radicle_surf::{fs, Branch, Repository};

proptest! {

    #[test]

    fn test_submodule(

        initial in gen::commit::commit(),

        commits in collection::vec(gen::commit::commit(), 1..5)

    ) {

        prop::test_submodule(initial, commits)

    }

    #[ignore = "segfault"]

    #[test]

    fn test_submodule_bare(

        initial in gen::commit::commit(),

        commits in collection::vec(gen::commit::commit(), 1..5)

    ) {

        prop::test_submodule_bare(initial, commits)

    }

}

mod prop {

    use radicle_git_ext_test::{gen::commit, repository};

    use super::*;

    pub fn test_submodule(

        initial: CommitData<commit::TreeData, Infallible>,

        commits: Vec<CommitData<commit::TreeData, Infallible>>,

    ) {

        let refname = refname!("refs/heads/master");

        let author = git2::Signature::try_from(initial.author()).unwrap();

        let submodule = repository::fixture(&refname, commits).unwrap();

        let repo = repository::fixture(&refname, vec![initial]).unwrap();

        let head = repo.head.expect("missing initial commit");

        let sub =

            repository::submodule(&repo.inner, &submodule.inner, &refname, head, &author).unwrap();

        let repo = Repository::open(repo.inner.path()).unwrap();

        let branch = Branch::local(refname);

        let dir = repo.root_dir(&branch).unwrap();

        let platinum = dir.find_entry(&sub.path(), &repo).unwrap();

        assert!(matches!(&platinum, fs::Entry::Submodule(module) if module.url().is_some()));

        let root = repo.tree(&branch, &Path::new("")).unwrap();

        let kind = EntryKind::from(platinum);

        assert!(root.entries().iter().any(|e| e.entry() == &kind));

    }

    pub fn test_submodule_bare(

        initial: CommitData<commit::TreeData, Infallible>,

        commits: Vec<CommitData<commit::TreeData, Infallible>>,

    ) {

        let refname = refname!("refs/heads/master");

        let author = git2::Signature::try_from(initial.author()).unwrap();

        let submodule = repository::fixture(&refname, commits).unwrap();

        let repo = repository::bare_fixture(&refname, vec![initial]).unwrap();

        let head = repo.head.expect("missing initial commit");

        let sub =

            repository::submodule(&repo.inner, &submodule.inner, &refname, head, &author).unwrap();

        let repo = Repository::open(repo.inner.path()).unwrap();

        let branch = Branch::local(refname);

        let dir = repo.root_dir(&branch).unwrap();

        let platinum = dir.find_entry(&sub.path(), &repo).unwrap();

        assert!(matches!(&platinum, fs::Entry::Submodule(module) if module.url().is_some()));

        let root = repo.tree(&branch, &Path::new("")).unwrap();

        let kind = EntryKind::from(platinum);

        assert!(root.entries().iter().any(|e| e.entry() == &kind));

    }

#[derive(Debug)]