Skip to main content

yaiko_core/
metadata.rs

1//! Validated SEO and social metadata rendering.
2#[derive(Debug, Clone, PartialEq, Eq)]
3pub enum MetadataError {
4    InvalidValue,
5}
6#[derive(Debug, Clone, Default, PartialEq, Eq)]
7pub struct Metadata {
8    pub title: Option<String>,
9    pub description: Option<String>,
10    pub canonical: Option<String>,
11    pub image: Option<String>,
12    pub json_ld: Option<String>,
13}
14impl Metadata {
15    pub fn new() -> Self {
16        Self::default()
17    }
18    pub fn title(mut self, v: impl Into<String>) -> Result<Self, MetadataError> {
19        self.title = Some(valid(v.into())?);
20        Ok(self)
21    }
22    pub fn description(mut self, v: impl Into<String>) -> Result<Self, MetadataError> {
23        self.description = Some(valid(v.into())?);
24        Ok(self)
25    }
26    pub fn canonical(mut self, v: impl Into<String>) -> Result<Self, MetadataError> {
27        self.canonical = Some(url(v.into())?);
28        Ok(self)
29    }
30    pub fn image(mut self, v: impl Into<String>) -> Result<Self, MetadataError> {
31        self.image = Some(url(v.into())?);
32        Ok(self)
33    }
34    pub fn json_ld(mut self, v: impl Into<String>) -> Result<Self, MetadataError> {
35        let v = valid(v.into())?;
36        if !v.trim_start().starts_with('{') {
37            return Err(MetadataError::InvalidValue);
38        }
39        self.json_ld = Some(v);
40        Ok(self)
41    }
42    pub fn render(&self) -> String {
43        let mut s = String::new();
44        if let Some(v) = &self.title {
45            s.push_str(&format!(
46                "<title>{}</title><meta property=\"og:title\" content=\"{}\">",
47                e(v),
48                e(v)
49            ))
50        }
51        if let Some(v) = &self.description {
52            s.push_str(&format!("<meta name=\"description\" content=\"{}\"><meta property=\"og:description\" content=\"{}\">",e(v),e(v)))
53        }
54        if let Some(v) = &self.canonical {
55            s.push_str(&format!("<link rel=\"canonical\" href=\"{}\">", e(v)))
56        }
57        if let Some(v) = &self.image {
58            s.push_str(&format!("<meta property=\"og:image\" content=\"{}\"><meta name=\"twitter:card\" content=\"summary_large_image\">",e(v)))
59        }
60        if let Some(v) = &self.json_ld {
61            s.push_str(&format!(
62                "<script type=\"application/ld+json\">{}</script>",
63                v
64            ))
65        }
66        s
67    }
68}
69fn valid(v: String) -> Result<String, MetadataError> {
70    if v.is_empty() || v.len() > 4096 || v.chars().any(|c| c.is_control()) {
71        Err(MetadataError::InvalidValue)
72    } else {
73        Ok(v)
74    }
75}
76fn url(v: String) -> Result<String, MetadataError> {
77    if !v.starts_with("https://") || v.chars().any(|c| c.is_control() || c.is_whitespace()) {
78        Err(MetadataError::InvalidValue)
79    } else {
80        Ok(v)
81    }
82}
83fn e(v: &str) -> String {
84    v.replace('&', "&amp;")
85        .replace('<', "&lt;")
86        .replace('>', "&gt;")
87        .replace('"', "&quot;")
88}
89#[cfg(test)]
90mod tests {
91    use super::*;
92    #[test]
93    fn renders_seo_social_and_jsonld() {
94        let m = Metadata::new()
95            .title("A & B")
96            .unwrap()
97            .description("Desc")
98            .unwrap()
99            .canonical("https://example.com")
100            .unwrap()
101            .image("https://example.com/a.png")
102            .unwrap()
103            .json_ld("{\"@type\":\"VideoObject\"}")
104            .unwrap();
105        let o = m.render();
106        assert!(o.contains("og:title"));
107        assert!(o.contains("&amp;"));
108        assert!(o.contains("application/ld+json"))
109    }
110    #[test]
111    fn rejects_invalid_metadata() {
112        assert_eq!(
113            Metadata::new().canonical("http://example.com"),
114            Err(MetadataError::InvalidValue)
115        );
116        assert_eq!(
117            Metadata::new().json_ld("[]"),
118            Err(MetadataError::InvalidValue)
119        )
120    }
121}