cargo fmt

Author: soerenmeier

lafere-api-codegen/src/api.rs

@@ -1,7 +1,7 @@
+use crate::ApiArgs;
 use crate::util::{
 	lafere_api_crate, ref_type, validate_inputs, validate_signature,
 };
-use crate::ApiArgs;
 
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};

lafere-api-codegen/src/args.rs

@@ -2,10 +2,9 @@ use syn::parse::{Parse, ParseStream, Result};
 
 use syn::Type;
 
-
 #[derive(Clone)]
 pub(crate) struct ApiArgs {
-	pub ty: Type
+	pub ty: Type,
 }
 
 impl Parse for ApiArgs {
@@ -14,4 +13,4 @@ impl Parse for ApiArgs {
 
 		Ok(Self { ty })
 	}
-}
+}

lafere-api-codegen/src/lib.rs

@@ -1,13 +1,13 @@
-mod args;
+mod action;
 mod api;
+mod args;
 mod message;
-mod action;
 mod util;
 
 use args::ApiArgs;
 
 use proc_macro::TokenStream;
-use syn::{parse_macro_input, ItemFn, DeriveInput};
+use syn::{DeriveInput, ItemFn, parse_macro_input};
 
 /*
 #[api(Request)]
@@ -28,7 +28,6 @@ pub fn api(attrs: TokenStream, item: TokenStream) -> TokenStream {
 		.into()
 }
 
-
 /*
 #[derive(IntoMessage)]
 #[message(json)]
@@ -58,4 +57,4 @@ pub fn derive_action(input: TokenStream) -> TokenStream {
 	action::expand(input)
 		.unwrap_or_else(|e| e.to_compile_error())
 		.into()
-}
+}

lafere-api-codegen/src/message.rs

@@ -1,7 +1,7 @@
 use crate::util::lafere_api_crate;
 
 use proc_macro2::{Span, TokenStream};
-use quote::{quote, ToTokens};
+use quote::{ToTokens, quote};
 use syn::{
 	Attribute, DeriveInput, Error, Generics, Ident, TypeGenerics, WhereClause,
 };

lafere-api-codegen/src/util.rs

@@ -1,8 +1,8 @@
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
-use syn::{punctuated, Error, FnArg, Result, Signature, Type, TypeReference};
+use syn::{Error, FnArg, Result, Signature, Type, TypeReference, punctuated};
 
-use proc_macro_crate::{crate_name, FoundCrate};
+use proc_macro_crate::{FoundCrate, crate_name};
 
 pub(crate) fn validate_signature(sig: &Signature) -> Result<()> {
 	if let Some(con) = &sig.constness {
@@ -45,7 +45,7 @@ pub(crate) fn validate_inputs(
 	for fn_arg in inputs {
 		let ty = match fn_arg {
 			FnArg::Receiver(r) => {
-				return Err(Error::new_spanned(r, "self not allowed"))
+				return Err(Error::new_spanned(r, "self not allowed"));
 			}
 			FnArg::Typed(t) => t.ty.clone(),
 		};

lafere-api/src/encdec.rs

@@ -5,7 +5,7 @@ pub mod json {
 	use crate::message::{Action, Message, PacketBytes};
 	use bytes::BytesRead;
 
-	use serde::{de::DeserializeOwned, Serialize};
+	use serde::{Serialize, de::DeserializeOwned};
 
 	pub fn encode<T, A, B>(value: T) -> Result<Message<A, B>, MessageError>
 	where

lafere-api/src/server.rs

@@ -439,7 +439,7 @@ mod json_tests {
 	use crate::error;
 	use crate::message;
 	use crate::request::Request;
-	use codegen::{api, FromMessage, IntoMessage};
+	use codegen::{FromMessage, IntoMessage, api};
 
 	use std::fmt;
 

lafere-api/tests/advanced.rs

@@ -16,10 +16,10 @@ mod api {
 	use serde::{Deserialize, Serialize};
 
 	use lafere_api::{
+		Action, FromMessage, IntoMessage,
 		error::{ApiError, MessageError, RequestError},
 		message::{FromMessage, IntoMessage, Message, PacketBytes},
 		request::Request,
-		Action, FromMessage, IntoMessage,
 	};
 
 	#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Action)]

lafere-api/tests/complete.rs

@@ -16,9 +16,9 @@ mod api {
 	use serde::{Deserialize, Serialize};
 
 	use lafere_api::{
+		Action, FromMessage, IntoMessage,
 		error::{ApiError, MessageError, RequestError},
 		request::Request,
-		Action, FromMessage, IntoMessage,
 	};
 
 	#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Action)]

lafere/src/client.rs

@@ -1,35 +1,33 @@
-use crate::plain;
-use crate::error::{TaskError, RequestError};
+use crate::error::{RequestError, TaskError};
 use crate::handler::{
-	TaskHandle, client::Sender, StreamSender, StreamReceiver, Configurator
+	Configurator, StreamReceiver, StreamSender, TaskHandle, client::Sender,
 };
 use crate::packet::{Packet, PlainBytes};
-use crate::util::{PinnedFuture, ByteStream};
+use crate::plain;
+use crate::util::{ByteStream, PinnedFuture};
 
 #[cfg(feature = "encrypted")]
 use crate::{encrypted, packet::EncryptedBytes};
 #[cfg(feature = "encrypted")]
 use crypto::signature as sign;
 
-use std::time::Duration;
 use std::io;
-
+use std::time::Duration;
 
 #[derive(Debug, Clone)]
 pub struct Config {
 	pub timeout: Duration,
 	/// if the limit is 0 there is no limit
-	pub body_limit: u32
+	pub body_limit: u32,
 }
 
 /// Reconnection strategy
-/// 
+///
 /// You should probably add a timeout before reconnecting
 pub struct ReconStrat<S> {
 	// async fn(error_count: usize) -> io::Result<S>
-	pub(crate) inner: Box<
-		dyn FnMut(usize) -> PinnedFuture<'static, io::Result<S>> + Send
-	>
+	pub(crate) inner:
+		Box<dyn FnMut(usize) -> PinnedFuture<'static, io::Result<S>> + Send>,
 }
 
 impl<S> ReconStrat<S> {
@@ -38,30 +36,30 @@ impl<S> ReconStrat<S> {
 	/// async fn new_stream(error_count: usize) -> io::Result<S>;
 	/// ```
 	pub fn new<F: 'static>(f: F) -> Self
-	where F: FnMut(usize) -> PinnedFuture<'static, io::Result<S>> + Send {
-		Self {
-			inner: Box::new(f)
-		}
+	where
+		F: FnMut(usize) -> PinnedFuture<'static, io::Result<S>> + Send,
+	{
+		Self { inner: Box::new(f) }
 	}
 }
 
 /// A connection to a server
 pub struct Connection<P> {
 	sender: Sender<P>,
-	task: TaskHandle
+	task: TaskHandle,
 }
 
 impl<P> Connection<P> {
 	/// Creates a new connection to a server with an existing stream
 	pub fn new<S>(
 		byte_stream: S,
 		cfg: Config,
-		recon_strat: Option<ReconStrat<S>>
+		recon_strat: Option<ReconStrat<S>>,
 	) -> Self
 	where
 		S: ByteStream,
 		P: Packet<PlainBytes> + Send + 'static,
-		P::Header: Send
+		P::Header: Send,
 	{
 		plain::client(byte_stream, cfg, recon_strat)
 	}
@@ -73,12 +71,12 @@ impl<P> Connection<P> {
 		byte_stream: S,
 		cfg: Config,
 		recon_strat: Option<ReconStrat<S>>,
-		sign: sign::PublicKey
+		sign: sign::PublicKey,
 	) -> Self
 	where
 		S: ByteStream,
 		P: Packet<EncryptedBytes> + Send + 'static,
-		P::Header: Send
+		P::Header: Send,
 	{
 		encrypted::client(byte_stream, cfg, recon_strat, sign)
 	}
@@ -101,7 +99,7 @@ impl<P> Connection<P> {
 
 	/// Send a request waiting until a response is available or the connection
 	/// closes
-	/// 
+	///
 	/// ## Errors
 	/// - Writing the packet failed
 	/// - Reading the response packet failed
@@ -113,15 +111,15 @@ impl<P> Connection<P> {
 	/// Create a new stream to send packets.
 	pub async fn request_sender(
 		&self,
-		packet: P
+		packet: P,
 	) -> Result<StreamSender<P>, RequestError> {
 		self.sender.request_sender(packet).await
 	}
 
 	/// Opens a new stream to listen to packets.
 	pub async fn request_receiver(
 		&self,
-		packet: P
+		packet: P,
 	) -> Result<StreamReceiver<P>, RequestError> {
 		self.sender.request_receiver(packet).await
 	}
@@ -141,4 +139,4 @@ impl<P> Connection<P> {
 	pub async fn close(self) -> Result<(), TaskError> {
 		self.task.close().await
 	}
-}
+}