1 files changed, 49 insertions, 175 deletions

diff --git a/alacritty_terminal/src/config/mod.rs b/alacritty_terminal/src/config/mod.rs
index f3221920..cbe56057 100644
--- a/alacritty_terminal/src/config/mod.rs
+++ b/alacritty_terminal/src/config/mod.rs
@@ -1,11 +1,10 @@
 use std::cmp::max;
 use std::collections::HashMap;
-use std::fmt::Display;
 use std::path::PathBuf;
 
-use log::error;
-use serde::{Deserialize, Deserializer};
-use serde_yaml::Value;
+use serde::Deserialize;
+
+use alacritty_config_derive::ConfigDeserialize;
 
 mod bell;
 mod colors;
@@ -17,132 +16,103 @@ pub use crate::config::bell::{BellAnimation, BellConfig};
 pub use crate::config::colors::Colors;
 pub use crate::config::scrolling::Scrolling;
 
-pub const LOG_TARGET_CONFIG: &str = "alacritty_config";
-const DEFAULT_CURSOR_THICKNESS: f32 = 0.15;
-const MAX_SCROLLBACK_LINES: u32 = 100_000;
+pub const LOG_TARGET_CONFIG: &str = "alacritty_config_derive";
 const MIN_BLINK_INTERVAL: u64 = 10;
 
 pub type MockConfig = Config<HashMap<String, serde_yaml::Value>>;
 
 /// Top-level config type.
-#[derive(Debug, PartialEq, Default, Deserialize)]
+#[derive(ConfigDeserialize, Debug, PartialEq, Default)]
 pub struct Config<T> {
     /// TERM env variable.
-    #[serde(default, deserialize_with = "failure_default")]
     pub env: HashMap<String, String>,
 
     /// Should draw bold text with brighter colors instead of bold font.
-    #[serde(default, deserialize_with = "failure_default")]
-    draw_bold_text_with_bright_colors: bool,
+    pub draw_bold_text_with_bright_colors: bool,
 
-    #[serde(default, deserialize_with = "failure_default")]
     pub colors: Colors,
 
-    #[serde(default, deserialize_with = "failure_default")]
     pub selection: Selection,
 
     /// Path to a shell program to run on startup.
-    #[serde(default, deserialize_with = "failure_default")]
     pub shell: Option<Program>,
 
-    /// Bell configuration.
-    #[serde(default, deserialize_with = "failure_default")]
-    bell: BellConfig,
-
     /// How much scrolling history to keep.
-    #[serde(default, deserialize_with = "failure_default")]
     pub scrolling: Scrolling,
 
     /// Cursor configuration.
-    #[serde(default, deserialize_with = "failure_default")]
     pub cursor: Cursor,
 
     /// Shell startup directory.
-    #[serde(default, deserialize_with = "option_explicit_none")]
     pub working_directory: Option<PathBuf>,
 
     /// Additional configuration options not directly required by the terminal.
-    #[serde(flatten)]
+    #[config(flatten)]
     pub ui_config: T,
 
     /// Remain open after child process exits.
-    #[serde(skip)]
+    #[config(skip)]
     pub hold: bool,
 
-    // TODO: DEPRECATED
+    /// Bell configuration.
+    bell: BellConfig,
+
     #[cfg(windows)]
-    #[serde(default, deserialize_with = "failure_default")]
+    #[config(deprecated = "recompile with winpty feature or remove this setting")]
     pub winpty_backend: bool,
 
-    // TODO: DEPRECATED
-    #[serde(default, deserialize_with = "failure_default")]
+    #[config(deprecated = "use `bell` instead")]
     pub visual_bell: Option<BellConfig>,
-
-    // TODO: REMOVED
-    #[serde(default, deserialize_with = "failure_default")]
-    pub tabspaces: Option<usize>,
 }
 
 impl<T> Config<T> {
     #[inline]
-    pub fn draw_bold_text_with_bright_colors(&self) -> bool {
-        self.draw_bold_text_with_bright_colors
-    }
-
-    #[inline]
     pub fn bell(&self) -> &BellConfig {
         self.visual_bell.as_ref().unwrap_or(&self.bell)
     }
 }
 
