use crate::storage::RemoteId;

pub use git_ext::Oid;

pub use git_url::Url;

/// Default port of the `git` transport protocol.

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

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

    }

    Ok(remotes)

use crate::collections::HashMap;

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

use crate::git::Url;

use crate::identity;

use crate::identity::{ProjId, ProjIdError, UserId};

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

}

pub type RemoteId = UserId;

/// Project remotes. Tracks the git state of a project.

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

    fn reference(

        &self,

        user: &UserId,

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

    fn references(&self, user: &UserId) -> Result<Refs, Error>;

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

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

    fn reference(

        &self,

        remote: &RemoteId,

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

        let name = format!("refs/remotes/{remote}/{name}");

        self.backend.find_reference(&name).map(Some).or_else(|e| {

        })

    }

        let reference = self.reference(user, reference)?;

        Ok(reference.and_then(|r| r.target().map(|o| o.into())))

    }

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

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

        }

        Ok(refs.into())

    }

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

        for remote in refs.values_mut() {

        }

        assert_eq!(refs, remotes.into());

    }

        let inventory = alice.inventory().unwrap();

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

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

        // Have Bob fetch Alice's refs.

        bob.repository(proj)

        for (id, _) in remotes.into_iter() {

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

            let bob_repo = bob.repository(proj).unwrap();

            assert_eq!(alice_oid.target(), bob_oid.target());

        }

        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 std::path::Path;

use std::str::FromStr;

use radicle_git_ext as git_ext;

use serde::{Deserialize, Serialize};

use thiserror::Error;

use crate::storage;

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

pub const REFS_BLOB_PATH: &str = "refs";

pub const SIGNATURE_BLOB_PATH: &str = "signature";

/// The published state of a local repository.

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

impl Refs {

    /// Verify the given signature on these refs, and return [`SignedRefs`] on success.

                .split_once(' ')

                .ok_or(canonical::Error::InvalidFormat)?;

            let oid = Oid::from_str(oid)?;

            refs.insert(name, oid);

    pub fn canonical(&self) -> Vec<u8> {

        let mut buf = String::new();

        for (name, oid) in refs {

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

    }

}

    fn from(refs: Refs) -> Self {

        refs.0

    }

    }

}

        Self(refs)

    }

}

impl Deref for Refs {

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

        &self.0

    where

        S: ReadRepository,

    {

            Self::load_at(oid, remote, repo)

        } else {

            Err(Error::NotFound)

        remote: &RemoteId,

        repo: &S,

    ) -> Result<Updated, Error> {

        let parent: Option<git2::Commit> = repo

            .map(|r| r.peel_to_commit())

            .transpose()?;

            }

        }

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

        let commit = repo.raw().commit(

            Some(&sigref),

            &author,

            &author,

            &tree,

            &parent.iter().collect::<Vec<&git2::Commit>>(),

        );

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

    pub enum Error {

        #[error("invalid canonical format")]

        InvalidFormat,

        #[error(transparent)]

        let encoded = refs.canonical();

        let decoded = Refs::from_canonical(&encoded).unwrap();

        assert_eq!(refs, decoded);

    }

}

use crate::collections::HashMap;

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

use crate::crypto::{PublicKey, SecretKey};

use crate::hash;

use crate::identity::ProjId;

use crate::storage;

impl Arbitrary for Refs {

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

        let mut bytes: [u8; 20] = [0; 20];

        let names = &[

            "heads/master",

                    *byte = u8::arbitrary(g);

                }

                let oid = storage::Oid::try_from(&bytes[..]).unwrap();

            }

        }

        Self::from(refs)

use git_url::Url;

use crate::crypto::Verified;

use crate::identity::{ProjId, UserId};

use crate::storage::refs;

use crate::storage::{

    fn reference(

        &self,

        _user: &UserId,

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

        todo!()

    }

    fn reference_oid(

        &self,

        _user: &UserId,

    ) -> Result<Option<radicle_git_ext::Oid>, git2::Error> {

        todo!()

    }