Merge pull request #69 from yoshuawuyts/extensions

feat: implement extensions

Author: yoshuawuyts

LICENSE-MIT

@@ -1,6 +1,8 @@
 The MIT License (MIT)
 
 Copyright (c) 2019 Yoshua Wuyts
+Copyright (c) 2017 http-rs authors
+Copyright (c) 2020 Jacob Brown
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

src/headers/constants.rs

@@ -17,3 +17,31 @@ pub const TRANSFER_ENCODING: HeaderName = HeaderName::from_lowercase_str("transf
 
 /// The `Date` Header
 pub const DATE: HeaderName = HeaderName::from_lowercase_str("date");
+
+/// The `Origin` Header
+pub const ORIGIN: HeaderName = HeaderName::from_lowercase_str("origin");
+
+/// The `access-control-max-age` Header
+pub const ACCESS_CONTROL_MAX_AGE: HeaderName =
+    HeaderName::from_lowercase_str("access-control-max-age");
+/// The `access-control-allow-origin` Header
+pub const ACCESS_CONTROL_ALLOW_ORIGIN: HeaderName =
+    HeaderName::from_lowercase_str("access-control-allow-origin");
+/// The `access-control-allow-headers` Header
+pub const ACCESS_CONTROL_ALLOW_HEADERS: HeaderName =
+    HeaderName::from_lowercase_str("access-control-allow-headers");
+/// The `access-control-allow-methods` Header
+pub const ACCESS_CONTROL_ALLOW_METHODS: HeaderName =
+    HeaderName::from_lowercase_str("access-control-allow-methods");
+/// The `access-control-expose-headers` Header
+pub const ACCESS_CONTROL_EXPOSE_HEADERS: HeaderName =
+    HeaderName::from_lowercase_str("access-control-expose-headers");
+/// The `access-control-request-method` Header
+pub const ACCESS_CONTROL_REQUEST_METHOD: HeaderName =
+    HeaderName::from_lowercase_str("access-control-request-method");
+/// The `access-control-request-headers` Header
+pub const ACCESS_CONTROL_REQUEST_HEADERS: HeaderName =
+    HeaderName::from_lowercase_str("access-control-request-headers");
+/// The `access-control-allow-credentials` Header
+pub const ACCESS_CONTROL_ALLOW_CREDENTIALS: HeaderName =
+    HeaderName::from_lowercase_str("access-control-allow-credentials");

src/lib.rs

@@ -121,6 +121,7 @@ mod method;
 mod request;
 mod response;
 mod status_code;
+mod type_map;
 mod version;
 
 pub use body::Body;
@@ -152,6 +153,9 @@ pub mod trailers;
 #[cfg(feature = "hyperium_http")]
 mod hyperium_http;
 
+#[doc(inline)]
+pub use crate::type_map::TypeMap;
+
 // Not public API. Referenced by macro-generated code.
 #[doc(hidden)]
 pub mod private {

src/request.rs

@@ -12,7 +12,7 @@ use crate::headers::{
 use crate::mime::Mime;
 use crate::trailers::{Trailers, TrailersSender};
 use crate::Cookie;
-use crate::{Body, Method, Url, Version};
+use crate::{Body, Method, TypeMap, Url, Version};
 
 pin_project_lite::pin_project! {
     /// An HTTP request.
@@ -35,6 +35,7 @@ pin_project_lite::pin_project! {
         receiver: sync::Receiver<crate::Result<Trailers>>,
         #[pin]
         body: Body,
+        local_state: TypeMap,
     }
 }
 
@@ -50,6 +51,7 @@ impl Request {
             body: Body::empty(),
             sender: Some(sender),
             receiver,
+            local_state: TypeMap::new(),
         }
     }
 
@@ -423,6 +425,31 @@ impl Request {
     pub fn header_values<'a>(&'a self) -> Values<'a> {
         self.headers.values()
     }
+
+    /// Returns a reference to the existing local state.
+    pub fn local_state(&self) -> &TypeMap {
+        &self.local_state
+    }
+
+    /// Returns a mutuable reference to the existing local state.
+    ///
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # fn main() -> Result<(), http_types::Error> {
+    /// #
+    /// use http_types::{Url, Method, Request, Version};
+    ///
+    /// let mut req = Request::new(Method::Get, Url::parse("https://example.com")?);
+    /// req.local_state_mut().insert("hello from the extension");
+    /// assert_eq!(req.local_state().get(), Some(&"hello from the extension"));
+    /// #
+    /// # Ok(()) }
+    /// ```    
+    pub fn local_state_mut(&mut self) -> &mut TypeMap {
+        &mut self.local_state
+    }
 }
 
 impl Read for Request {

src/response.rs

@@ -11,7 +11,7 @@ use crate::headers::{
 };
 use crate::mime::Mime;
 use crate::trailers::{Trailers, TrailersSender};
-use crate::{Body, Cookie, StatusCode, Version};
+use crate::{Body, Cookie, StatusCode, TypeMap, Version};
 
 pin_project_lite::pin_project! {
     /// An HTTP response.
@@ -37,6 +37,7 @@ pin_project_lite::pin_project! {
         receiver: sync::Receiver<crate::Result<Trailers>>,
         #[pin]
         body: Body,
+        local_state: TypeMap,
     }
 }
 
@@ -51,6 +52,7 @@ impl Response {
             body: Body::empty(),
             sender: Some(sender),
             receiver,
+            local_state: TypeMap::new(),
         }
     }
 
