text2art 1.0.2

Simple library for translate text to ascii art.
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

use std::hash::{Hash, Hasher};

#[derive(Debug, PartialEq, Eq)]
pub(crate) struct ArtSymbol {
    width: u32,
    height: u32,
    shift: i32,
    symbol: String,
    lines: Vec<String>,
    empty_line: String,
}

impl ArtSymbol {
    pub(crate) fn new(symbol: &str, data: &str, shift: i32) -> ArtSymbol {
        let width: u32 = data
            .split("\\n")
            .filter(|&x| !x.is_empty())
            .map(str::len)
            .max()
            .unwrap() as u32;
        let height: u32 = data.matches("\\n").count() as u32;
        ArtSymbol {
            width,
            height,
            shift,
            symbol: symbol.to_owned(),
            lines: data
                .split("\\n")
                .collect::<Vec<&str>>()
                .into_iter()
                .rev()
                .filter(|&x| !x.is_empty())
                .map(str::to_string)
                .collect::<Vec<String>>(),
            empty_line: " ".repeat(width as usize),
        }
    }

    pub(crate) fn width(&self) -> u32 {
        self.width
    }

    pub(crate) fn height(&self) -> u32 {
        self.height
    }

    pub(crate) fn shift(&self) -> i32 {
        self.shift
    }

    pub(crate) fn get_line(&self, line: i32) -> &str {
        if line < self.shift || line > (self.height as i32 + self.shift) {
            self.empty_line.as_str()
        } else {
            match self.lines.get((line - self.shift) as usize) {
                Some(line) => line,
                None => self.empty_line.as_str(),
            }
        }
    }
}

impl Hash for ArtSymbol {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.symbol.hash(state);
    }
}

#[cfg(test)]
mod tests {
    use crate::art_symbol;

    #[test]
    fn test_art_symbol_simple() {
        let test_symbol = "a";
        let test_data = "line_1\\nline_0\\n";
        let test_shift = 0i32;
        let asym = art_symbol::ArtSymbol::new(test_symbol, test_data, test_shift);

        assert_eq!(asym.symbol, test_symbol);
        assert_eq!(asym.shift, test_shift);
        assert_eq!(asym.height, 2);
        assert_eq!(asym.lines.len(), 2);
        assert_eq!(asym.get_line(2), "      ");
        assert_eq!(asym.get_line(1), "line_1");
        assert_eq!(asym.get_line(0), "line_0");
        assert_eq!(asym.get_line(-1), "      ");
    }

    #[test]
    fn test_art_symbol_with_positive_shift() {
        let test_symbol = "a";
        let test_data = "line_2\\nline_1\\n";
        let test_shift = 1i32;
        let asym = art_symbol::ArtSymbol::new(test_symbol, test_data, test_shift);

        assert_eq!(asym.symbol, test_symbol);
        assert_eq!(asym.shift, test_shift);
        assert_eq!(asym.height, 2);
        assert_eq!(asym.lines.len(), 2);
        assert_eq!(asym.get_line(3), "      ");
        assert_eq!(asym.get_line(2), "line_2");
        assert_eq!(asym.get_line(1), "line_1");
        assert_eq!(asym.get_line(0), "      ");
    }

    #[test]
    fn test_art_symbol_with_negative_shift() {
        let test_symbol = "a";
        let test_data = "line_0\\nline_-1\\n";
        let test_shift = -1i32;
        let asym = art_symbol::ArtSymbol::new(test_symbol, test_data, test_shift);

        assert_eq!(asym.symbol, test_symbol);
        assert_eq!(asym.shift, test_shift);
        assert_eq!(asym.height, 2);
        assert_eq!(asym.lines.len(), 2);
        assert_eq!(asym.get_line(1), "       ");
        assert_eq!(asym.get_line(0), "line_0");
        assert_eq!(asym.get_line(-1), "line_-1");
        assert_eq!(asym.get_line(-2), "       ");
    }
}