[[package]]

name = "amplify"

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

dependencies = [

 "amplify_derive",

 "amplify_num",

[[package]]

name = "cxx"

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

dependencies = [

 "cc",

 "cxxbridge-flags",

[[package]]

name = "cxx-build"

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

dependencies = [

 "cc",

 "codespan-reporting",

[[package]]

name = "cxxbridge-flags"

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

[[package]]

name = "cxxbridge-macro"

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

dependencies = [

 "proc-macro2",

 "quote",

[[package]]

name = "data-encoding"

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

[[package]]

name = "data-encoding-macro"

[[package]]

name = "der"

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

dependencies = [

 "const-oid",

 "pem-rfc7468",

[[package]]

name = "ed25519-compact"

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

dependencies = [

 "ct-codecs",

 "getrandom 0.2.8",

[[package]]

name = "filetime"

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

dependencies = [

 "cfg-if",

 "libc",

[[package]]

name = "git-ref-format"

version = "0.1.0"

source = "git+https://github.com/radicle-dev/radicle-git?rev=d3115a22158c8395705babefdc89049f7510d32d#d3115a22158c8395705babefdc89049f7510d32d"

dependencies = [

]

[[package]]

[[package]]

name = "git-ref-format-macro"

version = "0.1.0"

source = "git+https://github.com/radicle-dev/radicle-git?rev=d3115a22158c8395705babefdc89049f7510d32d#d3115a22158c8395705babefdc89049f7510d32d"

dependencies = [

 "proc-macro-error",

 "quote",

 "syn",

[[package]]

name = "libc"

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

[[package]]

name = "libgit2-sys"

 "cyphernet",

 "ed25519-compact",

 "fastrand",

 "git2",

 "log",

 "multibase",

 "ed25519-compact",

 "fastrand",

 "git-commit",

 "git-trailers",

 "git2",

 "log",

 "cyphernet",

 "ed25519-compact",

 "fastrand",

 "multibase",

 "qcheck",

 "qcheck-macros",

version = "0.2.0"

source = "git+https://github.com/radicle-dev/radicle-git?rev=d3115a22158c8395705babefdc89049f7510d32d#d3115a22158c8395705babefdc89049f7510d32d"

dependencies = [

 "git2",

 "percent-encoding",

 "radicle-std-ext",

 "colored",

 "crossbeam-channel",

 "fastrand",

 "lexopt",

 "log",

 "nakamoto-net",

 "base64",

 "either",

 "flate2",

 "git2",

 "nom 6.1.2",

 "nonempty 0.5.0",

version = "0.2.0"

dependencies = [

 "anyhow",

 "radicle",

]

[[package]]

name = "rustix"

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

dependencies = [

 "bitflags",

 "errno",

[[package]]

name = "scale-info"

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

dependencies = [

 "cfg-if",

 "derive_more",

[[package]]

name = "scale-info-derive"

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

dependencies = [

 "proc-macro-crate",

 "proc-macro2",

[[package]]

name = "serde"

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

dependencies = [

 "serde_derive",

]

[[package]]

name = "serde_derive"

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

dependencies = [

 "proc-macro2",

 "quote",

[[package]]

name = "syn"

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

dependencies = [

 "proc-macro2",

 "quote",

[[package]]

name = "tokio"

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

dependencies = [

 "autocfg",

 "bytes",

 "pin-project-lite",

 "socket2",

 "tokio-macros",

]

[[package]]

[[package]]

name = "tower-http"

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

dependencies = [

 "bitflags",

 "bytes",

[[package]]

name = "typenum"

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

[[package]]

name = "uint"

[[package]]

name = "zeroize_derive"

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

dependencies = [

 "proc-macro2",

 "quote",

[patch.crates-io.git-ref-format]

git = "https://github.com/radicle-dev/radicle-git"

}

   rad .

To publish your project to the network, run:

```

$ rad ls

```

pub fn execute(options: Options, profile: &Profile) -> anyhow::Result<PathBuf> {

    let id = options.id;

    let storage = &profile.storage;

        .repository(id)?

        .context("project could not be found in local storage")?;

    let path = PathBuf::from(payload.name.clone());

    if path.exists() {

    };

    spinner.finish();

        .into_iter()

        .map(|did| *did)

        .filter(|id| id != profile.id())

    let doc = profile

        .storage

        .repository(id)?

        .map_err(|_e| anyhow!("couldn't load project {} from local state", id))?;

    let repo = rad::checkout(id, profile.id(), path, &profile.storage)?;

    let delegates = doc

        .delegates

        .map(|d| **d)

        .filter(|id| id != profile.id())

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

    // Setup tracking for project delegates.

    setup_remotes(

        &profile.storage,

    ) {

        Ok((id, doc, _)) => {

            spinner.message(format!(

                "Project {} created",

            ));

            spinner.finish();

            if interactive.no() {

                term::blank();

            }

                // Setup eg. `master` -> `rad/master`

                radicle::git::set_upstream(

                    &repo,

                    &radicle::rad::REMOTE_NAME,

                )?;

            }

    storage.projects()?.into_iter().for_each(|id| {

        let Ok(repo) = storage.repository(id) else { return };

        let Ok((_, head)) = repo.head() else { return };

        let head = term::format::oid(head);

        table.push([

            term::format::tertiary(id),

            term::format::secondary(head),

        ]);

    });

    table.render();

    let signer = term::signer(&profile)?;

    let repository = profile.storage.repository(id)?;

    let _project = repository

        .context(format!("couldn't load project {} from local state", id))?;

    let repository = profile.storage.repository(id)?;

    let mut patches = Patches::open(*profile.id(), &repository)?;

    let signer = term::signer(&profile)?;

    let repository = profile.storage.repository(id)?;

    let _project = repository

        .context(format!("couldn't load project {} from local state", id))?;

    let mut patches = Patches::open(*profile.id(), &repository)?;

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

use radicle::storage::WriteStorage;

use crate::terminal as term;

    let profile = ctx.profile()?;

    let storage = &profile.storage;

    let (_, rid) = radicle::rad::cwd().context("this command must be run within a project")?;

    let mut node = radicle::node::connect(&profile.node())?;

    term::info!(

        "Establishing 🌱 tracking relationship for {}",

    );

    term::blank();

        .context("current directory is not a git repository; please supply an `<id>`")?;

    let profile = ctx.profile()?;

    let storage = &profile.storage;

    if untrack(id, &profile)? {

        term::success!(

            "Tracking relationships for {} ({}) removed",

            &id.to_human()

        );

    } else {

        term::info!(

            "Tracking relationships for {} ({}) doesn't exist",

            &id.to_human()

        );

    }

log = { version = "0.4.17" }

nonempty = { version = "0.8.1", features = ["serialize"] }

petgraph = { version = "0.5" }

serde_json = { version = "1.0" }

thiserror = { version = "1.0" }

use tracing::Span;

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

use radicle::storage::{ReadRepository, WriteStorage};

use radicle::Profile;

        let storage = &self.profile.storage;

        let repo = storage.repository(id)?;

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

        let issues = (Issues::open(self.profile.public_key, &repo)?).count()?;

        Ok(project::Info {

mod project {

    use radicle::git::Oid;

    use radicle::identity::Id;

    use serde::Serialize;

    pub struct Info {

        /// Project metadata.

        #[serde(flatten)]

        pub head: Oid,

        pub patches: usize,

        pub issues: usize,

use axum::{Extension, Json, Router};

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

use radicle::storage::{ReadRepository, WriteStorage};

use crate::api::axum_extra::{Path, Query};

        .filter_map(|id| {

            let Ok(repo) = storage.repository(id) else { return None };

            let Ok((_, head)) = repo.head() else { return None };

                return None;

            }

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

use radicle::cob::Timestamp;

use radicle::git::raw::BranchType;

use radicle::node::NodeId;

use radicle::storage::{Oid, ReadRepository, WriteRepository, WriteStorage};

use radicle_surf::git::History;

        .filter_map(|id| {

            let Ok(repo) = storage.repository(id) else { return None };

            let Ok((_, head)) = repo.head() else { return None };

            let Ok(issues) = Issues::open(ctx.profile.public_key, &repo) else { return None };

            let Ok(issues) = (*issues).count() else { return None };

mod id;

use std::collections::{BTreeMap, HashMap};

use std::io;

use std::marker::PhantomData;

use std::ops::Deref;

    Io(#[from] io::Error),

    #[error("verification: {0}")]

    Verification(#[from] VerificationError),

    #[error("git: {0}")]

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

    #[error("git: {0}")]

    }

}

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

#[serde(rename_all = "camelCase")]

    pub name: String,

    pub description: String,

}

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

#[serde(transparent)]

// TODO: Restrict values.

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

#[serde(rename_all = "camelCase")]

pub struct Doc<V> {

    pub delegates: NonEmpty<Did>,

    pub threshold: usize,

        false

    }

    pub fn sign<G: crypto::Signer>(&self, signer: &G) -> Result<(git::Oid, Signature), DocError> {

        let (oid, bytes) = self.encode()?;

        let sig = signer.sign(&bytes);

    }

}

#[derive(Error, Debug)]

pub enum VerificationError {

    #[error("invalid delegates: {0}")]

    Delegates(&'static str),

    #[error("invalid version `{0}`")]

    Version(u32),

    #[error("invalid threshold `{0}`: {1}")]

    Threshold(usize, &'static str),

}

impl Doc<Unverified> {

    }

        Self {

            delegates,

            threshold,

            verified: PhantomData,

    }

    pub fn verified(self) -> Result<Doc<Verified>, VerificationError> {

        if self.delegates.len() > MAX_DELEGATES {

            return Err(VerificationError::Delegates(

                "number of delegates cannot exceed 255",

                "delegate list cannot be empty",

            ));

        }

        if self.threshold > self.delegates.len() {

            return Err(VerificationError::Threshold(

                self.threshold,

        Ok(Doc {

            payload: self.payload,

            delegates: self.delegates,

            threshold: self.threshold,

            verified: PhantomData,

            String::from("z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi")

        );

        assert_eq!(

            id.to_human(),

        );

    }

        // TODO: In some cases we want to get the repo and the project, but don't

        // want to have to create a repository object twice. Perhaps there should

        // be a way of getting a project from a repo.

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

        // Make a change to the description and sign it.

            .and_then(|(_, sig)| {

                    alice.public_key(),

                    "Update description",

                    &[(alice.public_key(), sig)],

            .unwrap();

        // Add Bob as a delegate, and sign it.

            .and_then(|(_, sig)| {

                    alice.public_key(),

                    "Add bob",

                    &[(alice.public_key(), sig)],

            .unwrap();

        // Add Eve as a delegate, and sign it.

            .and_then(|(_, alice_sig)| {

                        alice.public_key(),

                        "Add eve",

                        &[(alice.public_key(), alice_sig), (bob.public_key(), bob_sig)],

            .unwrap();

        // Update description again with signatures by Eve and Bob.

            .sign(&bob)

            .and_then(|(_, bob_sig)| {

                        alice.public_key(),

                        "Update description",

                        &[(bob.public_key(), bob_sig), (eve.public_key(), eve_sig)],

        assert_eq!(identity.root, id);

        assert_eq!(identity.current, current);

        assert_eq!(identity.head, head);

    }

    #[quickcheck]

    use super::*;

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

    pub use node::NodeId;

    pub use profile::Profile;

    pub use storage::{BranchName, ReadRepository, ReadStorage, WriteRepository, WriteStorage};

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

use crate::git;

use crate::identity::Id;

use crate::node;

use crate::node::NodeId;

    // 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 (id, _, project) = doc.create(pk, "Initialize Radicle\n", storage)?;

    let url = git::Url::from(id).with_namespace(*pk);

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

    #[error("storage: {0}")]

    Storage(#[from] storage::Error),

    #[error("project `{0}` was not found in storage")]

    NotFound(Id),

    #[error("project identity error: {0}")]

    // refs/namespaces/<pk>/refs/tags/*

    let me = signer.public_key();

        .get(remote, proj)?

        .ok_or(ForkError::NotFound(proj))?;

    let repository = storage.repository(proj)?;

    let raw = repository.raw();

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

    #[error("storage: {0}")]

    Storage(#[from] storage::Error),

    #[error("project `{0}` was not found in storage")]

    NotFound(Id),

    #[error("project error: {0}")]

) -> Result<git2::Repository, CheckoutError> {

    // TODO: Decide on whether we can use `clone_local`

    // TODO: Look into sharing object databases.

        .get(remote, proj)?

        .ok_or(CheckoutError::NotFound(proj))?;

    let mut opts = git2::RepositoryInitOptions::new();

    opts.no_reinit(true).description(&project.description);

        )

        .unwrap();

        let remotes: HashMap<_, _> = storage

            .repository(proj)

            .unwrap()

        assert_eq!(project.name, "acme");

        assert_eq!(project.description, "Acme's repo");

        assert_eq!(project.default_branch, git::refname!("master"));

    }

    #[test]

use crate::git;

use crate::identity;

use crate::identity::{Doc, Id};

use crate::storage::refs;

use crate::storage::refs::{Refs, SignedRefs};

    Storage(#[from] Error),

    #[error("identity document error: {0}")]

    Doc(#[from] identity::project::DocError),

    #[error("identity verification error: {0}")]

    Verify(#[from] identity::project::VerificationError),

    #[error("git: {0}")]

    fn get(&self, remote: &RemoteId, proj: Id) -> Result<Option<Doc<Verified>>, ProjectError> {

        // TODO: Don't create a repo here if it doesn't exist?

        // Perhaps for checking we could have a `contains` method?

            Ok(doc) => Ok(Some(doc)),

            Err(err) if err.is_not_found() => Ok(None),

        Identity::load(remote, self)

    }

        let (doc, _) = identity::Doc::load(remote, self)?;

        let verified = doc.verified()?;

    }

    /// Return the canonical identity [`git::Oid`] and document.

        let mut heads = Vec::new();

        for remote in self.remote_ids()? {

            let remote = remote?;

    }

    fn project_identity(&self) -> Result<(Oid, identity::Doc<Unverified>), ProjectError> {

    }

    fn head(&self) -> Result<(Qualified, Oid), ProjectError> {

    fn canonical_head(&self) -> Result<(Qualified, Oid), ProjectError> {

        // TODO: In the `fork` function for example, we call Repository::project_identity again,

        // This should only be necessary once.

        let branch_ref = Qualified::from(lit::refs_heads(&project.default_branch));

        let raw = self.raw();

        let mut heads = Vec::new();

            let r = self.reference_oid(delegate, &branch_ref)?.into();

            heads.push(r);

use crate::collections::HashMap;

use crate::git;

use crate::storage;

use crate::storage::refs::{Refs, SignedRefs};

use crate::test::storage::MockStorage;

    }

}

    fn arbitrary(g: &mut qcheck::Gen) -> Self {

        let rng = fastrand::Rng::with_seed(u64::arbitrary(g));

        let name = iter::repeat_with(|| rng.alphanumeric())

            .collect::<String>()

            .try_into()

            .unwrap();

        let delegates: NonEmpty<_> = iter::repeat_with(|| Did::arbitrary(g))

            .take(rng.usize(1..6))

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

            .try_into()

            .unwrap();

        let threshold = delegates.len() / 2 + 1;

        doc.verified().unwrap()

    }