name = "automerge"

version = "0.1.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "3e97999332403b0685c203d4937730f72777829c8b6ed92d6f1ccba017f38e61"

dependencies = [

 "flate2",

 "fxhash",

 "hex",

 "itertools",

 "leb128",

 "serde",

 "sha2 0.10.6",

 "smol_str",

 "thiserror",

 "tinyvec",

 "tracing",

 "uuid 0.8.2",

]

[[package]]

name = "either"

version = "1.8.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"

[[package]]

name = "fxhash"

version = "0.2.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"

dependencies = [

 "byteorder",

]

[[package]]

name = "hex"

version = "0.4.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"

[[package]]

name = "itertools"

version = "0.10.5"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"

dependencies = [

 "either",

]

[[package]]

name = "leb128"

version = "0.2.5"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"

[[package]]

 "automerge",

 "uuid 1.2.1",

 "libc",

name = "smol_str"

version = "0.1.23"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "7475118a28b7e3a2e157ce0131ba8c5526ea96e90ee601d9f6bb2e286a35ab44"

dependencies = [

 "serde",

]

[[package]]

name = "uuid"

version = "0.8.2"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"

dependencies = [

 "getrandom 0.2.8",

 "serde",

]

[[package]]

name = "uuid"

version = "1.2.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "feb41e78f93363bb2df8b0e86a2ca30eed7806ea16ea0c790d757cf93f79be83"

dependencies = [

 "getrandom 0.2.8",

 "rand 0.8.5",

 "serde",

]

[[package]]

automerge = { version = "0.1" }

uuid = { version = "1.1.2", features = ["v4", "fast-rng", "serde"] }

pub mod doc;

pub mod issue;

pub mod label;

pub mod patch;

pub mod shared;

pub mod store;

pub mod transaction;

pub mod value;

use std::collections::{HashMap, HashSet};

use std::fmt;

use std::hash::Hash;

use std::ops::Deref;

use std::str::FromStr;

use automerge::{Automerge, AutomergeError, ObjType};

use crate::cob::value::{FromValue, ValueError};

/// Error decoding a document.

#[derive(thiserror::Error, Debug)]

pub enum DocumentError {

    #[error(transparent)]

