ggemtext 0.7.0

Glib-oriented Gemtext API
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

use super::Level;

pub trait Gemtext {
    /// Get [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) value for `Self`
    fn as_value(&self) -> Option<&str>;
    /// Get parsed H1 header value for `Self`
    fn as_h1_value(&self) -> Option<&str>;
    /// Get parsed H2 header value `Self`
    fn as_h2_value(&self) -> Option<&str>;
    /// Get parsed H3 header value `Self`
    fn as_h3_value(&self) -> Option<&str>;
    /// Get parsed header value `Self` match `Level`
    fn as_value_match_level(&self, level: Level) -> Option<&str>;
    /// Convert `Self` to `Level`
    fn to_level(&self) -> Option<Level>;
    /// Convert `Self` to [Gemtext](https://geminiprotocol.net/docs/gemtext-specification.gmi) line
    fn to_source(&self, level: &Level) -> String;
}

impl Gemtext for str {
    fn as_value(&self) -> Option<&str> {
        if let Some(value) = self.as_h1_value() {
            return Some(value);
        }
        if let Some(value) = self.as_h2_value() {
            return Some(value);
        }
        if let Some(value) = self.as_h3_value() {
            return Some(value);
        }
        None
    }
    fn as_h1_value(&self) -> Option<&str> {
        self.as_value_match_level(Level::H1)
    }
    fn as_h2_value(&self) -> Option<&str> {
        self.as_value_match_level(Level::H2)
    }
    fn as_h3_value(&self) -> Option<&str> {
        self.as_value_match_level(Level::H3)
    }
    fn as_value_match_level(&self, level: Level) -> Option<&str> {
        self.strip_prefix(level.as_tag())
            .map(|postfix| postfix.trim())
            .filter(|value| !value.starts_with(Level::H1.as_tag()))
    }
    fn to_level(&self) -> Option<Level> {
        if self.as_h1_value().is_some() {
            return Some(Level::H1);
        }
        if self.as_h2_value().is_some() {
            return Some(Level::H2);
        }
        if self.as_h3_value().is_some() {
            return Some(Level::H3);
        }
        None
    }
    fn to_source(&self, level: &Level) -> String {
        format!("{} {}", level.as_tag(), self.trim())
    }
}

#[test]
fn test() {
    const VALUE: &str = "H";
    let mut value: Option<&str> = Some(VALUE);
    for t in ["#", "##", "###", "####"] {
        if t.len() > 3 {
            value = None;
        }
        assert_eq!(format!("{t}{VALUE}").as_value(), value);
        assert_eq!(format!("{t}{VALUE} ").as_value(), value);
        assert_eq!(format!("{t} {VALUE}").as_value(), value);
        assert_eq!(format!("{t} {VALUE} ").as_value(), value);
    }

    fn to_source(l: &Level) {
        assert_eq!(VALUE.to_source(l), format!("{} {VALUE}", l.as_tag()));
    }
    to_source(&Level::H1);
    to_source(&Level::H2);
    to_source(&Level::H3);

    fn to_level(l: &Level) {
        fn assert(s: String, l: &str) {
            assert_eq!(s.to_level().unwrap().as_tag(), l);
        }
        let t = l.as_tag();
        assert(format!("{t} {VALUE}"), t);
        assert(format!("{t} {VALUE} "), t);
        assert(format!("{t}{VALUE} "), t);
        assert(format!("{t} {VALUE} "), t);
    }
    to_level(&Level::H1);
    to_level(&Level::H2);
    to_level(&Level::H3);
}