blockworx_web/

library.rs

//! The documents the origin holds: what a tab opens on, where a new one is
//! born, which containers the File menu offers, and the two doors a
//! container travels in and out through.
//!
//! The desktop's library is a directory; this one is [`Root`], and
//! everything else about it is the same — the born three-word name, the
//! recent list, the rename that renames the container, the refusal of a name
//! something already stands under. The policies are [`blockworx_store`]'s and
//! are consumed here rather than written a second time.
//!
//! Every door is a promise, because origin-private storage is. What that
//! costs the shell is in [`crate::shell`]: a door is awaited off the frame
//! and the document it lands is adopted under a fresh borrow.

use blockworx_opfs::{Missing, Root};
use blockworx_store::container::{Container, Discarded, Glance, discard_unclaimed};
use blockworx_store::doc::Doc;
use blockworx_store::handle::{Clock, Store};
use blockworx_store::history::humanize;
use blockworx_store::naming::{candidates, entropy};
use blockworx_store::record::WallTime;
use blockworx_store::storage::{Any, DocumentRef, Name};
use blockworx_store::{recent, transfer};
use core::time::Duration;
use std::cell::RefCell;

/// One diagram the origin holds, as the Diagrams section lists it.
#[derive(Clone, PartialEq, Debug)]
pub struct Listed {
    /// The container's own name, which a door is raised with.
    pub name: String,
    /// Its newest rev and when that was written: `None` where no rev has
    /// been, or where the container could not be read.
    pub glance: Option<Glance>,
}

impl Listed {
    /// What the document is called — the name the breadcrumb shows for it.
    #[must_use]
    pub fn document(&self) -> String {
        blockworx_editor::import::file_stem(&self.name)
    }

    /// How long ago the newest rev was written, and which it is, as a row
    /// says it against `now`.
    #[must_use]
    pub fn edited(&self, now: WallTime) -> Option<String> {
        let glance = self.glance?;
        let rev = glance.rev.get();
        Some(
            match now.unix_millis().checked_sub(glance.written.unix_millis()) {
                Some(elapsed) => format!(
                    "Edited {} \u{00b7} rev {rev}",
                    humanize(Duration::from_millis(elapsed))
                ),
                // A stamp in the future is another machine's clock: the rev
                // is still worth saying.
                None => format!("rev {rev}"),
            },
        )
    }
}

/// What the tab opened on, and what it could not.
pub struct Opened {
    pub library: Library,
    pub doc: Doc,
    /// The standing fact a session with no files behind it owes the user —
    /// a page that is not a secure context, or a browser that would not
    /// open the origin's storage.
    pub notice: Option<String>,
}

/// The origin's documents, and the short list of them worth offering.
pub struct Library {
    /// `None` where the origin refused its storage, which is every page that
    /// is not a secure context. The editor opens either way, on a scratch
    /// session that persists nothing.
    root: Option<Root>,
    recent: RefCell<Vec<DocumentRef>>,
    kept: crate::prefs::Store,
}

impl Opened {
    /// A tab with no origin under it and nothing open — what the chrome's
    /// own snapshots are rendered over, where there is no browser at all.
    #[must_use]
    pub fn detached() -> Self {
        Opened {
            library: Library {
                root: None,
                recent: RefCell::new(Vec::new()),
                kept: crate::prefs::Store::default(),
            },
            doc: Doc::default(),
            notice: None,
        }
    }
}

impl Library {
    /// Open the origin and the document the tab last had, before the first
    /// frame runs.
    ///
    /// Nothing here refuses to start. An origin that will not open, a
    /// remembered document that is gone, a container that cannot be born —
    /// each falls back to the next thing down and says what happened.
    pub async fn opening(kept: crate::prefs::Store) -> Opened {
        let remembered = kept.recent();
        let root = match Root::open().await {
            Ok(root) => root,
            Err(why) => {
                return Opened {
                    library: Library {
                        root: None,
                        recent: RefCell::new(remembered),
                        kept,
                    },
                    doc: Doc::default(),
                    notice: Some(format!(
                        "Nothing will be saved: this page has no private storage ({why}). \
                         A page served over https or from localhost has one."
                    )),
                };
            }
        };
        let library = Library {
            root: Some(root),
            recent: RefCell::new(remembered),
            kept,
        };
        let (doc, notice) = library.stands_on().await;
        // After the document this tab stands on, because the lock it took on
        // the way in is what keeps the sweep off it.
        library.sweeps_unclaimed().await;
        Opened {
            library,
            doc,
            notice,
        }
    }