    Automerge(#[from] AutomergeError),

    #[error("property '{0}' not found in object")]

    PropertyNotFound(automerge::Prop),

    #[error("error decoding property `{0}`")]

    Property(String),

    #[error("property '{0}' is not an object")]

    NotAnObject(automerge::Prop),

    #[error("Unexpected object type: expected `{expected}`, got `{actual}`")]

    ObjectType {

        expected: automerge::ObjType,

        actual: automerge::ObjType,

    },

    #[error("error decoding value: {0}")]

    Value(#[from] ValueError),

    #[error("list under `{0}` cannot be empty")]

    EmptyList(&'static str),

}

/// Automerge document decoder.

///

/// Wraps a document, providing convenience functions. Derefs to the underlying doc.

#[derive(Copy, Clone)]

pub struct Document<'a> {

    doc: &'a Automerge,

}

impl<'a> Document<'a> {

    /// Create a new document from an automerge document.

    pub fn new(doc: &'a Automerge) -> Self {

        Self { doc }

    }

    /// Get the value of a property of an object.

    pub fn get<O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>, T: FromValue<'a>>(

        &self,

        id: O,

        prop: P,

    ) -> Result<T, DocumentError> {

        let prop = prop.into();

        let (val, _) = Document::get_raw(self, id, prop)?;

        T::from_value(val).map_err(DocumentError::from)

    }

    /// Get an object's raw property.

    pub fn get_raw<O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>>(

        &self,

        id: O,

        prop: P,

    ) -> Result<(automerge::Value<'a>, automerge::ObjId), DocumentError> {

        let prop = prop.into();

        self.doc

            .get(id.as_ref(), prop.clone())?

            .ok_or(DocumentError::PropertyNotFound(prop))

    }

    /// Get the id of an object's property.

    pub fn get_id<O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>>(

        &self,

        id: O,

        prop: P,

    ) -> Result<automerge::ObjId, DocumentError> {

        self.get_raw(id, prop).map(|(_, id)| id)

    }

    /// Get a property using a lookup function.

    pub fn lookup<V, O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>>(

        &self,

        id: O,

        prop: P,

        lookup: fn(Document, &automerge::ObjId) -> Result<V, DocumentError>,

    ) -> Result<V, DocumentError> {

        let obj_id = self.get_id(&id, prop)?;

        lookup(*self, &obj_id)

    }

    /// Get a list-like value from an object.

    pub fn list<V, O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>>(

        &self,

        id: O,

        prop: P,

        item: fn(Document, &automerge::ObjId) -> Result<V, DocumentError>,

    ) -> Result<Vec<V>, DocumentError> {

        let prop = prop.into();

        let id = id.as_ref();

        let Some((list, list_id)) = self.doc.get(id, prop.clone())? else {

            return Err(DocumentError::PropertyNotFound(prop));

        };

        let Some(objtype) = list.to_objtype() else {

            return Err(DocumentError::NotAnObject(prop));

        };

        if objtype != ObjType::List {

            return Err(DocumentError::ObjectType {

                expected: ObjType::List,

                actual: objtype,

            });

        }

        let mut objs: Vec<V> = Vec::new();

        for i in 0..self.length(&list_id) {

            let Some((_, item_id)) = self.doc.get(&list_id, i as usize)? else {

                return Err(DocumentError::PropertyNotFound(prop));

            };

            let item = item(*self, &item_id)?;

            objs.push(item);

        }

        Ok(objs)

    }

    /// Get a map-like value from an object.

    pub fn map<

        V: Default,

        K: Hash + Eq + FromStr,

        O: AsRef<automerge::ObjId>,

        P: Into<automerge::Prop>,

    >(

        &self,

        id: O,

        prop: P,

        mut value: impl FnMut(&mut V),

    ) -> Result<HashMap<K, V>, DocumentError> {

        let prop = prop.into();

        let id = id.as_ref();

        let Some((obj, obj_id)) = self.doc.get(id, prop.clone())? else {

            return Err(DocumentError::PropertyNotFound(prop))?;

        };

        let Some(objtype) = obj.to_objtype() else {

            return Err(DocumentError::NotAnObject(prop));

        };

        if objtype != ObjType::Map {

            return Err(DocumentError::ObjectType {

                expected: ObjType::Map,

                actual: objtype,

            });

        }

        let mut map = HashMap::new();

        for key in self.doc.keys(&obj_id) {

            let key = K::from_str(&key).map_err(|_| DocumentError::Property(key))?;

            let val = map.entry(key).or_default();

            value(val);

        }

        Ok(map)

    }

    /// Get a folded value out of an object.

    pub fn fold<

        T: Default,

        V: FromValue<'a> + fmt::Debug,

        O: AsRef<automerge::ObjId>,

        P: Into<automerge::Prop>,

    >(

        &self,

        id: O,

        prop: P,

        mut f: impl FnMut(&mut T, V),

    ) -> Result<T, DocumentError> {

        let prop = prop.into();

        let id = id.as_ref();

        let Some((obj, obj_id)) = self.doc.get(id, prop.clone())? else {

            return Err(DocumentError::PropertyNotFound(prop));

        };

        let Some(objtype) = obj.to_objtype() else {

            return Err(DocumentError::NotAnObject(prop));

        };

        if objtype != ObjType::List {

            return Err(DocumentError::ObjectType {

                expected: ObjType::List,

                actual: objtype,

            });

        }

        let mut acc = T::default();

        for i in 0..self.doc.length(&obj_id) {

            let Some((item, _)) = self.doc.get(&obj_id, i as usize)? else {

                return Err(DocumentError::PropertyNotFound(prop));

            };

            let val = V::from_value(item)?;

            f(&mut acc, val);

        }

        Ok(acc)

    }

    /// Get the keys of a map-like property.

    pub fn keys<K: Hash + Eq + FromStr, O: AsRef<automerge::ObjId>, P: Into<automerge::Prop>>(

        &self,

        id: O,

        prop: P,

    ) -> Result<HashSet<K>, DocumentError> {

        let prop = prop.into();

        let id = id.as_ref();

        let Some((obj, obj_id)) = self.doc.get(id, prop.clone())? else {

            return Err(DocumentError::PropertyNotFound(prop));

        };

        let Some(objtype) = obj.to_objtype() else {

            return Err(DocumentError::NotAnObject(prop));

        };

        if objtype != ObjType::Map {

            return Err(DocumentError::ObjectType {

                expected: ObjType::Map,

                actual: objtype,

            });

        }

        let mut keys = HashSet::new();

        for key in self.doc.keys(&obj_id) {

            let key = K::from_str(&key).map_err(|_| DocumentError::Property(key))?;

            keys.insert(key);

        }

        Ok(keys)

    }

}

impl<'a> Deref for Document<'a> {

    type Target = Automerge;

    fn deref(&self) -> &Self::Target {

        self.doc

    }

}

#![allow(clippy::large_enum_variant)]

use std::collections::{HashMap, HashSet};

use std::convert::TryFrom;

use std::ops::ControlFlow;

use std::str::FromStr;

use automerge::{Automerge, ObjType, ScalarValue, Value};

use once_cell::sync::Lazy;

use serde::{Deserialize, Serialize};

use crate::cob::doc::{Document, DocumentError};

use crate::cob::shared;

use crate::cob::shared::*;

use crate::cob::store::{Error, FromHistory, Store};

use crate::cob::transaction::{Transaction, TransactionError};

use crate::cob::value::{FromValue, ValueError};

use crate::cob::{Contents, History, ObjectId, TypeName};

use crate::prelude::*;

/// Type name of an issue.

pub static TYPENAME: Lazy<TypeName> =