-#[serde(default)]
-#[derive(Deserialize, Default, Clone, Debug, PartialEq, Eq)]
+#[derive(ConfigDeserialize, Clone, Debug, PartialEq, Eq)]
 pub struct Selection {
-    #[serde(deserialize_with = "failure_default")]
-    semantic_escape_chars: EscapeChars,
-    #[serde(deserialize_with = "failure_default")]
+    pub semantic_escape_chars: String,
     pub save_to_clipboard: bool,
 }
 
-impl Selection {
-    pub fn semantic_escape_chars(&self) -> &str {
-        &self.semantic_escape_chars.0
-    }
-}
-
-#[derive(Deserialize, Clone, Debug, PartialEq, Eq)]
-struct EscapeChars(String);
-
-impl Default for EscapeChars {
+impl Default for Selection {
     fn default() -> Self {
-        EscapeChars(String::from(",│`|:\"' ()[]{}<>\t"))
+        Self {
+            semantic_escape_chars: String::from(",│`|:\"' ()[]{}<>\t"),
+            save_to_clipboard: Default::default(),
+        }
     }
 }
 
-#[serde(default)]
-#[derive(Deserialize, Copy, Clone, Debug, PartialEq)]
+#[derive(ConfigDeserialize, Copy, Clone, Debug, PartialEq)]
 pub struct Cursor {
-    #[serde(deserialize_with = "failure_default")]
     pub style: ConfigCursorStyle,
-    #[serde(deserialize_with = "option_explicit_none")]
     pub vi_mode_style: Option<ConfigCursorStyle>,
-    #[serde(deserialize_with = "failure_default")]
-    blink_interval: BlinkInterval,
-    #[serde(deserialize_with = "deserialize_cursor_thickness")]
+    pub unfocused_hollow: bool,
+
     thickness: Percentage,
-    #[serde(deserialize_with = "failure_default")]
-    unfocused_hollow: DefaultTrueBool,
+    blink_interval: u64,
 }
 
-impl Cursor {
-    #[inline]
-    pub fn unfocused_hollow(self) -> bool {
-        self.unfocused_hollow.0
+impl Default for Cursor {
+    fn default() -> Self {
+        Self {
+            thickness: Percentage(0.15),
+            unfocused_hollow: true,
+            blink_interval: 750,
+            style: Default::default(),
+            vi_mode_style: Default::default(),
+        }
     }
+}
 
+impl Cursor {
     #[inline]
-    pub fn thickness(self) -> f64 {
-        self.thickness.0 as f64
+    pub fn thickness(self) -> f32 {
+        self.thickness.as_f32()
     }
 
     #[inline]
@@ -157,48 +127,7 @@ impl Cursor {
 
     #[inline]
     pub fn blink_interval(self) -> u64 {
-        max(self.blink_interval.0, MIN_BLINK_INTERVAL)
-    }
-}
-
-impl Default for Cursor {
-    fn default() -> Self {
-        Self {
-            style: Default::default(),
-            vi_mode_style: Default::default(),
-            thickness: Percentage::new(DEFAULT_CURSOR_THICKNESS),
-            unfocused_hollow: Default::default(),
-            blink_interval: Default::default(),
-        }
-    }
-}
-
-#[derive(Deserialize, Copy, Clone, Debug, PartialEq)]
-struct BlinkInterval(u64);
-
-impl Default for BlinkInterval {
-    fn default() -> Self {
-        BlinkInterval(750)
-    }
-}
-
-fn deserialize_cursor_thickness<'a, D>(deserializer: D) -> Result<Percentage, D::Error>
-where
-    D: Deserializer<'a>,
-{
-    let value = Value::deserialize(deserializer)?;
-    match Percentage::deserialize(value) {
-        Ok(value) => Ok(value),
-        Err(err) => {
-            error!(
-                target: LOG_TARGET_CONFIG,
-                "Problem with config: {}, using default thickness value {}",
-                err,
-                DEFAULT_CURSOR_THICKNESS
-            );
-
-            Ok(Percentage::new(DEFAULT_CURSOR_THICKNESS))
-        },
+        max(self.blink_interval, MIN_BLINK_INTERVAL)
     }
 }
 
@@ -206,17 +135,12 @@ where
 #[derive(Deserialize, Debug, Copy, Clone, PartialEq, Eq)]
 pub enum ConfigCursorStyle {
     Shape(CursorShape),
-    WithBlinking {
-        #[serde(default, deserialize_with = "failure_default")]
-        shape: CursorShape,
-        #[serde(default, deserialize_with = "failure_default")]
-        blinking: CursorBlinking,
-    },
+    WithBlinking { shape: CursorShape, blinking: CursorBlinking },
 }
 
 impl Default for ConfigCursorStyle {
     fn default() -> Self {
-        Self::WithBlinking { shape: CursorShape::default(), blinking: CursorBlinking::default() }
+        Self::Shape(CursorShape::default())
     }
 }
 
@@ -241,7 +165,7 @@ impl From<ConfigCursorStyle> for CursorStyle {
     }
 }
 
-#[derive(Deserialize, Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(ConfigDeserialize, Debug, Copy, Clone, PartialEq, Eq)]
 pub enum CursorBlinking {
     Never,
     Off,
@@ -275,11 +199,7 @@ impl Into<bool> for CursorBlinking {
 #[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
 pub enum Program {
     Just(String),
-    WithArgs {
-        program: String,
-        #[serde(default, deserialize_with = "failure_default")]
-        args: Vec<String>,
-    },
+    WithArgs { program: String, args: Vec<String> },
 }
 
 impl Program {
@@ -299,9 +219,15 @@ impl Program {
 }
 
 /// Wrapper around f32 that represents a percentage value between 0.0 and 1.0.
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Deserialize, Clone, Copy, Debug, PartialEq)]
 pub struct Percentage(f32);
 
+impl Default for Percentage {
+    fn default() -> Self {
+        Percentage(1.0)
+    }
+}
+
 impl Percentage {
     pub fn new(value: f32) -> Self {
         Percentage(if value < 0.0 {
@@ -317,55 +243,3 @@ impl Percentage {
         self.0
     }
 }
-
-impl Default for Percentage {
-    fn default() -> Self {
-        Percentage(1.0)
-    }
-}
-
-impl<'a> Deserialize<'a> for Percentage {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'a>,
-    {
-        Ok(Percentage::new(f32::deserialize(deserializer)?))
-    }
-}
-
-#[derive(Deserialize, Copy, Clone, Debug, PartialEq, Eq)]
-struct DefaultTrueBool(bool);
-
-impl Default for DefaultTrueBool {
-    fn default() -> Self {
-        DefaultTrueBool(true)
-    }
-}
-
-fn fallback_default<T, E>(err: E) -> T
-where
-    T: Default,
-    E: Display,
-{
-    error!(target: LOG_TARGET_CONFIG, "Problem with config: {}; using default value", err);
-    T::default()
-}
-
-pub fn failure_default<'a, D, T>(deserializer: D) -> Result<T, D::Error>
-where
-    D: Deserializer<'a>,
-    T: Deserialize<'a> + Default,
-{
-    Ok(T::deserialize(Value::deserialize(deserializer)?).unwrap_or_else(fallback_default))
-}
-
-pub fn option_explicit_none<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
-where
-    D: Deserializer<'de>,
-    T: Deserialize<'de> + Default,
-{
-    Ok(match Value::deserialize(deserializer)? {
-        Value::String(ref value) if value.to_lowercase() == "none" => None,
-        value => Some(T::deserialize(value).unwrap_or_else(fallback_default)),
-    })
-}