Formatting

Author: samuelburnham

src/error.rs

@@ -1,8 +1,8 @@
-#[cfg(feature = "std")]
-use std::io::Error as IoError;
 #[cfg(not(feature = "std"))]
 use core2::io::Error as IoError;
-  
+#[cfg(feature = "std")]
+use std::io::Error as IoError;
+
 use unsigned_varint::decode::Error as DecodeError;
 #[cfg(feature = "std")]
 use unsigned_varint::io::ReadError;
@@ -36,14 +36,14 @@ impl core::fmt::Display for Error {
 impl std::error::Error for Error {}
 
 #[cfg(not(feature = "std"))]
-impl core2::error::Error for Error {} 
+impl core2::error::Error for Error {}
 
 #[cfg(not(feature = "std"))]
 impl From<core2::io::Error> for Error {
-  fn from(err: core2::io::Error) -> Self {
-    Self::Io(err)
-  }
-} 
+    fn from(err: core2::io::Error) -> Self {
+        Self::Io(err)
+    }
+}
 
 #[cfg(feature = "std")]
 impl From<IoError> for Error {

src/hasher.rs

@@ -58,11 +58,11 @@ pub trait Digest<S: Size>:
     where
         R: io::Read,
     {
-      #[cfg(not(feature = "std"))]
-      use crate::varint_read_u64 as read_u64;
-      
-      #[cfg(feature = "std")]
-      use unsigned_varint::io::read_u64;
+        #[cfg(not(feature = "std"))]
+        use crate::varint_read_u64 as read_u64;
+
+        #[cfg(feature = "std")]
+        use unsigned_varint::io::read_u64;
 
         let size = read_u64(&mut r)?;
         if size > S::to_u64() || size > u8::max_value() as u64 {

src/lib.rs

@@ -93,4 +93,3 @@ pub use crate::hasher_impl::sha3::{Sha3Digest, Sha3_224, Sha3_256, Sha3_384, Sha
 #[cfg(feature = "strobe")]
 pub use crate::hasher_impl::strobe::{Strobe256, Strobe512, StrobeDigest, StrobeHasher};
 pub use crate::hasher_impl::unknown::UnknownDigest;
-

src/multihash.rs

@@ -8,7 +8,7 @@ use core::convert::TryInto;
 use core::fmt::Debug;
 use generic_array::{ArrayLength, GenericArray};
 
-use unsigned_varint::{encode as varint_encode, decode};
+use unsigned_varint::{decode, encode as varint_encode};
 
 #[cfg(feature = "std")]
 use std::io;
@@ -261,7 +261,6 @@ pub fn write_multihash<W>(mut w: W, code: u64, size: u8, digest: &[u8]) -> Resul
 where
     W: io::Write,
 {
-
     let mut code_buf = varint_encode::u64_buffer();
     let code = varint_encode::u64(code, &mut code_buf);
 
@@ -285,20 +284,20 @@ where
     R: io::Read,
     S: Size,
 {
-  #[cfg(not(feature = "std"))]
-  use crate::read_u64 as read_u64;
-  
-  #[cfg(feature = "std")]
-  use unsigned_varint::io::read_u64;
-
-  let code = match read_u64(&mut r) {
-    Ok(c) => c,
-    Err(e) => return Err(e.into()),
-  };
-  let size = match read_u64(&mut r) {
-    Ok(s) => s,
-    Err(e) => return Err(e.into()),
-  };
+    #[cfg(not(feature = "std"))]
+    use crate::read_u64;
+
+    #[cfg(feature = "std")]
+    use unsigned_varint::io::read_u64;
+
+    let code = match read_u64(&mut r) {
+        Ok(c) => c,
+        Err(e) => return Err(e.into()),
+    };
+    let size = match read_u64(&mut r) {
+        Ok(s) => s,
+        Err(e) => return Err(e.into()),
+    };
 
     if size > S::to_u64() || size > u8::MAX as u64 {
         return Err(Error::InvalidSize(size));
@@ -313,20 +312,18 @@ where
 /// Adapted from unsigned-varint's generated read_u64 function at
 /// https://github.com/paritytech/unsigned-varint/blob/master/src/io.rs
 pub fn read_u64<R: io::Read>(mut r: R) -> Result<u64, Error> {
-  let mut b = varint_encode::u64_buffer();
-  for i in 0..b.len() {
-    let n = r.read(&mut (b[i..i + 1]))?;
-    if n == 0 {
-      return Err(Error::Varint(decode::Error::Insufficient));
-    }
-    else if decode::is_last(b[i]) {
-      return Ok(decode::u64(&b[..=i]).unwrap().0);
+    let mut b = varint_encode::u64_buffer();
+    for i in 0..b.len() {
+        let n = r.read(&mut (b[i..i + 1]))?;
+        if n == 0 {
+            return Err(Error::Varint(decode::Error::Insufficient));
+        } else if decode::is_last(b[i]) {
+            return Ok(decode::u64(&b[..=i]).unwrap().0);
+        }
     }
-  }
-  Err(Error::Varint(decode::Error::Overflow))
+    Err(Error::Varint(decode::Error::Overflow))
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;