monolith

public
Star0
Watch0
165 commits 1 branch 0 tags 0 releases1.5 MiB
//! The TOML config. Parsing and validation only, the compositor applies it.

use monolith_ipc::Command;
use regex::Regex;
use serde::Deserialize;
use serde::de::DeserializeOwned;
use std::fmt;
use std::path::{Path, PathBuf};

pub const DEFAULT: &str = include_str!("../default.toml");

#[derive(Debug, Clone)]
pub struct Config {
    pub general: General,
    pub output: Outputs,
    pub decoration: Decoration,
    pub animation: Animation,
    pub keyboard: Keyboard,
    pub input: Input,
    pub idle: Idle,
    pub binds: Vec<Bind>,
    pub rules: Vec<Rule>,
    pub startup: Vec<Vec<String>>,
}

#[derive(Deserialize, Debug, Clone, PartialEq)]
#[serde(default, deny_unknown_fields)]
pub struct General {
    /// What `Mod` means in binds.
    #[serde(rename = "mod")]
    pub mod_key: Modifier,
    pub gaps: Gaps,
    /// What a window move does when it meets a neighbour.
    #[serde(rename = "move")]
    pub move_mode: MoveMode,
    pub focus_follows_mouse: bool,
    pub mouse_follows_focus: bool,
    /// The first window to land on or move to an empty tag nobody is
    /// viewing brings that tag into view on its output.
    pub view_tag_on_first_window: bool,
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
#[serde(rename_all = "lowercase")]
pub enum MoveMode {
    /// Trade places with it.
    #[default]
    Swap,
    /// Join its lane, stacking with it if it is alone.
    Merge,
}

impl Default for General {
    fn default() -> Self {
        Self {
            mod_key: Modifier::Super,
            gaps: Gaps::default(),
            move_mode: MoveMode::Swap,
            focus_follows_mouse: false,
            mouse_follows_focus: false,
            view_tag_on_first_window: true,
        }
    }
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
#[serde(default, deny_unknown_fields)]
pub struct Gaps {
    pub inner: f64,
    pub outer: f64,
}

impl Default for Gaps {
    fn default() -> Self {
        Self {
            inner: 8.0,
            outer: 8.0,
        }
    }
}

#[derive(Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default)]
pub struct Outputs {
    pub vrr: Vrr,
    /// Settings for one connector, by name, like `DP-1`.
    #[serde(flatten)]
    pub named: std::collections::BTreeMap<String, OutputConfig>,
}

/// Transform and position follow a reload. A new mode waits for a restart
/// or a replug, since it means a modeset.
#[derive(Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default, deny_unknown_fields)]
pub struct OutputConfig {
    pub transform: OutputTransform,
    /// Top left corner in the global layout. Outputs without one are placed
    /// to the right of the others.
    pub position: Option<[i32; 2]>,
    /// `WIDTHxHEIGHT` or `WIDTHxHEIGHT@HZ`. Without a rate the highest one
    /// for that size wins.
    pub mode: Option<String>,
}

/// Counterclockwise rotation, optionally after flipping horizontally.
#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
#[serde(rename_all = "kebab-case")]
pub enum OutputTransform {
    #[default]
    Normal,
    #[serde(rename = "90")]
    Rotate90,
    #[serde(rename = "180")]
    Rotate180,
    #[serde(rename = "270")]
    Rotate270,
    Flipped,
    #[serde(rename = "flipped-90")]
    Flipped90,
    #[serde(rename = "flipped-180")]
    Flipped180,
    #[serde(rename = "flipped-270")]
    Flipped270,
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
#[serde(rename_all = "lowercase")]
pub enum Vrr {
    Off,
    On,
    /// Only while a fullscreen window is shown, where a game sets the pace.
    #[default]
    Fullscreen,
}

#[derive(Deserialize, Debug, Clone, PartialEq)]
#[serde(default, deny_unknown_fields)]
pub struct Decoration {
    /// Border width in logical pixels, drawn in the gap around each window.
    pub border: u32,
    pub radius: Corners,
    pub focused: Color,
    pub unfocused: Color,
}

/// Corner radii in logical pixels, top left, top right, bottom right and
/// bottom left. One number rounds every corner alike.
#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
#[serde(from = "CornersToml")]
pub struct Corners(pub [u32; 4]);

#[derive(Deserialize)]
#[serde(
    untagged,
    expecting = "expected a number or [top left, top right, bottom right, bottom left]"
)]
enum CornersToml {
    All(u32),
    Each([u32; 4]),
}

impl From<CornersToml> for Corners {
    fn from(c: CornersToml) -> Self {
        match c {
            CornersToml::All(r) => Self([r; 4]),
            CornersToml::Each(r) => Self(r),
        }
    }
}

impl Default for Decoration {
    fn default() -> Self {
        Self {
            border: 2,
            radius: Corners([0; 4]),
            focused: Color::rgb(0x88, 0xbf, 0xd1),
            unfocused: Color::rgb(0x3b, 0x42, 0x52),
        }
    }
}

/// Straight RGBA from `#rrggbb` or `#rrggbbaa`.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Color(pub [f32; 4]);

impl Color {
    pub const fn rgb(r: u8, g: u8, b: u8) -> Self {
        Self([r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0])
    }
}

impl<'de> Deserialize<'de> for Color {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        let s = String::deserialize(d)?;
        let hex = s.strip_prefix('#').unwrap_or(&s);
        let bad =
            || serde::de::Error::custom(format!("bad colour {s:?}, use #rrggbb or #rrggbbaa"));
        if !matches!(hex.len(), 6 | 8) || !hex.is_ascii() {
            return Err(bad());
        }
        let mut c = [1.0f32; 4];
        for (i, v) in c.iter_mut().enumerate().take(hex.len() / 2) {
            let byte = u8::from_str_radix(&hex[i * 2..i * 2 + 2], 16).map_err(|_| bad())?;
            *v = f32::from(byte) / 255.0;
        }
        Ok(Self(c))
    }
}

