spectrum 0.0.0

A library for building structured, colorful output. Under heavy development, and doesn't work yet
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

use std::{
    error::Error,
    io::{self, stdout},
};

use pretty::{Render, RenderAnnotated};

use crate::{EmitBackend, StyledFragment};

pub struct StyledRenderer<'a> {
    write: Box<dyn io::Write + 'a>,
    backend: EmitBackend<'a>,
}

impl<'a> StyledRenderer<'a> {
    #[allow(unused)]
    pub fn new(
        write: impl io::Write + 'a,
        backend: impl Into<EmitBackend<'a>>,
    ) -> StyledRenderer<'a> {
        StyledRenderer {
            write: Box::new(write),
            backend: backend.into(),
        }
    }

    #[allow(unused)]
    pub fn stdout(backend: impl Into<EmitBackend<'a>>) -> StyledRenderer<'a> {
        StyledRenderer {
            write: Box::new(stdout()),
            backend: backend.into(),
        }
    }
}

impl<'a> Render for StyledRenderer<'a> {
    type Error = Box<dyn Error>;

    fn write_str(&mut self, s: &str) -> Result<usize, Self::Error> {
        Ok(s.len())
    }

    fn fail_doc(&self) -> Self::Error {
        Box::new(io::Error::new(
            io::ErrorKind::Other,
            "Document failed to render",
        ))
    }
}

impl<'a> RenderAnnotated<'a, StyledFragment> for StyledRenderer<'_> {
    fn push_annotation(&mut self, annotation: &'a StyledFragment) -> Result<(), Self::Error> {
        Ok(annotation.emit_into(&mut *self.write, &self.backend)?)
    }

    fn pop_annotation(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use console::Color;

    use super::*;
    use crate::{emit::buf::Buf, structure::*, EmitForTest, EmitPlain, Style, StyledString};

    #[test]
    fn basic_render() -> Result<(), Box<dyn Error>> {
        let structure =
            Structure::fragment(StyledString::new("hello", Style::default().fg(Color::Red)))
                .append(Structure::Hardline);

        let pretty = structure.render();

        let string = Buf::collect_string(|write| {
            let mut renderer = StyledRenderer::new(write, &EmitPlain);
            pretty
                .render_raw(100, &mut renderer)
                .map_err(|_| std::fmt::Error)
        })?;

        assert_eq!(string, "hello\n");

        Ok(())
    }

    #[test]
    fn colored_render() -> Result<(), Box<dyn Error>> {
        let structure =
            Structure::fragment(StyledString::new("hello", Style::default().fg(Color::Red)))
                .append(Structure::Hardline);

        let pretty = structure.render();

        let string = Buf::collect_string(|write| {
            let mut renderer = StyledRenderer::new(write, &EmitForTest);
            pretty
                .render_raw(100, &mut renderer)
                .map_err(|_| std::fmt::Error)
        })?;

        assert_eq!(string, "[Red:hello]\n");

        Ok(())
    }
}