config: remove serde-inline-default (#303)

* Cleanup pumpkin-config

* Forgot to add #[serde(default)]

pumpkin-config/Cargo.toml

@@ -9,4 +9,3 @@ serde.workspace = true
 log.workspace = true
 
 toml = "0.8"
-serde-inline-default = "0.2.2"

pumpkin-config/src/auth.rs

@@ -1,26 +1,17 @@
 use pumpkin_core::ProfileAction;
 use serde::{Deserialize, Serialize};
-use serde_inline_default::serde_inline_default;
 
-#[serde_inline_default]
 #[derive(Deserialize, Serialize)]
 #[serde(default)]
 pub struct AuthenticationConfig {
     /// Whether to use Mojang authentication.
-    #[serde_inline_default(true)]
     pub enabled: bool,
-    #[serde_inline_default("https://sessionserver.mojang.com/session/minecraft/hasJoined?username={username}&serverId={server_hash}".to_string())]
     pub auth_url: String,
-    /// Prevent proxy connections.
-    #[serde_inline_default(false)]
     pub prevent_proxy_connections: bool,
-    #[serde_inline_default("https://sessionserver.mojang.com/session/minecraft/hasJoined?username={username}&serverId={server_hash}&ip={ip}".to_string())]
     pub prevent_proxy_connection_auth_url: String,
     /// Player profile handling.
-    #[serde(default)]
     pub player_profile: PlayerProfileConfig,
     /// Texture handling.
-    #[serde(default)]
     pub textures: TextureConfig,
 }
 
@@ -43,40 +34,31 @@ pub struct PlayerProfileConfig {
     /// Allow players flagged by Mojang (banned, forced name change).
     pub allow_banned_players: bool,
     /// Depends on the value above
-    #[serde(default = "default_allowed_actions")]
     pub allowed_actions: Vec<ProfileAction>,
 }
 
-fn default_allowed_actions() -> Vec<ProfileAction> {
-    vec![
-        ProfileAction::ForcedNameChange,
-        ProfileAction::UsingBannedSkin,
-    ]
-}
-
 impl Default for PlayerProfileConfig {
     fn default() -> Self {
         Self {
             allow_banned_players: false,
-            allowed_actions: default_allowed_actions(),
+            allowed_actions: vec![
+                ProfileAction::ForcedNameChange,
+                ProfileAction::UsingBannedSkin,
+            ],
         }
     }
 }
 
-#[serde_inline_default]
 #[derive(Deserialize, Serialize)]
+#[serde(default)]
 pub struct TextureConfig {
     /// Whether to use player textures.
-    #[serde_inline_default(true)]
     pub enabled: bool,
 
-    #[serde_inline_default(vec!["http".into(), "https".into()])]
     pub allowed_url_schemes: Vec<String>,
-    #[serde_inline_default(vec![".minecraft.net".into(), ".mojang.com".into()])]
     pub allowed_url_domains: Vec<String>,
 
     /// Specific texture types.
-    #[serde(default)]
     pub types: TextureTypes,
 }
 
@@ -92,17 +74,14 @@ impl Default for TextureConfig {
 }
 
 #[derive(Deserialize, Serialize)]
-#[serde_inline_default]
+#[serde(default)]
 pub struct TextureTypes {
     /// Use player skins.
-    #[serde_inline_default(true)]
     pub skin: bool,
     /// Use player capes.
-    #[serde_inline_default(true)]
     pub cape: bool,
     /// Use player elytras.
     /// (i didn't know myself that there are custom elytras)
-    #[serde_inline_default(true)]
     pub elytra: bool,
 }
 

pumpkin-config/src/commands.rs

@@ -1,14 +1,11 @@
 use serde::{Deserialize, Serialize};
-use serde_inline_default::serde_inline_default;
 
 #[derive(Deserialize, Serialize)]
-#[serde_inline_default]
+#[serde(default)]
 pub struct CommandsConfig {
     /// Are commands from the Console accepted ?
-    #[serde_inline_default(true)]
     pub use_console: bool,
     /// Should be commands from players be logged in console?
-    #[serde_inline_default(true)]
     pub log_console: bool, // TODO: commands...
 }
 

pumpkin-config/src/compression.rs

@@ -1,29 +1,33 @@
 use serde::{Deserialize, Serialize};
-use serde_inline_default::serde_inline_default;
 
-#[serde_inline_default]
 #[derive(Deserialize, Serialize)]
+#[serde(default)]
 /// Packet compression
 pub struct CompressionConfig {
     /// Wether compression is enabled
-    #[serde_inline_default(true)]
     pub enabled: bool,
     #[serde(flatten)]
-    #[serde(default)]
     pub compression_info: CompressionInfo,
 }
 
-#[serde_inline_default]
+impl Default for CompressionConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            compression_info: Default::default(),
+        }
+    }
+}
+
 #[derive(Deserialize, Serialize, Clone)]
