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

version = "0.4.22"

checksum = "bfd4d1b31faaa3a89d7934dbded3111da0d2ef28e3ebccdb4f0179f5929d1ef1"

version = "0.14.0"

checksum = "81224dc661606574f5a0f28c9947d0ee1d93ff11c5f1c4e7272f52e8c0b5483c"

name = "fxhash"

version = "0.2.1"

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

checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"

dependencies = [

 "byteorder",

]

[[package]]

name = "leb128"

version = "0.2.5"

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

checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"

[[package]]

 "automerge",

 "uuid 1.2.2",

name = "smol_str"

version = "0.1.23"

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

checksum = "7475118a28b7e3a2e157ce0131ba8c5526ea96e90ee601d9f6bb2e286a35ab44"

dependencies = [

 "serde",

]

[[package]]

version = "1.8.0"

checksum = "9724f9a975fb987ef7a3cd9be0350edcbe130698af5b8f7a631e23d42d052484"

version = "0.9.4"

checksum = "a45526d29728d135c2900b0d30573fe3ee79fceb12ef534c7bb30e810a91b601"

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.2"

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

checksum = "422ee0de9031b5b948b97a8fc04e3aa35230001a722ddd27943e0be31564ce4c"

dependencies = [

 "getrandom 0.2.8",

 "rand 0.8.5",

 "serde",

]

[[package]]

use radicle::cob::automerge;

use radicle::cob::patch::{Patch, PatchId};

    let cobs = automerge::Store::open(*profile.id(), &repository)?;

    let patches = cobs.patches();

    let patch = patches

        .get(&patch_id)?

        .ok_or_else(|| anyhow!("couldn't find patch {} locally", &options.id))?;

    let revision_id = options.revision.unwrap_or_else(|| patch.version());

    let revision = patch

        .revisions

        .get(revision_id)

        .ok_or_else(|| anyhow!("revision R{} does not exist", revision_id))?;

        term::format::dim(format!("R{}", revision_id)),

        term::format::tertiary(patch.author.id),

            merge_commit(&repo, patch_id, &patch_commit, &patch, cobs.public_key())?;

    patches.merge(&patch_id, revision_id, head_oid.into(), &signer)?;

    let description = patch.description().trim();

        patch.author.id()

        write!(&mut merge_msg, "{}", patch.description().trim())?;

    writeln!(&mut merge_msg, "Rad-Author: {}", patch.author.id())?;

