monolith

//! The TOML config. Parsing and validation only, the compositor applies it.

use monolith_ipc::Command;

use regex::Regex;

use serde::Deserialize;

use std::collections::BTreeMap;

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 keyboard: Keyboard,

    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,

}

impl Default for General {

    fn default() -> Self {

        Self {

            mod_key: Modifier::Super,

            gaps: Gaps::default(),

        }

    }

}

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

#[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,

        }

    }

}

#[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 {

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

    Bind(String, String),

    Regex(String, regex::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}"),

            Error::Bind(k, e) => write!(f, "bind {k:?}: {e}"),

            Error::Regex(r, e) => write!(f, "rule pattern {r:?}: {e}"),

        }

    }

}

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

#[derive(Deserialize)]

#[serde(deny_unknown_fields)]

struct Raw {

    #[serde(default)]

    startup: Vec<Vec<String>>,

    #[serde(default)]

    general: General,

    #[serde(default)]

    keyboard: Keyboard,

    #[serde(default)]

    binds: BTreeMap<String, Words>,

    #[serde(default)]

    rules: Vec<RawRule>,

}

#[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<Self, 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),

        }

    }

    pub fn parse(text: &str) -> Result<Self, Error> {

        let raw: Raw = toml::from_str(text).map_err(Error::Toml)?;

        let mod_key = raw.general.mod_key;

        let binds = raw

            .binds

            .into_iter()

            .map(|(combo, words)| parse_bind(&combo, words, mod_key))

            .collect::<Result<_, _>>()?;

        let regex = |p: Option<String>| {

            p.map(|p| Regex::new(&p).map_err(|e| Error::Regex(p, e)))

                .transpose()

        };

        let rules = raw

            .rules

            .into_iter()

            .map(|r| {

                Ok(Rule {

                    app_id: regex(r.app_id)?,

                    title: regex(r.title)?,

                    tag: r.tag,

                    output: r.output,

                    floating: r.floating,

                    sticky: r.sticky,

                    scratchpad: r.scratchpad,

                })

            })

            .collect::<Result<_, Error>>()?;

        Ok(Self {

            general: raw.general,

            keyboard: raw.keyboard,

            binds,

            rules,

            startup: raw.startup,

        })

    }

    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, Error> {

    let bad = |m: String| Error::Bind(combo.to_owned(), m);

    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(bad("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(bad(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| bad(e.0))?;

    Ok(Bind {

        mods: set,

        key: key.to_owned(),

        command,

    })

}

#[cfg(test)]

mod tests {

    #[test]

    fn the_default_config_parses() {

        let c = super::Config::parse(super::DEFAULT).unwrap();

        assert!(c.binds.len() > 40);

    }

}