let repo = storage

        .repository(rid)

        .context(anyhow!("repository `{rid}` not found in local storage"))?;

    let current = identity.current().clone();

    match options.op {

    Ok(result)

}

    title: Option<String>,

    description: Option<String>,

    doc: Doc<Verified>,

    signer: &G,

    if let Some((title, description)) = edit_title_description(title, description)? {

        let id = current.update(title, description, &doc, signer)?;

        let revision = current

use git_ref_format::Qualified;

use localtime::LocalTime;

use radicle::cob::TypedId;

use radicle::issue::cache::Issues as _;

use radicle::node::notifications;

use radicle::node::notifications::*;

    let proj = doc.project()?;

    let issues = profile.issues(&repo)?;

    let patches = profile.patches(&repo)?;

    let mut notifs = notifs.by_repo(&rid, sort_by.field)?.collect::<Vec<_>>();

    if !sort_by.reverse {

        } = match &n.kind {

            NotificationKind::Branch { name } => NotificationRow::branch(name, head, &n, &repo)?,

            NotificationKind::Cob { typed_id } => {

                    Some(row) => row,

                    None => continue,

                }

        ))

    }

        typed_id: &TypedId,

        n: &Notification,

        issues: &I,

        patches: &P,

    ) -> anyhow::Result<Option<Self>>

    where

        I: cob::issue::cache::Issues,

        P: cob::patch::cache::Patches,

    {

        let TypedId { id, .. } = typed_id;

        let (category, summary, state) = if typed_id.is_issue() {

                term::format::patch::state(patch.state()),

            )

        } else if typed_id.is_identity() {

                log::error!(

                    target: "cli",

                    "Error retrieving identity {id} for notification {}", n.id

            term::patch::show(&patch, &typed_id.id, false, &repo, None, profile)?;

        }

        NotificationKind::Cob { typed_id } if typed_id.is_identity() => {

            term::json::to_pretty(&identity.doc, Path::new("radicle.json"))?.print();

        }

use radicle::node::policy::Scope;

use radicle::node::{Event, Handle, NodeId};

use radicle::prelude::Doc;

use crate as cli;

use crate::commands;

    let mut spinner = term::spinner("Initializing...");

    let mut push_cmd = String::from("git push");

    match radicle::rad::init(

        &repo,

        &name,

        &description,

        branch.clone(),

use anyhow::{anyhow, Context as _};

use chrono::prelude::*;

use radicle::identity::RepoId;

use radicle::node::policy::Policy;

use radicle::node::AliasStore as _;

use radicle::storage::git::{Repository, Storage};

        }

        Target::History => {

            let (repo, _) = repo(rid, storage)?;

            let head = repo.identity_head()?;

            let history = repo.revwalk(head)?;

use anyhow::{anyhow, Context as _};

use radicle::node::Handle as _;

use radicle::prelude::RepoId;

use radicle::storage::{SignRepository, ValidateRepository, WriteRepository, WriteStorage};

    };

    let repo = profile.storage.repository_mut(rid)?;

    let mut doc = identity.doc().clone();

    if doc.visibility.is_public() {

use radicle::identity::Visibility;

use radicle::profile::Home;

use radicle::storage::ReadStorage;

use radicle::{node, profile};

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

    let visibility = Visibility::Private {

        allow: BTreeSet::default(),

    };

    let (rid, _, _) = radicle::rad::init(

        &repo,

        &name,

        &description,

        branch,

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

    let branch = RefString::try_from(DEFAULT_BRANCH).unwrap();

    let visibility = Visibility::default();

    let (rid, _, _) = radicle::rad::init(

        &repo,

        &name,

        &description,

        branch,

    pub config: Config,

    pub db: service::Stores<Database>,

    pub policies: policy::Store<policy::Write>,

}

impl Node<MemorySigner> {

        let policies = policy::Store::open(policies_db).unwrap();

        let db = profile.database_mut().unwrap();

        let db = service::Stores::from(db);

        Node {

            id,

            db,

            policies,

            storage: profile.storage,

        }

    }

}

        let policies = home.policies_mut().unwrap();

        let db = home.database_mut().unwrap();

        let db = service::Stores::from(db);

        log::debug!(target: "test", "Node::init {}: {}", config.alias, signer.public_key());

        Self {

            config,

            db,

            policies,

        }

    }

}

        let branch = refname!("master");

        let id = rad::init(

            repo,

            name,

            description,

            branch.clone(),

use log::*;

use radicle::identity::Visibility;

use radicle::node::address::Store as _;

use radicle::node::Database;

        radicle::storage::git::transport::local::register(self.storage().clone());

        let (repo, _) = fixtures::repository(self.tempdir.path().join(name));

        let (rid, _, _) = rad::init(

            &repo,

            name,

            description,

            radicle::git::refname!("master"),

use crossbeam_channel as chan;

use netservices::Direction as Link;

use radicle::identity::Visibility;

use radicle::node::address::Store;

use radicle::node::routing::Store as _;

        eve.address(),

        ConnectOptions::default(),

    ));

    // Alice creates a new project.

    let (proj_id, _, _) = rad::init(

        &repo,

        "alice",

        "alice's repo",

        git::refname!("master"),

) -> Result<(), error::Cache>

