Code formatting

Author: eldruin

src/blocking/i2c.rs

@@ -124,6 +124,6 @@ pub trait WriteIterRead {
         bytes: B,
         buffer: &mut [u8],
     ) -> Result<(), Self::Error>
-        where
+    where
         B: IntoIterator<Item = u8>;
 }

src/digital/mod.rs

@@ -1,11 +1,14 @@
 //! Digital I/O
 //!
-//! 
+//!
 //!
 
 // Deprecated / infallible traits
-#[deprecated(since = "0.2.2", note = "Deprecated because the methods cannot return errors. \
-                                      Users should use the traits in digital::v2.")]
+#[deprecated(
+    since = "0.2.2",
+    note = "Deprecated because the methods cannot return errors. \
+                                      Users should use the traits in digital::v2."
+)]
 pub mod v1;
 
 // New / fallible traits
@@ -22,4 +25,3 @@ pub mod v2_compat;
 // Re-export old traits so this isn't a breaking change
 #[allow(deprecated)]
 pub use self::v1::*;
-

src/digital/v1_compat.rs

@@ -34,7 +34,6 @@
 //! ```
 //!
 
-
 #[allow(deprecated)]
 use super::v1;
 use super::v2;
@@ -44,14 +43,14 @@ pub struct OldOutputPin<T> {
     pin: T,
 }
 
-impl <T, E> OldOutputPin<T>
+impl<T, E> OldOutputPin<T>
 where
-    T: v2::OutputPin<Error=E>,
+    T: v2::OutputPin<Error = E>,
     E: core::fmt::Debug,
 {
     /// Create a new OldOutputPin wrapper around a `v2::OutputPin`
     pub fn new(pin: T) -> Self {
-        Self{pin}
+        Self { pin }
     }
 
     /// Fetch a reference to the inner `v2::OutputPin` impl
@@ -61,22 +60,22 @@ where
     }
 }
 
-impl <T, E> From<T> for OldOutputPin<T>
+impl<T, E> From<T> for OldOutputPin<T>
 where
-    T: v2::OutputPin<Error=E>,
+    T: v2::OutputPin<Error = E>,
     E: core::fmt::Debug,
 {
     fn from(pin: T) -> Self {
-        OldOutputPin{pin}
+        OldOutputPin { pin }
     }
 }
 
 /// Implementation of `v1::OutputPin` trait for fallible `v2::OutputPin` output pins
 /// where errors will panic.
 #[allow(deprecated)]
-impl <T, E> v1::OutputPin for OldOutputPin<T>
+impl<T, E> v1::OutputPin for OldOutputPin<T>
 where
