accedentally ran cargo fmt instead of on one file

client/src/main.rs

@@ -6,7 +6,8 @@ use cursive::{
 	menu::{Item, Tree},
 	traits::Nameable,
 	views::{Dialog, TextView},
-	Cursive, CursiveExt,
+	Cursive,
+	CursiveExt,
 };
 use worker::Worker;
 

client/src/worker.rs

@@ -11,7 +11,12 @@ use tokio::{
 	time::sleep,
 };
 
-use crate::{managers::NetworkManager, worker_message::WorkerMessage, Cursive, TextView};
+use crate::{
+	managers::NetworkManager,
+	worker_message::WorkerMessage,
+	Cursive,
+	TextView,
+};
 
 pub type CursiveSender = CrossSender<Box<dyn FnOnce(&mut Cursive) + Send>>;
 

foundation/src/encryption/mod.rs

@@ -14,14 +14,16 @@ mod test {
 		let key = sha256(b"This is a key");
 		let IV = b"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
-		let encrypter = Crypter::new(Cipher::aes_256_gcm(), Mode::Encrypt, &key, Some(IV));
+		let encrypter =
+			Crypter::new(Cipher::aes_256_gcm(), Mode::Encrypt, &key, Some(IV));
 		let mut ciphertext = vec![0u8; 1024];
 		let cipherlen = encrypter
 			.unwrap()
 			.update(plaintext, ciphertext.as_mut_slice())
 			.unwrap();
 
-		let decrypter = Crypter::new(Cipher::aes_256_gcm(), Mode::Decrypt, &key, Some(IV));
+		let decrypter =
+			Crypter::new(Cipher::aes_256_gcm(), Mode::Decrypt, &key, Some(IV));
 		let mut decrypted = vec![0u8; 1024];
 		decrypter
 			.unwrap()

foundation/src/event/event.rs

@@ -2,7 +2,11 @@ use std::collections::HashMap;
 
 use futures::channel::oneshot::{channel, Receiver, Sender};
 
-use crate::event::{event_result::EventResultBuilder, EventResult, EventResultType};
+use crate::event::{
+	event_result::EventResultBuilder,
+	EventResult,
+	EventResultType,
+};
 
 /// # Eventw
 /// Object that holds details about an event being passed through the application.
@@ -69,7 +73,11 @@ impl<T> EventBuilder<T> {
 		}
 	}
 