    /// The document a tab opens on: always a newborn. A document that breaks
    /// the app must not be the one every reload walks back into; the ones
    /// before it are a menu away.
    pub(crate) async fn stands_on(&self) -> (Doc, Option<String>) {
        match self.born().await {
            Ok(store) => (Doc::attached(store), None),
            Err(why) => (Doc::default(), Some(why)),
        }
    }

    /// The containers a tab that is gone left behind: one born under a name
    /// nobody kept, never written into, and held by no view, goes before the
    /// library lists it.
    ///
    /// The desktop sweeps these on the way out. A closed tab runs nothing, so
    /// the question is asked the next time one opens instead, and the lock
    /// stands in for what a session would otherwise remember making.
    async fn sweeps_unclaimed(&self) {
        let Some(root) = &self.root else {
            return;
        };
        let held = match root.containers().await {
            Ok(held) => held,
            Err(why) => {
                tracing::error!("the origin would not list its documents: {why}");
                return;
            }
        };
        for name in held {
            let storage = match root.container(&name, Missing::IsNothing).await {
                Ok(storage) => storage,
                Err(why) => {
                    tracing::warn!("{name} could not be looked at: {why}");
                    continue;
                }
            };
            match discard_unclaimed(&storage, blockworx_store::history::now()).await {
                Ok(Discarded::Removed) => tracing::info!("removed {name}, which held no edit"),
                Ok(Discarded::Kept) => {}
                Err(why) => tracing::warn!("{name} could not be tidied away: {why}"),
            }
        }
    }

    /// Every container the origin holds, in name order — what File ▸ Open
    /// lists, with the recent ones first.
    pub async fn containers(&self) -> Vec<Name> {
        let Some(root) = &self.root else {
            return Vec::new();
        };
        let mut held = root.containers().await.unwrap_or_else(|why| {
            tracing::error!("the origin would not list its documents: {why}");
            Vec::new()
        });
        let recent = self.recent.borrow();
        held.sort_by_key(|name| {
            recent
                .iter()
                .position(|named| named.as_str() == name.as_str())
                .unwrap_or(recent.len())
        });
        held
    }

    /// Every container the origin holds with a glance at each, newest edit
    /// first — what the Diagrams section lists. Read without taking any
    /// container's lock, so one open in this tab or another lists the same.
    pub async fn listing(&self) -> Vec<Listed> {
        let Some(root) = &self.root else {
            return Vec::new();
        };
        let mut listed = Vec::new();
        for name in self.containers().await {
            let glance = match root.container(&name, Missing::IsNothing).await {
                Ok(storage) => Container::glance(storage).await.unwrap_or_else(|why| {
                    tracing::warn!("{name} could not be read: {why}");
                    None
                }),
                Err(why) => {
                    tracing::warn!("{name} could not be looked at: {why}");
                    None
                }
            };
            listed.push(Listed {
                name: name.to_string(),
                glance,
            });
        }
        listed.sort_by(|a, b| {
            let written = |entry: &Listed| entry.glance.map(|at| at.written);
            written(b).cmp(&written(a))
        });
        listed
    }

    /// A document born under a name nothing in the origin stands under.
    ///
    /// # Errors
    /// The sentence the canvas is told: no storage to be born in, no unused
    /// name, or the container that would not be laid down.
    pub async fn born(&self) -> Result<Store<Any>, String> {
        let root = self.origin()?;
        for called in candidates(entropy) {
            match root.holds(&called).await {
                Ok(true) => continue,
                Ok(false) => {}
                Err(why) => return Err(failed_to("create a new diagram", &why)),
            }
            let storage = root
                .container(&called, Missing::IsMade)
                .await
                .map_err(|why| failed_to("create a new diagram", &why))?;
            return Store::creating(Any::new(storage), Clock::System)
                .await
                .map_err(|why| failed_to("create a new diagram", &why));
        }
        Err("Failed to create a new diagram: no unused name to give it".to_owned())
    }

