[[package]]

name = "crossbeam-utils"

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

dependencies = [

 "cfg-if",

]

[[package]]

[[package]]

name = "ed25519-compact"

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

dependencies = [

 "ct-codecs",

 "getrandom",

[[package]]

name = "iana-time-zone"

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

dependencies = [

 "android_system_properties",

 "core-foundation-sys",

 "js-sys",

 "wasm-bindgen",

 "winapi",

]

[[package]]

name = "jobserver"

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

dependencies = [

 "libc",

]

[[package]]

name = "libc"

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

[[package]]

name = "libgit2-sys"

[[package]]

name = "olpc-cjson"

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

dependencies = [

 "serde",

 "serde_json",

[[package]]

name = "openssl-sys"

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

dependencies = [

 "autocfg",

 "cc",

[[package]]

name = "proc-macro2"

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

dependencies = [

 "unicode-ident",

]

[[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 = "thiserror"

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

dependencies = [

 "thiserror-impl",

]

[[package]]

name = "thiserror-impl"

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

dependencies = [

 "proc-macro2",

 "quote",

    let profile = radicle::Profile::load()?;

    let (_, id) = radicle::rad::remote(&repo)?;

    println!("{}", output);

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

pub use ext::Oid;

pub use git2 as raw;

pub use git_ref_format as fmt;

pub use git_url as url;

pub use git_url::Url;

pub use radicle_git_ext as ext;

    InvalidName(format::RefString),

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

    Format(#[from] format::Error),

}

#[derive(thiserror::Error, Debug)]

    InvalidRef(#[from] RefError),

}

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

    }

}

    pub static IDENTITY_BRANCH: Lazy<RefString> = Lazy::new(|| refname!("radicle/id"));

    pub mod storage {

        use super::*;

        }

        /// Get the branch used to track project information.

            branch(remote, &IDENTITY_BRANCH)

        }

    }

    pub mod workdir {

        use super::*;

        pub fn branch(branch: &RefStr) -> RefString {

            refname!("refs/heads").join(branch)

        }

        pub fn note(name: &RefStr) -> RefString {

            refname!("refs/notes").join(name)

        }

        pub fn remote_branch(remote: &RefStr, branch: &RefStr) -> RefString {

            refname!("refs/remotes").and(remote).and(branch)

        }

        pub fn tag(name: &RefStr) -> RefString {

            refname!("refs/tags").join(name)

        }

        let (id, refname) = parse_ref::<PublicKey>(r.name())?;

        let entry = remotes.entry(id).or_insert_with(Refs::default);

    }

    Ok(remotes)

}

/// Parse a ref string.

    let input = format::RefStr::try_from_str(s)?;

}

/// Create an initial empty commit.

    Ok(commit)

}

/// Get the repository head.

pub fn head(repo: &git2::Repository) -> Result<git2::Commit, git2::Error> {

    let head = repo.head()?.peel_to_commit()?;

/// Configure a repository's radicle remote.

///

pub fn configure_remote<'r>(

    repo: &'r git2::Repository,

) -> Result<git2::Remote<'r>, git2::Error> {

    Ok(remote)

}

/// Set the upstream of the given branch to the given remote.

///

/// This writes to the `config` directly. The entry will look like the

}

