edition = "2021"

features = ["macro", "serde"]

use git_ref_format::refname;

    git::{Branch, Repository},

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

use radicle_surf::{diff::Diff, git};

use git_ref_format::RefString;

    git::{self, Glob, RepositoryRef},

    pub branches: Vec<RefString>,

        .map(|b| b.refname().into())

pub fn commits(repo: &RepositoryRef, maybe_revision: Option<Revision>) -> Result<Commits, Error> {

    git::{Error, RepositoryRef},

    git::{self, RepositoryRef, Revision},

// This file is part of radicle-surf

// <https://github.com/radicle-dev/radicle-surf>

//

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

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License version 3 or

// later as published by the Free Software Foundation.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

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

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

//! ```

//! use nonempty::NonEmpty;

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

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

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

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

//! use std::str::FromStr;

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

//!

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

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

//!

//! // Pin the browser to a parituclar commit.

//! let pin_commit = Oid::from_str("3873745c8f6ffb45c990eb23b491d4b4b6182f95")?;

//! let mut browser = Browser::new(&repo, Branch::local("master"))?;

//! browser.commit(pin_commit)?;

//!

//! let directory = browser.get_directory()?;

//! let mut directory_contents = directory.list_directory();

//! directory_contents.sort();

//!

//! assert_eq!(directory_contents, vec![

//!     SystemType::file(unsound::label::new(".i-am-well-hidden")),

//!     SystemType::file(unsound::label::new(".i-too-am-hidden")),

//!     SystemType::file(unsound::label::new("README.md")),

//!     SystemType::directory(unsound::label::new("bin")),

//!     SystemType::directory(unsound::label::new("src")),

//!     SystemType::directory(unsound::label::new("text")),

//!     SystemType::directory(unsound::label::new("this")),

//! ]);

//!

//! // find src directory in the Git directory and the in-memory directory

//! let src_directory = directory

//!     .find_directory(Path::new(unsound::label::new("src")))

//!     .expect("failed to find src");

//! let mut src_directory_contents = src_directory.list_directory();

//! src_directory_contents.sort();

//!

//! assert_eq!(src_directory_contents, vec![

//!     SystemType::file(unsound::label::new("Eval.hs")),

//!     SystemType::file(unsound::label::new("Folder.svelte")),

//!     SystemType::file(unsound::label::new("memory.rs")),

//! ]);

//! #

//! # Ok(())

//! # }

//! ```

use std::str::FromStr;

// Re-export git2 as sub-module

pub use git2::{self, Error as Git2Error, Time};

use git_ref_format::{name::Components, Component, Qualified, RefString};

pub use radicle_git_ext::Oid;

mod repo;

pub use repo::{Repository, RepositoryRef};

mod glob;

pub use glob::Glob;

mod history;

pub use history::History;

pub mod error;

pub use error::Error;

/// Provides the data for talking about branches.

pub mod branch;

pub use branch::{Branch, Local, Remote};

/// Provides the data for talking about tags.

pub mod tag;

pub use tag::Tag;

/// Provides the data for talking about commits.

pub mod commit;

pub use commit::{Author, Commit};

/// Provides the data for talking about namespaces.

pub mod namespace;

pub use namespace::Namespace;

/// Provides the data for talking about repository statistics.

pub mod stats;

pub use stats::Stats;

pub use crate::diff::Diff;

/// The signature of a commit

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

pub struct Signature(Vec<u8>);

impl From<git2::Buf> for Signature {

    fn from(other: git2::Buf) -> Self {

        Signature((*other).into())

    }

}

/// Supports various ways to specify a revision used in Git.

pub trait Revision {

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

    fn object_id(&self, repo: &RepositoryRef) -> Result<Oid, Error>;

}

impl Revision for RefString {

    fn object_id(&self, repo: &RepositoryRef) -> Result<Oid, Error> {

        repo.refname_to_oid(self.as_str())

    }

}

impl Revision for &RefString {

    fn object_id(&self, repo: &RepositoryRef) -> Result<Oid, Error> {

        repo.refname_to_oid(self.as_str())

    }

}

impl Revision for Qualified<'_> {

    fn object_id(&self, repo: &RepositoryRef) -> Result<Oid, Error> {

        repo.refname_to_oid(self.as_str())

    }

}

impl Revision for &Qualified<'_> {

    fn object_id(&self, repo: &RepositoryRef) -> Result<Oid, Error> {

        repo.refname_to_oid(self.as_str())

    }

}

impl Revision for Oid {

    fn object_id(&self, _repo: &RepositoryRef) -> Result<Oid, Error> {

        Ok(*self)

    }

}

impl Revision for &str {

    fn object_id(&self, _repo: &RepositoryRef) -> Result<Oid, Error> {

        Oid::from_str(self).map_err(Error::Git)

    }

}

impl Revision for &Branch {

    fn object_id(&self, repo: &RepositoryRef) -> Result<Oid, Error> {

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

        Ok(repo.repo_ref.refname_to_id(&refname).map(Oid::from)?)

    }

}

impl Revision for &Tag {

