tears 0.9.3

A simple and elegant framework for building TUI applications using The Elm Architecture (TEA)
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

//! Test-only helpers shared across crate-internal unit tests.
//!
//! Keep helpers here when they depend on crate-private APIs or concrete
//! `tears` fixtures such as [`TestApp`]. Small dependency-free helpers may
//! intentionally be duplicated in integration-test `common` modules; that is
//! clearer than a workspace-only helper crate until reuse grows.

use std::sync::Mutex;

use ratatui::Frame;

use crate::application::Application;
use crate::command::{Action, Command};
use crate::subscription::Subscription;

pub use async_utils::{assert_pending_until, gate_fetches, wait_until};
pub use trace_recorder::TraceRecorder;

mod async_utils;
mod trace_recorder;

/// Serializes tests that install a process-global panic hook or deliberately
/// trigger panics.
///
/// The panic hook is process-global and shared across threads, so a test that
/// records hook activity and a test that panics must not run concurrently, or
/// the panicking test's hook invocation would pollute the recording one.
pub static PANIC_HOOK_GUARD: Mutex<()> = Mutex::new(());

/// A minimal counter [`Application`] shared by the runtime and runtime-core
/// tests. Increments on [`TestMessage::Increment`] and quits on
/// [`TestMessage::Quit`].
#[derive(Debug)]
pub struct TestApp {
    pub counter: i32,
    should_quit: bool,
}

#[derive(Debug, Clone)]
#[allow(dead_code)]
pub enum TestMessage {
    Increment,
    Quit,
}

impl Application for TestApp {
    type Message = TestMessage;
    type Flags = i32;

    fn new(initial: i32) -> (Self, Command<Self::Message>) {
        (
            Self {
                counter: initial,
                should_quit: false,
            },
            Command::none(),
        )
    }

    fn update(&mut self, msg: Self::Message) -> Command<Self::Message> {
        match msg {
            TestMessage::Increment => {
                self.counter += 1;
                Command::none()
            }
            TestMessage::Quit => {
                self.should_quit = true;
                Command::effect(Action::Quit)
            }
        }
    }

    fn view(&self, _frame: &mut Frame<'_>) {
        // No-op for testing
    }

    fn subscriptions(&self) -> Vec<Subscription<Self::Message>> {
        vec![]
    }
}