Use procedural macros (#340)

* Empty rpc trait with proc macro attribute

* Generate skeleton to_delegate method

* Move delegates to core - is this the right place

* WIP: wrap rpc methods in to_delegate

* Generate basic to_delegate

* Add derive examples and tests

* Add async rpc method example

* Fix extern crate hygiene

* Add where clause bounds to to_delegate function

* WIP: Support one way serialisation for generics

* Add Serialize bounds to generic RPC return types

* Add Serialize bounds for RPC args

* Clean up imports

* Refactor and read aliases from rpc trait

* Wire up aliases

* Derive rpc with metadata associated type

* Refactor

* Rename trait level attribute to rpc

* Refactor: move entry point function into lib

* WIP: implement pubsub

* Implement pubsub macro

* Register pub/sub method aliases

* Remove delegates file prematurely copied to core

* Fix TCP tests?

* Inline rpc method registration

Removes need for Wrap* types

* Extract return type when creating RpcMethod

* Handle methods with no params

* WIP: Add support for optional trailing params

* Handle optional trailing params

* Bring back aliases

* Inline into_future to remove extraneous types/fns

* Refactor extra args for use in pubsub

* WIP: migrate pubsub delegate registration

* Extract special args from delegate

* Register sub/unsub using generated delgate closure

* WIP: move macro delegates to core and pubsub

* WIP: refactor to handle subscription method

* Handle pubsub error

* Add pub/sub IoDelegate

* Refactor and fix pubsub compiler errors

* Restore original delegates file and fix auto_args

I've copied and split the delegates file into core and pubsub for use
with proc macros, was originally reusing it in classic macros but
putting it back

* Wrap subscriber in typed subscriber

* Handle pubsub unsubscribe method

* Uncomment pubsub example

* Unsubscribe optional metadata

* Copy macro tests over and make them compile with derive

* Fix pubsub trailing test

* Rename to_delegate

* Remove errant printlns

* Copy and modify module docs from macros

* Fix derive doc test

* Mark subscribe/unsubscribe methods with attribute

* Generic type param with metadata example, update some error messages

* Refactor: extract a couple of functions for readability

* Add compiletests to test compile errors

* Remove test both for now

* Remove top level future imports

* Fix unsubscribe missing import

* Correct derive crate author

* Rust 2018: cargo fix --edition --package jsonrpc-derive

* Remove redundant `extern crate` rust 2018

* Fix doc tests for edition 2018

* Add missing_docs warning

* Replace &str to_string() with into()

* Move all magic strings to constants

* WIP

* Bring pubsub methods back into same trait

* Geoup pubsub methods by subscription name

* Refactor attribute parsing

* Update compilefail tests for new pubsub

* Fix combined rpc and pubsub trait

* Fix compilefail tests

* added some tests (failing)

* Remove multiple trailing params tests, will implement in later PR

* Fix parse of single param tuple with trailing comma

* Specify subscription name in missing annotation error

* Add tests for trailing args

* Handle single trailing param

* Replace extern crates in macro output

* Reduce recursion limit

* Add comment for `to_delegate` trait method

* Deprecate `to_delegate` method generated by jsonrpc-macros

* Update README with derive example

* Add pubsub example and rpc attribute docs

* Remove commented out code

* Bump major version

Author: ascjones

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));
+}
+