flea-qml 0.0.0-stage → 0.2.0

package/ui/js/PathBar.js

@@ -0,0 +1,260 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// The sentence Tab answers with when nothing completes, filled by Format.fill.
+var WORDS = {
+    manyStart: "%1 items start with that",
+    nothingStartsWith: "Nothing in %1 starts with that"
+}
+
+// What a typed path line means, and nothing about the field that carries it: ui/ChromeBar.qml owns
+// the field and ui/shell.qml owns the navigation, the same split ui/js/Filter.js keeps with its
+// strip. Every function here is pure, so tests/js/pathbar.js drives the whole of it with no window.
+//
+// The bar reads what the chrome already draws: a tilde is the home directory because that is how
+// the path is written above the listing, and a bare name is relative to the directory the pane is
+// on, because with the line selected on open that is what one word and Enter has to mean.
+
+// The one place a path is made canonical. Interior "." and ".." are resolved here rather than sent
+// to the backend, so the listing is opened on the path the bar will draw and the two never disagree;
+// "" is not a path and is what every caller checks for.
+function normalize(path) {
+    var text = String(path)
+    if (text.length === 0) {
+        return ""
+    }
+    var parts = text.split("/")
+    var out = []
+    for (var i = 0; i < parts.length; i++) {
+        var part = parts[i]
+        // An empty part is a doubled or a trailing slash, and neither names a directory of its own.
+        if (part.length === 0 || part === ".") {
+            continue
+        }
+        if (part === "..") {
+            // The root has no parent, which is where climbing stops, exactly as ui/js/Nav.js parent does.
+            out.pop()
+            continue
+        }
+        out.push(part)
+    }
+    return "/" + out.join("/")
+}
+
+// A file:// URI is what a paste from another application carries, and Flea's own --select takes one
+// too. A URI that will not decode is left as it stands rather than dropped: a literal percent in a
+// filename is legal, and refusing the whole line over one would be worse than a listing that fails.
+//
+// The authority between the third slash and the fourth is part of the URI and not part of the path.
+// RFC 8089 gives it two local spellings, the empty one and "localhost", and both mean this machine;
+// file://localhost/etc is /etc. Any other authority names a file on another host, which is not a
+// path this bar can open, so it answers "" and ui/ChromeBar.qml says so rather than opening the
+// authority as a directory of its own: stripping the scheme alone turned that line into a relative
+// walk into <current>/localhost/etc, which is a directory nobody named.
+var LOCAL_HOSTS = ["", "localhost"]
+
+function unwrap(text) {
+    var body = String(text)
+    if (body.indexOf("file://") !== 0) {
+        return body
+    }
+    body = body.substring("file://".length)
+    // Everything up to the next slash is the authority; with none, the whole remainder is one.
+    var cut = body.indexOf("/")
+    var authority = cut < 0 ? body : body.substring(0, cut)
+    if (LOCAL_HOSTS.indexOf(authority.toLowerCase()) < 0) {
+        return ""
+    }
+    body = cut < 0 ? "/" : body.substring(cut)
+    try {
+        return decodeURIComponent(body)
+    } catch (e) {
+        return body
+    }
+}
+
+// Display/input alias only. The Trash collection keeps its existing filesystem paths.
+function isTrashRoot(text) {
+    return /^trash:\/{1,3}$/i.test(String(text).trim())
+}
+
+function addressTarget(text, current, home) {
+    if (isTrashRoot(text)) return "trash:///"
+    return resolve(text, isTrashRoot(current) ? "/" : current, home)
+}
+
+function editLine(path) {
+    if (isTrashRoot(path)) return "trash:///"
+    return path === "/" ? "/" : path + "/"
+}
+
+// A typed smb:// (or sftp://, davs://, ...) address is a network location, not a name
+// relative to the pane: resolving it against the directory would list one nobody named.
+// The bar hands it back untouched, and the window routes it to the rail's own open.
+function isNetworkUri(text) {
+    return /^(smb|sftp|ftp|ftps|dav|davs|nfs|afp):\/\//i.test(String(text).trim())
+}
+
+// The typed line as an absolute path. Answers "" for a line that names nothing, which is what the
+// field checks before it navigates: an empty commit closes the bar and leaves the pane where it is.
+function resolve(text, current, home) {
+    var line = String(text).trim()
+    if (isNetworkUri(line)) {
+        return line
+    }
+    var body = unwrap(line)
+    // Empty either because nothing was typed or because unwrap refused a URI on another host; both
+    // answer "" here, and refused() below is what tells the two apart for the sentence.
+    if (body.length === 0) {
+        return ""
+    }
+    // The tilde only expands against a home the shell actually published; with none, it is a name.
+    if (home.length > 0 && (body === "~" || body.indexOf("~/") === 0)) {
+        body = home + body.substring(1)
+    } else if (body.charAt(0) !== "/") {
+        // Relative to where the pane is, so "Downloads" and Enter is a directory down.
+        body = current + "/" + body
+    }
+    return normalize(body)
+}
+
+// The line cut at its last slash: head is what names a directory and leaf is the part being typed,
+// which is the only part a completion may rewrite. A line with no slash at all is all leaf.
+function split(text) {
+    var body = String(text)
+    var cut = body.lastIndexOf("/")
+    if (cut < 0) {
+        return { head: "", leaf: body }
+    }
+    return { head: body.substring(0, cut + 1), leaf: body.substring(cut + 1) }
+}
+
+// Which directory a completion has to read to answer the line. The head alone, because the leaf is
+// half a name and would resolve to a directory that does not exist; an empty head is the pane's own.
+function completionDir(text, current, home) {
+    var head = split(String(text).trim()).head
+    if (head.length === 0) {
+        return current
+    }
+    return resolve(head, current, home)
+}
+
+// A leaf that starts with a dot is asking for hidden entries whatever the listing is showing, so the
+// peek behind Tab is told to include them rather than completing against rows it cannot see.
+function wantsHidden(text, showHidden) {
+    return showHidden || split(String(text).trim()).leaf.indexOf(".") === 0
+}
+
+// What a completion request and its reply are matched on. The peek wire carries no request id, and
+// it does not need one: two peeks of the same directory with the same hidden flag answer the same
+// rows, so the pair is identity enough, and a reply that differs in either is another asker's.
+// ui/ColumnsArea.qml peeks the pane's ancestors on the same signal, with the listing's own hidden
+// flag, so without this a Tab on ".conf" could complete against rows that carried no dotfiles at all.
+function requestKey(dir, hidden) {
+    return String(dir) + "\u0000" + (hidden ? "hidden" : "visible")
+}
+
+function commonPrefix(names) {
+    if (names.length === 0) {
+        return ""
+    }
+    var prefix = names[0]
+    for (var i = 1; i < names.length; i++) {
+        var j = 0
+        while (j < prefix.length && j < names[i].length && prefix.charAt(j) === names[i].charAt(j)) {
+            j++
+        }
+        prefix = prefix.substring(0, j)
+    }
+    return prefix
+}
+
+function startsWith(name, leaf, fold) {
+    var a = fold ? name.toLowerCase() : name
+    var b = fold ? leaf.toLowerCase() : leaf
+    return a.indexOf(b) === 0
+}
+
+// What Tab makes of the names one directory holds. text is the whole line, names are that
+// directory's entries; the answer is the line as it should now read and how many entries stand
+// behind it, which is what the field uses to decide whether a slash goes on the end.
+//
+// Case-sensitively first, and only case-insensitively when that matched nothing: the filesystem is
+// case sensitive, so "Dev" and "dev" are two directories and a fold must never quietly pick one,
+// but a lone "dev" typed at a directory holding only "Dev" is a typist and not an ambiguity.
+function complete(text, names) {
+    var line = String(text)
+    var parts = split(line)
+    var matched = []
+    var i
+    for (i = 0; i < names.length; i++) {
+        if (startsWith(names[i], parts.leaf, false)) {
+            matched.push(names[i])
+        }
+    }
+    if (matched.length === 0) {
+        for (i = 0; i < names.length; i++) {
+            if (startsWith(names[i], parts.leaf, true)) {
+                matched.push(names[i])
+            }
+        }
+    }
+    if (matched.length === 0) {
+        return { text: line, matches: 0 }
+    }
+    var grown = commonPrefix(matched)
+    // The fold only runs when nothing matched exactly, so the matches can disagree in case inside
+    // the leaf and their common prefix be shorter than it: "re" against README and ReadMe.bak
+    // shares only "R", and returning that would delete a character the user typed.
+    if (grown.length < parts.leaf.length)
+        grown = parts.leaf
+    // One match is a whole name, so the line goes on with the separator already typed: Tab, Tab,
+    // Tab walks a tree. Several share a prefix, which is as far as the line can honestly go.
+    var tail = matched.length === 1 ? grown + "/" : grown
+    return { text: parts.head + tail, matches: matched.length }
+}
+
+// Sample input: shouldNavigate("/etc", "/etc", false) is false, the settled no-op.
+// Whether a committed target lists again. The settled same-path no-op keeps the selection.
+function shouldNavigate(target, current, failed) {
+    // An empty line closes the bar and navigates nowhere, the rule commitEdit already kept.
+    if (String(target).length === 0) {
+        return false
+    }
+    // The same path re-lists only when its listing failed, so an error retries and all else is a no-op.
+    if (String(target) === String(current) && !failed) {
+        return false
+    }
+    return true
+}
+
+// What a typed line that resolved to a path says when the picker's peek of it finds nothing, or a file the listing leaves out.
+var MISSING_SENTENCE = "%1 does not exist or cannot be reached."
+var FILTERED_SENTENCE = "%1 is hidden by the file filter or the hidden files setting."
+
+// Sample input: kindOfPeek(false, 0) and (true, 16877) are "folder", (true, 0) "missing", (true, 33188) "file".
+function kindOfPeek(readFailed, mode) {
+    if (!readFailed || (mode & Format.S_IFMT) === Format.S_IFDIR) return "folder"
+    return mode === 0 ? "missing" : "file"
+}
+
+// A line that named something yet resolved to nothing (a file:// URI on another host) owes a sentence; an empty line owes silence.
+var REFUSED_SENTENCE = "That URI names a file on another host, not a path on this machine."
+
+function refused(text) {
+    var line = String(text).trim()
+    return line.length > 0 && unwrap(line).length === 0
+}
+
+// The sentence Tab answers with when it changed nothing, written for the user and never an action
+// name. An empty string means the line moved and the bar says nothing, which is the usual case.
+function completionMessage(before, after, dir) {
+    if (after.matches === 0) {
+        return Format.fill(WORDS.nothingStartsWith, dir)
+    }
+    if (after.text === before) {
+        return Format.fill(WORDS.manyStart, Format.count(after.matches))
+    }
+    return ""
+}

