flea-qml 0.0.0-stage → 0.2.0

package/test/trash-address.test.js

@@ -0,0 +1,23 @@
+import {test,expect} from 'bun:test';
+async function load(name,names,deps={}) {
+ const source=(await Bun.file(new URL('../ui/js/'+name+'.js',import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm,'');
+ return new Function(...Object.keys(deps),source+';return {'+names+'};')(...Object.values(deps));
+}
+const PathBar=await load('PathBar','isTrashRoot,addressTarget,editLine,shouldNavigate',{Format:{}});
+const Crumbs=await load('Crumbs','crumbs');
+test('Trash root aliases canonicalize only at the address input boundary',()=>{
+ for(const value of ['trash:/','trash://','trash:///',' TRASH:/// ']) {
+  expect(PathBar.isTrashRoot(value)).toBe(true);
+  expect(PathBar.addressTarget(value,'/home/test','/home/test')).toBe('trash:///');
+ }
+ for(const value of ['trash:','trash:////','trash://host/','trash:///file','/tmp/trash:','trash'])expect(PathBar.isTrashRoot(value)).toBe(false);
+ expect(PathBar.addressTarget('/tmp','trash:///','/home/test')).toBe('/tmp');
+ expect(PathBar.addressTarget('~','trash:///','/home/test')).toBe('/home/test');
+ expect(PathBar.addressTarget('tmp','trash:///','/home/test')).toBe('/tmp');
+});
+test('Trash root remains a single breadcrumb and does not gain a fourth slash',()=>{
+ expect(PathBar.editLine('trash:///')).toBe('trash:///');
+ expect(PathBar.editLine('/tmp')).toBe('/tmp/');
+ expect(Crumbs.crumbs('trash:///','/home/test',null)).toEqual([{text:'trash:///',path:'trash:///',last:true}]);
+ expect(PathBar.shouldNavigate('trash:///','trash:///',false)).toBe(false);
+});

package/test/trash-view.test.js

@@ -0,0 +1,37 @@
+import {test,expect} from 'bun:test';
+async function load(name,names,deps={}) {
+ const source=(await Bun.file(new URL('../ui/js/'+name+'.js',import.meta.url)).text()).replace(/^\.(?:pragma|import).*$/gm,'');
+ return new Function(...Object.keys(deps),source+';return {'+names+'};')(...Object.values(deps));
+}
+test('Back from a trashed directory restores its collection and cursor, not filesystem root',async()=>{
+ const Back=await load('BackReturn','capture,travel');
+ const pane={path:'/',recentMode:'trash',recentFrom:'/home/test',cursorIndex:3,rowFor:()=>({n:'tmp/Trash/files/folder'})};
+ const entry=Back.capture(pane);
+ let opened=0;
+ Object.assign(pane,{path:'/tmp/Trash/files/folder',recentMode:'',history:[entry],forwardHistory:[],
+  trash:{open(){opened++}},join:(base,name)=>base+name,
+  openWithoutHistory(){throw Error('must not navigate to /')}});
+ Back.travel(pane,'history','forwardHistory');
+ expect(opened).toBe(1);expect(pane.recentFrom).toBe('/home/test');expect(pane.pendingSelect).toBe('/tmp/Trash/files/folder');
+ expect(pane.forwardHistory[0].path).toBe('/tmp/Trash/files/folder');
+});
+test('Trash Filter uses the visible original name, not its collision-safe storage name',async()=>{
+ const Match=await load('Match','run,base,rowName');
+ const Filter=await load('Filter','shown',{Match});
+ const rows=[{n:'tmp/Trash/files/report.2',trash:{original:'/docs/report'}},{n:'tmp/Trash/files/elsewhere',trash:{original:'/docs/notes'}}];
+ expect(Filter.shown(rows,10,'report')).toEqual([10]);
+ expect(Filter.shown(rows,10,'report.2')).toEqual([]);
+});
+test('Find in the virtual Trash cannot silently search the previous directory',async()=>{
+ const Search=await load('Search','start');let message='';
+ const pane={recentMode:'trash',path:'/',recentFrom:'/private',message:m=>message=m};
+ Search.start(pane);
+ expect(pane.path).toBe('/');expect(pane.recentMode).toBe('trash');expect(message).toContain('filters');
+});
+
+test('Trash captions share original basenames in list, grid and columns',async()=>{
+ const Match=await load('Match','rowName');
+ expect(Match.rowName({n:'tmp/Trash/files/report.2',trash:{original:'/docs/report'}},false)).toBe('report');
+ expect(Match.rowName({n:'C:/Trash/files/report.2',trash:{original:'C:\\docs\\report',name:'report'}},true)).toBe('report');
+ expect(Match.rowName({n:'sub/file.txt'},false)).toBe('sub/file.txt');
+});

package/test/trashbrowse.test.js

@@ -0,0 +1,135 @@
+import {test, expect, beforeEach, afterEach} from 'bun:test';
+import {mkdtempSync,mkdirSync,writeFileSync,readFileSync,renameSync,symlinkSync,existsSync,rmSync} from 'node:fs';
+import {join,dirname} from 'node:path';
+import {tmpdir} from 'node:os';
+import {trashOne,homeTrash,trashInfoPath,trashInfoOriginal} from '../src/trash.js';
+import {trashbrowse,readTrash,watchTrashCount} from '../src/trashbrowse.js';
+let root,saved,stop;
+const call=(op,fields={})=>{const replies=[];trashbrowse({op,id:1,...fields},m=>replies.push(m));return replies.find(m=>m.t==='trashbrowse');};
+beforeEach(()=>{root=mkdtempSync(join(tmpdir(),'flea-trashbrowse-'));saved=process.env.XDG_DATA_HOME;process.env.XDG_DATA_HOME=join(root,'data');mkdirSync(process.env.XDG_DATA_HOME);call('cancel',{clearSelection:true});});
+afterEach(()=>{stop?.();stop=null;if(saved===undefined)delete process.env.XDG_DATA_HOME;else process.env.XDG_DATA_HOME=saved;rmSync(root,{recursive:true,force:true});});
+function item(name='sample',directory=false){const path=join(root,name);if(directory){mkdirSync(path);writeFileSync(join(path,'keep'),'keep');}else writeFileSync(path,'payload');trashOne(path);return readTrash().find(i=>i.original===path);}
+test('Trash list, restore, collisions and single-use deletion',()=>{
+ const a=item('a');expect(call('list',{count:20}).rows.some(r=>r.uri===a.uri)).toBe(true);
+ writeFileSync(a.original,'new');expect(call('restore',{uris:[a.uri],identities:[a.identity]}).failed).toBe(1);
+ expect(readFileSync(a.original,'utf8')).toBe('new');rmSync(a.original);
+ expect(call('restore',{uris:[a.uri],identities:[a.identity]}).done).toBe(1);expect(readFileSync(a.original,'utf8')).toBe('payload');
+ const b=item('b');const prepared=call('prepare',{uris:[b.uri],identities:[b.identity]});expect(prepared.name).toBe('b');const {token}=prepared;
+ expect(call('check',{token}).valid).toBe(true);expect(call('delete',{token}).done).toBe(1);expect(call('delete',{token}).ok).toBe(false);
+});
+test('cancel and failed replacement reviews invalidate deletion tokens',()=>{
+ const a=item();let {token}=call('prepare',{uris:[a.uri]});call('cancel');expect(call('delete',{token}).ok).toBe(false);
+ ({token}=call('prepare',{uris:[a.uri]}));expect(call('prepare',{uris:['missing']}).ok).toBe(false);
+ expect(call('delete',{token}).ok).toBe(false);expect(existsSync(a.file)).toBe(true);
+});
+test('new descendants invalidate the whole deletion review',()=>{
+ const a=item('folder',true),{token}=call('prepare',{uris:[a.uri]});
+ writeFileSync(join(a.file,'new'),'new');expect(call('check',{token}).valid).toBe(false);
+ expect(call('delete',{token}).stale).toBe(true);expect(existsSync(join(a.file,'keep'))).toBe(true);
+});
+test('bulk selection refuses replaced files and metadata',()=>{
+ const a=item();call('list',{count:20});const {selectionToken}=call('select');
+ renameSync(a.file,a.file+'.old');writeFileSync(a.file,'replacement');
+ expect(call('restore',{selectionToken}).stale).toBe(true);
+ call('list',{count:20});const selected=call('select');writeFileSync(a.info,'[Trash Info]\nPath=/another-place\n');
+ expect(call('prepare',{selectionToken:selected.selectionToken}).stale).toBe(true);
+});
+test('Trash ignores symlink directories and dot metadata names',()=>{
+ const a=item();writeFileSync(join(homeTrash(),'info','...trashinfo'),'[Trash Info]\nPath=/bad\n');
+ expect(readTrash().some(i=>i.name==='..')).toBe(false);
+ const files=join(homeTrash(),'files');renameSync(files,files+'.old');symlinkSync(files+'.old',files);
+ expect(readTrash().some(i=>i.uri===a.uri)).toBe(false);
+});
+test('metadata round trips punctuation and rejects escaping relative paths',()=>{
+ const path=join(root,'a:b #中文 % x');expect(trashInfoOriginal(trashInfoPath(path), '')).toBe(path);
+ expect(trashInfoOriginal(trashInfoPath(path,root),root)).toBe(path);
+ for(const bad of ['../outside','%2e%2e/outside','%2foutside','bad%00name','%ZZ',''])expect(trashInfoOriginal(bad,root)).toBe('');
+});
+test('count watcher reports same-count replacements and disposes',async()=>{
+ const a=item();let reports=0;stop=watchTrashCount(()=>reports++);expect(reports).toBe(1);
+ renameSync(a.file,a.file+'.old');writeFileSync(a.file,'replacement');
+ const deadline=Date.now()+3000;while(reports<2 && Date.now()<deadline)await Bun.sleep(20);
+ expect(reports).toBeGreaterThan(1);stop();stop=null;
+});
+test('backend routes Trash requests and exits cleanly',()=>{
+ const result=Bun.spawnSync([process.execPath,new URL('../src/flea.js',import.meta.url).pathname,'--backend'],{
+  env:{...process.env},stdin:Buffer.from('{"c":"trashbrowse","op":"list","id":27,"count":10}\n{"c":"quit"}\n'),stdout:'pipe',stderr:'pipe'});
+ expect(result.exitCode).toBe(0);
+ const messages=result.stdout.toString().trim().split('\n').map(line=>JSON.parse(line));
+ expect(messages.some(m=>m.t==='trashcount' && typeof m.revision==='number')).toBe(true);
+ expect(messages.some(m=>m.t==='trashbrowse' && m.id===27 && m.ok===true)).toBe(true);
+});
+
+test('Trash collection uses ordinary rows, real paths and metadata; stale row actions are refused',()=>{
+ const a=item('preview 中文.txt');
+ const input=[{c:'listtrash',first:10000},{c:'trashbrowse',op:'restore',id:31,rows:[0],listing:-1},{c:'quit'}].map(x=>JSON.stringify(x)).join('\n')+'\n';
+ const result=Bun.spawnSync([process.execPath,new URL('../src/flea.js',import.meta.url).pathname,'--backend'],{env:{...process.env},stdin:Buffer.from(input),stdout:'pipe',stderr:'pipe'});
+ expect(result.exitCode).toBe(0);expect(result.stderr.toString()).toBe('');
+ const messages=result.stdout.toString().trim().split('\n').map(JSON.parse);
+ const rows=messages.find(x=>x.t==='rows');const row=rows.rows.find(x=>x.trash?.original===a.original);
+ expect(join('/',row.n)).toBe(a.file);expect(row.s).toBe(7);expect(row.d).toBe(false);
+ expect(messages.find(x=>x.id===31).stale).toBe(true);expect(existsSync(a.file)).toBe(true);
+});
+
+test('renaming a Trash entry preserves restore metadata and refuses destination collisions',async()=>{
+ const {renameWithTrashRecord}=await import('../src/trash-record.js');
+ const a=item('original.txt'),dst=join(dirname(a.file),'renamed.txt');
+ renameWithTrashRecord(a.file,dst);
+ expect(existsSync(a.file)).toBe(false);expect(existsSync(a.info)).toBe(false);
+ const moved=readTrash().find(x=>x.file===dst);expect(moved.original).toBe(join(root,'renamed.txt'));
+ writeFileSync(join(dirname(dst),'occupied'),'keep');
+ expect(()=>renameWithTrashRecord(dst,join(dirname(dst),'occupied'))).toThrow('already exists');
+ expect(readFileSync(dst,'utf8')).toBe('payload');
+ expect(call('restore',{uris:[moved.uri],identities:[moved.identity]}).done).toBe(1);
+ expect(readFileSync(join(root,'renamed.txt'),'utf8')).toBe('payload');
+});
+
+test('moving out cleans only the captured Trash record; copy keeps its source metadata',async()=>{
+ const {transfer}=await import('../src/transfer.js');
+ const a=item('move-me.txt');const dest=join(root,'destination');mkdirSync(dest);
+ const run=moving=>new Promise(resolve=>transfer({id:40,paths:[a.file],dest,op:moving?'move':'copy'},m=>{if(m.t==='transferdone')resolve(m)},null,0));
+ const copied=await run(false);expect(copied.ok).toBe(1);expect(existsSync(a.info)).toBe(true);
+ rmSync(join(dest,'move-me.txt'));
+ const moved=await run(true);expect(moved.ok).toBe(1);expect(existsSync(a.info)).toBe(false);
+ expect(readFileSync(join(dest,'move-me.txt'),'utf8')).toBe('payload');
+});
+
+test('Trash rename preserves literal replacement tokens in file names',async()=>{
+ const {renameWithTrashRecord}=await import('../src/trash-record.js');
+ for (const name of ['$&.txt', '$$.txt', "$'.txt", '$`.txt']) {
+  const a=item('old-'+name),dst=join(dirname(a.file),name);
+  renameWithTrashRecord(a.file,dst);
+  const moved=readTrash().find(x=>x.file===dst);
+  expect(moved.original).toBe(join(root,name));
+  expect(call('restore',{uris:[moved.uri],identities:[moved.identity]}).done).toBe(1);
+  expect(readFileSync(join(root,name),'utf8')).toBe('payload');
+ }
+});
+
+test('Trash menu restores its captured item after sort, not the replacement cursor',()=>{
+ const a=item('menu-a.txt'),b=item('menu-b.txt');
+ const commands=[{c:'listtrash',first:10000},
+  {c:'menuaction',op:'snapshot',id:93,paths:[a.file],cursorPath:a.file},
+  {c:'sort',by:'name',desc:true},
+  {c:'trashbrowse',op:'restore',id:94,menuId:93,rows:[0],listing:-1},
+  {c:'trashbrowse',op:'restore',id:95,menuId:999,rows:[0]},
+  {c:'quit'}];
+ const result=Bun.spawnSync([process.execPath,new URL('../src/flea.js',import.meta.url).pathname,'--backend'],{
+  env:{...process.env},stdin:Buffer.from(commands.map(JSON.stringify).join('\n')+'\n'),stdout:'pipe',stderr:'pipe'});
+ expect(result.exitCode).toBe(0);
+ const messages=result.stdout.toString().trim().split('\n').map(JSON.parse);
+ expect(messages.find(x=>x.id===94).done).toBe(1);
+ expect(messages.find(x=>x.id===95).stale).toBe(true);
+ expect(existsSync(a.original)).toBe(true);expect(existsSync(b.file)).toBe(true);
+});
+
+test('Trash collision suffixes do not change visible names or media classification',async()=>{
+ const {Listing}=await import('../src/listing.js');
+ for(const name of ['image.png','music.mp3','video.mp4','source.js','Dockerfile']) {
+  item(name);item(name);const a=readTrash().find(x=>x.original===join(root,name) && x.file.endsWith('.2'));
+  expect(a.file.endsWith('.2')).toBe(true);
+  const row=new Listing('/',[{name:a.file.slice(1),dir:false,trash:a}]).window(0,1).rows[0];
+  const original=new Listing(root,[{name,dir:false}]).window(0,1).rows[0];
+  expect(row.i).toBe(original.i);expect(row.trash.name).toBe(name);
+ }
+});

package/ui/AboutFacts.qml

@@ -0,0 +1,78 @@
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import "js/SettingsAbout.js" as About
+
+// Installed facts are read only when About is shown; each failed query keeps an explicit unknown.
+QtObject {
+    id: root
+    property bool active: false
+    property bool loaded: false
+    property var known: ({})
+    // What ui/js/SettingsAbout.js reads: the installed facts, with the updater's status and the default's claim beside them.
+    readonly property var facts: Object.assign({ update: UpdateCheck.status, handler: DefaultClaim.handler, claim: DefaultClaim.claim }, root.known)
+    readonly property string binary: Quickshell.env("FLEA_BIN") || "flea"
+
+    function setFact(key, value) {
+        var next = Object.assign({}, root.known)
+        next[key] = value
+        root.known = next
+    }
+
+    onActiveChanged: {
+        // About opening is one of the updater's two automatic triggers; ui/js/Update.js decides whether the last answer stands.
+        if (root.active) UpdateCheck.checkIfDue()
+        if (!root.active || root.loaded) return
+        root.loaded = true
+        version.running = true
+        owner.running = true
+        DefaultClaim.read()
+    }
+
+    property var versionQuery: Process {
+        id: version
+        command: [root.binary, "--version"]
+        property string answer: ""
+        stdout: StdioCollector { onStreamFinished: version.answer = this.text.trim() }
+        // Sample output: "0.2.0". src/main.rs prints CARGO_PKG_VERSION and nothing else, so the
+        // name is tolerated rather than required: demanding it left the Version row reading
+        // "Not reported" on every build Flea has ever shipped.
+        onExited: function (code) {
+            if (code !== 0) return
+            var text = version.answer.indexOf("flea ") === 0 ? version.answer.substring(5) : version.answer
+            if (text.length > 0) root.setFact("version", text)
+        }
+    }
+    property var ownerQuery: Process {
+        id: owner
+        command: ["pacman", "-Qqo", root.binary]
+        property string answer: ""
+        stdout: StdioCollector { onStreamFinished: owner.answer = this.text.trim() }
+        // Sample output: flea
+        onExited: function (code) {
+            if (code !== 0 || owner.answer.length === 0) {
+                root.setFact("source", About.installedFrom("", false))
+                root.setFact("package", "Not owned by a package")
+                return
+            }
+            packageVersion.command = ["pacman", "-Qi", owner.answer]
+            packageVersion.running = true
+        }
+    }
+    // -Qi rather than -Q: the same query carries the build date, and the Built row had nothing
+    // setting it at all, so every box read "Not recorded in this build" whatever it was running.
+    // Its Validated By line is the signature src/update.rs tells OPR's flea from a local build by.
+    property var packageQuery: Process {
+        id: packageVersion
+        environment: ({ LC_ALL: "C" })
+        property string answer: ""
+        stdout: StdioCollector { onStreamFinished: packageVersion.answer = this.text }
+        onExited: function (code) {
+            // A package pacman cannot describe reads as unsigned, the way src/update.rs reads it.
+            var facts = About.packageFacts(code === 0 ? packageVersion.answer : "")
+            root.setFact("source", About.installedFrom(owner.answer, facts.signed))
+            if (facts.package.length > 0) root.setFact("package", facts.package)
+            if (facts.built.length > 0) root.setFact("built", facts.built)
+        }
+    }
+}

package/ui/ArchiveCards.qml

@@ -0,0 +1,95 @@
+import QtQuick
+import "js/ArchiveCard.js" as ArchiveCard
+import "js/ArchiveOps.js" as ArchiveOps
+
+// The two password cards, built on their first open and kept like every overlay, so a launch that never opens one pays nothing.
+Item {
+    id: root
+
+    property var compressOwner: null
+    property var extractOwner: null
+    readonly property var compressItem: compressDialog.item
+    readonly property var extractItem: extractDialog.item
+
+    function askCompressPassword(pane, paths, menuId) {
+        if (paths) ArchiveOps.compressPasswordResolved(root, pane, paths, menuId)
+        else ArchiveOps.openCompressPassword(pane, menuId, root)
+    }
+
+    // One card at a time: a second request is answered with a sentence and never dropped silently.
+    function cardBusy(holder) {
+        if (!compressDialog.opened && !extractDialog.opened && !hereDialog.opened)
+            return false
+        holder.message(ArchiveCard.CARD_BUSY, true)
+        return true
+    }
+
+    function openCompressDialog(source, parentLeaf, holder) {
+        if (cardBusy(holder)) return
+        compressOwner = holder
+        compressDialog.active = true
+        compressDialog.item.open(source, parentLeaf, holder)
+    }
+
+    function openExtractPassword(source, holder, err) {
+        if (cardBusy(holder)) return
+        extractOwner = holder
+        extractDialog.active = true
+        extractDialog.item.open(source, holder, err)
+    }
+
+    function askExtractHere(holder, path, entries) {
+        if (cardBusy(holder)) return
+        var dest = path.substring(0, path.lastIndexOf("/") + 1)
+        if (entries >= 0 && entries <= 5) {
+            holder.backend.extractHere(path, dest, false)
+            return
+        }
+        hereDialog.active = true
+        hereDialog.item.open({ path: path, dest: dest, entries: entries, holder: holder, focusItem: holder.preview && holder.preview.active ? holder.preview : holder })
+    }
+
+    Loader {
+        id: hereDialog
+        anchors.fill: parent
+        active: false
+        source: "ArchiveHereConfirm.qml"
+        readonly property bool opened: item !== null && item.opened
+    }
+    Connections {
+        target: hereDialog.item
+        function onConfirmed(source) {
+            source.holder.backend.extractHere(source.path, source.dest, true)
+            source.focusItem.forceActiveFocus()
+        }
+        function onCancelled() { if (hereDialog.item.snapshot.focusItem) hereDialog.item.snapshot.focusItem.forceActiveFocus() }
+    }
+
+    anchors.fill: parent
+
+    Loader {
+        id: compressDialog
+        anchors.fill: parent
+        active: false
+        source: "ArchiveCompressDialog.qml"
+        readonly property bool opened: item !== null && item.opened
+    }
+    Connections {
+        target: compressDialog.item
+        function onAccepted(source, format, name, password, encryptNames) {
+            ArchiveOps.submitCompressPassword(root.compressOwner, source, format, name, password, encryptNames)
+        }
+    }
+
+    Loader {
+        id: extractDialog
+        anchors.fill: parent
+        active: false
+        source: "ArchivePasswordDialog.qml"
+        readonly property bool opened: item !== null && item.opened
+    }
+    Connections {
+        target: extractDialog.item
+        function onAccepted(source, password) { ArchiveOps.submitExtractPassword(root.extractOwner, source, password) }
+    }
+}