/// Execute a git command by spawning a child process.

    repo: &P,

    args: impl IntoIterator<Item = S>,

    if output.status.success() {

        let out = if output.stdout.is_empty() {

impl<V> Doc<V> {

    pub fn head<R: ReadRepository>(remote: &RemoteId, repo: &R) -> Result<Oid, DocError> {

    }

}

use std::path::Path;

use std::str::FromStr;

use once_cell::sync::Lazy;

use thiserror::Error;

        repo,

        &REMOTE_NAME,

        &default_branch,

    )?;

    let signed = storage.sign_refs(&project, signer)?;

    Ok((id, signed))

    let canonical_head = {

        let mut heads = Vec::new();

        for delegate in project.delegates.iter() {

            let r = repository.reference_oid(&delegate.id, &refname)?.into();

            heads.push(r);

        }

#[derive(Error, Debug)]

pub enum CheckoutError {

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

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

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

    let url = storage.url(&proj);

    // Configure and fetch all refs from remote.

    {

        // Setup default branch.

        let remote_head_ref =

            git::refs::workdir::remote_branch(&REMOTE_NAME, &project.default_branch);

        let remote_head_commit = repo.find_reference(&remote_head_ref)?.peel_to_commit()?;

        let _ = repo.branch(&project.default_branch, &remote_head_commit, true)?;

            &repo,

            &REMOTE_NAME,

            &project.default_branch,

        )?;

    }

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

use crate::git::ext as git_ext;

use crate::git::Url;

use crate::identity;

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

use crate::storage::refs::Refs;

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

    #[error("i/o: {0}")]

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

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

    Verify(#[from] git::VerifyError),

    #[error(transparent)]

    pub id: PublicKey,

    /// Git references published under this remote, and their hashes.

    pub refs: SignedRefs<V>,

    pub delegate: bool,

    /// Whether the remote is verified or not, ie. whether its signed refs were checked.

    verified: PhantomData<V>,

}

impl<V> Remote<V> {

    pub fn new(id: PublicKey, refs: impl Into<SignedRefs<V>>) -> Self {

        Self {

            id,

}

pub trait ReadRepository {

    fn is_empty(&self) -> Result<bool, git2::Error>;

    fn path(&self) -> &Path;

    fn blob_at<'a>(&'a self, oid: Oid, path: &'a Path) -> Result<git2::Blob<'a>, git_ext::Error>;

    fn reference(

        &self,

        remote: &RemoteId,

    ) -> Result<git2::Reference, git_ext::Error>;

    fn commit(&self, oid: Oid) -> Result<git2::Commit, git_ext::Error>;

    fn revwalk(&self, head: Oid) -> Result<git2::Revwalk, git2::Error>;

    fn references(&self, remote: &RemoteId) -> Result<Refs, Error>;

    fn remote(&self, remote: &RemoteId) -> Result<Remote<Verified>, refs::Error>;

    fn remotes(&self) -> Result<Remotes<Verified>, refs::Error>;

use super::{RefUpdate, RemoteId};

pub static REMOTES_GLOB: Lazy<refspec::PatternString> =

pub static SIGNATURES_GLOB: Lazy<refspec::PatternString> =

#[derive(Error, Debug)]

pub enum ProjectError {

            let remote = remotes

                .get_mut(&remote_id)

                .ok_or(VerifyError::InvalidRemote(remote_id))?;

            let signed_oid = remote

                .remove(&refname)

                .ok_or_else(|| VerifyError::UnknownRef(remote_id, refname.clone()))?;

impl ReadRepository for Repository {

    fn is_empty(&self) -> Result<bool, git2::Error> {

    }

    fn path(&self) -> &Path {

    fn reference(

        &self,

        remote: &RemoteId,

    ) -> Result<git2::Reference, git::Error> {

        self.backend.find_reference(&name).map_err(git::Error::from)

    }

        Ok(revwalk)

    }

        let oid = self

            .reference(remote, reference)?

            .target()

        // TODO: Only return known refs, eg. heads/ rad/ tags/ etc..

        let entries = self

            .backend

        let mut refs = BTreeMap::new();

        for e in entries {

            let (_, refname) = git::parse_ref::<RemoteId>(name)?;

            let oid = e.target().ok_or(Error::InvalidRef)?;

        }

        Ok(refs.into())

    }

        //     local <- git-fetch -- staging             # fetch from staging copy

        //

        let url = url.to_string();

        let mut updates = Vec::new();

        let mut callbacks = git2::RemoteCallbacks::new();

        let tempdir = tempfile::tempdir()?;

        // Strip the remote refs of sigrefs so we can compare them.

        for remote in refs.values_mut() {

        }

        let remotes = remotes

        let proj = *inventory.first().unwrap();

        let repo = alice.repository(proj).unwrap();

        let remotes = repo.remotes().unwrap().collect::<Vec<_>>();

        // Have Bob fetch Alice's refs.

        let updates = bob

        for update in updates {

            assert_matches!(

                update,

            );

        }

        let (proj_id, _, proj_repo, alice_head) =

            fixtures::project(tmp.path().join("alice/project"), &alice, &alice_signer).unwrap();

        let alice_url = git::Url {

            scheme: git_url::Scheme::File,

            path: paths::repository(&alice, &proj_id)

        let alice_head = git::commit(&proj_repo, &alice_head, &refname, "Making changes", "Alice")

            .unwrap()

            .id();

        alice.sign_refs(&alice_proj_storage, &alice_signer).unwrap();

        // Have Bob fetch Alice's new commit.

        assert_eq!(

            updates,

            vec![

            ]

        );

    }

        let mut unsigned = project.references(&alice).unwrap();

        // The signed refs doesn't contain the signature ref itself.

        assert_eq!(remote.refs, signed);

        assert_eq!(*remote.refs, unsigned);

use crate::storage;

use crate::storage::{ReadRepository, RemoteId, WriteRepository};

pub const REFS_BLOB_PATH: &str = "refs";

pub const SIGNATURE_BLOB_PATH: &str = "signature";

        let mut buf = String::new();

        let refs = self

            .iter()

        for (name, oid) in refs {

            buf.push_str(&oid.to_string());

            }

        }

        let author = repo.raw().signature()?;

        let commit = repo.raw().commit(

            Some(&sigref),

    fn reference(

        &self,

        _remote: &RemoteId,

    ) -> Result<git2::Reference, git_ext::Error> {

        todo!()

    }

    fn reference_oid(

        &self,

        _remote: &RemoteId,

    ) -> Result<git_ext::Oid, git_ext::Error> {

        todo!()

    }