monolith

public
Star0
Watch0
231 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 lid: Lid,
    pub xwayland: Xwayland,
    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,
    /// A new window splits the one it opens beside along that window's
    /// longer side, instead of joining its container.
    pub autotile: bool,
    /// 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(),
            autotile: true,
            move_mode: MoveMode::Swap,
            focus_follows_mouse: false,
            mouse_follows_focus: false,
            view_tag_on_first_window: true,
        }
    }
}

#[derive(Deserialize, Debug, Clone, PartialEq)]
#[serde(default, deny_unknown_fields)]
pub struct Xwayland {
    /// Which X11 clients may read a Wayland-owned selection.
    pub selection_access: SelectionAccess,
}

impl Default for Xwayland {
    fn default() -> Self {
        Self {
            selection_access: SelectionAccess::Focused,
        }
    }
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum SelectionAccess {
    /// Only the X11 window holding keyboard focus.
    Focused,
    /// Every X11 client, which clipboard managers and headless tools need.
    Any,
}

#[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`, or `nested` for the
    /// nested backend's window.
    #[serde(flatten)]
    pub named: std::collections::BTreeMap<String, OutputConfig>,
}

/// Transform, position and scale 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>,
    /// How many physical pixels make a logical one, `0.5` to `4.0` in steps of
    /// 1/120. Positions are in logical pixels.
    pub scale: Option<f64>,
}

impl OutputConfig {
    pub fn scale(&self) -> f64 {
        self.scale.unwrap_or(1.0)
    }

    fn validate(&mut self, name: &str, w: &mut Vec<String>) {
        let Some(s) = self.scale else {
            return;
        };
        if !(MIN_SCALE..=MAX_SCALE).contains(&s) {
            w.push(format!(
                "{name}.scale: {s} is outside {MIN_SCALE} to {MAX_SCALE}, ignored"
            ));
            self.scale = None;
        } else {
            self.scale = Some((s * 120.0).round() / 120.0);
        }
    }
}

const MIN_SCALE: f64 = 0.5;
const MAX_SCALE: f64 = 4.0;

/// 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,
    pub urgent: 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),
            urgent: Color::rgb(0xeb, 0xcb, 0x8b),
        }
    }
}

/// 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, Default)]
#[serde(default, deny_unknown_fields)]
pub struct Lid {
    /// What closing the lid does while no other output is connected.
    pub close: LidAction,
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
#[serde(rename_all = "lowercase")]
pub enum LidAction {
    #[default]
    Suspend,
    Poweroff,
    /// Leave it to logind or whatever else watches the switch.
    Ignore,
}

#[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 when: Matcher,
    pub set: Placement,
}

/// What a rule asks of a window. Every matcher given must hit.
#[derive(Debug, Clone, Default)]
pub struct Matcher {
    pub app_id: Option<Regex>,
    pub title: Option<Regex>,
    pub initial_title: Option<Regex>,
    pub class: Option<Regex>,
    pub instance: Option<Regex>,
    pub xwayland: Option<bool>,
    pub dialog: Option<bool>,
    pub parent_app_id: Option<Regex>,
}

/// What the rules can see of a window. `class` and `instance` are None for
/// windows that are not X11, and `parent_app_id` for those without a parent.
#[derive(Debug, Clone, Copy, Default)]
pub struct Subject<'a> {
    pub app_id: &'a str,
    pub title: &'a str,
    pub initial_title: &'a str,
    pub class: Option<&'a str>,
    pub instance: Option<&'a str>,
    pub xwayland: bool,
    pub dialog: bool,
    pub parent_app_id: Option<&'a str>,
}

impl Matcher {
    fn hits(&self, s: &Subject) -> bool {
        fn re(re: &Option<Regex>, s: Option<&str>) -> bool {
            re.as_ref()
                .is_none_or(|re| s.is_some_and(|s| re.is_match(s)))
        }
        re(&self.app_id, Some(s.app_id))
            && re(&self.title, Some(s.title))
            && re(&self.initial_title, Some(s.initial_title))
            && re(&self.class, s.class)
            && re(&self.instance, s.instance)
            && re(&self.parent_app_id, s.parent_app_id)
            && self.xwayland.is_none_or(|x| x == s.xwayland)
            && self.dialog.is_none_or(|d| d == s.dialog)
    }
}

