Use rustfmt (#407)

* Use rustfmt.

* Run rustfmt.

Author: dvc94ch

.travis.yml

@@ -21,9 +21,14 @@ matrix:
   allow_failures:
   - rust: nightly
 
+before_script:
+  - rustup component add rustfmt
+
 script:
   - cargo build --all
   - cargo test --all
+  - |
+    ([ $TRAVIS_RUST_VERSION = stable ] && cargo fmt --all -- --check) || true
 
 after_success: |
   [ $TRAVIS_OS_NAME == 'linux' ] &&

core/examples/async.rs

@@ -1,5 +1,5 @@
-use jsonrpc_core::*;
 use jsonrpc_core::futures::Future;
+use jsonrpc_core::*;
 
 fn main() {
 	let mut io = IoHandler::new();

core/examples/basic.rs

@@ -3,9 +3,7 @@ use jsonrpc_core::*;
 fn main() {
 	let mut io = IoHandler::new();
 
-	io.add_method("say_hello", |_: Params| {
-		Ok(Value::String("Hello World!".to_owned()))
-	});
+	io.add_method("say_hello", |_: Params| Ok(Value::String("Hello World!".to_owned())));
 
 	let request = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
 	let response = r#"{"jsonrpc":"2.0","result":"hello","id":1}"#;

core/examples/meta.rs

@@ -1,5 +1,5 @@
-use jsonrpc_core::*;
 use jsonrpc_core::futures::Future;
+use jsonrpc_core::*;
 
 #[derive(Clone, Default)]
 struct Meta(usize);

core/examples/middlewares.rs

@@ -1,8 +1,8 @@
-use std::time::Instant;
-use std::sync::atomic::{self, AtomicUsize};
-use jsonrpc_core::*;
-use jsonrpc_core::futures::Future;
 use jsonrpc_core::futures::future::Either;
+use jsonrpc_core::futures::Future;
+use jsonrpc_core::*;
+use std::sync::atomic::{self, AtomicUsize};
+use std::time::Instant;
 
 #[derive(Clone, Debug)]
 struct Meta(usize);
@@ -14,9 +14,10 @@ impl Middleware<Meta> for MyMiddleware {
 	type Future = FutureResponse;
 	type CallFuture = middleware::NoopCallFuture;
 
-	fn on_request<F, X>(&self, request: Request, meta: Meta, next: F) -> Either<Self::Future, X> where
+	fn on_request<F, X>(&self, request: Request, meta: Meta, next: F) -> Either<Self::Future, X>
+	where
 		F: FnOnce(Request, Meta) -> X + Send,
-		X: Future<Item=Option<Response>, Error=()> + Send + 'static,
+		X: Future<Item = Option<Response>, Error = ()> + Send + 'static,
 	{
 		let start = Instant::now();
 		let request_number = self.0.fetch_add(1, atomic::Ordering::SeqCst);

core/examples/params.rs

@@ -1,16 +1,16 @@
 use jsonrpc_core::*;
-use serde_derive::{Deserialize};
+use serde_derive::Deserialize;
 
 #[derive(Deserialize)]
 struct HelloParams {
-	name:String,
+	name: String,
 }
 
 fn main() {
 	let mut io = IoHandler::new();
 
 	io.add_method("say_hello", |params: Params| {
-    let parsed: HelloParams = params.parse().unwrap();
+		let parsed: HelloParams = params.parse().unwrap();
 		Ok(Value::String(format!("hello, {}", parsed.name)))
 	});
 

core/src/calls.rs

@@ -1,8 +1,8 @@
+use crate::types::{Error, Params, Value};
+use crate::BoxFuture;
+use futures::{Future, IntoFuture};
 use std::fmt;
 use std::sync::Arc;
-use crate::types::{Params, Value, Error};
-use futures::{Future, IntoFuture};
-use crate::BoxFuture;
 
 /// Metadata trait
 pub trait Metadata: Clone + Send + 'static {}
@@ -54,12 +54,13 @@ impl<T: Metadata> fmt::Debug for RemoteProcedure<T> {
 		match *self {
 			Method(..) => write!(fmt, "<method>"),
 			Notification(..) => write!(fmt, "<notification>"),
-			Alias(ref alias) => write!(fmt, "alias => {:?}", alias)
+			Alias(ref alias) => write!(fmt, "alias => {:?}", alias),
 		}
 	}
 }
 
-impl<F: Send + Sync + 'static, X: Send + 'static, I> RpcMethodSimple for F where
+impl<F: Send + Sync + 'static, X: Send + 'static, I> RpcMethodSimple for F
+where
 	F: Fn(Params) -> I,
 	X: Future<Item = Value, Error = Error>,
 	I: IntoFuture<Item = Value, Error = Error, Future = X>,
@@ -70,15 +71,17 @@ impl<F: Send + Sync + 'static, X: Send + 'static, I> RpcMethodSimple for F where
 	}
 }
 
-impl<F: Send + Sync + 'static> RpcNotificationSimple for F where
+impl<F: Send + Sync + 'static> RpcNotificationSimple for F
+where
 	F: Fn(Params),
 {
 	fn execute(&self, params: Params) {
 		self(params)
 	}
 }
 
-impl<F: Send + Sync + 'static, X: Send + 'static, T, I> RpcMethod<T> for F where
+impl<F: Send + Sync + 'static, X: Send + 'static, T, I> RpcMethod<T> for F
+where
 	T: Metadata,
 	F: Fn(Params, T) -> I,
 	I: IntoFuture<Item = Value, Error = Error, Future = X>,
@@ -89,7 +92,8 @@ impl<F: Send + Sync + 'static, X: Send + 'static, T, I> RpcMethod<T> for F where
 	}
 }
 
-impl<F: Send + Sync + 'static, T> RpcNotification<T> for F where
+impl<F: Send + Sync + 'static, T> RpcNotification<T> for F
+where
 	T: Metadata,
 	F: Fn(Params, T),
 {

core/src/delegates.rs

@@ -1,19 +1,20 @@
 //! Delegate rpc calls
 
-use std::sync::Arc;
 use std::collections::HashMap;
+use std::sync::Arc;
 
-use crate::types::{Params, Value, Error};
 use crate::calls::{Metadata, RemoteProcedure, RpcMethod, RpcNotification};
-use futures::IntoFuture;
+use crate::types::{Error, Params, Value};
 use crate::BoxFuture;
+use futures::IntoFuture;
 
 struct DelegateAsyncMethod<T, F> {
 	delegate: Arc<T>,
 	closure: F,
 }
 
-impl<T, M, F, I> RpcMethod<M> for DelegateAsyncMethod<T, F> where
+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>,
@@ -32,7 +33,8 @@ struct DelegateMethodWithMeta<T, F> {
 	closure: F,
 }
 
-impl<T, M, F, I> RpcMethod<M> for DelegateMethodWithMeta<T, F> where
+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>,
@@ -51,7 +53,8 @@ struct DelegateNotification<T, F> {
 	closure: F,
 }
 
-impl<T, M, F> RpcNotification<M> for DelegateNotification<T, F> where
+impl<T, M, F> RpcNotification<M> for DelegateNotification<T, F>
+where
 	F: Fn(&T, Params) + 'static,
 	F: Send + Sync + 'static,
 	T: Send + Sync + 'static,
@@ -64,15 +67,17 @@ impl<T, M, F> RpcNotification<M> for DelegateNotification<T, F> where
 }
 
 /// A set of RPC methods and notifications tied to single `delegate` struct.
-pub struct IoDelegate<T, M = ()> where
+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
+impl<T, M> IoDelegate<T, M>
+where
 	T: Send + Sync + 'static,
 	M: Metadata,
 {
@@ -91,50 +96,57 @@ impl<T, M> IoDelegate<T, M> where
 	}
 
 	/// Adds async method to the delegate.
-	pub fn add_method<F, I>(&mut self, name: &str, method: F) where
+	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 {
+		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
+	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 {
+		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
+	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 {
+		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
+impl<T, M> Into<HashMap<String, RemoteProcedure<M>>> for IoDelegate<T, M>
+where
 	T: Send + Sync + 'static,
 	M: Metadata,
 {