http-types and async-h1 2.0.0

Cargo.toml

@@ -32,12 +32,11 @@ unstable = []
 __internal__bench = []
 
 [dependencies]
-async-h1 = { version = "1.1.2", optional = true }
+async-h1 = { version = "2.0.0", optional = true }
 async-sse = "2.1.0"
-async-std = { version = "1.4.0", features = ["unstable"] }
-cookie = { version = "0.12.0", features = ["percent-encode"]}
+async-std = { version = "1.6.0", features = ["unstable"] }
 femme = "2.0.1"
-http-types = "1.0.1"
+http-types = "2.0.0"
 kv-log-macro = "1.0.4"
 mime = "0.3.14"
 mime_guess = "2.0.3"
@@ -47,12 +46,12 @@ serde_json = "1.0.41"
 serde_qs = "0.5.0"
 
 [dev-dependencies]
-async-std = { version = "1.4.0", features = ["unstable", "attributes"] }
+async-std = { version = "1.6.0", features = ["unstable", "attributes"] }
 juniper = "0.14.1"
 portpicker = "0.1.0"
 serde = { version = "1.0.102", features = ["derive"] }
-surf = "2.0.0-alpha.1"
 criterion = "0.3.1"
+surf = { version = "2.0.0-alpha.2", default-features = false, features = ["h1-client"] }
 
 [[test]]
 name = "nested"

examples/graphql.rs

