Apply some Clippy lints.

mo8it · SergioBenitez · commit ceb65c8e60eb · 2024-07-22T14:52:17.000-07:00
diff --git a/src/error.rs b/src/error.rs
@@ -438,7 +438,7 @@ impl From<String> for Error {
 impl Display for Kind {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Kind::Message(msg) => f.write_str(&msg),
+            Kind::Message(msg) => f.write_str(msg),
             Kind::InvalidType(v, exp) => {
                 write!(f, "invalid type: found {}, expected {}", v, exp)
             }
diff --git a/src/figment.rs b/src/figment.rs
@@ -159,8 +159,7 @@ impl Figment {
             (Err(e), Err(prev)) => Err(e.retagged(tag).chain(prev)),
             (Ok(mut new), Ok(old)) => {
                 new.iter_mut()
-                    .map(|(p, map)| std::iter::repeat(p).zip(map.values_mut()))
-                    .flatten()
+                    .flat_map(|(p, map)| std::iter::repeat(p).zip(map.values_mut()))
                     .for_each(|(p, v)| v.map_tag(|t| *t = tag.for_profile(p)));
 
                 Ok(old.coalesce(new, order))
diff --git a/src/jail.rs b/src/jail.rs
@@ -320,9 +320,7 @@ impl Jail {
     pub fn clear_env(&mut self) {
         for (key, val) in std::env::vars_os() {
             std::env::remove_var(&key);
-            if !self.saved_env_vars.contains_key(&key) {
-                self.saved_env_vars.insert(key, Some(val));
-            }
+            self.saved_env_vars.entry(key).or_insert(Some(val));
         }
     }
 
@@ -356,7 +354,7 @@ impl Jail {
 
 impl Drop for Jail {
     fn drop(&mut self) {
-        for (key, value) in self.saved_env_vars.iter() {
+        for (key, value) in &self.saved_env_vars {
             match value {
                 Some(val) => std::env::set_var(key, val),
                 None => std::env::remove_var(key)
diff --git a/src/metadata.rs b/src/metadata.rs
@@ -292,7 +292,7 @@ impl fmt::Display for Source {
             Source::File(p) => {
                 use {std::env::current_dir, crate::util::diff_paths};
 
-                match current_dir().ok().and_then(|cwd| diff_paths(p, &cwd)) {
+                match current_dir().ok().and_then(|cwd| diff_paths(p, cwd)) {
                     Some(r) if r.iter().count() < p.iter().count() => r.display().fmt(f),
                     Some(_) | None => p.display().fmt(f)
                 }
diff --git a/src/providers/data.rs b/src/providers/data.rs
@@ -290,10 +290,10 @@ impl<F: Format> Provider for Data<F> {
         use Source::*;
         let map: Result<Map<Profile, Dict>, _> = match (&self.source, &self.profile) {
             (File(None), _) => return Ok(Map::new()),
-            (File(Some(path)), None) => F::from_path(&path),
-            (String(s), None) => F::from_str(&s),
-            (File(Some(path)), Some(prof)) => F::from_path(&path).map(|v| prof.collect(v)),
-            (String(s), Some(prof)) => F::from_str(&s).map(|v| prof.collect(v)),
+            (File(Some(path)), None) => F::from_path(path),
+            (String(s), None) => F::from_str(s),
+            (File(Some(path)), Some(prof)) => F::from_path(path).map(|v| prof.collect(v)),
+            (String(s), Some(prof)) => F::from_str(s).map(|v| prof.collect(v)),
         };
 
         Ok(map.map_err(|e| e.to_string())?)
diff --git a/src/providers/env.rs b/src/providers/env.rs
@@ -232,7 +232,7 @@ impl Env {
     pub fn filter<F: Clone + 'static>(self, filter: F) -> Self
         where F: Fn(&UncasedStr) -> bool
     {
-        self.chain(move |prev| prev.filter(|v| filter(&v)))
+        self.chain(move |prev| prev.filter(|v| filter(v)))
     }
 
     /// Applys an additional mapping to the keys of environment variables being
@@ -432,7 +432,7 @@ impl Env {
     /// });
     /// ```
     pub fn ignore(self, keys: &[&str]) -> Self {
-        let keys: Vec<String> = keys.iter().map(|s| s.to_string()).collect();
+        let keys: Vec<String> = keys.iter().map(|s| (*s).to_string()).collect();
         self.filter(move |key| !keys.iter().any(|k| k.as_str() == key))
     }
 
@@ -461,7 +461,7 @@ impl Env {
     /// });
     /// ```
     pub fn only(self, keys: &[&str]) -> Self {
-        let keys: Vec<String> = keys.iter().map(|s| s.to_string()).collect();
+        let keys: Vec<String> = keys.iter().map(|s| (*s).to_string()).collect();
         self.filter(move |key| keys.iter().any(|k| k.as_str() == key))
     }
 
diff --git a/src/util.rs b/src/util.rs
@@ -84,8 +84,8 @@ pub fn diff_paths<P, B>(path: P, base: B) -> Option<PathBuf>
             }
             (None, _) => comps.push(Component::ParentDir),
             (Some(a), Some(b)) if comps.is_empty() && a == b => (),
-            (Some(a), Some(b)) if b == Component::CurDir => comps.push(a),
-            (Some(_), Some(b)) if b == Component::ParentDir => return None,
+            (Some(a), Some(Component::CurDir)) => comps.push(a),
+            (Some(_), Some(Component::ParentDir)) => return None,
             (Some(a), Some(_)) => {
                 comps.push(Component::ParentDir);
                 for _ in itb {
diff --git a/src/value/de.rs b/src/value/de.rs
@@ -99,7 +99,7 @@ impl<'de: 'c, 'c, I: Interpreter> Deserializer<'de> for ConfiguredValueDe<'c, I>
             _ => visitor.visit_some(self)
         };
 
-        result.map_err(|e| e.retagged(tag).resolved(&config))
+        result.map_err(|e| e.retagged(tag).resolved(config))
     }
 
     fn deserialize_struct<V: Visitor<'de>>(
@@ -145,7 +145,7 @@ impl<'de: 'c, 'c, I: Interpreter> Deserializer<'de> for ConfiguredValueDe<'c, I>
             _ => self.deserialize_any(v)
         };
 
-        result.map_err(|e| e.retagged(tag).resolved(&config))
+        result.map_err(|e| e.retagged(tag).resolved(config))
     }
 
     fn deserialize_newtype_struct<V: Visitor<'de>>(
@@ -432,10 +432,10 @@ impl<'de> Deserialize<'de> for Value {
         // Total hack to "fingerprint" our deserializer by checking if
         // human_readable changes, which does for ours but shouldn't for others.
         let (a, b) = (de.is_human_readable(), de.is_human_readable());
-        if a != b {
-            de.deserialize_struct(Value::NAME, Value::FIELDS, ValueVisitor)
-        } else {
+        if a == b {
             de.deserialize_any(ValueVisitor)
+        } else {
+            de.deserialize_struct(Value::NAME, Value::FIELDS, ValueVisitor)
         }
     }
 }
diff --git a/src/value/escape.rs b/src/value/escape.rs
@@ -37,7 +37,7 @@ pub fn escape(string: &str) -> Result<Cow<'_, str>, Error> {
                     Some((_, 'n')) => val.push('\n'),
                     Some((_, 'r')) => val.push('\r'),
                     Some((_, 't')) => val.push('\t'),
-                    Some((i, c @ 'u')) | Some((i, c @ 'U')) => {
+                    Some((i, c @ ('u' | 'U'))) => {
                         let len = if c == 'u' { 4 } else { 8 };
                         val.push(hex(&mut chars, i, len)?);
                     }
@@ -64,7 +64,7 @@ fn hex<I>(mut chars: I, i: usize, len: usize) -> Result<char, Error>
     let mut buf = String::with_capacity(len);
     for _ in 0..len {
         match chars.next() {
-            Some((_, ch)) if ch as u32 <= 0x7F && ch.is_digit(16) => buf.push(ch),
+            Some((_, ch)) if ch as u32 <= 0x7F && ch.is_ascii_hexdigit() => buf.push(ch),
             Some((i, ch)) => return Err(Error::InvalidHexEscape(i, ch)),
             None => return Err(Error::UnterminatedString(0)),
         }
diff --git a/src/value/magic.rs b/src/value/magic.rs
@@ -203,7 +203,7 @@ impl Magic for RelativePathBuf {
         }
 
         // If we have this struct with no metadata_path, still use the value.
-        let value = de.value.find_ref(Self::FIELDS[1]).unwrap_or(&de.value);
+        let value = de.value.find_ref(Self::FIELDS[1]).unwrap_or(de.value);
         map.insert(Self::FIELDS[1].into(), value.clone());
         visitor.visit_map(MapDe::new(&map, |v| ConfiguredValueDe::<I>::from(config, v)))
     }
@@ -592,7 +592,7 @@ impl<T: for<'de> Deserialize<'de>> Magic for Tagged<T> {
         }
 
         // If we have this struct with default tag, use the value.
-        let value = de.value.find_ref(Self::FIELDS[1]).unwrap_or(&de.value);
+        let value = de.value.find_ref(Self::FIELDS[1]).unwrap_or(de.value);
         map.insert(Self::FIELDS[0].into(), de.value.tag().into());
         map.insert(Self::FIELDS[1].into(), value.clone());
         visitor.visit_map(MapDe::new(&map, |v| ConfiguredValueDe::<I>::from(config, v)))
diff --git a/src/value/ser.rs b/src/value/ser.rs
@@ -231,14 +231,15 @@ impl SeqSerializer {
     }
 }
 
-impl<'a> ser::SerializeSeq for SeqSerializer {
+impl ser::SerializeSeq for SeqSerializer {
     type Ok = Value;
     type Error = Error;
 
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
         where T: Serialize
     {
-        Ok(self.sequence.push(value.serialize(ValueSerializer)?))
+        self.sequence.push(value.serialize(ValueSerializer)?);
+        Ok(())
     }
 
     fn end(self) -> Result<Self::Ok> {
@@ -250,7 +251,7 @@ impl<'a> ser::SerializeSeq for SeqSerializer {
     }
 }
 
-impl<'a> ser::SerializeTuple for SeqSerializer {
+impl ser::SerializeTuple for SeqSerializer {
     type Ok = Value;
     type Error = Error;
 
@@ -266,7 +267,7 @@ impl<'a> ser::SerializeTuple for SeqSerializer {
 }
 
 // Same thing but for tuple structs.
-impl<'a> ser::SerializeTupleStruct for SeqSerializer {
+impl ser::SerializeTupleStruct for SeqSerializer {
     type Ok = Value;
     type Error = Error;
 
@@ -281,7 +282,7 @@ impl<'a> ser::SerializeTupleStruct for SeqSerializer {
     }
 }
 
-impl<'a> ser::SerializeTupleVariant for SeqSerializer {
+impl ser::SerializeTupleVariant for SeqSerializer {
     type Ok = Value;
     type Error = Error;
 
@@ -306,7 +307,7 @@ impl MapSerializer {
     }
 }
 
-impl<'a> ser::SerializeMap for MapSerializer {
+impl ser::SerializeMap for MapSerializer {
     type Ok = Value;
     type Error = Error;
 
@@ -329,7 +330,7 @@ impl<'a> ser::SerializeMap for MapSerializer {
     }
 
     fn end(self) -> Result<Self::Ok> {
-        let iter = self.keys.into_iter().zip(self.values.into_iter());
+        let iter = self.keys.into_iter().zip(self.values);
         let value: Value = iter.collect::<Dict>().into();
         match self.tag {
             Some(tag) => Ok(crate::util::map![tag => value].into()),
@@ -338,7 +339,7 @@ impl<'a> ser::SerializeMap for MapSerializer {
     }
 }
 
-impl<'a> ser::SerializeStruct for MapSerializer {
+impl ser::SerializeStruct for MapSerializer {
     type Ok = Value;
     type Error = Error;
 
@@ -354,7 +355,7 @@ impl<'a> ser::SerializeStruct for MapSerializer {
     }
 }
 
-impl<'a> ser::SerializeStructVariant for MapSerializer {
+impl ser::SerializeStructVariant for MapSerializer {
     type Ok = Value;
     type Error = Error;
 
diff --git a/src/value/tag.rs b/src/value/tag.rs
@@ -109,21 +109,21 @@ impl PartialEq for Tag {
 
 impl Eq for Tag {  }
 
-impl PartialOrd for Tag {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.metadata_id().partial_cmp(&other.metadata_id())
-    }
-}
-
 impl Ord for Tag {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         self.metadata_id().cmp(&other.metadata_id())
     }
 }
 
+impl PartialOrd for Tag {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
 impl std::hash::Hash for Tag {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        state.write_u64(self.metadata_id())
+        state.write_u64(self.metadata_id());
     }
 }
 
diff --git a/src/value/value.rs b/src/value/value.rs
@@ -177,7 +177,7 @@ impl Value {
     /// assert!(value.find_ref("pineapple").is_none());
     /// ```
     pub fn find_ref<'a>(&'a self, path: &str) -> Option<&'a Value> {
-        fn find<'a, 'v>(mut keys: Split<'a, char>, value: &'v Value) -> Option<&'v Value> {
+        fn find<'v>(mut keys: Split<char>, value: &'v Value) -> Option<&'v Value> {
             match keys.next() {
                 Some(k) if !k.is_empty() => find(keys, value.as_dict()?.get(k)?),
                 Some(_) | None => Some(value)
@@ -476,7 +476,7 @@ impl<'a, T: Into<Value> + Clone> From<&'a [T]> for Value {
     }
 }
 
-impl<'a, T: Into<Value>> From<Vec<T>> for Value {
+impl<T: Into<Value>> From<Vec<T>> for Value {
     fn from(vec: Vec<T>) -> Value {
         let vector = vec.into_iter().map(|v| v.into()).collect();
         Value::Array(Tag::Default, vector)
@@ -591,7 +591,7 @@ impl Num {
         Some(match self {
             Num::U8(v) => v as u32,
             Num::U16(v) => v as u32,
-            Num::U32(v) => v as u32,
+            Num::U32(v) => v,
             _ => return None,
         })
     }
@@ -612,7 +612,7 @@ impl Num {
             Num::U16(v) => v as u128,
             Num::U32(v) => v as u128,
             Num::U64(v) => v as u128,
-            Num::U128(v) => v as u128,
+            Num::U128(v) => v,
             Num::USize(v) => v as u128,
             _ => return None,
         })
@@ -638,7 +638,7 @@ impl Num {
             Num::U16(v) => v as u128,
             Num::U32(v) => v as u128,
             Num::U64(v) => v as u128,
-            Num::U128(v) => v as u128,
+            Num::U128(v) => v,
             Num::USize(v) => v as u128,
             Num::I8(v) if v >= 0 => v as u128,
             Num::I16(v) if v >= 0 => v as u128,
@@ -667,7 +667,7 @@ impl Num {
             Num::I16(v) => v as i128,
             Num::I32(v) => v as i128,
             Num::I64(v) => v as i128,
-            Num::I128(v) => v as i128,
+            Num::I128(v) => v,
             Num::ISize(v) => v as i128,
             _ => return None,
         })
@@ -687,7 +687,7 @@ impl Num {
     pub fn to_f64(&self) -> Option<f64> {
         Some(match *self {
             Num::F32(v) => v as f64,
-            Num::F64(v) => v as f64,
+            Num::F64(v) => v,
             _ => return None,
         })
     }
@@ -717,16 +717,16 @@ impl Num {
             Num::U16(v) => Actual::Unsigned(v as u128),
             Num::U32(v) => Actual::Unsigned(v as u128),
             Num::U64(v) => Actual::Unsigned(v as u128),
-            Num::U128(v) => Actual::Unsigned(v as u128),
+            Num::U128(v) => Actual::Unsigned(v),
             Num::USize(v) => Actual::Unsigned(v as u128),
             Num::I8(v) => Actual::Signed(v as i128),
             Num::I16(v) => Actual::Signed(v as i128),
             Num::I32(v) => Actual::Signed(v as i128),
             Num::I64(v) => Actual::Signed(v as i128),
-            Num::I128(v) => Actual::Signed(v as i128),
+            Num::I128(v) => Actual::Signed(v),
             Num::ISize(v) => Actual::Signed(v as i128),
             Num::F32(v) => Actual::Float(v as f64),
-            Num::F64(v) => Actual::Float(v as f64),
+            Num::F64(v) => Actual::Float(v),
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -438,7 +438,7 @@ impl From<String> for Error {`
`438`	`438`	`impl Display for Kind {`
`439`	`439`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`440`	`440`	`match self {`
`441`		`- Kind::Message(msg) => f.write_str(&msg),`
	`441`	`+ Kind::Message(msg) => f.write_str(msg),`
`442`	`442`	`Kind::InvalidType(v, exp) => {`
`443`	`443`	`write!(f, "invalid type: found {}, expected {}", v, exp)`
`444`	`444`	`}`
Original file line number	Diff line number	Diff line change
`@@ -292,7 +292,7 @@ impl fmt::Display for Source {`
`292`	`292`	`Source::File(p) => {`
`293`	`293`	`use {std::env::current_dir, crate::util::diff_paths};`
`294`	`294`
`295`		`- match current_dir().ok().and_then(\|cwd\| diff_paths(p, &cwd)) {`
	`295`	`+ match current_dir().ok().and_then(\|cwd\| diff_paths(p, cwd)) {`
`296`	`296`	`Some(r) if r.iter().count() < p.iter().count() => r.display().fmt(f),`
`297`	`297`	`Some(_) \| None => p.display().fmt(f)`
`298`	`298`	`}`
Original file line number	Diff line number	Diff line change
`@@ -232,7 +232,7 @@ impl Env {`
`232`	`232`	`pub fn filter<F: Clone + 'static>(self, filter: F) -> Self`
`233`	`233`	`where F: Fn(&UncasedStr) -> bool`
`234`	`234`	`{`
`235`		`- self.chain(move \|prev\| prev.filter(\|v\| filter(&v)))`
	`235`	`+ self.chain(move \|prev\| prev.filter(\|v\| filter(v)))`
`236`	`236`	`}`
`237`	`237`
`238`	`238`	`/// Applys an additional mapping to the keys of environment variables being`
`@@ -432,7 +432,7 @@ impl Env {`
`432`	`432`	`/// });`
`433`	`433`	/// ```
`434`	`434`	`pub fn ignore(self, keys: &[&str]) -> Self {`
`435`		`- let keys: Vec<String> = keys.iter().map(\|s\| s.to_string()).collect();`
	`435`	`+ let keys: Vec<String> = keys.iter().map(\|s\| (*s).to_string()).collect();`
`436`	`436`	`self.filter(move \|key\| !keys.iter().any(\|k\| k.as_str() == key))`
`437`	`437`	`}`
`438`	`438`
`@@ -461,7 +461,7 @@ impl Env {`
`461`	`461`	`/// });`
`462`	`462`	/// ```
`463`	`463`	`pub fn only(self, keys: &[&str]) -> Self {`
`464`		`- let keys: Vec<String> = keys.iter().map(\|s\| s.to_string()).collect();`
	`464`	`+ let keys: Vec<String> = keys.iter().map(\|s\| (*s).to_string()).collect();`
`465`	`465`	`self.filter(move \|key\| keys.iter().any(\|k\| k.as_str() == key))`
`466`	`466`	`}`
`467`	`467`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ impl<'de: 'c, 'c, I: Interpreter> Deserializer<'de> for ConfiguredValueDe<'c, I>`
`99`	`99`	`_ => visitor.visit_some(self)`
`100`	`100`	`};`
`101`	`101`
`102`		`- result.map_err(\|e\| e.retagged(tag).resolved(&config))`
	`102`	`+ result.map_err(\|e\| e.retagged(tag).resolved(config))`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`fn deserialize_struct<V: Visitor<'de>>(`
`@@ -145,7 +145,7 @@ impl<'de: 'c, 'c, I: Interpreter> Deserializer<'de> for ConfiguredValueDe<'c, I>`
`145`	`145`	`_ => self.deserialize_any(v)`
`146`	`146`	`};`
`147`	`147`
`148`		`- result.map_err(\|e\| e.retagged(tag).resolved(&config))`
	`148`	`+ result.map_err(\|e\| e.retagged(tag).resolved(config))`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`fn deserialize_newtype_struct<V: Visitor<'de>>(`
`@@ -432,10 +432,10 @@ impl<'de> Deserialize<'de> for Value {`
`432`	`432`	`// Total hack to "fingerprint" our deserializer by checking if`
`433`	`433`	`// human_readable changes, which does for ours but shouldn't for others.`
`434`	`434`	`let (a, b) = (de.is_human_readable(), de.is_human_readable());`
`435`		`- if a != b {`
`436`		`- de.deserialize_struct(Value::NAME, Value::FIELDS, ValueVisitor)`
`437`		`- } else {`
	`435`	`+ if a == b {`
`438`	`436`	`de.deserialize_any(ValueVisitor)`
	`437`	`+ } else {`
	`438`	`+ de.deserialize_struct(Value::NAME, Value::FIELDS, ValueVisitor)`
`439`	`439`	`}`
`440`	`440`	`}`
`441`	`441`	`}`
Original file line number	Diff line number	Diff line change
`@@ -203,7 +203,7 @@ impl Magic for RelativePathBuf {`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`// If we have this struct with no metadata_path, still use the value.`
`206`		`- let value = de.value.find_ref(Self::FIELDS[1]).unwrap_or(&de.value);`
	`206`	`+ let value = de.value.find_ref(Self::FIELDS[1]).unwrap_or(de.value);`
`207`	`207`	`map.insert(Self::FIELDS[1].into(), value.clone());`
`208`	`208`	`visitor.visit_map(MapDe::new(&map, \|v\| ConfiguredValueDe::<I>::from(config, v)))`
`209`	`209`	`}`
`@@ -592,7 +592,7 @@ impl<T: for<'de> Deserialize<'de>> Magic for Tagged<T> {`
`592`	`592`	`}`
`593`	`593`
`594`	`594`	`// If we have this struct with default tag, use the value.`
`595`		`- let value = de.value.find_ref(Self::FIELDS[1]).unwrap_or(&de.value);`
	`595`	`+ let value = de.value.find_ref(Self::FIELDS[1]).unwrap_or(de.value);`
`596`	`596`	`map.insert(Self::FIELDS[0].into(), de.value.tag().into());`
`597`	`597`	`map.insert(Self::FIELDS[1].into(), value.clone());`
`598`	`598`	`visitor.visit_map(MapDe::new(&map, \|v\| ConfiguredValueDe::<I>::from(config, v)))`