numbat 1.23.0

A statically typed programming language for scientific computations with first class support for physical dimensions and units.
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
120

use crate::buffered_writer::BufferedWriter;
use crate::markup::{FormatType, FormattedString, Formatter};

use compact_str::{CompactString, format_compact};
use termcolor::{Color, WriteColor};

pub struct HtmlFormatter;

pub fn html_format(class: Option<&str>, content: &str) -> CompactString {
    if content.is_empty() {
        return CompactString::const_new("");
    }

    let content = html_escape::encode_text(content);

    if let Some(class) = class {
        format_compact!("<span class=\"numbat-{class}\">{content}</span>")
    } else {
        content.into()
    }
}

impl Formatter for HtmlFormatter {
    fn format_part(
        &self,
        FormattedString(_output_type, format_type, s): &FormattedString,
    ) -> CompactString {
        let css_class = match format_type {
            FormatType::Whitespace => None,
            FormatType::Emphasized => Some("emphasized"),
            FormatType::Dimmed => Some("dimmed"),
            FormatType::Text => None,
            FormatType::String => Some("string"),
            FormatType::Keyword => Some("keyword"),
            FormatType::Value => Some("value"),
            FormatType::Unit => Some("unit"),
            FormatType::Identifier => Some("identifier"),
            FormatType::TypeIdentifier => Some("type-identifier"),
            FormatType::Operator => Some("operator"),
            FormatType::Decorator => Some("decorator"),
        };
        html_format(css_class, s)
    }
}

pub struct HtmlWriter {
    buffer: Vec<u8>,
    color: Option<termcolor::ColorSpec>,
}

impl Default for HtmlWriter {
    fn default() -> Self {
        Self::new()
    }
}

impl HtmlWriter {
    pub fn new() -> Self {
        HtmlWriter {
            buffer: vec![],
            color: None,
        }
    }
}

impl BufferedWriter for HtmlWriter {
    fn to_string(&self) -> String {
        String::from_utf8_lossy(&self.buffer).into()
    }
}

impl std::io::Write for HtmlWriter {
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        if let Some(color) = &self.color {
            if color.fg() == Some(&Color::Red) {
                self.buffer
                    .write_all("<span class=\"numbat-diagnostic-red\">".as_bytes())?;
                let size = self.buffer.write(buf)?;
                self.buffer.write_all("</span>".as_bytes())?;
                Ok(size)
            } else if color.fg() == Some(&Color::Blue) {
                self.buffer
                    .write_all("<span class=\"numbat-diagnostic-blue\">".as_bytes())?;
                let size = self.buffer.write(buf)?;
                self.buffer.write_all("</span>".as_bytes())?;
                Ok(size)
            } else if color.bold() {
                self.buffer
                    .write_all("<span class=\"numbat-diagnostic-bold\">".as_bytes())?;
                let size = self.buffer.write(buf)?;
                self.buffer.write_all("</span>".as_bytes())?;
                Ok(size)
            } else {
                self.buffer.write(buf)
            }
        } else {
            self.buffer.write(buf)
        }
    }

    fn flush(&mut self) -> std::io::Result<()> {
        self.buffer.flush()
    }
}

impl WriteColor for HtmlWriter {
    fn supports_color(&self) -> bool {
        true
    }

    fn set_color(&mut self, spec: &termcolor::ColorSpec) -> std::io::Result<()> {
        self.color = Some(spec.clone());
        Ok(())
    }

    fn reset(&mut self) -> std::io::Result<()> {
        self.color = None;
        Ok(())
    }
}