doctest = false

[features]

syntax = ["syntect", "lazy_static"]

# NOTE: testing `test_submodule_failure` on GH actions

# is painful since it uses this specific repo and expects

base64 = "0.13"

log = "0.4"

nonempty = "0.5"

thiserror = "1.0"

[dependencies.git2]

version = "0.1.0"

path = "../radicle-std-ext"

[dependencies.syntect]

version = "5"

optional = true

use std::{convert::TryFrom, path::PathBuf, slice};

use serde::{ser, Serialize, Serializer};

pub mod git;

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

pub struct Diff {

    pub created: Vec<CreateFile>,

    }

}

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

pub struct CreateFile {

    pub path: PathBuf,

    pub diff: FileDiff,

}

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

pub struct DeleteFile {

    pub path: PathBuf,

    pub diff: FileDiff,

}

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

pub struct MoveFile {

    pub old_path: PathBuf,

    pub new_path: PathBuf,

}

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

pub struct CopyFile {

    pub old_path: PathBuf,

    pub new_path: PathBuf,

}

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

pub enum EofNewLine {

    OldMissing,

    BothMissing,

}

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

pub struct ModifiedFile {

    pub path: PathBuf,

/// A set of changes belonging to one file.

#[cfg_attr(

    derive(Serialize),

    serde(tag = "type", rename_all = "camelCase")

)]

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

pub enum FileDiff {

    Binary,

    Plain {

        hunks: Hunks,

    },

}

/// Statistics describing a particular [`Diff`].

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

pub struct Stats {

    /// Get the total number of files changed in a diff.

}

/// A set of line changes.

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

pub struct Hunk {

    pub header: Line,

}

/// A set of [`Hunk`]s.

#[derive(Clone, Debug, Default, PartialEq, Eq)]

pub struct Hunks(pub Vec<Hunk>);

    }

}

impl Serialize for Line {

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

    where

/// Single line delta. Two of these are need to represented a modified line: one

/// addition and one deletion. Context is also represented with this type.

#[cfg_attr(

    derive(Serialize),

    serde(tag = "type", rename_all = "camelCase")

)]

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

pub enum LineDiff {

    /// Line added.

    Addition { line: Line, line_num: u32 },

    /// Line deleted.

    Deletion { line: Line, line_num: u32 },

    /// Line context.

    Context {

        line: Line,

        line_num_old: u32,

use git_ext::Oid;

use thiserror::Error;

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

#[derive(Debug, Error)]

}

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

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

pub struct Author {

    /// Name of the author.

    pub email: String,

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

    #[cfg_attr(

        serde(

            serialize_with = "serialize_time",

            deserialize_with = "deserialize_time"

    pub time: git2::Time,

}

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

where

    D: Deserializer<'de>,

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

}

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

where

    S: Serializer,

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

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

pub struct Commit {

    /// Object Id

    }

}

impl Serialize for Commit {

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

    where

pub use radicle_git_ext::Oid;

use serde::Serialize;

/// Stats for a repository

pub struct Stats {

    /// Number of commits

    pub commits: usize,

use std::path::PathBuf;

use git_ref_format::RefString;

use serde::{

    ser::{SerializeStruct as _, Serializer},

    Serialize,

use radicle_git_ext::Oid;

/// Commit statistics.

#[derive(Clone)]

pub struct Stats {

    /// Additions.

}

/// Representation of a changeset between two revs.

#[derive(Clone)]

pub struct Commit {

    /// The commit header.

    }

}

impl Serialize for Header {

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

    where

}

/// A selection of commit headers and their statistics.

pub struct Commits {

    /// The commit headers

    pub headers: Vec<Header>,

use std::{path::Path, str};

use serde::{

    ser::{SerializeStruct as _, Serializer},

    Serialize,

    }

}

impl Serialize for Blob {

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

    where

    Binary(Vec<u8>),

}

impl Serialize for BlobContent {

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

    where

use std::path::Path;

use serde::{

    ser::{SerializeStruct as _, Serializer},

    Serialize,

    }

}

impl Serialize for TreeEntry {

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

    where

//! Represents a person in a repo.

/// Representation of a person (e.g. committer, author, signer) from a

/// repository. Usually extracted from a signature.

#[derive(Clone, Debug)]

pub struct Person {

    /// Name part of the commit signature.

test = true

[features]

test = []

[dev-dependencies]

[dev-dependencies.radicle-surf]

path = ".."

[dev-dependencies.test-helpers]

path = "../../test/test-helpers"

const GIT_PLATINUM: &str = "../data/git-platinum";

#[cfg(test)]

mod branch;

#[cfg(test)]

mod code_browsing;

#[cfg(test)]

mod commit;

#[cfg(test)]

use radicle_surf::git::{Author, Commit};

use test_helpers::roundtrip;

proptest! {

    #[test]

    fn prop_test_commits(commit in commits_strategy()) {

    Ok(())

}

#[test]

fn test_diff_serde() {

    use radicle_surf::diff::{Hunks, MoveFile};

[dev-dependencies.radicle-surf-test]

path = "../radicle-surf/t"

[dev-dependencies.git-storage-test]

path = "../git-storage/t"