"radicle-crypto",

 "radicle-git-ext",

 "radicle-ssh",

 "serde",

 "serde_json",

 "siphasher",

```

$ rad id edit --title "Add Alice" --description "Add Alice as a delegate" --delegates did:key:z6MkedTZGJGqgQ2py2b8kGecfxdt2yRdHWF6JpaZC47fovFn --no-confirm

title: Add Alice

description: Add Alice as a delegate

status: ❲open❳

```

$ rad id edit --title "Add Bob" --description "Add Bob as a delegate" --delegates did:key:z6MkjchhfUsD6mmvni8mCdXHw216Xrm9bQe2mBH1P5RDjVJG --no-confirm

title: Add Bob

description: Add Bob as a delegate

status: ❲open❳

through that and see what happens.

```

✓ Accepted proposal ✓

title: Add Alice

description: Add Alice as a delegate

```

```

✓ Committed new identity '29ae4b72f5a315328f06fbd68dc1c396a2d5c45e' 🌱

title: Add Alice

description: Add Alice as a delegate

Now, when we go to accept the second proposal:

```

! Warning: Revision is out of date

! Warning: d96f425412c9f8ad5d9a9a05c9831d0728e2338d =/= 475cdfbc8662853dd132ec564e4f5eb0f152dd7f

👉 Consider using 'rad id rebase' to update the proposal to the latest identity

If we attempt to commit this revision, the command will fail:

```

! Warning: Revision is out of date

! Warning: d96f425412c9f8ad5d9a9a05c9831d0728e2338d =/= 475cdfbc8662853dd132ec564e4f5eb0f152dd7f

👉 Consider using 'rad id rebase' to update the proposal to the latest identity

```

So, let's fix this by running a rebase on the proposal's revision:

```

title: Add Bob

description: Add Bob as a delegate

status: ❲open❳

We can now update the proposal to have both keys in the delegates set:

```

title: Add Bob

description: Add Bob as a delegate

status: ❲open❳

Finally, we can accept and commit this proposal, creating the final

state of our new Radicle identity:

```

✓ Accepted proposal ✓

title: Add Bob

description: Add Bob as a delegate

```

```

✓ Committed new identity '60de897bc24898f6908fd1272633c0b15aa4096f' 🌱

title: Add Bob

description: Add Bob as a delegate

```

$ rad id edit --title "Add Bob" --description "Add Bob as a delegate" --delegates did:key:z6MkedTZGJGqgQ2py2b8kGecfxdt2yRdHWF6JpaZC47fovFn --no-confirm

title: Add Bob

description: Add Bob as a delegate

status: ❲open❳

Let's see what happens when we reject the change:

```

✓ Rejected proposal 👎

title: Add Bob

description: Add Bob as a delegate

Instead, let's accept the proposal:

```

✓ Accepted proposal ✓

title: Add Bob

description: Add Bob as a delegate

At this point, we can commit the proposal and update the identity:

```

✓ Committed new identity 'c96e764965aaeff1c6ea3e5b97e2b9828773c8b0' 🌱

title: Add Bob

description: Add Bob as a delegate

```

$ rad id edit --title "Update threshold" --description "Update to safer threshold" --threshold 2 --no-confirm

title: Update threshold

description: Update to safer threshold

status: ❲open❳

But we change our minds and decide to close the proposal instead:

```

title: Update threshold

description: Update to safer threshold

status: ❲closed❳

```

$ rad id list

```

And if we want to view the latest state of any proposal we can use the

show command:

```

title: Update threshold

description: Update to safer threshold

status: ❲closed❳

```

$ rad issue list

```

Great! Now we've documented the issue for ourselves and others.

Let's assign ourselves to this one.

```

```

It will now show in the list of issues assigned to us.

```

$ rad issue list --assigned

```

Note: this can always be undone with the `unassign` subcommand.

```

```

Great, now we have communicated to the world about our car's defect.

It will help whoever works on a fix.

```

```

3e674d1 Define power requirements

To publish your patch to the network, run:

    rad push

❲YOU PROPOSED❳

└─ * opened by did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi (you) [..]

❲OTHERS PROPOSED❳

Nothing to show.

Define power requirements

[flux-capacitor-power 27857ec] Add README, just for the fun

 1 file changed, 0 insertions(+), 0 deletions(-)

 create mode 100644 README.md

🌱 Updating patch for heartwood

✓ Pushing HEAD to storage...

✓ Analyzing remotes...

