zeke 0.1.6

a http library for rust built on top of tokio
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 time::{OffsetDateTime, macros::format_description};

#[derive(Debug, Clone)]
pub struct CookieJar {
    pub cookies: Vec<Cookie>,
}

impl CookieJar {
    pub fn new() -> CookieJar {
        CookieJar {
            cookies: Vec::new(),
        }
    }
    pub fn add(&mut self, cookie: Cookie) {
        self.cookies.push(cookie);
    }
    pub fn get(&self, name: &str) -> Option<&Cookie> {
        self.cookies.iter().find(|cookie| cookie.name == name)
    }
    pub fn remove(&mut self, name: &str) {
        self.cookies.retain(|cookie| cookie.name != name);
    }
    pub fn to_string(&self) -> String {
        self.cookies.iter().map(|cookie| cookie.to_string()).collect::<Vec<String>>().join("; ")
    }
}

#[derive(Debug, Clone)]
pub struct Cookie {
    pub name: String,
    pub value: String,
    pub expires: Option<OffsetDateTime>,
    pub max_age: Option<u64>,
    pub domain: Option<String>,
    pub path: Option<String>,
    pub secure: bool,
    pub http_only: bool,
    pub same_site: Option<String>,
}

impl Cookie {
    pub fn new(name: &str, value: &str) -> Cookie {
        Cookie {
            name: name.to_string(),
            value: value.to_string(),
            expires: None,
            max_age: None,
            domain: None,
            path: None,
            secure: false,
            http_only: false,
            same_site: None,
        }
    }

    pub fn expires(mut self, expires: OffsetDateTime) -> Cookie {
        self.expires = Some(expires);
        self
    }

    pub fn max_age(mut self, max_age: u64) -> Cookie {
        self.max_age = Some(max_age);
        self
    }

    pub fn domain(mut self, domain: &str) -> Cookie {
        self.domain = Some(domain.to_string());
        self
    }

    pub fn path(mut self, path: &str) -> Cookie {
        self.path = Some(path.to_string());
        self
    }

    pub fn secure(mut self, secure: bool) -> Cookie {
        self.secure = secure;
        self
    }

    pub fn http_only(mut self, http_only: bool) -> Cookie {
        self.http_only = http_only;
        self
    }

    pub fn same_site(mut self, same_site: &str) -> Cookie {
        self.same_site = Some(same_site.to_string());
        self
    }

    fn format_expires(expires: &OffsetDateTime) -> String {
        // Format following: "Wdy, DD Mon YYYY HH:MM:SS GMT"
        let format = format_description!("[weekday repr:short], [day] [month repr:short] [year] [hour]:[minute]:[second] GMT");
        expires.format(&format).unwrap()
    }

    pub fn to_string(&self) -> String {
        let mut cookie = format!("{}={}", self.name, self.value);

        if let Some(expires) = &self.expires {
            cookie.push_str(&format!("; Expires={}", Cookie::format_expires(expires)));
        }

        if let Some(max_age) = &self.max_age {
            cookie.push_str(&format!("; Max-Age={}", max_age));
        }

        if let Some(domain) = &self.domain {
            cookie.push_str(&format!("; Domain={}", domain));
        }

        if let Some(path) = &self.path {
            cookie.push_str(&format!("; Path={}", path));
        }

        if self.secure {
            cookie.push_str("; Secure");
        }

        if self.http_only {
            cookie.push_str("; HttpOnly");
        }

        if let Some(same_site) = &self.same_site {
            cookie.push_str(&format!("; SameSite={}", same_site));
        }

        cookie
    }
}