where

    S: ReadRepository + cob::Store,

    C: cob::cache::Remove<cob::issue::Issue> + cob::cache::Remove<cob::patch::Patch>,

{

    let issues = cob::issue::Issues::open(storage)?;

    let patches = cob::patch::Patches::open(storage)?;

    for update in refs {

        match update {

            RefUpdate::Updated { name, .. }

                                    err: e.into(),

                                })?;

                        }

                    }

                }

                None => continue,

use std::path::Path;

fn main() -> anyhow::Result<()> {

    let cwd = Path::new(".").canonicalize()?;

    let repo = radicle::git::raw::Repository::open(cwd)?;

    let profile = Profile::load()?;

    let signer = profile.signer()?;

    let (id, _, _) = radicle::rad::init(

        &repo,

        &name,

        "",

        git::refname!("master"),

/// Database migrations.

/// The first migration is the creation of the initial tables.

#[derive(Error, Debug)]

pub enum Error {

///

/// The intention is for this to be used in tests that do not expect

/// any cache reads.

pub struct NoCache;

impl<T> Update<T> for NoCache {

use std::collections::BTreeMap;

use std::{fmt, ops::Deref, str::FromStr};

        doc::{Doc, DocError, RepoId},

        Did,

    },

};

use super::{Author, EntryId};

/// Type name of an identity proposal.

pub static TYPENAME: Lazy<TypeName> =

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

    Doc(#[from] DocError),

    #[error("revision {0} was not found")]

    NotFound(RevisionId),

}

/// An evolving identity document.

pub struct Identity {

    /// The canonical identifier for this identity.

    /// This is the object id of the initial document blob.

            timeline: vec![root],

        }

    }

}

impl Identity {

    }

}

pub enum Verdict {

    /// An accepting verdict must supply the [`Signature`] over the

    /// new proposed [`Doc`].

    /// Rejecting the proposed [`Doc`].

    Reject,

}

///

/// Once a revision has reached the quorum threshold of the previous

/// [`Identity`] it is then adopted as the current identity.

pub struct Revision {

    /// The id of this revision. Points to a commit.

    pub id: RevisionId,

impl Revision {

    pub fn signatures(&self) -> impl Iterator<Item = (&PublicKey, Signature)> {

        self.verdicts().filter_map(|(key, verdict)| match verdict {

            Verdict::Reject => None,

        })

    }

    pub fn rejected(&self) -> impl Iterator<Item = Did> + '_ {

        self.verdicts().filter_map(|(key, v)| match v {

            Verdict::Reject => Some(key.into()),

        })

    }

        parent: Option<RevisionId>,

        timestamp: Timestamp,

    ) -> Self {

        Self {

            id,

        }

        if self

            .verdicts

            .is_some()

        {

            return Err(ApplyError::DuplicateVerdict);

    }

}

    pub id: ObjectId,

    identity: Identity,

}

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        f.debug_struct("IdentityMut")

            .field("id", &self.id)

    }

}

where

    R: WriteRepository + cob::Store,

