fix!: support for non-'static PackedRefs transactions. (#450)

When configuring for packed-refs updates, previously one needed to
provide a function to find objects that could not borrow data due
to implicit 'static requirement. This has been lifted to allow
it to access references to data on the stack.

Author: Byron

git-ref/src/store/file/mod.rs

@@ -62,11 +62,11 @@ mod access {
 }
 
 /// A transaction on a file store
-pub struct Transaction<'s> {
+pub struct Transaction<'s, 'p> {
     store: &'s Store,
     packed_transaction: Option<crate::store_impl::packed::Transaction>,
     updates: Option<Vec<transaction::Edit>>,
-    packed_refs: transaction::PackedRefs,
+    packed_refs: transaction::PackedRefs<'p>,
 }
 
 pub(in crate::store_impl::file) fn path_to_name<'a>(path: impl Into<Cow<'a, Path>>) -> Cow<'a, BStr> {

git-ref/src/store/file/transaction/commit.rs

@@ -4,7 +4,7 @@ use crate::{
     Target,
 };
 
-impl<'s> Transaction<'s> {
+impl<'s, 'p> Transaction<'s, 'p> {
     /// Make all [prepared][Transaction::prepare()] permanent and return the performed edits which represent the current
     /// state of the affected refs in the ref store in that instant. Please note that the obtained edits may have been
     /// adjusted to contain more dependent edits or additional information.

git-ref/src/store/file/transaction/mod.rs

@@ -10,24 +10,24 @@ use crate::{
 /// used to obtain the peeled object ids for storage in packed-refs files.
 ///
 /// Resolution means to follow tag objects until the end of the chain.
-pub type FindObjectFn =
-    dyn FnMut(
+pub type FindObjectFn<'a> = dyn FnMut(
         git_hash::ObjectId,
         &mut Vec<u8>,
-    ) -> Result<Option<git_object::Kind>, Box<dyn std::error::Error + Send + Sync + 'static>>;
+    ) -> Result<Option<git_object::Kind>, Box<dyn std::error::Error + Send + Sync + 'static>>
+    + 'a;
 
 /// How to handle packed refs during a transaction
-pub enum PackedRefs {
+pub enum PackedRefs<'a> {
     /// Only propagate deletions of references. This is the default
     DeletionsOnly,
     /// Propagate deletions as well as updates to references which are peeled, that is contain an object id
-    DeletionsAndNonSymbolicUpdates(Box<FindObjectFn>),
+    DeletionsAndNonSymbolicUpdates(Box<FindObjectFn<'a>>),
     /// Propagate deletions as well as updates to references which are peeled, that is contain an object id. Furthermore delete the
     /// reference which is originally updated if it exists. If it doesn't, the new value will be written into the packed ref right away.
-    DeletionsAndNonSymbolicUpdatesRemoveLooseSourceReference(Box<FindObjectFn>),
+    DeletionsAndNonSymbolicUpdatesRemoveLooseSourceReference(Box<FindObjectFn<'a>>),
 }
 
-impl Default for PackedRefs {
+impl Default for PackedRefs<'_> {
     fn default() -> Self {
         PackedRefs::DeletionsOnly
     }
@@ -71,7 +71,7 @@ impl file::Store {
     /// will never have been altered.
     ///
     /// The transaction inherits the parent namespace.
-    pub fn transaction(&self) -> Transaction<'_> {
+    pub fn transaction(&self) -> Transaction<'_, '_> {
         Transaction {
             store: self,
             packed_transaction: None,
@@ -81,9 +81,9 @@ impl file::Store {
     }
 }
 
-impl<'s> Transaction<'s> {
+impl<'s, 'p> Transaction<'s, 'p> {
     /// Configure the way packed refs are handled during the transaction
-    pub fn packed_refs(mut self, packed_refs: PackedRefs) -> Self {
+    pub fn packed_refs(mut self, packed_refs: PackedRefs<'p>) -> Self {
         self.packed_refs = packed_refs;
         self
     }

git-ref/src/store/file/transaction/prepare.rs

@@ -12,7 +12,7 @@ use crate::{
     FullName, FullNameRef, Reference, Target,
 };
 
-impl<'s> Transaction<'s> {
+impl<'s, 'p> Transaction<'s, 'p> {
     fn lock_ref_and_apply_change(
         store: &file::Store,
         lock_fail_mode: git_lock::acquire::Fail,
@@ -167,7 +167,7 @@ impl<'s> Transaction<'s> {
     }
 }
 
-impl<'s> Transaction<'s> {
+impl<'s, 'p> Transaction<'s, 'p> {
     /// Prepare for calling [`commit(…)`][Transaction::commit()] in a way that can be rolled back perfectly.
     ///
     /// If the operation succeeds, the transaction can be committed or dropped to cause a rollback automatically.

git-ref/src/store/packed/transaction.rs

@@ -38,7 +38,7 @@ impl packed::Transaction {
     pub fn prepare(
         mut self,
         edits: impl IntoIterator<Item = RefEdit>,
-        find: &mut FindObjectFn,
+        find: &mut FindObjectFn<'_>,
     ) -> Result<Self, prepare::Error> {
         assert!(self.edits.is_none(), "BUG: cannot call prepare(…) more than once");
         let buffer = &self.buffer;