glyf 0.2.1

Glyph finder
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

use std::io::{self, Write};
use std::str::FromStr;

use crate::corpus::{
    FIELD_ALT_NAME, FIELD_BIDI, FIELD_BLOCK, FIELD_CATEGORY, FIELD_COMBINING, FIELD_DECIMAL,
    FIELD_DECOMP, FIELD_DIGIT, FIELD_GLYPH, FIELD_ICON_SET, FIELD_LOWERCASE, FIELD_MIRRORED,
    FIELD_NUMERIC, FIELD_SOURCE, FIELD_TITLECASE, FIELD_UPPERCASE, Idx, codepoint, entry_name,
    entry_str,
};

pub enum Format {
    Plain,
    Pretty,
    Tsv,
}

impl FromStr for Format {
    type Err = &'static str;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "plain" => Ok(Self::Plain),
            "pretty" => Ok(Self::Pretty),
            "tsv" => Ok(Self::Tsv),
            _ => Err("unknown format; use plain, pretty, or tsv"),
        }
    }
}

pub fn print_entry(w: &mut impl Write, idx: Idx, fmt: &Format) -> io::Result<()> {
    match fmt {
        Format::Plain => writeln!(w, "{}", entry_str(idx, FIELD_GLYPH)),
        Format::Pretty => writeln!(
            w,
            "{}\tU+{:04X}\t{}\t{}",
            entry_str(idx, FIELD_GLYPH),
            codepoint(idx),
            entry_name(idx),
            entry_str(idx, FIELD_BLOCK),
        ),
        Format::Tsv => writeln!(
            w,
            "{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}",
            codepoint(idx),
            entry_str(idx, FIELD_GLYPH),
            entry_name(idx),
            entry_str(idx, FIELD_SOURCE),
            entry_str(idx, FIELD_CATEGORY),
            entry_str(idx, FIELD_COMBINING),
            entry_str(idx, FIELD_BIDI),
            entry_str(idx, FIELD_DECOMP),
            entry_str(idx, FIELD_DECIMAL),
            entry_str(idx, FIELD_DIGIT),
            entry_str(idx, FIELD_NUMERIC),
            entry_str(idx, FIELD_MIRRORED),
            entry_str(idx, FIELD_ALT_NAME),
            entry_str(idx, FIELD_UPPERCASE),
            entry_str(idx, FIELD_LOWERCASE),
            entry_str(idx, FIELD_TITLECASE),
            entry_str(idx, FIELD_BLOCK),
            entry_str(idx, FIELD_ICON_SET),
        ),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::corpus::lookup;

    fn sample_idx() -> Idx {
        lookup(0x0041).expect("A should be in corpus")
    }

    #[test]
    fn format_from_str_plain() {
        let f: Format = "plain".parse().expect("plain is valid");
        assert!(matches!(f, Format::Plain));
    }

    #[test]
    fn format_from_str_pretty() {
        let f: Format = "pretty".parse().expect("pretty is valid");
        assert!(matches!(f, Format::Pretty));
    }

    #[test]
    fn format_from_str_tsv() {
        let f: Format = "tsv".parse().expect("tsv is valid");
        assert!(matches!(f, Format::Tsv));
    }

    #[test]
    fn format_from_str_invalid() {
        assert!("badger".parse::<Format>().is_err());
    }

    #[test]
    fn print_plain_format() {
        let idx = sample_idx();
        let mut buf = Vec::new();
        print_entry(&mut buf, idx, &Format::Plain).expect("write should succeed");
        let s = String::from_utf8(buf).expect("buf should be utf-8");
        assert_eq!(s, "A\n");
    }

    #[test]
    fn print_pretty_format() {
        let idx = sample_idx();
        let mut buf = Vec::new();
        print_entry(&mut buf, idx, &Format::Pretty).expect("write should succeed");
        let s = String::from_utf8(buf).expect("buf should be utf-8");
        assert_eq!(s, "A\tU+0041\tLATIN CAPITAL LETTER A\tBasic Latin\n");
    }

    #[test]
    fn print_tsv_format() {
        let idx = sample_idx();
        let mut buf = Vec::new();
        print_entry(&mut buf, idx, &Format::Tsv).expect("write should succeed");
        let s = String::from_utf8(buf).expect("buf should be utf-8");
        assert!(s.starts_with("65\tA\tLATIN CAPITAL LETTER A\tunicode"));
        assert!(s.ends_with("\tBasic Latin\t\n"));
    }
}