Merge pull request #106 from hyperium/cookies

Cookies

Cargo.toml

@@ -31,3 +31,5 @@ git = "https://github.com/carllerche/curl-rust"
 [dev-dependencies.http]
 git = "https://github.com/chris-morgan/rust-http"
 
+[dependencies.cookie]
+git = "https://github.com/alexcrichton/cookie-rs"

src/header/common/cookie.rs

@@ -0,0 +1,96 @@
+use header::{Header, HeaderFormat};
+use std::fmt::{mod, Show};
+use std::str::from_utf8;
+use std::from_str::from_str;
+
+use cookie::Cookie;
+use cookie::CookieJar;
+
+/// The `Cookie` header. Defined in [RFC6265](tools.ietf.org/html/rfc6265#section-5.4):
+///
+/// > If the user agent does attach a Cookie header field to an HTTP
+/// > request, the user agent must send the cookie-string
+/// > as the value of the header field.
+///
+/// > When the user agent generates an HTTP request, the user agent MUST NOT
+/// > attach more than one Cookie header field.
+#[deriving(Clone, PartialEq, Show)]
+pub struct Cookies(pub Vec<Cookie>);
+
+impl Header for Cookies {
+    fn header_name(_: Option<Cookies>) -> &'static str {
+        "Cookie"
+    }
+
+    fn parse_header(raw: &[Vec<u8>]) -> Option<Cookies> {
+        let mut cookies = Vec::with_capacity(raw.len());
+        for cookies_raw in raw.iter() {
+            match from_utf8(cookies_raw[]) {
+                Some(cookies_str) => {
+                    for cookie_str in cookies_str.split(';') {
+                        match from_str(cookie_str.trim()) {
+                            Some(cookie) => cookies.push(cookie),
+                            None => return None
+                        }
+                    }
+                },
+                None => return None
+            };
+        }
+
+        if !cookies.is_empty() {
+            Some(Cookies(cookies))
+        } else {
+            None
+        }
+    }
+}
+
+impl HeaderFormat for Cookies {
+    fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let cookies = &self.0;
+        let last = cookies.len() - 1;
+        for (i, cookie) in cookies.iter().enumerate() {
+            try!(cookie.pair().fmt(fmt));
+            if i < last {
+                try!("; ".fmt(fmt));
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Cookies {
+    /// This method can be used to create CookieJar that can be used
+    /// to manipulate cookies and create a corresponding `SetCookie` header afterwards.
+    pub fn to_cookie_jar(&self, key: &[u8]) -> CookieJar<'static> {
+        let mut jar = CookieJar::new(key);
+        for cookie in self.0.iter() {
+            jar.add_original((*cookie).clone());
+        }
+        jar
+    }
+}
+
+
+#[test]
+fn test_parse() {
+    let h = Header::parse_header([b"foo=bar; baz=quux".to_vec()][]);
+    let c1 = Cookie::new("foo".to_string(), "bar".to_string());
+    let c2 = Cookie::new("baz".to_string(), "quux".to_string());
+    assert_eq!(h, Some(Cookies(vec![c1, c2])));
+}
+
+#[test]
+fn test_fmt() {
+    use header::Headers;
+
+    let mut cookie = Cookie::new("foo".to_string(), "bar".to_string());
+    cookie.httponly = true;
+    cookie.path = Some("/p".to_string());
+    let cookies = Cookies(vec![cookie, Cookie::new("baz".to_string(), "quux".to_string())]);
+    let mut headers = Headers::new();
+    headers.set(cookies);
+
+    assert_eq!(headers.to_string()[], "Cookie: foo=bar; baz=quux\r\n");
+}

src/header/common/mod.rs

@@ -8,6 +8,7 @@
 
 pub use self::accept::Accept;
 pub use self::authorization::Authorization;
+pub use self::cookie::Cookies;
 pub use self::connection::Connection;
 pub use self::content_length::ContentLength;
 pub use self::content_type::ContentType;
@@ -18,6 +19,7 @@ pub use self::transfer_encoding::TransferEncoding;
 pub use self::upgrade::Upgrade;
 pub use self::user_agent::UserAgent;
 pub use self::server::Server;
+pub use self::set_cookie::SetCookie;
 
 use std::fmt::{mod, Show};
 use std::from_str::FromStr;
@@ -25,6 +27,11 @@ use std::str::from_utf8;
 
 /// Exposes the Accept header.
 pub mod accept;
+/// Exposes the Authorization header.
+pub mod authorization;
+
+/// Exposes the Cookie header.
+pub mod cookie;
 
 /// Exposes the Connection header.
 pub mod connection;
@@ -41,9 +48,15 @@ pub mod date;
 /// Exposes the Host header.
 pub mod host;
 
+/// Exposes the Location header.
+pub mod location;
+
 /// Exposes the Server header.
 pub mod server;
 
+/// Exposes the Set-Cookie header.
+pub mod set_cookie;
+
 /// Exposes the TransferEncoding header.
 pub mod transfer_encoding;
 
@@ -53,12 +66,7 @@ pub mod upgrade;
 /// Exposes the UserAgent header.
 pub mod user_agent;
 
-
-/// Exposes the Location header.
-pub mod location;
-
-/// Exposes the Authorization header.
-pub mod authorization;
+pub mod util;
 
 fn from_comma_delimited<T: FromStr>(raw: &[Vec<u8>]) -> Option<Vec<T>> {
     if raw.len() != 1 {
@@ -86,4 +94,3 @@ fn fmt_comma_delimited<T: Show>(fmt: &mut fmt::Formatter, parts: &[T]) -> fmt::R
     }
     Ok(())
 }
-pub mod util;

src/header/common/set_cookie.rs

@@ -0,0 +1,88 @@
+use header::{Header, HeaderFormat};
+use std::fmt::{mod, Show};
+use std::str::from_utf8;
+
+use cookie::Cookie;
+use cookie::CookieJar;
+
+/// The `Set-Cookie` header
+///
+/// Informally, the Set-Cookie response header contains the header name
+/// "Set-Cookie" followed by a ":" and a cookie.  Each cookie begins with
+/// a name-value-pair, followed by zero or more attribute-value pairs.
+#[deriving(Clone, PartialEq, Show)]
+pub struct SetCookie(pub Vec<Cookie>);
+
+impl Header for SetCookie {
+    fn header_name(_: Option<SetCookie>) -> &'static str {
+        "Set-Cookie"
+    }
+
+    fn parse_header(raw: &[Vec<u8>]) -> Option<SetCookie> {
+        let mut set_cookies = Vec::with_capacity(raw.len());
+        for set_cookies_raw in raw.iter() {
+            match from_utf8(set_cookies_raw[]) {
+                Some(s) if !s.is_empty() => {
+                    match from_str(s) {
+                        Some(cookie) => set_cookies.push(cookie),
+                        None => ()
+                    }
+                },
+                _ => ()
+            };
+        }
+
+        if !set_cookies.is_empty() {
+            Some(SetCookie(set_cookies))
+        } else {
+            None
+        }
+    }
+
+}
+
+impl HeaderFormat for SetCookie {
+
+    fn fmt_header(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for (i, cookie) in self.0.iter().enumerate() {
+            if i != 0 {
+                try!(f.write(b"\r\nSet-Cookie: "));
+            }
+            try!(cookie.fmt(f));
+        }
+        Ok(())
+    }
+}
+
+
+impl SetCookie {
+    /// Use this to create SetCookie header from CookieJar using
+    /// calculated delta.
+    pub fn from_cookie_jar(jar: &CookieJar) -> SetCookie {
+        SetCookie(jar.delta())
+    }
+}
+
+
+#[test]
+fn test_parse() {
+    let h = Header::parse_header([b"foo=bar; HttpOnly".to_vec()][]);
+    let mut c1 = Cookie::new("foo".to_string(), "bar".to_string());
+    c1.httponly = true;
+
+    assert_eq!(h, Some(SetCookie(vec![c1])));
+}
+
+#[test]
+fn test_fmt() {
+    use header::Headers;
+
+    let mut cookie = Cookie::new("foo".to_string(), "bar".to_string());
+    cookie.httponly = true;
+    cookie.path = Some("/p".to_string());
+    let cookies = SetCookie(vec![cookie, Cookie::new("baz".to_string(), "quux".to_string())]);
+    let mut headers = Headers::new();
+    headers.set(cookies);
+
+    assert_eq!(headers.to_string()[], "Set-Cookie: foo=bar; HttpOnly; Path=/p\r\nSet-Cookie: baz=quux; Path=/\r\n");
+}

src/lib.rs

@@ -136,6 +136,7 @@ extern crate "unsafe-any" as uany;
 extern crate "move-acceptor" as macceptor;
 extern crate intertwine;
 extern crate typeable;
+extern crate cookie;
 
 pub use std::io::net::ip::{SocketAddr, IpAddr, Ipv4Addr, Ipv6Addr, Port};
 pub use mimewrapper::mime;