+#[serde(default)]
 /// We have this in a Seperate struct so we can use it outside of the Config
 pub struct CompressionInfo {
     /// The compression threshold used when compression is enabled
-    #[serde_inline_default(256)]
     pub threshold: u32,
     /// A value between 0..9
     /// 1 = Optimize for the best speed of encoding.
     /// 9 = Optimize for the size of data being encoded.
-    #[serde_inline_default(4)]
     pub level: u32,
 }
 
@@ -35,12 +39,3 @@ impl Default for CompressionInfo {
         }
     }
 }
-
-impl Default for CompressionConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            compression_info: Default::default(),
-        }
-    }
-}

pumpkin-config/src/lib.rs

@@ -4,9 +4,6 @@ use pumpkin_core::{Difficulty, GameMode};
 use query::QueryConfig;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
-// TODO: when https://github.com/rust-lang/rfcs/pull/3681 gets merged, replace serde-inline-default with native syntax
-use serde_inline_default::serde_inline_default;
-
 use std::{
     fs,
     net::{Ipv4Addr, SocketAddr},
@@ -58,66 +55,46 @@ pub struct AdvancedConfiguration {
     pub query: QueryConfig,
 }
 
-#[serde_inline_default]
 #[derive(Serialize, Deserialize)]
+#[serde(default)]
 pub struct BasicConfiguration {
     /// The address to bind the server to.
-    #[serde(default = "default_server_address")]
     pub server_address: SocketAddr,
     /// The seed for world generation.
-    #[serde(default = "String::new")]
     pub seed: String,
     /// The maximum number of players allowed on the server. Specifying `0` disables the limit.
-    #[serde_inline_default(10000)]
     pub max_players: u32,
     /// The maximum view distance for players.
-    #[serde_inline_default(10)]
     pub view_distance: u8,
     /// The maximum simulated view distance.
-    #[serde_inline_default(10)]
     pub simulation_distance: u8,
     /// The default game difficulty.
-    #[serde_inline_default(Difficulty::Normal)]
     pub default_difficulty: Difficulty,
     /// Whether the Nether dimension is enabled.
-    #[serde_inline_default(true)]
     pub allow_nether: bool,
     /// Whether the server is in hardcore mode.
-    #[serde_inline_default(false)]
     pub hardcore: bool,
     /// Whether online mode is enabled. Requires valid Minecraft accounts.
-    #[serde_inline_default(true)]
     pub online_mode: bool,
     /// Whether packet encryption is enabled. Required when online mode is enabled.
-    #[serde_inline_default(true)]
     pub encryption: bool,
     /// The server's description displayed on the status screen.
-    #[serde_inline_default("A Blazing fast Pumpkin Server!".to_string())]
     pub motd: String,
-    #[serde_inline_default(20.0)]
     pub tps: f32,
     /// The default game mode for players.
-    #[serde_inline_default(GameMode::Survival)]
     pub default_gamemode: GameMode,
     /// Whether to remove IPs from logs or not
-    #[serde_inline_default(true)]
     pub scrub_ips: bool,
     /// Whether to use a server favicon
-    #[serde_inline_default(true)]
     pub use_favicon: bool,
     /// Path to server favicon
-    #[serde_inline_default("icon.png".to_string())]
     pub favicon_path: String,
 }
 
-fn default_server_address() -> SocketAddr {
-    SocketAddr::new(Ipv4Addr::new(0, 0, 0, 0).into(), 25565)
-}
-
 impl Default for BasicConfiguration {
     fn default() -> Self {
         Self {
-            server_address: default_server_address(),
+            server_address: SocketAddr::new(Ipv4Addr::new(0, 0, 0, 0).into(), 25565),
             seed: "".to_string(),
             max_players: 100000,
             view_distance: 10,

pumpkin-config/src/logging.rs

@@ -1,20 +1,13 @@
 use serde::{Deserialize, Serialize};
-use serde_inline_default::serde_inline_default;
 
-#[serde_inline_default]
 #[derive(Deserialize, Serialize)]
+#[serde(default)]
 pub struct LoggingConfig {
-    #[serde_inline_default(true)]
     pub enabled: bool,
-    #[serde_inline_default(LevelFilter::Info)]
     pub level: LevelFilter,
-    #[serde_inline_default(false)]
     pub env: bool,
-    #[serde_inline_default(true)]
     pub threads: bool,
-    #[serde_inline_default(true)]
     pub color: bool,
-    #[serde_inline_default(true)]
     pub timestamp: bool,
 }
 
@@ -22,7 +15,7 @@ impl Default for LoggingConfig {
     fn default() -> Self {
         Self {
             enabled: true,
-            level: LevelFilter::Info,
+            level: Default::default(),
             env: false,
             threads: true,
             color: true,
@@ -31,18 +24,15 @@ impl Default for LoggingConfig {
     }
 }
 
-#[derive(Deserialize, Serialize, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
+#[derive(
+    Deserialize, Serialize, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash,
+)]
 pub enum LevelFilter {
-    /// A level lower than all log levels.
     Off,
-    /// Corresponds to the `Error` log level.
     Error,
-    /// Corresponds to the `Warn` log level.
     Warn,
-    /// Corresponds to the `Info` log level.
+    #[default]
     Info,
-    /// Corresponds to the `Debug` log level.
     Debug,
-    /// Corresponds to the `Trace` log level.
     Trace,
 }

pumpkin-config/src/proxy.rs

@@ -1,39 +1,21 @@
 use serde::{Deserialize, Serialize};
-use serde_inline_default::serde_inline_default;
 
-#[serde_inline_default]
 #[derive(Deserialize, Serialize, Default)]
 #[serde(default)]
 pub struct ProxyConfig {
-    #[serde_inline_default(false)]
     pub enabled: bool,
     pub velocity: VelocityConfig,
     pub bungeecord: BungeeCordConfig,
 }
-
-#[serde_inline_default]
 #[derive(Deserialize, Serialize, Default)]
 #[serde(default)]
 pub struct BungeeCordConfig {
-    #[serde_inline_default(false)]
     pub enabled: bool,
 }
 
-#[serde_inline_default]
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Default)]
 #[serde(default)]
 pub struct VelocityConfig {
-    #[serde_inline_default(false)]
     pub enabled: bool,
-    #[serde_inline_default("".to_string())]
     pub secret: String,
 }
-
-impl Default for VelocityConfig {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            secret: "".into(),
-        }
-    }
-}

