From 05dd59f24b08232bf88864385e43b45a3db8dda7 Mon Sep 17 00:00:00 2001 From: Aiden McClelland Date: Wed, 26 May 2021 15:06:55 -0600 Subject: [PATCH] use absolute crate paths --- .../src/command/build.rs | 133 +++++++++--------- .../src/command/mod.rs | 4 +- .../src/command/parse.rs | 11 +- .../src/rpc_server/build.rs | 18 +-- rpc-toolkit/src/lib.rs | 3 - rpc-toolkit/{src => tests}/test.rs | 20 ++- 6 files changed, 89 insertions(+), 100 deletions(-) rename rpc-toolkit/{src => tests}/test.rs (94%) diff --git a/rpc-toolkit-macro-internals/src/command/build.rs b/rpc-toolkit-macro-internals/src/command/build.rs index f70e5a2..1da941e 100644 --- a/rpc-toolkit-macro-internals/src/command/build.rs +++ b/rpc-toolkit-macro-internals/src/command/build.rs @@ -35,7 +35,7 @@ fn build_app(name: LitStr, opt: &mut Options, params: &mut [ParamType]) -> Token return None; } let name = arg.name.clone().unwrap(); - let name_str = LitStr::new(&name.to_string(), name.span()); + let name_str = arg.rename.clone().unwrap_or_else(|| LitStr::new(&name.to_string(), name.span())); let help = arg.help.clone().into_iter(); let short = arg.short.clone().into_iter(); let long = arg.long.clone().into_iter(); @@ -77,7 +77,7 @@ fn build_app(name: LitStr, opt: &mut Options, params: &mut [ParamType]) -> Token }; Some(quote! { { - let mut arg = rpc_toolkit_prelude::Arg::with_name(#name_str); + let mut arg = ::rpc_toolkit::command_helpers::prelude::Arg::with_name(#name_str); #( arg = arg.help(#help); )* @@ -100,8 +100,8 @@ fn build_app(name: LitStr, opt: &mut Options, params: &mut [ParamType]) -> Token let required = LitBool::new(subcommand_required, Span::call_site()); let alias = &opt.common().aliases; quote! { - pub fn build_app() -> rpc_toolkit_prelude::App<'static, 'static> { - let mut app = rpc_toolkit_prelude::App::new(#name); + pub fn build_app() -> ::rpc_toolkit::command_helpers::prelude::App<'static, 'static> { + let mut app = ::rpc_toolkit::command_helpers::prelude::App::new(#name); #( app = app.about(#about); )* @@ -115,7 +115,7 @@ fn build_app(name: LitStr, opt: &mut Options, params: &mut [ParamType]) -> Token app = app.subcommand(#subcommand::build_app()); )* if #required { - app = app.setting(rpc_toolkit_prelude::AppSettings::SubcommandRequired); + app = app.setting(::rpc_toolkit::command_helpers::prelude::AppSettings::SubcommandRequired); } app } @@ -231,7 +231,10 @@ fn rpc_handler( match param { ParamType::Arg(arg) => { let name = arg.name.clone().unwrap(); - let rename = LitStr::new(&name.to_string(), name.span()); + let rename = arg + .rename + .clone() + .unwrap_or_else(|| LitStr::new(&name.to_string(), name.span())); let field_name = Ident::new(&format!("arg_{}", name), name.span()); let ty = arg.ty.clone(); param_def.push(quote! { @@ -257,14 +260,14 @@ fn rpc_handler( let param_generics = param_generics_filter.finish(); let (_, param_ty_generics, _) = param_generics.split_for_impl(); let param_struct_def = quote! { - #[derive(rpc_toolkit_prelude::Deserialize)] + #[derive(::rpc_toolkit::command_helpers::prelude::Deserialize)] pub struct Params#param_ty_generics { #( #param_def )* #[serde(flatten)] #[serde(default)] - rest: rpc_toolkit_prelude::Value, + rest: ::rpc_toolkit::command_helpers::prelude::Value, } }; let param = params.iter().map(|param| match param { @@ -284,10 +287,10 @@ fn rpc_handler( _ctx: #ctx_ty, method: &str, _args: Params#param_ty_generics, - ) -> Result { - Err(rpc_toolkit_prelude::RpcError { + ) -> Result<::rpc_toolkit::command_helpers::prelude::Value, ::rpc_toolkit::command_helpers::prelude::RpcError> { + Err(::rpc_toolkit::command_helpers::prelude::RpcError { data: Some(method.into()), - ..rpc_toolkit_prelude::yajrc::METHOD_NOT_FOUND_ERROR + ..::rpc_toolkit::command_helpers::prelude::yajrc::METHOD_NOT_FOUND_ERROR }) } }, @@ -298,7 +301,7 @@ fn rpc_handler( } } else if opt.blocking.is_some() { quote! { - rpc_toolkit_prelude::spawn_blocking(move || #fn_path(#(#param),*)).await? + ::rpc_toolkit::command_helpers::prelude::spawn_blocking(move || #fn_path(#(#param),*)).await? } } else { quote! { @@ -312,8 +315,8 @@ fn rpc_handler( ctx: #ctx_ty, method: &str, args: Params#param_ty_generics, - ) -> Result { - Ok(rpc_toolkit_prelude::to_value(#invocation)?) + ) -> Result<::rpc_toolkit::command_helpers::prelude::Value, ::rpc_toolkit::command_helpers::prelude::RpcError> { + Ok(::rpc_toolkit::command_helpers::prelude::to_value(#invocation)?) } } } @@ -328,7 +331,7 @@ fn rpc_handler( } } else if common.blocking.is_some() { quote! { - let ctx = rpc_toolkit_prelude::spawn_blocking(move || #fn_path(#(#param),*)).await?; + let ctx = ::rpc_toolkit::command_helpers::prelude::spawn_blocking(move || #fn_path(#(#param),*)).await?; } } else { quote! { @@ -345,7 +348,7 @@ fn rpc_handler( ), }; quote_spanned!{ subcommand.span() => - [#subcommand::NAME, rest] => #subcommand::#rpc_handler(ctx, rest, rpc_toolkit_prelude::from_value(args.rest)?).await + [#subcommand::NAME, rest] => #subcommand::#rpc_handler(ctx, rest, ::rpc_toolkit::command_helpers::prelude::from_value(args.rest)?).await } }); let subcmd_impl = quote! { @@ -353,9 +356,9 @@ fn rpc_handler( #( #subcmd_impl, )* - _ => Err(rpc_toolkit_prelude::RpcError { + _ => Err(::rpc_toolkit::command_helpers::prelude::RpcError { data: Some(method.into()), - ..rpc_toolkit_prelude::yajrc::METHOD_NOT_FOUND_ERROR + ..::rpc_toolkit::command_helpers::prelude::yajrc::METHOD_NOT_FOUND_ERROR }) } }; @@ -368,7 +371,7 @@ fn rpc_handler( } } else if self_impl.blocking { quote_spanned! { self_impl_fn.span() => - rpc_toolkit_prelude::spawn_blocking(move || #self_impl_fn(ctx)).await? + ::rpc_toolkit::command_helpers::prelude::spawn_blocking(move || #self_impl_fn(ctx)).await? } } else { quote_spanned! { self_impl_fn.span() => @@ -382,11 +385,11 @@ fn rpc_handler( ctx: #ctx_ty, method: &str, args: Params#param_ty_generics, - ) -> Result { + ) -> Result<::rpc_toolkit::command_helpers::prelude::Value, ::rpc_toolkit::command_helpers::prelude::RpcError> { #cmd_preprocess if method.is_empty() { - Ok(rpc_toolkit_prelude::to_value(&#self_impl)?) + Ok(::rpc_toolkit::command_helpers::prelude::to_value(&#self_impl)?) } else { #subcmd_impl } @@ -401,7 +404,7 @@ fn rpc_handler( ctx: #ctx_ty, method: &str, args: Params#param_ty_generics, - ) -> Result { + ) -> Result<::rpc_toolkit::command_helpers::prelude::Value, ::rpc_toolkit::command_helpers::prelude::RpcError> { #cmd_preprocess #subcmd_impl @@ -430,7 +433,7 @@ fn cli_handler( } let mut generics = fn_generics.clone(); generics.params.push(macro_try!(syn::parse2( - quote! { ParentParams: rpc_toolkit_prelude::Serialize } + quote! { ParentParams: ::rpc_toolkit::command_helpers::prelude::Serialize } ))); if generics.lt_token.is_none() { generics.lt_token = Some(Default::default()); @@ -458,7 +461,7 @@ fn cli_handler( } let mut param_generics = param_generics_filter.finish(); param_generics.params.push(macro_try!(syn::parse2(quote! { - ParentParams: rpc_toolkit_prelude::Serialize + ParentParams: ::rpc_toolkit::command_helpers::prelude::Serialize }))); if param_generics.lt_token.is_none() { generics.lt_token = Some(Default::default()); @@ -472,7 +475,10 @@ fn cli_handler( match param { ParamType::Arg(arg) => { let name = arg.name.clone().unwrap(); - let rename = LitStr::new(&name.to_string(), name.span()); + let rename = arg + .rename + .clone() + .unwrap_or_else(|| LitStr::new(&name.to_string(), name.span())); let field_name = Ident::new(&format!("arg_{}", name), name.span()); let ty = arg.ty.clone(); arg_def.push(quote! { @@ -494,7 +500,7 @@ fn cli_handler( }) .map(|arg| { let name = arg.name.clone().unwrap(); - let arg_name = LitStr::new(&name.to_string(), name.span()); + let arg_name = arg.rename.clone().unwrap_or_else(|| LitStr::new(&name.to_string(), name.span())); let field_name = Ident::new(&format!("arg_{}", name), name.span()); if arg.stdin.is_some() { if let Some(parse) = &arg.parse { @@ -503,7 +509,7 @@ fn cli_handler( } } else { quote! { - #field_name: rpc_toolkit_prelude::default_stdin_parser(&mut std::io::stdin(), matches)?, + #field_name: ::rpc_toolkit::command_helpers::prelude::default_stdin_parser(&mut std::io::stdin(), matches)?, } } } else if arg.check_is_present { @@ -521,7 +527,7 @@ fn cli_handler( } } else { quote! { - rpc_toolkit_prelude::default_arg_parser(arg_val, matches) + ::rpc_toolkit::command_helpers::prelude::default_arg_parser(arg_val, matches) } }; if arg.optional { @@ -547,7 +553,7 @@ fn cli_handler( } }); let param_struct_def = quote! { - #[derive(rpc_toolkit_prelude::Serialize)] + #[derive(::rpc_toolkit::command_helpers::prelude::Serialize)] struct Params#param_ty_generics { #( #arg_def @@ -566,9 +572,9 @@ fn cli_handler( let rt_ref = if let Some(rt) = rt.as_mut() { &*rt } else { - rt = Some(rpc_toolkit_prelude::Runtime::new().map_err(|e| rpc_toolkit_prelude::RpcError { + rt = Some(::rpc_toolkit::command_helpers::prelude::Runtime::new().map_err(|e| ::rpc_toolkit::command_helpers::prelude::RpcError { data: Some(format!("{}", e).into()), - ..rpc_toolkit_prelude::yajrc::INTERNAL_ERROR + ..::rpc_toolkit::command_helpers::prelude::yajrc::INTERNAL_ERROR })?); rt.as_ref().unwrap() }; @@ -576,20 +582,20 @@ fn cli_handler( let display = if let Some(display) = &opt.common().display { quote! { #display } } else { - quote! { rpc_toolkit_prelude::default_display } + quote! { ::rpc_toolkit::command_helpers::prelude::default_display } }; match opt { Options::Leaf(opt) if matches!(opt.exec_ctx, ExecutionContext::RpcOnly(_)) => quote! { pub fn cli_handler#generics( _ctx: #ctx_ty, - _rt: Option, - _matches: &rpc_toolkit_prelude::ArgMatches<'_>, - method: rpc_toolkit_prelude::Cow<'_, str>, + _rt: Option<::rpc_toolkit::command_helpers::prelude::Runtime>, + _matches: &::rpc_toolkit::command_helpers::prelude::ArgMatches<'_>, + method: ::rpc_toolkit::command_helpers::prelude::Cow<'_, str>, _parent_params: ParentParams, - ) -> Result<(), rpc_toolkit_prelude::RpcError> { - Err(rpc_toolkit_prelude::RpcError { + ) -> Result<(), ::rpc_toolkit::command_helpers::prelude::RpcError> { + Err(::rpc_toolkit::command_helpers::prelude::RpcError { data: Some(method.into()), - ..rpc_toolkit_prelude::yajrc::METHOD_NOT_FOUND_ERROR + ..::rpc_toolkit::command_helpers::prelude::yajrc::METHOD_NOT_FOUND_ERROR }) } }, @@ -607,23 +613,23 @@ fn cli_handler( quote! { pub fn cli_handler#generics( ctx: #ctx_ty, - mut rt: Option, - matches: &rpc_toolkit_prelude::ArgMatches<'_>, - method: rpc_toolkit_prelude::Cow<'_, str>, + mut rt: Option<::rpc_toolkit::command_helpers::prelude::Runtime>, + matches: &::rpc_toolkit::command_helpers::prelude::ArgMatches<'_>, + method: ::rpc_toolkit::command_helpers::prelude::Cow<'_, str>, parent_params: ParentParams, - ) -> Result<(), rpc_toolkit_prelude::RpcError> { + ) -> Result<(), ::rpc_toolkit::command_helpers::prelude::RpcError> { #param_struct_def #create_rt #[allow(unreachable_code)] let return_ty = if true { - rpc_toolkit_prelude::PhantomData + ::rpc_toolkit::command_helpers::prelude::PhantomData } else { - rpc_toolkit_prelude::make_phantom(#invocation) + ::rpc_toolkit::command_helpers::prelude::make_phantom(#invocation) }; - let res = rt_ref.block_on(rpc_toolkit_prelude::call_remote(ctx, method.as_ref(), params, return_ty))?; + let res = rt_ref.block_on(::rpc_toolkit::command_helpers::prelude::call_remote(ctx, method.as_ref(), params, return_ty))?; Ok(#display(res.result?, matches)) } } @@ -644,7 +650,7 @@ fn cli_handler( } } else { quote! { - rpc_toolkit_prelude::default_display(#invocation, matches) + ::rpc_toolkit::command_helpers::prelude::default_display(#invocation, matches) } }; let rt_action = if opt.is_async { @@ -657,11 +663,11 @@ fn cli_handler( quote! { pub fn cli_handler#generics( ctx: #ctx_ty, - mut rt: Option, - matches: &rpc_toolkit_prelude::ArgMatches<'_>, - _method: rpc_toolkit_prelude::Cow<'_, str>, + mut rt: Option<::rpc_toolkit::command_helpers::prelude::Runtime>, + matches: &::rpc_toolkit::command_helpers::prelude::ArgMatches<'_>, + _method: ::rpc_toolkit::command_helpers::prelude::Cow<'_, str>, _parent_params: ParentParams - ) -> Result<(), rpc_toolkit_prelude::RpcError> { + ) -> Result<(), ::rpc_toolkit::command_helpers::prelude::RpcError> { #rt_action Ok(#display_res) } @@ -757,34 +763,34 @@ fn cli_handler( #[allow(unreachable_code)] let return_ty = if true { - rpc_toolkit_prelude::PhantomData + ::rpc_toolkit::command_helpers::prelude::PhantomData } else { let ctx_new = unreachable!(); - rpc_toolkit_prelude::match_types(&ctx, &ctx_new); + ::rpc_toolkit::command_helpers::prelude::match_types(&ctx, &ctx_new); let ctx = ctx_new; - rpc_toolkit_prelude::make_phantom(#self_impl?) + ::rpc_toolkit::command_helpers::prelude::make_phantom(#self_impl?) }; - let res = rt_ref.block_on(rpc_toolkit_prelude::call_remote(ctx, method.as_ref(), params, return_ty))?; + let res = rt_ref.block_on(::rpc_toolkit::command_helpers::prelude::call_remote(ctx, method.as_ref(), params, return_ty))?; Ok(#display(res.result?, matches)) } } } _ => quote! { - Err(rpc_toolkit_prelude::RpcError { + Err(::rpc_toolkit::command_helpers::prelude::RpcError { data: Some(method.into()), - ..rpc_toolkit_prelude::yajrc::METHOD_NOT_FOUND_ERROR + ..::rpc_toolkit::command_helpers::prelude::yajrc::METHOD_NOT_FOUND_ERROR }), }, }; quote! { pub fn cli_handler#generics( ctx: #ctx_ty, - mut rt: Option, - matches: &rpc_toolkit_prelude::ArgMatches<'_>, - method: rpc_toolkit_prelude::Cow<'_, str>, + mut rt: Option<::rpc_toolkit::command_helpers::prelude::Runtime>, + matches: &::rpc_toolkit::command_helpers::prelude::ArgMatches<'_>, + method: ::rpc_toolkit::command_helpers::prelude::Cow<'_, str>, parent_params: ParentParams, - ) -> Result<(), rpc_toolkit_prelude::RpcError> { + ) -> Result<(), ::rpc_toolkit::command_helpers::prelude::RpcError> { #param_struct_def #cmd_preprocess @@ -813,12 +819,11 @@ pub fn build(args: AttributeArgs, mut item: ItemFn) -> TokenStream { let fn_vis = &item.vis; let fn_name = &item.sig.ident; let fn_generics = &item.sig.generics; - let command_name = opt + let command_name_str = opt .common() .rename .clone() - .unwrap_or_else(|| fn_name.clone()); - let command_name_str = LitStr::new(&command_name.to_string(), command_name.span()); + .unwrap_or_else(|| LitStr::new(&fn_name.to_string(), fn_name.span())); let is_async = LitBool::new( opt.common().is_async, item.sig @@ -834,7 +839,6 @@ pub fn build(args: AttributeArgs, mut item: ItemFn) -> TokenStream { #item #fn_vis mod #fn_name { use super::*; - use rpc_toolkit::command_helpers::prelude as rpc_toolkit_prelude; pub const NAME: &'static str = #command_name_str; pub const ASYNC: bool = #is_async; @@ -846,6 +850,5 @@ pub fn build(args: AttributeArgs, mut item: ItemFn) -> TokenStream { #cli_handler } }; - // panic!("{}", res); res } diff --git a/rpc-toolkit-macro-internals/src/command/mod.rs b/rpc-toolkit-macro-internals/src/command/mod.rs index 39dcf91..35b5a04 100644 --- a/rpc-toolkit-macro-internals/src/command/mod.rs +++ b/rpc-toolkit-macro-internals/src/command/mod.rs @@ -21,7 +21,7 @@ pub struct LeafOptions { is_async: bool, aliases: Vec, about: Option, - rename: Option, + rename: Option, exec_ctx: ExecutionContext, display: Option, } @@ -74,7 +74,7 @@ pub struct ArgOptions { check_is_present: bool, help: Option, name: Option, - rename: Option, + rename: Option, short: Option, long: Option, parse: Option, diff --git a/rpc-toolkit-macro-internals/src/command/parse.rs b/rpc-toolkit-macro-internals/src/command/parse.rs index d0878a9..ffa76b1 100644 --- a/rpc-toolkit-macro-internals/src/command/parse.rs +++ b/rpc-toolkit-macro-internals/src/command/parse.rs @@ -291,10 +291,7 @@ pub fn parse_command_attr(args: AttributeArgs) -> Result { if opt.common().rename.is_some() { return Err(Error::new(rename.span(), "duplicate argument `rename`")); } - opt.common().rename = Some( - syn::parse_str(&rename.value()) - .map_err(|e| Error::new(rename.span(), format!("{}", e)))?, - ); + opt.common().rename = Some(rename); } else { return Err(Error::new(nv.lit.span(), "`rename` must be a string")); } @@ -519,10 +516,7 @@ pub fn parse_arg_attr(attr: Attribute, arg: PatType) -> Result { "duplicate argument `rename`", )); } - opt.rename = Some( - syn::parse_str(&rename.value()) - .map_err(|e| Error::new(rename.span(), format!("{}", e)))?, - ); + opt.rename = Some(rename); } else { return Err(Error::new(nv.lit.span(), "`rename` must be a string")); } @@ -601,7 +595,6 @@ pub fn parse_arg_attr(attr: Attribute, arg: PatType) -> Result { Meta::Path(_) => (), Meta::NameValue(nv) => return Err(Error::new(nv.span(), "`arg` cannot be assigned to")), } - opt.name = opt.name.or(opt.rename.clone()); if opt.name.is_none() { return Err(Error::new( arg_span, diff --git a/rpc-toolkit-macro-internals/src/rpc_server/build.rs b/rpc-toolkit-macro-internals/src/rpc_server/build.rs index 97e814e..d96f034 100644 --- a/rpc-toolkit-macro-internals/src/rpc_server/build.rs +++ b/rpc-toolkit-macro-internals/src/rpc_server/build.rs @@ -15,29 +15,29 @@ pub fn build(args: RpcServerArgs) -> TokenStream { arguments, }); let ctx = args.ctx; - let status_fn = args - .status_fn - .unwrap_or_else(|| syn::parse2(quote! { |_| rpc_toolkit::hyper::StatusCode::OK }).unwrap()); + let status_fn = args.status_fn.unwrap_or_else(|| { + syn::parse2(quote! { |_| ::rpc_toolkit::hyper::StatusCode::OK }).unwrap() + }); quote! { { let ctx = #ctx; let status_fn = #status_fn; - let builder = rpc_toolkit::rpc_server_helpers::make_builder(&ctx); - let make_svc = rpc_toolkit::hyper::service::make_service_fn(move |_| { + let builder = ::rpc_toolkit::rpc_server_helpers::make_builder(&ctx); + let make_svc = ::rpc_toolkit::hyper::service::make_service_fn(move |_| { let ctx = ctx.clone(); async move { - Ok::<_, rpc_toolkit::hyper::Error>(rpc_toolkit::hyper::service::service_fn(move |mut req| { + Ok::<_, ::rpc_toolkit::hyper::Error>(::rpc_toolkit::hyper::service::service_fn(move |mut req| { let ctx = ctx.clone(); async move { - let rpc_req = rpc_toolkit::rpc_server_helpers::make_request(&mut req).await; - rpc_toolkit::rpc_server_helpers::to_response( + let rpc_req = ::rpc_toolkit::rpc_server_helpers::make_request(&mut req).await; + ::rpc_toolkit::rpc_server_helpers::to_response( &req, match rpc_req { Ok(rpc_req) => Ok(( rpc_req.id, #command( ctx, - rpc_toolkit::yajrc::RpcMethod::as_str(&rpc_req.method), + ::rpc_toolkit::yajrc::RpcMethod::as_str(&rpc_req.method), rpc_req.params, ) .await, diff --git a/rpc-toolkit/src/lib.rs b/rpc-toolkit/src/lib.rs index 0091680..962a993 100644 --- a/rpc-toolkit/src/lib.rs +++ b/rpc-toolkit/src/lib.rs @@ -46,6 +46,3 @@ pub use crate::context::Context; pub mod command_helpers; mod context; pub mod rpc_server_helpers; - -#[cfg(test)] -mod test; diff --git a/rpc-toolkit/src/test.rs b/rpc-toolkit/tests/test.rs similarity index 94% rename from rpc-toolkit/src/test.rs rename to rpc-toolkit/tests/test.rs index 21d9318..24faaec 100644 --- a/rpc-toolkit/src/test.rs +++ b/rpc-toolkit/tests/test.rs @@ -2,14 +2,11 @@ use std::fmt::Display; use std::str::FromStr; use std::sync::Arc; -use clap::Arg; -use rpc_toolkit_macro::run_cli; -use serde::{Deserialize, Serialize}; -use url::Host; -use yajrc::RpcError; - -pub use crate as rpc_toolkit; -use crate::{command, rpc_server, Context}; +use rpc_toolkit::clap::Arg; +use rpc_toolkit::serde::{Deserialize, Serialize}; +use rpc_toolkit::url::Host; +use rpc_toolkit::yajrc::RpcError; +use rpc_toolkit::{command, rpc_server, run_cli, Context}; #[derive(Debug, Clone)] pub struct AppState { @@ -91,8 +88,6 @@ fn dothething2 Deserialize<'a> + FromStr, E: Dis async fn test() { use tokio::io::AsyncWriteExt; - use crate as rpc_toolkit; - let seed = Arc::new(ConfigSeed { host: Host::parse("localhost").unwrap(), port: 8000, @@ -103,9 +98,10 @@ async fn test() { .arg("test") .arg("--package") .arg("rpc-toolkit") - .arg("--lib") + .arg("--test") + .arg("test") .arg("--") - .arg("test::cli_test") + .arg("cli_test") .arg("--exact") .arg("--nocapture") .arg("--")