    Lazy::new(|| FromStr::from_str("xyz.radicle.issue").expect("type name is valid"));

/// Identifier for an issue.

pub type IssueId = ObjectId;

/// Reason why an issue was closed.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]

#[serde(rename_all = "lowercase")]

pub enum CloseReason {

    Solved,

    Other,

}

/// Issue state.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]

#[serde(rename_all = "lowercase", tag = "status")]

pub enum State {

    /// The issue is open.

    Open,

    /// The issue is closed.

    Closed { reason: CloseReason },

}

impl State {

    fn lifecycle_message(self) -> String {

        match self {

            State::Open => "Open issue".to_owned(),

            State::Closed { .. } => "Close issue".to_owned(),

        }

    }

}

impl From<State> for ScalarValue {

    fn from(state: State) -> Self {

        match state {

            State::Open => ScalarValue::from("open"),

            State::Closed {

                reason: CloseReason::Solved,

            } => ScalarValue::from("solved"),

            State::Closed {

                reason: CloseReason::Other,

            } => ScalarValue::from("closed"),

        }

    }

}

impl<'a> FromValue<'a> for State {

    fn from_value(value: Value) -> Result<Self, ValueError> {

        let state = value.to_str().ok_or(ValueError::InvalidType)?;

        match state {

            "open" => Ok(Self::Open),

            "closed" => Ok(Self::Closed {

                reason: CloseReason::Other,

            }),

            "solved" => Ok(Self::Closed {

                reason: CloseReason::Solved,

            }),

            _ => Err(ValueError::InvalidValue(value.to_string())),

        }

    }

}

/// An issue or "ticket".

#[derive(Debug, Clone, Serialize, Deserialize)]

pub struct Issue {

    pub author: Author,

    pub title: String,

    pub state: State,

    pub comment: Comment,

    pub discussion: Discussion,

    pub labels: HashSet<Label>,

    pub timestamp: Timestamp,

}

impl Issue {

    pub fn author(&self) -> &Author {

        &self.author

    }

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

        &self.title

    }

    pub fn state(&self) -> State {

        self.state

    }

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

        &self.comment.body

    }

    pub fn reactions(&self) -> &HashMap<Reaction, usize> {

        &self.comment.reactions

    }

    pub fn comments(&self) -> &[Comment<Replies>] {

        &self.discussion

    }

    pub fn labels(&self) -> &HashSet<Label> {

        &self.labels

    }

    pub fn timestamp(&self) -> Timestamp {

        self.timestamp

    }

}

impl FromHistory for Issue {

    fn type_name() -> &'static TypeName {

        &TYPENAME

    }

    fn from_history(history: &History) -> Result<Self, Error> {

        let doc = history.traverse(Automerge::new(), |mut doc, entry| {

            match entry.contents() {

                Contents::Automerge(bytes) => {

                    match automerge::Change::from_bytes(bytes.clone()) {

                        Ok(change) => {

                            doc.apply_changes([change]).ok();

                        }

                        Err(_err) => {

                            // Ignore

                        }

                    }

                }

            }

            ControlFlow::Continue(doc)

        });

        let issue = Issue::try_from(doc)?;

        Ok(issue)

    }

}

impl TryFrom<&History> for Issue {

    type Error = Error;

    fn try_from(history: &History) -> Result<Self, Self::Error> {

        Issue::from_history(history)

    }

}

impl TryFrom<Automerge> for Issue {

    type Error = DocumentError;

    fn try_from(doc: Automerge) -> Result<Self, Self::Error> {

        let doc = Document::new(&doc);

        let obj_id = doc.get_id(automerge::ObjId::Root, "issue")?;

        let title = doc.get(&obj_id, "title")?;

        let comment_id = doc.get_id(&obj_id, "comment")?;

        let author = doc.get(&obj_id, "author").map(Author::new)?;

        let state = doc.get(&obj_id, "state")?;

        let timestamp = doc.get(&obj_id, "timestamp")?;

        let comment = shared::lookup::comment(doc, &comment_id)?;

        let discussion: Discussion = doc.list(&obj_id, "discussion", shared::lookup::thread)?;

        let labels: HashSet<Label> = doc.keys(&obj_id, "labels")?;

        Ok(Self {

            title,

            state,

            author,

            comment,

            discussion,

            labels,

            timestamp,

        })

    }

}

pub struct IssueStore<'a> {

    store: Store<'a, Issue>,

}

impl<'a> IssueStore<'a> {

    /// Create a new issue store.

    pub fn new(store: Store<'a, Issue>) -> Self {

        Self { store }

    }

    /// Get an issue by id.

    pub fn get(&self, id: &ObjectId) -> Result<Option<Issue>, Error> {

        self.store.get(id)

    }

    /// Create an issue.

    pub fn create<G: Signer>(

        &self,

        title: &str,

        description: &str,

        labels: &[Label],

        signer: &G,

    ) -> Result<IssueId, Error> {

        let author = self.store.author();

        let timestamp = Timestamp::now();

        let contents = events::create(&author, title, description, timestamp, labels)?;

        let cob = self.store.create("Create issue", contents, signer)?;

        Ok(*cob.id())

    }

