build: update version to 0.2.2

Updates the requirements on [syn](https://github.com/dtolnay/syn) to permit the latest version.
- [Release notes](https://github.com/dtolnay/syn/releases)
- [Commits](https://github.com/dtolnay/syn/compare/1.0.0...2.0.10)

---
updated-dependencies:
- dependency-name: syn
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: cargo
+    directory: /
+    schedule:
+      interval: weekly

Cargo.toml

@@ -1,24 +1,23 @@
 [package]
 name = "serde-inline-default"
-version = "0.1.1"
-authors = ["ByteDream"]
+version = "0.2.2"
+authors = ["bytedream"]
 edition = "2021"
 description = "Serde default values via inline declaration"
 readme = "README.md"
-repository = "https://github.com/ByteDream/serde-inline-default"
+repository = "https://github.com/bytedream/serde-inline-default"
 license = "MIT OR Apache-2.0"
 keywords = ["serde", "serialization"]
 categories = ["encoding"]
 
 [lib]
 proc-macro = true
-
 doctest = false
 
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0", features = ["full"] }
+syn = { version = "2.0", features = ["full"] }
 
 [dev-dependencies]
 serde = { version = "1.0", features = ["derive"] }

README.md

@@ -19,7 +19,7 @@ fn value_default() -> u32 { 42 }
 
 That can get quiet messy if you have many fields with many (different) default values.
 This crate tries to solve this issue by providing the `#[serde_inline_default]` proc macro.
-With this macro set at the struct level (_before `#[derive(Deserialize)]`/`#[derive(Serialize)]`!_, otherwise it's not working correctly), you can set default values via `#[serde_inline_default(...)]` for your serde fields inline, without creating an extra function.
+With this macro set at the struct level (_**before `#[derive(Deserialize)]`/`#[derive(Serialize)]`!, otherwise it's not working correctly**_), you can set default values via `#[serde_inline_default(...)]` for your serde fields inline, without creating an extra function.
 
 ```rust
 #[serde_inline_default]

examples/basic.rs

@@ -0,0 +1,29 @@
+use serde::Deserialize;
+use serde_inline_default::serde_inline_default;
+use serde_json::json;
+
+#[serde_inline_default]
+#[derive(Deserialize)]
+struct Basic {
+    // if using `String` you have to call `.to_string()`
+    #[serde_inline_default("0.0.0.0".to_string())]
+    host: String,
+    // works without specifying the integer type at the end of the value (8080u16)
+    #[serde_inline_default(8080)]
+    port: u16,
+    // expressions are working too
+    #[serde_inline_default(serde_json::json!({}))]
+    random_third_party_type: serde_json::Value,
+}
+
+fn main() -> Result<(), serde_json::Error> {
+    // creating a empty json object to use the default value of all fields
+    let json_object = json!({});
+    let basic: Basic = serde_json::from_value(json_object)?;
+
+    assert_eq!(basic.host, "0.0.0.0".to_string());
+    assert_eq!(basic.port, 8080);
+    assert_eq!(basic.random_third_party_type, json!({}));
+
+    Ok(())
+}

examples/macro_rules.rs

@@ -0,0 +1,39 @@
+use serde_json::json;
+macro_rules! simple_macro {
+    (struct $name:ident { $($field:ident: $type:ty $(= $default:expr)?),*$(,)? }) => {
+        #[serde_inline_default::serde_inline_default]
+        #[derive(serde::Deserialize)]
+        struct $name {
+            $(
+                $(
+                    #[serde_inline_default($default)]
+                )?
+                $field: $type
+            ),*
+        }
+    }
+}
+
+fn main() -> Result<(), serde_json::Error> {
+    // `username` and `password` must be set when deserializing as no default value is defined for
+    // them. `secret` not as we're defining a default value for it
+    simple_macro! {
+        struct Example {
+            username: String,
+            password: String,
+            secret: String = "verysecretsecret".to_string()
+        }
+    }
+
+    let json_object = json!({
+        "username": "testuser",
+        "password": "testpassword"
+    });
+
+    let example: Example = serde_json::from_value(json_object)?;
+    assert_eq!(example.username, "testuser");
+    assert_eq!(example.password, "testpassword");
+    assert_eq!(example.secret, "verysecretsecret");
+
+    Ok(())
+}

src/expand.rs

@@ -1,3 +1,4 @@
+use crate::utils::type_lifetimes_to_static;
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
 use syn::{parse_quote, ItemStruct};
@@ -7,12 +8,11 @@ pub(crate) fn expand_struct(mut item: ItemStruct) -> proc_macro::TokenStream {
 
     for (i, field) in item.fields.iter_mut().enumerate() {
         for (j, attr) in field.attrs.iter_mut().enumerate() {
-            if !attr.path.is_ident("serde_inline_default") {
+            if !attr.path().is_ident("serde_inline_default") {
                 continue;
             }
 
-            let _default_str = attr.tokens.to_string();
-            let default: TokenStream = _default_str[1.._default_str.len() - 1].parse().unwrap();
+            let default: TokenStream = attr.parse_args().unwrap();
 
             // we check here if a function with the exact same return value already exists. if so,
             // this function gets used.
@@ -24,10 +24,14 @@ pub(crate) fn expand_struct(mut item: ItemStruct) -> proc_macro::TokenStream {
             } else {
                 let fn_name_lit = format!("__serde_inline_default_{}_{}", item.ident, i);
                 let fn_name_ident = Ident::new(&fn_name_lit, Span::call_site());
-                let return_type = &field.ty;
+                let mut return_type = field.ty.clone();
+
+                // replaces most lifetimes with 'static
+                type_lifetimes_to_static(&mut return_type);
 
                 let inline_fn = quote! {
                     #[doc(hidden)]
+                    #[allow(non_snake_case)]
                     fn #fn_name_ident () -> #return_type {
                         #default
                     }

src/lib.rs

@@ -4,6 +4,7 @@ use proc_macro::TokenStream;
 use syn::{parse_macro_input, Item};
 
 mod expand;
+mod utils;
 
 /// The main macro of this crate.
 /// Use it to define default values of fields in structs you [`Serialize`] or [`Deserialize`].

src/utils.rs

@@ -0,0 +1,40 @@
+use syn::{parse_quote, GenericArgument, PathArguments, Type};
+
+pub(crate) fn type_lifetimes_to_static(ty: &mut Type) {
+    match ty {
+        Type::Array(array) => type_lifetimes_to_static(array.elem.as_mut()),
+        Type::Group(group) => type_lifetimes_to_static(&mut group.elem),
+        Type::Path(path) => {
+            for segment in &mut path.path.segments {
+                match &mut segment.arguments {
+                    PathArguments::None => (),
+                    PathArguments::AngleBracketed(angle_bracketed) => {
+                        for arg in &mut angle_bracketed.args {
+                            match arg {
+                                GenericArgument::Lifetime(lifetime) => {
+                                    *lifetime = parse_quote!('static);
+                                }
+                                GenericArgument::Type(ty) => type_lifetimes_to_static(ty),
+                                _ => (),
+                            }
+                        }
+                    }
+                    PathArguments::Parenthesized(parenthesized) => {
+                        for input in &mut parenthesized.inputs {
+                            type_lifetimes_to_static(input)
+                        }
+                    }
+                }
+            }
+        }
+        Type::Ptr(ptr) => type_lifetimes_to_static(&mut ptr.elem),
+        Type::Reference(reference) => reference.lifetime = Some(parse_quote!('static)),
+        Type::Slice(slice) => type_lifetimes_to_static(&mut slice.elem),
+        Type::Tuple(tuple) => {
+            for elem in &mut tuple.elems {
+                type_lifetimes_to_static(elem)
+            }
+        }
+        _ => (),
+    }
+}

tests/test_serde_inline_default.rs

@@ -1,6 +1,7 @@
 use serde::Deserialize;
 use serde_inline_default::serde_inline_default;
 use serde_json::json;
+use std::borrow::Cow;
 
 #[test]
 fn test_serde_inline_default() {
@@ -17,6 +18,8 @@ fn test_serde_inline_default() {
         inline: u32,
         #[serde_inline_default(-1337)]
         inline_negative: i32,
+        #[serde_inline_default("string".to_string())]
+        string: String,
     }
 
     let test: Test = serde_json::from_value(json!({})).unwrap();
@@ -24,4 +27,19 @@ fn test_serde_inline_default() {
     assert_eq!(test.native, 69);
     assert_eq!(test.inline, 420);
     assert_eq!(test.inline_negative, -1337);
+    assert_eq!(test.string, "string".to_string());
+}
+
+#[test]
+fn test_lifetime() {
+    #[serde_inline_default]
+    #[derive(Deserialize)]
+    struct LifetimeTest<'a> {
+        #[serde_inline_default("test".into())]
+        test_str: Cow<'a, str>,
+    }
+
+    let lifetime_test: LifetimeTest = serde_json::from_value(json!({})).unwrap();
+
+    assert_eq!(lifetime_test.test_str, "test");
 }