flea-qml 0.0.0-stage → 0.2.0

package/ui/js/Filter.js

@@ -0,0 +1,285 @@
+.pragma library
+.import "Input.js" as Input
+
+.import "Format.js" as Format
+.import "Match.js" as Match
+.import "Thumbs.js" as Thumbs
+
+// The strip's two sentences and the no-match tile's heading, each filled by Format.fill.
+var WORDS = {
+    noMatchOne: "No match among 1 item",
+    noMatchMany: "No match among %1 items",
+    shown: "%1 of %2 shown",
+    shownOfFolder: "%1 of %2 shown · of %3 in this folder",
+    nothingMatched: "Nothing matched %1"
+}
+
+// The filter narrows the listing already on screen: no walk, no round trip, and every row it keeps
+// is one the backend has already sent. ui/js/Search.js is its bigger sibling, which walks the
+// subtree and replaces the listing; the design canvas draws the two as different things and this
+// file never reaches ui/Backend.qml at all.
+//
+// Two index spaces meet here. A "listing row" is what the backend numbers, what a selection holds
+// and what every write operation sends; a "view position" is where a row is drawn. With no filter
+// up the two are the same number, and at() and viewOf() below are the only places that convert.
+
+// The listing rows a query leaves standing, in the order the backend sent them, or null when there
+// is no filter at all. Only the rows the pane holds can be tested, so the answer is a subsequence
+// of the held window; scope() below is what says so when the window is not the whole listing.
+// It is a subsequence and never a re-ranking, which is what keeps directories ahead of files.
+function shown(rows, held, query) {
+    if (query.length === 0) {
+        return null
+    }
+    var out = []
+    for (var i = 0; i < rows.length; i++) {
+        // The same run ui/js/Match.js paints in the name, so a row can never match without showing why.
+        // flea-qml: a Find result's row is a relative path, and the filter reads only its name.
+        if (Match.run(Match.rowName(rows[i], true), query).start >= 0) {
+            out.push(held + i)
+        }
+    }
+    return out
+}
+
+function at(list, view) {
+    if (list === null) {
+        return view
+    }
+    // A delegate can outlive the view position it was built for by a frame when the match list
+    // shrinks, so a position past the end answers -1: a listing row nothing holds and nothing draws.
+    return view < list.length ? list[view] : -1
+}
+
+// -1 for a row the filter hides, which is what the callers below clamp against.
+function viewOf(list, row) {
+    return list === null ? row : list.indexOf(row)
+}
+
+// Issue 92, nixfred: a query matching nothing leaves the cursor on a row the filter no longer draws.
+function cursorShown(pane) { return viewOf(pane.shown, pane.cursorIndex) >= 0 }
+
+// The strip's own sentence, SearchFilter rules 1 and 2: what the filter kept, out of the rows it
+// could test, and the directory those rows are a window on. The scope is the half that must not be
+// dropped, because zero matches among 350 loaded rows is not zero matches in a 104,812-file
+// directory; the tail goes when the window is the whole listing, which is nothing left to say.
+function summary(list, loaded, total) {
+    if (list === null) {
+        return ""
+    }
+    if (total > loaded) {
+        return Format.fill(WORDS.shownOfFolder, Format.count(list.length), Format.count(loaded), Format.count(total))
+    }
+    return Format.fill(WORDS.shown, Format.count(list.length), Format.count(loaded))
+}
+
+// States' no-match tile: the pane names the query back and says how many rows it tested, because
+// the query is up in a strip the reader may have looked away from.
+function noMatch(total) {
+    return total === 1 ? WORDS.noMatchOne : Format.fill(WORDS.noMatchMany, Format.count(total))
+}
+
+// The rows drawn between two ends, which is not the range between them: a plain index range would
+// sweep up every row the filter hid in the gap, and nothing on screen would say it had.
+function between(list, a, b) {
+    var lo = Math.min(a, b)
+    var hi = Math.max(a, b)
+    var out = []
+    for (var i = 0; i < list.length; i++) {
+        if (list[i] >= lo && list[i] <= hi) {
+            out.push(list[i])
+        }
+    }
+    return out
+}
+
+// A request cut back to the rows still drawn. A filtered viewport covers a set and not a run, so
+// the range-shaped planners hand back rows the filter hides, and asking for those would fetch work
+// nothing draws.
+function keep(asked, list) {
+    if (list === null) {
+        return asked
+    }
+    var drawn = {}
+    for (var i = 0; i < list.length; i++) {
+        drawn[list[i]] = true
+    }
+    var out = []
+    for (var j = 0; j < asked.length; j++) {
+        if (drawn[asked[j]] === true) {
+            out.push(asked[j])
+        }
+    }
+    return out
+}
+
+// A pending thumbnail can be hidden inside the planner's span as well as outside its viewport.
+function cut(work, list, state) {
+    var drop = work.drop.slice()
+    if (list !== null) {
+        var drawn = {}
+        for (var i = 0; i < list.length; i++) drawn[list[i]] = true
+        var dropping = {}
+        for (var j = 0; j < drop.length; j++) dropping[drop[j]] = true
+        for (var key in state.file) {
+            var row = Number(key)
+            if (Thumbs.pending(state.file[key]) && drawn[row] !== true && dropping[row] !== true)
+                drop.push(row)
+        }
+    }
+    return { ask: keep(work.ask, list), drop: drop }
+}
+
+// The listing rows a view range covers, for the two planners that take a first and a last.
+function span(list, first, last) {
+    if (list === null) {
+        return { first: first, last: last }
+    }
+    if (list.length === 0) {
+        return { first: 0, last: -1 }
+    }
+    var lo = Math.max(0, Math.min(list.length - 1, first))
+    var hi = Math.max(0, Math.min(list.length - 1, last))
+    return { first: list[lo], last: list[hi] }
+}
+
+// The transitions, taking ui/Pane.qml's root the way ui/js/Search.js and ui/js/Sort.js do: the pane
+// holds the state, this holds what the state does.
+
+// "/" opens the query line. Unlike the search's, nothing is committed to start a walk: the rows are
+// already here, so the listing narrows on the keystroke itself.
+function start(pane) {
+    pane.filterTyping = true
+}
+
+function typed(pane, character) {
+    apply(pane, pane.filterQuery + character)
+}
+
+function backspace(pane) {
+    apply(pane, pane.filterQuery.substring(0, pane.filterQuery.length - 1))
+}
+
+// Enter hands the keyboard back to the list with the filter standing, which is what makes y, x, d
+// and r work over the narrowed rows; an empty query has nothing to stand, so it closes instead.
+function commit(pane) {
+    if (pane.filterQuery.length === 0) {
+        close(pane)
+        return
+    }
+    pane.filterTyping = false
+}
+
+// Esc, and every fresh listing. The selection is deliberately not cleared: prune() below has already
+// cut it to rows the filter was showing, so what is left is exactly what was on screen.
+function close(pane) {
+    pane.filterQuery = ""
+    pane.filterTyping = false
+}
+
+// The new query is applied here rather than by writing the property alone, because the selection has
+// to lose the rows that just dropped out before anything can act on rows nobody can see. The next
+// match list is computed rather than read back off the pane's binding, so the order is not a guess.
+function apply(pane, query) {
+    var next = shown(pane.rows, pane.held, query)
+    prune(pane, next)
+    if (query !== pane.filterQuery) pane.filterKeyAt = Date.now()
+    pane.filterQuery = query
+    if (query.length > 0) pane.filterNarrowedAt = Date.now()
+    // A cursor the filter just hid takes the first row still standing, so it is never off screen.
+    if (next !== null && next.length > 0 && viewOf(next, pane.cursorIndex) < 0) {
+        pane.cursorIndex = next[0]
+        pane.cursorSeq += 1
+        pane.showRow(0)
+    }
+}
+
+// A selection you cannot see is one you can act on by accident, and trash, cut and copy all take the
+// selection with no confirmation at all: what the filter hides, it takes out of the selection too.
+function prune(pane, list) {
+    if (list === null) {
+        return
+    }
+    var drawn = {}
+    for (var i = 0; i < list.length; i++) {
+        drawn[list[i]] = true
+    }
+    var was = pane.selectedIndices()
+    var dropped = 0
+    for (var j = 0; j < was.length; j++) {
+        if (drawn[was[j]] !== true) {
+            pane.selection.toggle(was[j])
+            dropped += 1
+        }
+    }
+    if (dropped > 0) {
+        pane.selectionVersion += 1
+    }
+}
+
+// Cursor is a listing row but moves through drawn rows, so both steps convert.
+function setCursor(pane, index, context) {
+    setCursorView(pane, viewOf(pane.shown, index), context)
+}
+
+function setCursorView(pane, view, context) {
+    if (pane.shownTotal === 0) {
+        return
+    }
+    var to = Math.max(0, Math.min(pane.shownTotal - 1, view))
+    pane.cursorIndex = at(pane.shown, to)
+    // Every cursor setter bumps cursorSeq, so a plain move ends a Shift gesture.
+    pane.cursorSeq += 1
+    pane.showRow(to, context)
+}
+
+function moveCursor(pane, delta) {
+    setCursorView(pane, viewOf(pane.shown, pane.cursorIndex) + delta)
+}
+
+// The wheel moved the viewport and the cursor follows it. Both ends are view positions, because
+// under a filter the listing rows they name are not a run and a numeric clamp would be meaningless.
+function clampCursor(pane, first, last) {
+    var was = viewOf(pane.shown, pane.cursorIndex)
+    var to = Math.max(first, Math.min(last, was))
+    if (to !== was) {
+        var held = pulledFrom(pane)
+        var from = held >= 0 ? held : pane.cursorIndex
+        pane.cursorIndex = at(pane.shown, to)
+        pane.cursorSeq = (pane.cursorSeq || 0) + 1
+        pane.cursorPulled = { from: from, to: pane.cursorIndex, seq: pane.cursorSeq, version: pane.selectionVersion }
+    }
+}
+
+// The row the cursor held before the wheel pulled it, while no move, mark or new listing came since (issue 286); else -1.
+function pulledFrom(pane) {
+    var pull = pane.cursorPulled
+    var current = pull && pull.seq === (pane.cursorSeq || 0) && pull.to === pane.cursorIndex
+        && pull.version === pane.selectionVersion
+    return current ? pull.from : -1
+}
+
+// The query line's own keys while it has the caret, the shape ui/js/Search.js typeKey uses for the
+// search's. Enter commits, escape abandons, backspace shortens, every printable character narrows.
+function typeKey(event, pane) {
+    // Ctrl+V and Shift+Insert type the clipboard's first line as one narrowing (issue 287).
+    if (Input.isPasteKey(event))
+        return Input.pasteInto(pane, function (text) { typed(pane, text) })
+    if (event.key === Qt.Key_Return || event.key === Qt.Key_Enter) {
+        commit(pane)
+        return true
+    }
+    if (event.key === Qt.Key_Escape) {
+        close(pane)
+        return true
+    }
+    if (event.key === Qt.Key_Backspace) {
+        backspace(pane)
+        return true
+    }
+    if (Input.isPrintable(event.text)) {
+        typed(pane, event.text)
+        return true
+    }
+    return true
+}