    /// Remove an issue.

    pub fn remove<G: Signer>(&self, _issue_id: &IssueId) -> Result<(), Error> {

        todo!()

    }

    /// Comment on an issue.

    pub fn comment<G: Signer>(

        &self,

        issue_id: &IssueId,

        body: &str,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.store.author();

        let mut issue = self.store.get_raw(issue_id)?;

        let timestamp = Timestamp::now();

        let changes = events::comment(&mut issue, &author, body, timestamp)?;

        self.store

            .update(*issue_id, "Add comment", changes, signer)?;

        Ok(())

    }

    /// Life-cycle an issue, eg. open or close it.

    pub fn lifecycle<G: Signer>(

        &self,

        issue_id: &IssueId,

        state: State,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.store.author();

        let mut issue = self.store.get_raw(issue_id)?;

        let changes = events::lifecycle(&mut issue, &author, state)?;

        self.store.update(*issue_id, "Lifecycle", changes, signer)?;

        Ok(())

    }

    /// Label an issue.

    pub fn label<G: Signer>(

        &self,

        issue_id: &IssueId,

        labels: &[Label],

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.store.author();

        let mut issue = self.store.get_raw(issue_id)?;

        let changes = events::label(&mut issue, &author, labels)?;

        self.store.update(*issue_id, "Add label", changes, signer)?;

        Ok(())

    }

    /// React to an issue comment.

    pub fn react<G: Signer>(

        &self,

        issue_id: &IssueId,

        comment_id: CommentId,

        reaction: Reaction,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.store.author();

        let mut issue = self.store.get_raw(issue_id)?;

        let changes = events::react(&mut issue, comment_id, &author, &[reaction])?;

        self.store.update(*issue_id, "React", changes, signer)?;

        Ok(())

    }

    /// Reply to an issue comment.

    pub fn reply<G: Signer>(

        &self,

        issue_id: &IssueId,

        comment_id: CommentId,

        reply: &str,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.store.author();

        let mut issue = self.store.get_raw(issue_id)?;

        let changes = events::reply(&mut issue, comment_id, &author, reply, Timestamp::now())?;

        self.store.update(*issue_id, "Reply", changes, signer)?;

        Ok(())

    }

    /// Get all issues, sorted by time.

    pub fn all(&self) -> Result<Vec<(IssueId, Issue)>, Error> {

        let mut issues = self.store.list()?;

        issues.sort_by_key(|(_, i)| i.timestamp);

        Ok(issues)

    }

    /// Get the issue count.

    pub fn count(&self) -> Result<usize, Error> {

        let issues = self.store.list()?;

        Ok(issues.len())

    }

}

/// Issue events.

mod events {

    use super::*;

    use automerge::{

        transaction::{CommitOptions, Transactable},

        ObjId,

    };

    pub fn create(

        author: &Author,

        title: &str,

        description: &str,

        timestamp: Timestamp,

        labels: &[Label],

    ) -> Result<Contents, TransactionError> {

        let title = title.trim();

        if title.is_empty() {

            return Err(TransactionError::InvalidValue("title"));

        }

        let mut doc = Automerge::new();

        let _issue = doc

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message("Create issue".to_owned()),

                |tx| {

                    let issue = tx.put_object(ObjId::Root, "issue", ObjType::Map)?;

                    tx.put(&issue, "title", title)?;

                    tx.put(&issue, "author", author)?;

                    tx.put(&issue, "state", State::Open)?;

                    tx.put(&issue, "timestamp", timestamp)?;

                    tx.put_object(&issue, "discussion", ObjType::List)?;

                    let labels_id = tx.put_object(&issue, "labels", ObjType::Map)?;

                    for label in labels {

                        tx.put(&labels_id, label.name().trim(), true)?;

                    }

                    // Nb. The top-level comment doesn't have a `replies` field.

                    let comment_id = tx.put_object(&issue, "comment", ObjType::Map)?;

                    tx.put(&comment_id, "body", description.trim())?;

                    tx.put(&comment_id, "author", author)?;

                    tx.put(&comment_id, "timestamp", timestamp)?;

                    tx.put_object(&comment_id, "reactions", ObjType::Map)?;

                    Ok(issue)

                },

            )

            .map_err(|failure| failure.error)?

            .result;