    fn object_id(&self, repo: &RepositoryRef) -> Result<Oid, Error> {

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

        Ok(repo.repo_ref.refname_to_id(&refname).map(Oid::from)?)

    }

}

pub(crate) fn refstr_join<'a>(c: Component<'a>, cs: Components<'a>) -> RefString {

    std::iter::once(c).chain(cs).collect::<RefString>()

}

use std::{

    convert::TryFrom,

    str::{self, FromStr},

};

use crate::git::refstr_join;

use git_ref_format::{component, lit, Component, Qualified, RefStr, RefString};

/// A `Branch` represents any git branch. This can either be a reference

/// that is under the `refs/heads` or `refs/remotes` namespace.

///

/// Note that if a `Branch` is created from a [`git2::Reference`] then

/// any `refs/namespaces` will be stripped.

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

pub enum Branch {

    Local(Local),

    Remote(Remote),

}

impl Branch {

    /// Construct a [`Local`] branch.

    pub fn local<R>(name: R) -> Self

    where

        R: AsRef<RefStr>,

    {

        Self::Local(Local::new(name))

    }

    /// Construct a [`Remote`] branch.

    /// The `remote` is the remote name of the reference name while

    /// the `name` is the suffix, i.e. `refs/remotes/<remote>/<name>`.

    pub fn remote<R>(remote: Component<'_>, name: R) -> Self

    where

        R: AsRef<RefStr>,

    {

        Self::Remote(Remote::new(remote, name))

    }

    pub fn refname(&self) -> Qualified {

        match self {

            Branch::Local(local) => local.refname(),

            Branch::Remote(remote) => remote.refname(),

        }

    }

}

impl TryFrom<&git2::Reference<'_>> for Branch {

    type Error = error::Branch;

    fn try_from(reference: &git2::Reference<'_>) -> Result<Self, Self::Error> {

        let name = str::from_utf8(reference.name_bytes())?;

        Self::from_str(name)

    }

}

impl TryFrom<&str> for Branch {

    type Error = error::Branch;

    fn try_from(name: &str) -> Result<Self, Self::Error> {

        Self::from_str(name)

    }

}

impl FromStr for Branch {

    type Err = error::Branch;

    fn from_str(name: &str) -> Result<Self, Self::Err> {

        let name = RefStr::try_from_str(name)?;

        let name = match name.to_namespaced() {

            None => name

                .qualified()

                .ok_or_else(|| error::Branch::NotQualified(name.to_string()))?,

            Some(name) => name.strip_namespace_recursive(),

        };

        let (_ref, category, c, cs) = name.non_empty_components();

        if category == component::HEADS {

            Ok(Self::Local(Local::new(refstr_join(c, cs))))

        } else if category == component::REMOTES {

            Ok(Self::Remote(Remote::new(c, cs.collect::<RefString>())))

        } else {

            Err(error::Branch::NotBranch(name.into()))

        }

    }

}

/// A `Local` represents a local branch, i.e. it is a reference under

/// `refs/heads`.

///

/// Note that if a `Local` is created from a [`git2::Reference`] then

/// any `refs/namespaces` will be stripped.

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

pub struct Local {

    name: RefString,

}

impl Local {

    /// Construct a new `Local` with the given `name`.

    ///

    /// If the name is qualified with `refs/heads`, this will be

    /// shortened to the suffix. To get the `Qualified` name again,

    /// use [`Local::refname`].

    pub fn new<R>(name: R) -> Self

    where

        R: AsRef<RefStr>,

    {

        match name.as_ref().qualified() {

            None => Self {

                name: name.as_ref().to_ref_string(),

            },

            Some(qualified) => {

                let (_refs, heads, c, cs) = qualified.non_empty_components();

                if heads == component::HEADS {

                    Self {

                        name: refstr_join(c, cs),

                    }

                } else {

                    Self {

                        name: name.as_ref().to_ref_string(),

                    }

                }

            },

        }

    }

    /// Return the fully qualified `Local` refname,

    /// e.g. `refs/heads/fix/ref-format`.

    pub fn refname(&self) -> Qualified {

        lit::refs_heads(&self.name).into()

    }

}

impl TryFrom<&git2::Reference<'_>> for Local {

    type Error = error::Local;

    fn try_from(reference: &git2::Reference) -> Result<Self, Self::Error> {

        let name = str::from_utf8(reference.name_bytes())?;

        Self::from_str(name)

    }

}

impl TryFrom<&str> for Local {

    type Error = error::Local;

    fn try_from(name: &str) -> Result<Self, Self::Error> {

        Self::from_str(name)

    }

}

impl FromStr for Local {

    type Err = error::Local;

    fn from_str(name: &str) -> Result<Self, Self::Err> {

        let name = RefStr::try_from_str(name)?;

        let name = match name.to_namespaced() {

            None => name

                .qualified()

                .ok_or_else(|| error::Local::NotQualified(name.to_string()))?,

            Some(name) => name.strip_namespace_recursive(),

        };

        let (_ref, heads, c, cs) = name.non_empty_components();

        if heads == component::HEADS {

            Ok(Self::new(refstr_join(c, cs)))

        } else {

            Err(error::Local::NotHeads(name.into()))

        }

    }

}

