makeup 0.0.8

Stylish CLIs/TUIs for Rust!
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

pub mod diff;

#[doc(hidden)]
#[macro_export]
macro_rules! __THIS_IS_NOT_PUBLIC_DO_NOT_CALL_static_text {
    ($text:expr) => {
        $crate::DrawCommand::TextUnderCursor($text.into())
    };
}

#[doc(inline)]
pub use __THIS_IS_NOT_PUBLIC_DO_NOT_CALL_static_text as static_text;

#[doc(hidden)]
#[macro_export]
macro_rules! __THIS_IS_NOT_PUBLIC_DO_NOT_CALL_assert_renders_many {
    // (expected, component)
    // create a fake context and apply it to the component
    ($expected:expr, $component:expr) => {{
        let mut ctx = $crate::test::fake_render_ctx();
        let ui = $crate::test::make_test_ui!(&mut $component);
        let actual = ui
            .render_commands(&mut ctx)
            .await?
            .iter()
            .flat_map(|(_key, cmds)| cmds.clone())
            .collect();

        let diff = $crate::test::diff::DrawCommandDiff::new($expected, actual);
        let diff: $crate::test::diff::VisualDiff = diff.into_visual_diff().await?;
        if diff.is_different() {
            diff.render().await?;
            panic!();
        }
    }};
}

/// Given a set of draw commands, assert that they render the same thing. This
/// will display a visual diff if they do not render the same thing.
#[doc(inline)]
pub use __THIS_IS_NOT_PUBLIC_DO_NOT_CALL_assert_renders_many as assert_renders_many;

#[doc(hidden)]
#[macro_export]
macro_rules! __THIS_IS_NOT_PUBLIC_DO_NOT_CALL_assert_renders_one {
    // (expected, component)
    // create a fake context and apply it to the component
    ($expected:expr, $component:expr) => {{
        $crate::test::assert_renders_many!(vec![$expected], $component);
    }};
}

#[doc(inline)]
pub use __THIS_IS_NOT_PUBLIC_DO_NOT_CALL_assert_renders_one as assert_renders_one;

/// Create a test UI with a fake renderer and input.
///
/// Usage:
///
/// ```ignore
/// let ui = make_test_ui!(root_component);
/// let ui = make_test_ui!(root_component, 128); // both dimensions
/// let ui = make_test_ui!(root_component, 256, 64); // width, height
/// ```
#[doc(hidden)]
#[macro_export]
macro_rules! __THIS_IS_NOT_PUBLIC_DO_NOT_CALL_make_test_ui {
    ($root:expr) => {{
        use $crate::input::TerminalInput;
        use $crate::render::MemoryRenderer;
        use $crate::MUI;

        let renderer = MemoryRenderer::new(128, 128);
        let input = TerminalInput::new().await?;
        let ui = MUI::new($root, Box::new(renderer), input)?;
        ui
    }};

    ($root:expr, $size:expr) => {{
        use $crate::input::TerminalInput;
        use $crate::render::MemoryRenderer;
        use $crate::MUI;

        let renderer = MemoryRenderer::new($size, $size);
        let input = TerminalInput::new().await?;
        let ui = MUI::new($root, Box::new(renderer), input)?;
        ui
    }};

    ($root:expr, $w:expr, $h:expr) => {{
        use $crate::input::TerminalInput;
        use $crate::render::MemoryRenderer;
        use $crate::MUI;

        let renderer = MemoryRenderer::new($w, $h);
        let input = TerminalInput::new().await?;
        let ui = MUI::new($root, Box::new(renderer), input)?;
        ui
    }};
}

#[doc(inline)]
pub use __THIS_IS_NOT_PUBLIC_DO_NOT_CALL_make_test_ui as make_test_ui;

#[doc(hidden)]
pub fn fake_render_ctx() -> crate::component::RenderContext {
    crate::component::RenderContext {
        last_frame_time: None,
        frame_counter: 0,
        fps: 0f64,
        effective_fps: 0f64,
        cursor: (0, 0),
        dimensions: (0, 0),
        focus: 0,
    }
}