revue 2.71.1

A Vue-style TUI framework for Rust with CSS styling
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

//! Helper functions for lazy loading

use super::{LazyData, LazyReloadable, LazySync, PagedData, ProgressiveLoader};

/// Create a lazy data loader
pub fn lazy<T, F>(loader: F) -> LazyData<T, F>
where
    F: FnOnce() -> T,
{
    LazyData::new(loader)
}

/// Create a reloadable lazy loader
pub fn lazy_reloadable<T, F>(loader: F) -> LazyReloadable<T, F>
where
    F: Fn() -> T,
{
    LazyReloadable::new(loader)
}

/// Create a thread-safe lazy loader
pub fn lazy_sync<T, F>(loader: F) -> LazySync<T, F>
where
    F: FnOnce() -> T + Send,
    T: Send + Sync,
{
    LazySync::new(loader)
}

/// Create a paged data source
pub fn paged<T, F>(total: usize, page_size: usize, loader: F) -> PagedData<T, F>
where
    F: Fn(usize, usize) -> Vec<T>,
{
    PagedData::new(total, page_size, loader)
}

/// Create a progressive loader
pub fn progressive<T: Clone>(items: Vec<T>, chunk_size: usize) -> ProgressiveLoader<T> {
    ProgressiveLoader::new(items, chunk_size)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_lazy_function() {
        let lazy_data = lazy(|| 42);
        // Just verify it creates a LazyData (can't inspect private fields)
        let _ = lazy_data;
    }

    #[test]
    fn test_lazy_reloadable_function() {
        let lazy_data = lazy_reloadable(|| vec![1, 2, 3]);
        // Just verify it creates a LazyReloadable (can't inspect private fields)
        let _ = lazy_data;
    }

    #[test]
    fn test_lazy_sync_function() {
        let lazy_data = lazy_sync(|| vec![1, 2, 3]);
        // Just verify it creates a LazySync (can't inspect private fields)
        let _ = lazy_data;
    }

    #[test]
    fn test_paged_function() {
        let paged = paged(100, 10, |start, count| (start..start + count).collect());
        // Just verify it creates a PagedData (can't inspect private fields)
        let _ = paged;
    }

    #[test]
    fn test_progressive_function() {
        let items = vec![1, 2, 3, 4, 5];
        let progressive = progressive(items, 2);
        // Just verify it creates a ProgressiveLoader (can't inspect private fields)
        let _ = progressive;
    }

    #[test]
    fn test_lazy_with_closure() {
        let lazy_data = lazy(|| vec![1, 2, 3]);
        let _ = lazy_data;
    }

    #[test]
    fn test_lazy_reloadable_with_closure() {
        let counter = std::cell::RefCell::new(0);
        let lazy_data = lazy_reloadable(|| {
            let mut count = counter.borrow_mut();
            *count += 1;
            *count
        });
        let _ = lazy_data;
    }

    #[test]
    fn test_paged_with_loader() {
        let paged = paged(50, 10, |offset, limit| vec![(offset, limit)]);
        let _ = paged;
    }

    #[test]
    fn test_progressive_with_items() {
        let items = vec!["a", "b", "c", "d", "e"];
        let progressive = progressive(items.clone(), 2);
        let _ = progressive;
    }

    #[test]
    fn test_progressive_empty_items() {
        let items: Vec<i32> = vec![];
        let progressive = progressive(items, 10);
        let _ = progressive;
    }
}