5aadb26 storage/refs/sigrefs: migrate reference::Reader to RefReader — heartwood

modified crates/radicle/src/storage.rs

@@ -436,7 +436,7 @@ impl Deref for Remote {

 /// Read-only operations on a storage instance.
 pub trait ReadStorage {
     type Repository: ReadRepository + self::refs::sigrefs::git::reference::Reader;
     type Repository: ReadRepository + crate::git::repository::RefReader;
     /// Get user info for this storage.
     fn info(&self) -> &UserInfo;

modified crates/radicle/src/storage/refs.rs

@@ -19,7 +19,7 @@ use thiserror::Error;

 use crate::git;
 use crate::git::Oid;
 use crate::git::raw::ErrorExt as _;
 use crate::git::repository::ObjectReader;
 use crate::git::repository::{ObjectReader, RefReader};
 use crate::storage;
 use crate::storage::RemoteId;
 use crate::storage::refs::sigrefs::read::Tip;

@@ -80,7 +80,7 @@ impl Refs {

     ) -> Result<SignedRefs, Error>
     where
         R: ObjectReader + sigrefs::git::object::Writer,
         R: sigrefs::git::reference::Reader + sigrefs::git::reference::Writer,
         R: RefReader + sigrefs::git::reference::Writer,
         R: HasRepoId,
         S: signature::Signer<crypto::Signature>,
         S: signature::Verifier<crypto::Signature>,

@@ -98,7 +98,7 @@ impl Refs {

     ) -> Result<SignedRefs, Error>
     where
         R: ObjectReader + sigrefs::git::object::Writer,
         R: sigrefs::git::reference::Reader + sigrefs::git::reference::Writer,
         R: RefReader + sigrefs::git::reference::Writer,
         R: HasRepoId,
         S: signature::Signer<crypto::Signature>,
         S: signature::Verifier<crypto::Signature>,

@@ -116,7 +116,7 @@ impl Refs {

     ) -> Result<SignedRefs, Error>
     where
         R: ObjectReader + sigrefs::git::object::Writer,
         R: sigrefs::git::reference::Reader + sigrefs::git::reference::Writer,
         R: RefReader + sigrefs::git::reference::Writer,
         R: HasRepoId,
         S: signature::Signer<crypto::Signature>,
         S: signature::Verifier<crypto::Signature>,

@@ -349,10 +349,10 @@ pub struct RefsAt {

 impl RefsAt {
     pub fn new<R>(repo: &R, remote: RemoteId) -> Result<Self, sigrefs::read::error::Read>
     where
         R: sigrefs::git::reference::Reader,
         R: RefReader,
     {
         let at = repo
             .find_reference(
             .ref_target(
                 &storage::refs::SIGREFS_BRANCH.with_namespace(git::fmt::Component::from(&remote)),
             )
             .map_err(sigrefs::read::error::Read::FindReference)?

@@ -426,7 +426,7 @@ impl SignedRefs {

     pub fn load<R>(remote: RemoteId, repo: &R) -> Result<Option<Self>, sigrefs::read::error::Read>
     where
         R: HasRepoId,
         R: ObjectReader + sigrefs::git::reference::Reader,
         R: ObjectReader + RefReader,
     {
         Self::load_internal(remote, repo, sigrefs::read::Tip::Reference(remote))
     }

@@ -438,7 +438,7 @@ impl SignedRefs {

     ) -> Result<Option<Self>, sigrefs::read::error::Read>
     where
         R: HasRepoId,
         R: ObjectReader + sigrefs::git::reference::Reader,
         R: ObjectReader + RefReader,
     {
         Self::load_internal(remote, repo, sigrefs::read::Tip::Commit(oid))
     }

@@ -450,7 +450,7 @@ impl SignedRefs {

     ) -> Result<Option<Self>, sigrefs::read::error::Read>
     where
         R: HasRepoId,
         R: ObjectReader + sigrefs::git::reference::Reader,
         R: ObjectReader + RefReader,
     {
         let root = repo.rid();
         match sigrefs::SignedRefsReader::new(root, tip, repo, &remote).read() {

modified crates/radicle/src/storage/refs/sigrefs/read.rs

@@ -16,9 +16,8 @@ use radicle_git_metadata::commit::CommitData;

 use radicle_oid::Oid;
 use crate::git;
 use crate::git::repository::ObjectReader;
 use crate::git::repository::{ObjectReader, RefReader};
 use crate::identity::doc;
 use crate::storage::refs::sigrefs::git::reference;
 use crate::storage::refs::{
     FeatureLevel, IDENTITY_ROOT, REFS_BLOB_PATH, Refs, SIGNATURE_BLOB_PATH, SIGREFS_BRANCH,
     SignedRefs,

@@ -129,7 +128,7 @@ impl std::fmt::Display for FeatureLevels {

 impl<'a, R, V> SignedRefsReader<'a, R, V>
 where
     R: ObjectReader + reference::Reader,
     R: ObjectReader + RefReader,
     V: signature::Verifier<crypto::Signature>,
 {
     /// Construct a new [`SignedRefsReader`].

@@ -305,7 +304,7 @@ where

                     SIGREFS_BRANCH.with_namespace(git::fmt::Component::from(&namespace));
                 let head = self
                     .repository
                     .find_reference(&reference)
                     .ref_target(&reference)
                     .map_err(error::Read::FindReference)?
                     .ok_or_else(|| error::Read::MissingSigrefs { namespace })?;
                 Ok(head)

modified crates/radicle/src/storage/refs/sigrefs/read/error.rs

@@ -7,7 +7,7 @@ use radicle_oid::Oid;

 use thiserror::Error;
 use crate::git::repository::object;
 use crate::storage::refs::sigrefs::git::reference;
 use crate::git::repository::reference;
 use crate::storage::refs::sigrefs::read::FeatureLevels;
 use crate::storage::refs::{FeatureLevel, canonical};

@@ -17,7 +17,7 @@ pub enum Read {

     #[error(transparent)]
     Commit(Commit),
     #[error(transparent)]
     FindReference(reference::error::FindReference),
     FindReference(reference::error::read::RefTargetError),
     #[error("failed to find `refs/namespaces/{namespace}/refs/rad/sigrefs`")]
     MissingSigrefs { namespace: NodeId },
     #[error(transparent)]

@@ -67,7 +67,7 @@ impl fmt::Display for Parent {

                 .iter()
                 .map(|oid| oid.to_string())
                 .collect::<Vec<_>>()
                 .join(", ")
                 .join(", "),
         )
     }
 }

modified crates/radicle/src/storage/refs/sigrefs/read/test/mock.rs

@@ -14,11 +14,11 @@ use radicle_git_metadata::commit::trailers::OwnedTrailer;

 use radicle_oid::Oid;
 use crate::git;
 use crate::git::repository::ObjectReader;
 use crate::git::repository::object;
 use crate::git::repository::reference;
 use crate::git::repository::types::{Blob, Commit};
 use crate::git::repository::{ObjectReader, RefReader};
 use crate::identity::doc;
 use crate::storage::refs::sigrefs::git::reference;
 use crate::storage::refs::{REFS_BLOB_PATH, Refs, SIGNATURE_BLOB_PATH, SIGREFS_BRANCH};
 pub(crate) const MOCKED_IDENTITY: u8 = 99u8;

@@ -216,19 +216,30 @@ impl ObjectReader for MockRepository {

     }
 }
 impl reference::Reader for MockRepository {
     fn find_reference(
 impl RefReader for MockRepository {
     type References<'a> = std::iter::Empty<
         Result<(git::fmt::Qualified<'static>, Oid), reference::error::read::ListReferenceError>,
     >;
     fn ref_target<R: AsRef<git::fmt::RefStr>>(
         &self,
         reference: &git::fmt::Namespaced,
     ) -> Result<Option<Oid>, reference::error::FindReference> {
         match self.references.get(reference.as_str()) {
         name: &R,
     ) -> Result<Option<Oid>, reference::error::read::RefTargetError> {
         match self.references.get(name.as_ref().as_str()) {
             Some(RefBehavior::Present(oid)) => Ok(Some(*oid)),
             Some(RefBehavior::Missing) | None => Ok(None),
             Some(RefBehavior::Error) => Err(reference::error::FindReference::other(
             Some(RefBehavior::Error) => Err(reference::error::read::RefTargetError::backend(
                 std::io::Error::other("mock reference error"),
             )),
         }
     }
     fn list_refs<'a, P: AsRef<git::fmt::refspec::PatternStr>>(
         &'a self,
         _pattern: &P,
     ) -> Result<Self::References<'a>, reference::error::read::ListRefsError> {
         unimplemented!("MockRepository::list_refs")
     }
 }
 /// Accepts every (message, signature) pair without inspecting either.

modified crates/radicle/src/storage/refs/sigrefs/write.rs

@@ -13,7 +13,7 @@ use radicle_git_metadata::commit::{CommitData, headers::Headers, trailers::Owned

 use radicle_oid::Oid;
 use crate::git;
 use crate::git::repository::ObjectReader;
 use crate::git::repository::{ObjectReader, RefReader};
 use crate::storage::refs::SignedRefs;
 use crate::storage::refs::sigrefs::git::{Committer, object, reference};
 use crate::storage::refs::sigrefs::read::CommitReader;

@@ -73,7 +73,7 @@ pub struct SignedRefsWriter<'a, R, S> {

 impl<'a, R, S> SignedRefsWriter<'a, R, S>
 where
     R: object::Writer + ObjectReader + reference::Writer + reference::Reader,
     R: object::Writer + ObjectReader + reference::Writer + RefReader,
     S: Signer<crypto::Signature>,
     S: signature::Verifier<crypto::Signature>,
 {

@@ -373,7 +373,7 @@ struct HeadReader<'a, 'b, 'c, R, V> {

 impl<'a, 'b, 'c, R, V> HeadReader<'a, 'b, 'c, R, V>
 where
     R: ObjectReader + reference::Reader,
     R: ObjectReader + RefReader,
     V: signature::Verifier<crypto::Signature>,
 {
     /// Construct a [`HeadReader`] with the `reference` that is being read from

@@ -401,7 +401,7 @@ where

     fn read(self) -> Result<Option<Head>, error::Head> {
         let Some(oid) = self
             .repository
             .find_reference(self.reference)
             .ref_target(self.reference)
             .map_err(error::Head::Reference)?
         else {
             return Ok(None);

modified crates/radicle/src/storage/refs/sigrefs/write/error.rs

@@ -1,6 +1,7 @@

 use radicle_oid::Oid;
 use thiserror::Error;
 use crate::git::repository;
 use crate::storage::refs::sigrefs::git::{object, reference};
 // TODO: use commit NID (and RID?) for traceability

@@ -41,7 +42,7 @@ pub enum Tree {

 #[error(transparent)]
 pub enum Head {
     #[error(transparent)]
     Reference(reference::error::FindReference),
     Reference(repository::reference::error::read::RefTargetError),
     #[error(transparent)]
     Commit(super::read::error::Commit),
     #[error("failed to verify commit {commit}: {source}")]

modified crates/radicle/src/storage/refs/sigrefs/write/test/mock.rs

@@ -11,8 +11,8 @@ use radicle_oid::Oid;

 use crate::git;
 use crate::git::repository;
 use crate::git::repository::ObjectReader;
 use crate::git::repository::types::{Blob, Commit};
 use crate::git::repository::{ObjectReader, RefReader};
 use crate::identity::doc;
 use crate::storage::HasRepoId;
 use crate::storage::refs::sigrefs::git::{object, reference};

@@ -249,19 +249,35 @@ impl ObjectReader for MockRepository {

     }
 }
 impl reference::Reader for MockRepository {
     fn find_reference(
 impl RefReader for MockRepository {
     type References<'a> = std::iter::Empty<
         Result<
             (git::fmt::Qualified<'static>, Oid),
             repository::reference::error::read::ListReferenceError,
         >,
     >;
     fn ref_target<R: AsRef<git::fmt::RefStr>>(
         &self,
         reference: &git::fmt::Namespaced,
     ) -> Result<Option<Oid>, reference::error::FindReference> {
         match self.references.get(reference.as_str()) {
         name: &R,
     ) -> Result<Option<Oid>, repository::reference::error::read::RefTargetError> {
         match self.references.get(name.as_ref().as_str()) {
             Some(RefBehavior::Present(oid)) => Ok(Some(*oid)),
             Some(RefBehavior::Missing) | None => Ok(None),
             Some(RefBehavior::Error) => Err(reference::error::FindReference::other(
                 std::io::Error::other("mock reference error"),
             )),
             Some(RefBehavior::Error) => {
                 Err(repository::reference::error::read::RefTargetError::backend(
                     std::io::Error::other("mock reference error"),
                 ))
             }
         }
     }
     fn list_refs<'a, P: AsRef<git::fmt::refspec::PatternStr>>(
         &'a self,
         _pattern: &P,
     ) -> Result<Self::References<'a>, repository::reference::error::read::ListRefsError> {
         unimplemented!("MockRepository::list_refs")
     }
 }
 impl object::Writer for MockRepository {

modified crates/radicle/src/test/storage.rs

@@ -152,16 +152,29 @@ impl MockRepository {

     }
 }
 impl self::refs::sigrefs::git::reference::Reader for MockRepository {
     fn find_reference(
 impl crate::git::repository::RefReader for MockRepository {
     type References<'a> = std::iter::Empty<
         Result<
             (git::fmt::Qualified<'static>, Oid),
             crate::git::repository::reference::error::read::ListReferenceError,
         >,
     >;
     fn ref_target<R: AsRef<git::fmt::RefStr>>(
         &self,
         reference: &git::fmt::Namespaced,
     ) -> Result<Option<Oid>, refs::sigrefs::git::reference::error::FindReference> {
         use refs::sigrefs::git::reference::error::FindReference;
         let ns = reference.namespace();
         name: &R,
     ) -> Result<Option<Oid>, crate::git::repository::reference::error::read::RefTargetError> {
         use crate::git::repository::reference::error::read::RefTargetError;
         let name = name.as_ref();
         let namespaced = match name.to_namespaced() {
             Some(ns) => ns,
             None => return Ok(None),
         };
         let remote: PublicKey = ns.as_str().parse().map_err(FindReference::other)?;
         let reference = reference.strip_namespace();
         let ns = namespaced.namespace();
         let remote: PublicKey = ns.as_str().parse().map_err(RefTargetError::backend)?;
         let reference = namespaced.strip_namespace();
         match self.remotes.get(&remote) {
             None => Ok(None),

@@ -174,6 +187,14 @@ impl self::refs::sigrefs::git::reference::Reader for MockRepository {

             }
         }
     }
     fn list_refs<'a, P: AsRef<git::fmt::refspec::PatternStr>>(
         &'a self,
         _pattern: &P,
     ) -> Result<Self::References<'a>, crate::git::repository::reference::error::read::ListRefsError>
     {
         unimplemented!("MockRepository::list_refs")
     }
 }
 impl RemoteRepository for MockRepository {