c09f8a5 storage/refs/sigrefs: migrate reference::Writer to RefWriter — heartwood

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, ObjectWriter, RefReader};
 use crate::git::repository::{ObjectReader, ObjectWriter, RefReader, RefWriter};
 use crate::storage;
 use crate::storage::RemoteId;
 use crate::storage::refs::sigrefs::read::Tip;

@@ -79,8 +79,8 @@ impl Refs {

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

@@ -97,8 +97,8 @@ impl Refs {

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

@@ -115,8 +115,8 @@ impl Refs {

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

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

@@ -11,9 +11,9 @@ use radicle_git_metadata::commit::{CommitData, headers::Headers, trailers::Owned

 use radicle_oid::Oid;
 use crate::git;
 use crate::git::repository::{ObjectReader, ObjectWriter, RefReader};
 use crate::git::repository::{ObjectReader, ObjectWriter, RefReader, RefTarget, RefWriter};
 use crate::storage::refs::SignedRefs;
 use crate::storage::refs::sigrefs::git::{Committer, object, reference};
 use crate::storage::refs::sigrefs::git::{Committer, object};
 use crate::storage::refs::sigrefs::read::CommitReader;
 use crate::storage::refs::sigrefs::{VerifiedCommit, read};
 use crate::storage::refs::{FeatureLevel, IDENTITY_ROOT, Refs, SIGREFS_BRANCH, SIGREFS_PARENT};

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

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

@@ -175,8 +175,15 @@ where

             Err(err) => return Err(error::Write::Head(err)),
         };
         let commit = commit_writer.write().map_err(error::Write::Commit)?;
         let target = match commit.parent {
             Some(expected) => RefTarget::Cas {
                 target: commit.oid,
                 expected,
             },
             None => RefTarget::Create { target: commit.oid },
         };
         repository
             .write_reference(&reference, commit.oid, commit.parent, reflog)
             .write_ref(&reference, target, &reflog)
             .map_err(error::Write::Reference)?;
         Ok(Update::changed(commit, FeatureLevel::Parent))
     }

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

@@ -1,9 +1,8 @@

 use radicle_oid::Oid;
 use thiserror::Error;
 use crate::git::repository;
 use crate::git::repository::object;
 use crate::storage::refs::sigrefs::git::reference;
 use crate::git::repository::reference;
 // TODO: use commit NID (and RID?) for traceability
 #[derive(Debug, Error)]

@@ -14,7 +13,7 @@ pub enum Write {

     #[error(transparent)]
     Commit(Commit),
     #[error(transparent)]
     Reference(reference::error::WriteReference),
     Reference(reference::error::write::WriteRefError),
 }
 // TODO: use commit OID for traceability

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

 #[error(transparent)]
 pub enum Head {
     #[error(transparent)]
     Reference(repository::reference::error::read::RefTargetError),
     Reference(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

@@ -10,13 +10,12 @@ use radicle_git_metadata::commit::trailers::OwnedTrailer;

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

@@ -32,9 +31,9 @@ enum WriteTreeBehavior {

 struct WriteCommitBehavior(Oid);
 enum WriteReferenceBehavior {
     /// [`reference::Writer::write_reference`] returns `Ok(())`.
     /// [`RefWriter::write_ref`] returns `Ok(())`.
     Ok,
     /// [`reference::Writer::write_reference`] returns `Err(…)`.
     /// [`RefWriter::write_ref`] returns `Err(…)`.
     Error,
 }

@@ -246,31 +245,26 @@ impl ObjectReader for MockRepository {

 impl RefReader for MockRepository {
     type References<'a> = std::iter::Empty<
         Result<
             (git::fmt::Qualified<'static>, Oid),
             repository::reference::error::read::ListReferenceError,
         >,
         Result<(git::fmt::Qualified<'static>, Oid), reference::error::read::ListReferenceError>,
     >;
     fn ref_target<R: AsRef<git::fmt::RefStr>>(
         &self,
         name: &R,
     ) -> Result<Option<Oid>, repository::reference::error::read::RefTargetError> {
     ) -> 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(repository::reference::error::read::RefTargetError::backend(
                     std::io::Error::other("mock reference error"),
                 ))
             }
             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>, repository::reference::error::read::ListRefsError> {
     ) -> Result<Self::References<'a>, reference::error::read::ListRefsError> {
         unimplemented!("MockRepository::list_refs")
     }
 }

@@ -299,23 +293,29 @@ impl ObjectWriter for MockRepository {

     }
 }
 impl reference::Writer for MockRepository {
     fn write_reference(
 impl RefWriter for MockRepository {
     fn write_ref<R: AsRef<git::fmt::RefStr>>(
         &self,
         _reference: &git::fmt::Namespaced,
         _commit: Oid,
         _parent: Option<Oid>,
         _reflog: String,
     ) -> Result<(), reference::error::WriteReference> {
         _name: &R,
         _target: RefTarget,
         _reflog: &str,
     ) -> Result<(), reference::error::write::WriteRefError> {
         match &self.write_reference {
             Some(WriteReferenceBehavior::Ok) => Ok(()),
             Some(WriteReferenceBehavior::Error) | None => {
                 Err(reference::error::WriteReference::other(
                     std::io::Error::other("mock write_reference error"),
                 Err(reference::error::write::WriteRefError::backend(
                     std::io::Error::other("mock write_ref error"),
                 ))
             }
         }
     }
     fn delete_ref<R: AsRef<git::fmt::RefStr>>(
         &self,
         _name: &R,
     ) -> Result<(), reference::error::write::DeleteRefError> {
         unimplemented!("MockRepository::delete_ref")
     }
 }
 /// Always signs successfully, returning a fixed 64-byte signature.