thanks clippy

Author: Byron

Diff for: gitoxide-core/src/repository/attributes/validate_baseline.rs

@@ -305,13 +305,13 @@ pub(crate) mod function {
     }
 
     fn parse_exclude(line: &str) -> Option<(String, Baseline)> {
-        let (left, value) = line.split_at(line.find(|c| c == '\t')?);
+        let (left, value) = line.split_at(line.find('\t')?);
         let value = &value[1..];
 
         let location = if left == "::" {
             None
         } else {
-            let mut tokens = left.split(|b| b == ':');
+            let mut tokens = left.split(':');
             let source = tokens.next()?;
             let line_number: usize = tokens.next()?.parse().ok()?;
             let pattern = tokens.next()?;
@@ -363,8 +363,8 @@ pub(crate) mod function {
                 "unspecified" => StateRef::Unspecified,
                 _ => StateRef::from_bytes(info.as_bytes()),
             };
-            path = path.trim_end_matches(|b| b == ':');
-            let attr = attr.trim_end_matches(|b| b == ':');
+            path = path.trim_end_matches(':');
+            let attr = attr.trim_end_matches(':');
             let assignment = gix::attrs::AssignmentRef {
                 name: gix::attrs::NameRef::try_from(attr.as_bytes().as_bstr()).ok()?,
                 state,

Diff for: gitoxide-core/src/repository/index/entries.rs

@@ -319,7 +319,7 @@ pub(crate) mod function {
 
     #[cfg(feature = "serde")]
     fn to_json(
-        mut out: &mut impl std::io::Write,
+        out: &mut impl std::io::Write,
         index: &gix::index::File,
         entry: &gix::index::Entry,
         attrs: Option<Attrs>,
@@ -338,7 +338,7 @@ pub(crate) mod function {
         }
 
         serde_json::to_writer(
-            &mut out,
+            &mut *out,
             &Entry {
                 stat: &entry.stat,
                 hex_id: entry.id.to_hex().to_string(),

Diff for: gix-config/src/file/section/mod.rs

@@ -75,7 +75,7 @@ impl<'a> Section<'a> {
     /// Stream ourselves to the given `out`, in order to reproduce this section mostly losslessly
     /// as it was parsed.
     pub fn write_to(&self, mut out: &mut dyn std::io::Write) -> std::io::Result<()> {
-        self.header.write_to(&mut out)?;
+        self.header.write_to(&mut *out)?;
 
         if self.body.0.is_empty() {
             return Ok(());

Diff for: gix-config/src/file/write.rs

@@ -18,7 +18,7 @@ impl File<'_> {
     pub fn write_to_filter(
         &self,
         mut out: &mut dyn std::io::Write,
-        mut filter: &mut dyn FnMut(&Section<'_>) -> bool,
+        filter: &mut dyn FnMut(&Section<'_>) -> bool,
     ) -> std::io::Result<()> {
         let nl = self.detect_newline_style();
 
@@ -27,7 +27,8 @@ impl File<'_> {
                 event.write_to(&mut out)?;
             }
 
-            if !ends_with_newline(self.frontmatter_events.as_ref(), nl, true) && self.sections.values().any(&mut filter)
+            if !ends_with_newline(self.frontmatter_events.as_ref(), nl, true)
+                && self.sections.values().any(&mut *filter)
             {
                 out.write_all(nl)?;
             }

Diff for: gix-config/src/parse/event.rs

@@ -33,7 +33,7 @@ impl Event<'_> {
 
     /// Stream ourselves to the given `out`, in order to reproduce this event mostly losslessly
     /// as it was parsed.
-    pub fn write_to(&self, mut out: &mut dyn std::io::Write) -> std::io::Result<()> {
+    pub fn write_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {
         match self {
             Self::ValueNotDone(e) => {
                 out.write_all(e.as_ref())?;
@@ -42,8 +42,8 @@ impl Event<'_> {
             Self::Whitespace(e) | Self::Newline(e) | Self::Value(e) | Self::ValueDone(e) => out.write_all(e.as_ref()),
             Self::KeyValueSeparator => out.write_all(b"="),
             Self::SectionKey(k) => out.write_all(k.0.as_ref()),
-            Self::SectionHeader(h) => h.write_to(&mut out),
-            Self::Comment(c) => c.write_to(&mut out),
+            Self::SectionHeader(h) => h.write_to(out),
+            Self::Comment(c) => c.write_to(out),
         }
     }
 

Diff for: gix-config/src/parse/events.rs

@@ -28,26 +28,26 @@ pub type FrontMatterEvents<'a> = SmallVec<[Event<'a>; 8]>;
 ///
 /// For concrete examples, some notable differences are:
 /// - `git-config` sections permit subsections via either a quoted string
-/// (`[some-section "subsection"]`) or via the deprecated dot notation
-/// (`[some-section.subsection]`). Successful parsing these section names is not
-/// well defined in typical `.ini` parsers. This parser will handle these cases
-/// perfectly.
+///   (`[some-section "subsection"]`) or via the deprecated dot notation
+///   (`[some-section.subsection]`). Successful parsing these section names is not
+///   well defined in typical `.ini` parsers. This parser will handle these cases
+///   perfectly.
 /// - Comment markers are not strictly defined either. This parser will always
-/// and only handle a semicolon or octothorpe (also known as a hash or number
-/// sign).
+///   and only handle a semicolon or octothorpe (also known as a hash or number
+///   sign).
 /// - Global properties may be allowed in `.ini` parsers, but is strictly
-/// disallowed by this parser.
+///   disallowed by this parser.
 /// - Only `\t`, `\n`, `\b` `\\` are valid escape characters.
 /// - Quoted and semi-quoted values will be parsed (but quotes will be included
-/// in event outputs). An example of a semi-quoted value is `5"hello world"`,
-/// which should be interpreted as `5hello world` after
-/// [normalization][crate::value::normalize()].
+///   in event outputs). An example of a semi-quoted value is `5"hello world"`,
+///   which should be interpreted as `5hello world` after
+///   [normalization][crate::value::normalize()].
 /// - Line continuations via a `\` character is supported (inside or outside of quotes)
 /// - Whitespace handling similarly follows the `git-config` specification as
-/// closely as possible, where excess whitespace after a non-quoted value are
-/// trimmed, and line continuations onto a new line with excess spaces are kept.
+///   closely as possible, where excess whitespace after a non-quoted value are
+///   trimmed, and line continuations onto a new line with excess spaces are kept.
 /// - Only equal signs (optionally padded by spaces) are valid name/value
-/// delimiters.
+///   delimiters.
 ///
 /// Note that things such as case-sensitivity or duplicate sections are
 /// _not_ handled. This parser is a low level _syntactic_ interpreter
@@ -62,8 +62,8 @@ pub type FrontMatterEvents<'a> = SmallVec<[Event<'a>; 8]>;
 /// # Trait Implementations
 ///
 /// - This struct does _not_ implement [`FromStr`] due to lifetime
-/// constraints implied on the required `from_str` method. Instead, it provides
-/// [`From<&'_ str>`].
+///   constraints implied on the required `from_str` method. Instead, it provides
+///   [`From<&'_ str>`].
 ///
 /// # Idioms
 ///

Diff for: gix-ignore/src/search.rs

@@ -55,7 +55,7 @@ impl Search {
                 .transpose()?,
         );
         group.patterns.extend(pattern::List::<Ignore>::from_file(
-            &git_dir.join("info").join("exclude"),
+            git_dir.join("info").join("exclude"),
             None,
             follow_symlinks,
             buf,

Diff for: gix-pack/src/bundle/write/mod.rs

@@ -51,8 +51,8 @@ impl crate::Bundle {
     /// * `progress` provides detailed progress information which can be discarded with [`gix_features::progress::Discard`].
     /// * `should_interrupt` is checked regularly and when true, the whole operation will stop.
     /// * `thin_pack_base_object_lookup` If set, we expect to see a thin-pack with objects that reference their base object by object id which is
-    /// expected to exist in the object database the bundle is contained within.
-    /// `options` further configure how the task is performed.
+    ///    expected to exist in the object database the bundle is contained within.
+    ///    `options` further configure how the task is performed.
     ///
     /// # Note
     ///

Diff for: gix-pack/src/cache/delta/from_offsets.rs

@@ -31,13 +31,13 @@ const PACK_HEADER_LEN: usize = 12;
 impl<T> Tree<T> {
     /// Create a new `Tree` from any data sorted by offset, ascending as returned by the `data_sorted_by_offsets` iterator.
     /// * `get_pack_offset(item: &T) -> data::Offset` is a function returning the pack offset of the given item, which can be used
-    /// for obtaining the objects entry within the pack.
+    ///   for obtaining the objects entry within the pack.
     /// * `pack_path` is the path to the pack file itself and from which to read the entry data, which is a pack file matching the offsets
-    /// returned by `get_pack_offset(…)`.
+    ///   returned by `get_pack_offset(…)`.
     /// * `progress` is used to track progress when creating the tree.
     /// * `resolve_in_pack_id(gix_hash::oid) -> Option<data::Offset>` takes an object ID and tries to resolve it to an object within this pack if
-    /// possible. Failing to do so aborts the operation, and this function is not expected to be called in usual packs. It's a theoretical
-    /// possibility though as old packs might have referred to their objects using the 20 bytes hash, instead of their encoded offset from the base.
+    ///   possible. Failing to do so aborts the operation, and this function is not expected to be called in usual packs. It's a theoretical
+    ///   possibility though as old packs might have referred to their objects using the 20 bytes hash, instead of their encoded offset from the base.
     ///
     /// Note that the sort order is ascending. The given pack file path must match the provided offsets.
     pub fn from_offsets_in_pack(

Diff for: gix-pack/src/data/output/entry/iter_from_counts.rs

@@ -40,7 +40,7 @@ pub(crate) mod function {
     ///
     /// * ~~currently there is no way to easily write the pack index, even though the state here is uniquely positioned to do
     ///   so with minimal overhead (especially compared to `gix index-from-pack`)~~ Probably works now by chaining Iterators
-    ///  or keeping enough state to write a pack and then generate an index with recorded data.
+    ///   or keeping enough state to write a pack and then generate an index with recorded data.
     ///
     pub fn iter_from_counts<Find>(
         mut counts: Vec<output::Count>,

Diff for: gix-pack/src/index/write/mod.rs

@@ -78,9 +78,9 @@ impl crate::index::File {
     ///
     /// * neither in-pack nor out-of-pack Ref Deltas are supported here, these must have been resolved beforehand.
     /// * `make_resolver()` will only be called after the iterator stopped returning elements and produces a function that
-    /// provides all bytes belonging to a pack entry writing them to the given mutable output `Vec`.
-    /// It should return `None` if the entry cannot be resolved from the pack that produced the `entries` iterator, causing
-    /// the write operation to fail.
+    ///   provides all bytes belonging to a pack entry writing them to the given mutable output `Vec`.
+    ///   It should return `None` if the entry cannot be resolved from the pack that produced the `entries` iterator, causing
+    ///   the write operation to fail.
     #[allow(clippy::too_many_arguments)]
     pub fn write_data_iter_to_stream<F, F2, R>(
         version: crate::index::Version,

Diff for: gix-status/src/index_as_worktree_with_renames/types.rs

@@ -325,10 +325,10 @@ pub struct Context<'a> {
     ///
     /// * `attr_stack`
     ///     - A stack pre-configured to allow accessing attributes for each entry, as required for `filter`
-    ///      and possibly pathspecs.
-    ///      It *may* also allow accessing `.gitignore` information for use in the directory walk.
-    ///      If no excludes information is present, the directory walk will identify ignored files as untracked, which
-    ///      might be desirable under certain circumstances.
+    ///       and possibly pathspecs.
+    ///       It *may* also allow accessing `.gitignore` information for use in the directory walk.
+    ///       If no excludes information is present, the directory walk will identify ignored files as untracked, which
+    ///       might be desirable under certain circumstances.
     /// * `filter`
     ///     - A filter to be able to perform conversions from and to the worktree format.
     ///       It is needed to potentially refresh the index with data read from the worktree, which needs to be converted back

Diff for: src/porcelain/main.rs

@@ -62,11 +62,11 @@ pub fn main() -> Result<()> {
                     progress,
                     progress_keep_open,
                     crate::shared::STANDARD_RANGE,
-                    move |mut progress, out, mut err| {
+                    move |mut progress, out, err| {
                         let engine = query::prepare(
                             &repo_dir,
                             &mut progress,
-                            &mut err,
+                            &mut *err,
                             query::Options {
                                 object_cache_size_mb,
                                 find_copies_harder,