From 8e2318dc779ef45d00fd13765327498cd84ea13b Mon Sep 17 00:00:00 2001 From: vms Date: Thu, 1 Apr 2021 12:11:31 +0300 Subject: [PATCH] housekeeping --- .../{config_worker.rs => config_utils.rs} | 8 +++- .../src/fce_test/glue_code_generator.rs | 24 +++++----- .../fce-test-macro-impl/src/fce_test/mod.rs | 2 +- .../src/fce_test/module_generator.rs | 30 +++++-------- .../module_generator/methods_generator.rs | 44 ++++++++----------- .../module_generator/record_type_generator.rs | 31 ++++++------- 6 files changed, 65 insertions(+), 74 deletions(-) rename crates/fce-test-macro-impl/src/fce_test/{config_worker.rs => config_utils.rs} (85%) diff --git a/crates/fce-test-macro-impl/src/fce_test/config_worker.rs b/crates/fce-test-macro-impl/src/fce_test/config_utils.rs similarity index 85% rename from crates/fce-test-macro-impl/src/fce_test/config_worker.rs rename to crates/fce-test-macro-impl/src/fce_test/config_utils.rs index 6d3ffbc..a8d2fea 100644 --- a/crates/fce-test-macro-impl/src/fce_test/config_worker.rs +++ b/crates/fce-test-macro-impl/src/fce_test/config_utils.rs @@ -22,6 +22,7 @@ use fce_wit_parser::interface::FCEModuleInterface; use std::path::PathBuf; +#[derive(Debug, Clone, PartialEq, Eq)] pub(super) struct Module<'m> { pub name: &'m str, pub interface: FCEModuleInterface, @@ -33,6 +34,7 @@ impl<'m> Module<'m> { } } +/// Returns all modules the provided config consist of. pub(super) fn collect_modules( config: &TomlAppServiceConfig, modules_dir: PathBuf, @@ -67,7 +69,11 @@ fn collect_module_paths( .collect::>() } -pub(super) fn determine_modules_dir( +/// Tries to determine a dir with compiled Wasm modules according to the following +/// - if the modules_dir attribute is specified (by user) it will be chosen, +/// - otherwise if modules_dir is specified in AppService config it will be chosen, +/// - otherwise None will be returned. +pub(super) fn resolve_modules_dir( config: &TomlAppServiceConfig, modules_dir: Option, ) -> Option { diff --git a/crates/fce-test-macro-impl/src/fce_test/glue_code_generator.rs b/crates/fce-test-macro-impl/src/fce_test/glue_code_generator.rs index 3dfef57..3ec6b52 100644 --- a/crates/fce-test-macro-impl/src/fce_test/glue_code_generator.rs +++ b/crates/fce-test-macro-impl/src/fce_test/glue_code_generator.rs @@ -18,6 +18,7 @@ use crate::attributes::FCETestAttributes; use crate::TResult; use crate::TestGeneratorError; use crate::fce_test; +use crate::fce_test::config_utils; use fluence_app_service::TomlAppServiceConfig; use proc_macro2::TokenStream; @@ -89,7 +90,7 @@ use std::path::PathBuf; ///``` /// /// Here [(0), (1)] - module_definitions -/// [(1), (2)] - fce ctor +/// [(1), (2)] - AppService ctor /// [(2), (3)] - ctors of all modules of the tested service /// [(3), (4)] - original test function pub(super) fn generate_test_glue_code( @@ -97,28 +98,29 @@ pub(super) fn generate_test_glue_code( attrs: FCETestAttributes, ) -> TResult { let fce_config = TomlAppServiceConfig::load(&attrs.config_path)?; - let modules_dir = - match fce_test::config_worker::determine_modules_dir(&fce_config, attrs.modules_dir) { - Some(modules_dir) => modules_dir, - None => return Err(TestGeneratorError::ModulesDirUnspecified), - }; + let modules_dir = match config_utils::resolve_modules_dir(&fce_config, attrs.modules_dir) { + Some(modules_dir) => modules_dir, + None => return Err(TestGeneratorError::ModulesDirUnspecified), + }; - let fce_ctor = generate_fce_ctor(&attrs.config_path, &modules_dir); - let module_interfaces = fce_test::config_worker::collect_modules(&fce_config, modules_dir)?; + let app_service_ctor = generate_app_service_ctor(&attrs.config_path, &modules_dir); + let module_interfaces = fce_test::config_utils::collect_modules(&fce_config, modules_dir)?; let module_definitions = fce_test::module_generator::generate_module_definitions(module_interfaces.iter())?; + let module_iter = module_interfaces.iter().map(|module| module.name); let module_ctors = generate_module_ctors(module_iter)?; + let original_block = func_item.block; let signature = func_item.sig; let glue_code = quote! { #[test] #signature { - #module_definitions + #(#module_definitions)* - #fce_ctor + #app_service_ctor #module_ctors @@ -129,7 +131,7 @@ pub(super) fn generate_test_glue_code( Ok(glue_code) } -fn generate_fce_ctor(config_path: &str, modules_dir: &PathBuf) -> TokenStream { +fn generate_app_service_ctor(config_path: &str, modules_dir: &PathBuf) -> TokenStream { let config_path = config_path.to_token_stream(); let modules_dir = modules_dir.to_string_lossy().to_string(); diff --git a/crates/fce-test-macro-impl/src/fce_test/mod.rs b/crates/fce-test-macro-impl/src/fce_test/mod.rs index ed7a3a5..492c7af 100644 --- a/crates/fce-test-macro-impl/src/fce_test/mod.rs +++ b/crates/fce-test-macro-impl/src/fce_test/mod.rs @@ -14,7 +14,7 @@ * limitations under the License. */ -mod config_worker; +mod config_utils; mod fce_test_impl; mod glue_code_generator; mod module_generator; diff --git a/crates/fce-test-macro-impl/src/fce_test/module_generator.rs b/crates/fce-test-macro-impl/src/fce_test/module_generator.rs index 40b2f18..45aeee3 100644 --- a/crates/fce-test-macro-impl/src/fce_test/module_generator.rs +++ b/crates/fce-test-macro-impl/src/fce_test/module_generator.rs @@ -18,11 +18,9 @@ mod methods_generator; mod record_type_generator; use crate::fce_test::utils; -use crate::fce_test::config_worker::Module; +use crate::fce_test::config_utils::Module; use crate::TResult; -use fce_wit_parser::interface::FCEModuleInterface; - use proc_macro2::TokenStream; use quote::quote; @@ -57,25 +55,19 @@ use quote::quote; ///``` pub(super) fn generate_module_definitions<'i>( modules: impl ExactSizeIterator>, -) -> TResult { - let mut module_definitions = Vec::with_capacity(modules.len()); - - for module in modules { - let module_definition = generate_module_definition(&module.name, &module.interface)?; - module_definitions.push(module_definition); - } - - let module_definitions = quote! { #(#module_definitions),*}; - - Ok(module_definitions) +) -> TResult> { + modules + .into_iter() + .map(generate_module_definition) + .collect::, _>>() } -fn generate_module_definition( - module_name: &str, - module_interface: &FCEModuleInterface, -) -> TResult { +fn generate_module_definition(module: &Module<'_>) -> TResult { + let module_name = module.name; let module_name_ident = utils::generate_module_name(module_name)?; let struct_name_ident = utils::generate_struct_name(module_name)?; + + let module_interface = &module.interface; let module_records = record_type_generator::generate_records(&module_interface.record_types)?; let module_functions = methods_generator::generate_module_methods( module_name, @@ -85,7 +77,7 @@ fn generate_module_definition( let module_definition = quote! { pub mod #module_name_ident { - #module_records + #(#module_records)* pub struct #struct_name_ident { fce: std::rc::Rc>, diff --git a/crates/fce-test-macro-impl/src/fce_test/module_generator/methods_generator.rs b/crates/fce-test-macro-impl/src/fce_test/module_generator/methods_generator.rs index 9facb9d..58a4288 100644 --- a/crates/fce-test-macro-impl/src/fce_test/module_generator/methods_generator.rs +++ b/crates/fce-test-macro-impl/src/fce_test/module_generator/methods_generator.rs @@ -30,24 +30,22 @@ pub(super) fn generate_module_methods<'m, 'r>( method_signatures: impl ExactSizeIterator, records: &'r FCERecordTypes, ) -> TResult> { - let mut result = Vec::with_capacity(method_signatures.len()); + method_signatures + .map(|signature| -> TResult { + let func_name = utils::new_ident(&signature.name)?; + let arguments = generate_arguments(signature.arguments.iter(), records)?; + let output_type = generate_output_type(&signature.outputs, records)?; + let fce_call = generate_fce_call(module_name, &signature, records)?; - for signature in method_signatures { - let func_name = utils::new_ident(&signature.name)?; - let arguments = generate_arguments(signature.arguments.iter(), records)?; - let output_type = generate_output_type(&signature.outputs, records)?; - let fce_call = generate_fce_call(module_name, &signature, records)?; + let module_method = quote! { + pub fn #func_name(&mut self, #(#arguments),*) #output_type { + #fce_call + } + }; - let module_method = quote! { - pub fn #func_name(&mut self, #(#arguments),*) #output_type { - #fce_call - } - }; - - result.push(module_method); - } - - Ok(result) + Ok(module_method) + }) + .collect::, _>>() } fn generate_fce_call( @@ -79,20 +77,16 @@ fn generate_fce_call( Ok(function_call) } +/// Generates type convertor to json because of AppService receives them in json. fn generate_arguments_converter<'a>( args: impl ExactSizeIterator, ) -> TResult { - let mut arguments = Vec::with_capacity(args.len()); + let arg_idents: Vec = args.map(utils::new_ident).collect::>()?; - for arg in args { - let arg_ident = utils::new_ident(arg)?; - arguments.push(arg_ident); - } + let args_converter = + quote! { let arguments = fluence_test::internal::json!([#(#arg_idents),*]); }; - let arguments_serializer = - quote! { let arguments = fluence_test::internal::json!([#(#arguments),*]); }; - - Ok(arguments_serializer) + Ok(args_converter) } fn generate_function_call(module_name: &str, method_name: &str) -> TokenStream { diff --git a/crates/fce-test-macro-impl/src/fce_test/module_generator/record_type_generator.rs b/crates/fce-test-macro-impl/src/fce_test/module_generator/record_type_generator.rs index 9fb81dc..32bd833 100644 --- a/crates/fce-test-macro-impl/src/fce_test/module_generator/record_type_generator.rs +++ b/crates/fce-test-macro-impl/src/fce_test/module_generator/record_type_generator.rs @@ -23,40 +23,37 @@ use fce_wit_parser::interface::FCERecordTypes; use proc_macro2::TokenStream; use quote::quote; -pub(super) fn generate_records(records: &FCERecordTypes) -> TResult { +pub(super) fn generate_records(records: &FCERecordTypes) -> TResult> { use std::ops::Deref; - let mut result = TokenStream::new(); - - for (_, record) in records.iter() { + records.iter().map(|(_, record)| -> TResult { let record_name_ident = utils::generate_record_name(&record.name)?; let fields = prepare_field(record.fields.deref().iter(), records)?; - let record = quote! { + let generated_record = quote! { #[derive(Clone, fluence_test::internal::Serialize, fluence_test::internal::Deserialize)] pub struct #record_name_ident { #(#fields),* } }; - result.extend(record); - } - Ok(result) + Ok(generated_record) + } + ).collect::, _>>() } fn prepare_field<'f>( fields: impl ExactSizeIterator, records: &FCERecordTypes, ) -> TResult> { - let mut result = Vec::with_capacity(fields.len()); + fields + .map(|field| -> TResult { + let field_name = utils::new_ident(&field.name)?; + let field_type = utils::itype_to_tokens(&field.ty, records)?; - for field in fields { - let field_name = utils::new_ident(&field.name)?; - let field_type = utils::itype_to_tokens(&field.ty, records)?; + let generated_field = quote! { #field_name: #field_type }; - let field = quote! { #field_name: #field_type }; - result.push(field); - } - - Ok(result) + Ok(generated_field) + }) + .collect::, _>>() }