{

    /// Reload the identity data from storage.

    pub fn reload(&mut self) -> Result<(), store::Error> {

        Ok(())

    }

        let mut tx = Transaction::default();

        operations(&mut tx)?;

        self.identity = doc;

        Ok(commit)

    }

}

    type Target = Identity;

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

    }

}

mod lookup {

    use super::*;

        let NodeWithRepo { node, repo } = NodeWithRepo::default();

        let bob = MockSigner::default();

        let signer = &node.signer;

        let mut doc = identity.doc().clone();

        let title = "Identity update";

        let description = "";

        let bob = MockSigner::default();

        let eve = MockSigner::default();

        let signer = &node.signer;

        let mut doc = identity.doc().clone();

        let title = "Identity update";

        let description = "";

        let alice = &network.alice;

        let bob = &network.bob;

        let mut alice_doc = alice_identity.doc().clone();

        alice_doc.delegate(bob.signer.public_key());

        bob.repo.fetch(alice);

        let bob_doc = bob_identity.doc().clone();

        assert!(bob_doc.is_delegate(bob.signer.public_key()));

        let bob = &network.bob;

        let eve = &network.eve;

        let mut alice_doc = alice_identity.doc().clone();

        alice_doc.delegate(bob.signer.public_key());

        assert!(alice_identity.revision(&a1).is_some());

        assert_eq!(alice_identity.timeline, vec![a0, a1, a2, a3]);

        let b1 = bob_identity.accept(&a2, &bob.signer).unwrap();

        assert_eq!(bob_identity.timeline, vec![a0, a1, a2, b1]);

        let bob = &network.bob;

        let eve = &network.eve;

        let mut alice_doc = alice_identity.doc().clone();

        alice_doc.delegate(bob.signer.public_key());

        bob.repo.fetch(alice);

        eve.repo.fetch(bob);

        let b1 = bob_identity.accept(&a2, &bob.signer).unwrap();

        assert_eq!(bob_identity.current, a2);

        let mut eve_doc = eve_identity.doc().clone();

        eve_doc.visibility = Visibility::private([eve.signer.public_key().into()]);

        let e1 = eve_identity

        let bob = &network.bob;

        let eve = &network.eve;

        let mut alice_doc = alice_identity.doc().clone();

        alice_doc.delegate(bob.signer.public_key());

        eve.repo.fetch(bob);

        // Bob accepts alice's revision.

        let b1 = bob_identity.accept(&a2, &bob.signer).unwrap();

        // Eve rejects the revision, not knowing.

        let e1 = eve_identity.reject(a2, &eve.signer).unwrap();

        assert!(eve_identity.revision(&a2).unwrap().is_active());

        let bob = &network.bob;

        let eve = &network.eve;

        let mut alice_doc = alice_identity.doc().clone();

        alice.repo.fetch(bob);

        bob.repo.fetch(alice);

        eve.repo.fetch(alice);

        let mut bob_doc = bob_identity.doc().clone();

        assert!(bob_doc.is_delegate(bob.signer.public_key()));

        eve.repo.fetch(bob);

        // In the meantime, Eve does the same thing on her side.

        let mut eve_doc = eve_identity.doc().clone();

        eve_doc.visibility = Visibility::private([]);

        let e1 = eve_identity

        let bob = MockSigner::new(&mut rng);

        let eve = MockSigner::new(&mut rng);

        let storage = Storage::open(tempdir.path().join("storage"), fixtures::user()).unwrap();

        let (id, _, _, _) =

            fixtures::project(tempdir.path().join("copy"), &storage, &alice).unwrap();

        rad::fork_remote(id, alice.public_key(), &eve, &storage).unwrap();

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

        let mut doc = identity.doc().clone();

        let prj = doc.project().unwrap();

            .unwrap();

        identity.accept(&revision, &eve).unwrap();

        let root = repo.identity_root().unwrap();

        let doc = repo.identity_doc_at(revision).unwrap();

use thiserror::Error;

use crate::canonical::formatter::CanonicalFormatter;

use crate::cob::identity;

use crate::crypto;

use crate::crypto::{Signature, Unverified, Verified};