use radicle::cob::automerge::patch::{MergeTarget, Patch, PatchId, PatchStore};

    patches: &PatchStore,

) -> anyhow::Result<Vec<(PatchId, Patch)>> {

    for (id, patch) in proposed {

        let (_, rev) = patch.latest();

            matches.push((id, patch));

use radicle::cob::automerge;

use radicle::cob::automerge::patch::{MergeTarget, Patch, PatchId, PatchStore};

    let cobs = automerge::Store::open(profile.public_key, storage)?;

    let patches = cobs.patches();

            if let Some((id, patch)) = result.pop() {

                        term::format::italic(&patch.title)

                    Some((id, patch))

            if let Some(patch) = patches.get(id)? {

            return update(

                patch, id, &base_oid, &head_oid, &patches, workdir, options, &signer,

            );

        term::format::dim(term::format::node(cobs.public_key())),

    let id = patches.create(

    term::success!("Patch {} created 🌱", term::format::highlight(id));

    patch: Patch,

    patches: &PatchStore,

    let (current, current_revision) = patch.latest();

        term::format::dim(format!("R{}", current)),

        term::format::dim(format!("R{}", current + 1)),

    let new = patches.update(&patch_id, message, *base, *head, signer)?;

    assert_eq!(new, current + 1);

use radicle::cob::automerge;

use radicle::cob::patch::{Patch, PatchId, Verdict};

    let cobs = automerge::Store::open(*profile.id(), storage)?;

    let patches = cobs.patches();

    for (id, patch) in proposed {

        if *patch.author.id() == me {

            print(cobs.public_key(), id, patch, &workdir, storage)?;

    let target_head = common::patch_merge_target_oid(patch.target, storage)?;

    let you = patch.author.id() == whoami;

        term::format::tertiary(patch.author.id()),

    author_info.push(term::format::dim(term::format::timestamp(&patch.timestamp)));

    let revision = patch.revisions.last();

        term::format::bold(&patch.title),

    for merge in &revision.merges {

    for review in revision.reviews.values() {

        let verdict = match review.verdict {

        let peer = storage.remote(review.author.id())?;

            review.timestamp,

                term::format::tertiary(review.author.id()),

use radicle::cob;

use radicle::cob::automerge::patch::{PatchId, RevisionIx, Verdict};

    let cobs = cob::automerge::Store::open(*profile.id(), &repository)?;

    let patches = cobs.patches();

    let patch = patches

        .get(&patch_id)?

    let _revision = patch

        .revisions

        .get(revision_ix)

        term::format::tertiary(patch.author.id())

    patches.review(

        &patch_id,

        revision_ix,

        message,

automerge = { version = "0.1" }

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

pub mod automerge;

pub mod doc;

pub mod label;

pub mod patch;

pub mod shared;

pub mod store;

pub mod transaction;

pub mod value;

pub use store::Store;

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::automerge::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::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::automerge::doc::Document;

use crate::cob::automerge::shared::FromHistory;

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

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

use crate::cob::common::*;

use crate::cob::{Contents, History, ObjectId, Timestamp, 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| {

            let bytes = entry.contents();

            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(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::ops::{ControlFlow, Deref};

use std::sync::Arc;

use automerge::transaction::Transactable;

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

use nonempty::NonEmpty;

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

use crate::cob::automerge::shared;

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

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

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

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

use crate::cob::common::*;

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

use crate::git;

use crate::prelude::*;

// Re-export generic patch.

pub use crate::cob::patch::*;

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<Tag> = 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,

        })

    }

}

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)

    }

    /// Create a patch.

    pub fn create<G: Signer>(

        &self,

        title: &str,

        description: &str,

        target: MergeTarget,

        base: impl Into<git::Oid>,

        oid: impl Into<git::Oid>,

        labels: &[Tag],

        signer: &G,

    ) -> Result<PatchId, Error> {

        let author = self.author();

        let timestamp = Timestamp::now();

        let revision = Revision::new(

            author.clone(),

            base.into(),

            oid.into(),

            description.to_owned(),

            timestamp,

        );

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

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

        Ok(*cob.id())

    }

    /// Comment on a patch.

    pub fn comment<G: Signer>(

        &self,

        patch_id: &PatchId,

        revision_ix: RevisionIx,

        body: &str,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.author();

        let mut patch = self.store.get_raw(patch_id)?;

        let timestamp = Timestamp::now();

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

        self.store

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

        Ok(())

    }

    /// Update a patch with new code. Creates a new revision.

    pub fn update<G: Signer>(

        &self,

        patch_id: &PatchId,

        comment: impl ToString,

        base: impl Into<git::Oid>,

        oid: impl Into<git::Oid>,

        signer: &G,

    ) -> Result<RevisionIx, Error> {

        let author = self.author();

        let timestamp = Timestamp::now();

        let revision = Revision::new(

            author,

            base.into(),

            oid.into(),

            comment.to_string(),

            timestamp,

        );

        let mut patch = self.get_raw(patch_id)?;

        let (revision_ix, changes) = events::update(&mut patch, revision)?;

        self.store

            .update(*patch_id, "Update patch", changes, signer)?;

        Ok(revision_ix)

    }

    /// Reply to a patch comment.

    pub fn reply<G: Signer>(

        &self,

        patch_id: &PatchId,

        revision_ix: RevisionIx,

        comment_id: CommentId,

        reply: &str,

        signer: &G,

    ) -> Result<(), Error> {

        let author = self.author();

        let mut patch = self.get_raw(patch_id)?;

        let changes = events::reply(

            &mut patch,

            revision_ix,

            comment_id,

            &author,

            reply,

            Timestamp::now(),

        )?;

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

        Ok(())

    }

    /// Review a patch revision.

    pub fn review<G: Signer>(

        &self,

        patch_id: &PatchId,

        revision_ix: RevisionIx,

        verdict: Option<Verdict>,

        comment: impl Into<String>,

        inline: Vec<CodeComment>,

        signer: &G,

    ) -> Result<(), Error> {

        let timestamp = Timestamp::now();

        let review = Review::new(self.author(), verdict, comment, inline, timestamp);

        let mut patch = self.get_raw(patch_id)?;

        let (_, changes) = events::review(&mut patch, revision_ix, review)?;

        self.store

            .update(*patch_id, "Review patch", changes, signer)?;

        Ok(())

    }

    /// Merge a patch revision.

    pub fn merge<G: Signer>(

        &self,

        patch_id: &PatchId,

        revision_ix: RevisionIx,

        commit: git::Oid,

        signer: &G,

    ) -> Result<Merge, Error> {

        let timestamp = Timestamp::now();

        let merge = Merge {

            node: *signer.public_key(),

            commit,

            timestamp,

        };

        let mut patch = self.get_raw(patch_id)?;

        let changes = events::merge(&mut patch, revision_ix, &merge)?;

        self.store

            .update(*patch_id, "Merge revision", changes, signer)?;

        Ok(merge)

    }

    /// Get the patch count.

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

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

        Ok(cobs.len())

    }

    /// Get all patches for this project.

    pub fn all(&self) -> Result<Vec<(PatchId, Patch)>, Error> {

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

        patches.sort_by_key(|(_, p)| p.timestamp);

        Ok(patches)

    }

    /// Get proposed patches.

    pub fn proposed(&self) -> Result<impl Iterator<Item = (PatchId, Patch)>, Error> {

        let all = self.all()?;

        Ok(all.into_iter().filter(|(_, p)| p.is_proposed()))

    }

    /// Get patches proposed by the given key.

    pub fn proposed_by<'b>(

        &'b self,

        who: &'b PublicKey,

    ) -> Result<impl Iterator<Item = (PatchId, Patch)> + '_, Error> {

        Ok(self.proposed()?.filter(move |(_, p)| p.author.id() == who))

    }

}

impl From<State> for ScalarValue {

    fn from(state: State) -> Self {

        match state {

            State::Proposed => ScalarValue::from("proposed"),

            State::Draft => ScalarValue::from("draft"),

            State::Archived => ScalarValue::from("archived"),

        }

    }

}

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

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

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

        match state {

            "proposed" => Ok(Self::Proposed),

            "draft" => Ok(Self::Draft),

            "archived" => Ok(Self::Archived),

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

        }

    }

}

impl Revision {

    /// Put this object into an automerge document.

    fn put<'a>(

        &self,

        mut tx: impl AsMut<automerge::transaction::Transaction<'a>>,

        id: &automerge::ObjId,

    ) -> Result<(), AutomergeError> {

        assert!(

            self.merges.is_empty(),

            "Cannot put revision with non-empty merges"

        );

        assert!(

            self.reviews.is_empty(),

            "Cannot put revision with non-empty reviews"

        );

        assert!(

            self.discussion.is_empty(),

            "Cannot put revision with non-empty discussion"

        );

        let tx = tx.as_mut();

        tx.put(id, "id", self.id.to_string())?;

        tx.put(id, "oid", self.oid.to_string())?;

        tx.put(id, "base", self.base.to_string())?;

        self.comment.put(tx, id)?;

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

        tx.put_object(id, "reviews", ObjType::Map)?;

        tx.put_object(id, "merges", ObjType::List)?;

        tx.put(id, "timestamp", self.timestamp)?;

        Ok(())

    }

}

impl From<Verdict> for ScalarValue {

    fn from(verdict: Verdict) -> Self {

        #[allow(clippy::unwrap_used)]

        let s = serde_json::to_string(&verdict).unwrap(); // Cannot fail.

        ScalarValue::from(s)

    }

}

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

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

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

        serde_json::from_str(verdict).map_err(|e| ValueError::Other(Arc::new(e)))

    }

}

