finery 0.20.0

Keyboard-first Jira backlog and Composer with optional MCP access
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

use std::sync::mpsc::{self, Receiver, TryRecvError};

use super::AppService;

#[cfg(test)]
#[path = "tests/background_clipboard.rs"]
mod tests;

#[derive(Default)]
pub(super) struct BackgroundClipboard {
    pending: Option<Receiver<Result<String, String>>>,
}

impl AppService {
    pub(crate) fn copy_in_background(
        &self,
        load: impl FnOnce() -> Result<String, String> + Send + 'static,
    ) {
        let mut clipboard = self
            .background_clipboard
            .lock()
            .expect("clipboard lock poisoned");
        // A request owns its receiver, so a newer copy discards late results from older copies.
        clipboard.pending = None;
        let (sender, receiver) = mpsc::channel();
        match std::thread::Builder::new()
            .name("finery-report-copy".into())
            .spawn(move || {
                let _ = sender.send(load());
            }) {
            Ok(_) => clipboard.pending = Some(receiver),
            Err(error) => self.report_error(format!("Could not copy sprint report: {error}")),
        }
    }

    pub(crate) fn clipboard_pending(&self) -> bool {
        self.background_clipboard
            .lock()
            .expect("clipboard lock poisoned")
            .pending
            .is_some()
    }

    pub(crate) fn cancel_pending_clipboard(&self) {
        self.background_clipboard
            .lock()
            .expect("clipboard lock poisoned")
            .pending = None;
    }

    pub(crate) fn take_pending_clipboard(&self) -> Option<String> {
        let mut clipboard = self
            .background_clipboard
            .lock()
            .expect("clipboard lock poisoned");
        let receiver = clipboard.pending.as_ref()?;
        let result = match receiver.try_recv() {
            Ok(result) => result,
            Err(TryRecvError::Empty) => return None,
            Err(TryRecvError::Disconnected) => Err("Report copy worker disconnected".into()),
        };
        clipboard.pending = None;
        match result {
            Ok(text) => Some(text),
            Err(error) => {
                self.report_error(format!("Could not copy sprint report: {error}"));
                None
            }
        }
    }
}