Use procedural macros

Cargo.toml

@@ -4,6 +4,7 @@ members = [
 	"http",
 	"ipc",
 	"macros",
+	"derive",
 	"minihttp",
 	"pubsub",
 	"pubsub/more-examples",

README.md

@@ -18,7 +18,8 @@ Transport-agnostic `core` and transport servers for `http`, `ipc`, `websockets`
 - [jsonrpc-tcp-server](./tcp) [![crates.io][tcp-server-image]][tcp-server-url]
 - [jsonrpc-ws-server](./ws)
 - [jsonrpc-stdio-server](./stdio)
-- [jsonrpc-macros](./macros) [![crates.io][macros-image]][macros-url]
+- [jsonrpc-macros](./macros) [![crates.io][macros-image]][macros-url] *deprecated:* use `derive` instead
+- [jsonrpc-derive](./derive)
 - [jsonrpc-server-utils](./server-utils) [![crates.io][server-utils-image]][server-utils-url]
 - [jsonrpc-pubsub](./pubsub) [![crates.io][pubsub-image]][pubsub-url]
 
@@ -38,7 +39,8 @@ Transport-agnostic `core` and transport servers for `http`, `ipc`, `websockets`
 ## Examples
 
 - [core](./core/examples)
-- [macros](./macros/examples)
+- [derive](./derive/examples)
+- [macros](./macros/examples) *deprecated*
 - [pubsub](./pubsub/examples)
 
 ### Basic Usage (with HTTP transport)
@@ -65,21 +67,17 @@ fn main() {
 }
 ```
 
-### Basic usage with macros
+### Basic usage with derive
 
 ```rust
-extern crate jsonrpc_core;
-#[macro_use]
-extern crate jsonrpc_macros;
-
 use jsonrpc_core::Result;
+use jsonrpc_derive::rpc;
 
-build_rpc_trait! {
-	pub trait Rpc {
-		/// Adds two numbers and returns a result
-		#[rpc(name = "add")]
-		fn add(&self, u64, u64) -> Result<u64>;
-	}
+#[rpc]
+pub trait Rpc {
+	/// Adds two numbers and returns a result
+	#[rpc(name = "add")]
+	fn add(&self, u64, u64) -> Result<u64>;
 }
 
 pub struct RpcImpl;
@@ -89,7 +87,6 @@ impl Rpc for RpcImpl {
 	}
 }
 
-
 fn main() {
 	let mut io = jsonrpc_core::IoHandler::new();
 	io.extend_with(RpcImpl.to_delegate())

core/Cargo.toml

@@ -4,7 +4,7 @@ homepage = "https://github.com/paritytech/jsonrpc"
 repository = "https://github.com/paritytech/jsonrpc"
 license = "MIT"
 name = "jsonrpc-core"
-version = "9.0.0"
+version = "10.0.0"
 authors = ["debris <[email protected]>"]
 keywords = ["jsonrpc", "json-rpc", "json", "rpc", "serde"]
 documentation = "https://paritytech.github.io/jsonrpc/jsonrpc_core/index.html"

core/src/delegates.rs

@@ -0,0 +1,144 @@
+//! Delegate rpc calls
+
+use std::sync::Arc;
+use std::collections::HashMap;
+
+use types::{Params, Value, Error};
+use calls::{Metadata, RemoteProcedure, RpcMethod, RpcNotification};
+use futures::IntoFuture;
+use BoxFuture;
+
+struct DelegateAsyncMethod<T, F> {
+	delegate: Arc<T>,
+	closure: F,
+}
+
+impl<T, M, F, I> RpcMethod<M> for DelegateAsyncMethod<T, F> where
+	M: Metadata,
+	F: Fn(&T, Params) -> I,
+	I: IntoFuture<Item = Value, Error = Error>,
+	T: Send + Sync + 'static,
+	F: Send + Sync + 'static,
+	I::Future: Send + 'static,
+{
+	fn call(&self, params: Params, _meta: M) -> BoxFuture<Value> {
+		let closure = &self.closure;
+		Box::new(closure(&self.delegate, params).into_future())
+	}
+}
+
+struct DelegateMethodWithMeta<T, F> {
+	delegate: Arc<T>,
+	closure: F,
+}
+
+impl<T, M, F, I> RpcMethod<M> for DelegateMethodWithMeta<T, F> where
+	M: Metadata,
+	F: Fn(&T, Params, M) -> I,
+	I: IntoFuture<Item = Value, Error = Error>,
+	T: Send + Sync + 'static,
+	F: Send + Sync + 'static,
+	I::Future: Send + 'static,
+{
+	fn call(&self, params: Params, meta: M) -> BoxFuture<Value> {
+		let closure = &self.closure;
+		Box::new(closure(&self.delegate, params, meta).into_future())
+	}
+}
+
+struct DelegateNotification<T, F> {
+	delegate: Arc<T>,
+	closure: F,
+}
+
+impl<T, M, F> RpcNotification<M> for DelegateNotification<T, F> where
+	F: Fn(&T, Params) + 'static,
+	F: Send + Sync + 'static,
+	T: Send + Sync + 'static,
+	M: Metadata,
+{
+	fn execute(&self, params: Params, _meta: M) {
+		let closure = &self.closure;
+		closure(&self.delegate, params)
+	}
+}
+
+/// A set of RPC methods and notifications tied to single `delegate` struct.
+pub struct IoDelegate<T, M = ()> where
+	T: Send + Sync + 'static,
+	M: Metadata,
+{
+	delegate: Arc<T>,
+	methods: HashMap<String, RemoteProcedure<M>>,
+}
+
+impl<T, M> IoDelegate<T, M> where
+	T: Send + Sync + 'static,
+	M: Metadata,
+{
+	/// Creates new `IoDelegate`
+	pub fn new(delegate: Arc<T>) -> Self {
+		IoDelegate {
+			delegate: delegate,
+			methods: HashMap::new(),
+		}
+	}
+
+	/// Adds an alias to existing method.
+	/// NOTE: Aliases are not transitive, i.e. you cannot create alias to an alias.
+	pub fn add_alias(&mut self, from: &str, to: &str) {
+		self.methods.insert(from.into(), RemoteProcedure::Alias(to.into()));
+	}
+
+	/// Adds async method to the delegate.
+	pub fn add_method<F, I>(&mut self, name: &str, method: F) where
+		F: Fn(&T, Params) -> I,
+		I: IntoFuture<Item = Value, Error = Error>,
+		F: Send + Sync + 'static,
+		I::Future: Send + 'static,
+	{
+		self.methods.insert(name.into(), RemoteProcedure::Method(Arc::new(
+			DelegateAsyncMethod {
+				delegate: self.delegate.clone(),
+				closure: method,
+			}
+		)));
+	}
+
+	/// Adds async method with metadata to the delegate.
+	pub fn add_method_with_meta<F, I>(&mut self, name: &str, method: F) where
+		F: Fn(&T, Params, M) -> I,
+		I: IntoFuture<Item = Value, Error = Error>,
+		F: Send + Sync + 'static,
+		I::Future: Send + 'static,
+	{
+		self.methods.insert(name.into(), RemoteProcedure::Method(Arc::new(
+			DelegateMethodWithMeta {
+				delegate: self.delegate.clone(),
+				closure: method,
+			}
+		)));
+	}
+
+	/// Adds notification to the delegate.
+	pub fn add_notification<F>(&mut self, name: &str, notification: F) where
+		F: Fn(&T, Params),
+		F: Send + Sync + 'static,
+	{
+		self.methods.insert(name.into(), RemoteProcedure::Notification(Arc::new(
+			DelegateNotification {
+				delegate: self.delegate.clone(),
+				closure: notification,
+			}
+		)));
+	}
+}
+
+impl<T, M> Into<HashMap<String, RemoteProcedure<M>>> for IoDelegate<T, M> where
+	T: Send + Sync + 'static,
+	M: Metadata,
+{
+	fn into(self) -> HashMap<String, RemoteProcedure<M>> {
+		self.methods
+	}
+}

core/src/lib.rs

@@ -37,6 +37,7 @@ mod io;
 
 pub mod middleware;
 pub mod types;
+pub mod delegates;
 
 /// A `Future` trait object.
 pub type BoxFuture<T> = Box<futures::Future<Item = T, Error = Error> + Send>;
@@ -45,6 +46,7 @@ pub type BoxFuture<T> = Box<futures::Future<Item = T, Error = Error> + Send>;
 pub type Result<T> = ::std::result::Result<T, Error>;
 
 pub use calls::{RemoteProcedure, Metadata, RpcMethodSimple, RpcMethod, RpcNotificationSimple, RpcNotification};
+pub use delegates::IoDelegate;
 pub use io::{Compatibility, IoHandler, MetaIoHandler, FutureOutput, FutureResult, FutureResponse, FutureRpcResult};
 pub use middleware::{Middleware, Noop as NoopMiddleware};
 pub use types::*;

core/src/types/error.rs

@@ -1,4 +1,5 @@
 //! jsonrpc errors
+use std::fmt;
 use serde::de::{Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
 use super::Value;
@@ -124,6 +125,18 @@ impl Error {
 		}
 	}
 
+	/// Creates `InvalidParams` for given parameter, with details.
+	pub fn invalid_params_with_details<M, T>(message: M, details: T) -> Error where
+		M: Into<String>,
+		T: fmt::Debug
+	{
+		Error {
+			code: ErrorCode::InvalidParams,
+			message: format!("Invalid parameters: {}", message.into()),
+			data: Some(Value::String(format!("{:?}", details))),
+		}
+	}
+
 	/// Creates new `InternalError`
 	pub fn internal_error() -> Self {
 		Self::new(ErrorCode::InternalError)

core/src/types/params.rs

@@ -31,6 +31,15 @@ impl Params {
 			Error::invalid_params(format!("Invalid params: {}.", e))
 		})
 	}
+
+	/// Check for no params, returns Err if any params
+	pub fn expect_no_params(self) -> Result<(), Error> {
+		match self {
+			Params::None => Ok(()),
+			Params::Array(ref v) if v.is_empty() => Ok(()),
+			p => Err(Error::invalid_params_with_details("No parameters were expected", p)),
+		}
+	}
 }
 
 #[cfg(test)]
