Publish Draft Changes — heartwood

This patch introduces an API for publishing draft changes ensuring that the history of any published changes are compatible and preserved.

  "log",
  "nonempty 0.9.0",
  "once_cell",
  "pretty_assertions",
  "qcheck",
  "qcheck-macros",
  "radicle-crypto",

 [dev-dependencies]
 fastrand = { version = "2.0.0", default-features = false }
 tempfile = { version = "3" }
 pretty_assertions = { version = "1" }
 qcheck = { version = "1", default-features = false }
 qcheck-macros = { version = "1", default-features = false }
 [dev-dependencies.radicle-crypto]
 path = "../radicle-crypto"
 version = "0"
 features = ["test"]
 features = ["test", "radicle-git-ext"]

 use radicle_git_ext::commit::trailers::OwnedTrailer;
 use crate::change::store::Version;
 use crate::change::{ChangeEntry, MergeEntry};
 use crate::signatures;
 use crate::trailers::CommitTrailer;
 use crate::{

 /// Name of the COB manifest file.
 pub const MANIFEST_BLOB_NAME: &str = "manifest";
 /// The kind of change entry a commit represents.
 pub const ENTRY_KIND: &str = "kind";
 /// Path under which COB embeds are kept.
 pub static EMBEDS_PATH: Lazy<PathBuf> = Lazy::new(|| PathBuf::from("embeds"));

             #[source]
             err: serde_json::Error,
         },
         #[error("the 'kind' found at '{0}' was not a blob")]
         EntryKindIsNotBlob(Oid),
         #[error("the 'kinf' found at '{id}' was invalid: {err}")]
         InvalidEntryKind {
             id: Oid,
             #[source]
             err: serde_json::Error,
         },
         #[error("a 'change' file was expected be found in '{0}'")]
         NoChange(Oid),
         #[error("the 'change' found at '{0}' was not a blob")]

         })
     }
     fn merge<G>(
         &self,
         tips: Vec<Self::ObjectId>,
         signer: &G,
         type_name: crate::TypeName,
         message: String,
     ) -> Result<store::MergeEntry<Self::Parent, Self::ObjectId, Self::Signatures>, Self::StoreError>
     where
         G: crypto::Signer,
     {
         let manifest = store::Manifest::new(type_name, Version::default());
         let revision = write_merge_manifest(self, &manifest)?;
         let tree = self.find_tree(revision)?;
         let signature = {
             let sig = signer.sign(revision.as_bytes());
             let key = signer.public_key();
             ExtendedSignature::new(*key, sig)
         };
         let (id, timestamp) = write_commit(
             self,
             None,
             tips.iter().copied().map(git2::Oid::from),
             message,
             signature.clone(),
             None,
             tree,
         )?;
         Ok(MergeEntry {
             id,
             revision: revision.into(),
             signature,
             parents: tips,
             manifest,
             timestamp,
         })
     }
     fn parents_of(&self, id: &Oid) -> Result<Vec<Oid>, Self::LoadError> {
         Ok(self
             .find_commit(**id)?

             .collect::<Vec<_>>())
     }
     fn load(&self, id: Self::ObjectId) -> Result<Entry, Self::LoadError> {
     fn load(&self, id: Self::ObjectId) -> Result<ChangeEntry, Self::LoadError> {
         let commit = Commit::read(self, id.into())?;
         let timestamp = git2::Time::from(commit.committer().time).seconds() as u64;
         let trailers = parse_trailers(commit.trailers())?;

         let tree = self.find_tree(*commit.tree())?;
         let manifest = load_manifest(self, &tree)?;
         let contents = load_contents(self, &tree)?;
         Ok(Entry {
             id,
             revision: tree.id().into(),
             signature: ExtendedSignature::new(key, sig),
             resource: resources.pop(),
             related,
             parents,
             manifest,
             contents,
             timestamp,
         })
         let kind = load_entry_kind(self, &tree)?;
         match kind {
             store::EntryKind::Merge => Ok(ChangeEntry::Merge(MergeEntry {
                 id,
                 revision: tree.id().into(),
                 signature: ExtendedSignature::new(key, sig),
                 parents,
                 manifest,
                 timestamp,
             })),
             store::EntryKind::Commit => {
                 let contents = load_contents(self, &tree)?;
                 Ok(ChangeEntry::Entry(Entry {
                     id,
                     revision: tree.id().into(),
                     signature: ExtendedSignature::new(key, sig),
                     resource: resources.pop(),
                     related,
                     parents,
                     manifest,
                     contents,
                     timestamp,
                 }))
             }
         }
     }
 }

     })
 }
 fn load_entry_kind(
     repo: &git2::Repository,
     tree: &git2::Tree,
 ) -> Result<store::EntryKind, error::Load> {
     tree.get_name(ENTRY_KIND)
         .map_or(Ok(store::EntryKind::Commit), |entry| {
             let object = entry.to_object(repo)?;
             let blob = object
                 .as_blob()
                 .ok_or_else(|| error::Load::EntryKindIsNotBlob(tree.id().into()))?;
             serde_json::from_slice(blob.content()).map_err(|err| error::Load::InvalidEntryKind {
                 id: tree.id().into(),
                 err,
             })
         })
 }
 fn load_contents(repo: &git2::Repository, tree: &git2::Tree) -> Result<Contents, error::Load> {
     let ops = tree
         .iter()

     Ok((Oid::from(oid), timestamp as u64))
 }
 fn write_merge_manifest(
     repo: &git2::Repository,
     manifest: &store::Manifest,
 ) -> Result<git2::Oid, git2::Error> {
     let mut root = repo.treebuilder(None)?;
     // Insert manifest file into tree.
     {
         // SAFETY: we're serializing to an in memory buffer so the only source of
         // errors here is a programming error, which we can't recover from.
         #[allow(clippy::unwrap_used)]
         let manifest = serde_json::to_vec(manifest).unwrap();
         #[allow(clippy::unwrap_used)]
         let kind = serde_json::to_vec(&store::EntryKind::Merge).unwrap();
         let manifest_oid = repo.blob(&manifest)?;
         root.insert(
             MANIFEST_BLOB_NAME,
             manifest_oid,
             git2::FileMode::Blob.into(),
         )?;
         let kind_oid = repo.blob(&kind)?;
         root.insert(ENTRY_KIND, kind_oid, git2::FileMode::Blob.into())?;
     }
     let oid = root.write()?;
     Ok(oid)
 }
 fn write_manifest(
     repo: &git2::Repository,
     manifest: &store::Manifest,

 /// A single change in the change graph.
 pub type Entry = store::Entry<Oid, Oid, ExtendedSignature>;
 pub type MergeEntry = store::MergeEntry<Oid, Oid, ExtendedSignature>;
 pub type ChangeEntry = store::ChangeEntry<Oid, Oid, ExtendedSignature>;

     where
         G: crypto::Signer;
     /// Merge a set of entries into a [`MergeEntry`].
     #[allow(clippy::type_complexity)]
     fn merge<G>(
         &self,
         tips: Vec<Self::ObjectId>,
         signer: &G,
         type_name: TypeName,
         message: String,
     ) -> Result<MergeEntry<Self::ObjectId, Self::ObjectId, Self::Signatures>, Self::StoreError>
     where
         G: crypto::Signer;
     /// Load a change entry.
     #[allow(clippy::type_complexity)]
     fn load(
         &self,
         id: Self::ObjectId,
     ) -> Result<Entry<Self::Parent, Self::ObjectId, Self::Signatures>, Self::LoadError>;
     ) -> Result<ChangeEntry<Self::Parent, Self::ObjectId, Self::Signatures>, Self::LoadError>;
     /// Returns the parents of the object with the specified ID.
     fn parents_of(&self, id: &Oid) -> Result<Vec<Oid>, Self::LoadError>;

     pub contents: NonEmpty<Vec<u8>>,
 }
 /// Change template, used to create a new change.
 pub struct MergeTemplate<Id> {
     pub type_name: TypeName,
     pub tips: Vec<Id>,
     pub message: String,
     pub embeds: Vec<Embed<Oid>>,
     pub contents: NonEmpty<Vec<u8>>,
 }
 /// Entry contents.
 /// This is the change payload.
 pub type Contents = NonEmpty<Vec<u8>>;

 /// A unique identifier for a history entry.
 pub type EntryId = Oid;
 /// An entry for a change made in the store.
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum ChangeEntry<Resource, Id, Signature> {
     /// A single entry that contains contents.
     Entry(Entry<Resource, Id, Signature>),
     /// A merge of two or more entries.
     Merge(MergeEntry<Resource, Id, Signature>),
 }
 impl<R, I, S> ChangeEntry<R, I, S> {
     /// Get the identifier for the change.
     pub fn id(&self) -> &I {
         match self {
             ChangeEntry::Entry(change) => &change.id,
             ChangeEntry::Merge(change) => &change.id,
         }
     }
     /// Get the parent identifier of the change.
     pub fn parents(&self) -> &Vec<R> {
         match self {
             ChangeEntry::Entry(change) => &change.parents,
             ChangeEntry::Merge(change) => &change.parents,
         }
     }
     /// Get the optional resource identifier.
     pub fn resource(&self) -> Option<&R> {
         match self {
             ChangeEntry::Entry(change) => change.resource(),
             ChangeEntry::Merge(_) => None,
         }
     }
     /// Get the timestamp this change occurred at.
     pub fn timestamp(&self) -> &Timestamp {
         match self {
             ChangeEntry::Entry(c) => &c.timestamp,
             ChangeEntry::Merge(c) => &c.timestamp,
         }
     }
     /// Convert the `ChangeEntry` into its underlying [`Entry`].
     ///
     /// Returns `None` is it is a [`MergeEntry`].
     pub fn as_entry(&self) -> Option<&Entry<R, I, S>> {
         match self {
             ChangeEntry::Entry(e) => Some(e),
             ChangeEntry::Merge(_) => None,
         }
     }
     /// Convert the `ChangeEntry` into its underlying [`Entry`].
     ///
     /// Returns `None` is it is a [`MergeEntry`].
     pub fn into_entry(self) -> Option<Entry<R, I, S>> {
         match self {
             ChangeEntry::Entry(e) => Some(e),
             ChangeEntry::Merge(_) => None,
         }
     }
 }
 impl<R, I, S> From<Entry<R, I, S>> for ChangeEntry<R, I, S> {
     fn from(entry: Entry<R, I, S>) -> Self {
         Self::Entry(entry)
     }
 }
 impl<R, I, S> From<MergeEntry<R, I, S>> for ChangeEntry<R, I, S> {
     fn from(entry: MergeEntry<R, I, S>) -> Self {
         Self::Merge(entry)
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Entry<Resource, Id, Signature> {
     /// The content address of the entry itself.

     }
 }
 impl<R, Id> ChangeEntry<R, Id, signatures::ExtendedSignature>
 where
     Id: AsRef<[u8]>,
 {
     pub fn valid_signatures(&self) -> bool {
         match self {
             ChangeEntry::Entry(c) => c.valid_signatures(),
             ChangeEntry::Merge(c) => c.valid_signatures(),
         }
     }
     pub fn author(&self) -> &crypto::PublicKey {
         match self {
             ChangeEntry::Entry(c) => c.author(),
             ChangeEntry::Merge(c) => c.author(),
         }
     }
 }
 impl<R, Id> Entry<R, Id, signatures::ExtendedSignature>
 where
     Id: AsRef<[u8]>,

     }
 }
 impl<R, Id> MergeEntry<R, Id, signatures::ExtendedSignature>
 where
     Id: AsRef<[u8]>,
 {
     pub fn valid_signatures(&self) -> bool {
         self.signature.verify(self.revision.as_ref())
     }
     pub fn author(&self) -> &crypto::PublicKey {
         &self.signature.key
     }
 }
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct MergeEntry<Resource, Id, Signature> {
     /// The content address of the entry itself.
     pub id: Id,
     /// The content address of the tree of the entry.
     pub revision: Id,
     /// The cryptographic signature(s) and their public keys of the
     /// authors.
     pub signature: Signature,
     /// The set of entries that are being merged.
     pub parents: Vec<Resource>,
     /// The manifest describing the type of object as well as the type
     /// of history for this entry.
     pub manifest: Manifest,
     /// Timestamp of change.
     pub timestamp: Timestamp,
 }
 #[derive(Clone, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Manifest {

     }
 }
 #[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq, Serialize, Deserialize)]
 pub enum EntryKind {
     Merge,
     #[default]
     Commit,
 }
 /// COB version.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct Version(NonZeroUsize);

 // Copyright © 2021 The Radicle Link Contributors
 use std::ops::ControlFlow;
 use std::ops::{ControlFlow, Deref};
 use std::{cmp::Ordering, collections::BTreeSet};
 use git_ext::Oid;
 use radicle_dag::Dag;
 use crate::ChangeEntry;
 use crate::{
     change, object, object::collaboration::Evaluate, signatures::ExtendedSignature,
     CollaborativeObject, Entry, EntryId, History, ObjectId, TypeName,
     CollaborativeObject, EntryId, History, ObjectId, TypeName,
 };
 #[derive(Debug, thiserror::Error)]

 /// The graph of changes for a particular collaborative object
 pub(super) struct ChangeGraph {
     object_id: ObjectId,
     graph: Dag<Oid, Entry>,
     graph: Dag<Oid, ChangeEntry>,
 }
 impl ChangeGraph {

         let root = self
             .graph
             .get(&root)
             .ok_or(EvaluateError::MissingRoot(root))?;
             .ok_or_else(|| EvaluateError::MissingRoot(root))?;
         if !root.valid_signatures() {
             return Err(EvaluateError::Signature(root.id));
             return Err(EvaluateError::Signature(*root.id()));
         }
         let Some(root) = root.clone().map_value(|e| e.into_entry()).transpose_value() else {
             return Err(EvaluateError::Init(
                 "root must not be a merge entry".to_string().into(),
             ));
         };
         // Evaluate the root separately, since we can't have a COB without a valid root.
         // Then, traverse the graph starting from the root's dependents.
         let mut object =
             T::init(&root.value, store).map_err(|e| EvaluateError::Init(Box::new(e)))?;
         let mut object = T::init(&root, store).map_err(|e| EvaluateError::Init(Box::new(e)))?;
         let children = Vec::from_iter(root.dependents.iter().cloned());
         let manifest = root.manifest.clone();
         let root = root.id;
         let root = root.id();
         self.graph.prune_by(
             &children,

                 if !entry.valid_signatures() {
                     return ControlFlow::Break(());
                 }
                 // Apply the entry to the state, and if there's an error, prune that branch.
                 if object
                     .apply(entry, siblings.map(|(k, n)| (k, &n.value)), store)
                     .is_err()
                 {
                     return ControlFlow::Break(());
                 match entry.deref() {
                     change::store::ChangeEntry::Entry(entry) => {
                         // Apply the entry to the state, and if there's an error, prune that branch.
                         if object
                             .apply(
                                 entry,
                                 siblings.filter_map(|(k, n)| n.value.as_entry().map(|e| (k, e))),
                                 store,
                             )
                             .is_err()
                         {
                             ControlFlow::Break(())
                         } else {
                             ControlFlow::Continue(())
                         }
                     }
                     change::store::ChangeEntry::Merge(_) => ControlFlow::Continue(()),
                 }
                 ControlFlow::Continue(())
             },
             Self::chronological,
         );

         Ok(CollaborativeObject {
             manifest,
             object,
             history: History::new(root, self.graph),
             history: History::new(*root, self.graph),
             id: self.object_id,
         })
     }

         self.graph.len()
     }
     fn chronological(x: (&Oid, &Entry), y: (&Oid, &Entry)) -> Ordering {
         x.1.timestamp.cmp(&y.1.timestamp).then(x.0.cmp(y.0))
     fn chronological(x: (&Oid, &ChangeEntry), y: (&Oid, &ChangeEntry)) -> Ordering {
         x.1.timestamp().cmp(y.1.timestamp()).then(x.0.cmp(y.0))
     }
 }
 struct GraphBuilder {
     graph: Dag<Oid, Entry>,
     graph: Dag<Oid, ChangeEntry>,
 }
 impl Default for GraphBuilder {

 impl GraphBuilder {
     /// Add a change to the graph which we are building up, returning any edges
     /// corresponding to the parents of this node in the change graph
     fn add_change(&mut self, commit_id: Oid, change: Entry) -> Vec<(Oid, Oid)> {
     fn add_change(&mut self, commit_id: Oid, change: ChangeEntry) -> Vec<(Oid, Oid)> {
         let resource = change.resource().copied();
         let parents = change.parents.clone();
         let parents = change.parents().clone();
         if !self.graph.contains(&commit_id) {
             self.graph.node(commit_id, change);

 // Copyright © 2021 The Radicle Link Contributors
 #![allow(clippy::too_many_arguments)]
 use std::{cmp::Ordering, collections::BTreeSet, ops::ControlFlow};
 use std::{
     cmp::Ordering,
     collections::BTreeSet,
     ops::{ControlFlow, Deref},
 };
 use git_ext::Oid;
 use radicle_dag::Dag;
 pub use crate::change::{Contents, Entry, EntryId, Timestamp};
 pub use crate::change::{ChangeEntry, Contents, Entry, EntryId, Timestamp};
 /// The DAG of changes making up the history of a collaborative object.
 #[derive(Clone, Debug)]
 pub struct History {
     graph: Dag<EntryId, Entry>,
     graph: Dag<EntryId, ChangeEntry>,
     root: EntryId,
 }

 impl History {
     /// Create a new history from a DAG. Panics if the root is not part of the graph.
     pub fn new(root: EntryId, graph: Dag<EntryId, Entry>) -> Self {
     pub fn new(root: EntryId, graph: Dag<EntryId, ChangeEntry>) -> Self {
         assert!(
             graph.contains(&root),
             "History::new: root must be present in graph"
         );
         assert!(
             graph
                 .get(&root)
                 .and_then(|entry| entry.as_entry())
                 .is_some(),
             "History::new: root must be an `Entry` variant",
         );
         Self { root, graph }
     }

     pub fn new_from_root(root: Entry) -> Self {
         let id = *root.id();
         Self::new(id, Dag::root(id, root))
         Self::new(id, Dag::root(id, ChangeEntry::Entry(root)))
     }
     /// Get all the tips of the graph.

     where
         F: for<'r> FnMut(A, &'r EntryId, &'r Entry) -> ControlFlow<A, A>,
     {
         self.graph.fold(roots, init, |acc, k, v| f(acc, k, v))
         self.graph.fold(roots, init, |acc, k, v| match v.deref() {
             ChangeEntry::Entry(v) => f(acc, k, v),
             _ => ControlFlow::Continue(acc),
         })
     }
     /// Return a topologically-sorted list of history entries.

             .sorted_by(compare)
             .into_iter()
             .filter_map(|k| self.graph.get(&k))
             .map(|node| &node.value)
             .filter_map(|node| match &node.value {
                 crate::change::store::ChangeEntry::Entry(entry) => Some(entry),
                 crate::change::store::ChangeEntry::Merge(_) => None,
             })
     }
     /// Extend this history with a new entry.
     pub fn extend(&mut self, change: Entry) {
     pub fn extend(&mut self, change: ChangeEntry) {
         let tips = self.tips();
         let id = *change.id();

     }
     /// Get the underlying graph
     pub fn graph(&self) -> &Dag<EntryId, Entry> {
     pub fn graph(&self) -> &Dag<EntryId, ChangeEntry> {
         &self.graph
     }
     /// Get the root entry.
     pub fn root(&self) -> &Entry {
         // SAFETY: We don't allow construction of histories without a root.
         // SAFETY: We don't allow construction of histories without a root and
         // the root must be the `Entry` variant.
         self.graph
             .get(&self.root)
             .expect("History::root: the root entry must be present in the graph")
             .as_entry()
             .expect("History::root: the root entry must be an `Entry` variant")
     }
     /// Get the children of the given entry.

 //!   * [`list`]
 //!   * [`update`]
 //!
 //! There is an additional [`merge`] function that allows an interface for
 //! keeping track of draft changes on a separate reference, which can then be
 //! merged back into the published reference.
 //!
 //! ## Storage
 //!
 //! The storing of collaborative objects is based on a git

 pub mod change;
 pub use change::store::{Contents, Embed, EntryId, Manifest, Version};
 pub use change::Entry;
 pub use change::{ChangeEntry, Entry, MergeEntry};
 pub mod history;
 pub use history::History;

 pub mod object;
 pub use object::{
     create, get, info, list, remove, update, CollaborativeObject, Create, Evaluate, ObjectId,
     Update, Updated,
     create, get, info, list, merge, remove, update, CollaborativeObject, Create, Evaluate, Merge,
     Merged, ObjectId, Update, Updated,
 };
 #[cfg(test)]

 pub mod collaboration;
 pub use collaboration::{
     create, get, info, list, parse_refstr, remove, update, CollaborativeObject, Create, Evaluate,
     Update, Updated,
     create, get, info, list, merge, parse_refstr, remove, update, CollaborativeObject, Create,
     Evaluate, Merge, Merged, Update, Updated,
 };
 pub mod storage;

 mod list;
 pub use list::list;
 mod merge;
 pub use merge::{merge, Draft, Merge, Merged, Published};
 mod remove;
 pub use remove::remove;