forked/hyper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #332 from pyfisch/improvquality

Browse Source 
refactor(headers): Use u16 based newtype for quality value
This commit is contained in:
Sean McArthur
2015-02-28 23:12:58 -05:00
parent b1b8bf1db7 8f6ce453de
commit 7235d3f74a
6 changed files with 202 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/header/common/accept.rs
View File

@@ -33,7 +33,8 @@ impl_list_header!(Accept,
mod tests {
use mime::*;
use header::{Header, QualityItem, qitem};
use header::{Header, Quality, QualityItem, qitem};
use super::Accept;
#[test]
@@ -49,7 +50,7 @@ mod tests {
fn test_parse_header_with_quality() {
let a: Accept = Header::parse_header([b"text/plain; charset=utf-8; q=0.5".to_vec()].as_slice()).unwrap();
let b = Accept(vec![
QualityItem::new(Mime(TopLevel::Text, SubLevel::Plain, vec![(Attr::Charset, Value::Utf8)]), 0.5f32),
QualityItem::new(Mime(TopLevel::Text, SubLevel::Plain, vec![(Attr::Charset, Value::Utf8)]), Quality(500)),
]);
assert_eq!(a, b);
}

6
src/header/common/accept_encoding.rs
View File

@@ -13,7 +13,7 @@ impl_list_header!(AcceptEncoding,
#[cfg(test)]
mod tests {
use header::{Encoding, Header, QualityItem};
use header::{Encoding, Header, qitem, Quality, QualityItem};
use super::*;
@@ -21,8 +21,8 @@ mod tests {
fn test_parse_header() {
let a: AcceptEncoding = Header::parse_header([b"gzip;q=1.0, identity; q=0.5".to_vec()].as_slice()).unwrap();
let b = AcceptEncoding(vec![
QualityItem{item: Encoding::Gzip, quality: 1f32},
QualityItem{item: Encoding::Identity, quality: 0.5f32},
qitem(Encoding::Gzip),
QualityItem::new(Encoding::Identity, Quality(500)),
]);
assert_eq!(a, b);
}

40
src/header/common/accept_language.rs
View File

@@ -46,41 +46,45 @@ impl_list_header!(AcceptLanguage,
"Accept-Language",
Vec<QualityItem<Language>>);
bench_header!(bench, AcceptLanguage,
{ vec![b"en-us;q=1.0, en;q=0.5, fr".to_vec()] });
#[cfg(test)]
mod tests {
use header::{Header, qitem, Quality, QualityItem};
#[test]
fn test_parse_header() {
let a: AcceptLanguage = header::Header::parse_header(
use super::*;
#[test]
fn test_parse_header() {
let a: AcceptLanguage = Header::parse_header(
[b"en-us;q=1.0, en;q=0.5, fr".to_vec()].as_slice()).unwrap();
let b = AcceptLanguage(vec![
QualityItem { item: Language{primary: "en".to_string(),
sub: Some("us".to_string())},
quality: 1f32 },
QualityItem { item: Language{primary: "en".to_string(), sub: None},
quality: 0.5f32 },
QualityItem { item: Language{primary: "fr".to_string(), sub: None},
quality: 1f32 },
qitem(Language{primary: "en".to_string(), sub: Some("us".to_string())}),
QualityItem::new(Language{primary: "en".to_string(), sub: None},
Quality(500)),
qitem(Language{primary: "fr".to_string(), sub: None}),
]);
assert_eq!(format!("{}", a), format!("{}", b));
assert_eq!(a, b);
}
}
#[test]
fn test_display() {
#[test]
fn test_display() {
assert_eq!("en".to_string(),
format!("{}", Language{primary: "en".to_string(),
sub: None}));
assert_eq!("en-us".to_string(),
format!("{}", Language{primary: "en".to_string(),
sub: Some("us".to_string())}));
}
}
#[test]
fn test_from_str() {
#[test]
fn test_from_str() {
assert_eq!(Language { primary: "en".to_string(), sub: None },
"en".parse().unwrap());
assert_eq!(Language { primary: "en".to_string(),
sub: Some("us".to_string()) },
"en-us".parse().unwrap());
}
}
bench_header!(bench, AcceptLanguage,
{ vec![b"en-us;q=1.0, en;q=0.5, fr".to_vec()] });

6
src/header/mod.rs
View File

@@ -21,7 +21,7 @@ use unicase::UniCase;
use self::cell::OptCell;
use {http, HttpResult, HttpError};
pub use self::shared::{Encoding, EntityTag, QualityItem, qitem};
pub use self::shared::{Encoding, EntityTag, Quality, QualityItem, qitem};
pub use self::common::*;
mod cell;
@@ -540,7 +540,7 @@ mod tests {
use mime::TopLevel::Text;
use mime::SubLevel::Plain;
use super::{Headers, Header, HeaderFormat, ContentLength, ContentType,
Accept, Host, QualityItem};
Accept, Host, qitem};
use test::Bencher;
@@ -562,7 +562,7 @@ mod tests {
#[test]
fn test_accept() {
let text_plain = QualityItem{item: Mime(Text, Plain, vec![]), quality: 1f32};
let text_plain = qitem(Mime(Text, Plain, vec![]));
let application_vendor = "application/vnd.github.v3.full+json; q=0.5".parse().unwrap();
let accept = Header::parse_header([b"text/plain".to_vec()].as_slice());

2
src/header/shared/mod.rs
View File

@@ -1,6 +1,6 @@
pub use self::encoding::Encoding;
pub use self::entity::EntityTag;
pub use self::quality_item::{QualityItem, qitem};
pub use self::quality_item::{Quality, QualityItem, qitem};
mod encoding;
mod entity;

185
src/header/shared/quality_item.rs
View File

@@ -3,10 +3,79 @@
//! [RFC7231 Section 5.3.1](https://tools.ietf.org/html/rfc7231#section-5.3.1)
//! gives more information on quality values in HTTP header fields.
use std::fmt;
use std::str;
use std::cmp;
#[cfg(test)] use super::encoding::*;
use std::default::Default;
use std::fmt;
use std::num::{FromPrimitive, ToPrimitive};
use std::str;
/// Represents a quality used in quality values.
///
/// `Quality` should only be created using the `FromPrimitve` trait methods `from_f32` and
/// `from_f64`, they take a value between 0.0 and 1.0. To create a quality with the value 1.0, the
/// default you can use `let q: Quality = Default::default()`.
///
/// # Implementation notes
/// The quality value is defined as a number between 0 and 1 with three decimal places. This means
/// there are 1000 possible values. Since floating point numbers are not exact and the smallest
/// floating point data type (`f32`) consumes four bytes, hyper uses an `u16` value to store the
/// quality internally. For performance reasons you may set quality directly to a value between
/// 0 and 1000 e.g. `Quality(532)` matches the quality `q=0.532`.
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Quality(pub u16);
impl fmt::Display for Quality {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.0 == 1000 {
write!(f, "")
} else {
write!(f, "; q=0.{}", format!("{:03}", self.0).trim_right_matches('0'))
}
}
}
impl FromPrimitive for Quality {
fn from_i64(n: i64) -> Option<Quality> {
match n >= 0 {
true => FromPrimitive::from_u64(n as u64),
false => None,
}
}
fn from_u64(n: u64) -> Option<Quality> {
match n <= 1000 {
true => Some(Quality(n as u16)),
false => None,
}
}
fn from_f64(n: f64) -> Option<Quality> {
match n >= 0f64 && n <= 1f64 {
true => Some(Quality((n * 1000f64) as u16)),
false => None,
}
}
}
impl ToPrimitive for Quality {
fn to_i64(&self) -> Option<i64> {
Some(self.0 as i64)
}
fn to_u64(&self) -> Option<u64> {
Some(self.0 as u64)
}
fn to_f64(&self) -> Option<f64> {
Some((self.0 as f64) / 1000f64)
}
}
impl Default for Quality {
fn default() -> Quality {
Quality(1000)
}
}
/// Represents an item with a quality value as defined in
/// [RFC7231](https://tools.ietf.org/html/rfc7231#section-5.3.1).
@@ -15,14 +84,14 @@ pub struct QualityItem<T> {
/// The actual contents of the field.
pub item: T,
/// The quality (client or server preference) for the value.
pub quality: f32,
pub quality: Quality,
}
impl<T> QualityItem<T> {
/// Creates a new `QualityItem` from an item and a quality.
/// The item can be of any type.
/// The quality should be a value in the range [0, 1].
pub fn new(item: T, quality: f32) -> QualityItem<T> {
pub fn new(item: T, quality: Quality) -> QualityItem<T> {
QualityItem{item: item, quality: quality}
}
}
@@ -35,12 +104,7 @@ impl<T: PartialEq> cmp::PartialOrd for QualityItem<T> {
impl<T: fmt::Display> fmt::Display for QualityItem<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.quality == 1.0 {
write!(f, "{}", self.item)
} else {
write!(f, "{}; q={}", self.item,
format!("{:.3}", self.quality).trim_right_matches(&['0', '.'][..]))
}
write!(f, "{}{}", self.item, format!("{}", self.quality))
}
}
@@ -59,8 +123,7 @@ impl<T: str::FromStr> str::FromStr for QualityItem<T> {
if q_part.len() > 5 {
return Err(());
}
let x: Result<f32, _> = q_part.parse();
match x {
match q_part.parse::<f32>() {
Ok(q_value) => {
if 0f32 <= q_value && q_value <= 1f32 {
quality = q_value;
@@ -73,11 +136,8 @@ impl<T: str::FromStr> str::FromStr for QualityItem<T> {
}
}
}
let x: Result<T, _> = raw_item.parse();
match x {
Ok(item) => {
Ok(QualityItem{ item: item, quality: quality, })
},
match raw_item.parse::<T>() {
Ok(item) => Ok(QualityItem::new(item, FromPrimitive::from_f32(quality).unwrap())),
Err(_) => return Err(()),
}
}
@@ -86,58 +146,81 @@ impl<T: str::FromStr> str::FromStr for QualityItem<T> {
/// Convinience function to wrap a value in a `QualityItem`
/// Sets `q` to the default 1.0
pub fn qitem<T>(item: T) -> QualityItem<T> {
QualityItem::new(item, 1.0)
QualityItem::new(item, Default::default())
}
#[test]
fn test_quality_item_show1() {
#[cfg(test)]
mod tests {
use std::num::FromPrimitive;
use super::*;
use super::super::encoding::*;
#[test]
fn test_quality_item_show1() {
let x = qitem(Chunked);
assert_eq!(format!("{}", x), "chunked");
}
#[test]
fn test_quality_item_show2() {
let x = QualityItem::new(Chunked, 0.001);
}
#[test]
fn test_quality_item_show2() {
let x = QualityItem::new(Chunked, Quality(1));
assert_eq!(format!("{}", x), "chunked; q=0.001");
}
#[test]
fn test_quality_item_show3() {
}
#[test]
fn test_quality_item_show3() {
// Custom value
let x = QualityItem{
item: EncodingExt("identity".to_string()),
quality: 0.5f32,
quality: Quality(500),
};
assert_eq!(format!("{}", x), "identity; q=0.5");
}
}
#[test]
fn test_quality_item_from_str1() {
#[test]
fn test_quality_item_from_str1() {
let x: Result<QualityItem<Encoding>, ()> = "chunked".parse();
assert_eq!(x.unwrap(), QualityItem{ item: Chunked, quality: 1f32, });
}
#[test]
fn test_quality_item_from_str2() {
assert_eq!(x.unwrap(), QualityItem{ item: Chunked, quality: Quality(1000), });
}
#[test]
fn test_quality_item_from_str2() {
let x: Result<QualityItem<Encoding>, ()> = "chunked; q=1".parse();
assert_eq!(x.unwrap(), QualityItem{ item: Chunked, quality: 1f32, });
}
#[test]
fn test_quality_item_from_str3() {
assert_eq!(x.unwrap(), QualityItem{ item: Chunked, quality: Quality(1000), });
}
#[test]
fn test_quality_item_from_str3() {
let x: Result<QualityItem<Encoding>, ()> = "gzip; q=0.5".parse();
assert_eq!(x.unwrap(), QualityItem{ item: Gzip, quality: 0.5f32, });
}
#[test]
fn test_quality_item_from_str4() {
assert_eq!(x.unwrap(), QualityItem{ item: Gzip, quality: Quality(500), });
}
#[test]
fn test_quality_item_from_str4() {
let x: Result<QualityItem<Encoding>, ()> = "gzip; q=0.273".parse();
assert_eq!(x.unwrap(), QualityItem{ item: Gzip, quality: 0.273f32, });
}
#[test]
fn test_quality_item_from_str5() {
assert_eq!(x.unwrap(), QualityItem{ item: Gzip, quality: Quality(273), });
}
#[test]
fn test_quality_item_from_str5() {
let x: Result<QualityItem<Encoding>, ()> = "gzip; q=0.2739999".parse();
assert_eq!(x, Err(()));
}
#[test]
fn test_quality_item_ordering() {
}
#[test]
fn test_quality_item_ordering() {
let x: QualityItem<Encoding> = "gzip; q=0.5".parse().ok().unwrap();
let y: QualityItem<Encoding> = "gzip; q=0.273".parse().ok().unwrap();
let comparision_result: bool = x.gt(&y);
assert_eq!(comparision_result, true)
}
#[test]
fn test_quality() {
assert_eq!(Some(Quality(421)), FromPrimitive::from_f64(0.421f64));
assert_eq!(Some(Quality(421)), FromPrimitive::from_f32(0.421f32));
assert_eq!(Some(Quality(421)), FromPrimitive::from_i16(421i16));
assert_eq!(Some(Quality(421)), FromPrimitive::from_i32(421i32));
assert_eq!(Some(Quality(421)), FromPrimitive::from_i64(421i64));
assert_eq!(Some(Quality(421)), FromPrimitive::from_u16(421u16));
assert_eq!(Some(Quality(421)), FromPrimitive::from_u32(421u32));
assert_eq!(Some(Quality(421)), FromPrimitive::from_u64(421u64));
assert_eq!(None::<Quality>, FromPrimitive::from_i16(-5i16));
assert_eq!(None::<Quality>, FromPrimitive::from_i32(5000i32));
assert_eq!(None::<Quality>, FromPrimitive::from_f32(2.5f32));
}
}