pumpkin-config/src/pvp.rs

@@ -1,23 +1,17 @@
 use serde::{Deserialize, Serialize};
-use serde_inline_default::serde_inline_default;
 
-#[serde_inline_default]
 #[derive(Deserialize, Serialize)]
+#[serde(default)]
 pub struct PVPConfig {
     /// Is PVP enabled ?
-    #[serde_inline_default(true)]
     pub enabled: bool,
     /// Do we want to have the Red hurt animation & fov bobbing
-    #[serde_inline_default(true)]
     pub hurt_animation: bool,
     /// Should players in creative be protected against PVP
-    #[serde_inline_default(true)]
     pub protect_creative: bool,
     /// Has PVP Knockback?
-    #[serde_inline_default(true)]
     pub knockback: bool,
     /// Should player swing when attacking?
-    #[serde_inline_default(true)]
     pub swing: bool,
 }
 

pumpkin-config/src/query.rs

@@ -1,12 +1,9 @@
 use serde::{Deserialize, Serialize};
-use serde_inline_default::serde_inline_default;
 
-#[serde_inline_default]
 #[derive(Deserialize, Serialize, Default)]
+#[serde(default)]
 pub struct QueryConfig {
-    #[serde_inline_default(false)]
     pub enabled: bool,
     // Optional so if not specified the port server is running on will be used
-    #[serde_inline_default(None)]
     pub port: Option<u16>,
 }