impl Review {

    /// Put this object into an automerge document.

    fn put<'a>(

        &self,

        mut tx: impl AsMut<automerge::transaction::Transaction<'a>>,

        id: &automerge::ObjId,

    ) -> Result<(), AutomergeError> {

        assert!(

            self.inline.is_empty(),

            "Cannot put review with non-empty inline comments"

        );

        let tx = tx.as_mut();

        tx.put(id, "author", &self.author)?;

        tx.put(

            id,

            "verdict",

            if let Some(v) = self.verdict {

                v.into()

            } else {

                ScalarValue::Null

            },

        )?;

        self.comment.put(tx, id)?;

        tx.put_object(id, "inline", ObjType::List)?;

        tx.put(id, "timestamp", self.timestamp)?;

        Ok(())

    }

}

impl FromHistory for Patch {

    fn type_name() -> &'static TypeName {

        &TYPENAME

    }

    /// Create a patch from an automerge history.

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

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

            let bytes = entry.contents();

            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)

    }

}

mod lookup {

    use super::*;

    pub fn revision(

        doc: Document,

        revision_id: &automerge::ObjId,

    ) -> Result<Revision, DocumentError> {

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

        let reviews_id = doc.get_id(revision_id, "reviews")?;

        let id = doc.get(revision_id, "id")?;

        let base = doc.get(revision_id, "base")?;

        let oid = doc.get(revision_id, "oid")?;

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

        let merges: Vec<Merge> = doc.list(revision_id, "merges", self::merge)?;

        // Discussion.

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

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

        // Reviews.

        let mut reviews: HashMap<NodeId, Review> = HashMap::new();

        for key in (*doc).keys(&reviews_id) {

            let review_id = doc.get_id(&reviews_id, key)?;

            let review = self::review(doc, &review_id)?;

            reviews.insert(*review.author.id(), review);

        }

        Ok(Revision {

            id,

            base,

            oid,

            comment,

            discussion,

            reviews,

            merges,

            changeset: (),

            timestamp,

        })

    }

