cranpose-ui 0.1.164

UI primitives for Cranpose
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::cell::RefCell;

use super::*;

struct RecordingClipboard {
    value: RefCell<Option<String>>,
}

struct UnavailableClipboard;

struct AsyncOnlyClipboard {
    requests: Cell<usize>,
}

impl PlatformClipboard for RecordingClipboard {
    fn write_text(&self, text: &str) {
        *self.value.borrow_mut() = Some(text.to_string());
    }
    fn read_text(&self) -> Option<String> {
        self.value.borrow().clone()
    }
}

impl PlatformClipboard for UnavailableClipboard {
    fn write_text(&self, _text: &str) {}

    fn read_text(&self) -> Option<String> {
        None
    }
}

impl PlatformClipboard for AsyncOnlyClipboard {
    fn write_text(&self, _text: &str) {}

    fn read_text(&self) -> Option<String> {
        None
    }

    fn can_request_paste(&self) -> bool {
        true
    }

    fn request_paste(&self) -> bool {
        self.requests.set(self.requests.get() + 1);
        true
    }
}

#[test]
fn manager_uses_in_process_fallback_without_a_platform_clipboard() {
    let context = crate::render_state::AppContext::new();
    context.enter(|| {
        let clipboard = ClipboardManager;
        assert!(!clipboard.has_system_clipboard());
        clipboard.set_text("hello");
        assert_eq!(clipboard.text().as_deref(), Some("hello"));
    });
}

#[test]
fn manager_routes_through_the_installed_platform_clipboard() {
    let context = crate::render_state::AppContext::new();
    context.enter(|| {
        let recorder = Rc::new(RecordingClipboard {
            value: RefCell::new(None),
        });
        set_platform_clipboard(recorder.clone());

        let clipboard = ClipboardManager;
        assert!(clipboard.has_system_clipboard());
        clipboard.set_text("world");
        assert_eq!(recorder.value.borrow().as_deref(), Some("world"));
        assert_eq!(clipboard.text().as_deref(), Some("world"));

        clear_platform_clipboard();
        assert!(!clipboard.has_system_clipboard());
    });
}

#[test]
fn a_paste_goes_to_the_platform_when_it_cannot_be_read_on_the_spot() {
    let context = crate::render_state::AppContext::new();
    context.enter(|| {
        let clipboard = Rc::new(AsyncOnlyClipboard {
            requests: Cell::new(0),
        });
        set_platform_clipboard(clipboard.clone());

        assert!(clipboard_can_paste());
        clipboard_paste_into_focus();
        assert_eq!(clipboard.requests.get(), 1);
    });
}

#[test]
fn a_readable_clipboard_pastes_without_asking_the_platform() {
    let context = crate::render_state::AppContext::new();
    context.enter(|| {
        assert!(!clipboard_can_paste());
        clipboard_write_text("pasted");
        assert!(clipboard_can_paste());
        clipboard_paste_into_focus();
    });
}

#[test]
fn manager_falls_back_when_the_installed_platform_is_unavailable() {
    let context = crate::render_state::AppContext::new();
    context.enter(|| {
        set_platform_clipboard(Rc::new(UnavailableClipboard));

        let clipboard = ClipboardManager;
        clipboard.set_text("headless copy");
        assert_eq!(clipboard.text().as_deref(), Some("headless copy"));
    });
}