pumpkin-config/src/rcon.rs

@@ -1,42 +1,44 @@
+use serde::{Deserialize, Serialize};
 use std::net::{Ipv4Addr, SocketAddr};
 
-use serde::{Deserialize, Serialize};
-use serde_inline_default::serde_inline_default;
-
-#[serde_inline_default]
 #[derive(Deserialize, Serialize, Clone)]
+#[serde(default)]
 pub struct RCONConfig {
     /// Is RCON Enabled?
-    #[serde_inline_default(false)]
     pub enabled: bool,
     /// The network address and port where the RCON server will listen for connections.
-    #[serde(default = "default_rcon_address")]
     pub address: SocketAddr,
     /// The password required for RCON authentication.
-    #[serde(default)]
     pub password: String,
     /// The maximum number of concurrent RCON connections allowed.
     /// If 0 there is no limit
-    #[serde(default)]
     pub max_connections: u32,
     /// RCON Logging
     pub logging: RCONLogging,
 }
 
-#[serde_inline_default]
+impl Default for RCONConfig {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            address: SocketAddr::new(Ipv4Addr::new(0, 0, 0, 0).into(), 25575),
+            password: "".to_string(),
+            max_connections: 0,
+            logging: Default::default(),
+        }
+    }
+}
+
 #[derive(Deserialize, Serialize, Clone, Debug)]
+#[serde(default)]
 pub struct RCONLogging {
     /// Whether successful RCON logins should be logged.
-    #[serde_inline_default(true)]
     pub log_logged_successfully: bool,
     /// Whether failed RCON login attempts with incorrect passwords should be logged.
-    #[serde_inline_default(true)]
     pub log_wrong_password: bool,
     /// Whether all RCON commands, regardless of success or failure, should be logged.
-    #[serde_inline_default(true)]
     pub log_commands: bool,
     /// Whether RCON quit commands should be logged.
-    #[serde_inline_default(true)]
     pub log_quit: bool,
 }
 
@@ -50,19 +52,3 @@ impl Default for RCONLogging {
         }
     }
 }
-
-fn default_rcon_address() -> SocketAddr {
-    SocketAddr::new(Ipv4Addr::new(0, 0, 0, 0).into(), 25575)
-}
-
-impl Default for RCONConfig {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            address: default_rcon_address(),
-            password: "".to_string(),
-            max_connections: 0,
-            logging: Default::default(),
-        }
-    }
-}

pumpkin-config/src/resource_pack.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Default)]
 #[serde(default)]
 pub struct ResourcePackConfig {
     pub enabled: bool,
@@ -27,15 +27,3 @@ impl ResourcePackConfig {
         )
     }
 }
-
-impl Default for ResourcePackConfig {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            resource_pack_url: "".into(),
-            resource_pack_sha1: "".into(),
-            force: false,
-            prompt_message: "".into(),
-        }
-    }
-}