Removed some comments & cargo fmt

kabergstrom · kabergstrom · commit fb5e01de4883 · 2020-08-11T23:48:21.000+02:00
diff --git a/examples/enum.rs b/examples/enum.rs
@@ -3,8 +3,8 @@ use serde_diff::{Apply, Diff, SerdeDiff};
 
 #[derive(SerdeDiff, Serialize, Deserialize, PartialEq, Debug)]
 enum TestEnum {
-    Structish {x : u32, y: u32}, 
-    Enumish (i32, i32, i32),
+    Structish { x: u32, y: u32 },
+    Enumish(i32, i32, i32),
     Unitish,
 }
 
@@ -19,7 +19,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         let mut deserializer = serde_json::Deserializer::from_str(&json_data);
         let mut target = TestEnum::Structish { x: 0, y: 4 };
         Apply::apply(&mut deserializer, &mut target)?;
-        
+
         let result = TestEnum::Structish { x: 8, y: 4 };
         assert_eq!(result, target);
     }
@@ -31,30 +31,30 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         };
         let json_data = serde_json::to_string(&Diff::serializable(&old, &new))?;
         let mut deserializer = serde_json::Deserializer::from_str(&json_data);
-        let mut target = TestEnum::Enumish ( 1, 2, 3);        
+        let mut target = TestEnum::Enumish(1, 2, 3);
         Apply::apply(&mut deserializer, &mut target)?;
-        /* we can't apply changes from one enum variant 
+        /* we can't apply changes from one enum variant
         to another, as there may be unfilled fields with no sane defaults,
         should there be an error? probably.*/