#[derive(Deserialize, Debug, Clone, PartialEq)]
#[serde(default, deny_unknown_fields)]
pub struct Animation {
    pub enabled: bool,
    pub style: AnimationStyle,
    /// Every phase of a planned transition lasts this long.
    pub phase_ms: u64,
    /// A cubic bezier, as in CSS.
    pub curve: [f64; 4],
}

impl Default for Animation {
    fn default() -> Self {
        Self {
            enabled: true,
            style: AnimationStyle::Orthogonal,
            phase_ms: 160,
            curve: [0.45, 0.0, 0.2, 1.0],
        }
    }
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum AnimationStyle {
    Orthogonal,
    Direct,
}

#[derive(Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default, deny_unknown_fields)]
pub struct Idle {
    /// Seconds without input before every output is switched off, 0 for
    /// never.
    pub blank_after: u64,
}

#[derive(Deserialize, Debug, Clone, PartialEq)]
#[serde(default, deny_unknown_fields)]
pub struct Keyboard {
    pub rules: String,
    pub model: String,
    pub layout: String,
    pub variant: String,
    pub options: Option<String>,
    pub repeat_delay: i32,
    pub repeat_rate: i32,
}

impl Default for Keyboard {
    fn default() -> Self {
        Self {
            rules: String::new(),
            model: String::new(),
            layout: String::new(),
            variant: String::new(),
            options: None,
            repeat_delay: 200,
            repeat_rate: 25,
        }
    }
}

/// libinput settings for pointing devices. Unset options keep libinput's
/// default for the device.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Input {
    pub pointer: DeviceSettings,
    /// Devices that can tap, which libinput only offers on touchpads.
    pub touchpad: DeviceSettings,
    /// Overrides for devices by name, later entries winning.
    pub device: Vec<NamedDevice>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct NamedDevice {
    pub name: String,
    pub settings: DeviceSettings,
}

#[derive(Deserialize, Debug, Clone, PartialEq, Default)]
#[serde(default, deny_unknown_fields)]
pub struct DeviceSettings {
    pub accel_profile: Option<AccelProfile>,
    pub accel_speed: Option<f64>,
    /// The custom profile's curve, pointer speed sampled every `accel_step`
    /// device units per millisecond.
    pub accel_points: Option<Vec<f64>>,
    pub accel_step: Option<f64>,
    pub natural_scroll: Option<bool>,
    pub left_handed: Option<bool>,
    pub tap: Option<bool>,
    pub tap_drag: Option<bool>,
    pub tap_drag_lock: Option<bool>,
    pub dwt: Option<bool>,
    pub middle_emulation: Option<bool>,
    pub scroll_method: Option<ScrollMethod>,
    pub scroll_button: Option<u32>,
    pub click_method: Option<ClickMethod>,
    /// Applied by the compositor, libinput has no such setting.
    pub scroll_factor: Option<f64>,
}

impl DeviceSettings {
    /// `self` with every option `over` sets replaced.
    pub fn overlay(&self, over: &Self) -> Self {
        Self {
            accel_profile: over.accel_profile.or(self.accel_profile),
            accel_speed: over.accel_speed.or(self.accel_speed),
            accel_points: over
                .accel_points
                .clone()
                .or_else(|| self.accel_points.clone()),
            accel_step: over.accel_step.or(self.accel_step),
            natural_scroll: over.natural_scroll.or(self.natural_scroll),
            left_handed: over.left_handed.or(self.left_handed),
            tap: over.tap.or(self.tap),
            tap_drag: over.tap_drag.or(self.tap_drag),
            tap_drag_lock: over.tap_drag_lock.or(self.tap_drag_lock),
            dwt: over.dwt.or(self.dwt),
            middle_emulation: over.middle_emulation.or(self.middle_emulation),
            scroll_method: over.scroll_method.or(self.scroll_method),
            scroll_button: over.scroll_button.or(self.scroll_button),
            click_method: over.click_method.or(self.click_method),
            scroll_factor: over.scroll_factor.or(self.scroll_factor),
        }
    }

