yofi 0.2.1

minimalistic menu for wayland
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use std::cmp::Reverse;
use std::ffi::CString;

use anyhow::{Context, Result};

use super::{Entry, EvalInfo};
use crate::usage_cache::Usage;
use crate::DesktopEntry;

const CACHE_PATH: &str = concat!(crate::prog_name!(), ".cache");

pub struct AppsMode {
    entries: Vec<DesktopEntry>,
    term: Vec<CString>,
    usage: Usage,
}

impl AppsMode {
    pub fn new(mut entries: Vec<DesktopEntry>, term: Vec<CString>) -> Self {
        let usage = Usage::from_path(CACHE_PATH);

        entries.sort_by_key(|e| Reverse(usage.entry_count(&e.desktop_fname)));

        Self {
            entries,
            term,
            usage,
        }
    }

    pub fn eval(&mut self, info: EvalInfo<'_>) -> Result<std::convert::Infallible> {
        let idx = info.index.context("no app remain to launch")?;
        let entry = &self.entries[idx];
        let exec = if info.subindex == 0 {
            &entry.entry.exec
        } else {
            &entry.actions[info.subindex - 1].exec
        };

        let args = shlex::split(exec)
            .with_context(|| format!("invalid app command line: {exec}"))?
            .into_iter()
            .filter(|s| !s.starts_with('%')) // TODO: use placeholders somehow
            .map(|s| CString::new(s).expect("invalid argument"));

        self.usage
            .increment_entry_usage(entry.desktop_fname.clone());
        self.usage.try_update_cache(CACHE_PATH);

        let term = if entry.is_terminal {
            Some(std::mem::take(&mut self.term))
        } else {
            None
        };

        crate::exec::exec(term, args, info.input_value)
    }

    pub fn entries_len(&self) -> usize {
        self.entries.len()
    }

    pub fn subentries_len(&self, idx: usize) -> usize {
        self.entries.get(idx).map(|e| e.actions.len()).unwrap_or(0)
    }

    pub fn entry(&self, idx: usize, subidx: usize) -> Entry<'_> {
        let entry = &self.entries[idx];

        Entry {
            name: entry.entry.name.as_ref(),
            subname: Some(entry.subname(subidx).unwrap_or("Default Action")),
            icon: entry.icon(subidx).and_then(|i| i.as_image()),
        }
    }

    pub fn text_entries(&self) -> impl super::ExactSizeIterator<Item = &str> {
        self.entries.iter().map(|e| e.name.as_str())
    }
}