/// Where a rule puts a floating window.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum At {
    /// From the top left of the output's area.
    Position(i32, i32),
    Center,
}

#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum IdleInhibit {
    /// While the window is on screen.
    Visible,
    Fullscreen,
}

/// 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>,
    pub size: Option<(u32, u32)>,
    pub at: Option<At>,
    /// A zero axis puts no lower bound on it.
    pub min_size: Option<(u32, u32)>,
    /// A zero axis puts no upper bound on it.
    pub max_size: Option<(u32, u32)>,
    pub fullscreen: Option<bool>,
    pub focus: Option<bool>,
    pub opacity: Option<f32>,
    pub idle_inhibit: Option<IdleInhibit>,
    pub vrr: Option<bool>,
    /// Inert until tearing presentation exists.
    pub tearing: Option<bool>,
}

impl Placement {
    fn over(&mut self, r: &Placement) {
        self.tag = r.tag.clone().or(self.tag.take());
        self.output = r.output.clone().or(self.output.take());
        self.floating = r.floating.or(self.floating);
        self.sticky = r.sticky.or(self.sticky);
        self.scratchpad = r.scratchpad.clone().or(self.scratchpad.take());
        self.size = r.size.or(self.size);
        self.at = r.at.or(self.at);
        self.min_size = r.min_size.or(self.min_size);
        self.max_size = r.max_size.or(self.max_size);
        self.fullscreen = r.fullscreen.or(self.fullscreen);
        self.focus = r.focus.or(self.focus);
        self.opacity = r.opacity.or(self.opacity);
        self.idle_inhibit = r.idle_inhibit.or(self.idle_inhibit);
        self.vrr = r.vrr.or(self.vrr);
        self.tearing = r.tearing.or(self.tearing);
    }

    /// Bounds `(w, h)` by `min_size` and `max_size`.
    pub fn clamp_size(&self, w: f64, h: f64) -> (f64, f64) {
        let axis = |v: f64, min: Option<u32>, max: Option<u32>| {
            let v = min.map_or(v, |m| v.max(f64::from(m)));
            max.filter(|&m| m > 0).map_or(v, |m| v.min(f64::from(m)))
        };
        let (min, max) = (self.min_size, self.max_size);
        (
            axis(w, min.map(|s| s.0), max.map(|s| s.0)),
            axis(h, min.map(|s| s.1), max.map(|s| s.1)),
        )
    }
}

#[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>,
    initial_title: Option<String>,
    class: Option<String>,
    instance: Option<String>,
    xwayland: Option<bool>,
    dialog: Option<bool>,
    parent_app_id: Option<String>,
    tag: Option<String>,
    output: Option<String>,
    floating: Option<bool>,
    sticky: Option<bool>,
    scratchpad: Option<String>,
    size: Option<[u32; 2]>,
    position: Option<[i32; 2]>,
    center: Option<bool>,
    min_size: Option<[u32; 2]>,
    max_size: Option<[u32; 2]>,
    fullscreen: Option<bool>,
    focus: Option<bool>,
    opacity: Option<f32>,
    idle_inhibit: Option<IdleInhibit>,
    vrr: Option<bool>,
    tearing: Option<bool>,
}

