monolith

public

Star0

Watch0

111 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 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 output: Outputs,
    pub decoration: Decoration,
    pub animation: Animation,
    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,
    /// 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 on 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, deny_unknown_fields)]
pub struct Outputs {
    pub vrr: Vrr,
}

#[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)]
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)]
#[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 {
    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),
    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)]
    animation: Animation,
    #[serde(default)]
    decoration: Decoration,
    #[serde(default)]
    output: Outputs,
    #[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,
            animation: raw.animation,
            decoration: raw.decoration,
            output: raw.output,
            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 {
    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 c = Config::parse(DEFAULT).unwrap();
        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!(c.binds.len() > 40);
    }
}

1	//! The TOML config. Parsing and validation only, the compositor applies it.
2
3	use monolith_ipc::Command;
4	use regex::Regex;
5	use serde::Deserialize;
6	use std::collections::BTreeMap;
7	use std::fmt;
8	use std::path::{Path, PathBuf};
9
10	pub const DEFAULT: &str = include_str!("../default.toml");
11
12	#[derive(Debug, Clone)]
13	pub struct Config {
14	pub general: General,
15	pub output: Outputs,
16	pub decoration: Decoration,
17	pub animation: Animation,
18	pub keyboard: Keyboard,
19	pub binds: Vec<Bind>,
20	pub rules: Vec<Rule>,
21	pub startup: Vec<Vec<String>>,
22	}
23
24	#[derive(Deserialize, Debug, Clone, PartialEq)]
25	#[serde(default, deny_unknown_fields)]
26	pub struct General {
27	/// What `Mod` means in binds.
28	#[serde(rename = "mod")]
29	pub mod_key: Modifier,
30	pub gaps: Gaps,
31	/// What a window move does when it meets a neighbour.
32	#[serde(rename = "move")]
33	pub move_mode: MoveMode,
34	pub focus_follows_mouse: bool,
35	pub mouse_follows_focus: bool,
36	/// The first window on an empty tag nobody is viewing brings that tag
37	/// into view on its output.
38	pub view_tag_on_first_window: bool,
39	}
40
41	#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
42	#[serde(rename_all = "lowercase")]
43	pub enum MoveMode {
44	/// Trade places with it.
45	#[default]
46	Swap,
47	/// Join its lane, stacking with it if it is alone.
48	Merge,
49	}
50
51	impl Default for General {
52	fn default() -> Self {
53	Self {
54	mod_key: Modifier::Super,
55	gaps: Gaps::default(),
56	move_mode: MoveMode::Swap,
57	focus_follows_mouse: false,
58	mouse_follows_focus: false,
59	view_tag_on_first_window: true,
60	}
61	}
62	}
63
64	#[derive(Deserialize, Debug, Clone, Copy, PartialEq)]
65	#[serde(default, deny_unknown_fields)]
66	pub struct Gaps {
67	pub inner: f64,
68	pub outer: f64,
69	}
70
71	impl Default for Gaps {
72	fn default() -> Self {
73	Self {
74	inner: 8.0,
75	outer: 8.0,
76	}
77	}
78	}
79
80	#[derive(Deserialize, Debug, Clone, PartialEq, Default)]
81	#[serde(default, deny_unknown_fields)]
82	pub struct Outputs {
83	pub vrr: Vrr,
84	}
85
86	#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
87	#[serde(rename_all = "lowercase")]
88	pub enum Vrr {
89	Off,
90	On,
91	/// Only while a fullscreen window is shown, where a game sets the pace.
92	#[default]
93	Fullscreen,
94	}
95
96	#[derive(Deserialize, Debug, Clone, PartialEq)]
97	#[serde(default, deny_unknown_fields)]
98	pub struct Decoration {
99	/// Border width in logical pixels, drawn in the gap around each window.
100	pub border: u32,
101	pub radius: Corners,
102	pub focused: Color,
103	pub unfocused: Color,
104	}
105
106	/// Corner radii in logical pixels, top left, top right, bottom right and
107	/// bottom left. One number rounds every corner alike.
108	#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
109	#[serde(from = "CornersToml")]
110	pub struct Corners(pub [u32; 4]);
111
112	#[derive(Deserialize)]
113	#[serde(untagged)]
114	enum CornersToml {
115	All(u32),
116	Each([u32; 4]),
117	}
118
119	impl From<CornersToml> for Corners {
120	fn from(c: CornersToml) -> Self {
121	match c {
122	CornersToml::All(r) => Self([r; 4]),
123	CornersToml::Each(r) => Self(r),
124	}
125	}
126	}
127
128	impl Default for Decoration {
129	fn default() -> Self {
130	Self {
131	border: 2,
132	radius: Corners([0; 4]),
133	focused: Color::rgb(0x88, 0xbf, 0xd1),
134	unfocused: Color::rgb(0x3b, 0x42, 0x52),
135	}
136	}
137	}
138
139	/// Straight RGBA from `#rrggbb` or `#rrggbbaa`.
140	#[derive(Debug, Clone, Copy, PartialEq)]
141	pub struct Color(pub [f32; 4]);
142
143	impl Color {
144	pub const fn rgb(r: u8, g: u8, b: u8) -> Self {
145	Self([r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0])
146	}
147	}
148
149	impl<'de> Deserialize<'de> for Color {
150	fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
151	let s = String::deserialize(d)?;
152	let hex = s.strip_prefix('#').unwrap_or(&s);
153	let bad =
154	\|\| serde::de::Error::custom(format!("bad colour {s:?}, use #rrggbb or #rrggbbaa"));
155	if !matches!(hex.len(), 6 \| 8) \|\| !hex.is_ascii() {
156	return Err(bad());
157	}
158	let mut c = [1.0f32; 4];
159	for (i, v) in c.iter_mut().enumerate().take(hex.len() / 2) {
160	let byte = u8::from_str_radix(&hex[i * 2..i * 2 + 2], 16).map_err(\|_\| bad())?;
161	*v = f32::from(byte) / 255.0;
162	}
163	Ok(Self(c))
164	}
165	}
166
167	#[derive(Deserialize, Debug, Clone, PartialEq)]
168	#[serde(default, deny_unknown_fields)]
169	pub struct Animation {
170	pub enabled: bool,
171	pub style: AnimationStyle,
172	/// Every phase of a planned transition lasts this long.
173	pub phase_ms: u64,
174	/// A cubic bezier, as in CSS.
175	pub curve: [f64; 4],
176	}
177
178	impl Default for Animation {
179	fn default() -> Self {
180	Self {
181	enabled: true,
182	style: AnimationStyle::Orthogonal,
183	phase_ms: 160,
184	curve: [0.45, 0.0, 0.2, 1.0],
185	}
186	}
187	}
188
189	#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
190	#[serde(rename_all = "lowercase")]
191	pub enum AnimationStyle {
192	Orthogonal,
193	Direct,
194	}
195
196	#[derive(Deserialize, Debug, Clone, PartialEq)]
197	#[serde(default, deny_unknown_fields)]
198	pub struct Keyboard {
199	pub rules: String,
200	pub model: String,
201	pub layout: String,
202	pub variant: String,
203	pub options: Option<String>,
204	pub repeat_delay: i32,
205	pub repeat_rate: i32,
206	}
207
208	impl Default for Keyboard {
209	fn default() -> Self {
210	Self {
211	rules: String::new(),
212	model: String::new(),
213	layout: String::new(),
214	variant: String::new(),
215	options: None,
216	repeat_delay: 200,
217	repeat_rate: 25,
218	}
219	}
220	}
221
222	#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
223	#[serde(rename_all = "lowercase")]
224	pub enum Modifier {
225	Super,
226	Alt,
227	Ctrl,
228	Shift,
229	}
230
231	#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Hash)]
232	pub struct Mods {
233	pub logo: bool,
234	pub alt: bool,
235	pub ctrl: bool,
236	pub shift: bool,
237	}
238
239	impl Mods {
240	pub fn has(&self, m: Modifier) -> bool {
241	match m {
242	Modifier::Super => self.logo,
243	Modifier::Alt => self.alt,
244	Modifier::Ctrl => self.ctrl,
245	Modifier::Shift => self.shift,
246	}
247	}
248
249	fn set(&mut self, m: Modifier) {
250	match m {
251	Modifier::Super => self.logo = true,
252	Modifier::Alt => self.alt = true,
253	Modifier::Ctrl => self.ctrl = true,
254	Modifier::Shift => self.shift = true,
255	}
256	}
257	}
258
259	#[derive(Debug, Clone, PartialEq)]
260	pub struct Bind {
261	pub mods: Mods,
262	/// An xkb keysym name, resolved by the compositor.
263	pub key: String,
264	pub command: Command,
265	}
266
267	#[derive(Debug, Clone)]
268	pub struct Rule {
269	pub app_id: Option<Regex>,
270	pub title: Option<Regex>,
271	pub tag: Option<String>,
272	pub output: Option<String>,
273	pub floating: Option<bool>,
274	pub sticky: Option<bool>,
275	pub scratchpad: Option<String>,
276	}
277
278	/// Everything the matching rules say about a window, later rules winning.
279	#[derive(Debug, Clone, Default, PartialEq)]
280	pub struct Placement {
281	pub tag: Option<String>,
282	pub output: Option<String>,
283	pub floating: Option<bool>,
284	pub sticky: Option<bool>,
285	pub scratchpad: Option<String>,
286	}
287
288	#[derive(Debug)]
289	pub enum Error {
290	Io(PathBuf, std::io::Error),
291	Toml(toml::de::Error),
292	Bind(String, String),
293	Regex(String, regex::Error),
294	}
295
296	impl fmt::Display for Error {
297	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
298	match self {
299	Error::Io(p, e) => write!(f, "{}: {e}", p.display()),
300	Error::Toml(e) => write!(f, "{e}"),
301	Error::Bind(k, e) => write!(f, "bind {k:?}: {e}"),
302	Error::Regex(r, e) => write!(f, "rule pattern {r:?}: {e}"),
303	}
304	}
305	}
306
307	impl std::error::Error for Error {}
308
309	#[derive(Deserialize)]
310	#[serde(deny_unknown_fields)]
311	struct Raw {
312	#[serde(default)]
313	startup: Vec<Vec<String>>,
314	#[serde(default)]
315	general: General,
316	#[serde(default)]
317	keyboard: Keyboard,
318	#[serde(default)]
319	animation: Animation,
320	#[serde(default)]
321	decoration: Decoration,
322	#[serde(default)]
323	output: Outputs,
324	#[serde(default)]
325	binds: BTreeMap<String, Words>,
326	#[serde(default)]
327	rules: Vec<RawRule>,
328	}
329
330	#[derive(Deserialize)]
331	#[serde(untagged)]
332	enum Words {
333	Line(String),
334	List(Vec<String>),
335	}
336
337	#[derive(Deserialize)]
338	#[serde(deny_unknown_fields)]
339	struct RawRule {
340	app_id: Option<String>,
341	title: Option<String>,
342	tag: Option<String>,
343	output: Option<String>,
344	floating: Option<bool>,
345	sticky: Option<bool>,
346	scratchpad: Option<String>,
347	}
348
349	impl Config {
350	/// `$MONOLITH_CONFIG`, else `$XDG_CONFIG_HOME/monolith/config.toml`.
351	pub fn path() -> Option<PathBuf> {
352	if let Some(p) = std::env::var_os("MONOLITH_CONFIG") {
353	return Some(p.into());
354	}
355	let base = std::env::var_os("XDG_CONFIG_HOME")
356	.map(PathBuf::from)
357	.or_else(\|\| std::env::var_os("HOME").map(\|h\| PathBuf::from(h).join(".config")))?;
358	Some(base.join("monolith/config.toml"))
359	}
360
361	/// Loads `path`, or the built-in default when it does not exist.
362	pub fn load(path: Option<&Path>) -> Result<Self, Error> {
363	match path {
364	Some(p) => match std::fs::read_to_string(p) {
365	Ok(text) => Self::parse(&text),
366	Err(e) if e.kind() == std::io::ErrorKind::NotFound => Self::parse(DEFAULT),
367	Err(e) => Err(Error::Io(p.to_owned(), e)),
368	},
369	None => Self::parse(DEFAULT),
370	}
371	}
372
373	pub fn parse(text: &str) -> Result<Self, Error> {
374	let raw: Raw = toml::from_str(text).map_err(Error::Toml)?;
375	let mod_key = raw.general.mod_key;
376	let binds = raw
377	.binds
378	.into_iter()
379	.map(\|(combo, words)\| parse_bind(&combo, words, mod_key))
380	.collect::<Result<_, _>>()?;
381	let regex = \|p: Option<String>\| {
382	p.map(\|p\| Regex::new(&p).map_err(\|e\| Error::Regex(p, e)))
383	.transpose()
384	};
385	let rules = raw
386	.rules
387	.into_iter()
388	.map(\|r\| {
389	Ok(Rule {
390	app_id: regex(r.app_id)?,
391	title: regex(r.title)?,
392	tag: r.tag,
393	output: r.output,
394	floating: r.floating,
395	sticky: r.sticky,
396	scratchpad: r.scratchpad,
397	})
398	})
399	.collect::<Result<_, Error>>()?;
400	Ok(Self {
401	general: raw.general,
402	animation: raw.animation,
403	decoration: raw.decoration,
404	output: raw.output,
405	keyboard: raw.keyboard,
406	binds,
407	rules,
408	startup: raw.startup,
409	})
410	}
411
412	pub fn placement(&self, app_id: &str, title: &str) -> Placement {
413	let mut p = Placement::default();
414	let hit = \|re: &Option<Regex>, s: &str\| re.as_ref().is_none_or(\|re\| re.is_match(s));
415	for r in &self.rules {
416	if !hit(&r.app_id, app_id) \|\| !hit(&r.title, title) {
417	continue;
418	}
419	p.tag = r.tag.clone().or(p.tag);
420	p.output = r.output.clone().or(p.output);
421	p.floating = r.floating.or(p.floating);
422	p.sticky = r.sticky.or(p.sticky);
423	p.scratchpad = r.scratchpad.clone().or(p.scratchpad);
424	}
425	p
426	}
427	}
428
429	fn parse_bind(combo: &str, words: Words, mod_key: Modifier) -> Result<Bind, Error> {
430	let bad = \|m: String\| Error::Bind(combo.to_owned(), m);
431	let parts: Vec<&str> = combo.split('+').map(str::trim).collect();
432	let Some((&key, mods)) = parts.split_last().filter(\|(k, _)\| !k.is_empty()) else {
433	return Err(bad("no key".into()));
434	};
435	let mut set = Mods::default();
436	for m in mods {
437	let m = match m.to_ascii_lowercase().as_str() {
438	"mod" => mod_key,
439	"super" \| "logo" \| "win" => Modifier::Super,
440	"alt" => Modifier::Alt,
441	"ctrl" \| "control" => Modifier::Ctrl,
442	"shift" => Modifier::Shift,
443	other => return Err(bad(format!("unknown modifier {other}"))),
444	};
445	set.set(m);
446	}
447	let words: Vec<String> = match words {
448	Words::Line(s) => s.split_whitespace().map(str::to_owned).collect(),
449	Words::List(v) => v,
450	};
451	let command = Command::parse(&words).map_err(\|e\| bad(e.0))?;
452	Ok(Bind {
453	mods: set,
454	key: key.to_owned(),
455	command,
456	})
457	}
458
459	#[cfg(test)]
460	mod tests {
461	use super::*;
462
463	/// default.toml documents the defaults for users, and the Default impls
464	/// apply them to sections a user config leaves out. They must agree.
465	#[test]
466	fn default_toml_states_the_defaults() {
467	let c = Config::parse(DEFAULT).unwrap();
468	assert_eq!(c.general, General::default());
469	assert_eq!(c.output, Outputs::default());
470	assert_eq!(c.decoration, Decoration::default());
471	assert_eq!(c.animation, Animation::default());
472	assert_eq!(c.keyboard, Keyboard::default());
473	assert!(c.binds.len() > 40);
474	}
475	}