Add support for :(optional) prefix for path values in gix-config-value

Co-authored-by: Byron <[email protected]>

Author: Copilot

gix-config-value/src/path.rs

@@ -108,11 +108,35 @@ impl AsRef<BStr> for Path<'_> {
 
 impl<'a> From<Cow<'a, BStr>> for Path<'a> {
     fn from(value: Cow<'a, BStr>) -> Self {
-        Path { value }
+        const OPTIONAL_PREFIX: &[u8] = b":(optional)";
+        
+        // Check if the value starts with ":(optional)" prefix
+        if value.starts_with(OPTIONAL_PREFIX) {
+            // Strip the prefix and create a path marked as optional
+            let stripped = &value[OPTIONAL_PREFIX.len()..];
+            Path {
+                value: Cow::Owned(stripped.into()),
+                is_optional: true,
+            }
+        } else {
+            Path {
+                value,
+                is_optional: false,
+            }
+        }
     }
 }
 
 impl<'a> Path<'a> {
+    /// Returns `true` if this path was prefixed with `:(optional)`.
+    ///
+    /// Optional paths indicate that it's acceptable if the file doesn't exist.
+    /// This is typically used for configuration like `blame.ignorerevsfile` where
+    /// the file might not exist in all repositories.
+    pub fn is_optional(&self) -> bool {
+        self.is_optional
+    }
+
     /// Interpolates this path into a path usable on the file system.
     ///
     /// If this path starts with `~/` or `~user/` or `%(prefix)/`

gix-config-value/src/types.rs

@@ -45,4 +45,6 @@ pub struct Boolean(pub bool);
 pub struct Path<'a> {
     /// The path string, un-interpolated
     pub value: std::borrow::Cow<'a, bstr::BStr>,
+    /// Whether this path was prefixed with `:(optional)`, indicating it's acceptable if the file doesn't exist.
+    pub is_optional: bool,
 }

gix-config-value/tests/value/main.rs

@@ -15,3 +15,23 @@ mod boolean;
 mod color;
 mod integer;
 mod path;
+
+/// Ensure that the `:(optional)` prefix is only recognized for Path types, not for other types
+mod optional_prefix_only_for_paths {
+    use std::borrow::Cow;
+    use gix_config_value::{Boolean, Integer};
+
+    #[test]
+    fn optional_prefix_not_recognized_in_boolean() {
+        // Boolean should fail to parse this because it's not a valid boolean value
+        let result = Boolean::try_from(Cow::Borrowed(crate::b(":(optional)true")));
+        assert!(result.is_err(), "Boolean should not recognize :(optional) prefix");
+    }
+
+    #[test]
+    fn optional_prefix_not_recognized_in_integer() {
+        // Integer should fail to parse this because it's not a valid integer value
+        let result = Integer::try_from(Cow::Borrowed(crate::b(":(optional)42")));
+        assert!(result.is_err(), "Integer should not recognize :(optional) prefix");
+    }
+}

gix-config-value/tests/value/path.rs

@@ -127,3 +127,92 @@ mod interpolate {
         std::env::current_dir().unwrap().join(name).into()
     }
 }
+
+mod optional_prefix {
+    use std::borrow::Cow;
+
+    use crate::{b, cow_str};
+
+    #[test]
+    fn path_without_optional_prefix_is_not_optional() {
+        let path = gix_config_value::Path::from(Cow::Borrowed(b("/some/path")));
+        assert!(!path.is_optional(), "path without prefix should not be optional");
+        assert_eq!(path.value.as_ref(), b"/some/path");
+    }
+
+    #[test]
+    fn path_with_optional_prefix_is_optional() {
+        let path = gix_config_value::Path::from(cow_str(":(optional)/some/path"));
+        assert!(path.is_optional(), "path with :(optional) prefix should be optional");
+        assert_eq!(path.value.as_ref(), b"/some/path", "prefix should be stripped");
+    }
+
+    #[test]
+    fn optional_prefix_with_relative_path() {
+        let path = gix_config_value::Path::from(cow_str(":(optional)relative/path"));
+        assert!(path.is_optional());
+        assert_eq!(path.value.as_ref(), b"relative/path");
+    }
+
+    #[test]
+    fn optional_prefix_with_tilde_expansion() {
+        let path = gix_config_value::Path::from(cow_str(":(optional)~/config/file"));
+        assert!(path.is_optional());
+        assert_eq!(path.value.as_ref(), b"~/config/file", "tilde should be preserved for interpolation");
+    }
+
+    #[test]
+    fn optional_prefix_with_prefix_substitution() {
+        let path = gix_config_value::Path::from(cow_str(":(optional)%(prefix)/share/git"));
+        assert!(path.is_optional());
+        assert_eq!(path.value.as_ref(), b"%(prefix)/share/git", "prefix should be preserved for interpolation");
+    }
+
+    #[test]
+    fn optional_prefix_with_windows_path() {
+        let path = gix_config_value::Path::from(cow_str(r":(optional)C:\Users\file"));
+        assert!(path.is_optional());
+        assert_eq!(path.value.as_ref(), br"C:\Users\file");
+    }
+
+    #[test]
+    fn optional_prefix_followed_by_empty_path() {
+        let path = gix_config_value::Path::from(cow_str(":(optional)"));
+        assert!(path.is_optional());
+        assert_eq!(path.value.as_ref(), b"", "empty path after prefix is valid");
+    }
+
+    #[test]
+    fn partial_optional_string_is_not_treated_as_prefix() {
+        let path = gix_config_value::Path::from(cow_str(":(opt)ional/path"));
+        assert!(!path.is_optional(), "incomplete prefix should not be treated as optional marker");
+        assert_eq!(path.value.as_ref(), b":(opt)ional/path");
+    }
+
+    #[test]
+    fn optional_prefix_case_sensitive() {
+        let path = gix_config_value::Path::from(cow_str(":(OPTIONAL)/some/path"));
+        assert!(!path.is_optional(), "prefix should be case-sensitive");
+        assert_eq!(path.value.as_ref(), b":(OPTIONAL)/some/path");
+    }
+
+    #[test]
+    fn optional_prefix_with_spaces() {
+        let path = gix_config_value::Path::from(cow_str(":(optional) /path/with/space"));
+        assert!(path.is_optional());
+        assert_eq!(path.value.as_ref(), b" /path/with/space", "space after prefix should be preserved");
+    }
+
+    #[test]
+    fn interpolate_preserves_optional_flag() -> crate::Result {
+        use gix_config_value::path;
+        
+        let path = gix_config_value::Path::from(cow_str(":(optional)/absolute/path"));
+        assert!(path.is_optional());
+        
+        let interpolated = path.interpolate(path::interpolate::Context::default())?;
+        assert_eq!(interpolated.as_ref(), std::path::Path::new("/absolute/path"));
+        
+        Ok(())
+    }
+}