blockworx/tools/

file_menu.rs

//! The File menu: which diagram the session is editing, and where it lives.
//!
//! One thing opens here, and it is a diagram — a `.bwx` container, which on
//! disk is a directory with that suffix. There is no second entry for the
//! `document.json` beside the log: that file is a *projection*, carrying
//! neither the log nor the assets, so it is not a diagram anybody can open
//! (R53). It is still what an export writes and what the CLI will read for a
//! developer.
//!
//! The document bar's File section — a cascading dropdown, no dialogs of our
//! own. Nothing here writes *changes*: a container takes every commit as it
//! is made (F5), so there is no save action and no UI implies one (invariant
//! 10) — and nothing here refreshes `document.json` either, since the
//! projection keeps itself fresh (R31). "Save as…" is the one entry that
//! gives a scratch session a file for the first time.
//!
//! Native only: the browser has no container to open.

use std::path::{Path, PathBuf};

use egui::{TextWrapMode, Ui};

use crate::file::{FileRequest, SaveScope};
use crate::tools::tool::Action;
use blockworx_store::doc::Viewing;

/// See `preferences_menu::no_wrap`: menu popups shrink-to-fit and proportional
/// fonts can round a label just past the popup width, wrapping the last glyph.
fn no_wrap(ui: &mut Ui) {
    ui.style_mut().wrap_mode = Some(TextWrapMode::Extend);
}

/// Populate the File button's dropdown. Returns the action a click
/// requested. `home` is the container this session is attached to, or `None`
/// for a scratch session, which has nothing on disk to share.
pub fn menu(
    ui: &mut Ui,
    recent: &[PathBuf],
    viewing: Viewing,
    home: Option<&Path>,
) -> Option<Action> {
    no_wrap(ui);
    let mut action = None;
    if ui.button("New diagram").clicked() {
        action = Some(Action::NewDocument);
    }
    if ui.button("Open diagram…").clicked() {
        action = Some(Action::PickFile(FileRequest::OpenContainer));
    }
    if ui
        .button("Open shared diagram…")
        .on_hover_text("Open a diagram someone sent as a .zip \u{2014} it unpacks beside the file")
        .clicked()
    {
        action = Some(Action::PickFile(FileRequest::OpenBundle));
    }
    if let Some(picked) = recent_menu(ui, recent) {
        action = Some(Action::OpenRecent(picked));
    }
    ui.separator();
    // No "Refresh document.json" here. The user: *"'Refresh the
    // document.json' seems weird as a menu option - I don't know why this
    // would be needed."* — and they are right, because it is not: the
    // projection has kept itself fresh on its own since the debounced idle
    // refresh landed, so the entry offered to do by hand a thing that had
    // already happened. It stays in the registry, reachable from the
    // palette, for the one case the timer will not touch: a projection
    // somebody hand-edited, which is `Freshness::Unrecognized` and must be
    // overwritten deliberately or not at all (R31).
    // One entry, whose meaning is the rev on the canvas (R37). While the
    // lens is open it writes the log through *that* rev, so a reader can
    // take the document as they are looking at it and edit on top of it;
    // at head it is the Save-as it has always been. A second "Save rev
    // as…" would differ only by a condition the pill overhead is already
    // announcing.
    let scope = SaveScope::from(viewing);
    if ui
        .button("Save as…")
        .on_hover_text(save_as_hint(scope))
        .clicked()
    {
        action = Some(Action::PickFile(FileRequest::SaveAsContainer(scope)));
    }
    if let Some(shared) = share(ui, home) {
        action = Some(shared);
    }
    action
}

/// The share entry: this diagram as one file, which is the form that crosses
/// an e-mail (R54). Whole history, always — the ledger's without-history
/// bundle is deferred, since cutting at a rev is what Save-as is for.
///
/// Disabled rather than hidden on a scratch session, on R19's rule, and the
/// disabled hover says the one thing that makes it live.
fn share(ui: &mut Ui, home: Option<&Path>) -> Option<Action> {
    let mut action = None;
    ui.add_enabled_ui(home.is_some(), |ui| {
        let pressed = ui
            .button("Share…")
            .on_hover_text("Write this diagram and its whole history to one .zip")
            .on_disabled_hover_text("Save this diagram first \u{2014} there is nothing on disk yet")
            .clicked();
        if let (true, Some(home)) = (pressed, home) {
            action = Some(Action::PickFile(FileRequest::ShareBundle(
                crate::file::bundle_name(home),
            )));
        }
    });
    action
}

/// What Save-as promises, which is not the same sentence in both places it
/// can be pressed from.
fn save_as_hint(scope: SaveScope) -> String {
    match scope {
        SaveScope::Whole => {
            "Give this diagram a home on disk; every change lands in it from here on".to_owned()
        }
        SaveScope::Through(at) => format!(
            "Saves the diagram as shown \u{2014} through rev {}",
            at.get(),
        ),
    }
}

/// The remembered containers, as a submenu. Disabled rather than hidden
/// while nothing has been opened yet, so the menu keeps its shape.
fn recent_menu(ui: &mut Ui, recent: &[PathBuf]) -> Option<PathBuf> {
    let mut picked = None;
    ui.add_enabled_ui(!recent.is_empty(), |ui| {
        ui.menu_button("Open recent", |ui| {
            no_wrap(ui);
            for path in recent {
                if ui
                    .button(entry_label(path))
                    .on_hover_text(path.display().to_string())
                    .clicked()
                {
                    picked = Some(path.clone());
                }
            }
        });
    });
    picked
}

/// A recent entry's label: the container's own name, since the whole path
/// would run the menu off the screen. Two containers can share a name, which
/// is what the hover text is for.
fn entry_label(path: &Path) -> String {
    crate::file::container_name(path)
}

#[cfg(test)]
mod tests {
    use super::*;

    /// The hover says what the entry will do, and under the lens that is
    /// not what it does at the head — the promise names the rev, so a
    /// reader knows what they are about to get (R37).
    #[test]
    fn the_hover_promises_the_rev_that_will_be_written() {
        assert_eq!(
            save_as_hint(SaveScope::from(Viewing::Past(
                blockworx_doc::fixtures::rev(7)
            ))),
            "Saves the diagram as shown \u{2014} through rev 7",
        );
        assert!(
            !save_as_hint(SaveScope::from(Viewing::Head)).contains("rev"),
            "at the present there is no rev to promise",
        );
    }

    #[test]
    fn a_recent_entry_reads_as_the_container_name() {
        assert_eq!(
            entry_label(Path::new("/home/ada/work/engine.bwx")),
            "engine.bwx"
        );
    }
}