fix clippy and format warnings

Author: crapStone

ciborium/src/de/mod.rs

@@ -348,7 +348,7 @@ where
 
                     let mut segments = self.decoder.text(len);
                     while let Some(mut segment) = segments.pull()? {
-                        while let Some(chunk) = segment.pull(&mut self.scratch)? {
+                        while let Some(chunk) = segment.pull(self.scratch)? {
                             buffer.push_str(chunk);
                         }
                     }
@@ -389,7 +389,7 @@ where
 
                     let mut segments = self.decoder.bytes(len);
                     while let Some(mut segment) = segments.pull()? {
-                        while let Some(chunk) = segment.pull(&mut self.scratch)? {
+                        while let Some(chunk) = segment.pull(self.scratch)? {
                             buffer.extend_from_slice(chunk);
                         }
                     }

ciborium/src/value/canonical.rs

@@ -49,7 +49,7 @@ pub fn cmp_value(v1: &Value, v2: &Value) -> Ordering {
         (Bool(s), Bool(o)) => s.cmp(o),
         (Null, Null) => Ordering::Equal,
         (Tag(t, v), Tag(ot, ov)) => match Value::from(*t).partial_cmp(&Value::from(*ot)) {
-            Some(Ordering::Equal) | None => match v.partial_cmp(&ov) {
+            Some(Ordering::Equal) | None => match v.partial_cmp(ov) {
                 Some(x) => x,
                 None => serialized_canonical_cmp(v1, v2),
             },
@@ -80,9 +80,9 @@ impl From<Value> for CanonicalValue {
     }
 }
 
-impl Into<Value> for CanonicalValue {
-    fn into(self) -> Value {
-        self.0
+impl From<CanonicalValue> for Value {
+    fn from(v: CanonicalValue) -> Self {
+        v.0
     }
 }
 

ciborium/src/value/integer.rs

@@ -39,7 +39,7 @@ impl Integer {
     /// This is called `canonical` as it is only used for canonically comparing two
     /// values. It shouldn't be used in any other context.
     fn canonical_len(&self) -> usize {
-        let x = *&self.0;
+        let x = self.0;
 
         if let Ok(x) = u8::try_from(x) {
             if x < 24 {
@@ -53,17 +53,11 @@ impl Integer {
             } else {
                 2
             }
-        } else if let Ok(_) = u16::try_from(x) {
+        } else if u16::try_from(x).is_ok() || i16::try_from(x).is_ok() {
             3
-        } else if let Ok(_) = i16::try_from(x) {
-            3
-        } else if let Ok(_) = u32::try_from(x) {
-            5
-        } else if let Ok(_) = i32::try_from(x) {
+        } else if u32::try_from(x).is_ok() || i32::try_from(x).is_ok() {
             5
-        } else if let Ok(_) = u64::try_from(x) {
-            9
-        } else if let Ok(_) = i64::try_from(x) {
+        } else if u64::try_from(x).is_ok() || i64::try_from(x).is_ok() {
             9
         } else {
             // Ciborium serializes u128/i128 as BigPos if they don't fit in 64 bits.
@@ -79,12 +73,8 @@ impl Integer {
             Ordering::Equal => {
                 // Negative numbers are higher in byte-order than positive numbers.
                 match (self.0.is_negative(), other.0.is_negative()) {
-                    (false, true) => {
-                        Ordering::Less
-                    }
-                    (true, false) => {
-                        Ordering::Greater
-                    }
+                    (false, true) => Ordering::Less,
+                    (true, false) => Ordering::Greater,
                     (true, true) => {
                         // For negative numbers the byte order puts numbers closer to 0 which
                         // are lexically higher, lower. So -1 < -2 when sorting by be_bytes().
@@ -94,11 +84,9 @@ impl Integer {
                             Ordering::Greater => Ordering::Less,
                         }
                     }
-                    (_, _) => {
-                        self.0.cmp(&other.0)
-                    }
+                    (_, _) => self.0.cmp(&other.0),
                 }
-            },
+            }
             x => x,
         }
     }

ciborium/src/value/mod.rs

@@ -2,16 +2,16 @@
 
 //! A dynamic CBOR value
 
-mod integer;
 mod canonical;
+mod integer;
 
 mod de;
 mod error;
 mod ser;
 
+pub use canonical::CanonicalValue;
 pub use error::Error;
 pub use integer::Integer;
-pub use canonical::CanonicalValue;
 
 use alloc::{boxed::Box, string::String, vec::Vec};
 

ciborium/tests/canonical.rs

@@ -2,10 +2,10 @@
 
 extern crate std;
 
-use std::collections::BTreeMap;
 use ciborium::cbor;
-use ciborium::value::{ CanonicalValue, };
+use ciborium::value::CanonicalValue;
 use rand::prelude::*;
+use std::collections::BTreeMap;
 
 macro_rules! cval {
     ($x:expr) => {
@@ -56,7 +56,10 @@ fn map() {
     let mut bytes1 = Vec::new();
     ciborium::ser::into_writer(&map, &mut bytes1).unwrap();
 
-    assert_eq!(hex::encode(&bytes1), "a80a002001f402186403617a048120056261610681186407");
+    assert_eq!(
+        hex::encode(&bytes1),
+        "a80a002001f402186403617a048120056261610681186407"
+    );
 }
 
 #[test]