flea-qml 0.0.0-stage → 0.2.0

package/ui/js/Eject.js

@@ -0,0 +1,217 @@
+.pragma library
+
+.import "Mounts.js" as Mounts
+.import "Format.js" as Format
+.import "Protocols.js" as Protocols
+.import "NetFs.js" as NetFs
+
+// Whole sentences with "%1" for the drive and "%2" for the drives still mounted under it, filled by Format.fill; the first three are what Ctrl+E answers with when it releases nothing.
+var WORDS = {
+    systemDrive: "%1 is the system drive, which Flea never unmounts",
+    systemVolume: "This folder is on a system volume, which Flea never unmounts",
+    noVolume: "This folder is not on a volume Flea can unmount",
+    safe: "Ejected %1. It is safe to unplug.",
+    safeImage: "Ejected %1.",
+    stillMounted: "%1 is still mounted; close what is using it.",
+    blockedOne: "%1 could not be ejected because %2 on the same drive is still mounted. Eject that instead.",
+    blockedMany: "%1 could not be ejected because %2 on the same drive are still mounted. Eject those instead.",
+    unconfirmed: "Could not confirm %1 was ejected; do not unplug it yet."
+}
+
+// Sample input: the lsblk --json body ui/js/Mounts.js "parseDevices" reads, taken again after
+// gio mount -e returned for /dev/sda1:
+// {"blockdevices":[
+//   {"name":"sda","path":"/dev/sda","label":null,"mountpoints":[null],"rm":true,"size":"116.1G","type":"disk","model":"USB Flash Disk",
+//    "children":[{"name":"sda1","path":"/dev/sda1","label":"128GB","mountpoints":[null],"rm":true,"size":"116.1G","type":"part","model":null}]}]}
+// The sda entry is then either gone, or still listed with every mountpoint under it null.
+// gio's exit code is never the witness: it has been 0 over a volume that stayed mounted.
+// "safe" when nothing under the disk that carries the device is mounted, "mounted" when anything
+// under it still is, "unknown" when the body is not a listing this can judge.
+function verdict(body, device) {
+    var disk = diskOf(body, device)
+    if (disk === undefined)
+        return "unknown"
+    if (disk === null)
+        return "safe"
+    return anyMounted(disk) ? "mounted" : "safe"
+}
+
+// The top-level lsblk node that holds the device: undefined when the body is not a listing, null
+// when no node holds it, which is the powered-off shape. The whole disk is what gets judged: gvfs
+// ejects the drive, so a sibling partition or a crypt child still mounted means still in use.
+function diskOf(body, device) {
+    var tree
+    try {
+        tree = JSON.parse(String(body || ""))
+    } catch (e) {
+        return undefined
+    }
+    var nodes = tree && tree.blockdevices
+    // A box with no block devices at all is not running, so an empty listing is a broken one.
+    if (!Array.isArray(nodes) || nodes.length === 0)
+        return undefined
+    var name = kernelName(device)
+    if (name.length === 0)
+        return undefined
+    for (var i = 0; i < nodes.length; i++) {
+        if (holds(nodes[i], name))
+            return nodes[i]
+    }
+    return null
+}
+
+// Both sides of every comparison here come from lsblk's own NAME column. volumeRow carries lsblk's
+// PATH now, and a device-mapper volume's path is /dev/mapper/<name>, so the leaf is what is read.
+function kernelName(device) {
+    var text = String(device || "")
+    var cut = text.lastIndexOf("/")
+    return cut < 0 ? text : text.substring(cut + 1)
+}
+
+function holds(node, name) {
+    if (String(node.name) === name)
+        return true
+    var kids = node.children || []
+    for (var i = 0; i < kids.length; i++) {
+        if (holds(kids[i], name))
+            return true
+    }
+    return false
+}
+
+// lsblk writes "[SWAP]" as a mountpoint of active swap, which is in use like any other mount. This
+// asks whether anything holds the volume at all, which is not Mounts.js mountOf's question: that one
+// answers where to browse, and swap is nowhere.
+function inUse(node) {
+    var points = node.mountpoints || []
+    for (var i = 0; i < points.length; i++) {
+        if (points[i] !== null && String(points[i]).length > 0)
+            return true
+    }
+    return false
+}
+
+function anyMounted(node) {
+    if (inUse(node))
+        return true
+    var kids = node.children || []
+    for (var i = 0; i < kids.length; i++) {
+        if (anyMounted(kids[i]))
+            return true
+    }
+    return false
+}
+
+// What the refusal has to name. Empty when the row itself is still mounted, because a re-press on
+// it is then the right next step; otherwise the labels of what is still mounted under the same disk,
+// because a re-press on a row lsblk now shows unmounted would silently do nothing.
+function blockers(body, device) {
+    var disk = diskOf(body, device)
+    if (!disk)
+        return []
+    var mounted = []
+    collectMounted(disk, mounted)
+    var name = kernelName(device)
+    for (var i = 0; i < mounted.length; i++) {
+        if (mounted[i].name === name)
+            return []
+    }
+    return mounted.map(function (m) { return m.label })
+}
+
+function collectMounted(node, out) {
+    if (inUse(node))
+        out.push({ name: String(node.name), label: node.label ? String(node.label) : String(node.name) })
+    var kids = node.children || []
+    for (var i = 0; i < kids.length; i++)
+        collectMounted(kids[i], out)
+}
+
+// Only a real drive's safe verdict may claim it is safe to unplug; an image has nothing to unplug.
+// Other verdicts keep their warnings and name a next step only when pressing it does something.
+function sentence(v, label, others, loop) {
+    if (v === "safe")
+        return { text: Format.fill(loop === true ? WORDS.safeImage : WORDS.safe, label), isError: false }
+    if (v === "attached") // A loop row unmounted, but its loop device could not be detached.
+        return { text: "Unmounted " + label + ", but its loop device is still attached.", isError: true }
+    if (v === "mounted") {
+        var rest = others || []
+        if (rest.length === 0)
+            return { text: Format.fill(WORDS.stillMounted, label), isError: true }
+        return { text: Format.fill(rest.length > 1 ? WORDS.blockedMany : WORDS.blockedOne, label, rest.join(", ")), isError: true }
+    }
+    return { text: Format.fill(WORDS.unconfirmed, label), isError: true }
+}
+
+// Only a releasable mounted row draws the mark in place of the square.
+// Sample input: {label:"NAS", group:"network", kind:"share", uri:"smb://h/data/", mounted:true}.
+function releasable(entry) {
+    if (!entry || entry.mounted !== true)
+        return false
+    if (entry.group === "device" && entry.kind === "volume")
+        return entry.removable === true || entry.loop === true
+    if (entry.group === "device" && entry.kind === "phone")
+        return true
+    if (entry.group === "network" && entry.kind === "share") {
+        // A kernel row names its fstype for the mark split; a gvfs share's scheme decides it.
+        if (entry.fstype)
+            return NetFs.isCifsFstype(entry.fstype)
+        return Protocols.schemeOf(entry.uri) !== "nfs"
+    }
+    return false
+}
+
+// The one-click release mirrors the rows Mounts.railMenu offers.
+function releaseAction(entry) {
+    if (!releasable(entry))
+        return ""
+    if (entry.group === "device" && entry.kind === "phone")
+        return "unmountPhone"
+    return entry.group === "device" ? "eject" : "unmount"
+}
+
+// Picked by name, never position (a volume or phone row leads with Open): Eject, else the row's unmount, else "".
+function releaseFromRows(rows) {
+    var list = rows || []
+    for (var i = 0; i < list.length; i++) {
+        if (list[i].action === "eject")
+            return "eject"
+    }
+    for (var j = 0; j < list.length; j++) {
+        if (list[j].action === "unmount" || list[j].action === "unmountVolume" || list[j].action === "unmountPhone")
+            return list[j].action
+    }
+    return ""
+}
+
+// Finder's Cmd+E with Cmd read as Ctrl: from the rail it releases the cursor row, from a listing the
+// mounted volume the directory is inside, so the key can never release a volume the operator is
+// not looking at. The verdict is Mounts.railMenu's either way, off the lsblk poll, and the release
+// goes through the same releaseChosen a chosen menu row takes, carrying the row's key. A hidden rail
+// unloads the Sidebar with its poll, verdict state and releaseChosen, so there is nothing to read
+// and nothing to release through: the pane spins a transient DeviceMounts for one one-shot listing
+// (ui/PaneRail.qml), which completes through this same function with its own entries and
+// releaseChosen. A null rail therefore never answers from silence; it hands the key to that flow.
+function release(root, rail, fromRail) {
+    if (!rail) {
+        root.ejectHidden()
+        return
+    }
+    var entry = fromRail ? rail.entries[rail.cursorIndex] : Mounts.holding(rail.entries, root.path)
+    if (fromRail && entry && entry.group === "device" && entry.kind === "disk") {
+        root.message(Format.fill(WORDS.systemDrive, entry.label), false)
+        return
+    }
+    if (!entry) {
+        // The backend alone names a system volume, off the listing's own device; a Recent history spans mounts, so it names none.
+        root.message(root.systemVolume === true && root.recentMode === "" ? WORDS.systemVolume : WORDS.noVolume, false)
+        return
+    }
+    var rows = Mounts.railMenu(entry)
+    var pick = releaseFromRows(rows)
+    if (pick === "") {
+        root.message(Format.fill(Mounts.WORDS.nothingToRelease, entry.label), false)
+        return
+    }
+    rail.releaseChosen(pick, Mounts.railKey(entry))
+}