-        let result = TestEnum::Enumish ( 1, 2, 3);
+        let result = TestEnum::Enumish(1, 2, 3);
         assert_eq!(result, target);
     }
     {
-        let old = TestEnum::Enumish (1, 2, 3);
-        let new = TestEnum::Enumish (1, 10, 3);
+        let old = TestEnum::Enumish(1, 2, 3);
+        let new = TestEnum::Enumish(1, 10, 3);
         let json_data = serde_json::to_string(&Diff::serializable(&old, &new))?;
         let mut deserializer = serde_json::Deserializer::from_str(&json_data);
-        let mut target = TestEnum::Enumish ( 4, 3, 2);        
+        let mut target = TestEnum::Enumish(4, 3, 2);
         Apply::apply(&mut deserializer, &mut target)?;
-        let result = TestEnum::Enumish (4, 10, 2); 
+        let result = TestEnum::Enumish(4, 10, 2);
         assert_eq!(result, target);
     }
     {
         let old = TestEnum::Structish { x: 5, y: 2 };
         let new = TestEnum::Unitish;
         let json_data = serde_json::to_string(&Diff::serializable(&old, &new))?;
         let mut deserializer = serde_json::Deserializer::from_str(&json_data);
-        let mut target = TestEnum::Enumish ( 1, 2, 3);        
+        let mut target = TestEnum::Enumish(1, 2, 3);
         Apply::apply(&mut deserializer, &mut target)?;
         let result = TestEnum::Unitish;
         assert_eq!(result, target);
diff --git a/examples/struct.rs b/examples/struct.rs
@@ -13,7 +13,8 @@ struct Test3Struct;
 
 #[derive(SerdeDiff, Serialize, Deserialize, PartialEq, Debug)]
 struct Test4Struct<T>
-where T: SerdeDiff
+where
+    T: SerdeDiff,
 {
     a: T,
 }
@@ -34,18 +35,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         assert_eq!(result, target);
     }
     {
-        let old = Test2Struct (1, 2, 3);
-        let new = Test2Struct (
+        let old = Test2Struct(1, 2, 3);
+        let new = Test2Struct(
             5, // Differs from old.0, will be serialized
-            2,
-            3
+            2, 3,
         );
-        let mut target = Test2Struct (4,5,6);
+        let mut target = Test2Struct(4, 5, 6);
         let json_data = serde_json::to_string(&Diff::serializable(&old, &new))?;
         let mut deserializer = serde_json::Deserializer::from_str(&json_data);
         Apply::apply(&mut deserializer, &mut target)?;
 
-        let result = Test2Struct ( 5,5,6 );
+        let result = Test2Struct(5, 5, 6);
         assert_eq!(result, target);
     }
     {
@@ -60,14 +60,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         assert_eq!(result, target);
     }
     {
-        let old = Test4Struct { a: 5};
-        let new = Test4Struct { a: 7};
-        let mut target = Test4Struct { a: 10};
+        let old = Test4Struct { a: 5 };
+        let new = Test4Struct { a: 7 };
+        let mut target = Test4Struct { a: 10 };
         let json_data = serde_json::to_string(&Diff::serializable(&old, &new))?;
         let mut deserializer = serde_json::Deserializer::from_str(&json_data);
         Apply::apply(&mut deserializer, &mut target)?;
 
-        let result = Test4Struct { a: 7};
+        let result = Test4Struct { a: 7 };
         assert_eq!(result, target);
     }
     Ok(())
diff --git a/serde-diff-derive/src/serde_diff/mod.rs b/serde-diff-derive/src/serde_diff/mod.rs
@@ -19,7 +19,6 @@ pub fn macro_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
              } else {
                  // Go ahead and generate the code                 
                  match generate(&input, struct_args) {
-                     //Ok(v) => {eprintln!("{}", v); v},
                      Ok(v) => v,
                      Err(v) => v,
                  }
@@ -31,7 +30,6 @@ pub fn macro_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
              } else {
                  // Go ahead and generate the code                 
                  match generate(&input, struct_args) {
-                     //Ok(v) => {eprintln!("{}", v); v},
                      Ok(v) => v,
                      Err(v) => v,
                  }
@@ -270,7 +268,7 @@ fn generate_arms(name: &syn::Ident, variant: Option<&syn::Ident>, fields: &syn::
                     while let Some(element) = ctx.next_path_element(seq)? {
                         match element {
                             #(#apply_fn_field_handlers)* 
-                        _ =>  ctx.skip_value(seq)?
+                            _ =>  ctx.skip_value(seq)?
                         }
                     }
                 }
diff --git a/src/difference.rs b/src/difference.rs
@@ -71,16 +71,18 @@ impl<'a, S: SerializeSeq> DiffContext<'a, S> {
         self.element_stack
             .as_mut()
             .unwrap()
-            .push(ElementStackEntry::PathElement(DiffPathElementValue::EnumVariant(
-                Cow::Borrowed(variant_name),
-            )));
+            .push(ElementStackEntry::PathElement(
+                DiffPathElementValue::EnumVariant(Cow::Borrowed(variant_name)),
+            ));
     }
 
     pub fn push_full_variant(&mut self) {
         self.element_stack
             .as_mut()
             .unwrap()
-            .push(ElementStackEntry::PathElement(DiffPathElementValue::FullEnumVariant));
+            .push(ElementStackEntry::PathElement(
+                DiffPathElementValue::FullEnumVariant,
+            ));
     }
 
     /// Called when we visit a field. If the structure is recursive (i.e. struct within struct,

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,8 @@ struct Test3Struct;`
`13`	`13`
`14`	`14`	`#[derive(SerdeDiff, Serialize, Deserialize, PartialEq, Debug)]`
`15`	`15`	`struct Test4Struct<T>`
`16`		`-where T: SerdeDiff`
	`16`	`+where`
	`17`	`+ T: SerdeDiff,`
`17`	`18`	`{`
`18`	`19`	`a: T,`
`19`	`20`	`}`
`@@ -34,18 +35,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {`
`34`	`35`	`assert_eq!(result, target);`
`35`	`36`	`}`
`36`	`37`	`{`
`37`		`- let old = Test2Struct (1, 2, 3);`
`38`		`- let new = Test2Struct (`
	`38`	`+ let old = Test2Struct(1, 2, 3);`
	`39`	`+ let new = Test2Struct(`
`39`	`40`	`5, // Differs from old.0, will be serialized`
`40`		`- 2,`
`41`		`- 3`
	`41`	`+ 2, 3,`
`42`	`42`	`);`
`43`		`- let mut target = Test2Struct (4,5,6);`
	`43`	`+ let mut target = Test2Struct(4, 5, 6);`
`44`	`44`	`let json_data = serde_json::to_string(&Diff::serializable(&old, &new))?;`
`45`	`45`	`let mut deserializer = serde_json::Deserializer::from_str(&json_data);`
`46`	`46`	`Apply::apply(&mut deserializer, &mut target)?;`
`47`	`47`
`48`		`- let result = Test2Struct ( 5,5,6 );`
	`48`	`+ let result = Test2Struct(5, 5, 6);`
`49`	`49`	`assert_eq!(result, target);`
`50`	`50`	`}`
`51`	`51`	`{`
`@@ -60,14 +60,14 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {`
`60`	`60`	`assert_eq!(result, target);`
`61`	`61`	`}`
`62`	`62`	`{`
`63`		`- let old = Test4Struct { a: 5};`
`64`		`- let new = Test4Struct { a: 7};`
`65`		`- let mut target = Test4Struct { a: 10};`
	`63`	`+ let old = Test4Struct { a: 5 };`
	`64`	`+ let new = Test4Struct { a: 7 };`
	`65`	`+ let mut target = Test4Struct { a: 10 };`
`66`	`66`	`let json_data = serde_json::to_string(&Diff::serializable(&old, &new))?;`
`67`	`67`	`let mut deserializer = serde_json::Deserializer::from_str(&json_data);`
`68`	`68`	`Apply::apply(&mut deserializer, &mut target)?;`
`69`	`69`
`70`		`- let result = Test4Struct { a: 7};`
	`70`	`+ let result = Test4Struct { a: 7 };`
`71`	`71`	`assert_eq!(result, target);`
`72`	`72`	`}`
`73`	`73`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,6 @@ pub fn macro_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {`
`19`	`19`	`} else {`
`20`	`20`	`// Go ahead and generate the code`
`21`	`21`	`match generate(&input, struct_args) {`
`22`		`- //Ok(v) => {eprintln!("{}", v); v},`
`23`	`22`	`Ok(v) => v,`
`24`	`23`	`Err(v) => v,`
`25`	`24`	`}`
`@@ -31,7 +30,6 @@ pub fn macro_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {`
`31`	`30`	`} else {`
`32`	`31`	`// Go ahead and generate the code`
`33`	`32`	`match generate(&input, struct_args) {`
`34`		`- //Ok(v) => {eprintln!("{}", v); v},`
`35`	`33`	`Ok(v) => v,`
`36`	`34`	`Err(v) => v,`
`37`	`35`	`}`
`@@ -270,7 +268,7 @@ fn generate_arms(name: &syn::Ident, variant: Option<&syn::Ident>, fields: &syn::`
`270`	`268`	`while let Some(element) = ctx.next_path_element(seq)? {`
`271`	`269`	`match element {`
`272`	`270`	`#(#apply_fn_field_handlers)*`
`273`		`- _ => ctx.skip_value(seq)?`
	`271`	`+ _ => ctx.skip_value(seq)?`
`274`	`272`	`}`
`275`	`273`	`}`
`276`	`274`	`}`