@@ -75,4 +84,10 @@ mod tests {
 		assert_eq!(err2.message, "Invalid params: invalid length 2, expected a tuple of size 3.");
 		assert_eq!(err2.data, None);
 	}
+
+	#[test]
+	fn single_param_parsed_as_tuple() {
+		let params: (u64,) = Params::Array(vec![Value::from(1)]).parse().unwrap();
+		assert_eq!(params, (1,));
+	}
 }

derive/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "jsonrpc-derive"
+version = "10.0.0"
+authors = ["Parity Technologies <[email protected]>"]
+edition = "2018"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "^0.15.22", features = ["full", "extra-traits", "visit", "fold"] }
+proc-macro2 = "0.4"
+quote = "0.6"
+
+[dev-dependencies]
+jsonrpc-core = { version = "10.0", path = "../core" }
+jsonrpc-pubsub = { version = "10.0", path = "../pubsub" }
+jsonrpc-tcp-server = { version = "10.0", path = "../tcp" }
+serde = "1.0"
+serde_derive = "1.0"
+serde_json = "1.0"
+compiletest_rs = { version = "*", features = ["stable"] }

derive/examples/generic-trait-bounds.rs

@@ -0,0 +1,61 @@
+use serde_derive::{Serialize, Deserialize};
+
+use jsonrpc_core::{IoHandler, Error, Result};
+use jsonrpc_core::futures::future::{self, FutureResult};
+use jsonrpc_derive::rpc;
+
+// One is both parameter and a result so requires both Serialize and DeserializeOwned
+// Two is only a parameter so only requires DeserializeOwned
+// Three is only a result so only requires Serialize
+#[rpc]
+pub trait Rpc<One, Two, Three>
+{
+	/// Get One type.
+	#[rpc(name = "getOne")]
+	fn one(&self) -> Result<One>;
+
+	/// Adds two numbers and returns a result
+	#[rpc(name = "setTwo")]
+	fn set_two(&self, _: Two) -> Result<()>;
+
+	#[rpc(name = "getThree")]
+	fn get_three(&self) -> Result<Three>;
+
+	/// Performs asynchronous operation
+	#[rpc(name = "beFancy")]
+	fn call(&self, _: One) -> FutureResult<(One, u64), Error>;
+}
+
+struct RpcImpl;
+
+#[derive(Serialize, Deserialize)]
+struct InAndOut { foo: u64 }
+#[derive(Deserialize)]
+struct In {}
+#[derive(Serialize)]
+struct Out {}
+
+impl Rpc<InAndOut, In, Out> for RpcImpl {
+	fn one(&self) -> Result<InAndOut> {
+		Ok(InAndOut { foo: 1u64 })
+	}
+
+	fn set_two(&self, _x: In) -> Result<()> {
+		Ok(())
+	}
+
+	fn get_three(&self) -> Result<Out> {
+		Ok(Out {})
+	}
+
+	fn call(&self, num: InAndOut) -> FutureResult<(InAndOut, u64), Error> {
+		crate::future::finished((InAndOut {foo: num.foo + 999}, num.foo))
+	}
+}
+
+fn main() {
+	let mut io = IoHandler::new();
+
+	io.extend_with(Rpc::to_delegate(RpcImpl));
+}
+