feat: obtain a refmap after listing refs via remote::Connection::list_refs_to_map(). (#450)

With it it's possible to establish a relationship between what's about
to be fetched to local tracking branches as established by refspecs for
fetching.

Author: Byron

git-repository/src/remote/connection/list_refs.rs

@@ -27,9 +27,9 @@ where
     /// Note that this doesn't fetch the objects mentioned in the tips nor does it make any change to underlying repository.
     #[git_protocol::maybe_async::maybe_async]
     pub async fn list_refs(mut self) -> Result<Vec<git_protocol::fetch::Ref>, Error> {
-        let res = self.fetch_refs().await?;
+        let res = self.fetch_refs().await;
         git_protocol::fetch::indicate_end_of_interaction(&mut self.transport).await?;
-        Ok(res.refs)
+        Ok(res?.refs)
     }
 
     #[git_protocol::maybe_async::maybe_async]
@@ -99,19 +99,19 @@ pub mod to_map {
         /// Note that this doesn't fetch the objects mentioned in the tips nor does it make any change to underlying repository.
         #[git_protocol::maybe_async::maybe_async]
         pub async fn list_refs_to_map(mut self) -> Result<fetch::RefMap, Error> {
-            let mappings = self.ref_map().await?;
+            let res = self.ref_map().await;
             git_protocol::fetch::indicate_end_of_interaction(&mut self.transport)
                 .await
                 .map_err(|err| Error::ListRefs(crate::remote::list_refs::Error::Transport(err)))?;
-            Ok(mappings)
+            Ok(res?)
         }
 
         #[git_protocol::maybe_async::maybe_async]
         async fn ref_map(&mut self) -> Result<fetch::RefMap, Error> {
-            let res = self.fetch_refs().await?;
+            let remote = self.fetch_refs().await?;
             let group = git_refspec::MatchGroup::from_fetch_specs(self.remote.fetch_specs.iter().map(|s| s.to_ref()));
-            let (_res, fixes) = group
-                .match_remotes(res.refs.iter().map(|r| {
+            let (res, fixes) = group
+                .match_remotes(remote.refs.iter().map(|r| {
                     let (full_ref_name, target, object) = r.unpack();
                     git_refspec::match_group::Item {
                         full_ref_name,
@@ -120,10 +120,23 @@ pub mod to_map {
                     }
                 }))
                 .validated()?;
-            Ok(fetch::RefMap {
-                mappings: Vec::new(),
-                fixes,
-            })
+            let mappings = res.mappings;
+            let mappings = mappings
+                .into_iter()
+                .map(|m| fetch::Mapping {
+                    remote: m
+                        .item_index
+                        .map(|idx| fetch::Source::Ref(remote.refs[idx].clone()))
+                        .unwrap_or_else(|| {
+                            fetch::Source::ObjectId(match m.lhs {
+                                git_refspec::match_group::SourceRef::ObjectId(id) => id,
+                                _ => unreachable!("no item index implies having an object id"),
+                            })
+                        }),
+                    local: m.rhs.map(|c| c.into_owned()),
+                })
+                .collect();
+            Ok(fetch::RefMap { mappings, fixes })
         }
     }
 }

git-repository/src/remote/mod.rs

@@ -38,10 +38,18 @@ pub mod fetch {
         pub fixes: Vec<git_refspec::match_group::validate::Fix>,
     }
 
+    /// Either an object id that the remote has or the matched remote ref itself.
+    pub enum Source {
+        /// An object id, as the matched ref-spec was an object id itself.
+        ObjectId(git_hash::ObjectId),
+        /// The remote reference that matched the ref-specs name.
+        Ref(git_protocol::fetch::Ref),
+    }
+
     /// A mapping between a single remote reference and its advertised objects to a local destination which may or may not exist.
     pub struct Mapping {
         /// The reference on the remote side, along with information about the objects they point to as advertised by the server.
-        pub remote: git_protocol::fetch::Ref,
+        pub remote: Source,
         /// The local tracking reference to update after fetching the object visible via `remote`.
         pub local: Option<BString>,
     }

git-repository/tests/remote/list_refs.rs

@@ -29,6 +29,17 @@ mod blocking_io {
                 let refs = connection.list_refs()?;
                 assert_eq!(refs.len(), 14, "it gets all remote refs, independently of the refspec.");
             }
+
+            {
+                let connection = remote.connect(Fetch, progress::Discard)?;
+                let map = connection.list_refs_to_map()?;
+                assert_eq!(map.fixes.len(), 0);
+                assert_eq!(
+                    map.mappings.len(),
+                    11,
+                    "mappings are only a sub-set of all remotes due to refspec matching"
+                );
+            }
         }
         Ok(())
     }