rust-switcher 1.0.11

Windows keyboard layout switcher and text conversion utility
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use std::sync::{Mutex, MutexGuard, OnceLock};

use crate::input::ring_buffer::{self, InputRun, LayoutTag, RunKind, RunOrigin};

fn test_lock() -> MutexGuard<'static, ()> {
    static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
    LOCK.get_or_init(|| Mutex::new(()))
        .lock()
        .unwrap_or_else(|e| e.into_inner())
}

#[test]
fn run_journal_merges_contiguous_same_metadata() {
    let _guard = test_lock();
    ring_buffer::invalidate();
    ring_buffer::push_run(InputRun {
        text: "ab".to_string(),
        layout: LayoutTag::En,
        origin: RunOrigin::Physical,
        kind: RunKind::Text,
    });
    ring_buffer::push_run(InputRun {
        text: "cd".to_string(),
        layout: LayoutTag::En,
        origin: RunOrigin::Physical,
        kind: RunKind::Text,
    });

    let runs = ring_buffer::runs_snapshot();
    assert_eq!(runs.len(), 1);
    assert_eq!(runs[0].text, "abcd");
}

#[test]
fn run_journal_splits_on_layout_change() {
    let _guard = test_lock();
    ring_buffer::invalidate();
    ring_buffer::push_run(InputRun {
        text: "ABC".to_string(),
        layout: LayoutTag::En,
        origin: RunOrigin::Physical,
        kind: RunKind::Text,
    });
    ring_buffer::push_run(InputRun {
        text: ",".to_string(),
        layout: LayoutTag::Ru,
        origin: RunOrigin::Physical,
        kind: RunKind::Text,
    });

    let runs = ring_buffer::runs_snapshot();
    assert_eq!(runs.len(), 2);
    assert_eq!(runs[0].layout, LayoutTag::En);
    assert_eq!(runs[1].layout, LayoutTag::Ru);
}

#[test]
fn take_last_layout_run_with_suffix_basic() {
    let _guard = test_lock();
    ring_buffer::invalidate();
    ring_buffer::push_run(InputRun {
        text: "hello".to_string(),
        layout: LayoutTag::En,
        origin: RunOrigin::Physical,
        kind: RunKind::Text,
    });
    ring_buffer::push_run(InputRun {
        text: "   ".to_string(),
        layout: LayoutTag::En,
        origin: RunOrigin::Physical,
        kind: RunKind::Whitespace,
    });

    let (run, suffix) = ring_buffer::take_last_layout_run_with_suffix().expect("payload");
    assert_eq!(run.text, "hello");
    assert_eq!(suffix.len(), 1);
    assert_eq!(suffix[0].text, "   ");
}

#[test]
fn take_last_layout_run_with_suffix_returns_none_for_whitespace_only() {
    let _guard = test_lock();
    ring_buffer::invalidate();
    ring_buffer::push_text("  \t\n");
    assert!(ring_buffer::take_last_layout_run_with_suffix().is_none());
}

#[test]
fn legacy_push_text_segments_internally() {
    let _guard = test_lock();
    ring_buffer::invalidate();
    ring_buffer::push_text("hello world   ");

    let (run, suffix) = ring_buffer::take_last_layout_run_with_suffix().expect("payload");
    assert_eq!(run.text, "world");
    assert_eq!(
        suffix.iter().map(|r| r.text.as_str()).collect::<String>(),
        "   "
    );
}

#[test]
fn last_char_triggers_autoconvert_still_works_across_runs() {
    let _guard = test_lock();
    ring_buffer::invalidate();
    ring_buffer::push_run(InputRun {
        text: "abc".to_string(),
        layout: LayoutTag::En,
        origin: RunOrigin::Physical,
        kind: RunKind::Text,
    });
    ring_buffer::push_run(InputRun {
        text: ".".to_string(),
        layout: LayoutTag::En,
        origin: RunOrigin::Physical,
        kind: RunKind::Text,
    });
    assert!(ring_buffer::last_char_triggers_autoconvert());

    ring_buffer::push_run(InputRun {
        text: " ".to_string(),
        layout: LayoutTag::En,
        origin: RunOrigin::Physical,
        kind: RunKind::Whitespace,
    });
    assert!(ring_buffer::last_char_triggers_autoconvert());
}

#[test]
fn backspace_removes_from_last_run_and_drops_empty_run() {
    let _guard = test_lock();
    ring_buffer::invalidate();
    ring_buffer::push_text("a");
    ring_buffer::test_backspace();
    assert!(ring_buffer::take_last_layout_run_with_suffix().is_none());
}

#[test]
fn foreground_invalidation_state_reset_via_invalidate() {
    let _guard = test_lock();
    ring_buffer::invalidate();
    ring_buffer::push_text("abc");
    ring_buffer::mark_last_token_autoconverted();
    assert!(ring_buffer::last_token_autoconverted());

    ring_buffer::invalidate();
    assert!(!ring_buffer::last_token_autoconverted());
    assert!(ring_buffer::take_last_layout_run_with_suffix().is_none());
}