Format

rustler/src/serde/de.rs

@@ -65,12 +65,12 @@ impl<'de, 'a: 'de> de::Deserializer<'de> for Deserializer<'a> {
                 try_parse_number!(self.term, i64, visitor, visit_i64);
 
                 Err(Error::ExpectedNumber)
-            },
+            }
             TermType::Float => {
                 try_parse_number!(self.term, f64, visitor, visit_f64);
 
                 Err(Error::ExpectedNumber)
-            },
+            }
             // char
             // string
             // byte array

rustler/src/serde/error.rs

@@ -56,8 +56,7 @@ impl From<Error> for NifError {
     }
 }
 
-impl std::error::Error for Error {
-}
+impl std::error::Error for Error {}
 
 impl ser::Error for Error {
     fn custom<T: Display>(msg: T) -> Error {

rustler/src/serde/mod.rs

@@ -8,7 +8,7 @@ pub use de::{from_term, Deserializer};
 pub use error::Error;
 pub use ser::{to_term, Serializer};
 
-use crate::{Term, Encoder, Env, Decoder, NifResult};
+use crate::{Decoder, Encoder, Env, NifResult, Term};
 
 /* impl<T: ?Sized> crate::Encoder for T where T: serde::Serialize {
     fn encode<'a>(&self, env: crate::Env<'a>) -> crate::Term<'a> {

rustler/src/serde/util.rs

@@ -1,5 +1,5 @@
 use crate::serde::{atoms, Error};
-use crate::{types::tuple, Binary, Decoder, Env, Term, Encoder};
+use crate::{types::tuple, Binary, Decoder, Encoder, Env, Term};
 
 /// Converts an `&str` to either an existing atom or an Elixir bitstring.
 pub fn str_to_term<'a>(env: &Env<'a>, string: &str) -> Result<Term<'a>, Error> {

rustler_tests/native/rustler_serde_test/src/json.rs

@@ -1,6 +1,6 @@
-use rustler::{Env, Error as NifError, NifResult, Term, Binary};
-use serde_bytes::Bytes;
 use rustler::serde::{to_term, Deserializer, Serializer};
+use rustler::{Binary, Env, Error as NifError, NifResult, Term};
+use serde_bytes::Bytes;
 use serde_transcode::transcode;
 
 #[nif]

rustler_tests/native/rustler_serde_test/src/lib.rs

@@ -10,8 +10,8 @@ mod test;
 mod types;
 
 use crate::types::Animal;
-use rustler::{types::tuple, Encoder, Env, NifResult, Term};
 use rustler::serde::{atoms, from_term, to_term, Deserializer, Error, Serializer};
+use rustler::{types::tuple, Encoder, Env, NifResult, Term};
 
 init! {
     "Elixir.SerdeRustlerTests",

rustler_tests/native/rustler_serde_test/src/test.rs

@@ -5,15 +5,20 @@ use crate::{
         UnitVariant,
     },
 };
+use rustler::serde::{atoms, from_term, to_term};
 use rustler::{Encoder, Env, NifResult, Term};
 use serde::{Deserialize, Serialize};
 use serde_bytes::Bytes;
-use rustler::serde::{atoms, from_term, to_term};
 use std::{collections::HashMap, fmt::Debug};
 
 /// Serializes or deserializes a known Elixir term to/from a known Rust value, asserts that the resulting is equivalent to known term/value.
 #[nif]
-pub fn test<'a>(env: Env<'a>, test_type: &str, test_name: &str, expected_term: Term<'a>) -> NifResult<Term<'a>> {
+pub fn test<'a>(
+    env: Env<'a>,
+    test_type: &str,
+    test_name: &str,
+    expected_term: Term<'a>,
+) -> NifResult<Term<'a>> {
     macro_rules! run_test {
         ($actual:expr) => {
             run_test(env, test_type, $actual, expected_term)