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

use std::io::Write;

use anyhow::Result;
use derive_builder::Builder;
use html_site_generator_macro::DeriveSetHtmlAttributes;

use super::hyperlink::ReferrerPolicy;
use super::link::CrossOrigin;
use super::{IntoHtmlNode, IsParagraph};
use crate::attributes::HtmlAttributes;

/// Specifies whether a browser should load an image immediately or to defer loading of images until some conditions are met
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Loading {
    Eager,
    Lazy,
}

impl Loading {
    fn to_html_string(&self) -> &'static str {
        match self {
            Loading::Eager => "eager",
            Loading::Lazy => "lazy",
        }
    }
}

/// HTML Attribute: [`<img>`](https://www.w3schools.com/tags/tag_img.asp)
#[derive(Debug, Builder, DeriveSetHtmlAttributes)]
pub struct Image {
    /// Specifies an alternate text for an image
    #[builder(setter(strip_option, into), default)]
    alt: Option<String>,

    /// Allow images from third-party sites that allow cross-origin access to be used with canvas
    #[builder(setter(strip_option), default)]
    cross_origin: Option<CrossOrigin>,

    /// Specifies the height of an image
    #[builder(setter(strip_option), default)]
    height: Option<u32>,

    /// Specifies an image as a server-side image map
    #[builder(setter(strip_option), default = "false")]
    ismap: bool,

    /// Specifies whether a browser should load an image immediately or to defer loading of images until some conditions are met
    #[builder(setter(strip_option), default)]
    loading: Option<Loading>,

    // TODO not really supported https://www.w3schools.com/tags/att_img_longdesc.asp
    /// Specifies a URL to a detailed description of an image
    // #[builder(setter(strip_option, into), default)]
    // long_desc: Option<String>,

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

    // TODO add logic to check with `src_set`, https://www.dofactory.com/html/img/sizes
    /// Specifies image sizes for different page layouts
    // #[builder(setter(strip_option, into), default)]
    // sizes: Option<String>,

    /// Specifies the path to the image
    #[builder(setter(strip_option, into), default)]
    src: Option<String>,

    // TODO add logic to check with `sizes`, https://www.dofactory.com/html/img/sizes
    /// Specifies a list of image files to use in different situations
    // #[builder(setter(strip_option, into), default)]
    // src_set: Option<Vec<String>>,

    /// Specifies an image as a client-side image map
    // TODO implement html tag `map` before implementing this here in `Image`
    // #[builder(setter(strip_option, into), default)]
    // usemap: Option<String>,

    /// Specifies the width of an image
    #[builder(setter(strip_option), default)]
    width: Option<u32>,

    #[builder(setter(skip))]
    _attributes: HtmlAttributes,
}

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

        if let Some(value) = &self.alt {
            write!(buffer, " alt=\"{}\"", value)?;
        }
        if let Some(value) = &self.cross_origin {
            write!(buffer, " crossorigin=\"{}\"", value.to_html_string())?;
        }
        if let Some(value) = &self.height {
            write!(buffer, " height=\"{}\"", value)?;
        }
        if let Some(value) = &self.loading {
            write!(buffer, " loading=\"{}\"", value.to_html_string())?;
        }
        if let Some(value) = &self.referrer_policy {
            write!(buffer, " referrerpolicy=\"{}\"", value.to_html_string())?;
        }
        if let Some(value) = &self.src {
            write!(buffer, " src=\"{}\"", value)?;
        }
        if let Some(value) = &self.width {
            write!(buffer, " width=\"{}\"", value)?;
        }

        if self.ismap {
            write!(buffer, " ismap")?;
        }

        write!(buffer, ">")?;

        Ok(())
    }
}

// TODO I'm not quit sure if `Image` implements the trait `IsParagraph`.
// But at the moment this is the only way to use `Hyperlink` in a `Paragraph`
// Maybe there is another, and better way, to do this?
// same as `Hyperlink`, `LineBreak`
impl IsParagraph for Image {
    fn to_raw(&self) -> String {
        let mut vec = Vec::new();

        self.transform_into_html_node(&mut vec).unwrap();

        String::from_utf8(vec).unwrap()
    }
}