sketch a new peek method that uses gitoxide to fetch things

Author: Byron

Cargo.toml

@@ -15,7 +15,7 @@ include = ["src/**/*", "LICENSE.md", "README.md", "CHANGELOG.md"]
 test = false
 
 [dependencies]
-git-repository = { version = "0.24.0", default-features = false, features = ["max-performance-safe"] }
+git-repository = { version = "0.24.0", default-features = false, features = ["max-performance-safe", "blocking-network-client", "blocking-http-transport"], git = "https://github.com/byron/gitoxide" }
 similar = { version = "2.2.0", features = ["bytes"] }
 serde = { version = "1", features = ["std", "derive"] }
 serde_json = "1"

src/index/diff/mod.rs

@@ -3,6 +3,7 @@ use git_repository as git;
 use git_repository::prelude::ObjectIdExt;
 use git_repository::refs::transaction::PreviousValue;
 use std::convert::TryFrom;
+use std::sync::atomic::AtomicBool;
 
 mod delegate;
 use delegate::Delegate;
@@ -12,7 +13,7 @@ use delegate::Delegate;
 #[allow(missing_docs)]
 pub enum Error {
     #[error("Failed to fetch crates.io index repository")]
-    Fetch(#[from] git2::Error),
+    FetchGit2(#[from] git2::Error),
     #[error("Couldn't update marker reference")]
     ReferenceEdit(#[from] git::reference::edit::Error),
     #[error("Failed to parse rev-spec to determine which revisions to diff")]
@@ -29,6 +30,23 @@ pub enum Error {
         file_name: bstr::BString,
         line: bstr::BString,
     },
+    #[error(transparent)]
+    FindRemote(#[from] git::remote::find::existing::Error),
+    #[error(transparent)]
+    FindReference(#[from] git::reference::find::existing::Error),
+    #[error(transparent)]
+    Connect(#[from] git::remote::connect::Error),
+    #[error(transparent)]
+    PrepareFetch(#[from] git::remote::fetch::prepare::Error),
+    #[error(transparent)]
+    Fetch(#[from] git::remote::fetch::Error),
+    #[error(transparent)]
+    InitAnonymousRemote(#[from] git::remote::init::Error),
+    #[error("Could not find local tracking branch for remote branch {name:?} in any of {} fetched refs", mappings.len())]
+    NoMatchingBranch {
+        name: String,
+        mappings: Vec<git::remote::fetch::Mapping>,
+    },
 }
 
 /// Find changes without modifying the underling repository
@@ -63,13 +81,16 @@ impl Index {
             .ok()
             .and_then(|r| r.try_id().map(|id| id.detach()))
             .unwrap_or_else(|| git::hash::ObjectId::empty_tree(repo.object_hash()));
+        let remote_name = self
+            .remote_name
+            .expect("always set for this old portion of the code");
         let to = {
             let repo = git2::Repository::open(repo.git_dir())?;
-            repo.find_remote(self.remote_name).and_then(|mut r| {
+            repo.find_remote(remote_name).and_then(|mut r| {
                 r.fetch(
                     &[format!(
                         "+refs/heads/{branch}:refs/remotes/{remote}/{branch}",
-                        remote = self.remote_name,
+                        remote = remote_name,
                         branch = self.branch_name,
                     )],
                     options,
@@ -79,7 +100,7 @@ impl Index {
             git::hash::ObjectId::try_from(
                 repo.refname_to_id(&format!(
                     "refs/remotes/{}/{}",
-                    self.remote_name, self.branch_name
+                    remote_name, self.branch_name
                 ))?
                 .as_bytes(),
             )
@@ -89,6 +110,110 @@ impl Index {
         Ok((self.changes_between_commits(from, to)?, to))
     }
 
+    /// Return all `Change`s that are observed between the last time `peek_changes*(…)` was called
+    /// and the latest state of the `crates.io` index repository, which is obtained by fetching
+    /// the remote called `origin` or whatever is configured for the current `HEAD` branch and lastly
+    /// what it should be based on knowledge about he crates index.
+    /// The `last_seen_reference()` will not be created or updated.
+    /// The second field in the returned tuple is the commit object to which the changes were provided.
+    /// If one would set the `last_seen_reference()` to that object, the effect is exactly the same
+    /// as if `fetch_changes(…)` had been called.
+    ///
+    /// # Resource Usage
+    ///
+    /// As this method fetches the git repository, loose objects or small packs may be created. Over time,
+    /// these will accumulate and either slow down subsequent operations, or cause them to fail due to exhaustion
+    /// of the maximum number of open file handles as configured with `ulimit`.
+    ///
+    /// Thus it is advised for the caller to run `git gc` occasionally based on their own requirements and usage patterns.
+    // TODO: update this once it's clear how auto-gc works in `gitoxide`.
+    pub fn peek_changes_with_options2(
+        &self,
+        progress: impl git::Progress,
+        should_interrupt: &AtomicBool,
+    ) -> Result<(Vec<Change>, git::hash::ObjectId), Error> {
+        let repo = &self.repo;
+        let from = repo
+            .find_reference(self.seen_ref_name)
+            .ok()
+            .and_then(|r| r.try_id().map(|id| id.detach()))
+            .unwrap_or_else(|| git::hash::ObjectId::empty_tree(repo.object_hash()));
+        let to = {
+            let remote = self
+                .remote_name
+                .and_then(|name| {
+                    self.repo.find_remote(name).ok().or_else(|| {
+                        self.repo
+                            .head()
+                            .ok()
+                            .and_then(|head| {
+                                head.into_remote(git::remote::Direction::Fetch)
+                                    .map(|r| r.ok())
+                                    .flatten()
+                            })
+                            .or_else(|| {
+                                self.repo
+                                    .find_default_remote(git::remote::Direction::Fetch)
+                                    .map(|r| r.ok())
+                                    .flatten()
+                            })
+                    })
+                })
+                .map(Ok)
+                .unwrap_or_else(|| {
+                    self.repo
+                        .head()?
+                        .into_remote(git::remote::Direction::Fetch)
+                        .map(|r| r.map_err(Error::from))
+                        .or_else(|| {
+                            self.repo
+                                .find_default_remote(git::remote::Direction::Fetch)
+                                .map(|r| r.map_err(Error::from))
+                        })
+                        .unwrap_or_else(|| {
+                            let spec = format!(
+                                "+refs/heads/{branch}:refs/remotes/{remote}/{branch}",
+                                remote = self.remote_name.unwrap_or("origin"),
+                                branch = self.branch_name,
+                            );
+                            self.repo
+                                .remote_at("https://github.com/rust-lang/crates.io-index")
+                                .map_err(Into::into)
+                                .map(|r| {
+                                    r.with_refspec(spec.as_str(), git::remote::Direction::Fetch)
+                                        .expect("valid refspec")
+                                })
+                        })
+                })?;
+            let res: git::remote::fetch::Outcome<'_> = remote
+                .connect(git::remote::Direction::Fetch, progress)?
+                .prepare_fetch(Default::default())?
+                .receive(should_interrupt)?;
+            let branch_name = format!("refs/heads/{}", self.branch_name);
+            let local_tracking = res
+                .ref_map
+                .mappings
+                .iter()
+                .find_map(|m| match &m.remote {
+                    git::remote::fetch::Source::Ref(r) => (r.unpack().0 == branch_name)
+                        .then(|| m.local.as_ref())
+                        .flatten(),
+                    _ => None,
+                })
+                .ok_or_else(|| Error::NoMatchingBranch {
+                    name: branch_name,
+                    mappings: res.ref_map.mappings.clone(),
+                })?;
+            self.repo
+                .find_reference(local_tracking)
+                .expect("local tracking branch exists if we see it here")
+                .id()
+                .detach()
+        };
+
+        Ok((self.changes_between_commits(from, to)?, to))
+    }
+
     /// Similar to `changes()`, but requires `from` and `to` objects to be provided. They may point
     /// to either `Commit`s or `Tree`s.
     pub fn changes_between_commits(

src/index/init.rs

@@ -88,7 +88,7 @@ impl Index {
         repo.object_cache_size_if_unset(4 * 1024 * 1024);
         Ok(Index {
             repo,
-            remote_name: "origin",
+            remote_name: Some("origin"),
             branch_name: "master",
             seen_ref_name: LAST_SEEN_REFNAME,
         })

src/types.rs

@@ -12,7 +12,8 @@ pub struct Index {
     /// The name of the branch to fetch. This value also affects the tracking branch.
     pub branch_name: &'static str,
     /// The name of the symbolic name of the remote to fetch from.
-    pub remote_name: &'static str,
+    /// If `None`, obtain the remote name from the configuration of the currently checked-out branch.
+    pub remote_name: Option<&'static str>,
     /// The git repository to use for diffing
     pub(crate) repo: git::Repository,
 }

tests/index/mod.rs

@@ -93,7 +93,7 @@ fn changes_since_last_fetch() -> crate::Result {
 
     // now the remote has squashed their history, we should still be able to get the correct changes.
     git2::Repository::open(repo.git_dir())?.remote("local", repo.git_dir().to_str().unwrap())?;
-    index.remote_name = "local";
+    index.remote_name = Some("local");
     index
         .repository()
         .find_reference("refs/heads/main")?