feat: add index.threads configuration to gix::config::tree

Author: Byron

gix/src/config/tree/mod.rs

@@ -38,6 +38,8 @@ pub(crate) mod root {
         pub const GITOXIDE: sections::Gitoxide = sections::Gitoxide;
         /// The `http` section.
         pub const HTTP: sections::Http = sections::Http;
+        /// The `index` section.
+        pub const INDEX: sections::Index = sections::Index;
         /// The `init` section.
         pub const INIT: sections::Init = sections::Init;
         /// The `pack` section.
@@ -69,6 +71,7 @@ pub(crate) mod root {
                 &Self::EXTENSIONS,
                 &Self::GITOXIDE,
                 &Self::HTTP,
+                &Self::INDEX,
                 &Self::INIT,
                 &Self::PACK,
                 &Self::PROTOCOL,
@@ -84,9 +87,9 @@ pub(crate) mod root {
 
 mod sections;
 pub use sections::{
-    branch, checkout, core, credential, diff, extensions, gitoxide, http, protocol, remote, ssh, Author, Branch,
-    Checkout, Clone, Committer, Core, Credential, Diff, Extensions, Gitoxide, Http, Init, Pack, Protocol, Remote, Safe,
-    Ssh, Url, User,
+    branch, checkout, core, credential, diff, extensions, gitoxide, http, index, protocol, remote, ssh, Author, Branch,
+    Checkout, Clone, Committer, Core, Credential, Diff, Extensions, Gitoxide, Http, Index, Init, Pack, Protocol,
+    Remote, Safe, Ssh, Url, User,
 };
 
 /// Generic value implementations for static instantiation.

gix/src/config/tree/sections/index.rs

@@ -0,0 +1,62 @@
+use crate::{
+    config,
+    config::tree::{keys, Index, Key, Section},
+};
+
+impl Index {
+    /// The `index.threads` key.
+    pub const THREADS: IndexThreads =
+        IndexThreads::new_with_validate("threads", &config::Tree::INDEX, validate::IndexThreads);
+}
+
+/// The `index.threads` key.
+pub type IndexThreads = keys::Any<validate::IndexThreads>;
+
+mod index_threads {
+    use crate::bstr::BStr;
+    use crate::config;
+    use crate::config::key::GenericErrorWithValue;
+    use crate::config::tree::index::IndexThreads;
+    use std::borrow::Cow;
+
+    impl IndexThreads {
+        /// Parse `value` into the amount of threads to use, with `1` being single-threaded, or `0` indicating
+        /// to select the amount of threads, with any other number being the specific amount of threads to use.
+        pub fn try_into_index_threads(
+            &'static self,
+            value: Cow<'_, BStr>,
+        ) -> Result<usize, config::key::GenericErrorWithValue> {
+            gix_config::Integer::try_from(value.as_ref())
+                .ok()
+                .and_then(|i| i.to_decimal().and_then(|i| i.try_into().ok()))
+                .or_else(|| {
+                    gix_config::Boolean::try_from(value.as_ref())
+                        .ok()
+                        .map(|b| if b.0 { 0 } else { 1 })
+                })
+                .ok_or_else(|| GenericErrorWithValue::from_value(self, value.into_owned()))
+        }
+    }
+}
+
+impl Section for Index {
+    fn name(&self) -> &str {
+        "index"
+    }
+
+    fn keys(&self) -> &[&dyn Key] {
+        &[&Self::THREADS]
+    }
+}
+
+mod validate {
+    use crate::{bstr::BStr, config::tree::keys};
+
+    pub struct IndexThreads;
+    impl keys::Validate for IndexThreads {
+        fn validate(&self, value: &BStr) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+            super::Index::THREADS.try_into_index_threads(value.into())?;
+            Ok(())
+        }
+    }
+}

gix/src/config/tree/sections/mod.rs

@@ -55,6 +55,11 @@ pub mod gitoxide;
 pub struct Http;
 pub mod http;
 
+/// The `index` top-level section.
+#[derive(Copy, Clone, Default)]
+pub struct Index;
+pub mod index;
+
 /// The `init` top-level section.
 #[derive(Copy, Clone, Default)]
 pub struct Init;

gix/src/repository/worktree.rs

@@ -1,3 +1,4 @@
+use crate::config::cache::util::ApplyLeniencyDefault;
 use crate::{worktree, Worktree};
 
 /// Worktree iteration
@@ -58,23 +59,14 @@ impl crate::Repository {
     ///
     /// It will use the `index.threads` configuration key to learn how many threads to use.
     /// Note that it may fail if there is no index.
-    // TODO: test
     pub fn open_index(&self) -> Result<gix_index::File, worktree::open_index::Error> {
         let thread_limit = self
             .config
             .resolved
-            .boolean("index", None, "threads")
-            .map(|res| {
-                res.map(|value| usize::from(!value)).or_else(|err| {
-                    gix_config::Integer::try_from(err.input.as_ref())
-                        .map_err(|err| worktree::open_index::Error::ConfigIndexThreads {
-                            value: err.input.clone(),
-                            err,
-                        })
-                        .map(|value| value.to_decimal().and_then(|v| v.try_into().ok()).unwrap_or(1))
-                })
-            })
-            .transpose()?;
+            .string("index", None, "threads")
+            .map(|value| crate::config::tree::Index::THREADS.try_into_index_threads(value))
+            .transpose()
+            .with_lenient_default(self.config.lenient_config)?;
         gix_index::File::at(
             self.index_path(),
             self.object_hash(),

gix/src/worktree/mod.rs

@@ -71,18 +71,12 @@ pub mod proxy;
 
 ///
 pub mod open_index {
-    use crate::bstr::BString;
-
     /// The error returned by [`Worktree::open_index()`][crate::Worktree::open_index()].
     #[derive(Debug, thiserror::Error)]
     #[allow(missing_docs)]
     pub enum Error {
-        #[error("Could not interpret value '{}' as 'index.threads'", .value)]
-        ConfigIndexThreads {
-            value: BString,
-            #[source]
-            err: gix_config::value::Error,
-        },
+        #[error(transparent)]
+        ConfigIndexThreads(#[from] crate::config::key::GenericErrorWithValue),
         #[error(transparent)]
         IndexFile(#[from] gix_index::file::init::Error),
     }

gix/tests/config/tree.rs

@@ -351,6 +351,30 @@ mod core {
     }
 }
 
+mod index {
+    use crate::config::tree::bcow;
+    use gix::config::tree::{Index, Key};
+
+    #[test]
+    fn threads() {
+        for (value, expected) in [("false", 1), ("true", 0), ("0", 0), ("1", 1), ("2", 2), ("12", 12)] {
+            assert_eq!(
+                Index::THREADS.try_into_index_threads(bcow(value)).unwrap(),
+                expected,
+                "{value}"
+            );
+            assert!(Index::THREADS.validate(value.into()).is_ok());
+        }
+        assert_eq!(
+            Index::THREADS
+                .try_into_index_threads(bcow("nothing"))
+                .unwrap_err()
+                .to_string(),
+            "The key \"index.threads=nothing\" was invalid"
+        );
+    }
+}
+
 mod extensions {
     use gix::config::tree::{Extensions, Key};