/// A `Remote` represents a remote branch, i.e. it is a reference under

/// `refs/remotes`.

///

/// Note that if a `Remote` is created from a [`git2::Reference`] then

/// any `refs/namespaces` will be stripped.

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

pub struct Remote {

    remote: RefString,

    name: RefString,

}

impl Remote {

    /// Construct a new `Remote` with the given `name` and `remote`.

    ///

    /// ## Note

    /// `name` is expected to be in short form, i.e. not begin with

    /// `refs`.

    ///

    /// If you are creating a `Remote` with a name that begins with

    /// `refs/remotes`, use [`Remote::from_refs_remotes`] instead.

    ///

    /// To get the `Qualified` name, use [`Remote::refname`].

    pub fn new<R>(remote: Component, name: R) -> Self

    where

        R: AsRef<RefStr>,

    {

        Self {

            name: name.as_ref().to_ref_string(),

            remote: remote.to_ref_string(),

        }

    }

    /// Parse the `name` from the form `refs/remotes/<remote>/<rest>`.

    ///

    /// If the `name` is not of this form, then `None` is returned.

    pub fn from_refs_remotes<R>(name: R) -> Option<Self>

    where

        R: AsRef<RefStr>,

    {

        let qualified = name.as_ref().qualified()?;

        let (_refs, remotes, remote, cs) = qualified.non_empty_components();

        (remotes == component::REMOTES).then_some(Self {

            name: cs.collect(),

            remote: remote.to_ref_string(),

        })

    }

    /// Give back the fully qualified `Remote` refname,

    /// e.g. `refs/remotes/origin/fix/ref-format`.

    pub fn refname(&self) -> Qualified {

        lit::refs_remotes(self.remote.join(&self.name)).into()

    }

}

impl TryFrom<&git2::Reference<'_>> for Remote {

    type Error = error::Remote;

    fn try_from(reference: &git2::Reference) -> Result<Self, Self::Error> {

        let name = str::from_utf8(reference.name_bytes())?;

        Self::from_str(name)

    }

}

impl TryFrom<&str> for Remote {

    type Error = error::Remote;

    fn try_from(name: &str) -> Result<Self, Self::Error> {

        Self::from_str(name)

    }

}

impl FromStr for Remote {

    type Err = error::Remote;

    fn from_str(name: &str) -> Result<Self, Self::Err> {

        let name = RefStr::try_from_str(name)?;

        let name = match name.to_namespaced() {

            None => name

                .qualified()

                .ok_or_else(|| error::Remote::NotQualified(name.to_string()))?,

            Some(name) => name.strip_namespace_recursive(),

        };

        let (_ref, remotes, remote, cs) = name.non_empty_components();

        if remotes == component::REMOTES {

            Ok(Self::new(remote, cs.collect::<RefString>()))

        } else {

            Err(error::Remote::NotRemotes(name.into()))

        }

    }

}

pub mod error {

    use git_ref_format::RefString;

    use thiserror::Error;

    #[derive(Debug, Error)]

    pub enum Branch {

        #[error("the refname '{0}' did not begin with 'refs/heads' or 'refs/remotes'")]

        NotBranch(RefString),

        #[error("the refname '{0}' did not begin with 'refs/heads' or 'refs/remotes'")]

        NotQualified(String),

        #[error(transparent)]

        RefFormat(#[from] git_ref_format::Error),

        #[error(transparent)]

        Utf8(#[from] std::str::Utf8Error),

    }

    #[derive(Debug, Error)]

    pub enum Local {

        #[error("the refname '{0}' did not begin with 'refs/heads'")]

        NotHeads(RefString),

        #[error("the refname '{0}' did not begin with 'refs/heads'")]

        NotQualified(String),

        #[error(transparent)]

        RefFormat(#[from] git_ref_format::Error),

        #[error(transparent)]

        Utf8(#[from] std::str::Utf8Error),

    }

    #[derive(Debug, Error)]

    pub enum Remote {

        #[error("the refname '{0}' did not begin with 'refs/remotes'")]

        NotQualified(String),

        #[error("the refname '{0}' did not begin with 'refs/remotes'")]

        NotRemotes(RefString),

        #[error(transparent)]

        RefFormat(#[from] git_ref_format::Error),

        #[error(transparent)]

        Utf8(#[from] std::str::Utf8Error),

    }

}

// This file is part of radicle-surf

// <https://github.com/radicle-dev/radicle-surf>

//

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

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License version 3 or

// later as published by the Free Software Foundation.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

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

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

use crate::{

    file_system::{self, directory},

    git::{error::Error, Branch, RepositoryRef, Tag},

};

use git_ref_format::{Qualified, RefString};

use radicle_git_ext::Oid;

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

#[cfg(feature = "serialize")]

use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};

/// `Author` is the static information of a [`git2::Signature`].

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

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

pub struct Author {

    /// Name of the author.

    pub name: String,

    /// Email of the author.

    pub email: String,

    /// Time the action was taken, e.g. time of commit.

    #[cfg_attr(

        feature = "serialize",

        serde(

            serialize_with = "serialize_time",

            deserialize_with = "deserialize_time"

        )

    )]

    pub time: git2::Time,

}

#[cfg(feature = "serialize")]

fn deserialize_time<'de, D>(deserializer: D) -> Result<git2::Time, D::Error>

where

    D: Deserializer<'de>,

{

    let seconds: i64 = Deserialize::deserialize(deserializer)?;

    Ok(git2::Time::new(seconds, 0))

}

#[cfg(feature = "serialize")]

fn serialize_time<S>(t: &git2::Time, serializer: S) -> Result<S::Ok, S::Error>

where

    S: Serializer,

{

    serializer.serialize_i64(t.seconds())

}

impl std::fmt::Debug for Author {

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

        use std::cmp::Ordering;

        let time = match self.time.offset_minutes().cmp(&0) {

            Ordering::Equal => format!("{}", self.time.seconds()),

            Ordering::Greater => format!("{}+{}", self.time.seconds(), self.time.offset_minutes()),

            Ordering::Less => format!("{}{}", self.time.seconds(), self.time.offset_minutes()),

        };

        f.debug_struct("Author")

            .field("name", &self.name)

            .field("email", &self.email)

            .field("time", &time)

            .finish()

    }

}

impl<'repo> TryFrom<git2::Signature<'repo>> for Author {

