thanks clippy

Byron · Byron · commit a8c9ddc83a84 · 2025-04-25T17:50:05.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -152,7 +152,7 @@ gitoxide-core-async-client = ["gitoxide-core/async-client", "futures-lite"]
 anyhow = "1.0.42"
 
 gitoxide-core = { version = "^0.46.0", path = "gitoxide-core" }
-gix-date= { version = "^0.9.4", path = "gix-date" }
+gix-date = { version = "^0.9.4", path = "gix-date" }
 gix-features = { version = "^0.42.0", path = "gix-features" }
 gix = { version = "^0.71.0", path = "gix", default-features = false }
 
@@ -378,3 +378,7 @@ no_effect_underscore_binding = "allow"  # x1
 empty_docs = "allow"
 too_long_first_doc_paragraph = "allow"
 large_stack_arrays = "allow"
+
+# Fix one day
+result_large_err = "allow"
+large_enum_variant = "allow"
diff --git a/gitoxide-core/src/corpus/engine.rs b/gitoxide-core/src/corpus/engine.rs
@@ -57,8 +57,9 @@ impl Engine {
         let repos = self.refresh_repos(&corpus_path, corpus_id)?;
         self.state.progress.set_name("refresh repos".into());
         self.state.progress.info(format!(
-            "Added or updated {} repositories under {corpus_path:?}",
-            repos.len()
+            "Added or updated {} repositories under '{corpus_path}'",
+            repos.len(),
+            corpus_path = corpus_path.display(),
         ));
         Ok(())
     }
@@ -316,7 +317,7 @@ impl Engine {
                                 out.push(repo);
                                 progress.inc();
                             }
-                            Err(err) => progress.fail(format!("{repo_path:?}: {err:#?}")),
+                            Err(err) => progress.fail(format!("{repo_path}: {err:#?}", repo_path = repo_path.display())),
                         }
                     }
                     statement.finalize()?;
