feat: respect the :(optional) prefix when interpolating paths via ConfigSnapshot::trusted_path().

Optional, but non-existing paths are now returned as `None`.

Author: Byron

gix/src/config/cache/access.rs

@@ -544,7 +544,19 @@ pub(crate) fn trusted_file_path<'config>(
     let install_dir = crate::path::install_dir().ok();
     let home = home_dir(environment);
     let ctx = config::cache::interpolate_context(install_dir.as_deref(), home.as_deref());
-    Some(path.interpolate(ctx))
+
+    let is_optional = path.is_optional;
+    let res = path.interpolate(ctx);
+    if is_optional {
+        if let Ok(path) = &res {
+            // As opposed to Git, for a lack of the right error variant, we ignore everything that can't
+            // be stat'ed, instead of just checking if it doesn't exist via error code.
+            if path.metadata().is_err() {
+                return None;
+            }
+        }
+    }
+    Some(res)
 }
 
 pub(crate) fn home_dir(environment: crate::open::permissions::Environment) -> Option<PathBuf> {

gix/src/config/snapshot/access.rs

@@ -54,6 +54,12 @@ impl<'repo> Snapshot<'repo> {
     /// Return the trusted and fully interpolated path at `key`, or `None` if there is no such value
     /// or if no value was found in a trusted file.
     /// An error occurs if the path could not be interpolated to its final value.
+    ///
+    /// ### Optional paths
+    ///
+    /// The path can be prefixed with `:(optional)` which means it won't be returned if the interpolated
+    /// path couldn't be accessed. Note also that this is different from Git, which ignores it only if
+    /// it doesn't exist.
     pub fn trusted_path(
         &self,
         key: impl gix_config::AsKey,

gix/tests/gix/repository/config/config_snapshot/mod.rs

@@ -33,6 +33,33 @@ fn commit_auto_rollback() -> crate::Result {
     Ok(())
 }
 
+mod trusted_path {
+    use crate::util::named_repo;
+
+    #[test]
+    fn optional_is_respected() -> crate::Result {
+        let mut repo: gix::Repository = named_repo("make_basic_repo.sh")?;
+        repo.config_snapshot_mut().set_raw_value(&"my.path", "does-not-exist")?;
+
+        let actual = repo
+            .config_snapshot()
+            .trusted_path("my.path")
+            .transpose()?
+            .expect("is set");
+        assert_eq!(
+            actual.as_ref(),
+            "does-not-exist",
+            "the path isn't evaluated by default, and may not exist"
+        );
+
+        repo.config_snapshot_mut()
+            .set_raw_value(&"my.path", ":(optional)does-not-exist")?;
+        let actual = repo.config_snapshot().trusted_path("my.path").transpose()?;
+        assert_eq!(actual, None, "non-existing paths aren't returned to the caller");
+        Ok(())
+    }
+}
+
 #[test]
 fn snapshot_mut_commit_and_forget() -> crate::Result {
     let mut repo: gix::Repository = named_repo("make_basic_repo.sh")?;

gix/tests/gix/repository/excludes.rs

@@ -27,3 +27,19 @@ fn empty_core_excludes() -> crate::Result {
         .expect("empty paths are now just skipped");
     Ok(())
 }
+
+#[test]
+fn missing_core_excludes_is_ignored() -> crate::Result {
+    let mut repo = named_subrepo_opts(
+        "make_basic_repo.sh",
+        "empty-core-excludes",
+        gix::open::Options::default().strict_config(true),
+    )?;
+    repo.config_snapshot_mut()
+        .set_value(&gix::config::tree::Core::EXCLUDES_FILE, "definitely-missing")?;
+
+    let index = repo.index_or_empty()?;
+    repo.excludes(&index, None, Source::WorktreeThenIdMappingIfNotSkipped)
+        .expect("the call works as missing excludes files are ignored");
+    Ok(())
+}