Migration to new Rust-based engine (#401)

* wasm first steps * parsing start * parsing continued * progress * progress * progress * progress * progress * progress * progress * progress * fixes * reorganize * change type * fix * progress * refactoring * progress * progress * progress * keep style info * progress * progress * remove (copy) in name * progress * merge methods into 1 * splice * progress * progress * progress * cleaning * progress * progress * progress * visibility * progress * progress * progress * progress * progress * fixes * progress * fix markers * fix * progress * progress * progress * progress * progress * progress * small fix * use engine info * fix popups * small fix * progress * progress * progress * clean tool * handle self closing elements * reduce data exchanges across boundary * copy on wasm side to avoid any data corruption * speed fix * routing * refactoring * reverse * reverse * crop * split * merge * progress * time tool * fix bounds for waypoints * reduce * fix reactivity * handle corrupt time data * export * progress * remove gpx js package * remove todo * update readme * cleaning * progress * fix link fields * remove unused fields * refactoring and tests * import and export of routes, ref #192 * per-chunk categories storage * cross-tab sync * outdated state * refactoring * reorder methods * refactoring * fix * improve flow * renaming * progress * progress * fix * progress * per file history * keep original flag * use history variant * fix * progress * file explorer * progress * fix * sticky folders * improved sticky folders * fix sortable * fix sortable * fix * fix tab size * no file delete on desktop * fix routing on other file * fix sorting * remember language * open links in browser * commit missing changes * avoid selecting on resize * clarify filename * explorer actions * fix folder styling * drop anywhere in folder * cleaning * fixes * remove focus-ring * full screen * small fix * consistent highlight color * improved preview * performance improvements * sparser data transfers * sparser data transfers * show popup once data is loaded * fix routing control size * fix * sparse desktop build * remove custom ign styles * use new endpoint for openhikingmap * strip native menu * reorder context menu items * route full support * route - track conversion * create route file action * route export, filter out anchors at high zoom level * clarify name handling * move hide & center to view * routes continued * update docs * fix power format, closes #378 * lint fixes * fix display of additional data with gaps, closes #361 * fix linting issues * fix import modules * fix multidrag * change base to resolve * fix type errors * fix layer typings * fix last type error * each keys * improve typings * deploy to cloudflare --------- Co-authored-by: vcoppe <vcoppe@hexaly.com>
2026-11-15 07:07:07 +00:00 · 2026-10-31 18:08:22 +01:00
1 parent 6a0d434371
commit 8fe7d8d64d
@@ -0,0 +1,236 @@
+use crate::{Apply, CommandError, File, State, TrackpointCategories, parse, produce};
+
+#[derive(Debug)]
+pub struct Load<'a> {
+    pub data: &'a [u8],
+    /// Name of the file when the data has none (typically the name of the file on disk, without
+    /// its extension).
+    pub name: &'a str,
+}
+
+impl Load<'_> {
+    pub(crate) fn parse(self, categories: &mut TrackpointCategories) -> Result<File, CommandError> {
+        let mut file = parse(self.data, categories)
+            .map_err(|err| CommandError::InvalidData(err.to_string()))?;
+        if file.info.name.trim().is_empty() {
+            file.info.name = self.name.to_owned();
+        }
+        Ok(file)
+    }
+}
+
+impl Apply for Load<'_> {
+    fn apply(self, state: &mut State) -> Result<(), CommandError> {
+        LoadFiles { files: vec![self] }.apply(state)
+    }
+}
+
+/// Loads several files at once, as a single command (one undo step): the files are added at the
+/// end of the list, in the given order, and the first one is selected.
+///
+/// The files that cannot be read are skipped, unless none of them can: then nothing is loaded
+/// and the error is the one of the first file.
+#[derive(Debug)]
+pub struct LoadFiles<'a> {
+    pub files: Vec<Load<'a>>,
+}
+
+impl Apply for LoadFiles<'_> {
+    fn apply(self, state: &mut State) -> Result<(), CommandError> {
+        let mut files = Vec::with_capacity(self.files.len());
+        let mut first_error = None;
+        for load in self.files {
+            match load.parse(state.categories) {
+                Ok(file) => files.push(file),
+                Err(error) => {
+                    first_error.get_or_insert(error);
+                }
+            }
+        }
+        if files.is_empty() {
+            return Err(first_error.unwrap_or(CommandError::NothingToDo));
+        }
+        produce(state, |_| files);
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::engine::command::fixture::Fixture;
+
+    use super::*;
+
+    #[test]
+    fn test_load() {
+        let mut fx = Fixture::default();
+        let data = std::fs::read("data/with_tracks.gpx").unwrap();
+        assert!(
+            Load {
+                data: &data,
+                name: "file",
+            }
+            .apply(&mut fx.state())
+            .is_ok()
+        );
+        assert_eq!(fx.files.len(), 1);
+        let file = fx.files.values().next().unwrap();
+        assert!(!file.trk.is_empty());
+        assert_eq!(fx.selected_files(), [file.id].into());
+    }
+
+    #[test]
+    fn test_load_invalid_file_changes_nothing() {
+        let mut fx = Fixture::default();
+        crate::New {
+            name: "keep",
+            trackpoint: None,
+            route: false,
+        }
+        .apply(&mut fx.state())
+        .unwrap();
+        let selected = fx.selected_files();
+
+        let result = Load {
+            data: b"<gpx><trk></gpx>",
+            name: "file",
+        }
+        .apply(&mut fx.state());
+        assert!(matches!(result, Err(CommandError::InvalidData(_))));
+        assert_eq!(fx.files.len(), 1);
+        assert_eq!(fx.order.0.len(), 1);
+        assert_eq!(fx.selected_files(), selected);
+    }
+
+    fn load_with_name(data: &[u8]) -> String {
+        let mut fx = Fixture::default();
+        Load {
+            data,
+            name: "from disk",
+        }
+        .apply(&mut fx.state())
+        .unwrap();
+        fx.files.values().next().unwrap().info.name.clone()
+    }
+
+    #[test]
+    fn test_load_keeps_the_name_of_the_file() {
+        let data = br#"<gpx version="1.1"><metadata><name>in the file</name></metadata></gpx>"#;
+        assert_eq!(load_with_name(data), "in the file");
+    }
+
+    #[test]
+    fn test_load_without_name_uses_the_given_name() {
+        let without = br#"<gpx version="1.1"><trk><trkseg></trkseg></trk></gpx>"#;
+        assert_eq!(load_with_name(without), "from disk");
+        let empty = br#"<gpx version="1.1"><metadata><name>  </name></metadata></gpx>"#;
+        assert_eq!(load_with_name(empty), "from disk");
+    }
+
+    fn gpx(name: &str) -> Vec<u8> {
+        format!(r#"<gpx version="1.1"><metadata><name>{name}</name></metadata></gpx>"#).into_bytes()
+    }
+
+    fn load<'a>(data: &'a [u8], name: &'a str) -> Load<'a> {
+        Load { data, name }
+    }
+
+    #[test]
+    fn test_load_several_files() {
+        let mut fx = Fixture::default();
+        crate::New {
+            name: "before",
+            trackpoint: None,
+            route: false,
+        }
+        .apply(&mut fx.state())
+        .unwrap();
+        let before = fx.order.0[0];
+        let (a, b, c) = (gpx("a"), gpx("b"), gpx("c"));
+
+        LoadFiles {
+            files: vec![load(&a, "x"), load(&b, "x"), load(&c, "x")],
+        }
+        .apply(&mut fx.state())
+        .unwrap();
+
+        // added after the others, in the order they were given
+        let names: Vec<_> = fx
+            .order
+            .0
+            .iter()
+            .map(|id| fx.files[id].info.name.clone())
+            .collect();
+        assert_eq!(names, ["before", "a", "b", "c"]);
+        assert_eq!(fx.order.0[0], before);
+        // the first one is selected
+        assert_eq!(fx.selected_files(), [fx.order.0[1]].into());
+    }
+
+    #[test]
+    fn test_load_several_files_skips_the_invalid_ones() {
+        let mut fx = Fixture::default();
+        let (a, c) = (gpx("a"), gpx("c"));
+        LoadFiles {
+            files: vec![load(&a, "x"), load(b"<gpx><trk></gpx>", "x"), load(&c, "x")],
+        }
+        .apply(&mut fx.state())
+        .unwrap();
+        let names: Vec<_> = fx
+            .order
+            .0
+            .iter()
+            .map(|id| fx.files[id].info.name.clone())
+            .collect();
+        assert_eq!(names, ["a", "c"]);
+    }
+
+    #[test]
+    fn test_load_several_invalid_files_changes_nothing() {
+        let mut fx = Fixture::default();
+        crate::New {
+            name: "keep",
+            trackpoint: None,
+            route: false,
+        }
+        .apply(&mut fx.state())
+        .unwrap();
+        let selected = fx.selected_files();
+
+        let result = LoadFiles {
+            files: vec![
+                load(b"<gpx><trk></gpx>", "x"),
+                load(b"<gpx><wpt></gpx>", "y"),
+            ],
+        }
+        .apply(&mut fx.state());
+        assert!(matches!(result, Err(CommandError::InvalidData(_))));
+        assert_eq!(fx.files.len(), 1);
+        assert_eq!(fx.order.0.len(), 1);
+        assert_eq!(fx.selected_files(), selected);
+
+        // nothing to load
+        assert_eq!(
+            LoadFiles { files: vec![] }.apply(&mut fx.state()),
+            Err(CommandError::NothingToDo)
+        );
+    }
+
+    #[test]
+    fn test_each_file_without_name_gets_its_own_name() {
+        let mut fx = Fixture::default();
+        let unnamed = br#"<gpx version="1.1"><trk><trkseg></trkseg></trk></gpx>"#;
+        LoadFiles {
+            files: vec![load(unnamed, "first"), load(unnamed, "second")],
+        }
+        .apply(&mut fx.state())
+        .unwrap();
+        let names: Vec<_> = fx
+            .order
+            .0
+            .iter()
+            .map(|id| fx.files[id].info.name.clone())
+            .collect();
+        assert_eq!(names, ["first", "second"]);
+    }
+}