package/ui/js/Permissions.js

@@ -0,0 +1,179 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// Keeps the one-shot Make executable id clear of the dialog's own batch ids; both QML readers add their pending id to it.
+var MAKE_EXEC_ID = 1000000
+
+// Only the newest id on the asked path lands, so a late answer never arms a later file.
+function landsShebang(path, id, asked, currentId) {
+    return path === asked && id === currentId
+}
+
+// Sample input: "644" or "0644"; invalid text remains in the input until corrected.
+function parse(text) {
+    return /^(0?[0-7]{3})$/.test(String(text)) ? parseInt(text, 8) : -1
+}
+function octal(value) { return ("0000" + value.toString(8)).slice(-4) }
+function toggle(text, bit) {
+    var value = parse(text)
+    return value < 0 ? text : octal(value ^ bit)
+}
+
+// The nine rwx bits of a mode, below the special bits.
+var PERMISSION_BITS = 0x1ff
+
+// Sample input: "4644" answers 420 (0o644), "0755" answers 493, "" answers -1; the nine permission bits of a mode that carries special bits too.
+function shownBits(text) {
+    return /^[0-7]{3,4}$/.test(String(text)) ? parseInt(text, 8) & PERMISSION_BITS : -1
+}
+
+// Sample input: (["0644", "4644"], ["", "Read-only: setuid bit is present."]); one row per permission bit, in grid order.
+// A file the card skips (a mode parse refuses, or a reason) neither sets nor mixes a bit; when every file is skipped the boxes show their own bits and changeable is false.
+function summarize(modes, reasons) {
+    var values = []
+    var shown = []
+    for (var i = 0; i < modes.length; i++) {
+        var value = parse(modes[i])
+        if (value >= 0 && !(reasons && reasons[i]))
+            values.push(value)
+        var bits9 = shownBits(modes[i])
+        if (bits9 >= 0)
+            shown.push(bits9)
+    }
+    var changeable = values.length > 0
+    if (!changeable)
+        values = shown
+    var bits = []
+    var anyMixed = false
+    for (var b = 0; b < 9; b++) {
+        var mask = 1 << (8 - b)
+        var on = true
+        var off = true
+        for (var j = 0; j < values.length; j++) {
+            if (!(values[j] & mask))
+                on = false
+            else
+                off = false
+        }
+        var mixed = !on && !off
+        if (mixed)
+            anyMixed = true
+        bits.push({ mask: mask, on: values.length > 0 && on, mixed: mixed })
+    }
+    return { bits: bits, mixed: anyMixed, changeable: changeable }
+}
+
+function mixedNote() { return "Mixed boxes keep each item's setting unless you change them." }
+
+// A mode with special bits is named in the backend's own words, never dropped on parse -1.
+function specialReason(text) {
+    var digits = String(text || "")
+    if (!/^[1-7][0-7]{3}$/.test(digits))
+        return ""
+    var special = parseInt(digits.charAt(0), 8)
+    var label = (special & 4) !== 0 ? "setuid" : (special & 2) !== 0 ? "setgid" : "sticky"
+    return "Read-only: " + label + " bit is present."
+}
+
+function leafOf(path) {
+    var text = String(path || "")
+    var cut = text.lastIndexOf("/")
+    return cut < 0 ? text : text.substring(cut + 1)
+}
+
+// Modes land in arrival order in place; this answers true once per selection, on the last reply.
+function noteMode(store, at, path, message) {
+    if (message.ok === true) {
+        store.modes[at] = message.mode
+        store.reasons[at] = message.reason || ""
+    } else {
+        // A refused inspect rides the reasons once, in the backend's own words.
+        var why = message.error || "Could not change permissions."
+        store.modes[at] = ""
+        store.reasons[at] = why
+        store.skipped.push({ path: path, why: why })
+    }
+    store.pending -= 1
+    return store.pending <= 0
+}
+
+// One note names every row the grid cannot change, reasoned and refused together.
+function inspectNote(store, paths) {
+    var list = []
+    var reasons = (store && store.reasons) || []
+    for (var i = 0; i < paths.length; i++) {
+        var why = reasons[i] || ""
+        if (why.length > 0) list.push({ path: paths[i], why: why })
+    }
+    return list.length === 0 ? "" : skipNote(list)
+}
+
+// Most names a skip line lists before it counts the rest.
+var SKIP_NAMES_SHOWN = 3
+
+// Sample input: "Read-only: setgid bit is present." answers "setgid"; any other reason answers "".
+function specialLabel(why) {
+    var found = /^Read-only: (setuid|setgid|sticky) bit is present\.$/.exec(String(why))
+    return found ? found[1] : ""
+}
+
+function skipKind(why) {
+    if (specialLabel(why) !== "")
+        return "special"
+    return why === "Read-only: you are not the owner." ? "owner" : "other"
+}
+
+// Sample input: "Gone" answers "Gone."; "Gone." answers "Gone."; a backend reason's own words are never changed, only closed.
+function closed(text) {
+    return /\.$/.test(text) ? text : text + "."
+}
+
+// Whole sentences with "%1" for a value, filled by fill so each translates as one; a cause is a sentence of its own, never joined in.
+var WORDS = {
+    titleMany: "Permissions for %1 items",
+    requestedMode: "Requested mode %1",
+    currentMode: "Current mode %1",
+    keepsSpecial: "%1 keeps its mode because its %2 bit is set.",
+    keepsOwner: "%1 keeps its mode because you do not own it.",
+    keepsOther: "%1 keeps its mode: %2",
+    manySpecial: "%1 items keep their modes because a special bit is set: %2.",
+    manyOwner: "%1 items keep their modes because you do not own them: %2.",
+    manyOther: "%1 items keep their modes because they cannot be changed: %2.",
+    namesAndMore: "%1 and %2 more",
+    keptOne: "%1 kept its mode.",
+    keptMany: "%1 items kept their modes."
+}
+
+// Sample input: one setuid file answers "special.txt keeps its mode because its setuid bit is set."; two answer "2 items keep their modes because a special bit is set: a, b.".
+function skipNote(skipped) {
+    var list = skipped || []
+    if (list.length === 0)
+        return ""
+    var kinds = list.map(function (item) { return skipKind(item.why) })
+    var same = kinds.every(function (kind) { return kind === kinds[0] })
+    if (list.length === 1) {
+        var leaf = leafOf(list[0].path)
+        if (kinds[0] === "special")
+            return Format.fill(WORDS.keepsSpecial, leaf, specialLabel(list[0].why))
+        if (kinds[0] === "owner")
+            return Format.fill(WORDS.keepsOwner, leaf)
+        return closed(Format.fill(WORDS.keepsOther, leaf, list[0].why))
+    }
+    var names = []
+    for (var i = 0; i < list.length && i < SKIP_NAMES_SHOWN; i++)
+        names.push(leafOf(list[i].path))
+    var shown = list.length > SKIP_NAMES_SHOWN ? Format.fill(WORDS.namesAndMore, names.join(", "), list.length - SKIP_NAMES_SHOWN) : names.join(", ")
+    var sentence = same && kinds[0] === "special" ? WORDS.manySpecial
+        : same && kinds[0] === "owner" ? WORDS.manyOwner : WORDS.manyOther
+    return Format.fill(sentence, list.length, shown)
+}
+
+// Sample input: one file answers "special.txt kept its mode."; three answer "3 items kept their modes."; the reason is the card note's, said before Apply.
+// The status bar's room beside the counts and the disk is about 320 px at 800 wide, so the line holds no count of what changed, which the card closing already said.
+function multiResult(skipped) {
+    var list = skipped || []
+    if (list.length === 0)
+        return "Permissions changed."
+    return list.length === 1 ? Format.fill(WORDS.keptOne, leafOf(list[0].path)) : Format.fill(WORDS.keptMany, list.length)
+}

