feat: Remote knows about its tagOpt configuration.

That way it's clear if it should or shouldn't fetch included/reachable
tags automatically.

The default setting for this is to include tags, similar to `git`.

The `fetch_tags()` accessor allows to query this information, and the
`with_fetch_tags()` builder method allows to set the value comfortably
right after creating the `Remote` instance.

The `tagOpt` key will also be written as part of the remote's git
configuration.

Clone operations can set the `Tags` setting when configuring the
remote in a callback.

This also comes with a fix to assure that ref-updates aren't skipped
just because there was no pack to receive. That way, locally missing
refs or tags will automatically be put back.

Author: Byron

git-repository/src/clone/fetch/mod.rs

@@ -12,7 +12,9 @@ pub enum Error {
     #[error(transparent)]
     Fetch(#[from] crate::remote::fetch::Error),
     #[error(transparent)]
-    RemoteConfiguration(#[from] crate::remote::init::Error),
+    RemoteInit(#[from] crate::remote::init::Error),
+    #[error("Custom configuration of remote to clone from failed")]
+    RemoteConfiguration(#[source] Box<dyn std::error::Error + Send + Sync>),
     #[error("Default remote configured at `clone.defaultRemoteName` is invalid")]
     RemoteName(#[from] crate::remote::name::Error),
     #[error("Failed to load repo-local git configuration before writing")]
@@ -24,7 +26,7 @@ pub enum Error {
     #[error("The remote HEAD points to a reference named {head_ref_name:?} which is invalid.")]
     InvalidHeadRef {
         source: git_validate::refname::Error,
-        head_ref_name: crate::bstr::BString,
+        head_ref_name: BString,
     },
     #[error("Failed to update HEAD with values from remote")]
     HeadUpdate(#[from] crate::reference::edit::Error),
@@ -51,6 +53,7 @@ impl PrepareFetch {
         P: crate::Progress,
         P::SubProgress: 'static,
     {
+        use crate::remote;
         use crate::{bstr::ByteVec, remote::fetch::RefLogMessage};
 
         let repo = self
@@ -64,36 +67,39 @@ impl PrepareFetch {
                 .config
                 .resolved
                 .string_by_key("clone.defaultRemoteName")
-                .map(|n| crate::remote::name::validated(n.into_owned()))
+                .map(|n| remote::name::validated(n.into_owned()))
                 .unwrap_or_else(|| Ok("origin".into()))?,
         };
 
         let mut remote = repo
             .remote_at(self.url.clone())?
             .with_refspecs(
                 Some(format!("+refs/heads/*:refs/remotes/{remote_name}/*").as_str()),
-                crate::remote::Direction::Fetch,
+                remote::Direction::Fetch,
             )
             .expect("valid static spec");
         if let Some(f) = self.configure_remote.as_mut() {
-            remote = f(remote)?;
+            remote = f(remote).map_err(|err| Error::RemoteConfiguration(err))?;
         }
 
         let config = util::write_remote_to_local_config_file(&mut remote, remote_name.clone())?;
 
         // Add HEAD after the remote was written to config, we need it to know what to checkout later, and assure
         // the ref that HEAD points to is present no matter what.
-        remote.fetch_specs.push(
-            git_refspec::parse(
-                format!("HEAD:refs/remotes/{remote_name}/HEAD").as_str().into(),
-                git_refspec::parse::Operation::Fetch,
-            )
-            .expect("valid")
-            .to_owned(),
-        );
-        let pending_pack: crate::remote::fetch::Prepare<'_, '_, _, _> = remote
-            .connect(crate::remote::Direction::Fetch, progress)?
-            .prepare_fetch(self.fetch_options.clone())?;
+        let head_refspec = git_refspec::parse(
+            format!("HEAD:refs/remotes/{remote_name}/HEAD").as_str().into(),
+            git_refspec::parse::Operation::Fetch,
+        )
+        .expect("valid")
+        .to_owned();
+        let pending_pack: remote::fetch::Prepare<'_, '_, _, _> =
+            remote.connect(remote::Direction::Fetch, progress)?.prepare_fetch({
+                let mut opts = self.fetch_options.clone();
+                if !opts.extra_refspecs.contains(&head_refspec) {
+                    opts.extra_refspecs.push(head_refspec)
+                }
+                opts
+            })?;
         if pending_pack.ref_map().object_hash != repo.object_hash() {
             unimplemented!("configure repository to expect a different object hash as advertised by the server")
         }
@@ -148,10 +154,13 @@ impl PrepareFetch {
     ///
     /// The passed in `remote` will be un-named and pre-configured to be a default remote as we know it from git-clone.
     /// It is not yet present in the configuration of the repository,
-    /// but each change it will eventually be written to the configuration prior to performing a the fetch operation.
+    /// but each change it will eventually be written to the configuration prior to performing a the fetch operation,
+    /// _all changes done in `f()` will be persisted_.
+    ///
+    /// It can also be used to configure additional options, like those for fetching tags.
     pub fn configure_remote(
         mut self,
-        f: impl FnMut(crate::Remote<'_>) -> Result<crate::Remote<'_>, crate::remote::init::Error> + 'static,
+        f: impl FnMut(crate::Remote<'_>) -> Result<crate::Remote<'_>, Box<dyn std::error::Error + Send + Sync>> + 'static,
     ) -> Self {
         self.configure_remote = Some(Box::new(f));
         self

git-repository/src/clone/mod.rs

@@ -2,7 +2,8 @@ use std::convert::TryInto;
 
 use crate::bstr::BString;
 
-type ConfigureRemoteFn = Box<dyn FnMut(crate::Remote<'_>) -> Result<crate::Remote<'_>, crate::remote::init::Error>>;
+type ConfigureRemoteFn =
+    Box<dyn FnMut(crate::Remote<'_>) -> Result<crate::Remote<'_>, Box<dyn std::error::Error + Send + Sync>>>;
 
 /// A utility to collect configuration on how to fetch from a remote and initiate a fetch operation. It will delete the newly
 /// created repository on when dropped without successfully finishing a fetch.

git-repository/src/remote/access.rs

@@ -22,6 +22,11 @@ impl<'repo> Remote<'repo> {
         }
     }
 
+    /// Return how we handle tags when fetching the remote.
+    pub fn fetch_tags(&self) -> remote::fetch::Tags {
+        self.fetch_tags
+    }
+
     /// Return the url used for the given `direction` with rewrites from `url.<base>.insteadOf|pushInsteadOf`, unless the instance
     /// was created with one of the `_without_url_rewrite()` methods.
     /// For pushing, this is the `remote.<name>.pushUrl` or the `remote.<name>.url` used for fetching, and for fetching it's

git-repository/src/remote/build.rs

@@ -23,6 +23,12 @@ impl Remote<'_> {
         self.push_url_inner(url, false)
     }
 
+    /// Configure how tags should be handled when fetching from the remote.
+    pub fn with_fetch_tags(mut self, tags: remote::fetch::Tags) -> Self {
+        self.fetch_tags = tags;
+        self
+    }
+
     fn push_url_inner<Url, E>(mut self, push_url: Url, should_rewrite_urls: bool) -> Result<Self, remote::init::Error>
     where
         Url: TryInto<git_url::Url, Error = E>,

git-repository/src/remote/connection/fetch/mod.rs

@@ -41,8 +41,13 @@ impl RefLogMessage {
 /// The status of the repository after the fetch operation
 #[derive(Debug, Clone)]
 pub enum Status {
-    /// Nothing changed as the remote didn't have anything new compared to our tracking branches.
-    NoChange,
+    /// Nothing changed as the remote didn't have anything new compared to our tracking branches, thus no pack was received
+    /// and no new object was added.
+    NoPackReceived {
+        /// However, depending on the refspecs, references might have been updated nonetheless to point to objects as
+        /// reported by the remote.
+        update_refs: refs::update::Outcome,
+    },
     /// There was at least one tip with a new object which we received.
     Change {
         /// Information collected while writing the pack and its index.

git-repository/src/remote/connection/fetch/negotiate.rs

@@ -21,14 +21,27 @@ pub(crate) fn one_round(
     round: usize,
     repo: &crate::Repository,
     ref_map: &crate::remote::fetch::RefMap,
+    fetch_tags: crate::remote::fetch::Tags,
     arguments: &mut git_protocol::fetch::Arguments,
     _previous_response: Option<&git_protocol::fetch::Response>,
 ) -> Result<bool, Error> {
+    let tag_refspec_to_ignore = fetch_tags
+        .to_refspec()
+        .filter(|_| matches!(fetch_tags, crate::remote::fetch::Tags::Included));
     match algo {
         Algorithm::Naive => {
             assert_eq!(round, 1, "Naive always finishes after the first round, and claims.");
             let mut has_missing_tracking_branch = false;
             for mapping in &ref_map.mappings {
+                if tag_refspec_to_ignore.map_or(false, |tag_spec| {
+                    mapping
+                        .spec_index
+                        .implicit_index()
+                        .and_then(|idx| ref_map.extra_refspecs.get(idx))
+                        .map_or(false, |spec| spec.to_ref() == tag_spec)
+                }) {
+                    continue;
+                }
                 let have_id = mapping.local.as_ref().and_then(|name| {
                     repo.find_reference(name)
                         .ok()
@@ -44,8 +57,8 @@ pub(crate) fn one_round(
                         }
                     }
                     None => {
-                        if let Some(have_id) = mapping.remote.as_id() {
-                            arguments.want(have_id);
+                        if let Some(want_id) = mapping.remote.as_id() {
+                            arguments.want(want_id);
                             has_missing_tracking_branch = true;
                         }
                     }

git-repository/src/remote/connection/fetch/receive_pack.rs

@@ -99,14 +99,27 @@ where
                 round,
                 repo,
                 &self.ref_map,
+                con.remote.fetch_tags,
                 &mut arguments,
                 previous_response.as_ref(),
             ) {
                 Ok(_) if arguments.is_empty() => {
                     git_protocol::indicate_end_of_interaction(&mut con.transport).await.ok();
+                    let update_refs = refs::update(
+                        repo,
+                        self.reflog_message
+                            .take()
+                            .unwrap_or_else(|| RefLogMessage::Prefixed { action: "fetch".into() }),
+                        &self.ref_map.mappings,
+                        con.remote.refspecs(remote::Direction::Fetch),
+                        &self.ref_map.extra_refspecs,
+                        con.remote.fetch_tags,
+                        self.dry_run,
+                        self.write_packed_refs,
+                    )?;
                     return Ok(Outcome {
                         ref_map: std::mem::take(&mut self.ref_map),
-                        status: Status::NoChange,
+                        status: Status::NoPackReceived { update_refs },
                     });
                 }
                 Ok(is_done) => is_done,
@@ -175,6 +188,8 @@ where
                 .unwrap_or_else(|| RefLogMessage::Prefixed { action: "fetch".into() }),
             &self.ref_map.mappings,
             con.remote.refspecs(remote::Direction::Fetch),
+            &self.ref_map.extra_refspecs,
+            con.remote.fetch_tags,
             self.dry_run,
             self.write_packed_refs,
         )?;

git-repository/src/remote/connection/fetch/update_refs/mod.rs

@@ -33,38 +33,58 @@ impl From<update::Mode> for Update {
     }
 }
 
-/// Update all refs as derived from `mappings` and produce an `Outcome` informing about all applied changes in detail, with each
+/// Update all refs as derived from `refmap.mappings` and produce an `Outcome` informing about all applied changes in detail, with each
 /// [`update`][Update] corresponding to the [`fetch::Mapping`] of at the same index.
 /// If `dry_run` is true, ref transactions won't actually be applied, but are assumed to work without error so the underlying
 /// `repo` is not actually changed. Also it won't perform an 'object exists' check as these are likely not to exist as the pack
 /// wasn't fetched either.
 /// `action` is the prefix used for reflog entries, and is typically "fetch".
 ///
 /// It can be used to produce typical information that one is used to from `git fetch`.
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn update(
     repo: &Repository,
     message: RefLogMessage,
     mappings: &[fetch::Mapping],
     refspecs: &[git_refspec::RefSpec],
+    extra_refspecs: &[git_refspec::RefSpec],
+    fetch_tags: fetch::Tags,
     dry_run: fetch::DryRun,
     write_packed_refs: fetch::WritePackedRefs,
 ) -> Result<update::Outcome, update::Error> {
     let mut edits = Vec::new();
     let mut updates = Vec::new();
 
-    for (remote, local, spec) in mappings.iter().filter_map(
+    let implicit_tag_refspec = fetch_tags
+        .to_refspec()
+        .filter(|_| matches!(fetch_tags, crate::remote::fetch::Tags::Included));
+    for (remote, local, spec, is_implicit_tag) in mappings.iter().filter_map(
         |fetch::Mapping {
              remote,
              local,
              spec_index,
-         }| refspecs.get(*spec_index).map(|spec| (remote, local, spec)),
+         }| {
+            spec_index.get(refspecs, extra_refspecs).map(|spec| {
+                (
+                    remote,
+                    local,
+                    spec,
+                    implicit_tag_refspec.map_or(false, |tag_spec| spec.to_ref() == tag_spec),
+                )
+            })
+        },
     ) {
         let remote_id = match remote.as_id() {
             Some(id) => id,
             None => continue,
         };
         if dry_run == fetch::DryRun::No && !repo.objects.contains(remote_id) {
-            updates.push(update::Mode::RejectedSourceObjectNotFound { id: remote_id.into() }.into());
+            let update = if is_implicit_tag {
+                update::Mode::ImplicitTagNotSentByRemote.into()
+            } else {
+                update::Mode::RejectedSourceObjectNotFound { id: remote_id.into() }.into()
+            };
+            updates.push(update);
             continue;
         }
         let checked_out_branches = worktree_branches(repo)?;