Remove kstring from gix-attributes.

Add Criterion benchmarks for attribute lookup in a single file with 1, 10, 100, and 1000 entries, plus five nested files with 1024, 512, 256, 128, and 64 entries.

The kstring baseline measured 58.393 ns, 670.48 ns, 8.0138 us, and 96.207 us for the single-file cases, and 209.72 us for the hierarchy. Store owned attribute names in gix-features OwnShared<str>, using Rc without the parallel feature and Arc with it, so lookup clones remain allocation-free without another string dependency or leaked storage. Default-mode medians are 55.115 ns, 643.63 ns, 7.9572 us, 95.431 us, and 207.61 us; parallel-mode medians are 57.324 ns, 668.03 ns, 7.8143 us, 94.853 us, and 204.28 us. Outcome shrinks from 840 to 752 bytes.

Keep non-parallel consumers Rc-compatible: own the synthetic match-all pathspec per Search, defer CLI pathspec construction until after the worker boundary, transport attribute baseline assignments as thread-safe strings, and cache test exclusions per thread for the repository discovered from each archive path. Forward the parallel opt-in through public dependent crates, with Send assertions for pathspec Search and filter Pipeline. The always-threaded worktree stream enables parallel explicitly.

Validation:
- just check
- cargo +1.85.0 test -p gix-attributes --lib --tests
- cargo +1.85.0 test -p gix-attributes --lib --tests --features parallel
- cargo test -p gix-attributes
- cargo test -p gix-attributes --all-features --lib --tests
- cargo test -p gix-pathspec --features parallel
- cargo test -p gix-filter --features sha1,parallel
- cargo test -p gix-testtools --lib --tests
- cargo test -p gitoxide-core --lib
- cargo test --no-default-features --features small --lib
- cargo clippy -p gix-attributes --all-targets --all-features -- -D warnings
- cargo clippy -p gix-pathspec --all-targets --features parallel -- -D warnings
- cargo clippy -p gix-filter --all-targets --features sha1,parallel -- -D warnings
- cargo clippy --no-default-features --features small -- -D warnings
- cargo check --workspace --all-targets
- cargo build -p gix-pathspec --target wasm32-wasip1
- cargo build -p gix-pathspec --target wasm32-wasip2
- cargo build -p gix-pathspec --target wasm32-unknown-unknown
- cargo bench -p gix-attributes --bench lookup -- --noplot
- cargo bench -p gix-attributes --bench lookup --features parallel -- --noplot

Author: codex

Cargo.lock

@@ -18,7 +18,11 @@ pub(crate) mod function {
     };
 
     use anyhow::{anyhow, bail};
