progress

tauri/src/commands/disk.rs

@@ -1,16 +1,21 @@
-//! The files of the engine and the file system: picking files and folders, saving, and what the
-//! frontend shows of it (see `workspace`).
+//! The files of the engine and the file system: picking files and folders, saving, closing, and
+//! what the frontend shows of it (see `workspace`).
+//!
+//! The commands that can lose the edits of a file (closing, opening another folder) take what to do
+//! with the files that have some: the frontend asks the user, and the files that have edits stay
+//! open if it does not say.
 
 use std::collections::BTreeMap;
 use std::path::PathBuf;
 
-use gpx_engine::api;
+use gpx_engine::{ExportOptions, api};
+use serde::Deserialize;
 use tauri::{AppHandle, Runtime, State};
 use tauri_plugin_dialog::{DialogExt, FilePath};
 use uuid::Uuid;
 
 use crate::state::AppState;
-use crate::workspace::{Unsaved, WorkspaceState};
+use crate::workspace::{Entry, Unsaved, WorkspaceState, free_path};
 
 fn paths(picked: Vec<FilePath>) -> Vec<PathBuf> {
     picked
@@ -35,17 +40,186 @@ pub fn open_files<R: Runtime>(app: AppHandle<R>, state: State<AppState>) -> api:
     let Some(picked) = picked else {
         return api::Outcome::failed_none();
     };
-    let files = paths(picked);
+    open_paths(state, paths(picked))
+}
+
+/// Opens files that are on the disk, like the ones of the tree of the open folder. They get selected.
+#[tauri::command(async)]
+pub fn open_paths(state: State<AppState>, paths: Vec<PathBuf>) -> api::Outcome {
     state.core(move |core| {
-        let outcome = core.workspace.open_files(&mut core.engine, &files, true);
+        let outcome = core.workspace.open_files(&mut core.engine, &paths, true);
         core.keep_workspace();
         core.persist();
         outcome
     })
 }
 