    fn validate(&mut self, name: &str, w: &mut Vec<String>) {
        if let Some(s) = self.accel_speed
            && !(-1.0..=1.0).contains(&s)
        {
            w.push(format!(
                "{name}.accel_speed: {s} is outside -1 to 1, ignored"
            ));
            self.accel_speed = None;
        }
        if let Some(f) = self.scroll_factor
            && !(f.is_finite() && f >= 0.0)
        {
            w.push(format!(
                "{name}.scroll_factor: {f} must be zero or more, ignored"
            ));
            self.scroll_factor = None;
        }
        if self.accel_points.is_some() != self.accel_step.is_some() {
            w.push(format!(
                "{name}: accel_points needs accel_step and the other way round, both ignored"
            ));
            self.accel_points = None;
            self.accel_step = None;
        }
    }
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum AccelProfile {
    Flat,
    Adaptive,
    Custom,
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum ScrollMethod {
    None,
    TwoFinger,
    Edge,
    OnButtonDown,
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
pub enum ClickMethod {
    ButtonAreas,
    Clickfinger,
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum Modifier {
    Super,
    Alt,
    Ctrl,
    Shift,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Hash)]
pub struct Mods {
    pub logo: bool,
    pub alt: bool,
    pub ctrl: bool,
    pub shift: bool,
}

impl Mods {
    pub fn has(&self, m: Modifier) -> bool {
        match m {
            Modifier::Super => self.logo,
            Modifier::Alt => self.alt,
            Modifier::Ctrl => self.ctrl,
            Modifier::Shift => self.shift,
        }
    }

    fn set(&mut self, m: Modifier) {
        match m {
            Modifier::Super => self.logo = true,
            Modifier::Alt => self.alt = true,
            Modifier::Ctrl => self.ctrl = true,
            Modifier::Shift => self.shift = true,
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct Bind {
    pub mods: Mods,
    /// An xkb keysym name, resolved by the compositor.
    pub key: String,
    pub command: Command,
}

#[derive(Debug, Clone)]
pub struct Rule {
    pub app_id: Option<Regex>,
    pub title: Option<Regex>,
    pub tag: Option<String>,
    pub output: Option<String>,
    pub floating: Option<bool>,
    pub sticky: Option<bool>,
    pub scratchpad: Option<String>,
}

/// Everything the matching rules say about a window, later rules winning.
#[derive(Debug, Clone, Default, PartialEq)]
pub struct Placement {
    pub tag: Option<String>,
    pub output: Option<String>,
    pub floating: Option<bool>,
    pub sticky: Option<bool>,
    pub scratchpad: Option<String>,
}

#[derive(Debug)]
pub enum Error {
    Io(PathBuf, std::io::Error),
    Toml(toml::de::Error),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Error::Io(p, e) => write!(f, "{}: {e}", p.display()),
            Error::Toml(e) => write!(f, "{e}"),
        }
    }
}

impl std::error::Error for Error {}

#[derive(Deserialize)]
#[serde(untagged)]
enum Words {
    Line(String),
    List(Vec<String>),
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RawRule {
    app_id: Option<String>,
    title: Option<String>,
    tag: Option<String>,
    output: Option<String>,
    floating: Option<bool>,
    sticky: Option<bool>,
    scratchpad: Option<String>,
}

impl Config {
    /// `$MONOLITH_CONFIG`, else `$XDG_CONFIG_HOME/monolith/config.toml`.
    pub fn path() -> Option<PathBuf> {
        if let Some(p) = std::env::var_os("MONOLITH_CONFIG") {
            return Some(p.into());
        }
        let base = std::env::var_os("XDG_CONFIG_HOME")
            .map(PathBuf::from)
            .or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".config")))?;
        Some(base.join("monolith/config.toml"))
    }

    /// Loads `path`, or the built-in default when it does not exist.
    pub fn load(path: Option<&Path>) -> Result<Loaded, Error> {
        match path {
            Some(p) => match std::fs::read_to_string(p) {
                Ok(text) => Self::parse(&text),
                Err(e) if e.kind() == std::io::ErrorKind::NotFound => Self::parse(DEFAULT),
                Err(e) => Err(Error::Io(p.to_owned(), e)),
            },
            None => Self::parse(DEFAULT),
        }
    }

    /// Only broken TOML fails. A bad option, bind or rule is left out with a
    /// warning, so one typo does not throw away the rest of the file.
    pub fn parse(text: &str) -> Result<Loaded, Error> {
        let mut table: toml::Table = toml::from_str(text).map_err(Error::Toml)?;
        let mut warnings = Vec::new();
        let w = &mut warnings;
        let general: General = section("general", table.remove("general"), w);
        let keyboard = section("keyboard", table.remove("keyboard"), w);
        let input = input(table.remove("input"), w);
        let idle = section("idle", table.remove("idle"), w);
        let animation = section("animation", table.remove("animation"), w);
        let decoration = section("decoration", table.remove("decoration"), w);
        let output: Outputs = section("output", table.remove("output"), w);
        for name in output.named.keys().filter(|n| !connector_like(n)) {
            w.push(format!(
                "output.{name}: not a connector name like DP-1 or HDMI-A-1, matches nothing"
            ));
        }
        let startup = items("startup", table.remove("startup"), w);
        let mut binds = Vec::new();
        if let Some(value) = table.remove("binds") {
            let entries: toml::Table = entry("binds", value, w).unwrap_or_default();
            for (combo, value) in entries {
                let name = format!("binds.{combo:?}");
                let bind = entry::<Words>(&name, value, w)
                    .map(|words| parse_bind(&combo, words, general.mod_key));
                match bind {
                    Some(Ok(b)) => binds.push(b),
                    Some(Err(e)) => w.push(format!("{name}: {e}, left out")),
                    None => {}
                }
            }
        }
        let regex = |p: Option<String>| p.map(|p| Regex::new(&p)).transpose();
        let mut rules = Vec::new();
        for (i, raw) in items::<RawRule>("rules", table.remove("rules"), w)
            .into_iter()
            .enumerate()
        {
            match (regex(raw.app_id), regex(raw.title)) {
                (Ok(app_id), Ok(title)) => rules.push(Rule {
                    app_id,
                    title,
                    tag: raw.tag,
                    output: raw.output,
                    floating: raw.floating,
                    sticky: raw.sticky,
                    scratchpad: raw.scratchpad,
                }),
                (Err(e), _) | (_, Err(e)) => {
                    let e = e
                        .to_string()
                        .split_whitespace()
                        .collect::<Vec<_>>()
                        .join(" ");
                    w.push(format!("rules[{i}]: {e}, left out"));
                }
            }
        }
        for key in table.keys() {
            w.push(format!("unknown section [{key}], ignored"));
        }
        let config = Self {
            general,
            animation,
            decoration,
            output,
            keyboard,
            input,
            idle,
            binds,
            rules,
            startup,
        };
        Ok(Loaded { config, warnings })
    }

    pub fn placement(&self, app_id: &str, title: &str) -> Placement {
        let mut p = Placement::default();
        let hit = |re: &Option<Regex>, s: &str| re.as_ref().is_none_or(|re| re.is_match(s));
        for r in &self.rules {
            if !hit(&r.app_id, app_id) || !hit(&r.title, title) {
                continue;
            }
            p.tag = r.tag.clone().or(p.tag);
            p.output = r.output.clone().or(p.output);
            p.floating = r.floating.or(p.floating);
            p.sticky = r.sticky.or(p.sticky);
            p.scratchpad = r.scratchpad.clone().or(p.scratchpad);
        }
        p
    }
}

fn parse_bind(combo: &str, words: Words, mod_key: Modifier) -> Result<Bind, String> {
    let parts: Vec<&str> = combo.split('+').map(str::trim).collect();
    let Some((&key, mods)) = parts.split_last().filter(|(k, _)| !k.is_empty()) else {
        return Err("no key".into());
    };
    let mut set = Mods::default();
    for m in mods {
        let m = match m.to_ascii_lowercase().as_str() {
            "mod" => mod_key,
            "super" | "logo" | "win" => Modifier::Super,
            "alt" => Modifier::Alt,
            "ctrl" | "control" => Modifier::Ctrl,
            "shift" => Modifier::Shift,
            other => return Err(format!("unknown modifier {other}")),
        };
        set.set(m);
    }
    let words: Vec<String> = match words {
        Words::Line(s) => s.split_whitespace().map(str::to_owned).collect(),
        Words::List(v) => v,
    };
    let command = Command::parse(&words).map_err(|e| e.0)?;
    Ok(Bind {
        mods: set,
        key: key.to_owned(),
        command,
    })
}

/// A config and what had to be left out of it.
pub struct Loaded {
    pub config: Config,
    pub warnings: Vec<String>,
}

fn entry<T: DeserializeOwned>(name: &str, value: toml::Value, w: &mut Vec<String>) -> Option<T> {
    value
        .try_into()
        .map_err(|e| w.push(format!("{name}: {}, left out", one_line(&e))))
        .ok()
}

fn input(value: Option<toml::Value>, w: &mut Vec<String>) -> Input {
    let mut table = match value {
        None => toml::Table::new(),
        Some(toml::Value::Table(t)) => t,
        Some(_) => {
            w.push("[input] is not a table, using the defaults".into());
            toml::Table::new()
        }
    };
    let mut input = Input {
        pointer: section("input.pointer", table.remove("pointer"), w),
        touchpad: section("input.touchpad", table.remove("touchpad"), w),
        device: Vec::new(),
    };
    for (i, mut entry) in items::<toml::Table>("input.device", table.remove("device"), w)
        .into_iter()
        .enumerate()
    {
        let name = format!("input.device[{i}]");
        let Some(toml::Value::String(device)) = entry.remove("name") else {
            w.push(format!("{name}: no name, left out"));
            continue;
        };
        input.device.push(NamedDevice {
            name: device,
            settings: section(&name, Some(toml::Value::Table(entry)), w),
        });
    }
    for key in table.keys() {
        w.push(format!("input.{key}: unknown option, ignored"));
    }
    input.pointer.validate("input.pointer", w);
    input.touchpad.validate("input.touchpad", w);
    for (i, d) in input.device.iter_mut().enumerate() {
        d.settings.validate(&format!("input.device[{i}]"), w);
    }
    input
}

fn connector_like(name: &str) -> bool {
    name.rsplit_once('-').is_some_and(|(kind, n)| {
        !kind.is_empty() && !n.is_empty() && n.bytes().all(|b| b.is_ascii_digit())
    })
}

/// A section with every option that does not fit left at its default.
fn section<T: DeserializeOwned + Default>(
    name: &str,
    value: Option<toml::Value>,
    w: &mut Vec<String>,
) -> T {
    let Some(value) = value else {
        return T::default();
    };
    if let Ok(t) = value.clone().try_into() {
        return t;
    }
    let toml::Value::Table(options) = value else {
        w.push(format!("[{name}] is not a table, using the defaults"));
        return T::default();
    };
    let mut kept = toml::Table::new();
    for (key, v) in options {
        let alone = toml::Table::from_iter([(key.clone(), v.clone())]);
        match toml::Value::Table(alone).try_into::<T>() {
            Ok(_) => {
                kept.insert(key, v);
            }
            Err(e) => {
                let e = one_line(&e);
                let fallback = if e.starts_with("unknown field") {
                    "ignored"
                } else {
                    "using the default"
                };
                w.push(format!("{name}.{key}: {e}, {fallback}"));
            }
        }
    }
    toml::Value::Table(kept).try_into().unwrap_or_default()
}

/// An array with the elements that do not fit left out.
fn items<T: DeserializeOwned>(
    name: &str,
    value: Option<toml::Value>,
    w: &mut Vec<String>,
) -> Vec<T> {
    match value {
        None => Vec::new(),
        Some(toml::Value::Array(a)) => a
            .into_iter()
            .enumerate()
            .filter_map(|(i, v)| entry(&format!("{name}[{i}]"), v, w))
            .collect(),
        Some(_) => {
            w.push(format!("{name} is not an array, left out"));
            Vec::new()
        }
    }
}

fn one_line(e: &toml::de::Error) -> String {
    e.message().trim().replace('\n', " ")
}
#[cfg(test)]
mod tests {
    use super::*;

    /// default.toml documents the defaults for users, and the Default impls
    /// apply them to sections a user config leaves out. They must agree.
    #[test]
    fn default_toml_states_the_defaults() {
        let loaded = Config::parse(DEFAULT).unwrap();
        assert_eq!(loaded.warnings, Vec::<String>::new());
        let c = loaded.config;
        assert_eq!(c.general, General::default());
        assert_eq!(c.output, Outputs::default());
        assert_eq!(c.decoration, Decoration::default());
        assert_eq!(c.animation, Animation::default());
        assert_eq!(c.keyboard, Keyboard::default());
        assert_eq!(c.input, Input::default());
        assert_eq!(c.idle, Idle::default());
        assert!(c.binds.len() > 40);
    }

    #[test]
    fn a_bad_option_costs_only_itself() {
        let loaded = Config::parse(
            r##"
            [general]
            gaps = { inner = 3, outer = 3 }
            focus_follows_mouse = "yes"
            typo = 1
            [decoration]
            radius = [1, 2, 3, 4]
            focused = "#zzzzzz"
            [binds]
            "Mod+Return" = "spawn beer"
            "Hyper+x" = "close"
            [output.DP-1]
            transform = "90"
            position = [0, 0]
            [output.DP-2]
            transform = "sideways"
            [output.DP1]
            [[rules]]
            app_id = "("
            [[rules]]
            app_id = "^mpv$"
            floating = true
            "##,
        )
        .unwrap();
        let c = loaded.config;
        assert_eq!(c.general.gaps.inner, 3.0);
        assert!(!c.general.focus_follows_mouse);
        assert_eq!(c.decoration.radius, Corners([1, 2, 3, 4]));
        assert_eq!(c.decoration.focused, Decoration::default().focused);
        assert_eq!((c.binds.len(), c.rules.len()), (1, 1));
        assert_eq!(c.output.named["DP-1"].transform, OutputTransform::Rotate90);
        assert!(!c.output.named.contains_key("DP-2"));
        assert_eq!(loaded.warnings.len(), 7, "{:#?}", loaded.warnings);
    }

    #[test]
    fn a_bad_device_option_costs_only_itself() {
        let loaded = Config::parse(
            r#"
            [input.pointer]
            accel_speed = 2.0
            scroll_method = "two-finger"
            [[input.device]]
            name = "Mouse"
            accel_profile = "flat"
            [[input.device]]
            name = "Typo"
            tapp = true
            [[input.device]]
            name = "Half"
            accel_points = [0.0, 1.0]
            "#,
        )
        .unwrap();
        let input = loaded.config.input;
        assert_eq!(input.pointer.accel_speed, None);
        assert_eq!(input.pointer.scroll_method, Some(ScrollMethod::TwoFinger));
        let names: Vec<_> = input.device.iter().map(|d| d.name.as_str()).collect();
        assert_eq!(names, ["Mouse", "Typo", "Half"]);
        assert_eq!(
            input.device[0].settings.accel_profile,
            Some(AccelProfile::Flat)
        );
        assert_eq!(input.device[1].settings, DeviceSettings::default());
        assert_eq!(input.device[2].settings.accel_points, None);
        assert_eq!(loaded.warnings.len(), 3, "{:#?}", loaded.warnings);
    }
}