    /// The container `named`, open.
    ///
    /// A held lock is an outcome rather than a failure: the store opens
    /// read-only with [`ReadOnlyReason::Locked`], which is how a second tab
    /// of one document lands. Only a name nothing stands under — or stands
    /// under as something that is not a container — is refused.
    ///
    /// [`ReadOnlyReason::Locked`]: blockworx_store::container::ReadOnlyReason::Locked
    ///
    /// # Errors
    /// The sentence the canvas is told.
    pub async fn opens(&self, named: &DocumentRef) -> Result<Store<Any>, String> {
        let root = self.origin()?;
        let called =
            Name::new(named.as_str()).ok_or_else(|| format!("{named} is not a diagram"))?;
        let storage = root
            .container(&called, Missing::IsNothing)
            .await
            .map_err(|why| why.to_string())?;
        Store::opening(Any::new(storage), Clock::System)
            .await
            .map_err(|why| why.to_string())
    }

    /// Call `doc`'s container something else, which is what renaming the
    /// document means. The session carries straight on into it.
    ///
    /// # Errors
    /// The sentence the canvas is told.
    pub async fn renames(&self, doc: &mut Doc, to: &str) -> Result<(), String> {
        let was = doc
            .container_name()
            .ok_or("This session has no diagram to rename")?;
        let called =
            Name::of_document(to).ok_or_else(|| format!("\u{201c}{to}\u{201d} is not a name"))?;
        if called == was {
            return Ok(());
        }
        doc.renaming_to(&called)
            .await
            .map_err(|why| failed_to(&format!("rename {was}"), &why))?;
        self.forgets(&DocumentRef::new(was.as_str()));
        self.remembers(&called);
        Ok(())
    }

    /// Remove `named` and everything in it.
    ///
    /// # Errors
    /// The sentence the canvas is told.
    pub async fn removes(&self, named: &Name) -> Result<(), String> {
        let root = self.origin()?;
        root.remove(named)
            .await
            .map_err(|why| failed_to(&format!("delete {named}"), &why))?;
        self.forgets(&DocumentRef::new(named.as_str()));
        Ok(())
    }

    /// Remove `named`, which this tab does not have open — refused where
    /// another tab does, whose session would be left writing into nothing.
    ///
    /// # Errors
    /// The sentence the canvas is told.
    pub async fn removes_closed(&self, named: &Name) -> Result<(), String> {
        let root = self.origin()?;
        root.remove_unheld(named)
            .await
            .map_err(|why| failed_to(&format!("delete {named}"), &why))?;
        self.forgets(&DocumentRef::new(named.as_str()));
        Ok(())
    }

    /// The container `named`, as the one file it travels in.
    ///
    /// Read through a second handle on the same directory rather than
    /// through the session's own: the session holds a *resident* container,
    /// so what it owes the origin has to have been drained before this is
    /// asked — which is the shell's to see to.
    ///
    /// # Errors
    /// The sentence the canvas is told.
    pub async fn packs(&self, named: &Name) -> Result<Vec<u8>, String> {
        let root = self.origin()?;
        let storage = root
            .container(named, Missing::IsNothing)
            .await
            .map_err(|why| failed_to(&format!("export {named}"), &why))?;
        transfer::pack(&storage)
            .await
            .map_err(|why| failed_to(&format!("export {named}"), &why))
    }

    /// Lay the container `archive` holds down in the origin under the
    /// document name `called` suggests, and open it.
    ///
    /// The name is refused rather than merged into if something already
    /// stands under it: an import brings a diagram in, it does not overwrite
    /// one.
    ///
    /// # Errors
    /// The sentence the canvas is told.
    pub async fn unpacks(&self, called: &str, archive: &[u8]) -> Result<Store<Any>, String> {
        let root = self.origin()?;
        let named =
            carried(called).ok_or_else(|| format!("\u{201c}{called}\u{201d} is not a diagram"))?;
        let taken = root
            .holds(&named)
            .await
            .map_err(|why| failed_to(&format!("import {named}"), &why))?;
        if taken {
            return Err(format!(
                "Failed to import {named}: this origin already holds a diagram of that name"
            ));
        }
        let storage = root
            .container(&named, Missing::IsMade)
            .await
            .map_err(|why| failed_to(&format!("import {named}"), &why))?;
        // A container the store cannot open is not one that arrived: the
        // half-laid directory goes rather than joining the list as a
        // document that will not open.
        let laid = transfer::unpack(&storage, archive).await;
        let opened = match laid {
            Ok(()) => Store::opening(Any::new(storage), Clock::System)
                .await
                .map_err(|why| failed_to(&format!("import {named}"), &why)),
            Err(why) => Err(failed_to(&format!("import {named}"), &why)),
        };
        if opened.is_err() {
            let _ = root.remove(&named).await;
        }
        opened
    }

