feat: add stack::Platform::excluded_kind().

That way one can tell whether the excluded item is precious or not.

Author: Byron

gix-worktree/src/stack/platform.rs

@@ -13,6 +13,10 @@ impl<'a> Platform<'a> {
 
     /// See if the currently set entry is excluded as per exclude and git-ignore files.
     ///
+    /// Note that this threats both classes, [*trashable*](gix_ignore::Kind::Expendable) and [*precious*](gix_ignore::Kind::Precious)
+    /// as equal. If you need to differentiate, use [`matching_exclude_pattern()`](Self::matching_exclude_pattern)
+    /// or [`excluded_kind()`](Self::excluded_kind).
+    ///
     /// # Panics
     ///
     /// If the cache was configured without exclude patterns.
@@ -21,6 +25,16 @@ impl<'a> Platform<'a> {
             .map_or(false, |m| !m.pattern.is_negative())
     }
 
+    /// See if a non-negative ignore-pattern matches and obtain the kind of exclude, or return `None`
+    /// if the path isn't excluded.
+    ///
+    /// This is similar to [`is_excluded()`](Self::is_excluded), but provides details that are useful to
+    /// decide what to do with the excluded item.
+    pub fn excluded_kind(&self) -> Option<gix_ignore::Kind> {
+        self.matching_exclude_pattern()
+            .and_then(|m| (!m.pattern.is_negative()).then_some(m.kind))
+    }
+
     /// Check all exclude patterns to see if the currently set path matches any of them.
     ///
     /// Note that this pattern might be negated, and means this path in included.

gix-worktree/src/stack/state/ignore.rs

@@ -105,6 +105,7 @@ impl Ignore {
             let match_ = gix_ignore::search::Match {
                 pattern: &mapping.pattern,
                 sequence_number: mapping.sequence_number,
+                kind: mapping.value,
                 source,
             };
             if mapping.pattern.is_negative() {

gix-worktree/tests/worktree/stack/ignore.rs

@@ -76,6 +76,12 @@ fn exclude_by_dir_is_handled_just_like_git() {
             expected_pattern, "tld/",
             "each entry matches on the main directory exclude, ignoring negations entirely"
         );
+        // TODO: adjust baseline to also include precious files.
+        assert_eq!(
+            match_.kind,
+            gix_ignore::Kind::Expendable,
+            "for now all patterns are expendable until precious files are supported by git"
+        );
         assert_eq!(line, 2);
         assert_eq!(source, ".gitignore");
     }
@@ -134,6 +140,14 @@ fn check_against_baseline() -> crate::Result {
             (Some(m), Some((source_file, line, pattern))) => {
                 assert_eq!(m.pattern.to_string(), pattern);
                 assert_eq!(m.sequence_number, line);
+                // TODO: adjust baseline to also include precious files.
+                if !m.pattern.is_negative() {
+                    assert_eq!(
+                        m.kind,
+                        platform.excluded_kind().expect("it matches"),
+                        "both values agree, no matter which method is used"
+                    );
+                }
                 // Paths read from the index are relative to the repo, and they don't exist locally due tot skip-worktree
                 if m.source.map_or(false, std::path::Path::exists) {
                     assert_eq!(