Fixed bug with single-struct derives in Response macro

- New version 0.8.4 was tagged
- Reported in #25

Author: ohsayan

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All changes in this project will be noted in this file.
 
+### 0.8.4
+
+Fixed an issue with single-item struct derives when using the `Response` macro.
+
 ### 0.8.3
 
 Added the following implementations:

Cargo.toml

@@ -9,12 +9,12 @@ license = "Apache-2.0"
 name = "skytable"
 readme = "README.md"
 repository = "https://github.com/skytable/client-rust"
-version = "0.8.3"
+version = "0.8.4"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 # internal deps
-sky-derive = "0.2.0"
+sky-derive = "0.2.1"
 # external deps
 tokio = { version = "1.35.1", features = ["full"] }
 native-tls = "0.2.11"

sky-derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sky-derive"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
 license = "Apache-2.0"
 description = "Macros for the Skytable client driver"

sky-derive/src/lib.rs

@@ -2,31 +2,29 @@ extern crate proc_macro;
 
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, DeriveInput, Data, Fields};
+use syn::{parse_macro_input, Data, DeriveInput, Fields};
 
 #[proc_macro_derive(Query)]
 pub fn derive_query(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     let name = input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
     let ret = match input.data {
-        Data::Struct(data_struct) => {
-            match data_struct.fields {
-                Fields::Named(fields) => {
-                    let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
-                    assert!(!field_names.is_empty(), "can't derive on empty field");
-                    quote! {
-                        impl #impl_generics ::skytable::query::SQParam for #name #ty_generics #where_clause {
-                            fn append_param(&self, q: &mut Vec<u8>) -> usize {
-                                let mut size = 0;
-                                #(size += ::skytable::query::SQParam::append_param(&self.#field_names, q);)*
-                                size
-                            }
+        Data::Struct(data_struct) => match data_struct.fields {
+            Fields::Named(fields) => {
+                let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
+                assert!(!field_names.is_empty(), "can't derive on empty field");
+                quote! {
+                    impl #impl_generics ::skytable::query::SQParam for #name #ty_generics #where_clause {
+                        fn append_param(&self, q: &mut Vec<u8>) -> usize {
+                            let mut size = 0;
+                            #(size += ::skytable::query::SQParam::append_param(&self.#field_names, q);)*
+                            size
                         }
                     }
-                },
-                _ => unimplemented!(),
+                }
             }
+            _ => unimplemented!(),
         },
         _ => unimplemented!(),
     };
@@ -39,24 +37,26 @@ pub fn derive_response(input: TokenStream) -> TokenStream {
     let name = input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
     let ret = match input.data {
-        Data::Struct(data_struct) => {
-            match data_struct.fields {
-                Fields::Named(fields) => {
-                    let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
-                    assert!(!field_names.is_empty(), "can't derive on empty field");
-                    let tuple_pattern = quote! { (#(#field_names),*) };
-                    let struct_instantiation = quote! { Self { #(#field_names),* } };    
-                    quote! {
-                        impl #impl_generics skytable::response::FromResponse for #name #ty_generics #where_clause {
-                            fn from_response(resp: skytable::response::Response) -> skytable::ClientResult<Self> {
-                                let #tuple_pattern = skytable::response::FromResponse::from_response(resp)?;
-                                Ok(#struct_instantiation)
-                            }
+        Data::Struct(data_struct) => match data_struct.fields {
+            Fields::Named(fields) => {
+                let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
+                assert!(!field_names.is_empty(), "can't derive on empty field");
+                let tuple_pattern = if field_names.len() == 1 {
+                    quote! { quote! { (#(#field_names),*,) } }
+                } else {
+                    quote! { (#(#field_names),*) }
+                };
+                let struct_instantiation = quote! { Self { #(#field_names),* } };
+                quote! {
+                    impl #impl_generics skytable::response::FromResponse for #name #ty_generics #where_clause {
+                        fn from_response(resp: skytable::response::Response) -> skytable::ClientResult<Self> {
+                            let #tuple_pattern = skytable::response::FromResponse::from_response(resp)?;
+                            Ok(#struct_instantiation)
                         }
                     }
-                },
-                _ => unimplemented!(),
+                }
             }
+            _ => unimplemented!(),
         },
         _ => unimplemented!(),
     };