    type Error = str::Utf8Error;

    fn try_from(signature: git2::Signature) -> Result<Self, Self::Error> {

        let name = str::from_utf8(signature.name_bytes())?.into();

        let email = str::from_utf8(signature.email_bytes())?.into();

        let time = signature.when();

        Ok(Author { name, email, time })

    }

}

/// `Commit` is the static information of a [`git2::Commit`]. To get back the

/// original `Commit` in the repository we can use the [`Oid`] to retrieve

/// it.

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

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

pub struct Commit {

    /// Object Id

    pub id: Oid,

    /// The author of the commit.

    pub author: Author,

    /// The actor who committed this commit.

    pub committer: Author,

    /// The long form message of the commit.

    pub message: String,

    /// The summary message of the commit.

    pub summary: String,

    /// The parents of this commit.

    pub parents: Vec<Oid>,

}

impl Commit {

    /// Returns the commit description text. This is the text after the one-line

    /// summary.

    #[must_use]

    pub fn description(&self) -> &str {

        self.message

            .strip_prefix(&self.summary)

            .unwrap_or(&self.message)

            .trim()

    }

    /// Retrieves the file with `path` in this commit.

    pub fn get_file<'a>(

        &'a self,

        repo: &'a RepositoryRef,

        path: file_system::Path,

    ) -> Result<directory::FileContent, Error> {

        let git2_commit = repo.get_git2_commit(self.id)?;

        repo.get_commit_file(&git2_commit, path)

    }

}

#[cfg(feature = "serialize")]

impl Serialize for Commit {

    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

    where

        S: Serializer,

    {

        let mut state = serializer.serialize_struct("Commit", 7)?;

        state.serialize_field("id", &self.id.to_string())?;

        state.serialize_field("author", &self.author)?;

        state.serialize_field("committer", &self.committer)?;

        state.serialize_field("summary", &self.summary)?;

        state.serialize_field("message", &self.message)?;

        state.serialize_field("description", &self.description())?;

        state.serialize_field(

            "parents",

            &self

                .parents

                .iter()

                .map(|oid| oid.to_string())

                .collect::<Vec<String>>(),

        )?;

        state.end()

    }

}

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

    type Error = Error;

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

        let id = commit.id().into();

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

        let parents = commit.parent_ids().map(|oid| oid.into()).collect();

        Ok(Commit {

            id,

            author,

            committer,

            message,

            summary,

            parents,

        })

    }

}

/// A common trait for anything that can convert to a `Commit`.

pub trait ToCommit {

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

    fn to_commit(self, repo: &RepositoryRef) -> Result<Commit, Error>;

}

impl ToCommit for Commit {

    fn to_commit(self, _repo: &RepositoryRef) -> Result<Commit, Error> {

        Ok(self)

    }

}

impl ToCommit for &str {

    fn to_commit(self, repo: &RepositoryRef) -> Result<Commit, Error> {

        repo.commit(self)

    }

}

impl ToCommit for Oid {

    fn to_commit(self, repo: &RepositoryRef) -> Result<Commit, Error> {

        repo.commit(self)

    }

}

impl ToCommit for &Branch {

    fn to_commit(self, repo: &RepositoryRef) -> Result<Commit, Error> {

        repo.commit(self)

    }

}

impl ToCommit for &Tag {

    fn to_commit(self, repo: &RepositoryRef) -> Result<Commit, Error> {

        repo.commit(self)

    }

}

impl ToCommit for &RefString {

    fn to_commit(self, repo: &RepositoryRef) -> Result<Commit, Error> {

        repo.commit(self)

    }

}

impl ToCommit for &Qualified<'_> {

    fn to_commit(self, repo: &RepositoryRef) -> Result<Commit, Error> {

        repo.commit(self)

    }

}

// This file is part of radicle-surf

// <https://github.com/radicle-dev/radicle-surf>

//

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

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License version 3 or

