monolith

public

Star0

Fork 0

Watch0

113 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `8fb62aebf501`

tarball

atagen <boss@atagen.co>2026-10-17 10:29 UTC

1 file changed+180-68

config: drop only the options that fail instead of the whole file

One typo used to send the session back to the built-in defaults. Each section now keeps every option that parses, bad binds and rules are left out on their own, and only TOML that does not parse at all still fails.

Modified file: crates/config/src/lib.rs+180 additions−68 deletions@@ -3,7 +3,7 @@
 use monolith_ipc::Command;
 use regex::Regex;
 use serde::Deserialize;
-use std::collections::BTreeMap;
+use serde::de::DeserializeOwned;
 use std::fmt;
 use std::path::{Path, PathBuf};
 
@@ -110,7 +110,10 @@ pub struct Decoration {
 pub struct Corners(pub [u32; 4]);
 
 #[derive(Deserialize)]
-#[serde(untagged)]
+#[serde(
+    untagged,
+    expecting = "expected a number or [top left, top right, bottom right, bottom left]"
+)]
 enum CornersToml {
     All(u32),
     Each([u32; 4]),
@@ -289,8 +292,6 @@ pub struct Placement {
 pub enum Error {
     Io(PathBuf, std::io::Error),
     Toml(toml::de::Error),
-    Bind(String, String),
-    Regex(String, regex::Error),
 }
 
 impl fmt::Display for Error {
@@ -298,8 +299,6 @@ impl fmt::Display for Error {
         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}"),
         }
     }
 }
@@ -307,27 +306,6 @@ impl fmt::Display for Error {
 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),
@@ -359,7 +337,7 @@ impl Config {
     }
 
     /// Loads `path`, or the built-in default when it does not exist.
-    pub fn load(path: Option<&Path>) -> Result<Self, Error> {
+    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),
@@ -370,43 +348,72 @@ impl Config {
         }
     }
 
-    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
+    /// 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 animation = section("animation", table.remove("animation"), w);
+        let decoration = section("decoration", table.remove("decoration"), w);
+        let output = section("output", table.remove("output"), 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 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()
-            .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,
+            .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,
             binds,
             rules,
-            startup: raw.startup,
-        })
+            startup,
+        };
+        Ok(Loaded { config, warnings })
     }
 
     pub fn placement(&self, app_id: &str, title: &str) -> Placement {
@@ -426,11 +433,10 @@ impl Config {
     }
 }
 
-fn parse_bind(combo: &str, words: Words, mod_key: Modifier) -> Result<Bind, Error> {
-    let bad = |m: String| Error::Bind(combo.to_owned(), m);
+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(bad("no key".into()));
+        return Err("no key".into());
     };
     let mut set = Mods::default();
     for m in mods {
@@ -440,7 +446,7 @@ fn parse_bind(combo: &str, words: Words, mod_key: Modifier) -> Result<Bind, Erro
             "alt" => Modifier::Alt,
             "ctrl" | "control" => Modifier::Ctrl,
             "shift" => Modifier::Shift,
-            other => return Err(bad(format!("unknown modifier {other}"))),
+            other => return Err(format!("unknown modifier {other}")),
         };
         set.set(m);
     }
@@ -448,7 +454,7 @@ fn parse_bind(combo: &str, words: Words, mod_key: Modifier) -> Result<Bind, Erro
         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))?;
+    let command = Command::parse(&words).map_err(|e| e.0)?;
     Ok(Bind {
         mods: set,
         key: key.to_owned(),
@@ -456,6 +462,79 @@ fn parse_bind(combo: &str, words: Words, mod_key: Modifier) -> Result<Bind, Erro
     })
 }
 
+/// 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()
+}
+
+/// 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::*;
@@ -464,7 +543,9 @@ mod tests {
     /// 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();
+        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());
@@ -472,4 +553,35 @@ mod tests {
         assert_eq!(c.keyboard, Keyboard::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 foot"
+            "Hyper+x" = "close"
+            [[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!(loaded.warnings.len(), 5, "{:#?}", loaded.warnings);
+    }
 }

monolith

Commit 8fb62aebf501

Commit `8fb62aebf501`