html_export 0.1.1

Basic struct & enums to html file conversion crate
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

use std::fmt::Display;

use crate::{
    element::{Element, HtmlElement},
    tags::TagType,
};

pub type WrapResult = Result<Element, WrapElementError>;
pub type CreateElementResult = Result<HtmlElement, ElementError>;

#[derive(Debug)]
/// Defines Html element's related errors.
pub enum ElementError {
    /// Error when adding a sub-element to Html elements.
    InvalidContent(TagType),
    /// Error when indexing sub-element to Html elements.
    InvalidIndex(usize, usize),
}

#[derive(Debug)]
/// Defines Html wrapping error.
pub enum WrapElementError {
    /// Error when wrapping with a no-child Html element.
    NonWrapperElement(TagType),
    /// Error when wrapping multiple Html elements wwith a single-child Html element.
    SingleChildExceeded(TagType),
    /// Error when wrapping a sub-element at an invalid index.
    InvalidIndex(usize, usize),
}

#[derive(Debug)]
/// Defines the radio creation errors
pub enum FieldCreationError {
    /// Error when defining which element is checked. The given index is invalid.
    SetCheckedInvalidIndex(usize, usize),
}

#[derive(Debug)]
/// The `<head>` tag errors.
pub enum HeadCreationError {
    /// Error when adding an html incompatible hmlt tag.
    InvalidContent(Element),
}

impl Display for WrapElementError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            WrapElementError::NonWrapperElement(tag_type) => {
                writeln!(
                    f,
                    "Element Tag=<{}> can not wrap another element.",
                    tag_type.get_tag_name()
                )
            }
            WrapElementError::SingleChildExceeded(tag_type) => {
                writeln!(
                    f,
                    "Element Tag=<{}> can have at most 1 child element.",
                    tag_type.get_tag_name()
                )
            }
            WrapElementError::InvalidIndex(index, size) => {
                writeln!(
                    f,
                    "Attempted to insert a child element at position {} but the container had {} child-elements.",
                    index,
                    size
                )
            }
        }
    }
}

impl Display for ElementError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ElementError::InvalidContent(tag_type) => {
                if !tag_type.can_wrap() {
                    write!(
                        f,
                        "The element <{}> can not have sub-elements.",
                        tag_type.get_tag_name()
                    )
                } else if tag_type.is_single_child() {
                    write!(
                        f,
                        "The element <{}> can have at most 1 sub-elements.",
                        tag_type.get_tag_name()
                    )
                } else {
                    write!(
                        f,
                        "Unknown behavior occured while adding a sub-element to <{}> element.",
                        tag_type.get_tag_name()
                    )
                }
            }
            ElementError::InvalidIndex(index, size) => write!(
                f,
                "Could not remove element at index {} from the collection of size {}.",
                index, size
            ),
        }
    }
}

impl Display for FieldCreationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            FieldCreationError::SetCheckedInvalidIndex(index, size) => write!(
                f,
                "Can not set element checked at index {} for a list of size {}",
                index, size
            ),
        }
    }
}

impl Display for HeadCreationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            HeadCreationError::InvalidContent(element) => {
                write!(
                    f,
                    "Can not add element {:?} in an <head> html tag.",
                    element
                )
            }
        }
    }
}