blockworx/

file.rs

//! The File flow's platform half: the picker a [`FileRequest`] opens, and
//! which containers we offer to reopen. What a *path* means lives in
//! [`blockworx_store::file`] and what a request *is* in
//! [`blockworx_tools::file`]; both are re-exported here so the flow reads as
//! one vocabulary.
//!
//! Native only — the browser has no filesystem to open a container from.

use std::path::PathBuf;

use serde::{Deserialize, Serialize};

pub use blockworx_tools::file::{FilePick, FileRequest, PickReceiver, SaveScope};

pub use blockworx_store::file::{
    as_container_path, container_name, create_container, names_a_container, names_an_archive,
    open_archive, open_container, refused_as_a_diagram, renamed_beside, save_container_through,
};
pub use blockworx_store::storage::CONTAINER_EXTENSION;

/// What a container's *document* is called: the directory's own name without
/// the extension — `engine.bwx` holds the document `engine`. The name an
/// export stamps its provenance with. Here rather than one crate down, so
/// `.bwx` and an opened `.json` are stemmed by one function.
pub fn document_name(root: &std::path::Path) -> String {
    crate::import::file_stem(&container_name(root))
}

/// Where the recent-files list is kept in the eframe storage DB.
const RECENT_KEY: &str = "recent_containers";

/// The containers to offer reopening, most recent first. Persisted through
/// the eframe storage DB beside the appearance preferences.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct RecentFiles(Vec<PathBuf>);

impl RecentFiles {
    pub fn paths(&self) -> &[PathBuf] {
        &self.0
    }

    /// Put `path` at the front, where reopening it moves it back to.
    pub fn remember(&mut self, path: &std::path::Path) {
        blockworx_store::recent::remember(&mut self.0, &path.to_path_buf());
    }

    /// Drop `path` — what opening a container that is gone or unreadable
    /// does, so a dead entry is offered once and not twice.
    pub fn forget(&mut self, path: &std::path::Path) {
        blockworx_store::recent::forget(&mut self.0, &path.to_path_buf());
    }

    pub fn restore(storage: &dyn eframe::Storage) -> Self {
        storage
            .get_string(RECENT_KEY)
            .and_then(|text| serde_json::from_str(&text).ok())
            .unwrap_or_default()
    }

    pub fn save(&self, storage: &mut dyn eframe::Storage) {
        match serde_json::to_string(self) {
            Ok(text) => storage.set_string(RECENT_KEY, text),
            Err(e) => tracing::error!("Failed to serialize the recent-files list: {e}"),
        }
    }
}

/// Open `request`'s dialog off the UI thread (so the canvas keeps
/// repainting) and return the channel its pick arrives on.
pub fn spawn_file_dialog(ctx: &egui::Context, request: FileRequest) -> PickReceiver {
    let (tx, rx) = std::sync::mpsc::channel();
    let thread_ctx = ctx.clone();
    std::thread::spawn(move || {
        let _ = tx.send(pick(request));
        thread_ctx.request_repaint();
    });
    ctx.request_repaint();
    rx
}

/// The blocking half of [`spawn_file_dialog`]. A diagram is a directory, so
/// opening one is a folder pick; making one is a save pick, whose suggested
/// name carries the extension.
///
/// No native folder picker filters by suffix — rfd offers filters to file
/// pickers only — so the picker opens on folders and the *choice* is checked
/// afterwards, by [`refused_as_a_diagram`], with the refusal going out through
/// the ordinary failure path.
fn pick(request: FileRequest) -> Option<FilePick> {
    match request {
        FileRequest::OpenContainer => rfd::FileDialog::new()
            .set_title("Open a diagram (.bwx)")
            .pick_folder()
            .map(FilePick::Container),
        FileRequest::SaveAsContainer(scope) => rfd::FileDialog::new()
            .set_title("Save diagram as")
            .set_file_name(format!("diagram.{CONTAINER_EXTENSION}"))
            .save_file()
            .map(|path| FilePick::NewContainer(as_container_path(&path), scope)),
    }
}

#[cfg(test)]
pub(crate) mod tests {
    use super::*;
    use std::collections::HashMap;
    use std::path::Path;

    /// The eframe storage seam, in memory: the recent list has to survive a
    /// round trip through it, and there is no window here to get a real one.
    #[derive(Default)]
    pub struct MemoryStorage(HashMap<String, String>);

    impl eframe::Storage for MemoryStorage {
        fn get_string(&self, key: &str) -> Option<String> {
            self.0.get(key).cloned()
        }

        fn set_string(&mut self, key: &str, value: String) {
            self.0.insert(key.to_owned(), value);
        }

        fn remove_string(&mut self, key: &str) {
            self.0.remove(key);
        }

        fn flush(&mut self) {}
    }

    #[test]
    fn a_container_names_the_document_inside_it_without_its_extension() {
        assert_eq!(
            document_name(Path::new("/home/ada/motor-controller.bwx")),
            "motor-controller"
        );
        assert_eq!(
            document_name(Path::new("/home/ada/notes.v2.bwx")),
            "notes.v2"
        );
    }

    #[test]
    fn the_recent_list_round_trips_through_the_storage_seam() {
        let mut storage = MemoryStorage::default();
        assert!(
            RecentFiles::restore(&storage).paths().is_empty(),
            "precondition: nothing has been stored yet",
        );

        let mut recent = RecentFiles::default();
        recent.remember(Path::new("/tmp/one.bwx"));
        recent.remember(Path::new("/tmp/two.bwx"));
        recent.save(&mut storage);

        assert_eq!(RecentFiles::restore(&storage), recent);
    }

    /// A stored blob from a build that spelled the list differently must not
    /// take the app down with it — the same forgiveness the preferences blob
    /// gets.
    #[test]
    fn a_malformed_stored_list_restores_empty() {
        use eframe::Storage as _;

        let mut storage = MemoryStorage::default();
        storage.set_string(RECENT_KEY, "not a list".to_owned());
        assert!(RecentFiles::restore(&storage).paths().is_empty());
    }
}