package/ui/js/Errors.js

@@ -0,0 +1,188 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// Whole sentences, filled by Format.fill where a name goes in; the item is a file or a folder.
+var WORDS = {
+    deniedNamed: "%1 cannot be opened: you do not have permission.",
+    denied: "This folder cannot be opened: you do not have permission.",
+    unreadNamed: "%1 could not be read.",
+    unread: "That folder could not be read.",
+    taken: "An item with that name is already here.",
+    // Whole connection failures, each with its one cause; the mount service says it is a connection failure by flag, never by these words.
+    connectRefused: "Could not connect: the server refused the connection.",
+    connectNoFolder: "Could not connect: that location has no folder to show.",
+    connectMountedAs: "Could not connect: that share is already mounted as %1.",
+    connectNoAnswer: "Could not connect: the server did not respond.",
+    connectNoPassword: "Could not connect: the server did not accept the password.",
+    connectNoPrompt: "Could not connect: Flea could not ask for the password.",
+    connectUnopened: "Could not connect: the network location could not be opened."
+}
+
+// Errors reach the user as one sentence, never a raw path or errno. StatusBar board rule 4: the
+// sentence names the input and drops advice nobody can act on. named is the failing directory's own
+// leaf, empty when the breadcrumb is already standing on it and there is nothing to add.
+function sentence(where, message, named) {
+    if (where === "scan") {
+        if (denied(where, message)) {
+            return named ? Format.fill(WORDS.deniedNamed, named) : WORDS.denied
+        }
+        // A dead share names itself: stale, disconnected and silent each read differently.
+        if (shareStale(message)) return "That share changed, so this folder is no longer available."
+        if (shareGone(message)) return "That share is disconnected; remount it."
+        if (shareSilent(message)) return "That share is not responding."
+        return named ? Format.fill(WORDS.unreadNamed, named) : WORDS.unread
+    }
+    if (where === "sort") {
+        // Size and mtime are real orders, so the one refusal left is a key the wire never defined.
+        return "Sorting by that column is not available."
+    }
+    if (where === "read") {
+        return "Flea stopped responding. Reopen Flea and try again."
+    }
+    // The write operations say what they were doing, because the operator is about to try it again.
+    if (where === "undo" || where === "redo") {
+        // The empty journal is the common case and the backend's own sentence is already the right one.
+        return capitalised(message)
+    }
+    if (where === "rename") {
+        if (nameRefusal(message)) return capitalised(message)
+        if (readOnly(message)) return capitalised(message)
+        return exists(message) ? WORDS.taken : "That file could not be renamed."
+    }
+    // Bulk rename validates the whole batch first, so its sentence is the backend's own.
+    if (where === "bulkrename") {
+        return capitalised(message)
+    }
+    // undo reverses a rename through the same call, so this sentence names no direction.
+    if (where === "rename-kept") {
+        return "Copied to the new name, but the original was only partly removed. Check the original."
+    }
+    // Deliberately not the capitalised branch: every other mkdir refusal reaches the UI through
+    // src/error.rs from_io, which passes std::io::Error::to_string straight through, errno and all.
+    if (where === "mkdir") {
+        if (nameRefusal(message)) return capitalised(message)
+        if (readOnly(message)) return capitalised(message)
+        return exists(message) ? WORDS.taken
+                               : "That folder could not be created."
+    }
+    // The state file: what was asked for is still on screen, so the sentence says what did not last.
+    if (where === "state") {
+        return "That setting could not be saved."
+    }
+    // And the other way round: main() left a ui.json it could not read alone, so none of it is used.
+    if (where === "statefile") {
+        return "Your saved settings could not be read, so these are the defaults."
+    }
+    if (where === "duplicate") {
+        if (readOnly(message)) return capitalised(message)
+        return "That file could not be duplicated."
+    }
+    if (where === "trash") {
+        if (readOnly(message)) return capitalised(message)
+        return "That item could not be moved to Trash."
+    }
+    // The backend refused rows read from a listing it had already replaced, so nothing ran at all.
+    if (where === "stale") {
+        return "The listing changed before that arrived, so nothing was done."
+    }
+    // A window past its deadline names its mount, so the backend's own sentence is the one to show.
+    if (where === "window") {
+        return capitalised(message)
+    }
+    // A password request refused before the child started names its archive, like the read sentence names Flea.
+    if (where === "archive" && String(message) === "the backend is not running") {
+        return named ? Format.fill("%1 could not be opened because the Flea backend stopped; reopen Flea and try again.", named)
+                     : "This archive could not be opened because the Flea backend stopped; reopen Flea and try again."
+    }
+    if (where === "transfer" || where === "archive" || where === "convert"
+            || where === "link" || where === "linktarget" || where === "rename-stranded" || where === "pasteimage") {
+        return capitalised(message)
+    }
+    return "That action could not be completed; try again."
+}
+
+// One condition, two spellings: rename gets the errno's "File exists", while src/backend/ops.rs
+// words mkdir's own collision "a folder or file with that name already exists".
+function exists(message) {
+    var text = String(message).toLowerCase()
+    return text.indexOf("file exists") >= 0 || text.indexOf("already exists") >= 0
+}
+
+// A read-only refusal carries its own sentence from src/error.rs, so the write branches keep it.
+function readOnly(message) {
+    return String(message).toLowerCase().indexOf("read-only") >= 0
+}
+
+// A per-filesystem name refusal carries its own sentence from src/backend/fsname.rs, so rename and mkdir keep it.
+function nameRefusal(message) {
+    var text = String(message)
+    return text.indexOf("is not allowed in a name") >= 0 || text.indexOf("is reserved on this") >= 0
+        || text.indexOf("cannot end in a dot") >= 0 || text.indexOf("cannot end in a space") >= 0
+        || text.indexOf("cannot hold control character") >= 0
+}
+
+// The backend already writes these as sentences; this only makes one read like one in the bar.
+function capitalised(message) {
+    var text = String(message)
+    if (text.length === 0) {
+        return "That action could not be completed; try again."
+    }
+    var out = text.charAt(0).toUpperCase() + text.substring(1)
+    return out.charAt(out.length - 1) === "." ? out : out + "."
+}
+
+// The one place the backend's errno wording is read, so the sentence and the pane state can never
+// disagree about which failure this is.
+function denied(where, message) {
+    return where === "scan" && String(message).toLowerCase().indexOf("permission denied") >= 0
+}
+
+// ESTALE, ENOTCONN and ETIMEDOUT each read differently; the backend's words are src/error.rs.
+function shareStale(message) {
+    var text = String(message).toLowerCase()
+    return text.indexOf("stale") >= 0 || text.indexOf("no longer available") >= 0
+}
+function shareGone(message) {
+    var text = String(message).toLowerCase()
+    return text.indexOf("not connected") >= 0
+}
+function shareSilent(message) {
+    var text = String(message).toLowerCase()
+    return text.indexOf("timed out") >= 0 || text.indexOf("timeout") >= 0
+}
+
+// Which state the listing area reaches when a listing fails. A denial is the canvas's Locked tile on
+// States.dc.html, which draws the lock mark over the directory's own mode string; the rest are Error.
+function listingState(where, message) {
+    return denied(where, message) ? "locked" : "error"
+}
+
+// That tile's one line, drawn verbatim as "rwx------ · not yours". src/backend/meta.rs answers mode 0
+// when the stat itself failed, and a real st_mode always carries its file-type bits, so a zero here
+// means "I could not look" and earns no line rather than a false "---------".
+function lockedLine(mode) {
+    if (!(mode > 0)) {
+        return ""
+    }
+    return Format.permissions(mode) + notYours(mode)
+}
+
+// Entering a directory needs its execute bit and listing it needs its read bit, so an owner holding
+// both would not have been denied: a denial on such a directory proves the operator is not the
+// owner. Below that the owner is locked out too, and the line claims nothing it cannot know.
+var OWNER_CAN_LIST = 0o500
+
+// A readable, searchable owner mode proves an observed listing denial belongs to another user.
+function notYours(mode) {
+    return (mode & OWNER_CAN_LIST) === OWNER_CAN_LIST ? " · not yours" : ""
+}
+
+// 124 and 126/127 name a cause and 77 is tools/flea-gio-auth's proof of a refusal; gio's text is suppressed, so no other status names one.
+function connectFailure(exitCode) {
+    if (exitCode === 124) return WORDS.connectNoAnswer
+    if (exitCode === 126 || exitCode === 127)
+        return WORDS.connectNoPrompt
+    if (exitCode === 77) return WORDS.connectNoPassword
+    return WORDS.connectUnopened
+}