-/// Opens the folder that the user picks: its GPX files are opened and it is watched. The folder
-/// that was open is closed, `unsaved` says what to do with its files that have unsaved edits.
+/// Writes the files among `ids` that are not the ones on the disk, asking where to put the ones
+/// that have no place: the file dialog for a single one, a folder for several of them. Says whether
+/// they were written, which is not the case if the user cancelled.
+///
+/// The files whose file on the disk was replaced are overwritten: the frontend asks before.
+fn write_unsaved<R: Runtime>(
+    app: &AppHandle<R>,
+    state: &AppState,
+    ids: Vec<Uuid>,
+) -> Result<bool, String> {
+    let (unlinked, start) = {
+        let ids = ids.clone();
+        state.core(move |core| {
+            (
+                core.workspace.unlinked(&core.engine, &ids),
+                core.workspace.folder.clone(),
+            )
+        })
+    };
+    let mut chosen = BTreeMap::new();
+    let mut folder = None;
+    match unlinked.as_slice() {
+        [] => {}
+        [(id, name)] => {
+            let mut dialog = app
+                .dialog()
+                .file()
+                .add_filter("GPX", &["gpx"])
+                .set_file_name(format!("{name}.gpx"));
+            if let Some(start) = &start {
+                dialog = dialog.set_directory(start);
+            }
+            match dialog
+                .blocking_save_file()
+                .and_then(|path| path.into_path().ok())
+            {
+                Some(path) => {
+                    chosen.insert(*id, path);
+                }
+                None => return Ok(false),
+            }
+        }
+        _ => {
+            let mut dialog = app.dialog().file();
+            if let Some(start) = &start {
+                dialog = dialog.set_directory(start);
+            }
+            match dialog
+                .blocking_pick_folder()
+                .and_then(|path| path.into_path().ok())
+            {
+                Some(path) => folder = Some(path),
+                None => return Ok(false),
+            }
+        }
+    }
+    state.core(move |core| {
+        let result = core
+            .workspace
+            .save(&core.engine, &ids, &chosen, folder.as_deref());
+        core.keep_workspace();
+        core.announce(None);
+        result.map(|()| true)
+    })
+}
+
+/// Writes files to the disk, replacing what is there. The ones that are not on the disk yet go in
+/// their folder, or where the user says. Says whether they were written (`false` if the user
+/// cancelled).
+#[tauri::command(async)]
+pub fn save_files<R: Runtime>(
+    app: AppHandle<R>,
+    state: State<AppState>,
+    file_ids: Vec<Uuid>,
+) -> Result<bool, String> {
+    write_unsaved(&app, &state, file_ids)
+}
+
+/// Writes a file where the user says, which is where the file is from then on. Says whether it was
+/// written (`false` if the user cancelled).
+#[tauri::command(async)]
+pub fn save_file_as<R: Runtime>(
+    app: AppHandle<R>,
+    state: State<AppState>,
+    file_id: Uuid,
+) -> Result<bool, String> {
+    let (name, current, folder) = state.core(move |core| {
+        let name = core
+            .engine
+            .file_structure(&gpx_engine::FileId(file_id))
+            .map(|structure| structure.name.clone());
+        let status = core.workspace_state();
+        let file = status.files.get(&file_id.to_string());
+        let current = file.and_then(|file| file.path.clone().map(PathBuf::from));
+        let folder = file
+            .and_then(|file| file.folder.clone().map(PathBuf::from))
+            .or(status.folder.map(PathBuf::from));
+        (name, current, folder)
+    });
+    let Some(name) = name else {
+        return Ok(false);
+    };
+    let mut dialog = app.dialog().file().add_filter("GPX", &["gpx"]);
+    match &current {
+        Some(path) => {
+            if let Some(file_name) = path.file_name() {
+                dialog = dialog.set_file_name(file_name.to_string_lossy());
+            }
+            if let Some(parent) = path.parent() {
+                dialog = dialog.set_directory(parent);
+            }
+        }
+        None => {
+            dialog = dialog.set_file_name(format!("{name}.gpx"));
+            if let Some(folder) = &folder {
+                dialog = dialog.set_directory(folder);
+            }
+        }
+    }
+    let Some(path) = dialog
+        .blocking_save_file()
+        .and_then(|path| path.into_path().ok())
+    else {
+        return Ok(false);
+    };
+    state.core(move |core| {
+        let result = core.workspace.save_as(&core.engine, file_id, &path);
+        core.keep_workspace();
+        core.announce(None);
+        result.map(|()| true)
+    })
+}
+
+/// Reads files again from the disk: the edits they have are lost (they are one undo step).
+#[tauri::command(async)]
+pub fn reload_files(state: State<AppState>, file_ids: Vec<Uuid>) -> Result<api::Outcome, String> {
+    state.core(move |core| {
+        let outcome = core.workspace.reload(&mut core.engine, &file_ids);
+        core.keep_workspace();
+        core.persist();
+        core.announce(None);
+        outcome
+    })
+}
+
+/// The files among `ids` that are not the ones on the disk, saved first if `unsaved` says so.
+/// Says whether to go on, which is not the case if the user cancelled saving them.
+fn settle<R: Runtime>(
+    app: &AppHandle<R>,
+    state: &AppState,
+    ids: Vec<Uuid>,
+    unsaved: Option<Unsaved>,
+) -> Result<bool, String> {
+    if unsaved != Some(Unsaved::Save) {
+        return Ok(true);
+    }
+    let unsaved_ids = state.core(move |core| core.workspace.unsaved(&core.engine, &ids));
+    if unsaved_ids.is_empty() {
+        return Ok(true);
+    }
+    write_unsaved(app, state, unsaved_ids)
+}
+
+/// Opens the folder that the user picks, which is watched. Its files are not opened. The folder
+/// that was open is closed with its files: `unsaved` says what to do with the ones that have
+/// unsaved edits.
 #[tauri::command(async)]
 pub fn open_folder<R: Runtime>(
     app: AppHandle<R>,
@@ -60,80 +234,167 @@ pub fn open_folder<R: Runtime>(
     else {
         return Ok(api::Outcome::failed_none());
     };
+    let all = state.core(|core| core.workspace.all(&core.engine));
+    if !settle(&app, &state, all, unsaved)? {
+        return Ok(api::Outcome::failed_none());
+    }
     state.core(move |core| {
+        let discard = unsaved.is_some();
         let outcome = core
             .workspace
-            .open_folder(&mut core.engine, &folder, unsaved);
+            .open_folder(&mut core.engine, &folder, discard);
         core.keep_workspace();
         core.persist();
         core.watch();
         core.announce(None);
-        outcome
+        Ok(outcome)
     })
 }
 
-/// Closes the folder: it is not watched anymore, and its files are closed. `unsaved` says what to
-/// do with the ones that have unsaved edits (they stay without it).
+/// Closes the folder: it is not watched anymore, and the files are closed with it. `unsaved` says
+/// what to do with the ones that have unsaved edits (they stay open without it).
 #[tauri::command(async)]
-pub fn close_folder(
+pub fn close_folder<R: Runtime>(
+    app: AppHandle<R>,
     state: State<AppState>,
     unsaved: Option<Unsaved>,
 ) -> Result<api::Outcome, String> {
+    let all = state.core(|core| core.workspace.all(&core.engine));
+    if !settle(&app, &state, all, unsaved)? {
+        return Ok(api::Outcome::failed_none());
+    }
     state.core(move |core| {
-        let outcome = core.workspace.close_folder(&mut core.engine, unsaved);
+        let outcome = core
+            .workspace
+            .close_folder(&mut core.engine, unsaved.is_some());
         core.keep_workspace();
         core.persist();
         core.watch();
         core.announce(None);
-        outcome
+        Ok(outcome)
     })
 }
 
-/// Writes files to the disk, replacing what is there. The ones that are not on the disk yet go in
-/// the open folder, or where the user says if there is none.
+/// Closes files. `unsaved` says what to do with the ones that have unsaved edits: they are saved
+/// first, or the edits are lost (they stay open without it).
 #[tauri::command(async)]
-pub fn save_files<R: Runtime>(
+pub fn close_files<R: Runtime>(
     app: AppHandle<R>,
     state: State<AppState>,
     file_ids: Vec<Uuid>,
-) -> Result<(), String> {
-    let (ids, unlinked, folder) = {
-        let ids = file_ids.clone();
-        state.core(move |core| {
-            (
-                ids.clone(),
-                core.workspace.unlinked(&core.engine, &ids),
-                core.workspace.folder.clone(),
-            )
-        })
-    };
-    let mut chosen = BTreeMap::new();
-    // with a folder open, a new file goes in it: nobody is asked
-    let to_ask = if folder.is_some() { vec![] } else { unlinked };
-    for (id, name) in to_ask {
-        let mut dialog = app
-            .dialog()
-            .file()
-            .add_filter("GPX", &["gpx"])
-            .set_file_name(format!("{name}.gpx"));
-        if let Some(folder) = &folder {
-            dialog = dialog.set_directory(folder);
-        }
-        match dialog
-            .blocking_save_file()
-            .and_then(|path| path.into_path().ok())
-        {
-            Some(path) => {
-                chosen.insert(id, path);
-            }
-            // cancelled: the others are not saved either
-            None => return Ok(()),
-        }
+    unsaved: Option<Unsaved>,
+) -> Result<api::Outcome, String> {
+    if !settle(&app, &state, file_ids.clone(), unsaved)? {
+        return Ok(api::Outcome::failed_none());
     }
     state.core(move |core| {
-        let result = core.workspace.save(&core.engine, &ids, &chosen);
+        let outcome = core
+            .workspace
+            .close_files(&mut core.engine, &file_ids, unsaved.is_some());
         core.keep_workspace();
+        core.persist();
         core.announce(None);
-        result
+        Ok(outcome)
     })
 }
+
+/// The folders and GPX files that are in a folder of the open folder, or in it (the root of the
+/// tree when no path is given).
+#[tauri::command(async)]
+pub fn list_folder(state: State<AppState>, path: Option<PathBuf>) -> Result<Vec<Entry>, String> {
+    state.core(move |core| {
+        let Some(path) = path.or_else(|| core.workspace.folder.clone()) else {
+            return Ok(vec![]);
+        };
+        core.workspace.list_folder(&path)
+    })
+}
+
+/// What the files are exported with, see `ExportOptions`.
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExportArguments {
+    time: bool,
+    hr: bool,
+    cad: bool,
+    atemp: bool,
+    power: bool,
+    osm: bool,
+    as_route: bool,
+}
+
+impl From<ExportArguments> for ExportOptions {
+    fn from(arguments: ExportArguments) -> Self {
+        Self {
+            time: arguments.time,
+            hr: arguments.hr,
+            cad: arguments.cad,
+            atemp: arguments.atemp,
+            power: arguments.power,
+            osm: arguments.osm,
+            as_route: arguments.as_route,
+        }
+    }
+}
+
+/// Writes copies of files where the user says: a file dialog for a single one, a folder for
+/// several. The files stay as they are. Says whether they were written (`false` if the user
+/// cancelled).
+#[tauri::command(async)]
+pub fn export_files<R: Runtime>(
+    app: AppHandle<R>,
+    state: State<AppState>,
+    file_ids: Vec<Uuid>,
+    options: ExportArguments,
+) -> Result<bool, String> {
+    let options = ExportOptions::from(options);
+    let files: Vec<(String, Vec<u8>)> = state.read(move |engine| {
+        file_ids
+            .iter()
+            .filter_map(|id| {
+                let name = engine
+                    .file_structure(&gpx_engine::FileId(*id))?
+                    .name
+                    .clone();
+                Some((name, api::export_file(engine, *id, options)?))
+            })
+            .collect()
+    });
+    let write = |path: PathBuf, bytes: &[u8]| {
+        crate::store::write_atomically(&path, bytes)
+            .map_err(|error| format!("{}: {error}", path.display()))
+    };
+    match files.as_slice() {
+        [] => Ok(false),
+        [(name, bytes)] => {
+            let Some(path) = app
+                .dialog()
+                .file()
+                .add_filter("GPX", &["gpx"])
+                .set_file_name(format!("{name}.gpx"))
+                .blocking_save_file()
+                .and_then(|path| path.into_path().ok())
+            else {
+                return Ok(false);
+            };
+            write(path, bytes).map(|()| true)
+        }
+        _ => {
+            let Some(folder) = app
+                .dialog()
+                .file()
+                .blocking_pick_folder()
+                .and_then(|path| path.into_path().ok())
+            else {
+                return Ok(false);
+            };
+            let mut written: Vec<PathBuf> = vec![];
+            for (name, bytes) in &files {
+                let path = free_path(&folder, name, |path| written.iter().any(|w| w == path));
+                write(path.clone(), bytes)?;
+                written.push(path);
+            }
+            Ok(true)
+        }
+    }
+}