        Doc::from_json(blob.content())?.verified()

    }

        &self,

        repo: &storage::git::Repository,

        signer: &G,

        let id_ref = git::refs::storage::id(signer.public_key());

        let cob_ref = git::refs::storage::cob(

            signer.public_key(),

        let (repo, _) = fixtures::repository(tempdir.path().join("working"));

        let (id, _, _) = rad::init(

            &repo,

            "heartwood",

            "Radicle Heartwood Protocol & Stack",

            git::refname!("master"),

        let delegate = MockSigner::from_seed([0xff; 32]);

        let (rid, doc, _) = rad::init(

            &working,

            "heartwood",

            "Radicle Heartwood Protocol & Stack",

            git::refname!("master"),

        let store = cob::patch::Patches::open(repository)?;

        Ok(cob::patch::Cache::open(store, db))

    }

}

// Private methods.

use once_cell::sync::Lazy;

use thiserror::Error;

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

use crate::git;

use crate::identity::doc;

}

/// Initialize a new radicle project from a git repository.

    repo: &git2::Repository,

    name: &str,

    description: &str,

    default_branch: BranchName,

    visibility: Visibility,

    signer: &G,

    storage: S,

    // TODO: Better error when project id already exists in storage, but remote doesn't.

    let pk = signer.public_key();

    let delegate = identity::Did::from(*pk);

        )

    })?;

    let doc = identity::Doc::initial(proj, delegate, visibility).verified()?;

    let url = git::Url::from(project.id);

    match init_configure(repo, &project, pk, &default_branch, &url, signer) {

    use pretty_assertions::assert_eq;

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

    use crate::git::{name::component, qualified};

    use crate::identity::Did;

    use crate::storage::git::transport;

        let (repo, _) = fixtures::repository(tempdir.path().join("working"));

        let (proj, _, refs) = init(

            &repo,

            "acme",

            "Acme's repo",

            git::refname!("master"),

        let (original, _) = fixtures::repository(tempdir.path().join("original"));

        let (id, _, alice_refs) = init(

            &original,

            "acme",

            "Acme's repo",

            git::refname!("master"),

        let (original, _) = fixtures::repository(tempdir.path().join("original"));

        let (id, _, _) = init(

            &original,

            "acme",

            "Acme's repo",

            git::refname!("master"),

pub use git::{Validation, Validations};

pub use radicle_git_ext::Oid;

use crate::collections::RandomMap;

use crate::git::ext as git_ext;

use crate::git::{refspec::Refspec, PatternString, Qualified, RefError, RefStr, RefString};

    Quorum(#[from] git::QuorumError),

    #[error(transparent)]

    Refs(#[from] refs::Error),

}

/// Storage error.

    where

        Self: cob::Store,

    {

    }

    /// Compute the canonical `rad/id` of this repository.

use once_cell::sync::Lazy;

use tempfile::TempDir;

use crate::crypto::Unverified;

use crate::git;

use crate::identity::doc::DocError;

    }

    /// Create the repository's identity branch.

        doc: &Doc<Verified>,

        storage: &S,

        signer: &G,

        let (doc_oid, _) = doc.encode()?;

        let id = RepoId::from(doc_oid);

        let repo = Self::create(paths::repository(storage, &id), id, storage.info())?;

        Ok((repo, commit))

    }

            // We've got an identity that goes back to the correct root.

            if blob.id() == **self.id {

                return Ok(identity.head());

            }

use std::str::FromStr;

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

use crate::identity::doc::Visibility;

use crate::identity::RepoId;

use crate::node::Alias;

use crate::storage::git::transport;

use crate::storage::git::Storage;

use crate::storage::refs::SignedRefs;

/// The birth of the radicle project, January 1st, 2018.

pub const RADICLE_EPOCH: i64 = 1514817556;

        let (repo, _) = repository(path.join("workdir").join(name));

        rad::init(

            &repo,

            name,

            desc,

            git::refname!("master"),

    let (working, head) = repository(path);

    let (id, _, refs) = rad::init(

        &working,

        "acme",

        "Acme's repository",

        git::refname!("master"),