ohkami 0.24.9

A performant, declarative, and runtime-flexible web framework for 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

use std::borrow::Cow;

#[derive(Clone, Debug, PartialEq)]
pub enum ETag<'header> {
    Any,
    Strong(Cow<'header, str>),
    Weak(Cow<'header, str>),
}

pub enum ETagError {
    InvalidFormat,
    InvalidCharactor,
}
impl std::fmt::Debug for ETagError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            ETagError::InvalidFormat => "InvalidFormat",
            ETagError::InvalidCharactor => "InvalidCharactor",
        })
    }
}
impl std::fmt::Display for ETagError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            ETagError::InvalidFormat => "InvalidFormat(Etag must be * or a strong/weak tag)",
            ETagError::InvalidCharactor => {
                "InvalidCharactor(Etag can only contain ASCII characters)"
            }
        })
    }
}
impl std::error::Error for ETagError {}

impl<'header> ETag<'header> {
    pub fn serialize(&self) -> Cow<'static, str> {
        match self {
            ETag::Any => Cow::Borrowed("*"),
            ETag::Strong(value) => Cow::Owned(format!("\"{value}\"")),
            ETag::Weak(value) => Cow::Owned(format!("W/\"{value}\"")),
        }
    }

    /// Parse a single ETag.
    pub fn parse(mut raw: &'header str) -> Result<Self, ETagError> {
        if raw == "*" {
            Ok(ETag::Any)
        } else {
            let is_weak = raw.starts_with("W/");
            if is_weak {
                raw = &raw[2..];
            }

            raw = (raw.len() >= 2 && raw.starts_with('"') && raw.ends_with('"'))
                .then(|| &raw[1..raw.len() - 1])
                .ok_or(ETagError::InvalidFormat)?;

            if !raw.is_ascii() {
                return Err(ETagError::InvalidCharactor);
            }

            Ok(if is_weak {
                ETag::Weak(Cow::Borrowed(raw))
            } else {
                ETag::Strong(Cow::Borrowed(raw))
            })
        }
    }

    /// Parse comma-separated ETags into an iterator of `Result<ETag, ETagError>`.
    /// Invalid ETag is returned as `Err`.
    pub fn try_iter_from(
        raw: &'header str,
    ) -> impl Iterator<Item = Result<Self, ETagError>> + 'header {
        raw.split(", ").map(ETag::parse)
    }

    /// Parse comma-separated ETags into an iterator of `ETag`.
    /// Invalid ETag is just ignored.
    ///
    /// ## Example
    ///
    /// ```
    /// use ohkami::header::ETag;
    ///
    /// # fn main() {
    /// let mut etags = ETag::iter_from(
    ///     r#""abc123", W/"def456", "ghi789""#
    /// );
    ///
    /// assert_eq!(etags.next(), Some(ETag::Strong("abc123".into())));
    /// assert_eq!(etags.next(), Some(ETag::Weak("def456".into())));
    /// assert_eq!(etags.next(), Some(ETag::Strong("ghi789".into())));
    /// assert_eq!(etags.next(), None);
    ///
    /// let mut etags = ETag::iter_from("*");
    /// assert_eq!(etags.next(), Some(ETag::Any));
    /// assert_eq!(etags.next(), None);
    /// # }
    /// ```
    pub fn iter_from(raw: &'header str) -> impl Iterator<Item = Self> + 'header {
        raw.split(", ").filter_map(|it| ETag::parse(it).ok())
    }

    pub fn matches(&self, other: &ETag<'_>) -> bool {
        match (self, other) {
            (ETag::Any, _) | (_, ETag::Any) => true,
            (ETag::Strong(a), ETag::Strong(b))
            | (ETag::Strong(a), ETag::Weak(b))
            | (ETag::Weak(a), ETag::Strong(b))
            | (ETag::Weak(a), ETag::Weak(b)) => a == b,
        }
    }

    pub fn into_owned(self) -> ETag<'static> {
        match self {
            ETag::Any => ETag::Any,
            ETag::Strong(cow) => ETag::Strong(Cow::Owned(cow.into_owned())),
            ETag::Weak(cow) => ETag::Weak(Cow::Owned(cow.into_owned())),
        }
    }
}

impl ETag<'static> {
    pub fn new(value: String) -> Result<Self, ETagError> {
        value
            .is_ascii()
            .then_some(Self::Strong(value.into()))
            .ok_or(ETagError::InvalidCharactor)
    }
}