[Crate] Enforce formatting in CI (#46)

* [CI] Check formatting

* Format all files

src/protocols/quake/client.rs

@@ -1,11 +1,11 @@
-use std::collections::HashMap;
-use std::net::SocketAddr;
-use std::slice::Iter;
 use crate::bufferer::{Bufferer, Endianess};
-use crate::{GDError, GDResult};
 use crate::protocols::quake::types::Response;
 use crate::protocols::types::TimeoutSettings;
 use crate::socket::{Socket, UdpSocket};
+use crate::{GDError, GDResult};
+use std::collections::HashMap;
+use std::net::SocketAddr;
+use std::slice::Iter;
 
 pub(crate) trait QuakeClient {
     type Player;
@@ -15,11 +15,21 @@ pub(crate) trait QuakeClient {
     fn parse_player_string(data: Iter<&str>) -> GDResult<Self::Player>;
 }
 
-fn get_data<Client: QuakeClient>(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<Bufferer> {
+fn get_data<Client: QuakeClient>(
+    address: &SocketAddr,
+    timeout_settings: Option<TimeoutSettings>,
+) -> GDResult<Bufferer> {
     let mut socket = UdpSocket::new(address)?;
     socket.apply_timeout(timeout_settings)?;
 
-    socket.send(&[&[0xFF, 0xFF, 0xFF, 0xFF], Client::get_send_header().as_bytes(), &[0x00]].concat())?;
+    socket.send(
+        &[
+            &[0xFF, 0xFF, 0xFF, 0xFF],
+            Client::get_send_header().as_bytes(),
+            &[0x00],
+        ]
+        .concat(),
+    )?;
 
     let data = socket.receive(None)?;
     let mut bufferer = Bufferer::new_with_data(Endianess::Little, &data);
@@ -78,27 +88,34 @@ fn get_players<Client: QuakeClient>(bufferer: &mut Bufferer) -> GDResult<Vec<Cli
     Ok(players)
 }
 
-pub(crate) fn client_query<Client: QuakeClient>(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<Response<Client::Player>> {
+pub(crate) fn client_query<Client: QuakeClient>(
+    address: &SocketAddr,
+    timeout_settings: Option<TimeoutSettings>,
+) -> GDResult<Response<Client::Player>> {
     let mut bufferer = get_data::<Client>(address, timeout_settings)?;
 
     let mut server_vars = get_server_values(&mut bufferer)?;
     let players = get_players::<Client>(&mut bufferer)?;
 
     Ok(Response {
-        name: server_vars.remove("hostname")
+        name: server_vars
+            .remove("hostname")
             .or(server_vars.remove("sv_hostname"))
             .ok_or(GDError::PacketBad)?,
-        map: server_vars.remove("mapname")
+        map: server_vars
+            .remove("mapname")
             .or(server_vars.remove("map"))
             .ok_or(GDError::PacketBad)?,
         players_online: players.len() as u8,
-        players_maximum: server_vars.remove("maxclients")
+        players_maximum: server_vars
+            .remove("maxclients")
             .or(server_vars.remove("sv_maxclients"))
             .ok_or(GDError::PacketBad)?
             .parse()
             .map_err(|_| GDError::TypeParse)?,
         players,
-        version: server_vars.remove("version")
+        version: server_vars
+            .remove("version")
             .or(server_vars.remove("*version"))
             .ok_or(GDError::PacketBad)?,
         unused_entries: server_vars,
@@ -108,6 +125,6 @@ pub(crate) fn client_query<Client: QuakeClient>(address: &SocketAddr, timeout_se
 pub(crate) fn remove_wrapping_quotes<'a>(string: &&'a str) -> &'a str {
     match string.starts_with('\"') && string.ends_with('\"') {
         false => string,
-        true => &string[1..string.len() - 1]
+        true => &string[1 .. string.len() - 1],
     }
 }

src/protocols/quake/mod.rs

@@ -1,7 +1,6 @@
-
 pub mod one;
-pub mod two;
 pub mod three;
+pub mod two;
 
 /// All types used by the implementation.
 pub mod types;

src/protocols/quake/one.rs

@@ -1,11 +1,11 @@
-use std::net::SocketAddr;
-use std::slice::Iter;
-use crate::{GDError, GDResult};
+use crate::protocols::quake::client::{client_query, remove_wrapping_quotes, QuakeClient};
 use crate::protocols::quake::Response;
-use crate::protocols::quake::client::{QuakeClient, client_query, remove_wrapping_quotes};
 use crate::protocols::types::TimeoutSettings;
+use crate::{GDError, GDResult};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use std::net::SocketAddr;
+use std::slice::Iter;
 
 /// Quake 1 player data.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -19,54 +19,50 @@ pub struct Player {
     pub name: String,
     pub skin: String,
     pub color_primary: u8,
-    pub color_secondary: u8
+    pub color_secondary: u8,
 }
 
 pub(crate) struct QuakeOne;
 impl QuakeClient for QuakeOne {
     type Player = Player;
 
-    fn get_send_header<'a>() -> &'a str {
-        "status"
-    }
+    fn get_send_header<'a>() -> &'a str { "status" }
 
-    fn get_response_header<'a>() -> &'a str {
-        "n"
-    }
+    fn get_response_header<'a>() -> &'a str { "n" }
 
     fn parse_player_string(mut data: Iter<&str>) -> GDResult<Self::Player> {
         Ok(Player {
             id: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             score: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             time: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             ping: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             name: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => remove_wrapping_quotes(v).to_string()
+                Some(v) => remove_wrapping_quotes(v).to_string(),
             },
             skin: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => remove_wrapping_quotes(v).to_string()
+                Some(v) => remove_wrapping_quotes(v).to_string(),
             },
             color_primary: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             color_secondary: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
         })
     }

src/protocols/quake/three.rs

@@ -1,26 +1,20 @@
-use std::net::SocketAddr;
-use std::slice::Iter;
-use crate::GDResult;
+use crate::protocols::quake::client::{client_query, QuakeClient};
 use crate::protocols::quake::two::{Player, QuakeTwo};
 use crate::protocols::quake::Response;
-use crate::protocols::quake::client::{QuakeClient, client_query};
 use crate::protocols::types::TimeoutSettings;
+use crate::GDResult;
+use std::net::SocketAddr;
+use std::slice::Iter;
 
 struct QuakeThree;
 impl QuakeClient for QuakeThree {
     type Player = Player;
 
-    fn get_send_header<'a>() -> &'a str {
-        "getstatus"
-    }
+    fn get_send_header<'a>() -> &'a str { "getstatus" }
 
-    fn get_response_header<'a>() -> &'a str {
-        "statusResponse\n"
-    }
+    fn get_response_header<'a>() -> &'a str { "statusResponse\n" }
 
-    fn parse_player_string(data: Iter<&str>) -> GDResult<Self::Player> {
-        QuakeTwo::parse_player_string(data)
-    }
+    fn parse_player_string(data: Iter<&str>) -> GDResult<Self::Player> { QuakeTwo::parse_player_string(data) }
 }
 
 pub fn query(address: &SocketAddr, timeout_settings: Option<TimeoutSettings>) -> GDResult<Response<Player>> {

src/protocols/quake/two.rs

@@ -1,12 +1,12 @@
-use std::net::SocketAddr;
-use std::slice::Iter;
-use crate::{GDError, GDResult};
+use crate::protocols::quake::client::{client_query, remove_wrapping_quotes, QuakeClient};
 use crate::protocols::quake::one::QuakeOne;
 use crate::protocols::quake::Response;
-use crate::protocols::quake::client::{QuakeClient, client_query, remove_wrapping_quotes};
 use crate::protocols::types::TimeoutSettings;
+use crate::{GDError, GDResult};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use std::net::SocketAddr;
+use std::slice::Iter;
 
 /// Quake 2 player data.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -14,35 +14,31 @@ use serde::{Deserialize, Serialize};
 pub struct Player {
     pub frags: i16,
     pub ping: u16,
-    pub name: String
+    pub name: String,
 }
 
 pub(crate) struct QuakeTwo;
 impl QuakeClient for QuakeTwo {
     type Player = Player;
 
-    fn get_send_header<'a>() -> &'a str {
-        QuakeOne::get_send_header()
-    }
+    fn get_send_header<'a>() -> &'a str { QuakeOne::get_send_header() }
 
-    fn get_response_header<'a>() -> &'a str {
-        "print\n"
-    }
+    fn get_response_header<'a>() -> &'a str { "print\n" }
 
     fn parse_player_string(mut data: Iter<&str>) -> GDResult<Self::Player> {
         Ok(Player {
             frags: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             ping: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?
+                Some(v) => v.parse().map_err(|_| GDError::PacketBad)?,
             },
             name: match data.next() {
                 None => Err(GDError::PacketBad)?,
-                Some(v) => remove_wrapping_quotes(v).to_string()
-            }
+                Some(v) => remove_wrapping_quotes(v).to_string(),
+            },
         })
     }
 }

src/protocols/quake/types.rs

@@ -1,6 +1,6 @@
-use std::collections::HashMap;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
 /// General server information's.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]