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

use async_trait::async_trait;
use eyre::Result;
use thiserror::Error;

use crate::component::DrawCommandBatch;
use crate::util::AsAny;
use crate::{Coordinate, Coordinates, Dimension, Dimensions, RelativeCoordinate};

pub mod memory;
pub mod terminal;

pub use memory::MemoryRenderer;
pub use terminal::TerminalRenderer;

/// A `Renderer` takes in a slice of [`DrawCommandBatch`]es and renders them
/// somehow. No constraints are placed on rendering, ie a renderer can use any
/// backend it sees fit. Built-in renderers include [`MemoryRenderer`] and
/// [`TerminalRenderer`].
///
/// Renderers that might be useful to implement on your own are things like:
/// - A renderer that can render to a canvas backend, for trivial WASM parity
#[async_trait]
pub trait Renderer: std::fmt::Debug + AsAny + Send + Sync {
    async fn render(&mut self, commands: &[DrawCommandBatch]) -> Result<()>;

    async fn flush(&mut self) -> Result<()>;

    async fn move_cursor(&mut self, x: Coordinate, y: Coordinate) -> Result<()>;

    async fn move_cursor_relative(
        &mut self,
        x: RelativeCoordinate,
        y: RelativeCoordinate,
    ) -> Result<()>;

    async fn read_at_cursor(&self, width: Dimension) -> Result<String>;

    async fn read_string(&self, x: Coordinate, y: Coordinate, width: Dimension) -> Result<String>;

    fn cursor(&self) -> Coordinates;

    fn dimensions(&self) -> Dimensions;

    fn set_width(&mut self, w: Dimension);

    fn set_height(&mut self, h: Dimension);
}

/// An error that occurred during rendering.
#[derive(Debug, Error)]
pub enum RenderError {
    #[error("Coordinates ({0}, {1}) out of bounds!")]
    OutOfBounds(RelativeCoordinate, RelativeCoordinate),
}

#[cfg(test)]
mod tests {
    use super::MemoryRenderer;
    use crate::components::EchoText;
    use crate::input::TerminalInput;
    use crate::MUI;

    use eyre::Result;

    #[tokio::test]
    async fn test_it_works() -> Result<()> {
        let mut root = EchoText::<()>::new("henol world");

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

        ui.move_cursor(0, 0).await?;
        assert_eq!("henol world".to_string(), ui.read_at_cursor(11).await?);

        Ok(())
    }
}