fix: opening repositories without 'strict' mode also ignores IO errors. (#790)

Byron · Byron · commit 7bd8823ab424 · 2023-03-26T10:55:18.000+02:00
These will instead be logged, but won't make it impossible to open an
otherwise fine repository.
diff --git a/gix/src/config/cache/incubate.rs b/gix/src/config/cache/incubate.rs
@@ -30,6 +30,7 @@ impl StageOne {
             gix_config::Source::Local,
             git_dir_trust,
             lossy,
+            lenient,
         )?;
 
         // Note that we assume the repo is bare by default unless we are told otherwise. This is relevant if
@@ -64,6 +65,7 @@ impl StageOne {
                 gix_config::Source::Worktree,
                 git_dir_trust,
                 lossy,
+                lenient,
             )?;
             config.append(worktree_config);
         };
@@ -86,24 +88,47 @@ fn load_config(
     source: gix_config::Source,
     git_dir_trust: gix_sec::Trust,
     lossy: Option<bool>,
+    lenient: bool,
 ) -> Result<gix_config::File<'static>, Error> {
-    buf.clear();
     let metadata = gix_config::file::Metadata::from(source)
         .at(&config_path)
         .with(git_dir_trust);
     let mut file = match std::fs::File::open(&config_path) {
         Ok(f) => f,
         Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(gix_config::File::new(metadata)),
-        Err(err) => return Err(err.into()),
+        Err(err) => {
+            let err = Error::Io {
+                source: err,
+                path: config_path,
+            };
+            if lenient {
+                log::warn!("ignoring: {err:#?}");
+                return Ok(gix_config::File::new(metadata));
+            } else {
+                return Err(err);
+            }
+        }
+    };
+
+    buf.clear();
+    if let Err(err) = std::io::copy(&mut file, buf) {
+        let err = Error::Io {
+            source: err,
+            path: config_path,
+        };
+        if lenient {
+            log::warn!("ignoring: {err:#?}");
+        } else {
+            return Err(err);
+        }
     };
-    std::io::copy(&mut file, buf)?;
 
     let config = gix_config::File::from_bytes_owned(
         buf,
         metadata,
         gix_config::file::init::Options {
             includes: gix_config::file::includes::Options::no_follow(),
-            ..util::base_options(lossy)
+            ..util::base_options(lossy, lenient)
         },
     )?;
 
diff --git a/gix/src/config/cache/init.rs b/gix/src/config/cache/init.rs
@@ -65,7 +65,7 @@ impl Cache {
             } else {
                 gix_config::file::includes::Options::no_follow()
             },
-            ..util::base_options(lossy)
+            ..util::base_options(lossy, lenient_config)
         };
 
         let config = {
@@ -118,7 +118,7 @@ impl Cache {
             )
             .map_err(|err| match err {
                 gix_config::file::init::from_paths::Error::Init(err) => Error::from(err),
-                gix_config::file::init::from_paths::Error::Io(err) => err.into(),
+                gix_config::file::init::from_paths::Error::Io { source, path } => Error::Io { source, path },
             })?
             .unwrap_or_default();
 
diff --git a/gix/src/config/cache/util.rs b/gix/src/config/cache/util.rs
@@ -17,9 +17,10 @@ pub(crate) fn interpolate_context<'a>(
     }
 }
 
-pub(crate) fn base_options(lossy: Option<bool>) -> gix_config::file::init::Options<'static> {
+pub(crate) fn base_options(lossy: Option<bool>, lenient: bool) -> gix_config::file::init::Options<'static> {
     gix_config::file::init::Options {
         lossy: lossy.unwrap_or(!cfg!(debug_assertions)),
+        ignore_io_errors: lenient,
         ..Default::default()
     }
 }
diff --git a/gix/src/config/mod.rs b/gix/src/config/mod.rs
@@ -62,8 +62,11 @@ pub enum Error {
     UnsupportedObjectFormat { name: BString },
     #[error(transparent)]
     CoreAbbrev(#[from] abbrev::Error),
-    #[error("Could not read configuration file")]
-    Io(#[from] std::io::Error),
+    #[error("Could not read configuration file at \"{}\"", path.display())]
+    Io {
+        source: std::io::Error,
+        path: std::path::PathBuf,
+    },
     #[error(transparent)]
     Init(#[from] gix_config::file::init::Error),
     #[error(transparent)]
diff --git a/gix/src/open/options.rs b/gix/src/open/options.rs
@@ -134,6 +134,9 @@ impl Options {
     ///
     /// This is recommended for all applications that prefer correctness over usability.
     /// `git` itself defaults to strict configuration mode, flagging incorrect configuration immediately.
+    ///
+    /// Failure to read configuration files due to IO errors will also be a hard error if this mode is enabled, otherwise
+    /// these errors will merely be logged.
     pub fn strict_config(mut self, toggle: bool) -> Self {
         self.lenient_config = !toggle;
         self
diff --git a/src/plumbing/options/mod.rs b/src/plumbing/options/mod.rs
@@ -38,7 +38,7 @@ pub struct Args {
     #[clap(long, conflicts_with("verbose"))]
     pub progress: bool,
 
-    /// Don't default malformed configuration flags, but show an error instead.
+    /// Don't default malformed configuration flags, but show an error instead. Ignore IO errors as well.
     ///
     /// Note that some subcommands use strict mode by default.
     // TODO: needs a 'lenient' mutually exclusive counterpart. Opens the gate to auto-verbose some commands, and add --no-verbose

Original file line number	Diff line number	Diff line change
`@@ -17,9 +17,10 @@ pub(crate) fn interpolate_context<'a>(`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`
`20`		`-pub(crate) fn base_options(lossy: Option<bool>) -> gix_config::file::init::Options<'static> {`
	`20`	`+pub(crate) fn base_options(lossy: Option<bool>, lenient: bool) -> gix_config::file::init::Options<'static> {`
`21`	`21`	`gix_config::file::init::Options {`
`22`	`22`	`lossy: lossy.unwrap_or(!cfg!(debug_assertions)),`
	`23`	`+ ignore_io_errors: lenient,`
`23`	`24`	`..Default::default()`
`24`	`25`	`}`
`25`	`26`	`}`