cargo fmt

diff --git a/derive-macro/src/handle_enum.rs b/derive-macro/src/handle_enum.rs
index b2b14c0a5f0083a84af30748e8423c1bc3277073..8165ab5cdc8ae694d1afb8cf2792971adb05eb85 100644 (file)
--- a/derive-macro/src/handle_enum.rs
+++ b/derive-macro/src/handle_enum.rs
@@ -1,19 +1,23 @@
+use super::generate_fields;
 use proc_macro2::{Ident, Literal, TokenStream};
 use quote::quote;
 use syn::{DataEnum, Variant};
-use super::generate_fields;
 
 fn variant_weight(variant: &Variant) -> Literal {
     for attr in variant.attrs.iter() {
         if attr.path.is_ident("weight") {
-            return attr.parse_args::<Literal>().expect("expected literal for `#[weight(...)]`")
+            return attr
+                .parse_args::<Literal>()
+                .expect("expected literal for `#[weight(...)]`");
         }
     }
     Literal::u64_suffixed(1)
 }
 
 pub fn generate(name: &Ident, ty: DataEnum) -> TokenStream {
-    let mut variant_weights = ty.variants.into_iter()
+    let mut variant_weights = ty
+        .variants
+        .into_iter()
         .map(|variant| (variant_weight(&variant), variant));
 
     let mut arms = TokenStream::new();

diff --git a/derive-macro/src/handle_struct.rs b/derive-macro/src/handle_struct.rs
index 988bd06a09cb58bcd711cd3be63b0678217d461b..e5f05aaf6275a94f15a0742dbf06fbe71801250c 100644 (file)
--- a/derive-macro/src/handle_struct.rs
+++ b/derive-macro/src/handle_struct.rs
@@ -1,7 +1,7 @@
+use super::generate_fields;
 use proc_macro2::{Ident, TokenStream};
 use quote::quote;
 use syn::DataStruct;
-use super::generate_fields;
 
 pub fn generate(name: &Ident, ty: DataStruct) -> TokenStream {
     let fields = generate_fields(ty.fields);

diff --git a/derive-macro/src/lib.rs b/derive-macro/src/lib.rs
index 9aa93f55f0d4bb321c172f69176ffa17f427b035..8c77e611bf9f50947db3d108ccd8742753e2bf64 100644 (file)
--- a/derive-macro/src/lib.rs
+++ b/derive-macro/src/lib.rs
@@ -2,10 +2,10 @@
 //! that implements the trait of the same name from the `generate-random` crate.
 //! Refer to the documentation of that crate for more information.
 
-use syn::{DeriveInput, Data, Fields};
+use syn::{Data, DeriveInput, Fields};
 
-mod handle_struct;
 mod handle_enum;
+mod handle_struct;
 
 #[proc_macro_derive(GenerateRandom, attributes(weight))]
 pub fn derive_generate_random(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -14,14 +14,17 @@ pub fn derive_generate_random(input: proc_macro::TokenStream) -> proc_macro::Tok
         Data::Struct(ty) => handle_struct::generate(&input.ident, ty),
         Data::Enum(ty) => handle_enum::generate(&input.ident, ty),
         Data::Union(_) => panic!("Unions are not supported"),
-    }.into()
+    }
+    .into()
 }
 
 fn generate_fields(fields: Fields) -> proc_macro2::TokenStream {
     use quote::quote;
     match fields {
         Fields::Named(fields) => {
-            let fields = fields.named.into_iter()
+            let fields = fields
+                .named
+                .into_iter()
                 .map(|field| {
                     let field = field.ident.unwrap();
                     quote! {
@@ -32,7 +35,9 @@ fn generate_fields(fields: Fields) -> proc_macro2::TokenStream {
             quote! { { #fields } }
         }
         Fields::Unnamed(fields) => {
-            let fields = fields.unnamed.into_iter()
+            let fields = fields
+                .unnamed
+                .into_iter()
                 .map(|_field| {
                     quote! {
                         generate_random::GenerateRandom::generate_random(rng),

diff --git a/lib/src/lib.rs b/lib/src/lib.rs
index 40f02e9d3945b87a66bc426f8d0ef090cf55177c..e954eb47a0724bf886083797d9d227efd76aea79 100644 (file)
--- a/lib/src/lib.rs
+++ b/lib/src/lib.rs
@@ -42,15 +42,15 @@ pub trait GenerateRandom {
 }
 
 macro_rules! impl_generate_random {
-    ( $( $t:ty, )+ ) => {
-        $(
-            impl GenerateRandom for $t {
-                fn generate_random<R: rand::Rng + ?Sized>(rng: &mut R) -> Self {
-                    rng.gen()
-                }
-            }
-        )+
-    }
+       ( $( $t:ty, )+ ) => {
+               $(
+                       impl GenerateRandom for $t {
+                               fn generate_random<R: rand::Rng + ?Sized>(rng: &mut R) -> Self {
+                                       rng.gen()
+                               }
+                       }
+               )+
+       }
 }
 
 impl_generate_random! {
@@ -83,32 +83,32 @@ impl<T: GenerateRandom> GenerateRandom for Option<T> {
 }
 
 macro_rules! impl_generate_random_tuple {
-    ( $t0:ident $( $t:ident )* ) => {
-        impl< $t0, $( $t, )* > GenerateRandom for ( $t0, $( $t, )* )
-        where
-            $t0: GenerateRandom,
-            $(
-                $t: GenerateRandom,
-            )*
-        {
-            fn generate_random<R: rand::Rng + ?Sized>(rng: &mut R) -> Self {
-                (
-                    $t0::generate_random(rng),
-                    $(
-                        $t::generate_random(rng),
-                    )*
-                )
-            }
-        }
-        impl_generate_random_tuple!( $( $t )* );
-    };
-    () => {
-        impl GenerateRandom for () {
-            fn generate_random<R: rand::Rng + ?Sized>(_rng: &mut R) -> Self {
-                ()
-            }
-        }
-    }
+       ( $t0:ident $( $t:ident )* ) => {
+               impl< $t0, $( $t, )* > GenerateRandom for ( $t0, $( $t, )* )
+               where
+                       $t0: GenerateRandom,
+                       $(
+                               $t: GenerateRandom,
+                       )*
+               {
+                       fn generate_random<R: rand::Rng + ?Sized>(rng: &mut R) -> Self {
+                               (
+                                       $t0::generate_random(rng),
+                                       $(
+                                               $t::generate_random(rng),
+                                       )*
+                               )
+                       }
+               }
+               impl_generate_random_tuple!( $( $t )* );
+       };
+       () => {
+               impl GenerateRandom for () {
+                       fn generate_random<R: rand::Rng + ?Sized>(_rng: &mut R) -> Self {
+                               ()
+                       }
+               }
+       }
 }
 
 impl_generate_random_tuple!(A B C D E F G H I J K L);

diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index c60fbc51d888005a291efcf2dd9a2369461faf8c..b09335d7b87a4d53abe04c718b08f8a69d3dd757 100644 (file)
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -27,9 +27,13 @@ mod tests {
 
     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
     enum TestEnumNamed {
-        Left { x: u8 },
+        Left {
+            x: u8,
+        },
         #[weight(2)]
-        Right { y: bool },
+        Right {
+            y: bool,
+        },
     }
 
     #[derive(GenerateRandom, PartialEq, Eq, Debug)]
@@ -48,10 +52,7 @@ mod tests {
     fn test_enum_unit() {
         let mut rng = rng();
         assert_eq!(
-            repeat(
-                6,
-                || TestEnumUnit::generate_random(&mut rng),
-            ),
+            repeat(6, || TestEnumUnit::generate_random(&mut rng),),
             vec![
                 TestEnumUnit::Right,
                 TestEnumUnit::Right,
@@ -59,17 +60,15 @@ mod tests {
                 TestEnumUnit::Right,
                 TestEnumUnit::Right,
                 TestEnumUnit::Right,
-            ]);
+            ]
+        );
     }
 
     #[test]
     fn test_enum_unnamed() {
         let mut rng = rng();
         assert_eq!(
-            repeat(
-                6,
-                || TestEnumUnnamed::generate_random(&mut rng),
-            ),
+            repeat(6, || TestEnumUnnamed::generate_random(&mut rng),),
             vec![
                 TestEnumUnnamed::Right(false),
                 TestEnumUnnamed::Left(142),
@@ -77,17 +76,15 @@ mod tests {
                 TestEnumUnnamed::Right(true),
                 TestEnumUnnamed::Right(false),
                 TestEnumUnnamed::Left(19),
-            ]);
+            ]
+        );
     }
 
     #[test]
     fn test_enum_named() {
         let mut rng = rng();
         assert_eq!(
-            repeat(
-                6,
-                || TestEnumNamed::generate_random(&mut rng),
-            ),
+            repeat(6, || TestEnumNamed::generate_random(&mut rng),),
             vec![
                 TestEnumNamed::Right { y: false },
                 TestEnumNamed::Left { x: 142 },
@@ -95,16 +92,14 @@ mod tests {
                 TestEnumNamed::Right { y: true },
                 TestEnumNamed::Right { y: false },
                 TestEnumNamed::Left { x: 19 },
-            ]);
+            ]
+        );
     }
 
     #[test]
     fn test_struct_unit() {
         let mut rng = rng();
-        assert_eq!(
-            TestStructUnit::generate_random(&mut rng),
-            TestStructUnit
-        );
+        assert_eq!(TestStructUnit::generate_random(&mut rng), TestStructUnit);
     }
 
     #[test]