ggemini 0.20.0

Glib/Gio-oriented network API for Gemini protocol
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

pub mod error;
pub mod mode;

pub use error::Error;
pub use mode::Mode;

// Local dependencies

use gio::NetworkAddress;
use glib::{Bytes, Uri, UriHideFlags};

/// Single `Request` implementation for different protocols
pub enum Request {
    Gemini {
        uri: Uri,
        mode: Mode,
    },
    Titan {
        uri: Uri,
        data: Bytes,
        /// MIME type is optional attribute by Titan protocol specification,
        /// but server MAY reject the request without `mime` value provided.
        mime: Option<String>,
        token: Option<String>,
        mode: Mode,
    },
}

impl Request {
    // Getters

    /// Generate header string for `Self`
    pub fn header(&self) -> String {
        match self {
            Self::Gemini { uri, .. } => format!("{uri}\r\n"),
            Self::Titan {
                uri,
                data,
                mime,
                token,
                ..
            } => {
                let mut header = format!(
                    "{};size={}",
                    uri.to_string_partial(UriHideFlags::QUERY),
                    data.len()
                );
                if let Some(mime) = mime {
                    header.push_str(&format!(";mime={mime}"));
                }
                if let Some(token) = token {
                    header.push_str(&format!(";token={token}"));
                }
                if let Some(query) = uri.query() {
                    header.push_str(&format!("?{query}"));
                }
                header.push_str("\r\n");
                header
            }
        }
    }

    /// Get reference to `Self` [Uri](https://docs.gtk.org/glib/struct.Uri.html)
    pub fn uri(&self) -> &Uri {
        match self {
            Self::Gemini { uri, .. } => uri,
            Self::Titan { uri, .. } => uri,
        }
    }

    /// Get [NetworkAddress](https://docs.gtk.org/gio/class.NetworkAddress.html) for `Self`
    pub fn to_network_address(&self, default_port: u16) -> Result<NetworkAddress, Error> {
        match crate::gio::network_address::from_uri(self.uri(), default_port) {
            Ok(network_address) => Ok(network_address),
            Err(e) => Err(Error::NetworkAddress(e)),
        }
    }
}

#[test]
fn test_gemini_header() {
    use glib::UriFlags;

    const REQUEST: &str = "gemini://geminiprotocol.net/";

    assert_eq!(
        Request::Gemini {
            uri: Uri::parse(REQUEST, UriFlags::NONE).unwrap(),
            mode: Mode::HeaderOnly
        }
        .header(),
        format!("{REQUEST}\r\n")
    );
}

#[test]
fn test_titan_header() {
    use glib::UriFlags;

    const DATA: &[u8] = &[1, 2, 3];
    const MIME: &str = "plain/text";
    const TOKEN: &str = "token";

    assert_eq!(
        Request::Titan {
            uri: Uri::parse(
                "titan://geminiprotocol.net/raw/path?key=value",
                UriFlags::NONE
            )
            .unwrap(),
            data: Bytes::from(DATA),
            mime: Some(MIME.to_string()),
            token: Some(TOKEN.to_string()),
            mode: Mode::HeaderOnly
        }
        .header(),
        format!(
            "titan://geminiprotocol.net/raw/path;size={};mime={MIME};token={TOKEN}?key=value\r\n",
            DATA.len(),
        )
    );
}