[Crate] Enforce formatting in CI (#46)

* [CI] Check formatting

* Format all files

src/protocols/gamespy/protocols/one/protocol.rs

@@ -1,3 +1,4 @@
+use crate::protocols::gamespy::common::has_password;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -8,7 +9,6 @@ use crate::{
     GDError,
     GDResult,
 };
-use crate::protocols::gamespy::common::has_password;
 use std::collections::HashMap;
 use std::net::SocketAddr;
 

src/protocols/minecraft/protocol/bedrock.rs

@@ -1,7 +1,6 @@
 // This file has code that has been documented by the NodeJS GameDig library
 // (MIT) from https://github.com/gamedig/node-gamedig/blob/master/protocols/minecraftbedrock.js
 
-use std::net::SocketAddr;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -13,6 +12,7 @@ use crate::{
     GDError::{PacketBad, TypeParse},
     GDResult,
 };
+use std::net::SocketAddr;
 
 pub struct Bedrock {
     socket: UdpSocket,

src/protocols/minecraft/protocol/java.rs

@@ -1,4 +1,3 @@
-use std::net::SocketAddr;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -9,6 +8,7 @@ use crate::{
     GDError::{JsonParse, PacketBad},
     GDResult,
 };
+use std::net::SocketAddr;
 
 use serde_json::Value;
 

src/protocols/minecraft/protocol/legacy_bv1_8.rs

@@ -1,4 +1,3 @@
-use std::net::SocketAddr;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -10,6 +9,7 @@ use crate::{
     GDError::{PacketBad, ProtocolFormat},
     GDResult,
 };
+use std::net::SocketAddr;
 
 pub struct LegacyBV1_8 {
     socket: TcpSocket,

src/protocols/minecraft/protocol/legacy_v1_4.rs

@@ -1,4 +1,3 @@
-use std::net::SocketAddr;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -10,6 +9,7 @@ use crate::{
     GDError::{PacketBad, ProtocolFormat},
     GDResult,
 };
+use std::net::SocketAddr;
 
 pub struct LegacyV1_4 {
     socket: TcpSocket,

src/protocols/minecraft/protocol/legacy_v1_6.rs

@@ -1,4 +1,3 @@
-use std::net::SocketAddr;
 use crate::{
     bufferer::{Bufferer, Endianess},
     protocols::{
@@ -10,6 +9,7 @@ use crate::{
     GDError::{PacketBad, ProtocolFormat},
     GDResult,
 };
+use std::net::SocketAddr;
 
 pub struct LegacyV1_6 {
     socket: TcpSocket,

src/protocols/minecraft/protocol/mod.rs

@@ -1,4 +1,3 @@
-use std::net::SocketAddr;
 use crate::{
     protocols::minecraft::{
         protocol::{
@@ -16,6 +15,7 @@ use crate::{
     GDError::AutoQuery,
     GDResult,
 };
+use std::net::SocketAddr;
 
 mod bedrock;
 mod java;

src/protocols/mod.rs

@@ -8,9 +8,9 @@
 pub mod gamespy;
 /// Reference: [Server List Ping](https://wiki.vg/Server_List_Ping)
 pub mod minecraft;
+/// Reference: [node-GameDig](https://github.com/gamedig/node-gamedig/blob/master/protocols/quake1.js)
+pub mod quake;
 /// General types that are used by all protocols.
 pub mod types;
 /// Reference: [Server Query](https://developer.valvesoftware.com/wiki/Server_queries)
 pub mod valve;
-/// Reference: [node-GameDig](https://github.com/gamedig/node-gamedig/blob/master/protocols/quake1.js)
-pub mod quake;

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))]

src/protocols/valve/protocol.rs

@@ -418,12 +418,7 @@ pub fn query(
     timeout_settings: Option<TimeoutSettings>,
 ) -> GDResult<Response> {
     let response_gather_settings = gather_settings.unwrap_or_default();
-    get_response(
-        address,
-        engine,
-        response_gather_settings,
-        timeout_settings,
-    )
+    get_response(address, engine, response_gather_settings, timeout_settings)
 }
 
 fn get_response(