monolith

public

Star0

Fork 0

Watch0

214 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `a1e55dd5ed07`

tarball

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

1 file changed+74-3

config: drop only the broken lines of a config with bad toml

A single syntax error made the whole file unreadable, so a typo at startup replaced every bind and option with the built-in default. The parser now drops the line it blames, or for an unclosed table the nearby line that clears the error, warns, and parses again, giving up only after 32 bad lines.

Modified file: crates/config/src/lib.rs+74 additions−3 deletions@@ -561,11 +561,12 @@ impl Config {
         }
     }
 
-    /// 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.
+    /// 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 table: toml::Table = toml::from_str(text).map_err(Error::Toml)?;
         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);
@@ -694,6 +695,51 @@ pub struct Loaded {
     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()
@@ -869,6 +915,31 @@ mod tests {
     }
 
     #[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#"

monolith

Commit a1e55dd5ed07

Commit `a1e55dd5ed07`