    /// Put `named` at the front of the list the File menu offers.
    pub fn remembers(&self, named: &Name) {
        let mut recent = self.recent.borrow_mut();
        recent::remember(&mut recent, &DocumentRef::new(named.as_str()));
        self.kept.remembers(&recent);
    }

    fn forgets(&self, named: &DocumentRef) {
        let mut recent = self.recent.borrow_mut();
        recent::forget(&mut recent, named);
        self.kept.remembers(&recent);
    }

    fn origin(&self) -> Result<&Root, String> {
        self.root
            .as_ref()
            .ok_or_else(|| "This page has no private storage to keep a diagram in".to_owned())
    }
}

/// Ask for a `.bwx.zip` and hand what comes back to the import door.
///
/// The input is made, clicked and let go rather than standing hidden in the
/// component tree: a picker is a moment, and an element that outlived it
/// would be a second place its state could be.
pub fn picks_an_archive(shell: &crate::shell::Shell) {
    use wasm_bindgen::{JsCast as _, prelude::Closure};

    let Some(input) = crate::shell::window()
        .and_then(|window| window.document())
        .and_then(|document| document.create_element("input").ok())
        .and_then(|element| element.dyn_into::<web_sys::HtmlInputElement>().ok())
    else {
        return;
    };
    input.set_type("file");
    input.set_accept(".zip");
    let shell = shell.clone();
    let picked = input.clone();
    let taken = Closure::once_into_js(move || {
        let Some(file) = picked.files().and_then(|files| files.get(0)) else {
            return;
        };
        let called = file.name();
        crate::shell::spawn(async move {
            match wasm_bindgen_futures::JsFuture::from(file.array_buffer()).await {
                Ok(read) => {
                    shell.imports_archive(called, js_sys::Uint8Array::new(&read).to_vec());
                }
                Err(why) => shell.failed(format!("Could not read {called}: {why:?}")),
            }
        });
    });
    input.set_onchange(Some(taken.unchecked_ref()));
    input.click();
}

fn carried(file: &str) -> Option<Name> {
    Name::of_archive(file)
}

fn failed_to(what: &str, why: &impl std::fmt::Display) -> String {
    format!("Failed to {what}: {why}")
}

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

    fn named(file: &str) -> String {
        carried(file)
            .map(|name| name.to_string())
            .unwrap_or_default()
    }

    #[test]
    fn a_picked_archive_names_the_document_it_carries() {
        assert_eq!(named("engine.bwx.zip"), "engine.bwx");
        assert_eq!(named("engine.bwx"), "engine.bwx");
        assert_eq!(named("engine.zip"), "engine.bwx");
        assert_eq!(
            named("notes.v2.bwx.zip"),
            "notes.v2.bwx",
            "a dotted document name keeps all of itself",
        );
        assert_eq!(carried("../escaped.zip"), None, "and a path is no name");
    }

    /// A row says how long ago its newest rev was written and which rev it
    /// is; a stamp from a clock ahead of this one still names the rev, and a
    /// container with no rev says nothing.
    #[test]
    fn a_listed_row_says_when_it_was_edited_and_at_which_rev() {
        let now = WallTime::from_unix_millis(10 * 3_600_000);
        let listed = |written| Listed {
            name: "rig.bwx".to_owned(),
            glance: Some(Glance {
                rev: blockworx_doc::fixtures::rev(12),
                written,
            }),
        };
        assert_eq!(
            listed(WallTime::from_unix_millis(7 * 3_600_000))
                .edited(now)
                .as_deref(),
            Some("Edited 3 hours ago \u{00b7} rev 12"),
        );
        assert_eq!(
            listed(WallTime::from_unix_millis(11 * 3_600_000))
                .edited(now)
                .as_deref(),
            Some("rev 12"),
        );
        let fresh = Listed {
            name: "rig.bwx".to_owned(),
            glance: None,
        };
        assert_eq!(fresh.edited(now), None);
        assert_eq!(fresh.document(), "rig");
    }

    /// A page with no origin storage still opens, and every door on it says
    /// the same thing rather than failing silently.
    #[test]
    fn a_library_with_no_origin_refuses_every_door_in_words() {
        let library = Library {
            root: None,
            recent: RefCell::new(Vec::new()),
            kept: crate::prefs::Store::default(),
        };
        let Err(refusal) = library.origin() else {
            panic!("a library with no root has no origin to answer");
        };
        assert!(refusal.contains("no private storage"), "{refusal}");
    }
}