        Ok(Contents::Automerge(doc.save_incremental()))

    }

    pub fn comment(

        issue: &mut Automerge,

        author: &Author,

        body: &str,

        timestamp: Timestamp,

    ) -> Result<Contents, TransactionError> {

        let _comment = issue

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message("Add comment".to_owned()),

                |tx| {

                    let mut tx = Transaction::new(tx);

                    let (_obj, obj_id) = tx.get(ObjId::Root, "issue")?;

                    let (_, discussion_id) = tx.get(&obj_id, "discussion")?;

                    let length = tx.length(&discussion_id);

                    let comment = tx.insert_object(&discussion_id, length, ObjType::Map)?;

                    tx.put(&comment, "author", author)?;

                    tx.put(&comment, "body", body.trim())?;

                    tx.put(&comment, "timestamp", timestamp)?;

                    tx.put_object(&comment, "replies", ObjType::List)?;

                    tx.put_object(&comment, "reactions", ObjType::Map)?;

                    Ok(comment)

                },

            )

            .map_err(|failure| failure.error)?

            .result;

        #[allow(clippy::unwrap_used)]

        let change = issue.get_last_local_change().unwrap().raw_bytes().to_vec();

        Ok(Contents::Automerge(change))

    }

    pub fn lifecycle(

        issue: &mut Automerge,

        author: &Author,

        state: State,

    ) -> Result<Contents, TransactionError> {

        issue

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message(state.lifecycle_message()),

                |tx| {

                    let mut tx = Transaction::new(tx);

                    let (_, obj_id) = tx.get(ObjId::Root, "issue")?;

                    tx.put(&obj_id, "state", state)?;

                    tx.put(&obj_id, "author", author)?;

                    Ok(())

                },

            )

            .map_err(|failure| failure.error)?;

        #[allow(clippy::unwrap_used)]

        let change = issue.get_last_local_change().unwrap().raw_bytes().to_vec();

        Ok(Contents::Automerge(change))

    }

    pub fn label(

        issue: &mut Automerge,

        _author: &Author,

        labels: &[Label],

    ) -> Result<Contents, TransactionError> {

        issue

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message("Label issue".to_owned()),

                |tx| {

                    let mut tx = Transaction::new(tx);

                    let (_, obj_id) = tx.get(ObjId::Root, "issue")?;

                    let (_, labels_id) = tx.get(&obj_id, "labels")?;

                    for label in labels {

                        tx.put(&labels_id, label.name().trim(), true)?;

                    }

                    Ok(())

                },

            )

            .map_err(|failure| failure.error)?;

        #[allow(clippy::unwrap_used)]

        let change = issue.get_last_local_change().unwrap().raw_bytes().to_vec();

        Ok(Contents::Automerge(change))

    }

    pub fn reply(

        issue: &mut Automerge,

        comment_id: CommentId,

        author: &Author,

        body: &str,

        timestamp: Timestamp,

    ) -> Result<Contents, TransactionError> {

        issue

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message("Reply".to_owned()),

                |tx| {

                    let mut tx = Transaction::new(tx);

                    let (_, obj_id) = tx.get(ObjId::Root, "issue")?;

                    let (_, discussion_id) = tx.get(&obj_id, "discussion")?;

                    let (_, comment_id) = tx.get(&discussion_id, usize::from(comment_id))?;

                    let (_, replies_id) = tx.get(&comment_id, "replies")?;

                    let length = tx.length(&replies_id);

                    let reply = tx.insert_object(&replies_id, length, ObjType::Map)?;

                    // Nb. Replies don't themselves have replies.

                    tx.put(&reply, "author", author)?;

                    tx.put(&reply, "body", body.trim())?;

                    tx.put(&reply, "timestamp", timestamp)?;

                    tx.put_object(&reply, "reactions", ObjType::Map)?;

                    Ok(())

                },

            )

            .map_err(|failure| failure.error)?;

        #[allow(clippy::unwrap_used)]

        let change = issue.get_last_local_change().unwrap().raw_bytes().to_vec();

        Ok(Contents::Automerge(change))

    }

    pub fn react(

        issue: &mut Automerge,

        comment_id: CommentId,

        author: &Author,

        reactions: &[Reaction],

    ) -> Result<Contents, TransactionError> {

        issue

            .transact_with::<_, _, TransactionError, _, ()>(

                |_| CommitOptions::default().with_message("React".to_owned()),

                |tx| {

                    let mut tx = Transaction::new(tx);

                    let (_, obj_id) = tx.get(ObjId::Root, "issue")?;

                    let (_, discussion_id) = tx.get(&obj_id, "discussion")?;

                    let (_, comment_id) = if comment_id == CommentId::root() {

                        tx.get(&obj_id, "comment")?

                    } else {

                        tx.get(&discussion_id, usize::from(comment_id) - 1)?

                    };

                    let (_, reactions_id) = tx.get(&comment_id, "reactions")?;

                    for reaction in reactions {

                        let key = reaction.emoji.to_string();

                        let reaction_id = if let Some((_, reaction_id)) =

                            tx.try_get(&reactions_id, key)?

                        {

                            reaction_id

                        } else {

                            tx.put_object(&reactions_id, reaction.emoji.to_string(), ObjType::Map)?

                        };

                        tx.put(&reaction_id, author.id.to_human(), true)?;

                    }

                    Ok(())

                },

            )

            .map_err(|failure| failure.error)?;

        #[allow(clippy::unwrap_used)]

        let change = issue.get_last_local_change().unwrap().raw_bytes().to_vec();

        Ok(Contents::Automerge(change))

    }

}

#[cfg(test)]

mod test {