-    use gix::{Count, Progress, attrs::Assignment, bstr::BString};
+    use gix::{
+        Count, Progress,
+        attrs::{Assignment, NameRef},
+        bstr::{BString, ByteSlice},
+    };
 
     use crate::{
         OutputFormat,
@@ -200,19 +204,19 @@ pub(crate) mod function {
                     let fast_path_mismatch = matches
                         .iter()
                         .map(|m| m.assignment)
-                        .zip(expected.iter().map(Assignment::as_ref))
+                        .zip(expected.iter().map(ThreadSafeAssignment::as_ref))
                         .any(|(a, b)| a != b);
                     if fast_path_mismatch {
                         let actual_set = BTreeSet::from_iter(matches.iter().map(|m| m.assignment));
-                        let expected_set = BTreeSet::from_iter(expected.iter().map(Assignment::as_ref));
+                        let expected_set = BTreeSet::from_iter(expected.iter().map(ThreadSafeAssignment::as_ref));
                         let too_few_or_too_many =
                             !(expected_set.sub(&actual_set).is_empty() && actual_set.sub(&expected_set).is_empty());
                         if too_few_or_too_many {
                             mismatches.push((
                                 rela_path,
                                 Mismatch::Attributes {
                                     actual: matches.iter().map(|m| m.assignment.to_owned()).collect(),
-                                    expected,
+                                    expected: expected.into_iter().map(Into::into).collect(),
                                 },
                             ));
                         }
@@ -256,10 +260,36 @@ pub(crate) mod function {
     }
 
     enum Baseline {
-        Attribute { assignments: Vec<gix::attrs::Assignment> },
+        Attribute { assignments: Vec<ThreadSafeAssignment> },
         Exclude { location: Option<ExcludeLocation> },
     }
 
+    struct ThreadSafeAssignment {
+        name: String,
+        state: gix::attrs::State,
+    }
+
+    impl ThreadSafeAssignment {
+        fn as_ref(&self) -> gix::attrs::AssignmentRef<'_> {
+            gix::attrs::AssignmentRef {
+                name: NameRef::try_from(self.name.as_bytes().as_bstr())
+                    .expect("names from git check-attr were validated while parsing"),
+                state: self.state.as_ref(),
+            }
+        }
+    }
+
+    impl From<ThreadSafeAssignment> for Assignment {
+        fn from(value: ThreadSafeAssignment) -> Self {
+            Assignment {
+                name: NameRef::try_from(value.name.as_bytes().as_bstr())
+                    .expect("names from git check-attr were validated while parsing")
+                    .to_owned(),
+                state: value.state,
+            }
+        }
+    }
+
     #[derive(Debug)]
     // See note on `Mismatch`
     #[allow(dead_code)]
@@ -329,7 +359,7 @@ pub(crate) mod function {
         let (path, assignment) = parse_attribute_line(&first)?;
 
         let current = path.to_owned();
-        out.push(assignment.to_owned());
+        out.push(assignment);
         loop {
             let next_line = match lines.peek() {
                 None => break,
@@ -339,15 +369,15 @@ pub(crate) mod function {
             if next_path != current {
                 return Some((current, Baseline::Attribute { assignments: out }));
             } else {
-                out.push(next_assignment.to_owned());
+                out.push(next_assignment);
                 lines.next();
             }
         }
         Some((current, Baseline::Attribute { assignments: out }))
     }
 
-    fn parse_attribute_line(line: &str) -> Option<(&str, gix::attrs::AssignmentRef<'_>)> {
-        use gix::{attrs::StateRef, bstr::ByteSlice};
+    fn parse_attribute_line(line: &str) -> Option<(&str, ThreadSafeAssignment)> {
+        use gix::attrs::StateRef;
 
         let mut prev = None;
         let mut tokens = line.splitn(3, |b| {
@@ -364,9 +394,9 @@ pub(crate) mod function {
             };
             path = path.trim_end_matches(':');
             let attr = attr.trim_end_matches(':');
-            let assignment = gix::attrs::AssignmentRef {
-                name: gix::attrs::NameRef::try_from(attr.as_bytes().as_bstr()).ok()?,
-                state,
+            let assignment = ThreadSafeAssignment {
+                name: NameRef::try_from(attr.as_bytes().as_bstr()).ok()?.as_str().to_owned(),
+                state: state.to_owned(),
             };
             Some((path, assignment))
         } else {

gitoxide-core/src/repository/attributes/validate_baseline.rs

@@ -14,27 +14,35 @@ rust-version = "1.85"
 [lib]
 doctest = true
 
+[[bench]]
+name = "lookup"
+harness = false
+path = "./benches/lookup.rs"
+
 [features]
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde = ["dep:serde", "bstr/serde", "gix-glob/serde", "kstring/serde"]
+serde = ["dep:serde", "bstr/serde", "gix-glob/serde"]
+## Enable thread-safety.
+parallel = ["gix-features/parallel"]
 
 [dependencies]
+gix-features = { version = "^0.48.1", path = "../gix-features" }
 gix-path = { version = "^0.12.2", path = "../gix-path" }
 gix-quote = { version = "^0.7.2", path = "../gix-quote" }
 gix-glob = { version = "^0.26.1", path = "../gix-glob" }
 gix-trace = { version = "^0.1.20", path = "../gix-trace" }
 
 bstr = { version = "1.12.0", default-features = false, features = ["std", "unicode"] }
 smallvec = "1.15.1"
-kstring = "2.0.0"
 unicode-bom = { version = "2.0.3" }
 thiserror = "2.0.18"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 
 document-features = { version = "0.2.1", optional = true }
 
 [dev-dependencies]
-gix-testtools = { path = "../tests/tools" }
+criterion = "0.7.0"
+gix-testtools = { path = "../tests/tools", default-features = false }
 gix-fs = { path = "../gix-fs" }
 
 [package.metadata.docs.rs]