-    T: v2::OutputPin<Error=E>,
+    T: v2::OutputPin<Error = E>,
     E: core::fmt::Debug,
 {
     fn set_low(&mut self) {
@@ -92,9 +91,9 @@ where
 /// where errors will panic.
 #[cfg(feature = "unproven")]
 #[allow(deprecated)]
-impl <T, E> v1::StatefulOutputPin for OldOutputPin<T>
+impl<T, E> v1::StatefulOutputPin for OldOutputPin<T>
 where
-    T: v2::StatefulOutputPin<Error=E>,
+    T: v2::StatefulOutputPin<Error = E>,
     E: core::fmt::Debug,
 {
     fn is_set_low(&self) -> bool {
@@ -114,36 +113,35 @@ pub struct OldInputPin<T> {
 }
 
 #[cfg(feature = "unproven")]
-impl <T, E> OldInputPin<T>
+impl<T, E> OldInputPin<T>
 where
-    T: v2::InputPin<Error=E>,
+    T: v2::InputPin<Error = E>,
     E: core::fmt::Debug,
 {
     /// Create an `OldInputPin` wrapper around a `v2::InputPin`.
     pub fn new(pin: T) -> Self {
-        Self{pin}
+        Self { pin }
     }
-
 }
 
 #[cfg(feature = "unproven")]
-impl <T, E> From<T> for OldInputPin<T>
+impl<T, E> From<T> for OldInputPin<T>
 where
-    T: v2::InputPin<Error=E>,
+    T: v2::InputPin<Error = E>,
     E: core::fmt::Debug,
 {
     fn from(pin: T) -> Self {
-        OldInputPin{pin}
+        OldInputPin { pin }
     }
 }
 
 /// Implementation of `v1::InputPin` trait for `v2::InputPin` fallible pins
 /// where errors will panic.
 #[cfg(feature = "unproven")]
 #[allow(deprecated)]
-impl <T, E> v1::InputPin for OldInputPin<T>
+impl<T, E> v1::InputPin for OldInputPin<T>
 where
-    T: v2::InputPin<Error=E>,
+    T: v2::InputPin<Error = E>,
     E: core::fmt::Debug,
 {
     fn is_low(&self) -> bool {
@@ -169,7 +167,7 @@ mod tests {
     #[derive(Clone)]
     struct NewOutputPinImpl {
         state: bool,
-        res: Result<(), ()>
+        res: Result<(), ()>,
     }
 
     impl v2::OutputPin for NewOutputPinImpl {
@@ -179,7 +177,7 @@ mod tests {
             self.state = false;
             self.res
         }
-        fn set_high(&mut self) -> Result<(), Self::Error>{
+        fn set_high(&mut self) -> Result<(), Self::Error> {
             self.state = true;
             self.res
         }
@@ -191,23 +189,31 @@ mod tests {
     }
 
     #[allow(deprecated)]
-    impl <T>OldOutputPinConsumer<T>
-    where T: v1::OutputPin
+    impl<T> OldOutputPinConsumer<T>
+    where
+        T: v1::OutputPin,
     {
         pub fn new(pin: T) -> OldOutputPinConsumer<T> {
-            OldOutputPinConsumer{ _pin: pin }
+            OldOutputPinConsumer { _pin: pin }
         }
     }
 
     #[test]
     fn v1_v2_output_explicit() {
-        let i = NewOutputPinImpl{state: false, res: Ok(())};
+        let i = NewOutputPinImpl {
+            state: false,
+            res: Ok(()),
+        };
         let _c: OldOutputPinConsumer<OldOutputPin<_>> = OldOutputPinConsumer::new(i.into());
     }
 
     #[test]
     fn v1_v2_output_state() {
-        let mut o: OldOutputPin<_> = NewOutputPinImpl{state: false, res: Ok(())}.into();
+        let mut o: OldOutputPin<_> = NewOutputPinImpl {
+            state: false,
+            res: Ok(()),
+        }
+        .into();
 
         o.set_high();
         assert_eq!(o.inner().state, true);
@@ -219,7 +225,11 @@ mod tests {
     #[test]
     #[should_panic]
     fn v1_v2_output_panic() {
-        let mut o: OldOutputPin<_> = NewOutputPinImpl{state: false, res: Err(())}.into();
+        let mut o: OldOutputPin<_> = NewOutputPinImpl {
+            state: false,
+            res: Err(()),
+        }
+        .into();
 
         o.set_high();
     }
@@ -239,7 +249,7 @@ mod tests {
         fn is_low(&self) -> Result<bool, Self::Error> {
             self.state.map(|v| v == false)
         }
-        fn is_high(&self) -> Result<bool, Self::Error>{
+        fn is_high(&self) -> Result<bool, Self::Error> {
             self.state.map(|v| v == true)
         }
     }
@@ -252,25 +262,26 @@ mod tests {
 
     #[cfg(feature = "unproven")]
     #[allow(deprecated)]
-    impl <T>OldInputPinConsumer<T>
-    where T: v1::InputPin
+    impl<T> OldInputPinConsumer<T>
+    where
+        T: v1::InputPin,
     {
         pub fn new(pin: T) -> OldInputPinConsumer<T> {
-            OldInputPinConsumer{ _pin: pin }
+            OldInputPinConsumer { _pin: pin }
         }
     }
 
     #[cfg(feature = "unproven")]
     #[test]
     fn v1_v2_input_explicit() {
-        let i = NewInputPinImpl{state: Ok(false)};
+        let i = NewInputPinImpl { state: Ok(false) };
         let _c: OldInputPinConsumer<OldInputPin<_>> = OldInputPinConsumer::new(i.into());
     }
 
     #[cfg(feature = "unproven")]
     #[test]
     fn v1_v2_input_state() {
-        let i:  OldInputPin<_> = NewInputPinImpl{state: Ok(false)}.into();
+        let i: OldInputPin<_> = NewInputPinImpl { state: Ok(false) }.into();
 
         assert_eq!(i.is_low(), true);
         assert_eq!(i.is_high(), false);
@@ -280,9 +291,8 @@ mod tests {
     #[test]
     #[should_panic]
     fn v1_v2_input_panic() {
-        let i:  OldInputPin<_> = NewInputPinImpl{state: Err(())}.into();
+        let i: OldInputPin<_> = NewInputPinImpl { state: Err(()) }.into();
 
         i.is_low();
     }
-
 }

src/digital/v2.rs

@@ -24,7 +24,7 @@ pub trait OutputPin {
 ///
 /// *This trait is available if embedded-hal is built with the `"unproven"` feature.*
 #[cfg(feature = "unproven")]
-pub trait StatefulOutputPin : OutputPin {
+pub trait StatefulOutputPin: OutputPin {
     /// Is the pin in drive high mode?
     ///
     /// *NOTE* this does *not* read the electrical state of the pin