all tests pass, time to remove git2

Author: Byron

src/index/diff/mod.rs

@@ -83,6 +83,7 @@ impl Index {
             .unwrap_or_else(|| git::hash::ObjectId::empty_tree(repo.object_hash()));
         let remote_name = self
             .remote_name
+            .as_deref()
             .expect("always set for this old portion of the code");
         let to = {
             let repo = git2::Repository::open(repo.git_dir())?;
@@ -141,6 +142,7 @@ impl Index {
         let to = {
             let mut remote = self
                 .remote_name
+                .as_deref()
                 .and_then(|name| {
                     self.repo.find_remote(name).ok().or_else(|| {
                         self.repo
@@ -179,7 +181,7 @@ impl Index {
             if remote.refspecs(git::remote::Direction::Fetch).is_empty() {
                 let spec = format!(
                     "+refs/heads/{branch}:refs/remotes/{remote}/{branch}",
-                    remote = self.remote_name.unwrap_or("origin"),
+                    remote = self.remote_name.as_deref().unwrap_or("origin"),
                     branch = self.branch_name,
                 );
                 remote
@@ -241,6 +243,11 @@ impl Index {
 
 /// Find changes while changing the underlying repository in one way or another.
 impl Index {
+    /// As `fetch_changes_with_options`, but without the options.
+    pub fn fetch_changes2(&self) -> Result<Vec<Change>, Error> {
+        self.fetch_changes_with_options2(git::progress::Discard, &AtomicBool::default())
+    }
+
     /// As `fetch_changes_with_options`, but without the options.
     pub fn fetch_changes(&self) -> Result<Vec<Change>, Error> {
         self.fetch_changes_with_options(None)

src/index/init.rs

@@ -101,7 +101,7 @@ impl Index {
         repo.object_cache_size_if_unset(4 * 1024 * 1024);
         Ok(Index {
             repo,
-            remote_name: Some("origin"),
+            remote_name: Some("origin".into()),
             branch_name: "master",
             seen_ref_name: LAST_SEEN_REFNAME,
         })
@@ -148,9 +148,14 @@ impl Index {
         .apply_environment();
 
         repo.object_cache_size_if_unset(4 * 1024 * 1024);
+        let remote_name = repo
+            .remote_names()
+            .into_iter()
+            .next()
+            .map(ToOwned::to_owned);
         Ok(Index {
             repo,
-            remote_name: Some("origin"),
+            remote_name,
             branch_name: "master",
             seen_ref_name: LAST_SEEN_REFNAME,
         })

src/types.rs

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

tests/index/mod.rs

@@ -1,5 +1,6 @@
 use crates_index_diff::Index;
 use git_repository as git;
+use git_repository::refs::transaction::PreviousValue;
 use git_testtools::tempfile::TempDir;
 use std::path::PathBuf;
 use std::sync::atomic::AtomicBool;
@@ -60,20 +61,19 @@ fn clone_if_needed() {
 }
 
 #[test]
-#[ignore]
-fn changes_since_last_fetch() -> crate::Result {
-    let (mut index, _tmp) = index_rw()?;
+fn changes_since_last_fetch() {
+    let (mut index, _tmp) = index_rw().unwrap();
     let repo = index.repository();
     assert!(index.last_seen_reference().is_err(), "no marker exists");
-    let num_changes_since_first_commit = index.fetch_changes()?.len();
+    let num_changes_since_first_commit = index.fetch_changes2().unwrap().len();
     assert_eq!(
         num_changes_since_first_commit, NUM_CHANGES_SINCE_EVER,
         "all changes since ever"
     );
     let mut marker = index
         .last_seen_reference()
         .expect("must be created/update now");
-    let remote_main = repo.find_reference("refs/remotes/origin/main")?;
+    let remote_main = repo.find_reference("refs/remotes/origin/main").unwrap();
     assert_eq!(
         marker.target(),
         remote_main.target(),
@@ -83,15 +83,16 @@ fn changes_since_last_fetch() -> crate::Result {
     // reset to previous one
     marker
         .set_target_id(
-            repo.rev_parse(format!("{}~1", index.seen_ref_name).as_str())?
+            repo.rev_parse(format!("{}~1", index.seen_ref_name).as_str())
+                .unwrap()
                 .single()
                 .unwrap(),
             "resetting to previous commit",
         )
         .expect("reset success");
-    let num_seen_after_reset = index.fetch_changes()?.len();
+    let num_seen_after_reset = index.fetch_changes2().unwrap().len();
     assert_eq!(
-        index.last_seen_reference()?.target(),
+        index.last_seen_reference().unwrap().target(),
         remote_main.target(),
         "seen branch was updated again"
     );
@@ -101,26 +102,45 @@ fn changes_since_last_fetch() -> crate::Result {
     );
 
     assert_eq!(
-        index.fetch_changes()?.len(),
+        index.fetch_changes2().unwrap().len(),
         0,
         "nothing if there was no change"
     );
 
     // 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 = Some("local");
+    let repo_name = "local";
+    {
+        let git_dir = repo.git_dir().to_owned();
+        let mut config = index.repository_mut().config_snapshot_mut();
+        // TODO: use `remote.save_as_to()` here, requires a way to get the mutable repo ref again.
+        config
+            .set_raw_value("remote", Some(repo_name), "url", git_dir.to_str().unwrap())
+            .unwrap();
+        config
+            .set_raw_value(
+                "remote",
+                Some(repo_name),
+                "fetch",
+                "+refs/heads/*:refs/remotes/local/*",
+            )
+            .unwrap();
+    }
+    index.remote_name = Some(repo_name.into());
     index
         .repository()
-        .find_reference("refs/heads/main")?
-        .set_target_id(
+        .reference(
+            "refs/heads/main",
             index
                 .repository()
-                .rev_parse("origin/squashed")?
+                .rev_parse("origin/squashed")
+                .unwrap()
                 .single()
                 .unwrap(),
+            PreviousValue::Any,
             "adjust to simulate remote with new squashed history",
-        )?;
-    let changes = index.fetch_changes()?;
+        )
+        .unwrap();
+    let changes = index.fetch_changes2().unwrap();
     assert_eq!(changes.len(), 1);
     assert_eq!(
         changes
@@ -129,7 +149,6 @@ fn changes_since_last_fetch() -> crate::Result {
         Some(("git-repository", "1.0.0")),
         "there was just one actual changes compared to the previous state"
     );
-    Ok(())
 }
 
 fn index_ro() -> crate::Result<Index> {