feat(headers): adds Accept

Moved utils to shared/. Added quality_value.

src/header/common/accept.rs

@@ -1,7 +1,9 @@
-use header::{Header, HeaderFormat};
-use std::fmt::{mod, Show};
-use std::str::from_utf8;
-use mime::Mime;
+use std::fmt;
+
+use header;
+use header::shared;
+
+use mime;
 
 /// The `Accept` header.
 ///
@@ -14,60 +16,53 @@ use mime::Mime;
 /// ```
 /// # use hyper::header::Headers;
 /// # use hyper::header::common::Accept;
+/// # use hyper::header::shared::qitem;
 /// use hyper::mime::Mime;
 /// use hyper::mime::TopLevel::Text;
 /// use hyper::mime::SubLevel::{Html, Xml};
 /// # let mut headers = Headers::new();
-/// headers.set(Accept(vec![ Mime(Text, Html, vec![]), Mime(Text, Xml, vec![]) ]));
+/// headers.set(Accept(vec![
+///     qitem(Mime(Text, Html, vec![])),
+///     qitem(Mime(Text, Xml, vec![])) ]));
 /// ```
 #[deriving(Clone, PartialEq, Show)]
-pub struct Accept(pub Vec<Mime>);
+pub struct Accept(pub Vec<shared::QualityItem<mime::Mime>>);
 
-deref!(Accept -> Vec<Mime>);
+deref!(Accept -> Vec<shared::QualityItem<mime::Mime>>);
 
-impl Header for Accept {
+impl header::Header for Accept {
     fn header_name(_: Option<Accept>) -> &'static str {
         "Accept"
     }
 
     fn parse_header(raw: &[Vec<u8>]) -> Option<Accept> {
-        let mut mimes: Vec<Mime> = vec![];
-        for mimes_raw in raw.iter() {
-            match from_utf8(mimes_raw.as_slice()) {
-                Ok(mimes_str) => {
-                    for mime_str in mimes_str.split(',') {
-                        match mime_str.trim().parse() {
-                            Some(mime) => mimes.push(mime),
-                            None => return None
-                        }
-                    }
-                },
-                Err(_) => return None
-            };
-        }
-
-        if !mimes.is_empty() {
-            Some(Accept(mimes))
-        } else {
-            // Currently is just a None, but later it can be Accept for */*
-            None
-        }
+        // TODO: Return */* if no value is given.
+        shared::from_comma_delimited(raw).map(Accept)
     }
 }
 
-impl HeaderFormat for Accept {
+impl header::HeaderFormat for Accept {
     fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let Accept(ref value) = *self;
-        let last = value.len() - 1;
-        for (i, mime) in value.iter().enumerate() {
-            try!(mime.fmt(fmt));
-            if i < last {
-                try!(", ".fmt(fmt));
-            }
-        }
-        Ok(())
+        shared::fmt_comma_delimited(fmt, self[])
     }
 }
 
 bench_header!(bench, Accept, { vec![b"text/plain; q=0.5, text/html".to_vec()] });
 
+#[test]
+fn test_parse_header_no_quality() {
+    let a: Accept = header::Header::parse_header([b"text/plain; charset=utf-8".to_vec()].as_slice()).unwrap();
+    let b = Accept(vec![
+        shared::QualityItem{item: mime::Mime(mime::TopLevel::Text, mime::SubLevel::Plain, vec![(mime::Attr::Charset, mime::Value::Utf8)]), quality: 1f32},
+    ]);
+    assert_eq!(a, b);
+}
+
+#[test]
+fn test_parse_header_with_quality() {
+    let a: Accept = header::Header::parse_header([b"text/plain; charset=utf-8; q=0.5".to_vec()].as_slice()).unwrap();
+    let b = Accept(vec![
+        shared::QualityItem{item: mime::Mime(mime::TopLevel::Text, mime::SubLevel::Plain, vec![(mime::Attr::Charset, mime::Value::Utf8)]), quality: 0.5f32},
+    ]);
+    assert_eq!(a, b);
+}