@@ -389,6 +391,31 @@ impl Response {
     pub fn header_values<'a>(&'a self) -> Values<'a> {
         self.headers.values()
     }
+
+    /// Returns a reference to the existing local_state.
+    pub fn local_state(&self) -> &TypeMap {
+        &self.local_state
+    }
+
+    /// Returns a mutuable reference to the existing local state.
+    ///
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # fn main() -> Result<(), http_types::Error> {
+    /// #
+    /// use http_types::{StatusCode, Response, Version};
+    ///
+    /// let mut res = Response::new(StatusCode::Ok);
+    /// res.local_state_mut().insert("hello from the extension");
+    /// assert_eq!(res.local_state().get(), Some(&"hello from the extension"));
+    /// #
+    /// # Ok(()) }
+    /// ```    
+    pub fn local_state_mut(&mut self) -> &mut TypeMap {
+        &mut self.local_state
+    }
 }
 
 impl Read for Response {

src/type_map.rs

@@ -0,0 +1,123 @@
+// Implementation is based on
+// - https://github.com/hyperium/http/blob/master/src/extensions.rs
+// - https://github.com/kardeiz/type-map/blob/master/src/lib.rs
+
+use std::any::{Any, TypeId};
+use std::collections::HashMap;
+use std::fmt;
+use std::hash::{BuildHasherDefault, Hasher};
+
+/// Map type that allows storing any `Sync + Send + 'static` type as local state
+/// on a `Request` or `Response`.
+#[derive(Default)]
+pub struct TypeMap {
+    map: Option<HashMap<TypeId, Box<dyn Any + Send + Sync>, BuildHasherDefault<IdHasher>>>,
+}
+
+impl TypeMap {
+    /// Create an empty `TypeMap`.
+    #[inline]
+    pub fn new() -> Self {
+        Self { map: None }
+    }
+
+    /// Insert a value into this `TypeMap`.
+    ///
+    /// If a value of this type already exists, it will be returned.
+    pub fn insert<T: Send + Sync + 'static>(&mut self, val: T) -> Option<T> {
+        self.map
+            .get_or_insert_with(|| Default::default())
+            .insert(TypeId::of::<T>(), Box::new(val))
+            .and_then(|boxed| (boxed as Box<dyn Any>).downcast().ok().map(|boxed| *boxed))
+    }
+
+    /// Check if container contains value for type
+    pub fn contains<T: 'static>(&self) -> bool {
+        self.map
+            .as_ref()
+            .and_then(|m| m.get(&TypeId::of::<T>()))
+            .is_some()
+    }
+
+    /// Get a reference to a value previously inserted on this `TypeMap`.
+    pub fn get<T: 'static>(&self) -> Option<&T> {
+        self.map
+            .as_ref()
+            .and_then(|m| m.get(&TypeId::of::<T>()))
+            .and_then(|boxed| (&**boxed as &(dyn Any)).downcast_ref())
+    }
+
+    /// Get a mutable reference to a value previously inserted on this `TypeMap`.
+    pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
+        self.map
+            .as_mut()
+            .and_then(|m| m.get_mut(&TypeId::of::<T>()))
+            .and_then(|boxed| (&mut **boxed as &mut (dyn Any)).downcast_mut())
+    }
+
+    /// Remove a value from this `TypeMap`.
+    ///
+    /// If a value of this type exists, it will be returned.
+    pub fn remove<T: 'static>(&mut self) -> Option<T> {
+        self.map
+            .as_mut()
+            .and_then(|m| m.remove(&TypeId::of::<T>()))
+            .and_then(|boxed| (boxed as Box<dyn Any>).downcast().ok().map(|boxed| *boxed))
+    }
+
+    /// Clear the `TypeMap` of all inserted values.
+    #[inline]
+    pub fn clear(&mut self) {
+        self.map = None;
+    }
+}
+
+impl fmt::Debug for TypeMap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TypeMap").finish()
+    }
+}
+
+// With TypeIds as keys, there's no need to hash them. So we simply use an identy hasher.
+#[derive(Default)]
+struct IdHasher(u64);
+
+impl Hasher for IdHasher {
+    fn write(&mut self, _: &[u8]) {
+        unreachable!("TypeId calls write_u64");
+    }
+
+    #[inline]
+    fn write_u64(&mut self, id: u64) {
+        self.0 = id;
+    }
+
+    #[inline]
+    fn finish(&self) -> u64 {
+        self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_type_map() {
+        #[derive(Debug, PartialEq)]
+        struct MyType(i32);
+
+        let mut map = TypeMap::new();
+
+        map.insert(5i32);
+        map.insert(MyType(10));
+
+        assert_eq!(map.get(), Some(&5i32));
+        assert_eq!(map.get_mut(), Some(&mut 5i32));
+
+        assert_eq!(map.remove::<i32>(), Some(5i32));
+        assert!(map.get::<i32>().is_none());
+
+        assert_eq!(map.get::<bool>(), None);
+        assert_eq!(map.get(), Some(&MyType(10)));
+    }
+}