1 commit(s) ahead, 0 commit(s) behind

```

And lets leave a quick comment for our team:

```

```

Now, let's checkout the patch that we just created:

```

✓ Performing patch checkout...

```

            history_type,

        };

        let tree = self.find_tree(revision)?;

        let signature = {

            let sig = signer.sign(revision.as_bytes());

            let key = signer.public_key();

                    let blob = entry

                        .to_object(repo)

                        .and_then(|object| object.peel_to_blob())

                        .map(|b| (name, b));

                    Some(blob)

    repo: &git2::Repository,

    manifest: &store::Manifest,

    contents: &NonEmpty<Vec<u8>>,

    let mut tb = repo.treebuilder(None)?;

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

        git2::FileMode::Blob.into(),

    )?;

    for (ix, op) in contents.iter().enumerate() {

        let oid = repo.blob(op.as_ref())?;

        tb.insert(&ix.to_string(), oid, git2::FileMode::Blob.into())?;

    }

    let tree_oid = tb.write()?;

}

                let clock = graph[&c.oid]

                    .dependencies

                    .iter()

                    .max()

                    .unwrap_or_default() // When there are no operations, the clock is zero.

                    + 1;

    pub fn clock(&self) -> Clock {

        self.graph

            .tips()

            .max()

            .unwrap_or_default()

    }

//

// This file is part of radicle-link, distributed under the GPLv3 with Radicle

// Linking Exception. For full terms see the included LICENSE file.

use git_ext::Oid;

use nonempty::NonEmpty;

use radicle_crypto::PublicKey;

use crate::pruning_fold;

/// Entry contents.

/// This is the change payload.

/// Logical clock used to track causality in change graph.

pub type Clock = u64;

pub type Timestamp = u64;

/// A unique identifier for a history entry.

pub struct EntryId(Oid);

impl From<git2::Oid> for EntryId {

    fn from(id: git2::Oid) -> Self {

        Self(id.into())

        self.clock

    }

    /// Iterator over the changes, including the clock.

    }

}

pub mod object;

pub use object::{

};

#[cfg(test)]

pub mod collaboration;

pub use collaboration::{

    create, get, info, list, parse_refstr, remove, update, CollaborativeObject, Create, Update,

};

pub mod storage;

pub use remove::remove;

mod update;

/// A collaborative object

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

use super::error;

/// The data required to update an object

pub struct Update {

    /// The type of history that will be used for this object.

    resource: Oid,

    identifier: &S::Identifier,

    args: Update,

where

    S: Store,

    G: crypto::Signer,

        change.timestamp,

    );

}

use radicle_crypto::Signer;

use crate::{

};

use super::test;

        .unwrap()

        .expect("BUG: cob was missing");

        &storage,

        &signer,

        proj.project.content_id,

    )

    .unwrap();

        .unwrap()

        .expect("BUG: cob was missing");

}

#[test]

    )

    .unwrap();

        &storage,

        &neil_signer,

        neil_proj.project.content_id,

    .unwrap();

    // traverse over the history and filter by changes that were only authorized by terry

        if entry.actor() == terry_signer.public_key() {

        }

        ControlFlow::Continue(acc)

    });

    assert_eq!(contents, vec![b"issue 1".to_vec()]);

    // traverse over the history and filter by changes that were only authorized by neil

        ControlFlow::Continue(acc)

    });

                StatusCode::INTERNAL_SERVER_ERROR,

                Some(e.message().to_owned()),

            ),

                tracing::error!("Error: {:?}", &self);

            }

        };

use radicle::cob::issue::{Issue, IssueId};

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

use radicle::cob::thread::{self, CommentId};

use radicle_surf::blob::Blob;

use radicle_surf::tree::Tree;

use radicle_surf::{Commit, Stats};

#[derive(Serialize)]

#[serde(rename_all = "camelCase")]

struct Comment {

    author: Author,

    body: String,

    reactions: [String; 0],

                "assignees": [],

                "discussion": [

                  {

                    "author": {

                        "id": "did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi"

                    },

    #[tokio::test]

    async fn test_projects_issues_create() {

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

        let ctx = test::contributor(tmp.path());

                  "status": "open",

              },

              "discussion": [{

                  "author": {

                      "id": CONTRIBUTOR_PUB_KEY,

                  },

                  "replyTo": null,

                },

                {

                  "author": {

                      "id": CONTRIBUTOR_PUB_KEY,

                  },

        test::create_session(ctx).await;

        let body = serde_json::to_vec(&json!({

          "action": {

            "type": "comment",

            "body": "This is a reply to the first comment",

        }}))

        .unwrap();

        let response = patch(

            &app,

            format!("/projects/{CONTRIBUTOR_RID}/issues/{CONTRIBUTOR_ISSUE_ID}"),

                "tags": [],

                "revisions": [

                    {

                        "description": "",

                        "reviews": [],

                    }

                "tags": [],

                "revisions": [

                    {

                        "description": "",

                        "reviews": [],

                    }

    #[tokio::test]

    async fn test_projects_create_patches() {

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

        let ctx = test::contributor(tmp.path());

                "tags": [],

                "revisions": [

                    {

                        "description": "",

                        "reviews": [],

                    }

use std::path::Path;

use std::str::FromStr;

use std::sync::Arc;

use radicle::cob::issue::Issues;

use radicle::cob::patch::{MergeTarget, Patches};

use radicle::git::{raw as git2, RefString};

use radicle::storage::ReadStorage;

use radicle_crypto::test::signer::MockSigner;

use crate::api::{auth, Context};

pub const HEAD: &str = "1e978d19f251cd9821d9d9a76d1bd436bf0690d5";

pub const HEAD_1: &str = "f604ce9fd5b7cc77b7609beda45ea8760bee78f7";

pub const SESSION_ID: &str = "u9MGAkkfkMOv0uDDB2WeUHBT7HbsO2Dy";

pub const TIMESTAMP: u64 = 1671125284;

pub const CONTRIBUTOR_RID: &str = "rad:z4XaCmN3jLSeiMvW15YTDpNbDHFhG";

pub const CONTRIBUTOR_PUB_KEY: &str = "did:key:z6Mkk7oqY4pPxhMmGEotDYsFo97vhCj85BLY1H256HrJmjN8";

const PASSWORD: &str = "radicle";

pub fn seed(dir: &Path) -> Context {

}

pub fn contributor(dir: &Path) -> Context {

}

    let workdir = dir.join("hello-world");

    env::set_var("RAD_COMMIT_TIME", TIMESTAMP.to_string());

    env::set_var("RAD_PASSPHRASE", PASSWORD);

    fs::create_dir_all(&workdir).unwrap();

    // add commits to workdir (repo)

    let repo = git2::Repository::init(&workdir).unwrap();

    )

    .unwrap();

    // rad init

    let repo = git2::Repository::open(&workdir).unwrap();

    let name = "hello-world".to_string();

    let description = "Rad repository for tests".to_string();

    let branch = RefString::try_from("master").unwrap();

    let storage = &profile.storage;

    let repo = storage.repository(id).unwrap();

    let mut issues = Issues::open(&repo).unwrap();

        .create(

            "Issue #1".to_string(),

            "Change 'hello world' to 'hello everyone'".to_string(),

            &[],

            &[],

        )

        .unwrap();

    let mut patches = Patches::open(&repo).unwrap();

    let oid = radicle::git::Oid::from_str(HEAD).unwrap();

    let base = radicle::git::Oid::from_str(HEAD_1).unwrap();

        .create(

            "A new `hello word`",

            "change `hello world` in README to something else",

            base,

            oid,

            &[],

        )

        .unwrap();

serde_json = { version = "1", features = ["preserve_order"] }

siphasher = { version = "0.3.10" }

radicle-git-ext = { version = "0", features = ["serde"] }

sqlite = { version = "0.30.3", optional = true }

tempfile = { version = "3.3.0" }

thiserror = { version = "1" }

pub use cob::{create, get, list, remove, update};

pub use cob::{

};

pub use common::*;

use radicle_cob as cob;

use super::{

    thread::{self, Thread},

};

/// The logical clock we use to order operations to proposals.

pub type ProposalId = ObjectId;

/// Proposal operation.

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

    /// For example, this can occur if an operation references anothern operation

    /// that hasn't happened yet.

    #[error("causal dependency {0:?} missing")]

    #[error("the proposal is committed")]

    Committed,

    #[error(transparent)]

    Commit(#[from] CommitError),

    #[error("the revision {0:?} is redacted")]

    /// Error applying an op to the proposal thread.

    #[error("thread apply failed: {0}")]

    Thread(#[from] thread::OpError),

    #[error(transparent)]

    Identity(#[from] IdentityError),

    #[error("the proposal {0} is closed")]

    #[error("the revision {0} is missing")]

    #[error(

        "the identity hashes do match '{current} =/= {expected}' for the revision '{revision}'"

    )]

    Mismatch {

        current: Oid,

        expected: Oid,

    },

    #[error("the revision {0} is already committed")]

    #[error("the revision {0} is redacted")]

    #[error(transparent)]

    Doc(#[from] DocError),

    #[error("signatures did not reach quorum threshold: {0}")]

    /// List of revisions for this proposal.

    revisions: GMap<RevisionId, Redactable<Revision>>,

    /// Timeline of events.

}

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

                        revision.discussion.apply([cob::Op::new(

                            op.id,

                            action,

                            op.author,

                            op.timestamp,

                            op.clock,

        &mut self,

        revision: RevisionId,

        signature: Signature,

        self.push(Action::Accept {

            revision,

            signature,

        })

    }

        self.push(Action::Reject { revision })

    }

        &mut self,

        title: impl ToString,

        description: impl ToString,

        self.push(Action::Edit {

            title: title.to_string(),

            description: description.to_string(),

        })

    }

        self.push(Action::Redact { revision })

    }

        self.push(Action::Revision { current, proposed })

    }

        &mut self,

        revision: RevisionId,

        body: S,

        self.push(Action::Thread {

            revision,

            action: thread::Action::Comment {

        revision: RevisionId,

        body: S,

        reply_to: thread::CommentId,

        self.push(Action::Thread {

            revision,

            action: thread::Action::Comment {

        }

    }

        &mut self,

        message: &str,

        signer: &G,

        operations: F,

    where

        G: Signer,

    {

        self.proposal.apply(ops)?;

        self.clock = clock;

    }

    /// Get the internal logical clock.

        revision: RevisionId,

        signature: Signature,

        signer: &G,

        self.transaction("Accept", signer, |tx| tx.accept(revision, signature))

    }

    /// Reject a proposal revision.

        self.transaction("Reject", signer, |tx| tx.reject(revision))

    }

        title: String,

        description: String,

        signer: &G,

        self.transaction("Edit", signer, |tx| tx.edit(title, description))

    }

    /// Commit a proposal.

        self.transaction("Commit", signer, |tx| tx.push(Action::Commit))

    }

    /// Close a proposal.

        self.transaction("Close", signer, |tx| tx.push(Action::Close))

    }

        body: S,

        reply_to: thread::CommentId,

        signer: &G,

        self.transaction("Comment", signer, |tx| tx.comment(revision, body, reply_to))

    }

        current: impl Into<Oid>,

        proposed: Doc<Verified>,

        signer: &G,

        self.transaction("Add revision", signer, |tx| {

            tx.revision(current.into(), proposed)

        })

                Ok(())

            })?;

        // Just a sanity check that our clock is advancing as expected.

        Ok(ProposalMut::new(id, proposal, clock, self))

    }

use crate::cob::store::Transaction;

use crate::cob::thread;

use crate::cob::thread::{CommentId, Thread};

use crate::crypto::Signer;

use crate::prelude::Did;

use crate::storage::git as storage;

                    self.thread.apply([cob::Op::new(

                        op.id,

                        action,

                        op.author,

                        op.timestamp,

                        op.clock,

        &mut self,

        add: impl IntoIterator<Item = ActorId>,

        remove: impl IntoIterator<Item = ActorId>,

        let add = add.into_iter().collect::<Vec<_>>();

        let remove = remove.into_iter().collect::<Vec<_>>();

    }

    /// Set the issue title.

        self.push(Action::Edit {

            title: title.to_string(),

        })

    }

    /// Lifecycle an issue.

        self.push(Action::Lifecycle { state })

    }

    /// Create the issue thread.

        self.push(Action::from(thread::Action::Comment {

            body: body.to_string(),

            reply_to: None,

        &mut self,

        body: S,

        reply_to: CommentId,

        self.push(Action::from(thread::Action::Comment {

            body: body.to_string(),

            reply_to: Some(reply_to),

        &mut self,

        add: impl IntoIterator<Item = Tag>,

        remove: impl IntoIterator<Item = Tag>,

        let add = add.into_iter().collect::<Vec<_>>();

        let remove = remove.into_iter().collect::<Vec<_>>();

    }

    /// React to an issue comment.

        self.push(Action::Thread {

            action: thread::Action::React {

                to,

        &mut self,

        assignees: impl IntoIterator<Item = ActorId>,

        signer: &G,

        self.transaction("Assign", signer, |tx| tx.assign(assignees, []))

    }

    /// Set the issue title.

        self.transaction("Edit", signer, |tx| tx.edit(title))

    }

    /// Lifecycle an issue.

        self.transaction("Lifecycle", signer, |tx| tx.lifecycle(state))

    }

        &mut self,

        body: S,

        signer: &G,

        self.transaction("Create thread", signer, |tx| tx.thread(body))

    }

        body: S,

        reply_to: CommentId,

        signer: &G,

        self.transaction("Comment", signer, |tx| tx.comment(body, reply_to))

    }

        add: impl IntoIterator<Item = Tag>,

        remove: impl IntoIterator<Item = Tag>,

        signer: &G,

        self.transaction("Tag", signer, |tx| tx.tag(add, remove))

    }

        to: CommentId,

        reaction: Reaction,

        signer: &G,

        self.transaction("React", signer, |tx| tx.react(to, reaction))

    }

        &mut self,

        assignees: impl IntoIterator<Item = ActorId>,

        signer: &G,

        self.transaction("Unassign", signer, |tx| tx.assign([], assignees))

            .map_err(Error::from)

    }

        &mut self,

        message: &str,

        signer: &G,

        operations: F,

    where

        G: Signer,

    {

        self.issue.apply(ops)?;

        self.clock = clock;

    }

}

                Ok(())

            })?;

        // Just a sanity check that our clock is advancing as expected.

        Ok(IssueMut {

            id,

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

            .unwrap();

        let (id, created) = (created.id, created.issue);

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

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

            .unwrap();

        // The root thread op id is always the same.

        let (c0, _) = issue.root();

        let c0 = *c0;

        issue.comment("Ho ho ho.", c0, &signer).unwrap();

        issue.comment("Ha ha ha.", c0, &signer).unwrap();

        let id = issue.id;

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

        let (_, c0) = &issue.comments().nth(0).unwrap();

            )

            .unwrap();

        let (id, created) = (created.id, created.issue);

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

use nonempty::NonEmpty;

use thiserror::Error;

use radicle_crdt::clock;

use radicle_crdt::clock::Lamport;

use radicle_crypto::PublicKey;

/// The author of an [`Op`].

pub type ActorId = PublicKey;

/// Error decoding an operation from an entry.

#[derive(Error, Debug)]

pub enum OpEncodingError {

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

}

/// The `Op` is the operation that is applied onto a state to form a CRDT.

///

/// Everything that can be done in the system is represented by an `Op`.

/// Operations are applied to an accumulator to yield a final state.

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

pub struct Op<A> {

    /// The action carried out by this operation.

    pub action: A,

    /// The author of the operation.

    pub author: ActorId,

    /// Lamport clock.

impl<A> Op<A> {

    pub fn new(

        action: A,

        author: ActorId,

        timestamp: impl Into<clock::Physical>,

        clock: Lamport,

        Self {

            id,

            action,

            author,

            clock,

            timestamp: timestamp.into(),

        }

    }

        self.id

    }

}

    type Error = OpEncodingError;

    fn try_from(entry: &'a EntryWithClock) -> Result<Self, Self::Error> {

        let ops = entry

            .changes()

                let op = Op {

                    action,

                    author: *entry.actor(),

                    timestamp: entry.timestamp().into(),

                };

                Ok::<_, Self::Error>(op)

use crate::cob::thread;

use crate::cob::thread::CommentId;

use crate::cob::thread::Thread;

use crate::crypto::{PublicKey, Signer};

use crate::git;

use crate::prelude::*;

pub type PatchId = ObjectId;

/// Unique identifier for a patch revision.

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

pub type RevisionIx = usize;

/// Error applying an operation onto a state.

pub enum ApplyError {

    /// Causal dependency missing.

    ///

    /// For example, this can occur if an operation references anothern operation

    /// that hasn't happened yet.

    #[error("causal dependency {0:?} missing")]

    /// Error applying an op to the patch thread.

    #[error("thread apply failed: {0}")]

    Thread(#[from] thread::OpError),

    /// first revision.

    pub revisions: GMap<RevisionId, Redactable<Revision>>,

    /// Timeline of operations.

}

impl Semilattice for Patch {

                    // TODO(cloudhead): Make sure we can deal with redacted revisions which are added

                    // to out of order, like in the `Merge` case.

                    if let Some(Redactable::Present(revision)) = self.revisions.get_mut(&revision) {