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.

The `fetch_tags()` accessor allows to query this information, and the
`with_fetch_tags()` builder method allwos 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.

Author: Byron

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/errors.rs

@@ -6,6 +6,10 @@ pub mod find {
     #[derive(Debug, thiserror::Error)]
     #[allow(missing_docs)]
     pub enum Error {
+        #[error(
+            "The value for 'remote.<name>.tagOpt` is invalid and must either be '--tags' or '--no-tags': \"{value}\""
+        )]
+        TagOpt { value: BString },
         #[error("{spec:?} {kind} ref-spec failed to parse")]
         RefSpec {
             spec: BString,

git-repository/src/remote/fetch.rs

@@ -1,5 +1,3 @@
-use crate::bstr::{BStr, BString};
-
 /// If `Yes`, don't really make changes but do as much as possible to get an idea of what would be done.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
@@ -20,8 +18,28 @@ pub(crate) enum WritePackedRefs {
     Only,
 }
 
+/// Describe how to handle tags when fetching
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Tags {
+    /// Fetch all tags from the remote, even if these are not reachable from objects referred to by our refspecs.
+    All,
+    /// Fetch only the tags that point to the objects being sent.
+    /// That way, annotated tags that point to an object we receive are automatically transmitted and their refs are created.
+    /// The same goes for lightweight tags.
+    Included,
+    /// Do not fetch any tags.
+    None,
+}
+
+impl Default for Tags {
+    fn default() -> Self {
+        Tags::Included
+    }
+}
+
 /// Information about the relationship between our refspecs, and remote references with their local counterparts.
 #[derive(Default, Debug, Clone)]
+#[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
 pub struct RefMap {
     /// A mapping between a remote reference and a local tracking branch.
     pub mappings: Vec<Mapping>,
@@ -41,13 +59,15 @@ pub struct RefMap {
 
 /// Either an object id that the remote has or the matched remote ref itself.
 #[derive(Debug, Clone)]
+#[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
 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::handshake::Ref),
 }
 
+#[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
 impl Source {
     /// Return either the direct object id we refer to or the direct target that a reference refers to.
     /// The latter may be a direct or a symbolic reference, and we degenerate this to the peeled object id.
@@ -60,7 +80,7 @@ impl Source {
     }
 
     /// Return ourselves as the full name of the reference we represent, or `None` if this source isn't a reference but an object.
-    pub fn as_name(&self) -> Option<&BStr> {
+    pub fn as_name(&self) -> Option<&crate::bstr::BStr> {
         match self {
             Source::ObjectId(_) => None,
             Source::Ref(r) => match r {
@@ -75,11 +95,12 @@ impl Source {
 
 /// A mapping between a single remote reference and its advertised objects to a local destination which may or may not exist.
 #[derive(Debug, Clone)]
+#[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
 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: Source,
     /// The local tracking reference to update after fetching the object visible via `remote`.
-    pub local: Option<BString>,
+    pub local: Option<crate::bstr::BString>,
     /// The index into the fetch ref-specs used to produce the mapping, allowing it to be recovered.   
     pub spec_index: usize,
 }

git-repository/src/remote/init.rs

@@ -27,13 +27,15 @@ use crate::bstr::BString;
 
 /// Initialization
 impl<'repo> Remote<'repo> {
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn from_preparsed_config(
         name_or_url: Option<BString>,
         url: Option<git_url::Url>,
         push_url: Option<git_url::Url>,
         fetch_specs: Vec<RefSpec>,
         push_specs: Vec<RefSpec>,
         should_rewrite_urls: bool,
+        fetch_tags: remote::fetch::Tags,
         repo: &'repo Repository,
     ) -> Result<Self, Error> {
         debug_assert!(
@@ -51,6 +53,7 @@ impl<'repo> Remote<'repo> {
             push_url_alias,
             fetch_specs,
             push_specs,
+            fetch_tags,
             repo,
         })
     }
@@ -76,6 +79,7 @@ impl<'repo> Remote<'repo> {
             push_url_alias: None,
             fetch_specs: Vec::new(),
             push_specs: Vec::new(),
+            fetch_tags: Default::default(),
             repo,
         })
     }

git-repository/src/remote/mod.rs

@@ -43,7 +43,6 @@ pub use errors::find;
 pub mod init;
 
 ///
-#[cfg(any(feature = "async-network-client", feature = "blocking-network-client"))]
 pub mod fetch;
 
 ///

git-repository/src/repository/remote.rs

@@ -4,6 +4,9 @@ use crate::{bstr::BStr, remote, remote::find, Remote};
 
 impl crate::Repository {
     /// Create a new remote available at the given `url`.
+    ///
+    /// It's configured to fetch included tags by default, similar to git.
+    /// See [`with_fetch_tags(…)`][Remote::with_fetch_tags()] for a way to change it.
     pub fn remote_at<Url, E>(&self, url: Url) -> Result<Remote<'_>, remote::init::Error>
     where
         Url: TryInto<git_url::Url, Error = E>,
@@ -12,7 +15,8 @@ impl crate::Repository {
         Remote::from_fetch_url(url, true, self)
     }
 
-    /// Create a new remote available at the given `url`, but don't rewrite the url according to rewrite rules.
+    /// Create a new remote available at the given `url` similarly to [`remote_at()`][crate::Repository::remote_at()],
+    /// but don't rewrite the url according to rewrite rules.
     /// This eliminates a failure mode in case the rewritten URL is faulty, allowing to selectively [apply rewrite
     /// rules][Remote::rewrite_urls()] later and do so non-destructively.
     pub fn remote_at_without_url_rewrite<Url, E>(&self, url: Url) -> Result<Remote<'_>, remote::init::Error>
@@ -91,14 +95,14 @@ impl crate::Repository {
         };
         let url = config_url("url", "fetch");
         let push_url = config_url("pushUrl", "push");
+        let config = &self.config.resolved;
 
         let mut config_spec = |op: git_refspec::parse::Operation| {
             let kind = match op {
                 git_refspec::parse::Operation::Fetch => "fetch",
                 git_refspec::parse::Operation::Push => "push",
             };
-            self.config
-                .resolved
+            config
                 .strings_filter("remote", Some(name_or_url), kind, &mut filter)
                 .map(|specs| {
                     specs
@@ -122,6 +126,20 @@ impl crate::Repository {
         };
         let fetch_specs = config_spec(git_refspec::parse::Operation::Fetch);
         let push_specs = config_spec(git_refspec::parse::Operation::Push);
+        let fetch_tags = config
+            .string_filter("remote", Some(name_or_url), "tagOpt", &mut filter)
+            .map(|tag| {
+                Ok(match tag.as_ref().as_ref() {
+                    b"--tags" => remote::fetch::Tags::All,
+                    b"--no-tags" => remote::fetch::Tags::None,
+                    unknown => return Err(find::Error::TagOpt { value: unknown.into() }),
+                })
+            });
+        let fetch_tags = match fetch_tags {
+            Some(Ok(v)) => v,
+            Some(Err(err)) => return Some(Err(err)),
+            None => Default::default(),
+        };
 
         match (url, fetch_specs, push_url, push_specs) {
             (None, None, None, None) => None,
@@ -156,6 +174,7 @@ impl crate::Repository {
                         fetch_specs,
                         push_specs,
                         rewrite_urls,
+                        fetch_tags,
                         self,
                     )
                     .map_err(Into::into),

git-repository/src/types.rs

@@ -195,6 +195,8 @@ pub struct Remote<'repo> {
     pub(crate) fetch_specs: Vec<git_refspec::RefSpec>,
     /// Refspecs for use when pushing.
     pub(crate) push_specs: Vec<git_refspec::RefSpec>,
+    /// Tell us what to do with tags when fetched.
+    pub(crate) fetch_tags: remote::fetch::Tags,
     // /// Delete local tracking branches that don't exist on the remote anymore.
     // pub(crate) prune: bool,
     // /// Delete tags that don't exist on the remote anymore, equivalent to pruning the refspec `refs/tags/*:refs/tags/*`.

git-repository/tests/fixtures/make_remote_repos.sh

@@ -97,6 +97,12 @@ git clone --shared base clone
   git remote add myself .
 )
 
+git clone --no-tags --shared base clone-no-tags
+(cd clone-no-tags
+  git remote add --no-tags myself-no-tags .
+  git remote add --tags myself-with-tags .
+)
+
 git clone --shared base push-default
 (cd push-default
 

git-repository/tests/repository/remote.rs

@@ -110,7 +110,21 @@ mod find_remote {
     use crate::remote;
 
     #[test]
-    fn typical() {
+    fn tags_option() -> crate::Result {
+        let repo = remote::repo("clone-no-tags");
+        for (remote_name, expected) in [
+            ("origin", git::remote::fetch::Tags::None),
+            ("myself-no-tags", git::remote::fetch::Tags::None),
+            ("myself-with-tags", git::remote::fetch::Tags::All),
+        ] {
+            let remote = repo.find_remote(remote_name)?;
+            assert_eq!(remote.fetch_tags(), expected, "specifically set in this repo");
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn typical() -> crate::Result {
         let repo = remote::repo("clone");
         let mut count = 0;
         let base_dir = base_dir(&repo);
@@ -120,11 +134,17 @@ mod find_remote {
         ];
         for (name, (url, refspec)) in repo.remote_names().into_iter().zip(expected) {
             count += 1;
-            let remote = repo.find_remote(name).expect("no error");
+            let remote = repo.find_remote(name)?;
             assert_eq!(remote.name().expect("set").as_bstr(), name);
 
-            let url = git::url::parse(url.into()).expect("valid");
-            assert_eq!(remote.url(Direction::Fetch).unwrap(), &url);
+            assert_eq!(
+                remote.fetch_tags(),
+                git::remote::fetch::Tags::Included,
+                "the default value as it's not specified"
+            );
+
+            let url = git::url::parse(url.into())?;
+            assert_eq!(remote.url(Direction::Fetch).expect("present"), &url);
 
             assert_eq!(
                 remote.refspecs(Direction::Fetch),
@@ -142,6 +162,7 @@ mod find_remote {
             repo.find_remote("unknown").unwrap_err(),
             git::remote::find::existing::Error::NotFound { .. }
         ));
+        Ok(())
     }
 
     #[test]