feat: Repository::is_dirty() now also checks for tree/index changes.

This copmpletes the `is_dirty()` implementation.

Author: Byron

gix/src/config/cache/access.rs

@@ -181,7 +181,7 @@ impl Cache {
             .user_agent
             .get_or_init(|| {
                 self.resolved
-                    .string(Gitoxide::USER_AGENT.logical_name().as_str())
+                    .string(&Gitoxide::USER_AGENT)
                     .map_or_else(|| crate::env::agent().into(), |s| s.to_string())
             })
             .to_owned();

gix/src/status/mod.rs

@@ -129,7 +129,8 @@ impl Repository {
 
 ///
 pub mod is_dirty {
-    use crate::Repository;
+    use crate::{config, Repository};
+    use std::convert::Infallible;
 
     /// The error returned by [Repository::is_dirty()].
     #[derive(Debug, thiserror::Error)]
@@ -139,6 +140,10 @@ pub mod is_dirty {
         StatusPlatform(#[from] crate::status::Error),
         #[error(transparent)]
         CreateStatusIterator(#[from] crate::status::index_worktree::iter::Error),
+        #[error(transparent)]
+        TreeIndexStatus(#[from] crate::status::tree_index::Error),
+        #[error(transparent)]
+        HeadTreeId(#[from] crate::reference::head_tree_id::Error),
     }
 
     impl Repository {
@@ -150,12 +155,24 @@ pub mod is_dirty {
         /// * submodules are taken in consideration, along with their `ignore` and `isActive` configuration
         ///
         /// Note that *untracked files* do *not* affect this flag.
-        ///
-        /// ### Incomplete Implementation Warning
-        ///
-        /// Currently, this does not compute changes between the head and the index.
-        // TODO: use iterator which also tests for head->index changes.
         pub fn is_dirty(&self) -> Result<bool, Error> {
+            {
+                let mut repo = self.clone();
+                repo.config_snapshot_mut()
+                    .set_value(&config::tree::Status::RENAMES, "false")
+                    .expect("setting known values in memory always works");
+                let head_tree_id = repo.head_tree_id()?;
+                let mut index_is_dirty = false;
+
+                // Run this first as there is a high likelihood to find something, and it's very fast.
+                repo.tree_index_status(&head_tree_id, None, |_, _, _| {
+                    index_is_dirty = true;
+                    Ok::<_, Infallible>(gix_diff::index::Action::Cancel)
+                })?;
+                if index_is_dirty {
+                    return Ok(true);
+                }
+            }
             let is_dirty = self
                 .status(gix_features::progress::Discard)?
                 .index_worktree_rewrites(None)

gix/tests/fixtures/generated-archives/make_status_repos.tar

@@ -13,3 +13,11 @@ git init -q untracked-only
   mkdir new
   touch new/untracked subdir/untracked
 )
+
+git init git-mv
+(cd git-mv
+  echo hi > file
+  git add file && git commit -m "init"
+
+  git mv file renamed
+)

gix/tests/fixtures/make_status_repos.sh

@@ -134,7 +134,7 @@ mod index_worktree {
 }
 
 mod is_dirty {
-    use crate::status::submodule_repo;
+    use crate::status::{repo, submodule_repo};
 
     #[test]
     fn various_changes_positive() -> crate::Result {
@@ -155,7 +155,7 @@ mod is_dirty {
         let repo = submodule_repo("module1")?;
         assert_eq!(
             repo.status(gix::progress::Discard)?
-                .into_index_worktree_iter(Vec::new())?
+                .into_index_worktree_iter(None)?
                 .count(),
             1,
             "there is one untracked file"
@@ -168,9 +168,18 @@ mod is_dirty {
     }
 
     #[test]
-    fn no_changes() -> crate::Result {
+    fn index_changed() -> crate::Result {
+        let repo = repo("git-mv")?;
+        assert!(
+            repo.is_dirty()?,
+            "the only detectable change is in the index, in comparison to the HEAD^{{tree}}"
+        );
+
         let repo = submodule_repo("with-submodules")?;
-        assert!(!repo.is_dirty()?, "there are no changes");
+        assert!(
+            repo.is_dirty()?,
+            "the index changed here as well, this time there is also a new file"
+        );
         Ok(())
     }
 }