    pub fn merge(doc: Document, obj_id: &automerge::ObjId) -> Result<Merge, DocumentError> {

        let node = doc.get(obj_id, "peer")?;

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

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

        Ok(Merge {

            node,

            commit,

            timestamp,

        })

    }

    pub fn review(doc: Document, obj_id: &automerge::ObjId) -> Result<Review, DocumentError> {

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

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

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

        let comment = doc.lookup(obj_id, "comment", shared::lookup::thread)?;

        let inline = vec![];

        Ok(Review {

            author: Author::new(author),

            comment,

            verdict,

            inline,

            timestamp,

        })

    }

}

/// Patch events.

mod events {

    use super::*;

    use automerge::{

        transaction::{CommitOptions, Transactable},

        ObjId,

    };

    pub fn create(

        author: &Author,

        title: &str,

        revision: &Revision,

        target: MergeTarget,

        timestamp: Timestamp,

        labels: &[Tag],

    ) -> Result<Contents, TransactionError> {

        let title = title.trim();

        if title.is_empty() {

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

        }

        let mut doc = Automerge::new();

        let _patch = doc

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

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

                |tx| {

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

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

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

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

                    tx.put(&patch_id, "state", State::Proposed)?;

                    tx.put(&patch_id, "target", target)?;

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

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

                    for label in labels {

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

                    }

                    let revisions_id = tx.put_object(&patch_id, "revisions", ObjType::List)?;

                    let revision_id = tx.insert_object(&revisions_id, 0, ObjType::Map)?;

                    revision.put(tx, &revision_id)?;

                    Ok(patch_id)

                },

            )

            .map_err(|failure| failure.error)?

            .result;

        Ok(doc.save_incremental())

    }

    pub fn comment(

        patch: &mut Automerge,

        revision_ix: RevisionIx,

        author: &Author,

        body: &str,

        timestamp: Timestamp,

    ) -> Result<Contents, TransactionError> {

        let _comment = patch

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

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

                |t| {

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

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

                    let (_, revisions_id) = tx.get(&obj_id, "revisions")?;

                    let (_, revision_id) = tx.get(&revisions_id, revision_ix)?;

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

                    let length = tx.length(&discussion_id);