    use super::*;

    use crate::test;

    #[test]

    fn test_issue_create_and_get() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let timestamp = Timestamp::now();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        assert_eq!(issue.title(), "My first issue");

        assert_eq!(issue.author(), &store.author());

        assert_eq!(issue.description(), "Blah blah blah.");

        assert_eq!(issue.comments().len(), 0);

        assert_eq!(issue.state(), State::Open);

        assert!(issue.timestamp() >= timestamp);

    }

    #[test]

    fn test_issue_create_and_change_state() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        issues

            .lifecycle(

                &issue_id,

                State::Closed {

                    reason: CloseReason::Other,

                },

                &signer,

            )

            .unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        assert_eq!(

            issue.state(),

            State::Closed {

                reason: CloseReason::Other

            }

        );

        issues.lifecycle(&issue_id, State::Open, &signer).unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        assert_eq!(issue.state(), State::Open);

    }

    #[test]

    fn test_issue_react() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        let reaction = Reaction::new('🥳').unwrap();

        issues

            .react(&issue_id, CommentId::root(), reaction, &signer)

            .unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        let count = issue.reactions()[&reaction];

        // TODO: Test multiple reactions from same author and different authors

        assert_eq!(count, 1);

    }

    #[test]

    fn test_issue_reply() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        issues.comment(&issue_id, "Ho ho ho.", &signer).unwrap();

        issues

            .reply(&issue_id, CommentId::root(), "Hi hi hi.", &signer)

            .unwrap();

        issues

            .reply(&issue_id, CommentId::root(), "Ha ha ha.", &signer)

            .unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        let reply1 = &issue.comments()[0].replies[0];

        let reply2 = &issue.comments()[0].replies[1];

        assert_eq!(reply1.body, "Hi hi hi.");

        assert_eq!(reply2.body, "Ha ha ha.");

    }

    #[test]

    fn test_issue_label() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        let bug_label = Label::new("bug").unwrap();

        let wontfix_label = Label::new("wontfix").unwrap();

        issues

            .label(&issue_id, &[bug_label.clone()], &signer)

            .unwrap();

        issues

            .label(&issue_id, &[wontfix_label.clone()], &signer)

            .unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        let labels = issue.labels();

        assert!(labels.contains(&bug_label));

        assert!(labels.contains(&wontfix_label));

    }

    #[test]

    fn test_issue_comment() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let now = Timestamp::now();

        let author = *signer.public_key();

        let issue_id = issues

            .create("My first issue", "Blah blah blah.", &[], &signer)

            .unwrap();

        issues.comment(&issue_id, "Ho ho ho.", &signer).unwrap();

        issues.comment(&issue_id, "Ha ha ha.", &signer).unwrap();

        let issue = issues.get(&issue_id).unwrap().unwrap();

        let c1 = &issue.comments()[0];

        let c2 = &issue.comments()[1];

        assert_eq!(&c1.body, "Ho ho ho.");

        assert_eq!(c1.author.id(), &author);

        assert_eq!(&c2.body, "Ha ha ha.");

        assert_eq!(c2.author.id(), &author);

        assert!(c1.timestamp >= now);

    }

    #[test]

    fn test_issue_state_serde() {

        assert_eq!(

            serde_json::to_value(State::Open).unwrap(),

            serde_json::json!({ "status": "open" })

        );

        assert_eq!(

            serde_json::to_value(State::Closed {

                reason: CloseReason::Solved

            })

            .unwrap(),

            serde_json::json!({ "status": "closed", "reason": "solved" })

        );

    }

    #[test]

    fn test_issue_all() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let issues = store.issues();

        let author = store.author();

        let contents =

            events::create(&author, "First", "Blah blah.", Timestamp::new(0), &[]).unwrap();

        issues

            .store

            .create("Create issue", contents, &signer)

            .unwrap();

        let contents =

            events::create(&author, "Second", "Blah blah.", Timestamp::new(1), &[]).unwrap();

        issues

            .store

            .create("Create issue", contents, &signer)

            .unwrap();

        let contents =

            events::create(&author, "Third", "Blah blah.", Timestamp::new(2), &[]).unwrap();

        issues

            .store

            .create("Create issue", contents, &signer)

            .unwrap();

        let issues = issues.all().unwrap();

        assert_eq!(issues.len(), 3);

        // Issues are sorted by timestamp.

        assert_eq!(issues[0].1.title(), "First");

        assert_eq!(issues[1].1.title(), "Second");

        assert_eq!(issues[2].1.title(), "Third");

    }

}

#![allow(clippy::large_enum_variant)]

use std::convert::TryFrom;

use std::ops::ControlFlow;

use std::str::FromStr;

use automerge::{Automerge, ObjType};

use once_cell::sync::Lazy;

use serde::{Deserialize, Serialize};

use crate::cob::doc::Document;

use crate::cob::shared::*;

use crate::cob::store::{Error, FromHistory, Store};

use crate::cob::transaction::TransactionError;

