From d31943e0e7811a1ce9f9e57a01274596ab2cf818 Mon Sep 17 00:00:00 2001 From: Oguz Kocer Date: Thu, 20 Jun 2024 16:27:16 -0400 Subject: [PATCH 1/5] Generate request executor from wp_derived_request_builder --- wp_api/src/request/endpoint/users_endpoint.rs | 6 +- wp_derive_request_builder/src/generate.rs | 77 ++++++++- .../generate/helpers_to_generate_tokens.rs | 161 +++++++++++++++++- 3 files changed, 237 insertions(+), 7 deletions(-) diff --git a/wp_api/src/request/endpoint/users_endpoint.rs b/wp_api/src/request/endpoint/users_endpoint.rs index 466b1cf47..c4c4f6193 100644 --- a/wp_api/src/request/endpoint/users_endpoint.rs +++ b/wp_api/src/request/endpoint/users_endpoint.rs @@ -17,7 +17,7 @@ pub mod generated { enum UsersRequest { #[contextual_get(url = "/users", params = &UserListParams, output = Vec)] List, - #[post(url = "/users", params = &crate::UserCreateParams, output = UserWithEditContext)] + #[post(url = "/users", params = &crate::UserCreateParams, output = crate::UserWithEditContext)] Create, #[delete(url = "/users/", params = &UserDeleteParams, output = crate::UserDeleteResponse)] Delete, @@ -27,9 +27,9 @@ pub mod generated { Retrieve, #[contextual_get(url = "/users/me", output = crate::SparseUser)] RetrieveMe, - #[post(url = "/users/", params = &crate::UserUpdateParams, output = UserWithEditContext)] + #[post(url = "/users/", params = &crate::UserUpdateParams, output = crate::UserWithEditContext)] Update, - #[post(url = "/users/me", params = &crate::UserUpdateParams, output = UserWithEditContext)] + #[post(url = "/users/me", params = &crate::UserUpdateParams, output = crate::UserWithEditContext)] UpdateMe, } } diff --git a/wp_derive_request_builder/src/generate.rs b/wp_derive_request_builder/src/generate.rs index 1cb66b07f..79effaf82 100644 --- a/wp_derive_request_builder/src/generate.rs +++ b/wp_derive_request_builder/src/generate.rs @@ -21,11 +21,75 @@ pub(crate) fn generate_types(parsed_enum: &ParsedEnum) -> TokenStream { &mut [ generate_endpoint_type(&config, parsed_enum), generate_request_builder(&config, parsed_enum), + generate_async_request_executor(&config, parsed_enum), ] .into_iter(), ) } +fn generate_async_request_executor(config: &Config, parsed_enum: &ParsedEnum) -> TokenStream { + let api_base_url_type = &config.api_base_url_type; + let request_builder_ident = &config.request_builder_ident; + let request_executor_ident = &config.request_executor_ident; + let request_executor_type = &config.request_executor_type; + let wp_api_error_type = &config.wp_api_error_type; + + let functions = parsed_enum.variants.iter().map(|variant| { + let url_parts = variant.attr.url_parts.as_slice(); + let params_type = &variant.attr.params; + let output_type = TokenStream::from_iter(variant.attr.output.clone().into_iter()); + let output_type = quote! { #output_type }; + + ContextAndFilterHandler::from_request_type(variant.attr.request_type) + .into_iter() + .map(|context_and_filter_handler| { + let request_from_request_builder = fn_body_get_request_from_request_builder( + &variant.variant_ident, + url_parts, + params_type, + variant.attr.request_type, + context_and_filter_handler, + ); + let fn_signature = fn_signature( + PartOf::RequestExecutor, + &variant.variant_ident, + url_parts, + params_type, + variant.attr.request_type, + context_and_filter_handler, + &config.sparse_field_type, + ); + quote! { + pub async #fn_signature -> Result<#output_type, #wp_api_error_type> { + #request_from_request_builder + self.request_executor.execute(request).await?.parse() + } + } + }) + .collect::() + }); + + quote! { + #[derive(Debug, uniffi::Object)] + pub struct #request_executor_ident { + request_builder: #request_builder_ident, + request_executor: #request_executor_type, + } + impl #request_executor_ident { + pub(crate) fn new(request_builder: #request_builder_ident, request_executor: #request_executor_type) -> Self { + Self { + request_builder, + request_executor, + } + } + } + #[uniffi::export] + impl #request_executor_ident { + #(#functions)* + } + } +} + fn generate_request_builder(config: &Config, parsed_enum: &ParsedEnum) -> TokenStream { let api_base_url_type = &config.api_base_url_type; let endpoint_ident = &config.endpoint_ident; @@ -56,12 +120,12 @@ fn generate_request_builder(config: &Config, parsed_enum: &ParsedEnum) -> TokenS context_and_filter_handler, &config.sparse_field_type, ); - let fn_body = + let fn_body_build_request_from_url = fn_body_build_request_from_url(params_type, variant.attr.request_type); quote! { pub #fn_signature -> #wp_network_request_type { #url_from_endpoint - #fn_body + #fn_body_build_request_from_url } } }) @@ -150,6 +214,7 @@ fn generate_endpoint_type(config: &Config, parsed_enum: &ParsedEnum) -> TokenStr pub enum PartOf { Endpoint, RequestBuilder, + RequestExecutor, } #[derive(Debug, Clone, Copy)] @@ -207,12 +272,16 @@ impl Display for WpContext { #[derive(Debug)] pub struct Config { + // TODO: It's not clear what some of the names refer to and the difference between them + // For example, with "request_builder_ident" & "request_builder_type" pub api_base_url_type: TokenStream, pub api_endpoint_url_type: TokenStream, pub crate_ident: Ident, pub endpoint_ident: Ident, pub request_builder_ident: Ident, pub request_builder_type: TokenStream, + pub request_executor_ident: Ident, + pub request_executor_type: TokenStream, pub sparse_field_type: SparseFieldAttr, pub wp_api_error_type: TokenStream, pub wp_network_request_type: TokenStream, @@ -232,6 +301,8 @@ impl Config { quote! { std::sync::Arc<#crate_ident::request::endpoint::ApiBaseUrl> }; let api_endpoint_url_type = quote! { #crate_ident::request::endpoint::ApiEndpointUrl }; let request_builder_type = quote! { std::sync::Arc<#crate_ident::request::RequestBuilder> }; + let request_executor_type = + quote! { std::sync::Arc }; let wp_api_error_type = quote! { #crate_ident::WpApiError }; let wp_network_request_type = quote! { #crate_ident::request::WpNetworkRequest }; Self { @@ -243,6 +314,8 @@ impl Config { // implementation request_builder_ident: format_ident!("{}Builder2", parsed_enum.enum_ident), request_builder_type, + request_executor_ident: format_ident!("{}Executor", parsed_enum.enum_ident), + request_executor_type, sparse_field_type: parsed_enum.sparse_field_attr.clone(), wp_api_error_type, wp_network_request_type, diff --git a/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs b/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs index e0cef6ff8..ddcc9f5c6 100644 --- a/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs +++ b/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs @@ -75,7 +75,7 @@ pub fn fn_provided_param( | crate::parse::RequestType::Get => tokens, crate::parse::RequestType::Post => TokenStream::new(), }, - PartOf::RequestBuilder => tokens, + PartOf::RequestBuilder | PartOf::RequestExecutor => tokens, } } else { TokenStream::new() @@ -170,7 +170,7 @@ fn fn_arg_provided_params( | crate::parse::RequestType::Get => tokens, crate::parse::RequestType::Post => TokenStream::new(), }, - PartOf::RequestBuilder => tokens, + PartOf::RequestBuilder | PartOf::RequestExecutor => tokens, } } else { TokenStream::new() @@ -319,6 +319,25 @@ pub fn fn_body_build_request_from_url( } } +pub fn fn_body_get_request_from_request_builder( + variant_ident: &Ident, + url_parts: &[UrlPart], + params_type: &ParamsType, + request_type: RequestType, + context_and_filter_handler: ContextAndFilterHandler, +) -> TokenStream { + let fn_name = fn_name(variant_ident, context_and_filter_handler); + let fn_arg_url_parts = fn_arg_url_parts(url_parts); + let fn_arg_context = fn_arg_context(context_and_filter_handler); + let fn_arg_provided_params = + fn_arg_provided_params(PartOf::RequestExecutor, params_type, request_type); + let fn_arg_fields = fn_arg_fields(context_and_filter_handler); + + quote! { + let request = self.request_builder.#fn_name(#fn_arg_url_parts #fn_arg_context #fn_arg_provided_params #fn_arg_fields); + } +} + #[cfg(test)] mod tests { #![allow(clippy::too_many_arguments)] @@ -352,6 +371,12 @@ mod tests { RequestType::Post, "params : &UserCreateParams ," )] + #[case( + PartOf::RequestExecutor, + &referenced_params_type("UserCreateParams"), + RequestType::Post, + "params : &UserCreateParams ," + )] #[case( PartOf::Endpoint, &referenced_params_type("UserListParams"), @@ -496,6 +521,7 @@ mod tests { #[case(PartOf::Endpoint, &ParamsType::new(None), RequestType::Get, "")] #[case(PartOf::Endpoint, &referenced_params_type("UserCreateParams"), RequestType::Post, "")] #[case(PartOf::RequestBuilder, &referenced_params_type("UserCreateParams"), RequestType::Post, "params ,")] + #[case(PartOf::RequestExecutor, &referenced_params_type("UserCreateParams"), RequestType::Post, "params ,")] #[case(PartOf::Endpoint, &referenced_params_type("UserListParams"), RequestType::ContextualGet, "params ,")] #[case(PartOf::Endpoint, &referenced_params_type("UserListParams"), RequestType::ContextualGet, "params ,")] #[case(PartOf::Endpoint, &referenced_params_type("UserListParams"), RequestType::Delete, "params ,")] @@ -557,6 +583,14 @@ mod tests { RequestType::Post, ContextAndFilterHandler::FilterNoContext, "fn filter_create (& self , params : &UserCreateParams , fields : & [SparseUserField])")] + #[case( + PartOf::RequestExecutor, + format_ident!("Create"), + url_static_users(), + &referenced_params_type("UserCreateParams"), + RequestType::Post, + ContextAndFilterHandler::FilterNoContext, + "fn filter_create (& self , params : &UserCreateParams , fields : & [SparseUserField])")] #[case( PartOf::Endpoint, format_ident!("Delete"), @@ -637,6 +671,14 @@ mod tests { RequestType::Post, ContextAndFilterHandler::None, "fn update (& self , user_id : UserId , params : &UserUpdateParams ,)")] + #[case( + PartOf::RequestExecutor, + format_ident!("Update"), + url_users_with_user_id(), + &referenced_params_type("UserUpdateParams"), + RequestType::Post, + ContextAndFilterHandler::None, + "fn update (& self , user_id : UserId , params : &UserUpdateParams ,)")] #[case( PartOf::RequestBuilder, format_ident!("Update"), @@ -645,6 +687,14 @@ mod tests { RequestType::Post, ContextAndFilterHandler::FilterNoContext, "fn filter_update (& self , user_id : UserId , params : &UserUpdateParams , fields : & [SparseUserField])")] + #[case( + PartOf::RequestExecutor, + format_ident!("Update"), + url_users_with_user_id(), + &referenced_params_type("UserUpdateParams"), + RequestType::Post, + ContextAndFilterHandler::FilterNoContext, + "fn filter_update (& self , user_id : UserId , params : &UserUpdateParams , fields : & [SparseUserField])")] #[case( PartOf::RequestBuilder, format_ident!("List"), @@ -653,6 +703,14 @@ mod tests { RequestType::ContextualGet, ContextAndFilterHandler::NoFilterTakeContextAsFunctionName(WpContext::Edit), "fn list_with_edit_context (& self , params : &UserListParams ,)")] + #[case( + PartOf::RequestExecutor, + format_ident!("List"), + url_static_users(), + &referenced_params_type("UserListParams"), + RequestType::ContextualGet, + ContextAndFilterHandler::NoFilterTakeContextAsFunctionName(WpContext::Edit), + "fn list_with_edit_context (& self , params : &UserListParams ,)")] fn test_fn_signature( #[case] part_of: PartOf, #[case] variant_ident: Ident, @@ -924,6 +982,105 @@ mod tests { ); } + #[rstest] + #[case( + format_ident!("Create"), + url_static_users(), + &referenced_params_type("UserCreateParams"), + RequestType::Post, + ContextAndFilterHandler::None, + "let request = self . request_builder . create (params ,) ;")] + #[case( + format_ident!("Create"), + url_static_users(), + &referenced_params_type("UserCreateParams"), + RequestType::Post, + ContextAndFilterHandler::FilterNoContext, + "let request = self . request_builder . filter_create (params , fields ,) ;")] + #[case( + format_ident!("Delete"), + url_users_with_user_id(), + &referenced_params_type("UserDeleteParams"), + RequestType::Delete, + ContextAndFilterHandler::None, + "let request = self . request_builder . delete (user_id , params ,) ;")] + #[case( + format_ident!("Delete"), + url_users_with_user_id(), + &referenced_params_type("UserDeleteParams"), + RequestType::Delete, + ContextAndFilterHandler::FilterNoContext, + "let request = self . request_builder . filter_delete (user_id , params , fields ,) ;")] + #[case( + format_ident!("DeleteMe"), + url_static_users(), + &referenced_params_type("UserDeleteParams"), + RequestType::Delete, + ContextAndFilterHandler::None, + "let request = self . request_builder . delete_me (params ,) ;")] + #[case( + format_ident!("List"), + url_static_users(), + &referenced_params_type("UserListParams"), + RequestType::ContextualGet, + ContextAndFilterHandler::NoFilterTakeContextAsFunctionName(WpContext::Edit), + "let request = self . request_builder . list_with_edit_context (params ,) ;")] + #[case( + format_ident!("List"), + url_static_users(), + &referenced_params_type("UserListParams"), + RequestType::ContextualGet, + ContextAndFilterHandler::FilterTakeContextAsArgument, + "let request = self . request_builder . filter_list (context , params , fields ,) ;")] + #[case( + format_ident!("Retrieve"), + url_users_with_user_id(), + &ParamsType::new(None), + RequestType::ContextualGet, + ContextAndFilterHandler::NoFilterTakeContextAsFunctionName(WpContext::Embed), + "let request = self . request_builder . retrieve_with_embed_context (user_id ,) ;")] + #[case( + format_ident!("Retrieve"), + url_users_with_user_id(), + &ParamsType::new(None), + RequestType::ContextualGet, + ContextAndFilterHandler::FilterTakeContextAsArgument, + "let request = self . request_builder . filter_retrieve (user_id , context , fields ,) ;")] + #[case( + format_ident!("Update"), + url_users_with_user_id(), + &referenced_params_type("UserUpdateParams"), + RequestType::Post, + ContextAndFilterHandler::None, + "let request = self . request_builder . update (user_id , params ,) ;")] + #[case( + format_ident!("Update"), + url_users_with_user_id(), + &referenced_params_type("UserUpdateParams"), + RequestType::Post, + ContextAndFilterHandler::FilterNoContext, + "let request = self . request_builder . filter_update (user_id , params , fields ,) ;")] + fn test_fn_body_get_request_from_request_builder( + #[case] variant_ident: Ident, + #[case] url_parts: Vec, + #[case] params_type: &ParamsType, + #[case] request_type: RequestType, + #[case] context_and_filter_handler: ContextAndFilterHandler, + #[case] expected_str: &str, + ) { + assert_eq!( + fn_body_get_request_from_request_builder( + &variant_ident, + &url_parts, + params_type, + request_type, + context_and_filter_handler + ) + .to_string(), + expected_str + ); + } + #[rstest::fixture] fn sparse_field_type() -> SparseFieldAttr { SparseFieldAttr { From 4c4c54e7d76937b89851d2d247c9c63c2d760080 Mon Sep 17 00:00:00 2001 From: Oguz Kocer Date: Thu, 20 Jun 2024 16:49:24 -0400 Subject: [PATCH 2/5] Implement contextual output type for request executor --- wp_derive_request_builder/src/generate.rs | 4 +- .../generate/helpers_to_generate_tokens.rs | 37 +++++++++++++++++++ 2 files changed, 39 insertions(+), 2 deletions(-) diff --git a/wp_derive_request_builder/src/generate.rs b/wp_derive_request_builder/src/generate.rs index 79effaf82..01e6171f2 100644 --- a/wp_derive_request_builder/src/generate.rs +++ b/wp_derive_request_builder/src/generate.rs @@ -37,12 +37,12 @@ fn generate_async_request_executor(config: &Config, parsed_enum: &ParsedEnum) -> let functions = parsed_enum.variants.iter().map(|variant| { let url_parts = variant.attr.url_parts.as_slice(); let params_type = &variant.attr.params; - let output_type = TokenStream::from_iter(variant.attr.output.clone().into_iter()); - let output_type = quote! { #output_type }; ContextAndFilterHandler::from_request_type(variant.attr.request_type) .into_iter() .map(|context_and_filter_handler| { + let output_type = + output_type(variant.attr.output.clone(), context_and_filter_handler); let request_from_request_builder = fn_body_get_request_from_request_builder( &variant.variant_ident, url_parts, diff --git a/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs b/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs index ddcc9f5c6..85bea7b00 100644 --- a/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs +++ b/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs @@ -10,6 +10,8 @@ use crate::{ variant_attr::{ParamsType, UrlPart}, }; +const SPARSE_IDENT_PREFIX: &str = "Sparse"; + pub fn endpoint_ident(parsed_enum: &ParsedEnum) -> Ident { format_ident!("{}Endpoint", parsed_enum.enum_ident) } @@ -26,6 +28,41 @@ pub fn request_builder_type(crate_ident: &Ident) -> TokenStream { quote! { std::sync::Arc<#crate_ident::request::RequestBuilder> } } +pub fn output_type( + output_token_tree: Vec, + context_and_filter_handler: ContextAndFilterHandler, +) -> TokenStream { + match context_and_filter_handler { + ContextAndFilterHandler::None + | ContextAndFilterHandler::NoFilterTakeContextAsArgument + | ContextAndFilterHandler::FilterTakeContextAsArgument + | ContextAndFilterHandler::FilterNoContext => { + TokenStream::from_iter(output_token_tree.into_iter()) + } + ContextAndFilterHandler::NoFilterTakeContextAsFunctionName(context) => output_token_tree + .into_iter() + .map(|token| { + if let TokenTree::Ident(ident) = token { + let new_ident = if let Some(ident_without_sparse_prefix) = + ident.to_string().strip_prefix(SPARSE_IDENT_PREFIX) + { + format_ident!( + "{}With{}Context", + ident_without_sparse_prefix, + context.to_string() + ) + } else { + ident + }; + quote! { #new_ident } + } else { + quote! { #token } + } + }) + .collect::(), + } +} + pub fn fn_signature( part_of: PartOf, variant_ident: &Ident, From 3edcdb9589d3b999c30d60eb42cc0a7c631dd2a5 Mon Sep 17 00:00:00 2001 From: Oguz Kocer Date: Thu, 20 Jun 2024 17:26:17 -0400 Subject: [PATCH 3/5] Add unit tests for output type --- .../generate/helpers_to_generate_tokens.rs | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs b/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs index 85bea7b00..eb3b5eebf 100644 --- a/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs +++ b/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs @@ -381,6 +381,7 @@ mod tests { use crate::sparse_field_attr; use super::*; + use quote::ToTokens; use rstest::rstest; use syn::parse_quote; @@ -595,6 +596,41 @@ mod tests { ); } + #[rstest] + #[case(parse_quote!(crate::SparseUser), ContextAndFilterHandler::None, "crate :: SparseUser")] + #[case(parse_quote!(crate::SparseUser), ContextAndFilterHandler::NoFilterTakeContextAsArgument, "crate :: SparseUser")] + #[case( + parse_quote!(crate::SparseUser), + ContextAndFilterHandler::NoFilterTakeContextAsFunctionName(WpContext::Edit), + "crate :: UserWithEditContext" + )] + #[case( + parse_quote!(SparseUser), + ContextAndFilterHandler::NoFilterTakeContextAsFunctionName(WpContext::Embed), + "UserWithEmbedContext" + )] + #[case( + parse_quote!(std::vec::Vec), + ContextAndFilterHandler::NoFilterTakeContextAsFunctionName(WpContext::View), + "std :: vec :: Vec < crate :: UserWithViewContext >" + )] + #[case(parse_quote!(SparseUser), ContextAndFilterHandler::FilterTakeContextAsArgument, "SparseUser")] + #[case(parse_quote!(Vec), ContextAndFilterHandler::FilterNoContext, "Vec < SparseUser >")] + fn test_output_type( + #[case] output_token_stream: TokenStream, + #[case] context_and_filter_handler: ContextAndFilterHandler, + #[case] expected_str: &str, + ) { + assert_eq!( + output_type( + output_token_stream.into_iter().collect(), + context_and_filter_handler + ) + .to_string(), + expected_str + ); + } + #[rstest] #[case( PartOf::Endpoint, From 44d83596cef09b059ae57ee157d29dae731fd0df Mon Sep 17 00:00:00 2001 From: Oguz Kocer Date: Thu, 20 Jun 2024 17:29:19 -0400 Subject: [PATCH 4/5] Remove 'get' attribute from WpDerivedRequest --- wp_derive_request_builder/src/generate.rs | 6 --- .../generate/helpers_to_generate_tokens.rs | 37 +++++++------------ wp_derive_request_builder/src/lib.rs | 3 +- wp_derive_request_builder/src/parse.rs | 1 - wp_derive_request_builder/src/variant_attr.rs | 1 - 5 files changed, 15 insertions(+), 33 deletions(-) diff --git a/wp_derive_request_builder/src/generate.rs b/wp_derive_request_builder/src/generate.rs index 01e6171f2..190d3c1bc 100644 --- a/wp_derive_request_builder/src/generate.rs +++ b/wp_derive_request_builder/src/generate.rs @@ -236,12 +236,6 @@ impl ContextAndFilterHandler { v.push(ContextAndFilterHandler::FilterTakeContextAsArgument); v } - crate::parse::RequestType::Get => { - vec![ - ContextAndFilterHandler::NoFilterTakeContextAsArgument, - ContextAndFilterHandler::FilterTakeContextAsArgument, - ] - } crate::parse::RequestType::Delete | crate::parse::RequestType::Post => { vec![ ContextAndFilterHandler::None, diff --git a/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs b/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs index eb3b5eebf..f0cab415c 100644 --- a/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs +++ b/wp_derive_request_builder/src/generate/helpers_to_generate_tokens.rs @@ -36,9 +36,7 @@ pub fn output_type( ContextAndFilterHandler::None | ContextAndFilterHandler::NoFilterTakeContextAsArgument | ContextAndFilterHandler::FilterTakeContextAsArgument - | ContextAndFilterHandler::FilterNoContext => { - TokenStream::from_iter(output_token_tree.into_iter()) - } + | ContextAndFilterHandler::FilterNoContext => TokenStream::from_iter(output_token_tree), ContextAndFilterHandler::NoFilterTakeContextAsFunctionName(context) => output_token_tree .into_iter() .map(|token| { @@ -107,9 +105,9 @@ pub fn fn_provided_param( // Endpoints don't need the params type if it's a Post request because params will // be part of the body. PartOf::Endpoint => match request_type { - crate::parse::RequestType::ContextualGet - | crate::parse::RequestType::Delete - | crate::parse::RequestType::Get => tokens, + crate::parse::RequestType::ContextualGet | crate::parse::RequestType::Delete => { + tokens + } crate::parse::RequestType::Post => TokenStream::new(), }, PartOf::RequestBuilder | PartOf::RequestExecutor => tokens, @@ -202,9 +200,9 @@ fn fn_arg_provided_params( // Endpoints don't need the params type if it's a Post request because params will // be part of the body. PartOf::Endpoint => match request_type { - crate::parse::RequestType::ContextualGet - | crate::parse::RequestType::Delete - | crate::parse::RequestType::Get => tokens, + crate::parse::RequestType::ContextualGet | crate::parse::RequestType::Delete => { + tokens + } crate::parse::RequestType::Post => TokenStream::new(), }, PartOf::RequestBuilder | PartOf::RequestExecutor => tokens, @@ -261,7 +259,7 @@ pub fn fn_body_get_url_from_endpoint( pub fn fn_body_query_pairs(params_type: &ParamsType, request_type: RequestType) -> TokenStream { match request_type { - RequestType::ContextualGet | RequestType::Delete | RequestType::Get => { + RequestType::ContextualGet | RequestType::Delete => { if let Some(tokens) = params_type.tokens() { let is_option = if let Some(TokenTree::Ident(ref ident)) = tokens.first() { // TODO: This won't work with `std::option::Option` or `core::option::Option` @@ -336,7 +334,7 @@ pub fn fn_body_build_request_from_url( request_type: RequestType, ) -> TokenStream { match request_type { - RequestType::ContextualGet | RequestType::Get => quote! { + RequestType::ContextualGet => quote! { self.request_builder.build_get_request(url) }, RequestType::Delete => quote! { @@ -395,8 +393,8 @@ mod tests { } #[rstest] - #[case(PartOf::Endpoint, &ParamsType::new(None), RequestType::Get, "")] - #[case(PartOf::Endpoint, &ParamsType::new(Some(vec![])), RequestType::Get, "")] + #[case(PartOf::Endpoint, &ParamsType::new(None), RequestType::ContextualGet, "")] + #[case(PartOf::Endpoint, &ParamsType::new(Some(vec![])), RequestType::ContextualGet, "")] #[case( PartOf::Endpoint, &referenced_params_type("UserCreateParams"), @@ -418,13 +416,13 @@ mod tests { #[case( PartOf::Endpoint, &referenced_params_type("UserListParams"), - RequestType::Get, + RequestType::ContextualGet, "params : &UserListParams ," )] #[case( PartOf::Endpoint, &referenced_params_type("UserListParams"), - RequestType::Get, + RequestType::ContextualGet, "params : &UserListParams ," )] fn test_fn_provided_param( @@ -556,14 +554,13 @@ mod tests { } #[rstest] - #[case(PartOf::Endpoint, &ParamsType::new(None), RequestType::Get, "")] + #[case(PartOf::Endpoint, &ParamsType::new(None), RequestType::ContextualGet, "")] #[case(PartOf::Endpoint, &referenced_params_type("UserCreateParams"), RequestType::Post, "")] #[case(PartOf::RequestBuilder, &referenced_params_type("UserCreateParams"), RequestType::Post, "params ,")] #[case(PartOf::RequestExecutor, &referenced_params_type("UserCreateParams"), RequestType::Post, "params ,")] #[case(PartOf::Endpoint, &referenced_params_type("UserListParams"), RequestType::ContextualGet, "params ,")] #[case(PartOf::Endpoint, &referenced_params_type("UserListParams"), RequestType::ContextualGet, "params ,")] #[case(PartOf::Endpoint, &referenced_params_type("UserListParams"), RequestType::Delete, "params ,")] - #[case(PartOf::Endpoint, &referenced_params_type("UserListParams"), RequestType::Get, "params ,")] #[case(PartOf::Endpoint, &referenced_params_type("UserListParams"), RequestType::Post, "")] fn test_fn_arg_provided_params( #[case] part_of: PartOf, @@ -1026,12 +1023,6 @@ mod tests { RequestType::ContextualGet, "self . request_builder . build_get_request (url)" )] - #[case(&ParamsType::new(None), RequestType::Get, "self . request_builder . build_get_request (url)")] - #[case( - &referenced_params_type("UserListParams"), - RequestType::Get, - "self . request_builder . build_get_request (url)" - )] #[case(&ParamsType::new(None), RequestType::Delete, "self . request_builder . build_delete_request (url)")] #[case( &referenced_params_type("UserListParams"), diff --git a/wp_derive_request_builder/src/lib.rs b/wp_derive_request_builder/src/lib.rs index 3fddf1c66..728f1a103 100644 --- a/wp_derive_request_builder/src/lib.rs +++ b/wp_derive_request_builder/src/lib.rs @@ -9,13 +9,12 @@ mod variant_attr; #[proc_macro_derive( WpDerivedRequest, - attributes(SparseField, get, post, delete, contextual_get) + attributes(SparseField, post, delete, contextual_get) )] pub fn derive(input: TokenStream) -> TokenStream { let parsed_enum = parse_macro_input!(input as parse::ParsedEnum); if cfg!(feature = "generate_request_builder") { - //dbg!("{:#?}", parsed_enum.clone()); generate::generate_types(&parsed_enum).into() } else { TokenStream::new() diff --git a/wp_derive_request_builder/src/parse.rs b/wp_derive_request_builder/src/parse.rs index 815591d6f..dbf4c03e7 100644 --- a/wp_derive_request_builder/src/parse.rs +++ b/wp_derive_request_builder/src/parse.rs @@ -56,6 +56,5 @@ impl Parse for ParsedVariant { pub(crate) enum RequestType { ContextualGet, Delete, - Get, Post, } diff --git a/wp_derive_request_builder/src/variant_attr.rs b/wp_derive_request_builder/src/variant_attr.rs index c38f42dd5..1890c5752 100644 --- a/wp_derive_request_builder/src/variant_attr.rs +++ b/wp_derive_request_builder/src/variant_attr.rs @@ -95,7 +95,6 @@ impl ParsedVariantAttribute { match path_segment.ident.to_string().as_str() { "contextual_get" => Ok(RequestType::ContextualGet), "delete" => Ok(RequestType::Delete), - "get" => Ok(RequestType::Get), "post" => Ok(RequestType::Post), _ => build_err(path_segment.ident.span()), } From 75d08140b1f265ef2e60e2126d960f1969748616 Mon Sep 17 00:00:00 2001 From: Oguz Kocer Date: Thu, 20 Jun 2024 17:48:47 -0400 Subject: [PATCH 5/5] Disable filter endpoints for Delete & Post request types --- wp_derive_request_builder/src/generate.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/wp_derive_request_builder/src/generate.rs b/wp_derive_request_builder/src/generate.rs index 190d3c1bc..69d11464d 100644 --- a/wp_derive_request_builder/src/generate.rs +++ b/wp_derive_request_builder/src/generate.rs @@ -237,10 +237,7 @@ impl ContextAndFilterHandler { v } crate::parse::RequestType::Delete | crate::parse::RequestType::Post => { - vec![ - ContextAndFilterHandler::None, - ContextAndFilterHandler::FilterNoContext, - ] + vec![ContextAndFilterHandler::None] } } }