badgeland 0.13.0

Fast badge generator for any purpose
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use ab_glyph::{Font, FontRef, PxScale, ScaleFont};
use std::{cmp::Ordering, ops::Range};
use unicode_normalization::UnicodeNormalization;

fn get_font() -> FontRef<'static> {
    let font_data: &[u8] = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/resx/Verdana.ttf"));
    FontRef::try_from_slice(font_data).expect("Error constructing Font")
}

pub(crate) trait TextWidth {
    fn get_text_width(&self, height: f32) -> usize;
}

impl<'a> TextWidth for &'a str {
    #[inline]
    fn get_text_width(&self, height: f32) -> usize {
        let font = get_font();

        let scale = PxScale::from(height as f32);
        let scaled_font = font.as_scaled(scale);

        let normalized: String = self.trim().nfc().collect();
        normalized
            .chars()
            .map(|c| {
                let glyph = scaled_font.scaled_glyph(c);
                let gb = scaled_font.glyph_bounds(&glyph);
                gb.width() * 1.12
            })
            .fold(0.0, |acc, w| acc + w)
            .floor() as usize
    }
}

#[derive(Debug, Default, Clone)]
pub struct Path<'a> {
    values: &'a [f32],
    chart_height: f32,
    x_offset: f32,
    y_offset: f32,
    index: Range<usize>,
}

impl<'a> Path<'a> {
    pub fn new(values: &'a [f32], height: usize, width: usize) -> Self {
        let len = values.len();
        let chart_height = height as f32;
        let max = values
            .iter()
            .max_by(|&a, &b| a.partial_cmp(b).unwrap_or(Ordering::Equal))
            .unwrap_or(&0.);

        let y_offset = chart_height / max;
        let x_offset = width as f32 / (len as f32 - 1.0);

        Path {
            values,
            chart_height,
            x_offset,
            y_offset,
            index: 0..len,
        }
    }
}

impl<'a> Iterator for Path<'a> {
    type Item = (f32, f32);
    fn next(&mut self) -> Option<Self::Item> {
        self.index.next().map(|i| {
            let x = i as f32 * self.x_offset;
            let y = self.chart_height - self.y_offset * self.values[i];
            (x, y)
        })
    }
}

#[derive(Default)]
pub(super) struct ContentSize {
    pub(super) x: usize,
    pub(super) y: usize,
    pub(super) rw: usize,
}

pub(super) trait BadgeContentSize {
    fn content_size(&self, height: usize, width: usize, padding: usize, x_offset: usize) -> ContentSize;
}

impl<'a> BadgeContentSize for &'a [f32] {
    #[inline]
    fn content_size(&self, height: usize, width: usize, padding: usize, _: usize) -> ContentSize {
        ContentSize {
            x: (width + padding) / 2,
            y: height / 2,
            rw: width,
        }
    }
}

impl<'a> BadgeContentSize for &'a str {
    #[inline]
    fn content_size(&self, height: usize, width: usize, padding: usize, x_offset: usize) -> ContentSize {
        let w = width + x_offset;
        let x = (width + padding) / 2 + x_offset;
        let y = height / 2;
        let rw = w + padding;
        ContentSize { x, y, rw }
    }
}

#[cfg(test)]
mod tests {
    use super::{Path, TextWidth};

    #[test]
    fn content_str_width() {
        let s = "Hello";
        let bc = s.get_text_width(20.);
        assert!(bc > 0);
    }
    #[test]
    fn content_text_has_width() {
        let text = "".get_text_width(20.);
        assert_eq!(text, 0);
        let text = "npm".get_text_width(20.);
        assert_eq!(text, 46);
        let text = "long text".get_text_width(20.);
        assert_eq!(text, 90);
    }

    #[test]
    fn path_generate() {
        let d = [2., 4., 3., 2.];
        let path = Path::new(&d, 20, 100).into_iter().collect::<Vec<_>>();

        assert_eq!(path.len(), 4);
        assert_eq!(
            path,
            vec![(0.0, 10.0), (33.333332, 0.0), (66.666664, 5.0), (100.0, 10.0)]
        )
    }
}