use crate::cob::{Contents, History, ObjectId, TypeName};

use crate::prelude::*;

pub static TYPENAME: Lazy<TypeName> =

    Lazy::new(|| FromStr::from_str("xyz.radicle.label").expect("type name is valid"));

/// Identifier for a label.

pub type LabelId = ObjectId;

/// Describes a label.

#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]

pub struct Label {

    pub name: String,

    pub description: String,

    pub color: Color,

}

impl FromHistory for Label {

    fn type_name() -> &'static TypeName {

        &TYPENAME

    }

    fn from_history(history: &History) -> Result<Self, Error> {

        Label::try_from(history)

    }

}

impl TryFrom<&History> for Label {

    type Error = Error;

    fn try_from(history: &History) -> Result<Self, Self::Error> {

        let doc = history.traverse(Automerge::new(), |mut doc, entry| {

            match entry.contents() {

                Contents::Automerge(bytes) => {

                    match automerge::Change::from_bytes(bytes.clone()) {

                        Ok(change) => {

                            doc.apply_changes([change]).ok();

                        }

                        Err(_err) => {

                            // Ignore

                        }

                    }

                }

            }

            ControlFlow::Continue(doc)

        });

        let label = Label::try_from(doc)?;

        Ok(label)

    }

}

impl TryFrom<Automerge> for Label {

    type Error = Error;

    fn try_from(doc: Automerge) -> Result<Self, Self::Error> {

        let doc = Document::new(&doc);

        let obj_id = doc.get_id(automerge::ObjId::Root, "label")?;

        let name = doc.get(&obj_id, "name")?;

        let description = doc.get(&obj_id, "description")?;

        let color = doc.get(&obj_id, "color")?;

        Ok(Self {

            name,

            description,

            color,

        })

    }

}

pub struct LabelStore<'a> {

    store: Store<'a, Label>,

}

impl<'a> LabelStore<'a> {

    pub fn new(store: Store<'a, Label>) -> Self {

        Self { store }

    }

    pub fn create<G: Signer>(

        &self,

        name: &str,

        description: &str,

        color: &Color,

        signer: &G,

    ) -> Result<LabelId, Error> {

        let author = self.store.author();

        let _timestamp = Timestamp::now();

        let contents = events::create(&author, name, description, color)?;

        let cob = self.store.create("Create label", contents, signer)?;

        Ok(*cob.id())

    }

    pub fn get(&self, id: &LabelId) -> Result<Option<Label>, Error> {

        self.store.get(id)

    }

}

mod events {

    use super::*;

    use automerge::{

        transaction::{CommitOptions, Transactable},

        ObjId,

    };

    pub fn create(

        _author: &Author,

        name: &str,

        description: &str,

        color: &Color,

    ) -> Result<Contents, TransactionError> {

        let name = name.trim();

        if name.is_empty() {

            return Err(TransactionError::InvalidValue("name"));

        }

        let mut doc = Automerge::new();

        doc.transact_with::<_, _, TransactionError, _, ()>(

            |_| CommitOptions::default().with_message("Create label".to_owned()),

            |tx| {

                let label = tx.put_object(ObjId::Root, "label", ObjType::Map)?;

                tx.put(&label, "name", name)?;

                tx.put(&label, "description", description)?;

                tx.put(&label, "color", color.to_string())?;

                Ok(label)

            },

        )

        .map_err(|failure| failure.error)?;

        Ok(Contents::Automerge(doc.save_incremental()))

    }

}

#[cfg(test)]

mod test {

    use super::*;

    use crate::test;

    #[test]

    fn test_label_create_and_get() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, project) = test::setup::context(&tmp);

        let store = Store::open(*signer.public_key(), &project).unwrap();

        let labels = store.labels();

        let label_id = labels

            .create(

                "bug",

                "Something that doesn't work",

                &Color::from_str("#ff0000").unwrap(),

                &signer,

            )

            .unwrap();

        let label = labels.get(&label_id).unwrap().unwrap();

        assert_eq!(label.name, "bug");

        assert_eq!(label.description, "Something that doesn't work");

        assert_eq!(label.color.to_string(), "#ff0000");

    }

}

#![allow(clippy::too_many_arguments)]

use std::collections::{HashMap, HashSet};

use std::convert::TryFrom;

use std::fmt;

use std::ops::{ControlFlow, Deref, RangeInclusive};

use std::str::FromStr;

use std::sync::Arc;

use automerge::transaction::Transactable;

use automerge::{Automerge, AutomergeError, ObjType, ScalarValue, Value};

use nonempty::NonEmpty;

use once_cell::sync::Lazy;

use serde::{Deserialize, Serialize};

use crate::cob::doc::{Document, DocumentError};

use crate::cob::shared;

use crate::cob::shared::*;

use crate::cob::store::Error;

use crate::cob::store::{FromHistory, Store};

use crate::cob::transaction::{Transaction, TransactionError};

use crate::cob::value::{FromValue, ValueError};

use crate::cob::{Contents, History, ObjectId, TypeName};

