[[package]]

name = "radicle"

version = "0.13.0"

dependencies = [

 "amplify",

 "base64 0.21.7",

[[package]]

name = "radicle-cob"

version = "0.12.0"

dependencies = [

 "fastrand",

 "git2",

[[package]]

name = "radicle-crypto"

version = "0.11.0"

dependencies = [

 "amplify",

 "cyphernet",

[[package]]

name = "radicle-dag"

version = "0.9.0"

dependencies = [

 "fastrand",

]

[[package]]

name = "radicle-ssh"

version = "0.9.0"

dependencies = [

 "byteorder",

 "log",

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

checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"

dependencies = [

]

[[package]]

}

impl Author {

        Self {

        }

    }

}

        Self {

            id: id.to_string(),

            title: issue.title().to_string(),

            state: (*issue.state()).into(),

            assignees: issue

                .assignees()

                .collect::<Vec<_>>(),

            body: cobs::thread::Comment::<cobs::Never>::new(

                *root_oid,

    pub fn new(id: patch::PatchId, patch: &patch::Patch, aliases: &impl AliasStore) -> Self {

        Self {

            id: id.to_string(),

            title: patch.title().to_string(),

            state: patch.state().clone().into(),

            base: *patch.base(),

            head: *patch.head(),

            assignees: patch

                .assignees()

                .collect::<Vec<_>>(),

            labels: patch.labels().cloned().collect::<Vec<_>>(),

            timestamp: patch.timestamp(),

    pub fn new(value: cob::patch::Revision, aliases: &impl AliasStore) -> Self {

        Self {

            id: value.id(),

            description: value

                .edits()

                .map(|e| Edit::new(e, aliases))

                        .map(|(emoji, authors)| {

                            cobs::thread::Reaction::new(

                                *emoji,

                                location

                                    .as_ref()

                                    .map(|l| cobs::thread::CodeLocation::new(l.clone())),

impl Edit {

    pub fn new(edit: &cob::thread::Edit, aliases: &impl AliasStore) -> Self {

        Self {

            timestamp: edit.timestamp,

            body: edit.body.clone(),

            embeds: edit

    ) -> Self {

        Self {

            id,

            verdict: review.verdict(),

            summary: review.summary().map(|s| s.to_string()),

            comments: review

use ts_rs::TS;

use radicle::node::AliasStore;

use crate::cobs;

    ) -> Self {

        Self {

            id,

            edits: comment

                .edits()

                .map(|e| cobs::patch::Edit::new(e, aliases))

                .reactions()

                .into_iter()

                .map(|(reaction, authors)| {

                })

                .collect::<Vec<_>>(),

            reply_to: comment.reply_to(),

    ) -> Self {

        Self {

            id,

            edits: comment

                .edits()

                .map(|e| cobs::patch::Edit::new(e, aliases))

                .reactions()

                .into_iter()

                .map(|(reaction, authors)| {

                })

                .collect::<Vec<_>>(),

            reply_to: comment.reply_to(),

impl Reaction {

    pub fn new(

        emoji: cob::Reaction,

        location: Option<CodeLocation>,

        aliases: &impl AliasStore,

    ) -> Self {

            emoji,

            authors: authors

                .into_iter()

                .collect::<Vec<_>>(),

            location,

        }

use radicle::cob::object::Storage;

use radicle::storage::refs::draft;

use radicle::storage::{self, ReadStorage};

                    Some(crate::cobs::issue::Operation {

                        entry_id: op.id,

                        action,

                        timestamp: op.timestamp,

                    })

                },

            &draft_oid.into(),

        )?;

        patches.write(&cob_id.into())?;

        storage::git::cob::DraftStore::new(&repo, *signer.public_key()).remove(

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

use radicle::node::Handle;

use radicle::storage::ReadStorage;

        let profile = self.profile();

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

        let status = status.unwrap_or_default();

        let mut issues: Vec<_> = issues

            .list()?

            .filter_map(|r| {

    ) -> Result<Option<cobs::issue::Issue>, Error> {

        let profile = self.profile();

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

        let issue = issues.get(&id.into())?;

        let aliases = &profile.aliases();

    ) -> Result<Option<Vec<cobs::thread::Thread>>, Error> {

        let profile = self.profile();

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

        let issue = issues.get(&id.into())?;

        let aliases = &profile.aliases();

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

        let signer = profile.signer()?;

        let aliases = profile.aliases();

        let issue = issues.create(

            new.title,

            new.description,

            &new.labels,

            &new.assignees,

            &signer,

        )?;

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

        let signer = profile.signer()?;

        let aliases = profile.aliases();

        let mut issue = issues.get_mut(&cob_id.into())?;

        match action {

                issue.comment(

                    body,

                    reply_to.unwrap_or(cob_id),

                    &signer,

                )?;

            }

                issue.edit_comment(

                    id,

                    body,

                    &signer,

                )?;

            }

use radicle::node::Handle;

use radicle::patch::cache::Patches as _;

use radicle::storage;

        let take = take.unwrap_or(20);

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

        let aliases = &profile.aliases();

        let patches = match status {

            None => cache.list()?.collect::<Vec<_>>(),

            Some(s) => cache.list_by_status(&s.into())?.collect::<Vec<_>>(),

    ) -> Result<Option<cobs::patch::Patch>, Error> {

        let profile = self.profile();

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

        let patch = patches.get(&id.into())?;

        let aliases = &profile.aliases();

        let patches = patch.map(|patch| cobs::patch::Patch::new(id.into(), &patch, aliases));

    ) -> Result<Option<Vec<cobs::patch::Revision>>, Error> {

        let profile = self.profile();

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

        let revisions = patches.get(&id.into())?.map(|patch| {

            let aliases = &profile.aliases();

    ) -> Result<Option<cobs::patch::Revision>, Error> {

        let profile = self.profile();

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

        let revision = patches.get(&id.into())?.and_then(|patch| {

            let aliases = &profile.aliases();

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

        let signer = profile.signer()?;

        let aliases = profile.aliases();

        let mut patch = patches.get_mut(&cob_id.into())?;

        match action {

                patch.edit_revision(

                    revision,

                    description,

                    &signer,

                )?;

            }

                    body,

                    location.map(|l| l.into()),

                    reply_to,

                    &signer,

                )?;

            }

                    review,

                    comment,

                    body,

                    &signer,

                )?;

            }

                    body,

                    reply_to,

                    location.map(|l| l.into()),

                    &signer,

                )?;

            }

                    revision,

                    comment,

                    body,

                    &signer,

                )?;

            }

                new.body,

                new.location.map(|l| l.into()),

                new.reply_to,

            )?;

            Ok(())

use radicle_surf as surf;

use serde::{Deserialize, Serialize};

use radicle::identity::{doc, Doc, DocAt};

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

use radicle::node::routing::Store;

                continue;

            }

                continue;

            }

    fn repo_info(

        &self,

        repo: &storage::git::Repository,

    ) -> Result<repo::RepoInfo, Error> {

        let profile = self.profile();

        let aliases = profile.aliases();

        let delegates = doc

            .map(|did| cobs::Author::new(did, &aliases))

            .collect::<Vec<_>>();

        let db = profile.database()?;

        let seeding = db.count(&repo.id).unwrap_or_default();

        let project = doc

            .get(&doc::PayloadId::project())

            .and_then(|payload| {

                let (_, head) = repo.head().ok()?;

                let commit = repo.commit(head).ok()?;

                let patches = patches.counts().ok()?;

                let issues = issues.counts().ok()?;

                let data: repo::ProjectPayloadData = (*payload).clone().try_into().ok()?;

        Ok::<_, Error>(repo::RepoInfo {

            payloads: repo::SupportedPayloads { project },

            delegates,

            rid: repo.id,

            seeding,

        })

use localtime::LocalTime;

use radicle::cob;

use radicle::git;

use radicle::identity;

use radicle::node::Handle;

        let mut node = Node::new(profile.socket());

        let signer = profile.signer()?;

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

        let mut issue = issues.get_mut(&new.id.into())?;

        let id = new.reply_to.unwrap_or_else(|| {

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

        let oid = issue.comment(

            n.body,

            id,

            &signer,

        )?;

                new.body,

                id.into(),

                None,

                LocalTime::now().into(),

            ),

            aliases,

        let mut node = Node::new(profile.socket());

        let signer = profile.signer()?;

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

        let mut patch = patches.get_mut(&new.id.into())?;

        let n = new.clone();

        let oid = patch.comment(

            n.body,

            n.reply_to,

            n.location.map(|l| l.into()),

            &signer,

        )?;

                new.body,

                new.reply_to,

                new.location.map(|l| l.into()),

                LocalTime::now().into(),

            ),

            aliases,