uhh... changes and formatting

client/src/main.rs

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

client/src/managers/message.rs

@@ -41,8 +41,7 @@ impl PartialEq for NetworkManagerMessage {
 					server_name: other_name,
 				} = other
 				{
-					return server_owner == other_owner
-						&& server_name == other_name;
+					return server_owner == other_owner && server_name == other_name;
 				}
 				false
 			}

client/src/worker.rs

@@ -11,12 +11,7 @@ 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/connection.rs

@@ -26,10 +26,7 @@ impl Connection {
 		})
 	}
 
-	pub async fn connect<T: ToSocketAddrs>(
-		&self,
-		host: T,
-	) -> Result<(), Error> {
+	pub async fn connect<T: ToSocketAddrs>(&self, host: T) -> Result<(), Error> {
 		let connection = TcpStream::connect(host).await?;
 		let (rd, wd) = io::split(connection);
 

foundation/src/encryption/mod.rs

@@ -14,16 +14,14 @@ 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,11 +2,7 @@ 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.
@@ -73,11 +69,7 @@ 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,10 +33,7 @@ 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(),
@@ -50,7 +47,8 @@ impl EventResultBuilder {
 	}
 
 	pub fn send(self) {
-		self.sender
+		self
+			.sender
 			.send(EventResult {
 				code: self.code,
 				args: self.args,

rustfmt.toml

@@ -1,7 +1,8 @@
+max_width = 90
 hard_tabs = true
-max_width = 80
-imports_indent = "Block"
+tab_spaces = 2
 imports_layout = "HorizontalVertical"
 imports_granularity = "Crate"
+merge_imports = true
 reorder_imports = true
 group_imports = "StdExternalCrate"

server/Cargo.toml

@@ -19,6 +19,7 @@ name = "server"
 path = "src/main.rs"
 
 [dependencies]
+chrono = "0.4"
 clap = {version = "3.2.5", features = ["derive"]}
 uuid = {version = "1.1.2", features = ["serde", "v4"]}
 serde = { version = "1.0", features = ["derive"] }

server/src/client_management/chat_manager/chat_manager.rs

@@ -0,0 +1,41 @@
+use actix::{Actor, Context, Handler};
+use uuid::Uuid;
+
+use crate::client_management::chat_manager::{
+	message_type::Message, messages::ChatManagerMessage,
+};
+
+struct ChatManager {
+	messages: Vec<Message>,
+}
+
+impl ChatManager {
+	pub fn new() -> Self {
+		Self {
+			messages: Vec::new(),
+		}
+	}
+
+	// no need for a remove methods because this is a read only system
+	pub fn add_message(&mut self, id: Uuid, content: String) {
+		self.messages.push(Message::new(id, content))
+	}
+}
+
+impl Actor for ChatManager {
+	type Context = Context<Self>;
+}
+
+impl Handler<ChatManagerMessage> for ChatManager {
+	type Result = ();
+
+	fn handle(
+		&mut self,
+		msg: ChatManagerMessage,
+		_ctx: &mut Self::Context,
+	) -> Self::Result {
+		match msg {
+			ChatManagerMessage::AddMessage(id, content) => self.add_message(id, content),
+		}
+	}
+}

server/src/client_management/chat_manager/message_type.rs

@@ -0,0 +1,19 @@
+use chrono::{DateTime, Local};
+
+use uuid::Uuid;
+
+pub struct Message {
+	from: Uuid,
+	content: String,
+	time: DateTime<Local>,
+}
+
+impl Message {
+	pub fn new(from: Uuid, content: String) -> Self {
+		Self {
+			from,
+			content,
+			time: Local::now(),
+		}
+	}
+}

server/src/client_management/chat_manager/messages.rs

@@ -0,0 +1,15 @@
+use actix::{Message, MessageResponse};
+use uuid::Uuid;
+
+#[derive(Message, Debug)]
+#[rtype(result = "()")]
+pub enum ChatManagerMessage {
+	AddMessage(Uuid, String),
+}
+
+#[derive(Message, Debug)]
+#[rtype(result = "ChatManagerDataResponse")]
+pub enum ChatManagerDataMessage {}
+
+#[derive(MessageResponse)]
+pub enum ChatManagerDataResponse {}

server/src/client_management/chat_manager/mod.rs

@@ -0,0 +1,5 @@
+mod chat_manager;
+mod message_type;
+mod messages;
+
+use message_type::Message;

server/src/client_management/client/client.rs

@@ -2,8 +2,7 @@ use crate::client_management::client::messages::ClientObservableMessage::{
 	SendGlobalMessageRequest, SendMessageRequest, UpdateRequest,
 };
 use crate::client_management::client::messages::{
-	ClientDataMessage, ClientDataResponse, ClientMessage,
-	ClientObservableMessage,
+	ClientDataMessage, ClientDataResponse, ClientMessage, ClientObservableMessage,
 };
 use crate::network::{Connection, ConnectionOuput};
 use crate::prelude::messages::ObservableMessage;
@@ -29,10 +28,7 @@ pub struct Client {
 }
 
 impl Client {
-	pub(crate) fn new(
-		connection: Addr<Connection>,
-		details: ClientDetails,
-	) -> Addr<Self> {
+	pub(crate) fn new(connection: Addr<Connection>, details: ClientDetails) -> Addr<Self> {
 		Client {
 			connection,
 			details,
@@ -57,9 +53,7 @@ impl Client {
 		match msg {
 			Update => self.handle_update(ctx),
 			SendMessage { to, content } => self.handle_send(ctx, to, content),
-			SendGlobalMessage { content } => {
-				self.handle_global_send(ctx, content)
-			}
+			SendGlobalMessage { content } => self.handle_global_send(ctx, content),
 			Disconnect => self.handle_disconnect(ctx),
 			_ => todo!(),
 		}
@@ -71,25 +65,13 @@ impl Client {
 	}
 
 	#[inline]
-	fn handle_send(
-		&self,
-		ctx: &mut Context<Client>,
-		to: Uuid,
-		content: String,
-	) {
-		self.broadcast(SendMessageRequest(
-			ctx.address().downgrade(),
-			to,
-			content,
-		));
+	fn handle_send(&self, ctx: &mut Context<Client>, to: Uuid, content: String) {
+		self.broadcast(SendMessageRequest(ctx.address().downgrade(), to, content));
 	}
 
 	#[inline]
 	fn handle_global_send(&self, ctx: &mut Context<Client>, content: String) {
-		self.broadcast(SendGlobalMessageRequest(
-			ctx.address().downgrade(),
-			content,
-		));
+		self.broadcast(SendGlobalMessageRequest(ctx.address().downgrade(), content));
 	}
 
 	#[inline]
@@ -116,13 +98,14 @@ impl Actor for Client {
 		use foundation::messages::client::ClientStreamOut::Connected;
 		use serde_json::to_string;
 		println!("[Client] started");
-		self.connection
+		self
+			.connection
 			.do_send::<ObservableMessage<ConnectionOuput>>(Subscribe(
 				ctx.address().recipient(),
 			));
-		self.connection.do_send(SendData(
-			to_string::<ClientStreamOut>(&Connected).unwrap(),
-		));
+		self
+			.connection
+			.do_send(SendData(to_string::<ClientStreamOut>(&Connected).unwrap()));
 	}
 
 	fn stopped(&mut self, ctx: &mut Self::Context) {
@@ -131,7 +114,8 @@ impl Actor for Client {
 		use foundation::messages::client::ClientStreamOut;
 		use foundation::messages::client::ClientStreamOut::Disconnected;
 		use serde_json::to_string;
-		self.connection
+		self
+			.connection
 			.do_send::<ObservableMessage<ConnectionOuput>>(Unsubscribe(
 				ctx.address().recipient(),
 			));
@@ -143,15 +127,9 @@ impl Actor for Client {
 
 impl Handler<ClientDataMessage> for Client {
 	type Result = ClientDataResponse;
-	fn handle(
-		&mut self,
-		msg: ClientDataMessage,
-		_ctx: &mut Self::Context,
-	) -> Self::Result {
+	fn handle(&mut self, msg: ClientDataMessage, _ctx: &mut Self::Context) -> Self::Result {
 		match msg {
-			ClientDataMessage::Details => {
-				ClientDataResponse::Details(self.details.clone())
-			}
+			ClientDataMessage::Details => ClientDataResponse::Details(self.details.clone()),
 			_ => todo!(),
 		}
 	}
@@ -160,11 +138,7 @@ impl Handler<ClientDataMessage> for Client {
 // Handles incoming messages to the client.
 impl Handler<ClientMessage> for Client {
 	type Result = ();
-	fn handle(
-		&mut self,
-		msg: ClientMessage,
-		_ctx: &mut Self::Context,
-	) -> Self::Result {
+	fn handle(&mut self, msg: ClientMessage, _ctx: &mut Self::Context) -> Self::Result {
 		use crate::client_management::client::messages::ClientMessage::{
 			SendGlobalMessage, SendMessage, SendUpdate,
 		};
@@ -184,15 +158,10 @@ impl Handler<ClientMessage> for Client {
 				to_string::<ClientStreamOut>(&UserMessage { from, content })
 					.expect("[Client] Failed to encode string"),
 			)),
-			SendGlobalMessage { from, content } => {
-				self.connection.do_send(SendData(
-					to_string::<ClientStreamOut>(&GlobalMessage {
-						from,
-						content,
-					})
+			SendGlobalMessage { from, content } => self.connection.do_send(SendData(
+				to_string::<ClientStreamOut>(&GlobalMessage { from, content })
 					.expect("[Client] Failed to encode string"),
-				))
-			}
+			)),
 		}
 	}
 }
@@ -201,16 +170,10 @@ impl Handler<ClientMessage> for Client {
 impl Handler<ConnectionOuput> for Client {
 	type Result = ();
 
-	fn handle(
-		&mut self,
-		msg: ConnectionOuput,
-		ctx: &mut Self::Context,
-	) -> Self::Result {
+	fn handle(&mut self, msg: ConnectionOuput, ctx: &mut Self::Context) -> Self::Result {
 		use crate::network::ConnectionOuput::RecvData;
 		match msg {
-			RecvData(sender, addr, data) => {
-				self.handle_request(ctx, sender, addr, data)
-			}
+			RecvData(sender, addr, data) => self.handle_request(ctx, sender, addr, data),
 			_ => todo!(),
 		}
 	}
@@ -224,9 +187,7 @@ impl Handler<ObservableMessage<ClientObservableMessage>> for Client {
 		msg: ObservableMessage<ClientObservableMessage>,
 		_ctx: &mut Self::Context,
 	) -> Self::Result {
-		use crate::prelude::messages::ObservableMessage::{
-			Subscribe, Unsubscribe,
-		};
+		use crate::prelude::messages::ObservableMessage::{Subscribe, Unsubscribe};
 		match msg {
 			Subscribe(r) => {
 				println!("[Client] adding subscriber");

server/src/client_management/client/messages.rs

@@ -1,7 +1,7 @@
-use actix::{WeakAddr, Message, MessageResponse};
-use uuid::Uuid;
-use foundation::ClientDetails;
 use crate::client_management::client::client::Client;
+use actix::{Message, MessageResponse, WeakAddr};
+use foundation::ClientDetails;
+use uuid::Uuid;
 
 /// Message sent ot the clients delegate
 #[derive(Message)]

server/src/client_management/client/mod.rs

@@ -1,5 +1,5 @@
-mod messages;
 mod client;
+mod messages;
 
+pub use client::Client;
 pub use messages::*;
-pub use client::{Client};

server/src/client_management/client_manager.rs

@@ -1,26 +1,35 @@
 use std::collections::HashMap;
 
 use actix::{
-	fut::wrap_future, Actor, Addr, AsyncContext, Context, Handler, WeakAddr,
+	fut::wrap_future,
+	Actor,
+	Addr,
+	AsyncContext,
+	Context,
+	Handler,
+	WeakAddr,
 	WeakRecipient,
 };
 use foundation::ClientDetails;
-
 use tokio_stream::StreamExt;
 use uuid::Uuid;
 
-use crate::client_management::client::ClientDataResponse::Details;
-use crate::client_management::client::ClientMessage::SendMessage;
-use crate::client_management::client::{Client, ClientDataResponse};
-use crate::client_management::client::{
-	ClientDataMessage, ClientObservableMessage,
-};
-use crate::client_management::messages::ClientManagerDataResponse::{
-	ClientCount, Clients,
-};
-use crate::client_management::messages::{
-	ClientManagerDataMessage, ClientManagerDataResponse, ClientManagerMessage,
-	ClientManagerOutput,
+use crate::client_management::{
+	client::{
+		Client,
+		ClientDataMessage,
+		ClientDataResponse,
+		ClientDataResponse::Details,
+		ClientMessage::SendMessage,
+		ClientObservableMessage,
+	},
+	messages::{
+		ClientManagerDataMessage,
+		ClientManagerDataResponse,
+		ClientManagerDataResponse::{ClientCount, Clients},
+		ClientManagerMessage,
+		ClientManagerOutput,
+	},
 };
 
 pub struct ClientManager {
@@ -29,9 +38,7 @@ pub struct ClientManager {
 }
 
 impl ClientManager {
-	pub(crate) fn new(
-		delegate: WeakRecipient<ClientManagerOutput>,
-	) -> Addr<Self> {
+	pub(crate) fn new(delegate: WeakRecipient<ClientManagerOutput>) -> Addr<Self> {
 		ClientManager {
 			_delegate: delegate,
 			clients: HashMap::new(),
@@ -39,11 +46,7 @@ impl ClientManager {
 		.start()
 	}
 
-	pub(crate) fn send_update(
-		&mut self,
-		ctx: &mut Context<Self>,
-		addr: WeakAddr<Client>,
-	) {
+	pub(crate) fn send_update(&mut self, ctx: &mut Context<Self>, addr: WeakAddr<Client>) {
 		println!("[ClientManager] sending update to client");
 		use crate::client_management::client::ClientMessage::SendUpdate;
 		if let Some(to_send) = addr.upgrade() {
@@ -211,7 +214,9 @@ impl Handler<ClientObservableMessage> for ClientManager {
 		ctx: &mut Self::Context,
 	) -> Self::Result {
 		use crate::client_management::client::ClientObservableMessage::{
-			SendGlobalMessageRequest, SendMessageRequest, UpdateRequest,
+			SendGlobalMessageRequest,
+			SendMessageRequest,
+			UpdateRequest,
 		};
 		match msg {
 			SendMessageRequest(addr, uuid, content) => {
@@ -234,9 +239,7 @@ impl Handler<ClientManagerDataMessage> for ClientManager {
 		_ctx: &mut Self::Context,
 	) -> Self::Result {
 		match msg {
-			ClientManagerDataMessage::ClientCount => {
-				ClientCount(self.clients.values().count())
-			}
+			ClientManagerDataMessage::ClientCount => ClientCount(self.clients.values().count()),
 			ClientManagerDataMessage::Clients => {
 				Clients(self.clients.values().map(|a| a.downgrade()).collect())
 			}

server/src/client_management/mod.rs

@@ -7,6 +7,7 @@
 //! - to handle server to client communication.
 //! - to handler client lifecycle events such as dicconection.
 
+mod chat_manager;
 pub mod client;
 mod client_manager;
 mod messages;

server/src/config_manager/config_manager.rs

@@ -14,8 +14,7 @@ use crate::{
 		arg_parser::Arguments,
 		builder::Builder,
 		messages::{
-			ConfigManagerDataMessage, ConfigManagerDataResponse,
-			ConfigManagerOutput,
+			ConfigManagerDataMessage, ConfigManagerDataResponse, ConfigManagerOutput,
 		},
 		types::ConfigValue::{Dict, Number, String as ConfigString},
 		ConfigValue,
@@ -65,9 +64,7 @@ impl ConfigManager {
 		value: Option<ConfigValue>,
 	) -> Option<ConfigValue> {
 		value.and_then(|value| {
-			if let (Dict(stored), Dict(root)) =
-				(&mut self.stored, &mut self.root)
-			{
+			if let (Dict(stored), Dict(root)) = (&mut self.stored, &mut self.root) {
 				stored.insert(key.clone(), value.clone());
 				root.insert(key.clone(), value.clone());
 				Some(value)
@@ -114,9 +111,7 @@ impl Handler<ConfigManagerDataMessage> for ConfigManager {
 		use ConfigManagerDataResponse::{GotValue, SetValue, SoftSetValue};
 
 		match msg {
-			ConfigManagerDataMessage::GetValue(val) => {
-				GotValue(self.get_value(val))
-			}
+			ConfigManagerDataMessage::GetValue(val) => GotValue(self.get_value(val)),
 			ConfigManagerDataMessage::SetValue(key, value) => {
 				SetValue(key.clone(), self.set_value(key, value))
 			}
@@ -140,7 +135,8 @@ impl From<Builder> for ConfigManager {
 			.unwrap();
 
 		let mut output = String::new();
-		file.read_to_string(&mut output)
+		file
+			.read_to_string(&mut output)
 			.expect("failed to read from file");
 
 		let stored = output
@@ -152,23 +148,14 @@ impl From<Builder> for ConfigManager {
 		let mut root = stored.clone();
 		if let Dict(root) = &mut root {
 			builder.args.map(|v| {
-				v.port.map(|p| {
-					root.insert("Network.Port".to_owned(), Number(p.into()))
-				});
+				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/mod.rs

@@ -9,7 +9,5 @@ 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

@@ -18,9 +18,9 @@ pub enum ConfigValue {
 impl From<ConfigValue> for Value {
 	fn from(v: ConfigValue) -> Self {
 		match v {
-			ConfigValue::Dict(dict) => Value::Table(
-				dict.into_iter().map(|(k, v)| (k, v.into())).collect(),
-			),
+			ConfigValue::Dict(dict) => {
+				Value::Table(dict.into_iter().map(|(k, v)| (k, v.into())).collect())
+			}
 			ConfigValue::Array(arr) => {
 				Value::Array(arr.into_iter().map(|v| v.into()).collect())
 			}
@@ -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/lua/mod.rs

@@ -1,4 +1,4 @@
-mod lua_manager;
 mod builder;
+mod lua_manager;
 
-pub use lua_manager::LuaManager;
+pub use lua_manager::LuaManager;

server/src/network/connection/mod.rs

@@ -1,15 +1,13 @@
 use std::{io::Write, net::SocketAddr, pin::Pin, sync::Arc};
 
 use actix::{
-	fut::wrap_future, Actor, ActorContext, Addr, AsyncContext, Context,
-	Handler, Message, Recipient, SpawnHandle,
+	fut::wrap_future, Actor, ActorContext, Addr, AsyncContext, Context, Handler, Message,
+	Recipient, SpawnHandle,
 };
 use futures::{future::join_all, Future, FutureExt};
 
 use tokio::{
-	io::{
-		split, AsyncBufReadExt, AsyncWriteExt, BufReader, ReadHalf, WriteHalf,
-	},
+	io::{split, AsyncBufReadExt, AsyncWriteExt, BufReader, ReadHalf, WriteHalf},
 	net::TcpStream,
 	sync::Mutex,
 };
@@ -93,9 +91,10 @@ impl Actor for Connection {
 				use SelfMessage::UpdateObserversWithData;
 				if len == 0 {
 					println!("[Connection] connection closed");
-					addr.send(CloseConnection).await.expect(
-						"[Connection] failed to send close message to self",
-					);
+					addr
+						.send(CloseConnection)
+						.await
+						.expect("[Connection] failed to send close message to self");
 					return;
 				}
 
@@ -145,11 +144,7 @@ impl Handler<ObservableMessage<ConnectionOuput>> for Connection {
 
 impl Handler<ConnectionMessage> for Connection {
 	type Result = ();
-	fn handle(
-		&mut self,
-		msg: ConnectionMessage,
-		ctx: &mut Self::Context,
-	) -> Self::Result {
+	fn handle(&mut self, msg: ConnectionMessage, ctx: &mut Self::Context) -> Self::Result {
 		use ConnectionMessage::{CloseConnection, SendData};
 		let writer = self.write_half.clone();
 
@@ -170,11 +165,7 @@ impl Handler<ConnectionMessage> for Connection {
 
 impl Handler<SelfMessage> for Connection {
 	type Result = ();
-	fn handle(
-		&mut self,
-		msg: SelfMessage,
-		ctx: &mut Self::Context,
-	) -> Self::Result {
+	fn handle(&mut self, msg: SelfMessage, ctx: &mut Self::Context) -> Self::Result {
 		use ConnectionOuput::RecvData;
 		use SelfMessage::UpdateObserversWithData;
 		match msg {

server/src/network/connection_initiator/mod.rs

@@ -1,8 +1,7 @@
 use std::net::SocketAddr;
 
 use actix::{
-	Actor, ActorContext, Addr, AsyncContext, Context, Handler, Message,
-	WeakRecipient,
+	Actor, ActorContext, Addr, AsyncContext, Context, Handler, Message, WeakRecipient,
 };
 use foundation::{
 	messages::{
@@ -89,15 +88,10 @@ impl ConnectionInitiator {
 		}
 	}
 
-	fn error(
-		&mut self,
-		ctx: &mut <Self as Actor>::Context,
-		sender: Addr<Connection>,
-	) {
+	fn error(&mut self, ctx: &mut <Self as Actor>::Context, sender: Addr<Connection>) {
 		use ConnectionMessage::{CloseConnection, SendData};
 		sender.do_send(SendData(
-			to_string::<ClientStreamOut>(&Error)
-				.expect("failed to convert error to string"),
+			to_string::<ClientStreamOut>(&Error).expect("failed to convert error to string"),
 		));
 		sender.do_send(CloseConnection);
 		ctx.stop()
@@ -117,10 +111,12 @@ impl Actor for ConnectionInitiator {
 
 		println!("[ConnectionInitiator] started");
 
-		self.connection
+		self
+			.connection
 			.do_send(Subscribe(ctx.address().recipient()));
 
-		self.connection
+		self
+			.connection
 			.do_send(SendData(to_string(&Request).unwrap()));
 	}
 
@@ -128,18 +124,15 @@ impl Actor for ConnectionInitiator {
 	fn stopped(&mut self, ctx: &mut Self::Context) {
 		use ObservableMessage::Unsubscribe;
 		println!("[ConnectionInitiator] stopped");
-		self.connection
+		self
+			.connection
 			.do_send(Unsubscribe(ctx.address().recipient()));
 	}
 }
 
 impl Handler<ConnectionOuput> for ConnectionInitiator {
 	type Result = ();
-	fn handle(
-		&mut self,
-		msg: ConnectionOuput,
-		ctx: &mut Self::Context,
-	) -> Self::Result {
+	fn handle(&mut self, msg: ConnectionOuput, ctx: &mut Self::Context) -> Self::Result {
 		use ConnectionOuput::RecvData;
 
 		if let RecvData(sender, addr, data) = msg {

server/src/network/listener/mod.rs

@@ -1,8 +1,8 @@
 use std::net::{SocketAddr, ToSocketAddrs};
 
 use actix::{
-	fut::wrap_future, Actor, Addr, AsyncContext, Context, Handler, Message,
-	Recipient, SpawnHandle,
+	fut::wrap_future, Actor, Addr, AsyncContext, Context, Handler, Message, Recipient,
+	SpawnHandle,
 };
 use tokio::net::TcpListener;
 

server/src/network/mod.rs

@@ -36,6 +36,5 @@ pub(crate) use connection::{Connection, ConnectionMessage, ConnectionOuput};
 pub(crate) use connection_initiator::{ConnectionInitiator, InitiatorOutput};
 // use listener::{ListenerMessage, ListenerOutput, NetworkListener};
 pub(crate) use network_manager::{
-	NetworkDataMessage, NetworkDataOutput, NetworkManager, NetworkMessage,
-	NetworkOutput,
+	NetworkDataMessage, NetworkDataOutput, NetworkManager, NetworkMessage, NetworkOutput,
 };

server/src/network/network_manager/messages.rs

@@ -1,7 +1,7 @@
-use actix::Addr;
-use foundation::ClientDetails;
 use crate::network::Connection;
+use actix::Addr;
 use actix::{Message, MessageResponse};
+use foundation::ClientDetails;
 
 #[derive(Message, Debug, Ord, PartialOrd, Eq, PartialEq)]
 #[rtype(result = "()")]
@@ -20,10 +20,10 @@ pub enum NetworkOutput {
 #[derive(Message, Debug, Ord, PartialOrd, Eq, PartialEq)]
 #[rtype(result = "NetworkDataOutput")]
 pub enum NetworkDataMessage {
-	IsListening
+	IsListening,
 }
 
 #[derive(MessageResponse)]
 pub enum NetworkDataOutput {
 	IsListening(bool),
-}
+}

server/src/network/network_manager/network_manager.rs

@@ -1,21 +1,15 @@
-use crate::config_manager::{
-	ConfigManager, ConfigManagerDataMessage, ConfigValue,
-};
+use crate::config_manager::{ConfigManager, ConfigManagerDataMessage, ConfigValue};
 use crate::network::listener::NetworkListener;
 use crate::network::listener::{ListenerMessage, ListenerOutput};
 
-use crate::network::network_manager::messages::{
-	NetworkMessage, NetworkOutput,
-};
+use crate::network::network_manager::messages::{NetworkMessage, NetworkOutput};
 use crate::network::network_manager::Builder;
 use crate::network::{
-	Connection, ConnectionInitiator, InitiatorOutput, NetworkDataMessage,
-	NetworkDataOutput,
+	Connection, ConnectionInitiator, InitiatorOutput, NetworkDataMessage, NetworkDataOutput,
 };
 use actix::fut::wrap_future;
 use actix::{
-	Actor, ActorFutureExt, Addr, AsyncContext, Context, Handler, WeakAddr,
-	WeakRecipient,
+	Actor, ActorFutureExt, Addr, AsyncContext, Context, Handler, WeakAddr, WeakRecipient,
 };
 use foundation::ClientDetails;
 
@@ -72,10 +66,8 @@ impl NetworkManager {
 	) {
 		println!("[NetworkManager] Got new connection");
 
-		let init = ConnectionInitiator::new(
-			ctx.address().recipient().downgrade(),
-			connection,
-		);
+		let init =
+			ConnectionInitiator::new(ctx.address().recipient().downgrade(), connection);
 		self.initiators.push(init);
 	}
 
@@ -133,13 +125,11 @@ impl Actor for NetworkManager {
 		let config_mgr = self.config_manager.clone().upgrade();
 
 		if let Some(config_mgr) = config_mgr {
-			let fut = wrap_future(config_mgr.send(
-				ConfigManagerDataMessage::GetValue("Network.Port".to_owned()),
-			))
+			let fut = wrap_future(config_mgr.send(ConfigManagerDataMessage::GetValue(
+				"Network.Port".to_owned(),
+			)))
 			.map(
-				|out,
-				 actor: &mut NetworkManager,
-				 ctx: &mut Context<NetworkManager>| {
+				|out, actor: &mut NetworkManager, ctx: &mut Context<NetworkManager>| {
 					use crate::config_manager::ConfigManagerDataResponse::GotValue;
 
 					let recipient = ctx.address().recipient();
@@ -147,10 +137,7 @@ impl Actor for NetworkManager {
 					out.ok().map(|res| {
 						if let GotValue(Some(ConfigValue::Number(port))) = res {
 							println!("[NetworkManager] got port: {:?}", port);
-							let nl = NetworkListener::new(
-								format!("0.0.0.0:{}", port),
-								recipient,
-							);
+							let nl = NetworkListener::new(format!("0.0.0.0:{}", port), recipient);
 							nl.do_send(ListenerMessage::StartListening);
 							actor.listener_addr.replace(nl);
 						};
@@ -196,11 +183,7 @@ impl Handler<NetworkDataMessage> for NetworkManager {
 
 impl Handler<ListenerOutput> for NetworkManager {
 	type Result = ();
-	fn handle(
-		&mut self,
-		msg: ListenerOutput,
-		ctx: &mut Self::Context,
-	) -> Self::Result {
+	fn handle(&mut self, msg: ListenerOutput, ctx: &mut Self::Context) -> Self::Result {
 		use ListenerOutput::NewConnection;
 		match msg {
 			NewConnection(connection) => self.new_connection(ctx, connection),
@@ -210,11 +193,7 @@ impl Handler<ListenerOutput> for NetworkManager {
 
 impl Handler<InitiatorOutput> for NetworkManager {
 	type Result = ();
-	fn handle(
-		&mut self,
-		msg: InitiatorOutput,
-		ctx: &mut Self::Context,
-	) -> Self::Result {
+	fn handle(&mut self, msg: InitiatorOutput, ctx: &mut Self::Context) -> Self::Result {
 		use InitiatorOutput::{ClientRequest, InfoRequest};
 		match msg {
 			ClientRequest(sender, addr, client_details) => {

server/src/prelude/mod.rs

@@ -8,9 +8,7 @@ pub mod actors {
 	//! exports all actors used in the program.
 	pub(crate) use crate::client_management::client::Client;
 	pub(crate) use crate::client_management::ClientManager;
-	pub(crate) use crate::network::{
-		Connection, ConnectionInitiator, NetworkManager,
-	};
+	pub(crate) use crate::network::{Connection, ConnectionInitiator, NetworkManager};
 	pub use crate::server::Server;
 }
 
@@ -18,9 +16,7 @@ pub mod actors {
 pub mod messages {
 	//! exports all messages used in the program.
 	pub(crate) use super::observer::ObservableMessage;
-	pub(crate) use crate::client_management::{
-		ClientManagerMessage, ClientManagerOutput,
-	};
+	pub(crate) use crate::client_management::{ClientManagerMessage, ClientManagerOutput};
 	pub(crate) use crate::network::{
 		ConnectionMessage, ConnectionOuput, NetworkMessage, NetworkOutput,
 	};

server/src/rhai/mod.rs

@@ -1,4 +1,4 @@
-mod rhai_manager;
 mod builder;
+mod rhai_manager;
 
-pub use rhai_manager::RhaiManager;
+pub use rhai_manager::RhaiManager;

server/src/rhai/rhai_manager.rs

@@ -33,7 +33,8 @@ impl Actor for RhaiManager {
 	type Context = Context<Self>;
 
 	fn started(&mut self, _ctx: &mut Self::Context) {
-		self.engine
+		self
+			.engine
 			.run(
 				r#"
 			print("hello rhai")

server/src/scripting/mod.rs

@@ -1,4 +1,4 @@
-pub(crate) mod scriptable_server;
-pub(crate) mod scriptable_network_manager;
+pub(crate) mod scriptable_client;
 pub(crate) mod scriptable_client_manager;
-pub(crate) mod scriptable_client;
+pub(crate) mod scriptable_network_manager;
+pub(crate) mod scriptable_server;

server/src/scripting/scriptable_network_manager.rs

@@ -1,11 +1,11 @@
+use crate::network::NetworkDataOutput::IsListening;
+use crate::network::{NetworkDataMessage, NetworkManager};
 use actix::Addr;
 use mlua::{Error, UserData, UserDataMethods};
-use crate::network::{NetworkDataMessage, NetworkManager};
-use crate::network::NetworkDataOutput::IsListening;
 
 #[derive(Clone)]
 pub(crate) struct ScriptableNetworkManager {
-	addr: Addr<NetworkManager>
+	addr: Addr<NetworkManager>,
 }
 
 impl UserData for ScriptableNetworkManager {
@@ -15,7 +15,9 @@ impl UserData for ScriptableNetworkManager {
 			if let Some(IsListening(is_listening)) = is_listening {
 				Ok(is_listening)
 			} else {
-				Err(Error::RuntimeError("Uuid returned null or other value".to_string()))
+				Err(Error::RuntimeError(
+					"Uuid returned null or other value".to_string(),
+				))
 			}
 		});
 	}
@@ -23,8 +25,6 @@ impl UserData for ScriptableNetworkManager {
 
 impl From<Addr<NetworkManager>> for ScriptableNetworkManager {
 	fn from(addr: Addr<NetworkManager>) -> Self {
-		Self {
-			addr
-		}
+		Self { addr }
 	}
-}
+}

server/src/scripting/scriptable_server.rs

@@ -3,9 +3,7 @@ use crate::scripting::scriptable_network_manager::ScriptableNetworkManager;
 use actix::Addr;
 use mlua::{Error, UserData, UserDataMethods};
 
-use crate::server::ServerDataResponse::{
-	ClientManager, Name, NetworkManager, Owner,
-};
+use crate::server::ServerDataResponse::{ClientManager, Name, NetworkManager, Owner};
 use crate::server::*;
 
 #[derive(Clone)]
@@ -39,35 +37,29 @@ impl UserData for ScriptableServer {
 			}
 		});
 
-		methods.add_async_method(
-			"client_manager",
-			|_lua, obj, ()| async move {
-				let name: Option<ServerDataResponse> =
-					obj.addr.send(ServerDataMessage::ClientManager).await.ok();
-				if let Some(ClientManager(Some(cm))) = name {
-					Ok(ScriptableClientManager::from(cm))
-				} else {
-					Err(Error::RuntimeError(
-						"Name returned null or other value".to_string(),
-					))
-				}
-			},
-		);
+		methods.add_async_method("client_manager", |_lua, obj, ()| async move {
+			let name: Option<ServerDataResponse> =
+				obj.addr.send(ServerDataMessage::ClientManager).await.ok();
+			if let Some(ClientManager(Some(cm))) = name {
+				Ok(ScriptableClientManager::from(cm))
+			} else {
+				Err(Error::RuntimeError(
+					"Name returned null or other value".to_string(),
+				))
+			}
+		});
 
-		methods.add_async_method(
-			"network_manager",
-			|_lua, obj, ()| async move {
-				let name: Option<ServerDataResponse> =
-					obj.addr.send(ServerDataMessage::NetworkManager).await.ok();
-				if let Some(NetworkManager(Some(nm))) = name {
-					Ok(ScriptableNetworkManager::from(nm))
-				} else {
-					Err(Error::RuntimeError(
-						"Name returned null or other value".to_string(),
-					))
-				}
-			},
-		);
+		methods.add_async_method("network_manager", |_lua, obj, ()| async move {
+			let name: Option<ServerDataResponse> =
+				obj.addr.send(ServerDataMessage::NetworkManager).await.ok();
+			if let Some(NetworkManager(Some(nm))) = name {
+				Ok(ScriptableNetworkManager::from(nm))
+			} else {
+				Err(Error::RuntimeError(
+					"Name returned null or other value".to_string(),
+				))
+			}
+		});
 	}
 }
 

server/src/server/server.rs

@@ -5,8 +5,7 @@ use crate::client_management::client::Client;
 use crate::client_management::ClientManagerMessage::AddClient;
 use crate::client_management::{ClientManager, ClientManagerOutput};
 use crate::config_manager::{
-	ConfigManager, ConfigManagerDataMessage, ConfigManagerDataResponse,
-	ConfigValue,
+	ConfigManager, ConfigManagerDataMessage, ConfigManagerDataResponse, ConfigValue,
 };
 use crate::lua::LuaManager;
 use crate::network::ConnectionMessage::{CloseConnection, SendData};
@@ -14,9 +13,7 @@ use crate::network::NetworkOutput::{InfoRequested, NewClient};
 use crate::network::{Connection, NetworkManager, NetworkOutput};
 use crate::rhai::RhaiManager;
 
-use crate::server::{
-	builder, ServerBuilder, ServerDataMessage, ServerDataResponse,
-};
+use crate::server::{builder, ServerBuilder, ServerDataMessage, ServerDataResponse};
 
 use actix::fut::wrap_future;
 use actix::{Actor, ActorFutureExt, Addr, AsyncContext, Context, Handler};
@@ -89,8 +86,7 @@ impl Actor for Server {
 		let cm = ClientManager::new(addr.clone().recipient());
 		self.client_manager.replace(cm.clone());
 
-		let rm =
-			RhaiManager::create(ctx.address(), nm.clone(), cm.clone()).build();
+		let rm = RhaiManager::create(ctx.address(), nm.clone(), cm.clone()).build();
 		self.rhai_manager.replace(rm);
 
 		let lm = LuaManager::create(ctx.address(), nm, cm).build();
@@ -126,19 +122,11 @@ impl Actor for Server {
 impl Handler<ServerDataMessage> for Server {
 	type Result = ServerDataResponse;
 
-	fn handle(
-		&mut self,
-		msg: ServerDataMessage,
-		_ctx: &mut Self::Context,
-	) -> Self::Result {
+	fn handle(&mut self, msg: ServerDataMessage, _ctx: &mut Self::Context) -> Self::Result {
 		println!("data message");
 		match msg {
-			ServerDataMessage::Name => {
-				ServerDataResponse::Name(self.name.clone())
-			}
-			ServerDataMessage::Owner => {
-				ServerDataResponse::Owner(self.owner.clone())
-			}
+			ServerDataMessage::Name => ServerDataResponse::Name(self.name.clone()),
+			ServerDataMessage::Owner => ServerDataResponse::Owner(self.owner.clone()),
 			ServerDataMessage::ClientManager => {
 				ServerDataResponse::ClientManager(self.client_manager.clone())
 			}
@@ -151,11 +139,7 @@ impl Handler<ServerDataMessage> for Server {
 
 impl Handler<NetworkOutput> for Server {
 	type Result = ();
-	fn handle(
-		&mut self,
-		msg: NetworkOutput,
-		ctx: &mut Self::Context,
-	) -> Self::Result {
+	fn handle(&mut self, msg: NetworkOutput, ctx: &mut Self::Context) -> Self::Result {
 		println!("[ServerActor] received message");
 		match msg {
 			// This uses promise like funcionality to queue