use crate::git;

use crate::prelude::*;

/// Type name of a patch.

pub static TYPENAME: Lazy<TypeName> =

    Lazy::new(|| FromStr::from_str("xyz.radicle.patch").expect("type name is valid"));

/// Identifier for a patch.

pub type PatchId = ObjectId;

/// Unique identifier for a patch revision.

pub type RevisionId = uuid::Uuid;

/// Index of a revision in the revisions list.

pub type RevisionIx = usize;

/// Where a patch is intended to be merged.

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

#[serde(rename_all = "lowercase")]

pub enum MergeTarget {

    /// Intended for the default branch of the project delegates.

    /// Note that if the delegations change while the patch is open,

    /// this will always mean whatever the "current" delegation set is.

    #[default]

    Delegates,

}

impl From<MergeTarget> for ScalarValue {

    fn from(target: MergeTarget) -> Self {

        match target {

            MergeTarget::Delegates => ScalarValue::from("delegates"),

        }

    }

}

impl<'a> FromValue<'a> for MergeTarget {

    fn from_value(value: Value<'a>) -> Result<Self, ValueError> {

        let state = value.to_str().ok_or(ValueError::InvalidType)?;

        match state {

            "delegates" => Ok(Self::Delegates),

            _ => Err(ValueError::InvalidValue(value.to_string())),

        }

    }

}

/// A patch to a repository.

#[derive(Debug, Clone, Serialize)]

pub struct Patch<T = ()>

where

    T: Clone,

{

    /// Author of the patch.

    pub author: Author,

    /// Title of the patch.

    pub title: String,

    /// Current state of the patch.

    pub state: State,

    /// Target this patch is meant to be merged in.

    pub target: MergeTarget,

    /// Labels associated with the patch.

    pub labels: HashSet<Label>,

    /// List of patch revisions. The initial changeset is part of the

    /// first revision.

    pub revisions: NonEmpty<Revision<T>>,

    /// Patch creation time.

    pub timestamp: Timestamp,

}

impl Patch {

    pub fn head(&self) -> &git::Oid {

        &self.revisions.last().oid

    }

    pub fn version(&self) -> RevisionIx {

        self.revisions.len() - 1

    }

    pub fn latest(&self) -> (RevisionIx, &Revision) {

        let version = self.version();

        let revision = &self.revisions[version];

        (version, revision)

    }

    pub fn is_proposed(&self) -> bool {

        matches!(self.state, State::Proposed)

    }

    pub fn is_archived(&self) -> bool {

        matches!(self.state, State::Archived)

    }

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

        self.latest().1.description()

    }

}

impl FromHistory for Patch {

    fn type_name() -> &'static TypeName {

        &TYPENAME

    }

    fn from_history(history: &History) -> Result<Self, Error> {

        Patch::try_from(history)

    }

}

impl TryFrom<Document<'_>> for Patch {

    type Error = DocumentError;

    fn try_from(doc: Document) -> Result<Self, Self::Error> {

        let obj_id = doc.get_id(automerge::ObjId::Root, "patch")?;

        let title = doc.get(&obj_id, "title")?;

        let author = doc.get(&obj_id, "author")?;

        let state = doc.get(&obj_id, "state")?;

        let target = doc.get(&obj_id, "target")?;

        let timestamp = doc.get(&obj_id, "timestamp")?;

        let revisions = doc.list(&obj_id, "revisions", lookup::revision)?;

        let labels: HashSet<Label> = doc.keys(&obj_id, "labels")?;

        let revisions =

            NonEmpty::from_vec(revisions).ok_or(DocumentError::EmptyList("revisions"))?;

        let author: Author = Author::new(author);

        Ok(Self {

            author,

            title,

            state,

            target,

            labels,

            revisions,

            timestamp,

        })

    }

}

impl TryFrom<&History> for Patch {

    type Error = Error;

    fn try_from(history: &History) -> Result<Self, Self::Error> {

        let doc = history.traverse(Automerge::new(), |mut doc, entry| {

            match entry.contents() {

                Contents::Automerge(bytes) => {

                    match automerge::Change::from_bytes(bytes.clone()) {

                        Ok(change) => {

                            doc.apply_changes([change]).ok();

                        }

                        Err(_err) => {

                            // Ignore

                        }

                    }

                }

            }

            ControlFlow::Continue(doc)

        });

        let patch = Patch::try_from(Document::new(&doc))?;

        Ok(patch)

    }

}

pub struct PatchStore<'a> {

    store: Store<'a, Patch>,

}

impl<'a> Deref for PatchStore<'a> {

    type Target = Store<'a, Patch>;

    fn deref(&self) -> &Self::Target {

        &self.store

    }

}

impl<'a> PatchStore<'a> {

    /// Create a new patch store.

    pub fn new(store: Store<'a, Patch>) -> Self {

        Self { store }

    }

    /// Get a patch by id.

    pub fn get(&self, id: &ObjectId) -> Result<Option<Patch>, Error> {

        self.store.get(id)