html-site-generator 0.0.1

Build a html file blazingly fast in Rust
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::io::Write;

use anyhow::Result;
use derive_builder::Builder;

use crate::html::hyperlink::ReferrerPolicy;
use crate::html::IntoHtmlNode;

/// Specifies how the element handles cross-origin requests
#[derive(Debug, Clone)]
pub enum CrossOrigin {
    Anonymous,
    UseCredentials,
}

impl CrossOrigin {
    pub(crate) fn to_html_string(&self) -> &'static str {
        match self {
            CrossOrigin::Anonymous => "anonymous",
            CrossOrigin::UseCredentials => "use-credentials",
        }
    }
}

/// Specifies the relationship between the current document and the linked document
#[derive(Debug, Clone, Default)]
pub enum Relationship {
    Alternate,
    Author,
    DnsPrefetch,
    Help,
    Icon,
    License,
    Next,
    Pingback,
    Preconnect,
    Prefetch,
    Preload,
    Prerender,
    Prev,
    Search,
    #[default]
    Stylesheet,
}

impl Relationship {
    fn to_html_string(&self) -> &'static str {
        match self {
            Relationship::Alternate => "alternate",
            Relationship::Author => "author",
            Relationship::DnsPrefetch => "dns-prefetch",
            Relationship::Help => "help",
            Relationship::Icon => "icon",
            Relationship::License => "license",
            Relationship::Next => "next",
            Relationship::Pingback => "pingback",
            Relationship::Preconnect => "preconnect",
            Relationship::Prefetch => "prefetch",
            Relationship::Preload => "preload",
            Relationship::Prerender => "prerender",
            Relationship::Prev => "prev",
            Relationship::Search => "search",
            Relationship::Stylesheet => "stylesheet",
        }
    }
}

/// HTML Attribute: [`<link>`](https://www.w3schools.com/tags/tag_link.asp)
#[derive(Debug, Default, Builder)]
pub struct Link {
    /// Specifies how the element handles cross-origin requests
    #[builder(setter(strip_option), default)]
    crossorigin: Option<CrossOrigin>,

    /// Specifies the location of the linked document
    #[builder(setter(strip_option, into), default)]
    href: Option<String>,

    /// Specifies the language of the text in the linked document
    #[builder(setter(strip_option, into), default)]
    href_lang: Option<String>,

    /// Specifies on what device the linked document will be displayed
    #[builder(setter(strip_option, into), default)]
    media: Option<String>,

    /// Specifies which referrer to use when fetching the resource
    #[builder(setter(strip_option), default)]
    referrer_policy: Option<ReferrerPolicy>,

    /// Specifies the relationship between the current document and the linked document
    rel: Relationship,

    /// Specifies the size of the linked resource. Only for rel="icon"
    #[builder(setter(strip_option, into), default)]
    sizes: Option<String>,

    /// Defines a preferred or an alternate stylesheet
    #[builder(setter(strip_option, into), default)]
    title: Option<String>,

    // TODO maybe use a crate with mime types
    /// Specifies the media type of the linked document
    #[builder(setter(strip_option, into), default)]
    media_type: Option<String>,
}

impl IntoHtmlNode for Link {
    fn transform_into_html_node(&self, buffer: &mut dyn Write) -> Result<()> {
        write!(buffer, "<link")?;

        if let Some(value) = &self.crossorigin {
            write!(buffer, " crossorigin=\"{}\"", value.to_html_string())?;
        }
        if let Some(value) = &self.href {
            write!(buffer, " href=\"{}\"", value)?;
        }
        if let Some(value) = &self.href_lang {
            write!(buffer, " hreflang=\"{}\"", value)?;
        }
        if let Some(value) = &self.media {
            write!(buffer, " media=\"{}\"", value)?;
        }
        if let Some(value) = &self.referrer_policy {
            write!(buffer, " referrerpolicy=\"{}\"", value.to_html_string())?;
        }
        write!(buffer, " rel=\"{}\"", self.rel.to_html_string())?;
        if let Some(value) = &self.sizes {
            write!(buffer, " sizes=\"{}\"", value)?;
        }
        if let Some(value) = &self.title {
            write!(buffer, " title=\"{}\"", value)?;
        }
        if let Some(value) = &self.title {
            write!(buffer, " title=\"{}\"", value)?;
        }
        if let Some(value) = &self.media_type {
            write!(buffer, " type=\"{}\"", value)?;
        }

        writeln!(buffer, ">")?;

        Ok(())
    }
}