From 72d4e44a125c50f71a570740189c692f099c3e8d Mon Sep 17 00:00:00 2001 From: Bastien Orivel Date: Wed, 5 Sep 2018 21:40:20 +0200 Subject: [PATCH] WIP hyper 0.12 --- Cargo.toml | 8 ++--- src/lib.rs | 90 ++++++++++++++++++++++++++++++++++++++++++------------ 2 files changed, 74 insertions(+), 24 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index f9ce2b7..6234382 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,16 +16,16 @@ travis-ci = { repository = "nox/hyper_serde" } doctest = false [dependencies] -cookie = {version = "0.10", default-features = false} -hyper = { version = "0.11", features = ["raw_status"] } +cookie = {version = "0.11", default-features = false} +http = "0.1" +hyper = { version = "0.12" } mime = "0.3" serde = "1.0" serde_bytes = "0.10" time = "0.1" +typed-headers = "0.1" [dev-dependencies] serde_test = "1.0" time = "0.1" -[replace] -"hyper:0.11.2" = { git = "https://github.com/hyperium/hyper.git" } diff --git a/src/lib.rs b/src/lib.rs index f6c6f71..054e172 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -4,7 +4,7 @@ //! The supported types are: //! //! * `cookie::Cookie` -//! * `hyper::header::ContentType` +//! * `typed_headers::ContentType` //! * `hyper::header::Headers` //! * `hyper::RawStatus` //! * `hyper::Method` @@ -54,25 +54,30 @@ #![deny(unsafe_code)] extern crate cookie; +extern crate http; extern crate hyper; extern crate mime; extern crate serde; extern crate serde_bytes; extern crate time; +extern crate typed_headers; use cookie::Cookie; -use hyper::header::{ContentType, Headers}; -use hyper::RawStatus; +use typed_headers::ContentType; +use hyper::StatusCode; +use hyper::header::{HeaderName, HeaderValue}; +use http::HeaderMap; use hyper::Method; use mime::Mime; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use serde_bytes::{ByteBuf, Bytes}; -use serde::de::{self, MapAccess, SeqAccess, Visitor}; +use serde::de::{self, MapAccess, SeqAccess, Visitor, Error}; use serde::ser::{SerializeMap, SerializeSeq}; use std::cmp; use std::fmt; use std::ops::{Deref, DerefMut}; use std::str; +use std::str::FromStr; use time::{Tm, strptime}; /// Deserialises a `T` value with a given deserializer. @@ -309,14 +314,15 @@ impl<'a, 'cookie> Serialize for Ser<'a, Cookie<'cookie>> { } } -impl<'de> Deserialize<'de> for De { + +impl<'de> Deserialize<'de> for De { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { struct HeadersVisitor; impl<'de> Visitor<'de> for HeadersVisitor { - type Value = De; + type Value = De; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { write!(formatter, "a map from header names to header values") @@ -325,7 +331,7 @@ impl<'de> Deserialize<'de> for De { fn visit_unit(self) -> Result where E: de::Error, { - Ok(De::new(Headers::new())) + Ok(De::new(HeaderMap::new())) } fn visit_map(self, @@ -333,9 +339,11 @@ impl<'de> Deserialize<'de> for De { -> Result where V: MapAccess<'de>, { - let mut headers = Headers::new(); - while let Some((k, v)) = visitor.next_entry::()? { - headers.set_raw(k, v.0); + let mut headers = HeaderMap::new(); + while let Some((k, values)) = visitor.next_entry::()? { + for v in values.0.iter() { + headers.insert(HeaderName::from_str(&k).map_err(V::Error::custom)?, HeaderValue::from_bytes(&v).map_err(V::Error::custom)?); + } } Ok(De::new(headers)) } @@ -383,7 +391,7 @@ impl<'de> Deserialize<'de> for De { } } -impl<'a> Serialize for Ser<'a, Headers> { +impl<'a> Serialize for Ser<'a, HeaderMap> { fn serialize(&self, serializer: S) -> Result where S: Serializer, { @@ -409,10 +417,9 @@ impl<'a> Serialize for Ser<'a, Headers> { } let mut serializer = serializer.serialize_map(Some(self.v.len()))?; - for header in self.v.iter() { - let name = header.name(); - let value = self.v.get_raw(name).unwrap(); - serializer.serialize_entry(name, &Value(&value.iter().map(|v| v.to_vec()).collect::>>(), self.pretty))?; + for name in self.v.keys() { + let values = self.v.get_all(name); + serializer.serialize_entry(name.as_str(), &Value(&values.iter().map(|v| v.as_bytes().iter().cloned().collect()).collect::>>(), self.pretty))?; } serializer.end() } @@ -484,20 +491,63 @@ impl<'a> Serialize for Ser<'a, Mime> { } } -impl<'de> Deserialize<'de> for De { +impl<'de> Deserialize<'de> for De { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { - let (code, reason) = Deserialize::deserialize(deserializer)?; - Ok(De::new(RawStatus(code, reason))) + let code = Deserialize::deserialize(deserializer)?; + Ok(De::new(StatusCode::from_u16(code).map_err(D::Error::custom)?)) + } +} + +impl<'a> Serialize for Ser<'a, StatusCode> { + fn serialize(&self, serializer: S) -> Result + where S: Serializer, + { + self.v.as_u16().serialize(serializer) } } -impl<'a> Serialize for Ser<'a, RawStatus> { +impl<'a> Serialize for Ser<'a, (StatusCode, String)> { fn serialize(&self, serializer: S) -> Result where S: Serializer, { - (self.v.0, &self.v.1).serialize(serializer) + let mut serializer = serializer.serialize_seq(Some(2))?; + serializer.serialize_element(&Ser::new(&self.v.0))?; + serializer.serialize_element(&self.v.1)?; + serializer.end() + } +} + +impl<'de> Deserialize<'de> for De<(StatusCode, String)> { + fn deserialize(deserializer: D) -> Result + where D: Deserializer<'de>, + { + Ok(De::new(deserializer.deserialize_seq(StatusVisitor)?)) + } +} + +struct StatusVisitor; + +impl<'de> Visitor<'de> for StatusVisitor { + type Value = (StatusCode, String); + + fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + write!(formatter, "an array containing a status code and a reason string") + } + + fn visit_seq(self, mut visitor: V) -> Result + where V: SeqAccess<'de>, + { + + let code = visitor.next_element::()?.ok_or_else(|| + V::Error::custom("Can't find the status code") + )?; + let code = StatusCode::from_u16(code).map_err(V::Error::custom)?; + let reason = visitor.next_element::()?.ok_or_else(|| + V::Error::custom("Can't find the reason string") + )?; + Ok((code, reason)) } }