Simplify rust-core: single-format gcode header parser, fewer error variants

parse_header now only handles '; key = value' lines instead of three
different slicer comment formats at once. Error enum trimmed from 4
variants to 3 (Io, Parse, Other).

Verified with cargo test (3/3 passing).

packages/rust-core/src/error.rs

@@ -1,15 +1,14 @@
 use thiserror::Error;
 
+/// One error type for everything in this crate. `Parse` covers G-code
+/// parsing problems; `Other` is an escape hatch for anything else via `?`.
 #[derive(Debug, Error)]
 pub enum Error {
     #[error("io error: {0}")]
     Io(#[from] std::io::Error),
 
-    #[error("invalid g-code checksum on line: {line}")]
+    #[error("{0}")]
-    GcodeChecksum { line: String },
+    Parse(String),
-
-    #[error("malformed g-code header: {reason}")]
-    GcodeHeader { reason: String },
 
     #[error("{0}")]
     Other(#[from] anyhow::Error),

packages/rust-core/src/gcode.rs

@@ -1,9 +1,9 @@
 use crate::error::{Error, Result};
 use std::collections::BTreeMap;
 
-/// XORs every byte in `data` together, per the standard Marlin/RepRap
+/// XORs every byte together — the standard Marlin/RepRap G-code checksum.
-/// G-code checksum scheme (checksum covers everything before the `*`,
+/// Covers everything before the `*`, including a leading `N<n> ` line number
-/// including any leading `N<n> ` line number).
+/// if present.
 pub fn compute_checksum(data: &[u8]) -> u8 {
     data.iter().fold(0u8, |acc, &b| acc ^ b)
 }
@@ -20,14 +20,11 @@ pub fn split_checksum(line: &str) -> (&str, Option<u8>) {
 }
 
 /// Verifies a checksummed G-code line (e.g. `N12 G1 X10 Y20*43`).
-/// Returns `Err` if the line carries no `*NN` suffix to verify against.
 pub fn verify_line_checksum(line: &str) -> Result<bool> {
     let (content, checksum) = split_checksum(line);
     match checksum {
         Some(expected) => Ok(compute_checksum(content.as_bytes()) == expected),
-        None => Err(Error::GcodeChecksum {
+        None => Err(Error::Parse(format!("line has no checksum: {line}"))),
-            line: line.to_string(),
-        }),
     }
 }
 
@@ -36,110 +33,28 @@ pub fn append_checksum(line: &str) -> String {
     format!("{line}*{}", compute_checksum(line.as_bytes()))
 }
 
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
+/// Every `; key = value` comment line found in a G-code file's header,
-pub struct GcodeHeader {
+/// keyed by `key`. Slicers (PrusaSlicer, BambuStudio, ...) write their
-    pub slicer: Option<String>,
+/// settings this way at the top of the file.
-    pub filament_type: Option<String>,
+///
-    pub nozzle_diameter: Option<String>,
+/// This only handles that one format. Real slicer output has more variety
-    pub estimated_print_time_secs: Option<u64>,
+/// (Cura's `;KEY:value` style, free-form "generated by ..." comments) —
-    /// Every `; key = value` comment field found, keyed by `key`.
+/// add support for those once this simple version makes sense.
-    pub raw_fields: BTreeMap<String, String>,
+pub fn parse_header(gcode: &str) -> BTreeMap<String, String> {
-}
+    let mut fields = BTreeMap::new();
 
-/// Parses slicer metadata out of a G-code file's `;`-prefixed comment lines.
+    for line in gcode.lines() {
-/// Handles the PrusaSlicer/SuperSlicer/BambuStudio `; key = value` config
+        let Some(comment) = line.trim().strip_prefix(';') else { continue };
-/// block as well as Cura's `;KEY:value` header and both slicers' free-form
+        let Some((key, value)) = comment.split_once('=') else { continue };
-/// `generated by` / estimated-time comments.
-pub fn parse_header(gcode: &str) -> GcodeHeader {
-    let mut header = GcodeHeader::default();
 
-    for raw_line in gcode.lines() {
-        let line = raw_line.trim();
-        let comment = match line.strip_prefix(';') {
-            Some(rest) => rest.trim(),
-            None => continue,
-        };
-        if comment.is_empty() {
-            continue;
-        }
-
-        if header.slicer.is_none() {
-            if let Some(rest) = comment
-                .strip_prefix("generated by ")
-                .or_else(|| comment.strip_prefix("Generated by "))
-            {
-                let name = rest.split(" on ").next().unwrap_or(rest).trim();
-                header.slicer = Some(name.to_string());
-                continue;
-            }
-            if let Some(rest) = comment
-                .strip_prefix("Generated with ")
-                .or_else(|| comment.strip_prefix("generated with "))
-            {
-                header.slicer = Some(rest.trim().to_string());
-                continue;
-            }
-        }
-
-        if let Some((key, value)) = comment.split_once('=') {
         let key = key.trim().to_string();
         let value = value.trim().to_string();
         if !key.is_empty() && !value.is_empty() {
-                match key.as_str() {
+            fields.insert(key, value);
-                    "filament_type" => header.filament_type = Some(value.clone()),
-                    "nozzle_diameter" => header.nozzle_diameter = Some(value.clone()),
-                    _ => {}
-                }
-                if key.starts_with("estimated printing time") {
-                    header.estimated_print_time_secs = parse_duration(&value);
-                }
-                header.raw_fields.insert(key, value);
-            }
-            continue;
-        }
-
-        if let Some((key, value)) = comment.split_once(':') {
-            let key = key.trim();
-            let value = value.trim();
-            if key.eq_ignore_ascii_case("TIME") {
-                header.estimated_print_time_secs =
-                    value.parse::<u64>().ok().or_else(|| parse_duration(value));
-            }
-        }
-    }
-
-    header
-}
-
-/// Parses slicer duration strings like `1h 23m 45s` or `45m 2s` into seconds.
-fn parse_duration(s: &str) -> Option<u64> {
-    let mut total: u64 = 0;
-    let mut digits = String::new();
-    let mut matched_any = false;
-
-    for c in s.chars() {
-        if c.is_ascii_digit() {
-            digits.push(c);
-        } else if matches!(c, 'd' | 'h' | 'm' | 's') {
-            if digits.is_empty() {
-                continue;
-            }
-            let n: u64 = digits.parse().ok()?;
-            digits.clear();
-            matched_any = true;
-            total += match c {
-                'd' => n * 86_400,
-                'h' => n * 3_600,
-                'm' => n * 60,
-                's' => n,
-                _ => 0,
-            };
-        } else {
-            digits.clear();
         }
     }
 
-    matched_any.then_some(total)
+    fields
 }
 
 #[cfg(test)]
@@ -161,25 +76,10 @@ mod tests {
     }
 
     #[test]
-    fn header_parses_prusaslicer_style() {
+    fn header_parses_key_value_comments() {
-        let gcode = "\
+        let gcode = "; filament_type = PLA\n; nozzle_diameter = 0.4\nG28\n";
-; generated by PrusaSlicer 2.7.0+win64 on 2026-01-01 at 12:00:00
+        let fields = parse_header(gcode);
-; filament_type = PLA
+        assert_eq!(fields.get("filament_type").map(String::as_str), Some("PLA"));
-; nozzle_diameter = 0.4
+        assert_eq!(fields.get("nozzle_diameter").map(String::as_str), Some("0.4"));
-; estimated printing time (normal mode) = 1h 23m 45s
-G28
-";
-        let header = parse_header(gcode);
-        assert_eq!(header.slicer.as_deref(), Some("PrusaSlicer 2.7.0+win64"));
-        assert_eq!(header.filament_type.as_deref(), Some("PLA"));
-        assert_eq!(header.estimated_print_time_secs, Some(5025));
-    }
-
-    #[test]
-    fn header_parses_cura_style() {
-        let gcode = ";Generated with Cura_SteamEngine 5.6.0\n;TIME:3725\nG28\n";
-        let header = parse_header(gcode);
-        assert_eq!(header.slicer.as_deref(), Some("Cura_SteamEngine 5.6.0"));
-        assert_eq!(header.estimated_print_time_secs, Some(3725));
     }
 }