package/ui/js/Phones.js

@@ -0,0 +1,112 @@
+.pragma library
+
+// Sample input, "gio mount -li" under the C locale ui/MountListing.qml pins, captured live on this
+// box with a Samsung phone on USB (2026-09-11), the udisks noise around it cut:
+// Volume(0): SAMSUNG Android
+//   Type: GProxyVolume (GProxyVolumeMonitorMTP)
+//   activation_root=mtp://SAMSUNG_SAMSUNG_Android_RQGL705T0NR/
+//   can_mount=1
+//   Mount(0): SAMSUNG Android -> mtp://SAMSUNG_SAMSUNG_Android_RQGL705T0NR/
+// And with an iPhone on USB (iOS 26.6.2, 2026-09-14), which answers on two monitors at once,
+// then once its root is mounted, at column zero and outside the block that offered it:
+// Volume(0): iPhone
+//   Type: GProxyVolume (GProxyVolumeMonitorGPhoto2)
+//   activation_root=gphoto2://Apple_Inc._iPhone_00008130001641411883401C/
+//   can_mount=1
+// Volume(1): Documents on GM's iPhone
+//   Type: GProxyVolume (GProxyVolumeMonitorAfc)
+//   uuid=00008130-001641411883401C
+//   activation_root=afc://00008130-001641411883401C:3/
+//   can_mount=1
+// Mount(2): GM's iPhone -> afc://00008130-001641411883401C/
+// The root is that column-zero line; the share answers can_mount=0 with its own indented Mount when gvfs automounts it.
+// Only a COLUMN-ZERO Volume() block can be a phone: a udisks volume prints indented under its own
+// Drive() block, and the Type line is required anyway, so only the three gvfs monitors with no block
+// device behind them qualify, MTP for Android, AFC for an iPhone's files and GPhoto2 for cameras.
+// lsblk can never list these, which is why ui/DeviceMounts.qml's enumeration misses a plugged phone.
+// The indented Mount() inside the block is what says an MTP or GPhoto2 volume is live; an AFC root
+// mounts outside the block that offered it, so a column-zero Mount() naming the row's own uri says
+// the same thing. Either way that line is ui/js/Mounts.js parseMounts's to skip as a NETWORK row.
+function parsePhones(output) {
+    var blocks = []
+    var mounted = {}
+    var lines = String(output || "").split("\n")
+    var v = null
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i]
+        var head = line.match(/^Volume\(\d+\):\s*(.+?)\s*$/)
+        if (head) {
+            v = { label: head[1], uri: "", uuid: "", mounted: false, inBlock: false, monitor: "", canMount: false }
+            blocks.push(v)
+            continue
+        }
+        // An AFC root mounts outside the block that offered it, so these are collected first.
+        var top = line.match(/^Mount\(\d+\):\s*.+?\s*->\s*(\S+)\s*$/)
+        if (top) mounted[top[1]] = true
+        // Any other column-zero line ends the block, the next Drive() or Mount() included.
+        if (!/^\s/.test(line)) { v = null; continue }
+        if (!v) continue
+        // Rule 1: the mark names the transport, MTP and AFC the phone and GPhoto2 the camera.
+        var monitor = line.match(/^\s+Type: GProxyVolume \(GProxyVolumeMonitor(MTP|GPhoto2|Afc)\)\s*$/)
+        if (monitor) v.monitor = monitor[1]
+        // The block's own uuid line, not the deeper one under ids: that carries the same digits.
+        var uuid = line.match(/^\s+uuid=(\S+)\s*$/)
+        if (uuid) v.uuid = uuid[1]
+        var root = line.match(/^\s+activation_root=(\S+)\s*$/)
+        if (root) v.uri = root[1]
+        if (/^\s+can_mount=1\s*$/.test(line)) v.canMount = true
+        if (/^\s+Mount\(\d+\):/.test(line)) v.inBlock = true
+    }
+    for (var a = 0; a < blocks.length; a++) {
+        if (blocks[a].monitor !== "Afc")
+            continue
+        // gvfs-afc advertises afc://<uuid>:3/, the documents share; the phone's files are at the root.
+        blocks[a].uri = blocks[a].uuid.length > 0 ? "afc://" + blocks[a].uuid + "/" : ""
+    }
+    var kept = []
+    var serials = []
+    var seen = {}
+    for (var b = 0; b < blocks.length; b++) {
+        var p = blocks[b]
+        // An Afc block's own Mount is that documents share, so only the root's column-zero line counts.
+        p.mounted = p.monitor === "Afc" ? mounted[p.uri] === true : (p.inBlock || mounted[p.uri] === true)
+        // An Afc volume's can_mount is that share's too, so its row stands on the root it names.
+        var live = p.monitor === "Afc" || p.canMount || p.mounted
+        // gvfs answers can_mount=0 for a volume it has already mounted, measured on this box's own USB
+        if (p.monitor.length === 0 || p.uri.length === 0 || !live)
+            continue
+        // Two AFC volumes can carry one uuid, and they rebuild to one root, which is one row.
+        if (seen[p.uri])
+            continue
+        seen[p.uri] = true
+        if (p.monitor === "Afc")
+            serials.push(p.uuid.replace(/-/g, "").toUpperCase())
+        kept.push(p)
+    }
+    // Folded against rows that survived, so a dropped AFC volume cannot take the phone off the rail.
+    var out = []
+    for (var c = 0; c < kept.length; c++) {
+        // One phone, one row: the serial the two monitors share is what says they are one device.
+        if (kept[c].monitor === "GPhoto2" && carriesOneOf(kept[c].uri, serials))
+            continue
+        out.push(entry(kept[c]))
+    }
+    return out
+}
+
+// The serial both monitors spell: AFC hyphenates it in its uuid, GPhoto2 buries it in the host name.
+function carriesOneOf(uri, serials) {
+    var up = String(uri).toUpperCase()
+    for (var i = 0; i < serials.length; i++)
+        if (up.indexOf(serials[i]) >= 0)
+            return true
+    return false
+}
+
+// path is "" until "gio info" resolves the FUSE folder, and size is null because ui/SidebarRow.qml reads a device row's detail off "size !== null".
+function entry(v) {
+    // AFC names its volume for the documents share it advertises, and the row is the phone, not that.
+    var label = v.monitor === "Afc" ? v.label.replace(/^Documents on /, "") : v.label
+    return { path: "", label: label, group: "device", kind: "phone", uri: v.uri, size: null,
+             mounted: v.mounted, glyph: v.monitor === "GPhoto2" ? "camera" : "smartphone" }
+}