package/ui/js/ExtThumbs.js

@@ -0,0 +1,115 @@
+.pragma library
+
+.import "Thumbs.js" as Thumbs
+.import "Format.js" as Format
+
+// The ExtThumbs board's storage-class gate: network shares and phones are off, USB
+// drives are on, and anything else is local and always gets thumbnails. A class is
+// src/backend/extclass.rs's own word, carried beside the fsinfo line once per
+// directory change, so nothing here classifies and there is no second classifier.
+
+// Whole sentences with "%1" for a value, filled by fill so each translates as one; one per state.
+var WORDS = {
+    hide: "Hide %1 thumbnails",
+    show: "Show %1 thumbnails",
+    isOn: "%1 thumbnails are on",
+    isOff: "%1 thumbnails are off"
+}
+
+// Sample input: "network" answers "thumbNetwork", "" answers "".
+function keyForClass(storageClass) {
+    if (storageClass === "network") return "thumbNetwork"
+    if (storageClass === "phone") return "thumbPhone"
+    if (storageClass === "usb") return "thumbUsb"
+    return ""
+}
+
+// The menu row is present only on network, phone or USB storage, never locally.
+function present(storageClass) {
+    return keyForClass(storageClass) !== ""
+}
+
+// Sample input: ("usb", {}) answers true, ("network", {}) answers false.
+function classOn(storageClass, preview) {
+    var key = keyForClass(storageClass)
+    if (key === "") return true
+    if (key === "thumbUsb") return !preview || preview.thumbUsb !== false
+    return !!preview && preview[key] === true
+}
+
+function classOff(storageClass, preview) {
+    return present(storageClass) && !classOn(storageClass, preview)
+}
+
+// Off is cache-only, not blank: a visible row still asks, and the backend answers from
+// the shared cache with one stat and never starts a decoder. Thumbnails already made
+// still show, because the cache answers them. Sample input: ("network", {}) answers true.
+function cacheOnly(storageClass, preview) {
+    if (!classOff(storageClass, preview)) return false
+    return !preview || preview.thumbnails !== "off"
+}
+
+// The thumbed line's record: a cache-only miss on a generating class returns to unasked, any other reply is remembered.
+function thumbReply(state, row, file, cap, known, storageClass, preview) {
+    if (file === "" && state.file[row] === Thumbs.CACHE_ASKED && (!known || !cacheOnly(storageClass, preview)))
+        return { state: Thumbs.miss(state, row, true, cap), missed: true }
+    return { state: Thumbs.remember(state, row, file, cap), missed: false }
+}
+
+// In Columns the preview is manual on a class that is off: one condition, two surfaces.
+function manualHold(storageClass, preview) {
+    return cacheOnly(storageClass, preview)
+}
+
+// The menu row's own entrance: absent off the three classes, otherwise labelled for
+// the class and its state. Sample input: ({storageClass: "usb"}) answers "Hide USB thumbnails".
+function entry(e, p) {
+    if (!present(p.storageClass)) return false
+    e.label = label(p.storageClass, classOn(p.storageClass, p.thumbPreview))
+    return true
+}
+
+// Sample input: ("network", false) answers "Show network thumbnails".
+function label(storageClass, on) {
+    var noun = storageClass === "usb" ? "USB" : storageClass
+    return Format.fill(on ? WORDS.hide : WORDS.show, noun)
+}
+
+// The status bar's own verdict for the toggle, in the board's words.
+// Sample input: ("network", true) answers "Network thumbnails are on".
+function statusLine(storageClass, on) {
+    var noun = storageClass === "usb" ? "USB"
+        : storageClass.charAt(0).toUpperCase() + storageClass.slice(1)
+    return Format.fill(on ? WORDS.isOn : WORDS.isOff, noun)
+}
+
+// A class switched on decodes again: only its cache-only marks leave the map, so a
+// real refusal stays answered and is never decoded twice. Sample input:
+// {file: {3: "", 4: "/c/x.png", 5: "cache-missed"}, order: [3, 4, 5]} forgets 5 alone.
+function forgetMisses(state) {
+    var kept = []
+    for (var i = 0; i < state.order.length; i++) {
+        var at = state.order[i]
+        if (state.file[at] === Thumbs.CACHE_MISS || state.file[at] === Thumbs.CACHE_ASKED) delete state.file[at]
+        else kept.push(at)
+    }
+    state.order = kept
+    return { file: state.file, order: state.order }
+}
+
+// Sample input: ("network", {}) answers "only|media"; a zoom step or another class keeps it, so refreshes nothing.
+function verdict(storageClass, preview) {
+    var mode = preview && preview.thumbnails ? preview.thumbnails : "media"
+    return (cacheOnly(storageClass, preview) ? "only" : "full") + "|" + mode
+}
+
+// FileView reads the whole file, so a row over the gate is refused, not truncated, the
+// same rule ui/PreviewText.qml already keeps. Text previews on network and phone storage
+// read at most the first 256 KiB. Sample input: ("phone") answers 262144.
+var TEXT_PREVIEW_MAX = 1048576
+var REMOTE_TEXT_PREVIEW_MAX = 262144
+
+function textLimit(storageClass) {
+    if (storageClass === "network" || storageClass === "phone") return REMOTE_TEXT_PREVIEW_MAX
+    return TEXT_PREVIEW_MAX
+}