package/ui/js/Find.js

@@ -0,0 +1,46 @@
+.pragma library
+
+// Match names by default; a forward slash explicitly asks for a relative path.
+// find emits slash-separated paths on Windows too (bunmsh's builtin), so the
+// query is never rewritten to backslashes, which would become glob escapes.
+function expression(query, hidden) {
+    var pattern = /[*?[]/.test(query) ? query : "*" + query + "*"
+    var predicate = query.indexOf("/") >= 0 ? "-ipath" : "-iname"
+    return hidden ? [predicate, pattern]
+        : ["-mindepth", "1", "-name", ".*", "-prune", "-o", predicate, pattern, "-print"]
+}
+
+// flea-qml: Ctrl+G's content search, `grep -r` with the query as literal text. Each file reports
+// its first matching line (-m 1), binary files included (-a), case ignored as -iname ignores it.
+// -o with CONTEXT characters either side bounds every output line, so a match inside a huge line
+// (a minified script, a binary with no line ends) still arrives as a short snippet around the
+// match. -Z ends the file name with NUL, so a name holding ":" parses. With no path operand grep
+// walks "." and names files without "./"; hidden names are skipped as find prunes them, and the
+// bare "." is never excluded by --exclude-dir.
+var CONTEXT = 80
+var SNIPPET_LIMIT = 300
+function escapeRegex(text) {
+    return String(text).replace(/[\\^$.*+?()[\]{}|]/g, "\\$&")
+}
+function grepArguments(query, hidden) {
+    var args = ["-r", "-n", "-o", "-a", "-i", "-m", "1", "-Z", "--line-buffered", "-E"]
+    if (!hidden) args.push("--exclude=.*", "--exclude-dir=.*")
+    return args.concat(["-e", ".{0," + CONTEXT + "}" + escapeRegex(query) + ".{0," + CONTEXT + "}"])
+}
+// One output line "name\0line:text" as {path, line, text}, or null for anything else.
+function grepLine(raw) {
+    var line = String(raw)
+    var cut = line.indexOf("\u0000")
+    if (cut <= 0) return null
+    var rest = line.substring(cut + 1)
+    var number = /^(\d+):/.exec(rest)
+    if (!number) return null
+    return { path: line.substring(0, cut), line: Number(number[1]), text: snippet(rest.substring(number[0].length)) }
+}
+// Control characters (a binary's NULs among them) and undecodable bytes become a middle dot and tabs a space, so the
+// row's single line of PlainText never breaks or hides; the text is cut at SNIPPET_LIMIT.
+function snippet(text) {
+    var cut = text.length > SNIPPET_LIMIT ? text.substring(0, SNIPPET_LIMIT) : text
+    // U+FFFD is a byte that was not UTF-8, as a binary holds many; it is shown the same way.
+    return cut.replace(/\t/g, " ").replace(/[\u0000-\u001f\u007f\ufffd]/g, "\u00b7").trim()
+}

package/ui/js/Flash.js

@@ -0,0 +1,184 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// The model behind ui/FlashView.qml, checked headless; every string is a whole template filled by one function.
+
+// One pass over the placeholders, so a value that holds a placeholder is never read twice.
+function fill(template, values) {
+    return String(template).replace(/\{(\w+)\}/g, function (whole, key) {
+        return Object.prototype.hasOwnProperty.call(values, key) ? String(values[key]) : whole
+    })
+}
+
+function leaf(path) {
+    var cut = String(path || "").lastIndexOf("/")
+    return cut >= 0 ? String(path).substring(cut + 1) : String(path)
+}
+
+// A drive fits when the backend refused it for no reason.
+function fits(drive) {
+    return !drive || drive.refused === ""
+}
+
+// An SD card reports through mmcblk, so its read-only row names the lock switch.
+function isCard(dev) {
+    return String((dev || "")).indexOf("mmcblk") === 0
+}
+
+// Refusal hints, each one whole sentence.
+var HINT_SMALL = "It is too small for the image."
+var HINT_LOCK = "Its lock switch is on. Slide the switch off and plug the card in again."
+var HINT_READONLY = "It is read-only, so Flea cannot write to it."
+var HINT_HOLDS_IMAGE = "The image is on this drive. Copy it elsewhere first."
+var HINT_MEMBER = "It is part of a RAID or volume group."
+var HINT_NOT_IMAGE = "This file is not a disk image."
+
+// The refusal hint under a refused drive row, the boards' own wording.
+function refusedHint(drive) {
+    var refused = drive ? drive.refused : ""
+    if (refused === "small")
+        return HINT_SMALL
+    if (refused === "readonly")
+        return isCard(drive.dev) ? HINT_LOCK : HINT_READONLY
+    if (refused === "holdsimage")
+        return HINT_HOLDS_IMAGE
+    if (refused === "member")
+        return HINT_MEMBER
+    return ""
+}
+
+// The label, or the model where no volume label names it; a repeated label gains the kernel name.
+function driveName(drive, drives) {
+    var label = drive.label && drive.label.length > 0 ? drive.label : drive.model
+    var twins = 0
+    for (var i = 0; i < (drives || []).length; i++) {
+        var other = drives[i].label && drives[i].label.length > 0 ? drives[i].label : drives[i].model
+        if (other === label)
+            twins += 1
+    }
+    return twins > 1 ? fill("{label} ({dev})", { label: label, dev: drive.dev }) : label
+}
+
+// The detail column, empty when it would repeat the label.
+function driveDetail(drive, drives) {
+    var model = drive.model || ""
+    return model === driveName(drive, drives) ? "" : model
+}
+
+// The compressed image's unpacked size in the detail column.
+function unpackedLine(bytes) {
+    return fill("{size} unpacked", { size: Format.size(bytes) })
+}
+
+// One drive that fits is chosen for you; with two or more none is.
+function preselect(drives) {
+    var found = -1
+    for (var i = 0; i < (drives || []).length; i++) {
+        if (!fits(drives[i]))
+            continue
+        if (found >= 0)
+            return -1
+        found = i
+    }
+    return found
+}
+
+// Cursor positions: 0 is the image, 1 to n the drives, n + 1 the Flash step.
+function flashPos(driveCount) {
+    return 1 + (driveCount || 0)
+}
+
+// The cursor walk skips refused rows, so a refused drive is never the choice.
+function step(cursor, delta, drives, hasImage, flashLive) {
+    var count = flashPos((drives || []).length) + 1
+    var at = cursor + delta
+    while (at >= 0 && at < count) {
+        if (at === 0 && hasImage)
+            return at
+        if (at > 0 && at <= (drives || []).length && fits(drives[at - 1]))
+            return at
+        if (at === flashPos((drives || []).length) && flashLive)
+            return at
+        at += delta
+    }
+    return cursor
+}
+
+// Flash is live only when an image and a fitting drive are both chosen.
+function flashLive(imageOk, drive) {
+    return imageOk === true && !!drive && fits(drive)
+}
+
+// The greyed row names the chosen drive, or the drive in general when none is chosen.
+var ERASE_NAMED = "Erases everything on {drive}"
+var ERASE_BARE = "Erases everything on the drive"
+var FLASH_NAMED = "Flash {drive}"
+var FLASH_BARE = "Flash"
+
+function flashWords(imageOk, drive, drives) {
+    var name = drive ? driveName(drive, drives) : ""
+    if (!imageOk || !name)
+        return { erase: ERASE_BARE, action: FLASH_BARE }
+    return { erase: fill(ERASE_NAMED, { drive: name }), action: fill(FLASH_NAMED, { drive: name }) }
+}
+
+// Ending headlines and hints live in ui/js/FlashEndings.js, beside the table they serve.
+
+// The card's heads and byte lines: one template each, {f:key} spans ink as figures.
+var FLASH_HEAD_WRITING = "Flashing {drive}"
+var FLASH_HEAD_VERIFYING = "Verifying {drive}"
+var FLASH_WAIT_PASSWORD = "waiting for your password"
+var FLASH_FILE_KNOWN = "{name} · {size}"
+var FLASH_FLUSH_LINE = "{f:bytes} written · waiting for the drive"
+var FLASH_KNOWN_LINE = "{f:moved} of {f:total} · {f:rate}{f:unit} · {f:left} left"
+var FLASH_KNOWN_STALLED = "{f:moved} of {f:total} · {f:rate}{f:unit}"
+var FLASH_UNKNOWN_LINE = "{f:moved} written · {f:rate}{f:unit} · {f:left} left"
+var FLASH_UNKNOWN_STALLED = "{f:moved} written · {f:rate}{f:unit}"
+
+// The status bar counts the pane's drives, never the covered folder: whole-sentence variants.
+var DRIVES_LINE = "{count} drives"
+var ONE_DRIVE_LINE = "1 drive"
+
+// A second pane cannot take the host while a flash runs.
+var ALREADY_RUNNING = "A flash is already running. Wait for it to finish."
+
+function drivesLine(n) {
+    return n === 1 ? ONE_DRIVE_LINE : fill(DRIVES_LINE, { count: Format.count(n) })
+}
+
+function alreadyRunning() {
+    return ALREADY_RUNNING
+}
+
+// A rail volume names its whole disk: sda1 is sda, sdp1 is sdp, nvme0n1p2 is nvme0n1, and mmcblk0 names itself.
+function railDisk(device) {
+    var name = leaf(device)
+    var numbered = /^(.*[0-9])p[0-9]+$/.exec(name)
+    if (numbered)
+        return numbered[1]
+    var lettered = /^((?:sd|vd|hd|xvd)[a-z]+)[0-9]+$/.exec(name)
+    return lettered ? lettered[1] : name
+}
+
+// The unpacked size shows only for a compressed image whose file records it; a raw image's size is its own.
+function imageDetail(image) {
+    var raw = !image || image.kind === "iso" || image.kind === "img"
+    return !raw && image.known === true && image.unpacked > 0 ? unpackedLine(image.unpacked) : ""
+}
+
+// The card's image from a flashimage reply, or null when the reply answers another file's probe, such as the pane's zip check.
+function imageFrom(current, message) {
+    if (!current || !message || message.path !== current.path)
+        return null
+    var kind = message.kind || ""
+    return { path: current.path, kind: kind, bytes: message.bytes || 0, unpacked: message.unpacked || 0,
+             known: message.known === true, member: message.member || "", refused: kind === "" }
+}
+
+// The Flash row's label ink: the erase line wears the warning's red with its triangle, the running head the foreground.
+function stepRole(running, ending) {
+    if (ending)
+        return ending.role
+    return running ? "foreground" : "error"
+}

package/ui/js/FlashCard.js

@@ -0,0 +1,79 @@
+.pragma library
+
+.import "Flash.js" as Flash
+.import "Format.js" as Format
+
+// The flash card's rendering, imported only by the lazy flasher so no startup file compiles it.
+
+// One template fill into inked parts: {f:key} spans become figures, the rest words.
+function lined(template, values) {
+    var parts = [], text = "", at = 0
+    while (at < template.length) {
+        var open = template.indexOf("{f:", at)
+        if (open < 0) {
+            text += template.substring(at)
+            break
+        }
+        text += template.substring(at, open)
+        var close = template.indexOf("}", open)
+        if (text.length > 0) {
+            parts.push({ text: text, figure: false })
+            text = ""
+        }
+        parts.push({ text: String(values[template.substring(open + 3, close)]), figure: true })
+        at = close + 1
+    }
+    if (text.length > 0)
+        parts.push({ text: text, figure: false })
+    return parts
+}
+
+function head(t) {
+    return Flash.fill(t.phase === "verify" ? Flash.FLASH_HEAD_VERIFYING : Flash.FLASH_HEAD_WRITING,
+        { drive: t.drive })
+}
+
+function file(t) {
+    return t.total > 0 ? Flash.fill(Flash.FLASH_FILE_KNOWN, { name: t.name, size: Format.size(t.total) }) : t.name
+}
+
+// The total a flash measures against: the known size, else the share the unpacker reports scaled up, else 0.
+function total(t) {
+    if (t.known === true && t.total > 0)
+        return t.total
+    var moved = t.bytes || 0
+    return (t.permille || 0) > 0 && moved > 0 ? Math.round(moved * 1000 / t.permille) : 0
+}
+
+function parts(t, rate) {
+    if (t.phase === "prepare" || t.phase === "password")
+        return [{ text: Flash.FLASH_WAIT_PASSWORD, figure: false }]
+    if (t.phase === "flush")
+        return t.bytes > 0 ? lined(Flash.FLASH_FLUSH_LINE, { bytes: Format.size(t.bytes) }) : []
+    var moved = t.bytes || 0
+    if (moved <= 0)
+        return []
+    var whole = total(t)
+    var values = { moved: Format.size(moved), rate: Format.size(rate), unit: "/s" }
+    if (whole > 0)
+        values.total = Format.size(whole)
+    if (whole > 0 && rate > 0)
+        values.left = Format.duration(Math.max(0, whole - moved) / rate * 1000)
+    if (t.known === true && t.total > 0)
+        return lined(values.left !== undefined ? Flash.FLASH_KNOWN_LINE : Flash.FLASH_KNOWN_STALLED, values)
+    return lined(values.left !== undefined ? Flash.FLASH_UNKNOWN_LINE : Flash.FLASH_UNKNOWN_STALLED, values)
+}
+
+function share(t) {
+    if (t.known === true && t.total > 0)
+        return (t.bytes || 0) / t.total
+    return (t.permille || 0) / 1000
+}
+
+// One render of every line a flash draws, stored on the transfer by the runner.
+function render(t, rate) {
+    var lines = parts(t, rate)
+    var at = share(t)
+    return { headText: head(t), fileText: file(t), byteText: lines,
+             share: at < 0 ? 0 : (at > 1 ? 1 : at), noCancel: t.phase === "flush" }
+}