poet 0.7.0

Static site generator with optional MCP server and LLM SEO optimizations
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

use actix_web::HttpRequest;
use actix_web::error::ParseError;
use actix_web::http::header::Accept;
use actix_web::http::header::Header as _;
use mime::Mime;

pub enum Conclusion {
    AllAcceptable,
    ErrorParsingHeader(ParseError),
    NotAllAcceptable,
}

fn accepts(choices: &[Mime], mime: Mime) -> bool {
    for choice in choices {
        match choice.type_() {
            mime::STAR => return true,
            type_ => {
                if type_ == mime.type_() {
                    match choice.subtype() {
                        mime::STAR => return true,
                        subtype => {
                            if subtype == mime.subtype() {
                                return true;
                            }
                        }
                    }
                }
            }
        }
    }

    false
}

pub fn accepts_all(req: &HttpRequest, mimes: Vec<Mime>) -> Conclusion {
    match Accept::parse(req) {
        Ok(accept) => {
            let ranked = accept.ranked();

            for mime in mimes {
                if !accepts(&ranked, mime) {
                    return Conclusion::NotAllAcceptable;
                }
            }

            Conclusion::AllAcceptable
        }
        Err(err) => Conclusion::ErrorParsingHeader(err),
    }
}

#[cfg(test)]
mod tests {
    use actix_web::http::header::ACCEPT;
    use actix_web::http::header::HeaderValue;
    use actix_web::test::TestRequest;
    use anyhow::Result;

    use super::*;

    #[test]
    fn accepts_mime() -> Result<()> {
        assert!(accepts(
            &["image/something".parse()?, "text/*".parse()?,],
            "text/event-stream".parse()?
        ));
        assert!(accepts(&["*/*".parse()?,], "text/event-stream".parse()?));

        Ok(())
    }

    #[test]
    fn does_not_accept_mime() -> Result<()> {
        assert!(!accepts(&["text/*".parse()?,], "something/else".parse()?));

        Ok(())
    }

    #[test]
    fn all_requested_mimes_are_acceptable() -> Result<()> {
        let request = TestRequest::default()
            .insert_header((ACCEPT, "text/*"))
            .to_http_request();

        assert!(matches!(
            accepts_all(&request, vec!["text/event-stream".parse()?]),
            Conclusion::AllAcceptable
        ));

        Ok(())
    }

    #[test]
    fn rejects_when_a_requested_mime_is_not_acceptable() -> Result<()> {
        let request = TestRequest::default()
            .insert_header((ACCEPT, "text/plain"))
            .to_http_request();

        assert!(matches!(
            accepts_all(&request, vec!["application/json".parse()?]),
            Conclusion::NotAllAcceptable
        ));

        Ok(())
    }

    #[test]
    fn reports_header_parse_error_for_invalid_accept_header() -> Result<()> {
        let request = TestRequest::default()
            .insert_header((ACCEPT, HeaderValue::from_bytes(&[0xff])?))
            .to_http_request();

        assert!(matches!(
            accepts_all(&request, vec!["text/event-stream".parse()?]),
            Conclusion::ErrorParsingHeader(_)
        ));

        Ok(())
    }
}