@@ -95,7 +95,7 @@ async fn handle_graphql(mut cx: Request<State>) -> tide::Result {
 async fn handle_graphiql(_: Request<State>) -> tide::Result {
     let res = Response::new(StatusCode::Ok)
         .body_string(juniper::http::graphiql::graphiql_source("/graphql"))
-        .set_header("content-type".parse().unwrap(), "text/html;charset=utf-8");
+        .set_mime(mime::TEXT_HTML_UTF_8);
     Ok(res)
 }
 

src/cookies/middleware.rs

@@ -13,11 +13,12 @@ use std::sync::{Arc, RwLock};
 ///
 /// ```
 /// # use tide::{Request, Response, StatusCode};
+/// # use tide::http::cookies::Cookie;
 /// let mut app = tide::Server::new();
 /// app.at("/get").get(|cx: Request<()>| async move { Ok(cx.cookie("testCookie").unwrap().value().to_string()) });
 /// app.at("/set").get(|_| async {
 ///     let mut res = Response::new(StatusCode::Ok);
-///     res.set_cookie(cookie::Cookie::new("testCookie", "NewCookieValue"));
+///     res.set_cookie(Cookie::new("testCookie", "NewCookieValue"));
 ///     Ok(res)
 /// });
 /// ```
@@ -38,13 +39,13 @@ impl<State: Send + Sync + 'static> Middleware<State> for CookiesMiddleware {
         next: Next<'a, State>,
     ) -> BoxFuture<'a, crate::Result> {
         Box::pin(async move {
-            let cookie_jar = if let Some(cookie_data) = ctx.local::<CookieData>() {
+            let cookie_jar = if let Some(cookie_data) = ctx.ext::<CookieData>() {
                 cookie_data.content.clone()
             } else {
                 let cookie_data = CookieData::from_request(&ctx);
-                // no cookie data in local context, so we try to create it
+                // no cookie data in ext context, so we try to create it
                 let content = cookie_data.content.clone();
-                ctx = ctx.set_local(cookie_data);
+                ctx = ctx.set_ext(cookie_data);
                 content
             };
 

src/redirect.rs

@@ -16,6 +16,7 @@
 //! # Ok(()) }) }
 //! ```
 
+use crate::http::headers::LOCATION;
 use crate::utils::BoxFuture;
 use crate::StatusCode;
 use crate::{Endpoint, Request, Response};
@@ -103,6 +104,6 @@ impl<T: AsRef<str>> Into<Response> for Redirect<T> {
 
 impl<T: AsRef<str>> Into<Response> for &Redirect<T> {
     fn into(self) -> Response {
-        Response::new(self.status).set_header("location".parse().unwrap(), &self.location)
+        Response::new(self.status).set_header(LOCATION, self.location.as_ref())
     }
 }

src/request.rs

@@ -9,7 +9,7 @@ use std::{str::FromStr, sync::Arc};
 
 use crate::cookies::CookieData;
 use crate::http::cookies::Cookie;
-use crate::http::headers::{HeaderName, HeaderValue};
+use crate::http::headers::{HeaderName, HeaderValues};
 use crate::http::{self, Method, StatusCode, Url, Version};
 use crate::Response;
 
@@ -124,7 +124,7 @@ impl<State> Request<State> {
     ///
     /// let mut app = tide::new();
     /// app.at("/").get(|req: Request<()>| async move {
-    ///     assert_eq!(req.header(&"X-Forwarded-For".parse().unwrap()), Some(&vec!["127.0.0.1".parse().unwrap()]));
+    ///     assert_eq!(req.header("X-Forwarded-For").unwrap(), "127.0.0.1");
     ///     Ok("")
     /// });
     /// app.listen("127.0.0.1:8080").await?;
@@ -134,20 +134,20 @@ impl<State> Request<State> {
     #[must_use]
     pub fn header(
         &self,
-        key: &http_types::headers::HeaderName,
-    ) -> Option<&Vec<http_types::headers::HeaderValue>> {
+        key: impl Into<http_types::headers::HeaderName>,
+    ) -> Option<&http_types::headers::HeaderValues> {
         self.request.header(key)
     }
 
-    /// Get a local value.
+    /// Get a request extension value.
     #[must_use]
-    pub fn local<T: Send + Sync + 'static>(&self) -> Option<&T> {
-        self.request.local().get()
+    pub fn ext<T: Send + Sync + 'static>(&self) -> Option<&T> {
+        self.request.ext().get()
     }
 
-    /// Set a local value.
-    pub fn set_local<T: Send + Sync + 'static>(mut self, val: T) -> Self {
-        self.request.local_mut().insert(val);
+    /// Set a request extension value.
+    pub fn set_ext<T: Send + Sync + 'static>(mut self, val: T) -> Self {
+        self.request.ext_mut().insert(val);
         self
     }
 
@@ -294,10 +294,8 @@ impl<State> Request<State> {
     /// returns a `Cookie` by name of the cookie.
     #[must_use]
     pub fn cookie(&self, name: &str) -> Option<Cookie<'static>> {
-        if let Some(cookie_data) = self.local::<CookieData>() {
-            return cookie_data.content.read().unwrap().get(name).cloned();
-        }
-        None
+        self.ext::<CookieData>()
+            .and_then(|cookie_data| cookie_data.content.read().unwrap().get(name).cloned())
     }
 
     /// Get the length of the body.
@@ -349,7 +347,7 @@ impl<State: Send + Sync + 'static> Into<Response> for Request<State> {
 }
 
 impl<State> IntoIterator for Request<State> {
-    type Item = (HeaderName, Vec<HeaderValue>);
+    type Item = (HeaderName, HeaderValues);
     type IntoIter = http_types::headers::IntoIter;
 
     /// Returns a iterator of references over the remaining items.
@@ -360,7 +358,7 @@ impl<State> IntoIterator for Request<State> {
 }
 
 impl<'a, State> IntoIterator for &'a Request<State> {
-    type Item = (&'a HeaderName, &'a Vec<HeaderValue>);
+    type Item = (&'a HeaderName, &'a HeaderValues);
     type IntoIter = http_types::headers::Iter<'a>;
 
     #[inline]
@@ -370,7 +368,7 @@ impl<'a, State> IntoIterator for &'a Request<State> {
 }
 
 impl<'a, State> IntoIterator for &'a mut Request<State> {
-    type Item = (&'a HeaderName, &'a mut Vec<HeaderValue>);
+    type Item = (&'a HeaderName, &'a mut HeaderValues);
     type IntoIter = http_types::headers::IterMut<'a>;
 
     #[inline]

src/response.rs

@@ -5,9 +5,9 @@ use mime::Mime;
 use serde::Serialize;
 
 use crate::http::cookies::Cookie;
-use crate::http::headers::{HeaderName, HeaderValue};
+use crate::http::headers::{HeaderName, HeaderValues, ToHeaderValues, CONTENT_TYPE};
 use crate::http::{self, Body, StatusCode};
-use crate::Redirect;
+use crate::redirect::Redirect;
 
 #[derive(Debug)]
 pub(crate) enum CookieEvent {
@@ -99,38 +99,24 @@ impl Response {
 
     /// Get an HTTP header.
     #[must_use]
-    pub fn header(&self, name: &HeaderName) -> Option<&Vec<HeaderValue>> {
+    pub fn header(&self, name: impl Into<HeaderName>) -> Option<&HeaderValues> {
         self.res.header(name)
     }
 
     /// Remove a header.
-    pub fn remove_header(&mut self, name: &HeaderName) -> Option<Vec<HeaderValue>> {
+    pub fn remove_header(&mut self, name: impl Into<HeaderName>) -> Option<HeaderValues> {
         self.res.remove_header(name)
     }
 
     /// Insert an HTTP header.
-    pub fn set_header(
-        mut self,
-        key: http_types::headers::HeaderName,
-        value: impl AsRef<str>,
-    ) -> Self {
-        let value = value.as_ref().to_owned();
-        self.res
-            .insert_header(key, &[value.parse().unwrap()][..])
-            .expect("invalid header");
+    pub fn set_header(mut self, key: impl Into<HeaderName>, value: impl ToHeaderValues) -> Self {
+        self.res.insert_header(key, value);
         self
     }
 
     /// Append an HTTP header.
-    pub fn append_header(
-        mut self,
-        key: http_types::headers::HeaderName,
-        value: impl AsRef<str>,
-    ) -> Self {
-        let value = value.as_ref().to_owned();
-        self.res
-            .append_header(key, &[value.parse().unwrap()][..])
-            .expect("invalid header");
+    pub fn append_header(mut self, key: impl Into<HeaderName>, value: impl ToHeaderValues) -> Self {
+        self.res.append_header(key, value);
         self
     }
 
@@ -139,7 +125,7 @@ impl Response {
     /// [Read more on MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types)
     #[must_use]
     pub fn set_mime(self, mime: Mime) -> Self {
-        self.set_header(http_types::headers::CONTENT_TYPE, format!("{}", mime))
+        self.set_header(CONTENT_TYPE, mime.to_string())
     }
 
     /// Pass a string as the request body.
@@ -233,15 +219,15 @@ impl Response {
         self.cookie_events.push(CookieEvent::Removed(cookie));
     }
 
-    /// Get a local value.
+    /// Get a response extension value.
     #[must_use]
-    pub fn local<T: Send + Sync + 'static>(&self) -> Option<&T> {
-        self.res.local().get()
+    pub fn ext<T: Send + Sync + 'static>(&self) -> Option<&T> {
+        self.res.ext().get()
     }
 
     /// Set a local value.
-    pub fn set_local<T: Send + Sync + 'static>(mut self, val: T) -> Self {
-        self.res.local_mut().insert(val);
+    pub fn set_ext<T: Send + Sync + 'static>(mut self, val: T) -> Self {
+        self.res.ext_mut().insert(val);
         self
     }
 
@@ -309,7 +295,7 @@ impl<'a> From<&'a str> for Response {
 }
 
 impl IntoIterator for Response {
-    type Item = (HeaderName, Vec<HeaderValue>);
+    type Item = (HeaderName, HeaderValues);
     type IntoIter = http_types::headers::IntoIter;
 
     /// Returns a iterator of references over the remaining items.
@@ -320,7 +306,7 @@ impl IntoIterator for Response {
 }
 
 impl<'a> IntoIterator for &'a Response {
-    type Item = (&'a HeaderName, &'a Vec<HeaderValue>);
+    type Item = (&'a HeaderName, &'a HeaderValues);
     type IntoIter = http_types::headers::Iter<'a>;
 
     #[inline]
@@ -330,7 +316,7 @@ impl<'a> IntoIterator for &'a Response {
 }
 
 impl<'a> IntoIterator for &'a mut Response {
-    type Item = (&'a HeaderName, &'a mut Vec<HeaderValue>);
+    type Item = (&'a HeaderName, &'a mut HeaderValues);
     type IntoIter = http_types::headers::IterMut<'a>;
 
     #[inline]

src/route.rs

@@ -153,7 +153,7 @@ impl<'a, State: 'static> Route<'a, State> {
                     ));
                     (ep.clone(), ep)
                 };
-            self.router.add(&self.path, method.clone(), ep1);
+            self.router.add(&self.path, method, ep1);
             let wildcard = self.at("*--tide-path-rest");
             wildcard.router.add(&wildcard.path, method, ep2);
         } else {