-	pub fn add_arg<K: Into<String>, V: Into<String>>(mut self, key: K, value: V) -> Self {
+	pub fn add_arg<K: Into<String>, V: Into<String>>(
+		mut self,
+		key: K,
+		value: V,
+	) -> Self {
 		self.args.insert(key.into(), value.into());
 		self
 	}

foundation/src/event/event_result.rs

@@ -33,7 +33,10 @@ pub struct EventResultBuilder {
 }
 
 impl EventResultBuilder {
-	pub(self) fn new(result_type: EventResultType, sender: Sender<EventResult>) -> Self {
+	pub(self) fn new(
+		result_type: EventResultType,
+		sender: Sender<EventResult>,
+	) -> Self {
 		Self {
 			code: result_type,
 			args: HashMap::default(),

server/src/client_management/chat_manager/actor.rs

@@ -21,7 +21,12 @@ impl ChatManager {
 	}
 
 	// no need for a remove methods because this is a read only system
-	fn add_message(&mut self, _ctx: &mut Context<Self>, id: Uuid, content: String) {
+	fn add_message(
+		&mut self,
+		_ctx: &mut Context<Self>,
+		id: Uuid,
+		content: String,
+	) {
 		println!(
 			"[ChatManager] add_message id: {:?} content: {:?}",
 			id, content
@@ -51,10 +56,16 @@ impl Actor for ChatManager {
 impl Handler<ChatManagerMessage> for ChatManager {
 	type Result = ();
 
-	fn handle(&mut self, msg: ChatManagerMessage, ctx: &mut Self::Context) -> Self::Result {
+	fn handle(
+		&mut self,
+		msg: ChatManagerMessage,
+		ctx: &mut Self::Context,
+	) -> Self::Result {
 		println!("[ChatManager] got message: {:?}", msg);
 		match msg {
-			ChatManagerMessage::AddMessage(id, content) => self.add_message(ctx, id, content),
+			ChatManagerMessage::AddMessage(id, content) => {
+				self.add_message(ctx, id, content)
+			}
 		}
 	}
 }

server/src/client_management/messages.rs

@@ -1,8 +1,8 @@
-use crate::client_management::client::Client;
-use crate::client_management::ClientManager;
 use actix::{Addr, Message, MessageResponse, WeakAddr};
 use uuid::Uuid;
 
+use crate::client_management::{client::Client, ClientManager};
+
 #[derive(Message)]
 #[rtype(result = "()")]
 pub(crate) enum ClientManagerMessage {

server/src/config_manager/config_manager.rs

@@ -155,11 +155,13 @@ impl From<Builder> for ConfigManager {
 				v.port
 					.map(|p| root.insert("Network.Port".to_owned(), Number(p.into())));
 
-				v.name
-					.map(|n| root.insert("Server.Name".to_owned(), ConfigString(n.into())));
+				v.name.map(|n| {
+					root.insert("Server.Name".to_owned(), ConfigString(n.into()))
+				});
 
-				v.owner
-					.map(|o| root.insert("Server.Owner".to_owned(), ConfigString(o.into())));
+				v.owner.map(|o| {
+					root.insert("Server.Owner".to_owned(), ConfigString(o.into()))
+				});
 			});
 		}
 

server/src/config_manager/messages.rs

@@ -1,6 +1,7 @@
-use crate::config_manager::types::ConfigValue;
 use actix::{Message, MessageResponse};
 
+use crate::config_manager::types::ConfigValue;
+
 #[derive(Message, Debug)]
 #[rtype(result = "()")]
 pub enum ConfigManagerOutput {

server/src/config_manager/mod.rs

@@ -9,5 +9,8 @@ mod messages;
 mod types;
 
 pub(crate) use config_manager::ConfigManager;
-pub(crate) use messages::{ConfigManagerDataMessage, ConfigManagerDataResponse};
+pub(crate) use messages::{
+	ConfigManagerDataMessage,
+	ConfigManagerDataResponse,
+};
 pub(crate) use types::ConfigValue;

server/src/config_manager/types.rs

@@ -35,9 +35,9 @@ impl From<ConfigValue> for Value {
 impl From<Value> for ConfigValue {
 	fn from(v: Value) -> Self {
 		match v {
-			Value::Table(dict) => {
-				ConfigValue::Dict(dict.into_iter().map(|(k, v)| (k, v.into())).collect())
-			}
+			Value::Table(dict) => ConfigValue::Dict(
+				dict.into_iter().map(|(k, v)| (k, v.into())).collect(),
+			),
 			Value::Array(arr) => {
 				ConfigValue::Array(arr.into_iter().map(|v| v.into()).collect())
 			}

server/src/main.rs

@@ -11,7 +11,6 @@ pub(crate) mod scripting;
 pub(crate) mod server;
 
 use server::Server;
-
 use tokio::time::{sleep, Duration};
 
 /// The main function

server/src/network/mod.rs

@@ -32,7 +32,11 @@ mod connection_initiator;
 mod listener;
 mod network_manager;
 
-pub(crate) use connection::{Connection, ConnectionMessage, ConnectionObservableOutput};
+pub(crate) use connection::{
+	Connection,
+	ConnectionMessage,
+	ConnectionObservableOutput,
+};
 pub(crate) use connection_initiator::{ConnectionInitiator, InitiatorOutput};
 // use listener::{ListenerMessage, ListenerOutput, NetworkListener};
 pub(crate) use network_manager::{

server/src/network/network_manager/builder.rs

@@ -1,7 +1,10 @@
-use crate::network::network_manager::messages::NetworkOutput;
-use crate::network::NetworkManager;
 use actix::{Actor, Addr, WeakRecipient};
 
+use crate::network::{
+	network_manager::messages::NetworkOutput,
+	NetworkManager,
+};
+
 pub struct Builder {
 	pub(super) delegate: WeakRecipient<NetworkOutput>,
 }

server/src/network/network_manager/messages.rs

@@ -1,8 +1,8 @@
-use crate::network::Connection;
-use actix::Addr;
-use actix::{Message, MessageResponse};
+use actix::{Addr, Message, MessageResponse};
 use foundation::ClientDetails;
 
+use crate::network::Connection;
+
 #[derive(Message, Debug, Ord, PartialOrd, Eq, PartialEq)]
 #[rtype(result = "()")]
 pub enum NetworkMessage {

server/src/scripting/scriptable_client.rs

@@ -1,9 +1,13 @@
-use crate::client_management::client::Client;
-use crate::client_management::client::ClientDataResponse::{Username, Uuid};
-use crate::client_management::client::{ClientDataMessage, ClientDataResponse};
 use actix::Addr;
 use mlua::{Error, UserData, UserDataMethods};
 
+use crate::client_management::client::{
+	Client,
+	ClientDataMessage,
+	ClientDataResponse,
+	ClientDataResponse::{Username, Uuid},
+};
+
 #[derive(Clone)]
 pub(crate) struct ScriptableClient {
 	addr: Addr<Client>,

server/src/scripting/scriptable_network_manager.rs

@@ -1,8 +1,12 @@
-use crate::network::NetworkDataOutput::IsListening;
-use crate::network::{NetworkDataMessage, NetworkManager};
 use actix::Addr;
 use mlua::{Error, UserData, UserDataMethods};
 
+use crate::network::{
+	NetworkDataMessage,
+	NetworkDataOutput::IsListening,
+	NetworkManager,
+};
+
 #[derive(Clone)]
 pub(crate) struct ScriptableNetworkManager {
 	addr: Addr<NetworkManager>,
@@ -11,7 +15,8 @@ pub(crate) struct ScriptableNetworkManager {
 impl UserData for ScriptableNetworkManager {
 	fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
 		methods.add_async_method("Listening", |_lua, obj, ()| async move {
-			let is_listening = obj.addr.send(NetworkDataMessage::IsListening).await.ok();
+			let is_listening =
+				obj.addr.send(NetworkDataMessage::IsListening).await.ok();
 			if let Some(IsListening(is_listening)) = is_listening {
 				Ok(is_listening)
 			} else {

server/src/server/builder.rs

@@ -1,6 +1,7 @@
-use super::*;
 use actix::{Actor, Addr};
 
+use super::*;
+
 pub struct ServerBuilder {
 	pub(super) name: String,
 	pub(super) owner: String,

server/src/server/messages.rs

@@ -1,7 +1,7 @@
-use crate::client_management::ClientManager;
-use crate::network::NetworkManager;
 use actix::{Addr, Message, MessageResponse};
 
+use crate::{client_management::ClientManager, network::NetworkManager};
+
 #[derive(Message, Clone)]
 #[rtype(result = "ServerDataResponse")]
 pub enum ServerDataMessage {