diff --git a/gitoxide-core/src/hours/core.rs b/gitoxide-core/src/hours/core.rs
@@ -166,13 +166,11 @@ pub fn spawn_tree_delta_threads<'scope>(
                                             (true, true) => {
                                                 files.modified += 1;
                                                 if let Some(cache) = cache.as_mut() {
-                                                    let mut diff = change.diff(cache).map_err(|err| {
-                                                        std::io::Error::new(std::io::ErrorKind::Other, err)
-                                                    })?;
+                                                    let mut diff = change.diff(cache).map_err(std::io::Error::other)?;
                                                     let mut nl = 0;
-                                                    if let Some(counts) = diff.line_counts().map_err(|err| {
-                                                        std::io::Error::new(std::io::ErrorKind::Other, err)
-                                                    })? {
+                                                    if let Some(counts) =
+                                                        diff.line_counts().map_err(std::io::Error::other)?
+                                                    {
                                                         nl += counts.insertions as usize + counts.removals as usize;
                                                         lines.added += counts.insertions as usize;
                                                         lines.removed += counts.removals as usize;
diff --git a/gitoxide-core/src/organize.rs b/gitoxide-core/src/organize.rs
@@ -138,9 +138,9 @@ fn handle(
 
     if let Some(parent_repo_path) = find_parent_repo(git_workdir) {
         progress.fail(format!(
-            "Skipping repository at {:?} as it is nested within repository {:?}",
+            "Skipping repository at '{}' as it is nested within repository '{}'",
             git_workdir.display(),
-            parent_repo_path
+            parent_repo_path.display()
         ));
         return Ok(());
     }
@@ -157,7 +157,7 @@ fn handle(
     };
     if url.path.is_empty() {
         progress.info(format!(
-            "Skipping repository at {:?} whose remote does not have a path: {:?}",
+            "Skipping repository at '{}' whose remote does not have a path: {}",
             git_workdir.display(),
             url.to_bstring()
         ));
diff --git a/gitoxide-core/src/pack/receive.rs b/gitoxide-core/src/pack/receive.rs
@@ -294,7 +294,7 @@ fn receive_pack_blocking(
         None::<gix::objs::find::Never>,
         options,
     )
-    .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+    .map_err(io::Error::other)?;
 
     if let Some(directory) = refs_directory.take() {
         write_raw_refs(refs, directory)?;
diff --git a/gitoxide-core/src/query/db.rs b/gitoxide-core/src/query/db.rs
@@ -19,8 +19,12 @@ pub fn create(path: impl AsRef<std::path::Path>) -> anyhow::Result<rusqlite::Con
         }
         Some(version) if version != VERSION => match con.close() {
             Ok(()) => {
-                std::fs::remove_file(path)
-                    .with_context(|| format!("Failed to remove incompatible database file at {path:?}"))?;
+                std::fs::remove_file(path).with_context(|| {
+                    format!(
+                        "Failed to remove incompatible database file at {path}",
+                        path = path.display()
+                    )
+                })?;
                 con = rusqlite::Connection::open(path)?;
                 con.execute_batch(meta_table)?;
                 con.execute("INSERT into meta(version) values(?)", params![VERSION])?;
diff --git a/gitoxide-core/src/repository/attributes/validate_baseline.rs b/gitoxide-core/src/repository/attributes/validate_baseline.rs
@@ -44,8 +44,8 @@ pub(crate) mod function {
         if repo.is_bare() {
             writeln!(
                 err,
-                "Repo {:?} is bare - disabling git-ignore baseline as `git check-ignore` needs a worktree",
-                repo.path()
+                "Repo at '{repo}' is bare - disabling git-ignore baseline as `git check-ignore` needs a worktree",
+                repo = repo.path().display()
             )
             .ok();
             ignore = false;
diff --git a/gitoxide-core/src/repository/fetch.rs b/gitoxide-core/src/repository/fetch.rs
@@ -169,7 +169,7 @@ pub(crate) mod function {
 
         let start = std::time::Instant::now();
         progress.set_name("layout graph".into());
-        progress.info(format!("writing {path:?}…"));
+        progress.info(format!("writing {}…", path.display()));
         let mut svg = SVGWriter::new();
         vg.do_it(false, false, false, &mut svg);
         std::fs::write(path, svg.finalize().as_bytes())?;
diff --git a/gitoxide-core/src/repository/revision/list.rs b/gitoxide-core/src/repository/revision/list.rs
@@ -117,7 +117,7 @@ pub(crate) mod function {
         if let Some((mut vg, path, _)) = vg {
             let start = std::time::Instant::now();
             progress.set_name("layout graph".into());
-            progress.info(format!("writing {path:?}…"));
+            progress.info(format!("writing {}…", path.display()));
             let mut svg = SVGWriter::new();
             vg.do_it(false, false, false, &mut svg);
             std::fs::write(&path, svg.finalize().as_bytes())?;
diff --git a/gix-config/tests/config/file/init/from_paths/includes/conditional/gitdir/util.rs b/gix-config/tests/config/file/init/from_paths/includes/conditional/gitdir/util.rs
@@ -142,8 +142,8 @@ pub fn assert_section_value(
             Some(Value::Override) => Some(cow_str("override-value")),
             None => None,
         },
-        "gix-config disagrees with the expected value, {:?} for debugging",
-        env.tempdir.into_path()
+        "gix-config disagrees with the expected value, {} for debugging",
+        env.tempdir.into_path().display()
     );
     assure_git_agrees(expected, env)
 }
@@ -171,9 +171,9 @@ fn assure_git_agrees(expected: Option<Value>, env: GitEnv) -> crate::Result {
     assert_eq!(
         output.status.success(),
         expected.is_some(),
-        "{:?}, {:?} for debugging",
+        "{:?}, {} for debugging",
         output,
-        env.tempdir.into_path()
+        env.tempdir.into_path().display()
     );
     let git_output: BString = output.stdout.trim_end().into();
     assert_eq!(
diff --git a/gix-config/tests/config/mod.rs b/gix-config/tests/config/mod.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::unnecessary_debug_formatting)]
 pub use gix_testtools::Result;
 
 mod file;
diff --git a/gix-date/src/lib.rs b/gix-date/src/lib.rs
@@ -17,7 +17,7 @@ pub use parse::function::parse;
 pub use parse::function::parse_header;
 
 /// A timestamp with timezone.
-#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
+#[derive(Default, PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Time {
     /// The seconds that have passed since UNIX epoch. This makes it UTC, or `<seconds>+0000`.
diff --git a/gix-date/src/parse.rs b/gix-date/src/parse.rs
@@ -218,7 +218,7 @@ pub(crate) mod function {
             Ok(s) => s,
             Err(_err) => {
                 // Inefficient, but it's not the common case.
-                let first_digits: String = seconds.chars().take_while(|b| b.is_ascii_digit()).collect();
+                let first_digits: String = seconds.chars().take_while(char::is_ascii_digit).collect();
                 first_digits.parse().ok()?
             }
         };
diff --git a/gix-date/src/time/mod.rs b/gix-date/src/time/mod.rs
@@ -40,13 +40,3 @@ impl From<CustomFormat> for Format {
 pub mod format;
 mod init;
 mod write;
-
-mod impls {
-    use crate::Time;
-
-    impl Default for Time {
-        fn default() -> Self {
-            Time { seconds: 0, offset: 0 }
-        }
-    }
-}
diff --git a/gix-features/src/zlib/stream/deflate/tests.rs b/gix-features/src/zlib/stream/deflate/tests.rs
@@ -45,6 +45,7 @@ mod deflate_stream {
         let r = InflateReader::from_read(io::BufReader::new(std::fs::File::open(fixture_path(
             "objects/37/d4e6c5c48ba0d245164c4e10d5f41140cab980",
         ))?));
+        #[allow(clippy::unbuffered_bytes)]
         let mut bytes = r.bytes();
         let content = bytes.by_ref().take(16).collect::<Result<Vec<_>, _>>()?;
         assert_eq!(content.as_slice().as_bstr(), b"blob 9\0hi there\n".as_bstr());
diff --git a/gix-fs/src/dir/create.rs b/gix-fs/src/dir/create.rs
@@ -63,7 +63,8 @@ mod error {
                     retries,
                 } => write!(
                     f,
-                    "Permanently failing to create directory {dir:?} ({retries_left:?} of {retries:?})",
+                    "Permanently failing to create directory '{dir}' ({retries_left:?} of {retries:?})",
+                    dir = dir.display(),
                 ),
             }
         }
diff --git a/gix-fs/src/dir/remove.rs b/gix-fs/src/dir/remove.rs
@@ -20,7 +20,11 @@ impl<'a> Iter<'a> {
         if !target.starts_with(boundary) {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::InvalidInput,
-                format!("Removal target {target:?} must be contained in boundary {boundary:?}"),
+                format!(
+                    "Removal target '{target}' must be contained in boundary '{boundary}'",
+                    target = target.display(),
+                    boundary = boundary.display()
+                ),
             ));
         }
         let cursor = if target == boundary {
@@ -93,7 +97,7 @@ pub fn empty_depth_first(delete_dir: PathBuf) -> std::io::Result<()> {
             if entry.file_type()?.is_dir() {
                 next_to_push.push(entry.path());
             } else {
-                return Err(std::io::Error::new(std::io::ErrorKind::Other, "Directory not empty"));
+                return Err(std::io::Error::other("Directory not empty"));
             }
         }
         if num_entries == 0 {
diff --git a/gix-fs/src/stack.rs b/gix-fs/src/stack.rs
@@ -156,10 +156,7 @@ impl Stack {
     ) -> std::io::Result<()> {
         let mut components = relative.to_normal_path_components().peekable();
         if self.valid_components != 0 && components.peek().is_none() {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                "empty inputs are not allowed",
-            ));
+            return Err(std::io::Error::other("empty inputs are not allowed"));
         }
         if self.valid_components == 0 {
             delegate.push_directory(self)?;
diff --git a/gix-index/src/extension/end_of_index_entry/decode.rs b/gix-index/src/extension/end_of_index_entry/decode.rs
@@ -48,7 +48,7 @@ pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Result<Option<usize>,
         return Ok(None);
     }
     // The last-to-this chunk ends where ours starts
-    if last_chunk.map_or(true, |s| s.as_ptr_range().end != (&data[start_of_eoie]) as *const _) {
+    if last_chunk.map_or(true, |s| !std::ptr::eq(s.as_ptr_range().end, &data[start_of_eoie])) {
         return Ok(None);
     }
 
diff --git a/gix-odb/src/store_impls/dynamic/load_index.rs b/gix-odb/src/store_impls/dynamic/load_index.rs
@@ -165,7 +165,7 @@ impl super::Store {
             }
             if previous_state_id == index.state_id() {
                 let potentially_new_index = self.index.load();
-                if Arc::as_ptr(&potentially_new_index) == Arc::as_ptr(&index) {
+                if std::ptr::eq(Arc::as_ptr(&potentially_new_index), Arc::as_ptr(&index)) {
                     // There isn't a new index with which to retry the whole ordeal, so nothing could be done here.
                     return false;
                 } else {
@@ -392,9 +392,11 @@ impl super::Store {
                 next_index_to_load: index_unchanged
                     .then(|| Arc::clone(&index.next_index_to_load))
                     .unwrap_or_default(),
-                loaded_indices: index_unchanged
-                    .then(|| Arc::clone(&index.loaded_indices))
-                    .unwrap_or_else(|| Arc::new(num_loaded_indices.into())),
+                loaded_indices: if index_unchanged {
+                    Arc::clone(&index.loaded_indices)
+                } else {
+                    Arc::new(num_loaded_indices.into())
+                },
                 num_indices_currently_being_loaded: Default::default(),
             });
             self.index.store(new_index);
diff --git a/gix-prompt/src/lib.rs b/gix-prompt/src/lib.rs
@@ -43,7 +43,10 @@ pub fn ask(prompt: &str, opts: &Options<'_>) -> Result<String, Error> {
                     return Ok(stdout);
                 }
             }
-            Err(err) => eprintln!("Cannot run askpass program: {askpass:?} with error: {err}"),
+            Err(err) => eprintln!(
+                "Cannot run askpass program: '{askpass}' with error: {err}",
+                askpass = askpass.display()
+            ),
         }
     }
     imp::ask(prompt, opts)
diff --git a/gix-status/src/index_as_worktree/function.rs b/gix-status/src/index_as_worktree/function.rs
@@ -575,7 +575,7 @@ where
                     },
                     &mut |buf| Ok(self.objects.find_blob(self.id, buf).map(|_| Some(()))?),
                 )
-                .map_err(|err| Error::Io(io::Error::new(io::ErrorKind::Other, err).into()))?;
+                .map_err(|err| Error::Io(io::Error::other(err).into()))?;
             let len = match out {
                 ToGitOutcome::Unchanged(_) => Some(self.file_len),
                 ToGitOutcome::Process(_) | ToGitOutcome::Buffer(_) => None,
diff --git a/gix-status/src/stack.rs b/gix-status/src/stack.rs
@@ -66,10 +66,7 @@ impl gix_fs::stack::Delegate for Delegate {
             }
 
             if stack.current().symlink_metadata()?.is_symlink() {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    "Cannot step through symlink to perform an lstat",
-                ));
+                return Err(std::io::Error::other("Cannot step through symlink to perform an lstat"));
             }
             Ok(())
         }
diff --git a/gix-submodule/src/access.rs b/gix-submodule/src/access.rs
@@ -181,7 +181,7 @@ impl File {
                 .sections_by_name("submodule")
                 .into_iter()
                 .flatten()
-                .any(|s| (s.header().subsection_name() == Some(name) && s.meta() as *const _ != ours as *const _));
+                .any(|s| (s.header().subsection_name() == Some(name) && !std::ptr::eq(s.meta(), ours)));
             if !has_value_from_foreign_section {
                 return Err(config::update::Error::CommandForbiddenInModulesConfiguration {
                     submodule: name.to_owned(),
diff --git a/gix-worktree-state/tests/state/checkout.rs b/gix-worktree-state/tests/state/checkout.rs
@@ -30,7 +30,7 @@ static DRIVER: Lazy<PathBuf> = Lazy::new(|| {
         .join("debug")
         .join("examples")
         .join(if cfg!(windows) { "arrow.exe" } else { "arrow" });
-    assert!(path.is_file(), "Expecting driver to be located at {path:?}");
+    assert!(path.is_file(), "Expecting driver to be located at {}", path.display());
     path
 });
 
diff --git a/gix-worktree-stream/tests/stream.rs b/gix-worktree-stream/tests/stream.rs
@@ -295,7 +295,7 @@ mod from_tree {
             .join("debug")
             .join("examples")
             .join(if cfg!(windows) { "arrow.exe" } else { "arrow" });
-        assert!(path.is_file(), "Expecting driver to be located at {path:?}");
+        assert!(path.is_file(), "Expecting driver to be located at {}", path.display());
         path
     });
 
diff --git a/gix-worktree/src/stack/delegate.rs b/gix-worktree/src/stack/delegate.rs
@@ -135,15 +135,12 @@ fn validate_last_component(
     let Some(last_component) = stack.current_relative().components().next_back() else {
         return Ok(());
     };
-    let last_component =
-        gix_path::try_into_bstr(std::borrow::Cow::Borrowed(last_component.as_os_str().as_ref())).map_err(|_err| {
-            std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!(
-                    "Path component {last_component:?} of path \"{}\" contained invalid UTF-8 and could not be validated",
-                    stack.current_relative().display()
-                ),
-            )
+    let last_component = gix_path::try_into_bstr(std::borrow::Cow::Borrowed(last_component.as_os_str().as_ref()))
+        .map_err(|_err| {
+            std::io::Error::other(format!(
+                "Path component {last_component:?} of path \"{}\" contained invalid UTF-8 and could not be validated",
+                stack.current_relative().display()
+            ))
         })?;
 
     if let Err(err) = gix_validate::path::component(
@@ -153,7 +150,7 @@ fn validate_last_component(
         }),
         opts,
     ) {
-        return Err(std::io::Error::new(std::io::ErrorKind::Other, err));
+        return Err(std::io::Error::other(err));
     }
     Ok(())
 }
diff --git a/gix-worktree/src/stack/state/attributes.rs b/gix-worktree/src/stack/state/attributes.rs
@@ -110,7 +110,7 @@ impl Attributes {
                 if let Ok(idx) = attr_file_in_index {
                     let blob = objects
                         .find_blob(&id_mappings[idx].1, buf)
-                        .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+                        .map_err(std::io::Error::other)?;
                     let attr_path = gix_path::from_bstring(attr_path_relative.into_owned());
                     self.stack.add_patterns_buffer(
                         blob.data,
@@ -149,7 +149,7 @@ impl Attributes {
                 if let Some(idx) = attr_file_in_index.ok().filter(|_| !added) {
                     let blob = objects
                         .find_blob(&id_mappings[idx].1, buf)
-                        .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+                        .map_err(std::io::Error::other)?;
                     let attr_path = gix_path::from_bstring(attr_path_relative.into_owned());
                     self.stack.add_patterns_buffer(
                         blob.data,
diff --git a/gix-worktree/src/stack/state/ignore.rs b/gix-worktree/src/stack/state/ignore.rs
diff --git a/gix/examples/clone.rs b/gix/examples/clone.rs
diff --git a/gix/examples/init-repo-and-commit.rs b/gix/examples/init-repo-and-commit.rs
diff --git a/gix/src/path.rs b/gix/src/path.rs
diff --git a/gix/src/repository/index.rs b/gix/src/repository/index.rs
diff --git a/gix/src/repository/worktree.rs b/gix/src/repository/worktree.rs
diff --git a/gix/tests/gix/main.rs b/gix/tests/gix/main.rs
diff --git a/gix/tests/gix/repository/config/config_snapshot/credential_helpers.rs b/gix/tests/gix/repository/config/config_snapshot/credential_helpers.rs
diff --git a/tests/tools/src/lib.rs b/tests/tools/src/lib.rs
diff --git a/tests/tools/src/main.rs b/tests/tools/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -57,8 +57,9 @@ impl Engine {`
`57`	`57`	`let repos = self.refresh_repos(&corpus_path, corpus_id)?;`
`58`	`58`	`self.state.progress.set_name("refresh repos".into());`
`59`	`59`	`self.state.progress.info(format!(`
`60`		`- "Added or updated {} repositories under {corpus_path:?}",`
`61`		`- repos.len()`
	`60`	`+ "Added or updated {} repositories under '{corpus_path}'",`
	`61`	`+ repos.len(),`
	`62`	`+ corpus_path = corpus_path.display(),`
`62`	`63`	`));`
`63`	`64`	`Ok(())`
`64`	`65`	`}`
`@@ -316,7 +317,7 @@ impl Engine {`
`316`	`317`	`out.push(repo);`
`317`	`318`	`progress.inc();`
`318`	`319`	`}`
`319`		`- Err(err) => progress.fail(format!("{repo_path:?}: {err:#?}")),`
	`320`	`+ Err(err) => progress.fail(format!("{repo_path}: {err:#?}", repo_path = repo_path.display())),`
`320`	`321`	`}`
`321`	`322`	`}`
`322`	`323`	`statement.finalize()?;`
Original file line number	Diff line number	Diff line change
`@@ -294,7 +294,7 @@ fn receive_pack_blocking(`
`294`	`294`	`None::<gix::objs::find::Never>,`
`295`	`295`	`options,`
`296`	`296`	`)`
`297`		`- .map_err(\|err\| io::Error::new(io::ErrorKind::Other, err))?;`
	`297`	`+ .map_err(io::Error::other)?;`
`298`	`298`
`299`	`299`	`if let Some(directory) = refs_directory.take() {`
`300`	`300`	`write_raw_refs(refs, directory)?;`