impl RawRule {
    /// A pattern that does not compile drops the rule, since without it the
    /// rule would hit every window. A bad effect only drops itself.
    fn build(self, name: &str, warn: &mut Vec<String>) -> Result<Rule, regex::Error> {
        let regex = |p: Option<String>| p.map(|p| Regex::new(&p)).transpose();
        let when = Matcher {
            app_id: regex(self.app_id)?,
            title: regex(self.title)?,
            initial_title: regex(self.initial_title)?,
            class: regex(self.class)?,
            instance: regex(self.instance)?,
            xwayland: self.xwayland,
            dialog: self.dialog,
            parent_app_id: regex(self.parent_app_id)?,
        };
        let mut set = Placement {
            tag: self.tag,
            output: self.output,
            floating: self.floating,
            sticky: self.sticky,
            scratchpad: self.scratchpad,
            size: self.size.map(|[a, b]| (a, b)),
            at: self.position.map(|[x, y]| At::Position(x, y)),
            min_size: self.min_size.map(|[a, b]| (a, b)),
            max_size: self.max_size.map(|[a, b]| (a, b)),
            fullscreen: self.fullscreen,
            focus: self.focus,
            opacity: self.opacity,
            idle_inhibit: self.idle_inhibit,
            vrr: self.vrr,
            tearing: self.tearing,
        };
        if self.center == Some(true) {
            if set.at.is_some() {
                warn.push(format!("{name}: position and center both set, center wins"));
            }
            set.at = Some(At::Center);
        }
        if set.size.is_some_and(|(w, h)| w == 0 || h == 0) {
            warn.push(format!("{name}.size: must be above zero, ignored"));
            set.size = None;
        }
        if let (Some(min), Some(max)) = (set.min_size, set.max_size)
            && [(min.0, max.0), (min.1, max.1)]
                .iter()
                .any(|&(lo, hi)| hi > 0 && lo > hi)
        {
            warn.push(format!(
                "{name}: min_size is larger than max_size, both ignored"
            ));
            set.min_size = None;
            set.max_size = None;
        }
        if let Some(o) = set.opacity
            && !(0.0..=1.0).contains(&o)
        {
            warn.push(format!("{name}.opacity: {o} is outside 0 to 1, ignored"));
            set.opacity = None;
        }
        Ok(Rule { when, set })
    }
}

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 TOML too broken to repair line by line 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 warnings = Vec::new();
        let mut table = lenient_table(text, &mut warnings)?;
        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 lid = section("lid", table.remove("lid"), w);
        let animation = section("animation", table.remove("animation"), w);
        let xwayland = section("xwayland", table.remove("xwayland"), w);
        let decoration = section("decoration", table.remove("decoration"), w);
        let mut output: Outputs = section("output", table.remove("output"), w);
        for name in output
            .named
            .keys()
            .filter(|n| *n != "nested" && !connector_like(n))
        {
            w.push(format!(
                "output.{name}: not a connector name like DP-1 or HDMI-A-1, matches nothing"
            ));
        }
        for (name, config) in &mut output.named {
            config.validate(&format!("output.{name}"), w);
        }
        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 mut rules = Vec::new();
        for (i, raw) in items::<RawRule>("rules", table.remove("rules"), w)
            .into_iter()
            .enumerate()
        {
            let name = format!("rules[{i}]");
            match raw.build(&name, w) {
                Ok(rule) => rules.push(rule),
                Err(e) => {
                    let e = e
                        .to_string()
                        .split_whitespace()
                        .collect::<Vec<_>>()
                        .join(" ");
                    w.push(format!("{name}: {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,
            lid,
            xwayland,
            binds,
            rules,
            startup,
        };
        Ok(Loaded { config, warnings })
    }

    pub fn placement(&self, window: &Subject) -> Placement {
        let mut p = Placement::default();
        for r in self.rules.iter().filter(|r| r.when.hits(window)) {
            p.over(&r.set);
        }
        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>,
}

/// Parses TOML, dropping each line the parser rejects and trying again, so a
/// syntax error costs its own line rather than the whole file. An unclosed
/// table or array is reported lines after the mistake, so the culprit is
/// the nearby line whose removal clears that error, or else gets furthest.
fn lenient_table(text: &str, w: &mut Vec<String>) -> Result<toml::Table, Error> {
    const MAX_BAD_LINES: usize = 32;
    const LOOK_BACK: usize = 4;
    let mut lines: Vec<(usize, &str)> = text.lines().enumerate().map(|(i, l)| (i + 1, l)).collect();
    let join =
        |lines: &[(usize, &str)]| lines.iter().map(|(_, l)| *l).collect::<Vec<_>>().join("\n");
    let failing_line = |lines: &[(usize, &str)], e: &toml::de::Error| -> Option<usize> {
        let at = e.span()?.start;
        let text = join(lines);
        let index = text[..at.min(text.len())].matches('\n').count();
        Some(index.min(lines.len().saturating_sub(1)))
    };
    for _ in 0..MAX_BAD_LINES {
        let e = match toml::from_str(&join(&lines)) {
            Ok(table) => return Ok(table),
            Err(e) => e,
        };
        let Some(at) = failing_line(&lines, &e) else {
            return Err(Error::Toml(e));
        };
        let progress = |drop: usize| {
            let mut rest = lines.clone();
            rest.remove(drop);
            match toml::from_str::<toml::Table>(&join(&rest)) {
                Ok(_) => (true, usize::MAX),
                Err(next) => (
                    next.message() != e.message(),
                    failing_line(&rest, &next).map_or(0, |i| rest[i].0),
                ),
            }
        };
        let culprit = (at.saturating_sub(LOOK_BACK)..=at)
            .filter(|&i| !lines[i].1.trim().is_empty())
            .max_by_key(|&i| progress(i))
            .unwrap_or(at);
        let (line, _) = lines.remove(culprit);
        w.push(format!("line {line}: {}, left out", e.message().trim()));
    }
    toml::from_str(&join(&lines)).map_err(Error::Toml)
}

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_eq!(c.lid, Lid::default());
        assert_eq!(c.xwayland, Xwayland::default());
        assert!(c.binds.len() > 40);
    }

    #[test]
    fn output_scale_is_snapped_and_range_checked() {
        let loaded = Config::parse(
            r#"
            [output.DP-1]
            scale = 1.5
            [output.DP-2]
            scale = 1.3333
            [output.DP-3]
            scale = 9.0
            [output.nested]
            scale = 2.0
            "#,
        )
        .unwrap();
        let named = &loaded.config.output.named;
        assert_eq!(named["DP-1"].scale(), 1.5);
        assert_eq!(named["DP-2"].scale(), 160.0 / 120.0);
        assert_eq!(named["DP-3"].scale(), 1.0);
        assert_eq!(loaded.warnings.len(), 1, "{:#?}", loaded.warnings);
    }

    #[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 broken_toml_costs_only_its_line() {
        let loaded = Config::parse(
            r##"
            [general]
            gaps = { inner = 3, outer = 3
            focus_follows_mouse = true
            focus_follows_mouse = false
            [binds]
            "Mod+Return" = "spawn beer
            "Mod+q" = "close"
            "##,
        )
        .unwrap();
        let c = loaded.config;
        assert_eq!(c.general.gaps, General::default().gaps);
        assert_eq!(c.binds.len(), 1);
        assert_eq!(loaded.warnings.len(), 3, "{:#?}", loaded.warnings);
        assert!(
            loaded.warnings[0].starts_with("line 3:"),
            "{:#?}",
            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);
    }

    fn subject<'a>(app_id: &'a str, title: &'a str) -> Subject<'a> {
        Subject {
            app_id,
            title,
            initial_title: title,
            ..Subject::default()
        }
    }

    #[test]
    fn rules_match_every_given_matcher_and_later_ones_win() {
        let loaded = Config::parse(
            r#"
            [[rules]]
            app_id = "^mpv$"
            size = [800, 600]
            opacity = 0.5
            idle_inhibit = "visible"
            [[rules]]
            title = "Picture"
            opacity = 0.8
            focus = false
            vrr = true
            tearing = true
            [[rules]]
            class = "^Steam$"
            instance = "steam"
            xwayland = true
            fullscreen = true
            [[rules]]
            dialog = true
            parent_app_id = "^firefox$"
            center = true
            min_size = [300, 0]
            max_size = [0, 500]
            "#,
        )
        .unwrap();
        assert_eq!(loaded.warnings, Vec::<String>::new());
        let c = loaded.config;
        let p = c.placement(&subject("mpv", "Picture in picture"));
        assert_eq!(p.size, Some((800, 600)));
        assert_eq!(p.opacity, Some(0.8));
        assert_eq!(p.idle_inhibit, Some(IdleInhibit::Visible));
        assert_eq!(
            (p.focus, p.vrr, p.tearing),
            (Some(false), Some(true), Some(true))
        );
        assert_eq!(c.placement(&subject("foot", "sh")), Placement::default());

        let x11 = Subject {
            class: Some("Steam"),
            instance: Some("steam"),
            xwayland: true,
            ..subject("Steam", "Steam")
        };
        assert_eq!(c.placement(&x11).fullscreen, Some(true));
        let wayland = Subject {
            xwayland: false,
            ..subject("Steam", "Steam")
        };
        assert_eq!(c.placement(&wayland).fullscreen, None);

        let dialog = Subject {
            dialog: true,
            parent_app_id: Some("firefox"),
            ..subject("firefox", "Save")
        };
        let p = c.placement(&dialog);
        assert_eq!(p.at, Some(At::Center));
        assert_eq!(p.clamp_size(100.0, 900.0), (300.0, 500.0));
        let orphan = Subject {
            parent_app_id: None,
            ..dialog
        };
        assert_eq!(c.placement(&orphan), Placement::default());
    }

    #[test]
    fn initial_title_holds_when_the_title_changes() {
        let loaded = Config::parse(
            r#"
            [[rules]]
            initial_title = "^Untitled$"
            floating = true
            "#,
        )
        .unwrap();
        let later = Subject {
            title: "notes.txt",
            initial_title: "Untitled",
            ..subject("gedit", "")
        };
        assert_eq!(loaded.config.placement(&later).floating, Some(true));
        let other = Subject {
            initial_title: "notes.txt",
            ..later
        };
        assert_eq!(loaded.config.placement(&other).floating, None);
    }

    #[test]
    fn bad_rule_values_are_warned_about_and_cost_little() {
        let loaded = Config::parse(
            r#"
            [[rules]]
            app_id = "a"
            opacity = 1.5
            size = [0, 100]
            min_size = [500, 500]
            max_size = [400, 0]
            position = [10, 10]
            center = true
            floating = true
            [[rules]]
            app_id = "b"
            idle_inhibit = "always"
            [[rules]]
            class = "("
            [[rules]]
            parent_app_id = "["
            [[rules]]
            app_id = "c"
            size = [-1, 10]
            [[rules]]
            app_id = "d"
            focus = "no"
            [[rules]]
            app_id = "e"
            vrr = false
            "#,
        )
        .unwrap();
        let c = loaded.config;
        assert_eq!(c.rules.len(), 2, "{:#?}", loaded.warnings);
        let a = c.placement(&subject("a", ""));
        assert_eq!(a.floating, Some(true));
        assert_eq!(
            (a.opacity, a.size, a.min_size, a.max_size),
            (None, None, None, None)
        );
        assert_eq!(a.at, Some(At::Center));
        assert_eq!(c.placement(&subject("e", "")).vrr, Some(false));
        assert_eq!(loaded.warnings.len(), 9, "{:#?}", loaded.warnings);
    }

    #[test]
    fn size_bounds_treat_zero_as_open() {
        let p = Placement {
            min_size: Some((200, 0)),
            max_size: Some((0, 300)),
            ..Placement::default()
        };
        assert_eq!(p.clamp_size(50.0, 900.0), (200.0, 300.0));
        assert_eq!(p.clamp_size(4000.0, 10.0), (4000.0, 10.0));
        assert_eq!(Placement::default().clamp_size(7.0, 9.0), (7.0, 9.0));
    }
}