build: update version to 0.2.1

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,22 +1,23 @@
 [package]
 name = "serde-inline-default"
-version = "0.1.0"
+version = "0.2.1"
-authors = ["ByteDream"]
+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

@@ -1,10 +1,10 @@
-# serde-inline-default [![ci](https://github.com/ByteDream/serde-inline-default/actions/workflows/ci.yml/badge.svg)](https://github.com/ByteDream/serde-inline-default/actions/workflows/ci.yml) [![crates.io](https://img.shields.io/crates/v/serde-inline-default)](https://crates.io/crates/serde-inline-default) [![docs](https://img.shields.io/docsrs/serde-inline-default)](https://docs.rs/crunchyroll-rs/latest/serde-inline-default/)
+# serde-inline-default [![ci](https://github.com/ByteDream/serde-inline-default/actions/workflows/ci.yml/badge.svg)](https://github.com/ByteDream/serde-inline-default/actions/workflows/ci.yml) [![crates.io](https://img.shields.io/crates/v/serde-inline-default)](https://crates.io/crates/serde-inline-default) [![docs](https://img.shields.io/docsrs/serde-inline-default)](https://docs.rs/serde-inline-default/latest/serde_inline_default/)
 
 Tiny crate to set default values for serde fields via inline attribute declaration.
 
 ## Overview
 
-This crate is an approach to do what serde-rs/serde#368 purposes.
+This crate is an approach to do what [serde-rs/serde#368](https://github.com/serde-rs/serde/issues/368) purposes.
 If you want to set default values in plain [`serde`](https://serde.rs/), you have to create a function and link to it with `#[serde(default = "...")`.
 This may be good if you need to do calculations to get the default value, but often you just want a simple integer or string to be the default value and have to create a whole function to return a hard-coded value.
 ```rust
@@ -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]
@@ -37,5 +37,5 @@ So this macro is just some syntax sugar for you, but can get quiet handy if you
 
 This project is licensed under either of the following licenses, at your option:
 
-- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
-- MIT License ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+- MIT License ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)

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

@@ -7,12 +7,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 = attr.parse_args().unwrap();
-            let default: TokenStream = _default_str[1.._default_str.len() - 1].parse().unwrap();
 
             // we check here if a function with the exact same return value already exists. if so,
             // this function gets used.
@@ -28,6 +27,7 @@ pub(crate) fn expand_struct(mut item: ItemStruct) -> proc_macro::TokenStream {
 
                 let inline_fn = quote! {
                     #[doc(hidden)]
+                    #[allow(non_snake_case)]
                     fn #fn_name_ident () -> #return_type {
                         #default
                     }

src/lib.rs

@@ -1,8 +1,32 @@
+#![doc = include_str!("../README.md")]
+
 use proc_macro::TokenStream;
 use syn::{parse_macro_input, Item};
 
 mod expand;
 
+/// The main macro of this crate.
+/// Use it to define default values of fields in structs you [`Serialize`] or [`Deserialize`].
+/// You do not need to create a extra function to provide the default value, as it is the case in serdes' implementation of default (`#[serde(default = "...")]`).
+///
+/// Set this macro on a struct where you use [`Serialize`] or [`Deserialize`] and use `#[serde_inline_default(...)]` on the field you want to have a inline default value.
+/// Replace the `...` with the value you want and it will be set as default if serde needs it.
+///
+/// Note that you must set this macro _before_ `#[derive(Serialize)]` / `#[derive(Deserialize)]` as it wouldn't work properly if set after the derive.
+///
+/// # Examples
+///
+/// ```rust
+/// #[serde_inline_default]
+/// #[derive(Deserialize)]
+/// struct Test {
+///     #[serde_inline_default(42)]
+///     value: u32
+/// }
+/// ```
+///
+/// [`Serialize`]: https://docs.rs/serde/*/serde/trait.Serialize.html
+/// [`Deserialize`]: https://docs.rs/serde/*/serde/trait.Deserialize.html
 #[proc_macro_attribute]
 pub fn serde_inline_default(_attr: TokenStream, input: TokenStream) -> TokenStream {
     let item = parse_macro_input!(input as Item);

tests/test_serde_inline_default.rs

@@ -17,6 +17,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 +26,5 @@ 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());
 }