// later as published by the Free Software Foundation.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

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

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

//! Collection of errors and helper instances that can occur when performing

//! operations from [`crate::git`].

use crate::{diff, file_system, git, git::Namespace};

use std::str;

use thiserror::Error;

/// Enumeration of errors that can occur in operations from [`crate::git`].

#[derive(Debug, Error)]

#[non_exhaustive]

pub enum Error {

    #[error(transparent)]

    BranchIter(#[from] git::repo::iter::error::Branch),

    #[error(transparent)]

    TagIter(#[from] git::repo::iter::error::Tag),

    /// A `revspec` was provided that could not be parsed into a branch, tag, or

    /// commit object.

    #[error("provided revspec '{rev}' could not be parsed into a git object")]

    RevParseFailure {

        /// The provided revspec that failed to parse.

        rev: String,

    },

    /// A `revspec` was provided that could not be found in the given

    /// `namespace`.

    #[error("provided revspec '{rev}' could not be parsed into a git object in the namespace '{namespace}'")]

    NamespaceRevParseFailure {

        /// The namespace we are in when attempting to fetch the `rev`.

        namespace: Namespace,

        /// The provided revspec that failed to parse.

        rev: String,

    },

    /// When parsing a namespace we may come across one that was an empty

    /// string.

    #[error("tried parsing the namespace but it was empty")]

    EmptyNamespace,

    /// A [`str::Utf8Error`] error, which usually occurs when a git object's

    /// name is not in UTF-8 form and parsing of it as such fails.

    #[error(transparent)]

    Utf8Error(#[from] str::Utf8Error),

    /// When trying to get the summary for a [`git2::Commit`] some action

    /// failed.

    #[error("an error occurred trying to get a commit's summary")]

    MissingSummary,

    /// An error that comes from performing a [`crate::file_system`] operation.

    #[error(transparent)]

    FileSystem(#[from] file_system::Error),

    /// While attempting to calculate a diff for retrieving the

    /// [`crate::vcs::git::Browser.last_commit()`], the file path was returned

    /// as an `Option::None`.

    #[error("last commit has an invalid file path")]

    LastCommitException,

    /// The requested file was not found.

    #[error("path not found for: {0}")]

    PathNotFound(file_system::Path),

    /// An error that comes from performing a *diff* operations.

    #[error(transparent)]

    Diff(#[from] diff::git::error::Diff),

    /// A wrapper around the generic [`git2::Error`].

    #[error(transparent)]

    Git(#[from] git2::Error),

    /// A wrapper around git-ref-format::Error

    #[error(transparent)]

    RefFormat(#[from] git_ref_format::Error),

}

// This file is part of radicle-git

// <https://github.com/radicle-dev/radicle-git>

//

// Copyright (C) 2022 The Radicle Team <dev@radicle.xyz>

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License version 3 or

// later as published by the Free Software Foundation.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

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

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

use crate::git::Error;

use git_ref_format::refspec::PatternString;

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

/// A collection of globs for T (a git reference type).

pub struct Glob<T> {

    globs: Vec<PatternString>,

    glob_type: PhantomData<T>, // To support different methods for different T.

}

impl<T> Glob<T> {

    /// Returns the globs.

    pub fn globs(&self) -> Vec<&str> {

        self.globs.iter().map(|g| g.as_str()).collect()

    }

}

impl<Namespace> Glob<Namespace> {

    /// Creates a `Glob` for namespaces.

    pub fn namespaces(glob: &str) -> Result<Self, Error> {

        let pattern = PatternString::try_from(format!("refs/namespaces/{}", glob))?;

        let globs = vec![pattern];

        Ok(Self {

            globs,

            glob_type: PhantomData,

        })

    }

    /// Adds namespaces patterns to existing `Glob`.

    pub fn and(mut self, glob: &str) -> Result<Self, Error> {

        let pattern = PatternString::try_from(format!("refs/namespaces/{}", glob))?;

        self.globs.push(pattern);

        Ok(self)

    }

}

impl<Tag> Glob<Tag> {

    /// Creates a `Glob` for local tags.

    pub fn tags(glob: &str) -> Result<Self, Error> {

        let pattern = PatternString::try_from(format!("refs/tags/{}", glob))?;

        let globs = vec![pattern];

        Ok(Self {

            globs,

            glob_type: PhantomData,

        })

    }

    /// Updates a `Glob` to include other tags.

    pub fn and_tags(mut self, glob: &str) -> Result<Self, Error> {

        let pattern = PatternString::try_from(format!("refs/tags/{}", glob))?;

        self.globs.push(pattern);

        Ok(self)

    }

}

impl<Branch> Glob<Branch> {

    /// Creates a `Glob` for local branches.

    pub fn heads(glob: &str) -> Result<Self, Error> {

        let pattern = PatternString::try_from(format!("refs/heads/{}", glob))?;

        let globs = vec![pattern];

        Ok(Self {

            globs,

            glob_type: PhantomData,

        })

    }

    /// Creates a `Glob` for remote branches.

    pub fn remotes(glob: &str) -> Result<Self, Error> {

        let pattern = PatternString::try_from(format!("refs/remotes/{}", glob))?;

        let globs = vec![pattern];

        Ok(Self {

            globs,

            glob_type: PhantomData,

        })

    }

    /// Updates a `Glob` to include local branches.

    pub fn and_heads(mut self, glob: &str) -> Result<Self, Error> {

        let pattern = PatternString::try_from(format!("refs/heads/{}", glob))?;

        self.globs.push(pattern);

        Ok(self)

    }

    /// Updates a `Glob` to include remote branches.

    pub fn and_remotes(mut self, glob: &str) -> Result<Self, Error> {

        let pattern = PatternString::try_from(format!("refs/remotes/{}", glob))?;

        self.globs.push(pattern);

        Ok(self)

    }

}

// This file is part of radicle-surf

// <https://github.com/radicle-dev/radicle-git>

//

// Copyright (C) 2022 The Radicle Team <dev@radicle.xyz>

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License version 3 or

// later as published by the Free Software Foundation.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

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

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

use crate::{

    file_system,

    git::{commit::ToCommit, Commit, Error, RepositoryRef},

};

use std::convert::TryFrom;

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

/// in the `repo`.

pub struct History<'a> {

    repo: RepositoryRef<'a>,

    head: Commit,

    revwalk: git2::Revwalk<'a>,

    filter_by: Option<FilterBy>,

}

/// Internal implementation, subject to refactoring.

enum FilterBy {

    File { path: file_system::Path },

}

impl<'a> History<'a> {

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

    pub fn new<C: ToCommit>(repo: RepositoryRef<'a>, head: C) -> Result<Self, Error> {

        let head = head.to_commit(&repo)?;

        let mut revwalk = repo.repo_ref.revwalk()?;

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

        let history = Self {

            repo,

            head,

            revwalk,

            filter_by: None,

        };

        Ok(history)

    }

    /// Returns the first commit (i.e. the head) in the history.

    pub fn head(&self) -> &Commit {

        &self.head

    }

    /// Returns a modified `History` filtered by `path`.

    ///

    /// Note that it is possible that a filtered History becomes empty,

    /// even though calling `.head()` still returns the original head.

    pub fn by_path(mut self, path: file_system::Path) -> Self {

        self.filter_by = Some(FilterBy::File { path });

        self

    }

}

impl<'a> Iterator for History<'a> {

    type Item = Result<Commit, Error>;

    fn next(&mut self) -> Option<Self::Item> {

        // Loop through the commits with the optional filtering.

        while let Some(oid) = self.revwalk.next() {

            let found = oid

                .map_err(Error::Git)

                .and_then(|oid| {

                    let git2_commit = self.repo.repo_ref.find_commit(oid)?;

                    // Handles the optional filter_by.

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

                        let path_opt = self.repo.diff_commit_and_parents(path, &git2_commit)?;

                        if path_opt.is_none() {

                            return Ok(None); // Filter out this commit.

                        }

                    }

                    let commit = Commit::try_from(git2_commit)?;

                    Ok(Some(commit))

                })

                .transpose();

            if found.is_some() {

                return found;

            }

        }

        None

    }

}

impl<'a> std::fmt::Debug for History<'a> {

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

        write!(f, "History of {}", self.head.id)

    }

}

// This file is part of radicle-surf

// <https://github.com/radicle-dev/radicle-surf>

//

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

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License version 3 or

// later as published by the Free Software Foundation.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

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

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

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

use nonempty::NonEmpty;

pub use radicle_git_ext::Oid;

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

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

/// a repo.

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

pub struct Namespace {

    /// Since namespaces can be nested we have a vector of strings.

    /// This means that the namespaces `"foo/bar"` is represented as

    /// `vec!["foo", "bar"]`.

    pub(super) values: NonEmpty<String>,

}

impl Namespace {

    /// Appends a `refname` to this namespace, and returns

    /// the full reference path.

    pub fn append_refname(&self, refname: &str) -> String {

        let mut prefix = String::new();

        for value in self.values.iter() {

            prefix = format!("{}refs/namespaces/{}/", &prefix, value);

        }

        format!("{}{}", &prefix, refname)

    }

}

impl fmt::Display for Namespace {

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

        let values: Vec<_> = self.values.clone().into();

        write!(f, "{}", values.join("/"))

    }

}

impl TryFrom<&str> for Namespace {

    type Error = Error;

    fn try_from(namespace: &str) -> Result<Self, Self::Error> {

        let values = namespace.split('/').map(|n| n.to_string()).collect();

        NonEmpty::from_vec(values)

            .map(|values| Self { values })

            .ok_or(Error::EmptyNamespace)

    }

}

impl TryFrom<&[u8]> for Namespace {

    type Error = Error;

    fn try_from(namespace: &[u8]) -> Result<Self, Self::Error> {

        str::from_utf8(namespace)

            .map_err(Error::from)

            .and_then(Namespace::try_from)

    }

}

impl TryFrom<git2::Reference<'_>> for Namespace {

    type Error = Error;

    fn try_from(reference: git2::Reference) -> Result<Self, Self::Error> {

        let re = regex::Regex::new(r"refs/namespaces/([^/]+)/").unwrap();

        let ref_name = str::from_utf8(reference.name_bytes())?;

        let values = re

            .find_iter(ref_name)

            .map(|m| {

                String::from(

                    m.as_str()

                        .trim_start_matches("refs/namespaces/")

                        .trim_end_matches('/'),

                )

            })

            .collect::<Vec<_>>();

        NonEmpty::from_vec(values)

            .map(|values| Self { values })

            .ok_or(Error::EmptyNamespace)

    }

}

// This file is part of radicle-surf

// <https://github.com/radicle-dev/radicle-surf>

//

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

//

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License version 3 or

// later as published by the Free Software Foundation.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

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

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

use crate::{

    diff::*,

    file_system,

    file_system::{

        directory::{self, Directory, DirectoryEntry, FileContent},

        Label,

    },

    git::{error::*, Branch, Commit, Glob, History, Namespace, Revision, Signature, Stats, Tag},

};

use git_ref_format::RefString;

use radicle_git_ext::Oid;

use std::{

    collections::{BTreeMap, BTreeSet},

    convert::TryFrom,

    path::PathBuf,

    str,

};

use super::commit::ToCommit;

pub mod iter;

pub use iter::{Branches, Namespaces, Tags};

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

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

/// on the underlying object.

pub struct Repository(pub(super) git2::Repository);

/// A reference-only `Repository`. This means that we cannot mutate the

/// underlying `Repository`. Not being able to mutate the `Repository` means

/// that the functions defined for `RepositoryRef` should be thread-safe.

///

/// # Construction

///

/// Use the `From<&'a git2::Repository>` implementation to construct a

/// `RepositoryRef`.

#[derive(Clone, Copy)]

pub struct RepositoryRef<'a> {

    pub(crate) repo_ref: &'a git2::Repository,

}

// RepositoryRef should be safe to transfer across thread boundaries since it

// only holds a reference to git2::Repository. git2::Repository is also Send

// (see: https://docs.rs/git2/0.13.5/src/git2/repo.rs.html#46)

unsafe impl<'a> Send for RepositoryRef<'a> {}

impl<'a> From<&'a git2::Repository> for RepositoryRef<'a> {

