]

[[package]]

name = "git-ref-format"

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

dependencies = [

 "git-ref-format-core",

 "git-ref-format-macro",

[[package]]

name = "git-ref-format-core"

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

dependencies = [

 "serde",

 "thiserror",

]

[[package]]

name = "git-ref-format-macro"

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

dependencies = [

 "git-ref-format-core",

 "proc-macro-error",

]

[[package]]

name = "git2"

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

dependencies = [

 "bitflags",

 "libc",

[[package]]

name = "libgit2-sys"

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

dependencies = [

 "cc",

 "libc",

checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"

[[package]]

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

[[package]]

name = "miniz_oxide"

]

[[package]]

name = "nonempty"

version = "0.5.0"

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

 "crossbeam-channel",

 "cyphernet",

 "fastrand",

 "git2",

 "localtime",

 "log",

 "radicle-cli-test",

 "radicle-cob",

 "radicle-crypto",

 "radicle-node",

 "radicle-term",

 "serde",

version = "0.1.0"

dependencies = [

 "fastrand",

 "git2",

 "log",

 "nonempty 0.8.1",

 "cyphernet",

 "ec25519",

 "fastrand",

 "multibase",

 "qcheck",

 "qcheck-macros",

 "radicle-ssh",

 "serde",

 "sqlite",

[[package]]

name = "radicle-git-ext"

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

dependencies = [

 "git-ref-format",

 "git2",

 "crossbeam-channel",

 "cyphernet",

 "fastrand",

 "io-reactor",

 "lexopt",

 "libc",

 "qcheck-macros",

 "radicle",

 "radicle-crypto",

 "radicle-term",

 "scrypt",

 "serde",

[[package]]

name = "radicle-surf"

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

dependencies = [

 "anyhow",

 "base64",

 "flate2",

 "git2",

 "log",

 "nonempty 0.5.0",

version = "0.2.0"

dependencies = [

 "anyhow",

 "radicle",

 "radicle-cli",

]

[[package]]

lexopt = { version = "0.2" }

log = { version = "0.4", features = ["std"] }

nonempty = { version = "0.8" }

serde = { version = "1.0" }

serde_json = { version = "1" }

serde_yaml = { version = "0.8" }

```

$ 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❳

#[test]

fn test_cob_replication() {

    let mut environment = Environment::new();

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

    let mut alice = environment.node("alice");

[dependencies]

fastrand = { version = "1.9.0" }

log = { version = "0.4.17" }

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

serde_json = { version = "1.0" }

thiserror = { version = "1.0" }

[dependencies.git2]

default-features = false

features = ["vendored-libgit2"]

[dev-dependencies]

fastrand = { version = "1.9.0", default-features = false }

tempfile = { version = "3" }

qcheck = { version = "1", default-features = false }

qcheck-macros = { version = "1", default-features = false }

use std::collections::BTreeMap;

use std::convert::TryFrom;

use git_ext::Oid;

use nonempty::NonEmpty;

use crate::history::entry::Timestamp;

use crate::signatures;

    use std::str::Utf8Error;

    use std::string::FromUtf8Error;

    use git_ext::Oid;

    use thiserror::Error;

    use crate::signatures::error::Signatures;

    #[derive(Debug, Error)]

    pub enum Create {

        #[error(transparent)]

        FromUtf8(#[from] FromUtf8Error),

        #[error(transparent)]

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

    #[derive(Debug, Error)]

    pub enum Load {

        #[error(transparent)]

        #[error(transparent)]

        Signatures(#[from] Signatures),

        #[error(transparent)]

        ResourceTrailer(#[from] super::trailers::error::InvalidResourceTrailer),

        #[error("non utf-8 characters in commit message")]

        Utf8(#[from] FromUtf8Error),

    }

}

    let author = repo.signature()?;

    let timestamp = author.when().seconds();

    headers.push(

        "gpgsig",

        signature

            .map_err(signatures::error::Signatures::from)?

            .as_str(),

    );

    #[cfg(debug_assertions)]

    let (author, timestamp) = if let Ok(s) = std::env::var(crate::git::RAD_COMMIT_TIME) {

        let timestamp = s.trim().parse::<i64>().unwrap();

            ..author

        };

        (author, timestamp)

use std::{convert::TryFrom as _, fmt, ops::Deref, str::FromStr};

use git_ext::Oid;

use serde::{Deserialize, Serialize};

use thiserror::Error;

///   * The parsing of the [`TypeName`] fails

pub fn parse_refstr<R>(name: &R) -> Option<(TypeName, ObjectId)>

where

{

    let name = name.as_ref();

    let refs_cobs = match name.to_namespaced() {

        None => Qualified::from_refstr(name)?,

use std::{collections::HashMap, error::Error};

use git_ext::Oid;

use crate::change::Change;

use crate::{ObjectId, TypeName};

pub mod convert {

    use std::str;

    use thiserror::Error;

    use super::{Commit, Reference};

            err: git2::Error,

        },

        #[error(transparent)]

        #[error(transparent)]

        Utf8(#[from] str::Utf8Error),

    }

};

use crypto::{ssh, PublicKey};

    Commit,

};

pub use ssh::ExtendedSignature;

        #[error(transparent)]

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

        #[error(transparent)]

    }

}

use std::ops::ControlFlow;

use crypto::test::signer::MockSigner;

use nonempty::nonempty;

use qcheck::Arbitrary;

use radicle_crypto::Signer;

// Copyright © 2019-2020 The Radicle Foundation <hello@radicle.foundation>

pub mod error {

    use thiserror::Error;

impl TryFrom<&Trailer<'_>> for ResourceCommitTrailer {

    type Error = error::InvalidResourceTrailer;

        let ext_oid =

            Ok(ResourceCommitTrailer(ext_oid.into()))

        } else {

            Err(Self::Error::WrongToken)

    fn from(containing: ResourceCommitTrailer) -> Self {

        Trailer {

            token: Token::try_from("Rad-Resource").unwrap(),

        }

    }

}

    }

}

        Self(oid.into())

    }

}

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

use serde::{Deserialize, Serialize};

use thiserror::Error;

default-features = false

optional = true

optional = true

[dependencies.ssh-key]

        multibase::encode(multibase::Base::Base58Btc, buf)

    }

    }

        let name = refstr.namespace().into_inner();

        Self::from_str(name.deref().as_str())

    }

}

    fn from(id: &PublicKey) -> Self {

        let refstr =

            RefString::try_from(id.to_string()).expect("encoded public keys are valid ref strings");

        Component::from_refstr(refstr).expect("encoded public keys are valid refname components")

hyper = { version = "0.14.17", default-features = false }

lexopt = { version = "0.2.1" }

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

serde = { version = "1", features = ["derive"] }

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

thiserror = { version = "1" }

crossbeam-channel = { version = "0.5.6" }

cyphernet = { version = "0.2.0", features = ["tor", "dns", "ed25519", "p2p-ed25519"] }

fastrand = { version = "1.9.0" }

io-reactor = { version = "0.1.2", features = ["popol"] }

lexopt = { version = "0.2.1" }

libc = { version = "0.2.137" }

netservices = { version = "0.2.2", features = ["io-reactor", "socket2"] }

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

qcheck = { version = "1", default-features = false, optional = true }

sqlite = { version = "0.30.3" }

sqlite3-src = { version = "0.4.0", features = ["bundled"] } # Ensures static linking

scrypt = { version = "0.10.0", default-features = false }

        channels: &mut Channels,

    ) -> Result<(), FetchError>

    where

    {

        let mut tunnel = Tunnel::with(channels, stream, self.nid, remote, self.handle.clone())?;

        let tunnel_addr = tunnel.local_addr();

        let namespace = self.nid.to_namespace();

        let mut fetchspecs = specs

            .into_iter()

            // Filter out our own refs, if we aren't cloning.

            .filter(|fs| is_cloning || !fs.dst.starts_with(namespace.as_str()))

mod refspecs;

pub mod error;

use std::ops::Deref;

use radicle::crypto::{PublicKey, Unverified, Verified};

use radicle::git::{url, Namespaced};

use radicle::prelude::{Doc, Id, NodeId};

use radicle::storage::git::Repository;

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

use radicle::{git, Storage};

/// The initial phase of staging a fetch from a remote.

///

/// The [`StagingPhaseInitial::refpsecs`] generated are to fetch the

    /// Return the fetch refspecs for fetching the necessary `rad`

    /// references.

        let id = git::PatternString::from(IDENTITY_BRANCH.clone().into_refstring());

        match self.repo {

                src: id.clone(),

                dst: id,

                force: false,

            StagedRepository::Fetching(_) => SpecialRefs(self.namespaces.clone()).into_refspecs(),

        }

    }

                    // don't need to be re-fetched from the remote.

                    let mut remote = copy.remote_anonymous(&url)?;

                    let refspecs: Vec<_> = Namespaces::All

                        .into_iter()

                        .map(|s| s.to_string())

                        .collect();

impl<'a> StagingPhaseFinal<'a> {

    /// Return the fetch refspecs for fetching the necessary

    /// references.

        match &self.repo {

            FinalStagedRepository::Cloning { trusted, .. } => {

            }

        }

    }

                        refspecs.push((

                            remote.id,

                            Refspec {

                                // Nb. The identity branch is allowed to be force-updated.

                                force: true,

                            }

                        refspecs.push((

                            remote.id,

                            Refspec {

                                // Nb. Sigrefs are never force-updated.

                                force: false,

                            }

use radicle::crypto::PublicKey;

use radicle::git;

use radicle::git::refs::storage::{IDENTITY_BRANCH, SIGREFS_BRANCH};

use radicle::storage::git::NAMESPACES_GLOB;

/// Radicle special refs, i.e. `refs/rad/*`.

pub struct SpecialRefs(pub(super) Namespaces);

        match &self.0 {

            Namespaces::All => {

                let id = NAMESPACES_GLOB.join(&*IDENTITY_BRANCH);

            Namespaces::Trusted(pks) => pks.iter().flat_map(rad_refs).collect(),

        }

    }

}

    let ns = pk.to_namespace();

    let id = git::PatternString::from(ns.join(&*IDENTITY_BRANCH));

    let id = Refspec {

    };

    vec![id, sigrefs]

}

[dependencies]

anyhow = { version = "1" }

[dependencies.radicle]

version = "0"

crossbeam-channel = { version = "0.5.6" }

cyphernet = { version = "0.2.0", features = ["tor", "dns", "ed25519"] }

fastrand = { version = "1.9.0" }

multibase = { version = "0.9.1" }

localtime = { version = "1.2.0" }

log = { version = "0.4.17", features = ["std"] }

unicode-normalization = { version = "0.1" }

[dependencies.git2]

default-features = false

features = ["vendored-libgit2"]

[dependencies.radicle-crypto]

path = "../radicle-crypto"

version = "0"

[dependencies.radicle-ssh]

path = "../radicle-ssh"

        revision: RevisionId,

    },

    Revision {

        current: Oid,

        proposed: Doc<Verified>,

    },

    },

}

/// Error applying an operation onto a state.

#[derive(Error, Debug)]

    #[test]

    fn test_issue_create_and_assign() {

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

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

        let assignee: ActorId = arbitrary::gen(1);

    #[test]

    fn test_issue_create_and_reassign() {

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

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

        let assignee: ActorId = arbitrary::gen(1);

    #[test]

    fn test_issue_create_and_get() {

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

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

        let created = issues

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

    #[test]

    fn test_issue_create_and_change_state() {

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

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

        let mut issue = issues

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

    #[test]

    fn test_issue_create_and_unassign() {

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

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

        let assignee: ActorId = arbitrary::gen(1);

    #[test]

    fn test_issue_edit_title() {

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

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

        let mut issue = issues

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

    #[test]

    fn test_issue_react() {

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

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

        let mut issue = issues

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

    #[test]

    fn test_issue_reply() {

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

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

        let mut issue = issues

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

    #[test]

    fn test_issue_tag() {

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

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

        let bug_tag = Tag::new("bug").unwrap();

        let ux_tag = Tag::new("ux").unwrap();

    #[test]

    fn test_issue_comment() {

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

        let author = *signer.public_key();

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

        let mut issue = issues

    #[test]

    fn test_issue_all() {

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

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

        issues.create("First", "Blah", &[], &[], &signer).unwrap();

    #[test]

    fn test_issue_multilines() {

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

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

        let created = issues

            .create(

    #[test]

    fn test_patch_create_and_get() {

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

        let author: Did = signer.public_key().into();

        let target = MergeTarget::Delegates;

        let patch = patches

            .create(

                "My first patch",

                "Blah blah blah.",

                target,

                &[],

            )

            .unwrap();

        assert_eq!(revision.author.id(), &author);

        assert_eq!(revision.description(), "");

        assert_eq!(revision.discussion.len(), 0);

        let (id, _, _) = patches.find_by_revision(rev_id).unwrap().unwrap();

        assert_eq!(id, patch_id);

    #[test]

    fn test_patch_discussion() {

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

        let patch = patches

            .create(

                "My first patch",

                "Blah blah blah.",

                MergeTarget::Delegates,

                &[],

            )

            .unwrap();

        let (revision_id, _) = patch.revisions().last().unwrap();

        assert!(

            patch

                .is_ok(),

            "can comment on patch"

        );

    #[test]

    fn test_patch_merge() {

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

        let mut patch = patches

            .create(

                "My first patch",

                "Blah blah blah.",

                MergeTarget::Delegates,

                &[],

            )

            .unwrap();

        let id = patch.id;

        let (rid, _) = patch.revisions().next().unwrap();

        let patch = patches.get(&id).unwrap().unwrap();

        let merge = merges.first().unwrap();

        assert_eq!(merge.node, *signer.public_key());

    }

    #[test]

    fn test_patch_review() {

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

        let mut patch = patches

            .create(

                "My first patch",

                "Blah blah blah.",

                MergeTarget::Delegates,

                &[],

            )

            .unwrap();

                Some(Verdict::Accept),

                Some("LGTM".to_owned()),

                vec![],

            )

            .unwrap();

    #[test]

    fn test_patch_review_edit() {

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

        let blob = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d133999").unwrap();

        let mut patch = patches

            .create(

                "My first patch",

                "Blah blah blah.",

                MergeTarget::Delegates,

                &[],

            )

            .unwrap();

            location: CodeLocation {

                blob,

                path: Path::new("file.rs").to_path_buf(),

                lines: 1..3,

            },

            comment: "Nice!".to_owned(),

                Some(Verdict::Accept),

                Some("LGTM".to_owned()),

                inline.clone(),

            )

            .unwrap();

        patch

                Some(Verdict::Reject),

                Some("LGTM".to_owned()),

                vec![],

            )

            .unwrap(); // Overwrite the verdict.

                Some(Verdict::Reject),

                Some("Whoops!".to_owned()),

                vec![],

            )

            .unwrap(); // Overwrite the comment.

        let (_, revision) = patch.latest().unwrap();

    #[test]

    fn test_patch_reject_to_accept() {

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

        let mut patch = patches

            .create(

                "My first patch",

                "Blah blah blah.",

                MergeTarget::Delegates,

                &[],

            )

            .unwrap();

                Some(Verdict::Reject),

                Some("Nah".to_owned()),

                vec![],

            )

            .unwrap();

        patch

                Some(Verdict::Accept),

                Some("LGTM".to_owned()),

                vec![],

            )

            .unwrap();

    #[test]

    fn test_patch_review_remove_fields() {

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

        let mut patch = patches

            .create(

                "My first patch",

                "Blah blah blah.",

                MergeTarget::Delegates,

                &[],

            )

            .unwrap();

                Some(Verdict::Reject),

                Some("Nah".to_owned()),

                vec![],

            )

            .unwrap();

        let id = patch.id;

        let patch = patches.get_mut(&id).unwrap();

    #[test]

    fn test_patch_update() {

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

        let mut patch = patches

            .create(

                "My first patch",

                "Blah blah blah.",

                MergeTarget::Delegates,

                &[],

            )

            .unwrap();

        assert_eq!(patch.description(), "Blah blah blah.");

        assert_eq!(patch.version(), 0);

        let _ = patch

            .unwrap();

        assert_eq!(patch.clock.get(), 2);

        let (_, revision) = patch.latest().unwrap();

        assert_eq!(patch.version(), 1);

        assert_eq!(revision.description(), "I've made changes.");

    }

}

    #[test]

    fn test_redact_comment() {

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

        let repo = gen::<MockRepository>(1);

        let mut alice = Actor::new(signer);

        let mut thread = Thread::default();

use std::process::Command;

use std::str::FromStr;

use once_cell::sync::Lazy;

use crate::collections::HashMap;

pub use ext::NotFound;

pub use ext::Oid;

pub use git2 as raw;

    component, lit, name, qualified, refname, refspec,

    refspec::{PatternStr, PatternString},

    Component, Namespaced, Qualified, RefStr, RefString,

    pub mod storage {

        use format::{

            name::component,

            refspec::{self, PatternString},

        };

        /// `refs/namespaces/<remote>/refs/heads/<branch>`

        ///

        pub fn branch<'a>(remote: &RemoteId, branch: &RefStr) -> Namespaced<'a> {

        }

        /// Get the branch where the project's identity document is stored.

use std::ops::Deref;

use std::{ffi::OsString, fmt, str::FromStr};

use thiserror::Error;

use crate::crypto;

#[macro_use]

extern crate amplify;

mod canonical;

pub mod cob;