tidos 0.7.0

Tidos is a component framework that can be served by any web framework.
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

use std::collections::HashSet;
#[cfg(all(feature = "rocket", feature = "i18n"))]
use ::rocket::request::FromParam;
#[cfg(feature = "i18n")]
use unic_langid::{LanguageIdentifier, LanguageIdentifierError};

#[cfg(not(feature = "i18n"))]
pub struct Page {
	pub head_ids: HashSet<&'static str>,
	pub head: String,
	pub template: String,
}

#[cfg(feature = "i18n")]
pub struct Page {
	pub head_ids: HashSet<&'static str>,
	pub lang: LanguageIdentifier,
	pub head: String,
	pub template: String,
}

impl Page {
	#[cfg(not(feature = "i18n"))]
	pub fn new() -> Page {
		Page {
			head_ids: HashSet::new(),
			head: String::new(),
			template: String::new(),
		}
	}

	#[cfg(feature = "i18n")]
	pub fn new(lang: LanguageIdentifier) -> Page {
		Page {
			head_ids: HashSet::new(),
			lang,
			head: String::new(),
			template: String::new(),
		}
	}

	pub fn add_elements_to_head(&mut self, id: &'static str, element: String) {
		if self.head_ids.insert(id) {
			self.head += &element;
		}
	}
}

#[cfg(feature = "rocket")]
mod rocket {
	use rocket::http::{ContentType, Status};
	use rocket::response::Responder;
	use rocket::{response, Request, Response};

	#[cfg(not(feature = "i18n"))]
	impl<'r> Responder<'r, 'static> for crate::page::Page {
		fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
			let string = format!(
				"<!doctype html>\
                <html lang=\"en\">\
                    <head>\
                        <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\
                        <meta charset=\"utf-8\" />\
                        {}\
                    </head>\
                    <body>\
                        {}\
                    </body>\
                </html>",
				self.head,
				self.template,
			);
			Response::build_from(string.respond_to(req)?)
				.header(ContentType::HTML)
				.ok()
		}
	}

	#[cfg(feature = "i18n")]
	impl<'r> Responder<'r, 'static> for crate::page::Page {
		fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
			let string = format!(
				"<!doctype html>\
                <html lang=\"{}\">\
                    <head>\
                        <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\
                        <meta charset=\"utf-8\" />\
                        {}\
                    </head>\
                    <body>\
                        {}\
                    </body>\
                </html>",
				self.lang,
				self.head,
				self.template,
			);
			Response::build_from(string.respond_to(req)?)
				.header(ContentType::HTML)
				.ok()
		}
	}
}

#[cfg(all(feature = "rocket", feature = "i18n"))]
pub struct Lang(pub LanguageIdentifier);

#[cfg(all(feature = "rocket", feature = "i18n"))]
impl<'a> FromParam<'a> for Lang {
		type Error = LanguageIdentifierError;

		fn from_param(param: &'a str) -> Result<Self, Self::Error> {
			match LanguageIdentifier::from_bytes(param.as_bytes()) {
				Ok(id) => Ok(Self(id)),
				Err(error) => Err(error)
			}
		}
	}