Add submodule support for status iterator

Author: Byron

gix/src/status/index_worktree.rs

@@ -174,6 +174,10 @@ impl Repository {
 /// Note that depending on the underlying configuration, there might be a significant delay until the first
 /// item is received due to the buffering necessary to perform rename tracking and/or sorting.
 ///
+/// ### Submodules
+///
+/// Note that submodules can be set to 'inactive' which automatically excludes them from the status operation.
+///
 /// ### Index Changes
 ///
 /// Changes to the index are collected and it's possible to write the index back using [iter::Outcome::write_changes()].
@@ -200,6 +204,7 @@ pub mod iter {
     use crate::status::index_worktree::iter;
     use crate::status::{index_worktree, Platform};
     use crate::worktree::IndexPersistedOrInMemory;
+    use crate::ThreadSafeRepository;
     use std::sync::atomic::{AtomicBool, Ordering};
     use std::sync::Arc;
 
@@ -420,9 +425,7 @@ pub mod iter {
         }
     }
 
-    /// The status of a submodule
-    #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
-    pub struct SubmoduleStatus {}
+    type SubmoduleStatus = crate::submodule::Status;
 
     /// The error returned by [Platform::into_index_worktree_iter()](crate::status::Platform::into_index_worktree_iter()).
     #[derive(Debug, thiserror::Error)]
@@ -434,6 +437,8 @@ pub mod iter {
         SpawnThread(#[source] std::io::Error),
         #[error(transparent)]
         ConfigSkipHash(#[from] crate::config::boolean::Error),
+        #[error(transparent)]
+        PrepareSubmodules(#[from] crate::submodule::modules::Error),
     }
 
     /// Lifecycle
@@ -454,7 +459,6 @@ pub mod iter {
             let should_interrupt = Arc::new(AtomicBool::default());
             let (tx, rx) = std::sync::mpsc::channel();
             let mut collect = Collect { tx };
-            let submodule = ComputeSubmoduleStatus { _mode: self.submodules };
             let skip_hash = self
                 .repo
                 .config
@@ -464,6 +468,7 @@ pub mod iter {
                 .transpose()
                 .with_lenient_default(self.repo.config.lenient_config)?
                 .unwrap_or_default();
+            let submodule = ComputeSubmoduleStatus::new(self.repo.clone().into_sync(), self.submodules)?;
             let join = std::thread::Builder::new()
                 .name("gix::status::index_worktree::iter::producer".into())
                 .spawn({
@@ -568,19 +573,53 @@ pub mod iter {
 
     #[derive(Clone)]
     struct ComputeSubmoduleStatus {
-        _mode: crate::status::Submodule,
+        mode: crate::status::Submodule,
+        repo: ThreadSafeRepository,
+        submodule_paths: Vec<BString>,
     }
 
+    ///
     mod submodule_status {
+        use crate::bstr;
         use crate::bstr::BStr;
         use crate::status::index_worktree::iter::{ComputeSubmoduleStatus, SubmoduleStatus};
+        use crate::status::Submodule;
+        use std::borrow::Cow;
+
+        impl ComputeSubmoduleStatus {
+            pub(super) fn new(
+                repo: crate::ThreadSafeRepository,
+                mode: crate::status::Submodule,
+            ) -> Result<Self, crate::submodule::modules::Error> {
+                let local_repo = repo.to_thread_local();
+                let submodule_paths = match local_repo.submodules()? {
+                    Some(sm) => {
+                        let mut v: Vec<_> = sm
+                            .filter(|sm| sm.is_active().unwrap_or_default())
+                            .filter_map(|sm| sm.path().ok().map(Cow::into_owned))
+                            .collect();
+                        v.sort();
+                        v
+                    }
+                    None => Vec::new(),
+                };
+                Ok(Self {
+                    mode,
+                    repo,
+                    submodule_paths,
+                })
+            }
+        }
 
-        /// The error returned by the submodule status implementation - it will be turned into a box, hence it doesn't have to
-        /// be private.
+        /// The error returned submodule status checks.
         #[derive(Debug, thiserror::Error)]
         #[allow(missing_docs)]
-        #[error("TBD")]
-        pub enum Error {}
+        pub(super) enum Error {
+            #[error(transparent)]
+            SubmoduleStatus(#[from] crate::submodule::status::Error),
+            #[error(transparent)]
+            IgnoreConfig(#[from] crate::submodule::config::Error),
+        }
 
         impl gix_status::index_as_worktree::traits::SubmoduleStatus for ComputeSubmoduleStatus {
             type Output = SubmoduleStatus;
@@ -589,9 +628,29 @@ pub mod iter {
             fn status(
                 &mut self,
                 _entry: &gix_index::Entry,
-                _rela_path: &BStr,
+                rela_path: &BStr,
             ) -> Result<Option<Self::Output>, Self::Error> {
-                todo!("impl in Submodule itself, it will be calling this exact implementation under the hood, maybe with reduced threads")
+                use bstr::ByteSlice;
+                if self
+                    .submodule_paths
+                    .binary_search_by(|path| path.as_bstr().cmp(rela_path))
+                    .is_err()
+                {
+                    return Ok(None);
+                }
+                let repo = self.repo.to_thread_local();
+                let Ok(Some(mut submodules)) = repo.submodules() else {
+                    return Ok(None);
+                };
+                let Some(sm) = submodules.find(|sm| sm.path().map_or(false, |path| path == rela_path)) else {
+                    return Ok(None);
+                };
+                let (ignore, check_dirty) = match self.mode {
+                    Submodule::AsConfigured { check_dirty } => (sm.ignore()?.unwrap_or_default(), check_dirty),
+                    Submodule::Given { ignore, check_dirty } => (ignore, check_dirty),
+                };
+                let status = sm.status(ignore, check_dirty)?;
+                Ok(status.is_dirty().and_then(|dirty| dirty.then_some(status)))
             }
         }
     }

gix/src/status/mod.rs

@@ -64,8 +64,6 @@ impl Repository {
     /// Whereas Git runs the index-modified check before the directory walk to set entries
     /// as up-to-date to (potentially) safe some disk-access, we run both in parallel which
     /// ultimately is much faster.
-    // TODO: if untracked and ignored entries are disabled, don't run a dirwalk at all.
-    // TODO: submodule support with reasonable configurability.
     pub fn status<P>(&self, progress: P) -> Result<Platform<'_, P>, config::boolean::Error>
     where
         P: gix_features::progress::Progress + 'static,
@@ -83,8 +81,6 @@ impl Repository {
             },
         })
     }
-
-    // TODO: submodule status, where the base of the operation is the list of submodules in the .gitmodules file.
 }
 
 mod platform;

gix/tests/fixtures/generated-archives/make_submodules.tar.xz

@@ -42,6 +42,22 @@ git init submodule-head-changed-and-modified
   )
 )
 
+git init modified-untracked-and-submodule-head-changed-and-modified
+(cd modified-untracked-and-submodule-head-changed-and-modified
+  git submodule add ../module1 m1
+  git commit -m "add submodule"
+
+  (cd m1
+    git checkout @~1
+    echo change >> this
+  )
+
+  touch this
+  git add this && git commit -m "this"
+  echo change >> this
+  touch untracked
+)
+
 git init with-submodules
 (cd with-submodules
   mkdir dir

gix/tests/fixtures/make_submodules.sh

@@ -16,5 +16,7 @@ mod remote;
 mod repository;
 #[cfg(feature = "revision")]
 mod revision;
+#[cfg(feature = "status")]
+mod status;
 #[cfg(feature = "attributes")]
 mod submodule;

gix/tests/gix.rs

@@ -0,0 +1,46 @@
+pub fn repo(name: &str) -> crate::Result<gix::Repository> {
+    use crate::util::named_subrepo_opts;
+    Ok(named_subrepo_opts(
+        "make_submodules.sh",
+        name,
+        gix::open::Options::isolated(),
+    )?)
+}
+
+mod index_worktree {
+    mod iter {
+        use crate::status::repo;
+
+        #[test]
+        fn submodule_modification() -> crate::Result {
+            let repo = repo("modified-untracked-and-submodule-head-changed-and-modified")?;
+            let mut status = repo
+                .status(gix::progress::Discard)?
+                .index_worktree_options_mut(|opts| {
+                    opts.sorting =
+                        Some(gix::status::plumbing::index_as_worktree_with_renames::Sorting::ByPathCaseSensitive)
+                })
+                .into_index_worktree_iter(Vec::new())?;
+            let items: Vec<_> = status.by_ref().filter_map(Result::ok).collect();
+            assert_eq!(items.len(), 3, "1 untracked, 1 modified file, 1 submodule modification");
+            Ok(())
+        }
+
+        #[test]
+        fn early_drop_for_is_dirty_emulation() -> crate::Result {
+            let repo = repo("modified-untracked-and-submodule-head-changed-and-modified")?;
+            let is_dirty = repo
+                .status(gix::progress::Discard)?
+                .index_worktree_submodules(gix::status::Submodule::AsConfigured { check_dirty: true })
+                .index_worktree_options_mut(|opts| {
+                    opts.sorting =
+                        Some(gix::status::plumbing::index_as_worktree_with_renames::Sorting::ByPathCaseSensitive)
+                })
+                .into_index_worktree_iter(Vec::new())?
+                .next()
+                .is_some();
+            assert!(is_dirty, "this should abort the work as quickly as possible");
+            Ok(())
+        }
+    }
+}