    fn from(repo_ref: &'a git2::Repository) -> Self {

        RepositoryRef { repo_ref }

    }

}

impl<'a> RepositoryRef<'a> {

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

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

        self.repo_ref

            .namespace_bytes()

            .map(Namespace::try_from)

            .transpose()

    }

    /// Returns an iterator of branches that match `pattern`.

    pub fn branches(&self, pattern: &Glob<Branch>) -> Result<Branches, Error> {

        let mut branches = Branches::default();

        for glob in pattern.globs().iter() {

            let namespaced = self.namespaced_refname(glob)?;

            let references = self.repo_ref.references_glob(&namespaced)?;

            branches.push(references);

        }

        Ok(branches)

    }

    /// Returns an iterator of tags that match `pattern`.

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

        let mut tags = Tags::default();

        for glob in pattern.globs().iter() {

            let namespaced = self.namespaced_refname(glob)?;

            let references = self.repo_ref.references_glob(&namespaced)?;

            tags.push(references);

        }

        Ok(tags)

    }

    /// Returns an iterator of namespaces that match `pattern`.

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

        let mut set = BTreeSet::new();

        for glob in pattern.globs().iter() {

            let new_set = self

                .repo_ref

                .references_glob(glob)?

                .map(|reference| {

                    reference

                        .map_err(Error::Git)

                        .and_then(|r| Namespace::try_from(r).map_err(|_| Error::EmptyNamespace))

                })

                .collect::<Result<BTreeSet<Namespace>, Error>>()?;

            set.extend(new_set);

        }

        Ok(Namespaces::new(set))

    }

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

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

        let from_commit = self.get_git2_commit(from.object_id(self)?)?;

        let to_commit = self.get_git2_commit(to.object_id(self)?)?;

        self.diff_commits(None, Some(&from_commit), &to_commit)

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

    }

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

    pub fn initial_diff<R: Revision>(&self, rev: R) -> Result<Diff, Error> {

        let commit = self.get_git2_commit(rev.object_id(self)?)?;

        self.diff_commits(None, None, &commit)

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

    }

    /// Get the diff introduced by a particlar rev.

    pub fn diff_from_parent<C: ToCommit>(&self, commit: C) -> Result<Diff, Error> {

        let commit = commit.to_commit(self)?;

        match commit.parents.first() {

            Some(parent) => self.diff(*parent, commit.id),

            None => self.initial_diff(commit.id),

        }

    }

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

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

        Ok(self.repo_ref.revparse_single(oid)?.id().into())

    }

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

    ///

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

    /// on the sub-directory.

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

        let commit = commit.to_commit(self)?;

        let git2_commit = self.repo_ref.find_commit((commit.id).into())?;

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

        Ok(Directory {

            name: Label::root(),

            oid: tree.id().into(),

        })

    }

    /// Retrieves the content of a directory.

    pub(crate) fn directory_get(

        &self,

        d: &Directory,

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

        let git2_tree = self.repo_ref.find_tree(d.oid.into())?;

        let map = self.tree_first_level(git2_tree)?;

        Ok(map)

    }

    /// Returns a map of the first level entries in `tree`.

    fn tree_first_level(&self, tree: git2::Tree) -> Result<BTreeMap<Label, DirectoryEntry>, Error> {

        let mut map = BTreeMap::new();

        // Walks only the first level of entries.

        tree.walk(git2::TreeWalkMode::PreOrder, |_s, entry| {

            let oid = entry.id().into();

            let label = match entry.name() {

                Some(name) => match name.parse::<Label>() {

                    Ok(label) => label,

                    Err(_) => return git2::TreeWalkResult::Abort,

                },

                None => return git2::TreeWalkResult::Abort,

            };

            match entry.kind() {

                Some(git2::ObjectType::Tree) => {

                    let dir = Directory::new(label.clone(), oid);

                    map.insert(label, DirectoryEntry::Directory(dir));

                    return git2::TreeWalkResult::Skip; // Not go into nested

                                                       // directories.

                },

                Some(git2::ObjectType::Blob) => {

                    let f = directory::File {

                        name: label.clone(),

                        oid,

                    };

                    map.insert(label, DirectoryEntry::File(f));

                },

                _ => {

                    return git2::TreeWalkResult::Skip;

                },

            }

            git2::TreeWalkResult::Ok

        })?;

        Ok(map)

    }

    /// Returns the last commit, if exists, for a `path` in the history of

    /// `rev`.

    pub fn last_commit<C: ToCommit>(

        &self,

        path: file_system::Path,

        rev: C,

    ) -> Result<Option<Commit>, Error> {

        let history = self.history(rev)?;

        history.by_path(path).next().transpose()

    }

    /// Returns a commit for `rev` if exists.

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

        let oid = rev.object_id(self)?;

        match self.repo_ref.find_commit(oid.into()) {

            Ok(commit) => Commit::try_from(commit),

            Err(e) => Err(Error::Git(e)),

        }

    }

    /// Gets stats of `commit`.

    pub fn get_commit_stats<C: ToCommit>(&self, commit: C) -> Result<Stats, Error> {

        let branches = self.branches(&Glob::heads("*")?)?.count();

        let history = self.history(commit)?;

        let mut commits = 0;

        let contributors = history

            .filter_map(|commit| match commit {

                Ok(commit) => {

                    commits += 1;

                    Some((commit.author.name, commit.author.email))

                },

                Err(_) => None,

            })

            .collect::<BTreeSet<_>>();

        Ok(Stats {

            branches,

            commits,

            contributors: contributors.len(),

        })

    }

    /// Obtain the file content

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

        let blob = self.repo_ref.find_blob(object_id.into())?;

        Ok(FileContent::new(blob))

    }

    /// Return the size of a file

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

        let blob = self.repo_ref.find_blob(oid.into())?;

        Ok(blob.size())

    }

    /// Lists branch names with `filter`.

    pub fn branch_names(&self, filter: &Glob<Branch>) -> Result<Vec<RefString>, Error> {

        let mut branches = self

            .branches(filter)?

            .map(|b| b.map(|b| b.refname().into()))

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

        branches.sort();

        Ok(branches)

    }

    /// Lists tag names in the local RefScope.

    pub fn tag_names(&self) -> Result<Vec<RefString>, Error> {

        let mut tags = self

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

            .map(|t| t.map_err(Error::from).map(|t| t.refname().into()))

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

        tags.sort();

        Ok(tags)

    }

    /// Returns the Oid of the current HEAD

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

        let head = self.repo_ref.head()?;

        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> {

        Ok(self.repo_ref.set_namespace(namespace)?)

    }

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

    pub(crate) fn namespaced_refname(&self, refname: &str) -> Result<String, Error> {

        let fullname = match self.which_namespace()? {

            Some(namespace) => namespace.append_refname(refname),

            None => refname.to_string(),

        };

        Ok(fullname)

    }

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

        let oid = self.repo_ref.refname_to_id(refname)?;

        Ok(oid.into())

    }

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

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

        self.repo_ref.find_commit(oid.into()).map_err(Error::Git)

    }

    /// Extract the signature from a commit

    ///

    /// # Arguments

    ///

    /// `commit_oid` - The object ID of the commit

    /// `field` - the name of the header field containing the signature block;

    ///           pass `None` to extract the default 'gpgsig'

    pub fn extract_signature(

        &self,

        commit_oid: &Oid,

        field: Option<&str>,

    ) -> Result<Option<Signature>, Error> {

        // Match is necessary here because according to the documentation for

        // 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

        match self.repo_ref.extract_signature(commit_oid, field) {

            Err(error) => {

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

                    Ok(None)

                } else {

                    Err(error.into())

                }

            },

            Ok(sig) => Ok(Some(Signature::from(sig.0))),

        }

    }

    /// Lists branches that are reachable from `oid`.

    pub fn revision_branches(&self, oid: &Oid, glob: &Glob<Branch>) -> Result<Vec<Branch>, Error> {

        let mut contained_branches = vec![];

        for branch in self.branches(glob)? {