bonbon 0.4.2

A sweet and simple Rust library for generating static diabetes data visualizations.
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
121
122

use image::Rgba;
use serde::{Deserialize, Deserializer};
use std::fs::File;
use std::io::Read;
use std::path::Path;

#[derive(Clone, Debug, Deserialize)]
pub struct Theme {
    #[serde(deserialize_with = "deserialize_color")]
    pub background: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub grid_major: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub grid_minor: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub axis_lines: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub text_primary: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub text_secondary: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub text_dim: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub glucose_high: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub glucose_low: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub glucose_in_range: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub insulin: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub carbs: Rgba<u8>,

    #[serde(deserialize_with = "deserialize_color")]
    pub glucose_reading_fill: Rgba<u8>,
    #[serde(deserialize_with = "deserialize_color")]
    pub glucose_reading_outline: Rgba<u8>,
}

macro_rules! builtin_theme {
    ($(#[$doc:meta])* $fn_name:ident, $file:literal) => {
        $(#[$doc])*
        pub fn $fn_name() -> Self {
            let json = include_str!(concat!("./themes/", $file, ".json"));
            serde_json::from_str(json)
                .unwrap_or_else(|e| panic!("Built-in theme `{}` is invalid JSON: {e}", $file))
        }
    };
}

impl Theme {
    pub fn dark() -> Self {
        let json = include_str!("./themes/beetroot_dark.json");
        serde_json::from_str(json).expect("Built-in dark theme is invalid JSON")
    }

    pub fn light() -> Self {
        let json = include_str!("./themes/beetroot_light.json");
        serde_json::from_str(json).expect("Built-in light theme is invalid JSON")
    }

    builtin_theme!(licorice_dark, "licorice_dark");
    builtin_theme!(watermelon_dark, "watermelon_dark");

    // --- Light themes -------------------------------------------------------

    builtin_theme!(paper_light, "paper_light");
    builtin_theme!(ube_light, "ube_light");

    pub fn builtins() -> Vec<(&'static str, Theme)> {
        vec![
            ("beetroot_dark", Self::dark()),
            ("licorice_dark", Self::licorice_dark()),
            ("watermelon_dark", Self::watermelon_dark()),
            ("beetroot_light", Self::light()),
            ("paper_light", Self::paper_light()),
            ("ube_light", Self::ube_light()),
        ]
    }

    /// Load a custom theme from a file path
    pub fn load_from_file<P: AsRef<Path>>(path: P) -> Result<Self, Box<dyn std::error::Error>> {
        let mut file = File::open(path)?;
        let mut contents = String::new();
        file.read_to_string(&mut contents)?;

        let theme: Theme = serde_json::from_str(&contents)?;
        Ok(theme)
    }
}

fn deserialize_color<'de, D>(deserializer: D) -> Result<Rgba<u8>, D::Error>
where
    D: Deserializer<'de>,
{
    let s: String = Deserialize::deserialize(deserializer)?;
    parse_hex_color(&s).map_err(serde::de::Error::custom)
}

fn parse_hex_color(hex: &str) -> Result<Rgba<u8>, String> {
    let hex = hex.trim_start_matches('#');

    match hex.len() {
        6 => {
            let r = u8::from_str_radix(&hex[0..2], 16).map_err(|_| "Invalid Red")?;
            let g = u8::from_str_radix(&hex[2..4], 16).map_err(|_| "Invalid Green")?;
            let b = u8::from_str_radix(&hex[4..6], 16).map_err(|_| "Invalid Blue")?;
            Ok(Rgba([r, g, b, 255]))
        }
        8 => {
            let r = u8::from_str_radix(&hex[0..2], 16).map_err(|_| "Invalid Red")?;
            let g = u8::from_str_radix(&hex[2..4], 16).map_err(|_| "Invalid Green")?;
            let b = u8::from_str_radix(&hex[4..6], 16).map_err(|_| "Invalid Blue")?;
            let a = u8::from_str_radix(&hex[6..8], 16).map_err(|_| "Invalid Alpha")?;
            Ok(Rgba([r, g, b, a]))
        }
        _ => Err(format!(
            "Invalid hex length: {}. Expected 6 (RGB) or 8 (RGBA)",
            hex.len()
        )),
    }
}