Yoda 0.10.10

Browser for Gemini Protocol
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

mod directory;
mod image;
mod status;
mod text;

use super::{Feature, Page};
use gtk::{gio::Cancellable, glib::Uri};
use std::rc::Rc;

/// Local files client driver
pub struct File {
    page: Rc<Page>,
}

impl File {
    // Constructors

    /// Create new `Self`
    pub fn init(page: &Rc<Page>) -> Self {
        Self { page: page.clone() } // @TODO
    }

    pub fn handle(&self, uri: Uri, feature: Rc<Feature>, cancellable: Cancellable) {
        use directory::Directory;
        use gtk::{
            gio::{File, FileQueryInfoFlags, FileType},
            glib::Priority,
            prelude::FileExt,
        };
        use image::Image;
        use status::Status;
        use text::Text;

        let url = uri.to_string();
        let file = File::for_uri(&url);
        let page = self.page.clone();

        match file.query_file_type(FileQueryInfoFlags::NONE, Some(&cancellable)) {
            FileType::Directory => Directory { file }.handle(&page),
            _ => file.clone().query_info_async(
                "standard::content-type",
                FileQueryInfoFlags::NONE,
                Priority::DEFAULT,
                Some(&cancellable.clone()),
                move |result| match result {
                    Ok(file_info) => match file_info.content_type() {
                        Some(content_type) => match content_type.as_str() {
                            "text/plain" => {
                                if matches!(*feature, Feature::Source) {
                                    load_contents_async(file, cancellable, move |result| {
                                        match result {
                                            Ok(data) => Text::Source(uri, data).handle(&page),
                                            Err(message) => Status::Failure(message).handle(&page),
                                        }
                                    })
                                } else if url.ends_with(".txt") {
                                    load_contents_async(file, cancellable, move |result| {
                                        match result {
                                            Ok(data) => Text::Plain(uri, data).handle(&page),
                                            Err(message) => Status::Failure(message).handle(&page),
                                        }
                                    });
                                } else {
                                    load_contents_async(file, cancellable, move |result| {
                                        match result {
                                            Ok(data) => Text::Gemini(uri, data).handle(&page),
                                            Err(message) => Status::Failure(message).handle(&page),
                                        }
                                    })
                                }
                            }
                            "image/png" | "image/gif" | "image/jpeg" | "image/webp" => {
                                match gtk::gdk::Texture::from_file(&file) {
                                    Ok(texture) => Image::Bitmap(uri, texture).handle(&page),
                                    Err(e) => Status::Failure(e.to_string()).handle(&page),
                                }
                            }
                            mime => {
                                Status::Failure(format!("Content type `{mime}` yet not supported"))
                                    .handle(&page)
                            }
                        },
                        None => {
                            Status::Failure("Undetectable content type".to_string()).handle(&page)
                        }
                    },
                    Err(e) => Status::Failure(e.to_string()).handle(&page),
                },
            ),
        }
    }
}

// Tools

fn load_contents_async(
    file: gtk::gio::File,
    cancellable: Cancellable,
    callback: impl FnOnce(Result<String, String>) + 'static,
) {
    use gtk::prelude::FileExtManual;
    file.load_contents_async(Some(&cancellable), {
        move |result| {
            callback(match result {
                Ok((ref buffer, _)) => match String::from_utf8(buffer.to_vec()) {
                    Ok(data) => Ok(data),
                    Err(e) => Err(e.to_string()),
                },
                Err(e) => Err(e.to_string()),
            })
        }
    })
}