thanks clippy

Author: Byron

Cargo.toml

@@ -377,3 +377,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"

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()?;

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;

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()
         ));

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)?;

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])?;

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;

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())?;

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())?;

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!(

gix-config/tests/config/mod.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::unnecessary_debug_formatting)]
 pub use gix_testtools::Result;
 
 mod file;

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`.

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()?
             }
         };

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 }
-        }
-    }
-}

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());

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(),
                 ),
             }
         }

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 {

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)?;

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);
     }
 

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);

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)

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,

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(())
         }

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(),

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
 });
 

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
     });
 

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(())
 }

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,

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

@@ -180,7 +180,7 @@ impl Ignore {
                     Ok(idx) => {
                         let ignore_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 ignore_path = gix_path::from_bstring(ignore_path_relative.into_owned());
                         self.stack
                             .add_patterns_buffer(ignore_blob.data, ignore_path, Some(Path::new("")));
@@ -208,7 +208,7 @@ impl Ignore {
                         Ok(idx) => {
                             let ignore_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 ignore_path = gix_path::from_bstring(ignore_path_relative.into_owned());
                             self.stack
                                 .add_patterns_buffer(ignore_blob.data, ignore_path, Some(Path::new("")));