monolith

public

Star0

Fork 0

Watch0

289 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `92fbde37d644`

tarball

atagen <boss@atagen.co>2026-10-19 10:50 UTC

2 files changed+78-5

config: drop a broken table header together with its keys

lenient_table removed a header line the parser rejected on its own, so the keys beneath a broken [binds or [[rules] attached to the table above and silently changed what they meant. A header now goes with every line up to the next header and the warning names the section. The reload doc no longer claims a non-TOML file leaves the config untouched, since only unrepairable files do.

Modified file: crates/config/src/lib.rs+75 additions−3 deletions@@ -898,6 +898,8 @@ pub struct Loaded {
 /// 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.
+/// A table header is never dropped alone, since its keys would then join the
+/// table above and change what they mean. It takes its keys with it.
 fn lenient_table(text: &str, w: &mut Vec<String>) -> Result<toml::Table, Error> {
     const MAX_BAD_LINES: usize = 32;
     const LOOK_BACK: usize = 4;
@@ -931,14 +933,32 @@ fn lenient_table(text: &str, w: &mut Vec<String>) -> Result<toml::Table, Error> 
         };
         let culprit = (at.saturating_sub(LOOK_BACK)..=at)
             .filter(|&i| !lines[i].1.trim().is_empty())
-            .max_by_key(|&i| progress(i))
+            .max_by_key(|&i| (progress(i), !is_header(lines[i].1)))
             .unwrap_or(at);
-        let (line, _) = lines.remove(culprit);
-        w.push(format!("line {line}: {}, left out", e.message().trim()));
+        let (line, text) = lines[culprit];
+        if is_header(text) {
+            let end = (culprit + 1..lines.len())
+                .find(|&i| is_header(lines[i].1))
+                .unwrap_or(lines.len());
+            lines.drain(culprit..end);
+            let name = text.split('#').next().unwrap_or(text).trim();
+            w.push(format!(
+                "line {line}: {}, section {name} left out",
+                e.message().trim()
+            ));
+        } else {
+            lines.remove(culprit);
+            w.push(format!("line {line}: {}, left out", e.message().trim()));
+        }
     }
     toml::from_str(&join(&lines)).map_err(Error::Toml)
 }
 
+fn is_header(line: &str) -> bool {
+    let line = line.split('#').next().unwrap_or_default().trim_start();
+    line.starts_with('[') && !line.contains(['=', ',', '{'])
+}
+
 fn entry<T: DeserializeOwned>(name: &str, value: toml::Value, w: &mut Vec<String>) -> Option<T> {
     value
         .try_into()
@@ -1161,6 +1181,58 @@ mod tests {
     }
 
     #[test]
+    fn a_broken_table_header_takes_its_section_with_it() {
+        let loaded = Config::parse(
+            r##"
+            [general]
+            focus_follows_mouse = false
+            [binds
+            "Mod+q" = "close"
+            [decoration]
+            radius = [1, 2, 3, 4]
+            "##,
+        )
+        .unwrap();
+        let c = loaded.config;
+        assert!(!c.general.focus_follows_mouse);
+        assert_eq!(c.binds.len(), 0);
+        assert_eq!(c.decoration.radius, Corners([1, 2, 3, 4]));
+        assert_eq!(loaded.warnings.len(), 1, "{:#?}", loaded.warnings);
+        assert!(
+            loaded.warnings[0].contains("section [binds left out"),
+            "{:#?}",
+            loaded.warnings
+        );
+    }
+
+    #[test]
+    fn a_broken_rule_header_does_not_feed_the_rule_above() {
+        let loaded = Config::parse(
+            r##"
+            [[rules]]
+            app_id = "^a$"
+            floating = true
+            [[rules]
+            app_id = "^b$"
+            fullscreen = true
+            [[rules]]
+            app_id = "^c$"
+            "##,
+        )
+        .unwrap();
+        let apps: Vec<_> = loaded
+            .config
+            .rules
+            .iter()
+            .map(|r| format!("{r:?}"))
+            .collect();
+        assert_eq!(apps.len(), 2, "{:#?} {:#?}", apps, loaded.warnings);
+        assert!(apps[0].contains("floating: Some(true)") && !apps[0].contains("fullscreen: Some"));
+        assert_eq!(loaded.warnings.len(), 1, "{:#?}", loaded.warnings);
+        assert!(loaded.warnings[0].contains("section [[rules] left out"));
+    }
+
+    #[test]
     fn a_bad_device_option_costs_only_itself() {
         let loaded = Config::parse(
             r#"

Modified file: crates/monolith/src/commands.rs+3 additions−2 deletions@@ -222,8 +222,9 @@ impl State {
         }
     }
 
-    /// Swaps in a freshly parsed config. A file that is not TOML leaves the
-    /// running config untouched.
+    /// Swaps in a freshly parsed config. A file too broken to repair line by
+    /// line leaves the running config untouched, anything less is loaded with
+    /// warnings for what had to be left out.
     pub fn reload(&mut self) -> Result<(), String> {
         let loaded = Config::load(self.settings.path.as_deref()).map_err(|e| e.to_string())?;
         let mut warnings = loaded.warnings.clone();

monolith

Commit 92fbde37d644

Commit `92fbde37d644`