cargo fix + cargo fmt

Signed-off-by: Francesco Guardiani <francescoguard@gmail.com>

cloudevents-sdk-actix-web/src/server_request.rs

@@ -4,8 +4,8 @@ use actix_web::web::{Bytes, BytesMut};
 use actix_web::{web, HttpMessage, HttpRequest};
 use cloudevents::event::SpecVersion;
 use cloudevents::message::{
-    BinaryDeserializer, BinarySerializer, Encoding, MessageAttributeValue,
+    BinaryDeserializer, BinarySerializer, Encoding, MessageAttributeValue, MessageDeserializer,
-    MessageDeserializer, StructuredDeserializer, StructuredSerializer, Result
+    Result, StructuredDeserializer, StructuredSerializer,
 };
 use cloudevents::{message, Event};
 use futures::StreamExt;
@@ -24,10 +24,7 @@ impl HttpRequestDeserializer<'_> {
 }
 
 impl<'a> BinaryDeserializer for HttpRequestDeserializer<'a> {
-    fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(
+    fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<R> {
-        self,
-        mut visitor: V,
-    ) -> Result<R> {
         if self.encoding() != Encoding::BINARY {
             return Err(message::Error::WrongEncoding {});
         }
@@ -78,10 +75,7 @@ impl<'a> BinaryDeserializer for HttpRequestDeserializer<'a> {
 }
 
 impl<'a> StructuredDeserializer for HttpRequestDeserializer<'a> {
-    fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(
+    fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(self, visitor: V) -> Result<R> {
-        self,
-        visitor: V,
-    ) -> Result<R> {
         if self.encoding() != Encoding::STRUCTURED {
             return Err(message::Error::WrongEncoding {});
         }

cloudevents-sdk-actix-web/src/server_response.rs

@@ -4,8 +4,7 @@ use actix_web::http::{HeaderName, HeaderValue};
 use actix_web::HttpResponse;
 use cloudevents::event::SpecVersion;
 use cloudevents::message::{
-    BinaryDeserializer, BinarySerializer, MessageAttributeValue, Result,
+    BinaryDeserializer, BinarySerializer, MessageAttributeValue, Result, StructuredSerializer,
-    StructuredSerializer,
 };
 use cloudevents::Event;
 use std::str::FromStr;

cloudevents-sdk-reqwest/src/client_request.rs

@@ -1,8 +1,7 @@
 use super::headers;
 use cloudevents::event::SpecVersion;
 use cloudevents::message::{
-    BinaryDeserializer, BinarySerializer, MessageAttributeValue,
+    BinaryDeserializer, BinarySerializer, MessageAttributeValue, Result, StructuredSerializer,
-    Result, StructuredSerializer,
 };
 use cloudevents::Event;
 use reqwest::RequestBuilder;
@@ -64,10 +63,7 @@ impl StructuredSerializer<RequestBuilder> for RequestSerializer {
 }
 
 /// Method to transform an incoming [`HttpRequest`] to [`Event`]
-pub fn event_to_request(
+pub fn event_to_request(event: Event, request_builder: RequestBuilder) -> Result<RequestBuilder> {
-    event: Event,
-    request_builder: RequestBuilder,
-) -> Result<RequestBuilder> {
     BinaryDeserializer::deserialize_binary(event, RequestSerializer::new(request_builder))
 }
 
@@ -76,10 +72,10 @@ mod tests {
     use super::*;
     use mockito::{mock, Matcher};
 
+    use cloudevents::message::StructuredDeserializer;
     use cloudevents::EventBuilder;
     use serde_json::json;
     use url::Url;
-    use cloudevents::message::StructuredDeserializer;
 
     #[tokio::test]
     async fn test_request() {
@@ -164,8 +160,9 @@ mod tests {
         let client = reqwest::Client::new();
         StructuredDeserializer::deserialize_structured(
             input,
-            RequestSerializer::new(client.post(&url))
+            RequestSerializer::new(client.post(&url)),
-        ).unwrap()
+        )
+        .unwrap()
         .send()
         .await
         .unwrap();

cloudevents-sdk-reqwest/src/client_response.rs

@@ -1,11 +1,14 @@
 use super::headers;
-use reqwest::Response;
-use cloudevents::event::SpecVersion;
-use cloudevents::message::{BinaryDeserializer, BinarySerializer, Encoding, MessageAttributeValue, MessageDeserializer, StructuredDeserializer, StructuredSerializer, Result, Error};
-use cloudevents::{message, Event};
-use std::convert::TryFrom;
 use bytes::Bytes;
+use cloudevents::event::SpecVersion;
+use cloudevents::message::{
+    BinaryDeserializer, BinarySerializer, Encoding, Error, MessageAttributeValue,
+    MessageDeserializer, Result, StructuredDeserializer, StructuredSerializer,
+};
+use cloudevents::{message, Event};
 use reqwest::header::{HeaderMap, HeaderName};
+use reqwest::Response;
+use std::convert::TryFrom;
 
 /// Wrapper for [`Response`] that implements [`MessageDeserializer`] trait
 pub struct ResponseDeserializer {
@@ -20,10 +23,7 @@ impl ResponseDeserializer {
 }
 
 impl BinaryDeserializer for ResponseDeserializer {
-    fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(
+    fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<R> {
-        self,
-        mut visitor: V,
-    ) -> Result<R> {
         if self.encoding() != Encoding::BINARY {
             return Err(message::Error::WrongEncoding {});
         }
@@ -38,10 +38,10 @@ impl BinaryDeserializer for ResponseDeserializer {
             .get(&spec_version)
             .unwrap();
 
-        for (hn, hv) in
+        for (hn, hv) in self
-            self.headers.iter().filter(|(hn, _)| {
+            .headers
-                headers::SPEC_VERSION_HEADER.ne(hn) && hn.as_str().starts_with("ce-")
+            .iter()
-            })
+            .filter(|(hn, _)| headers::SPEC_VERSION_HEADER.ne(hn) && hn.as_str().starts_with("ce-"))
         {
             let name = &hn.as_str()["ce-".len()..];
 
@@ -74,10 +74,7 @@ impl BinaryDeserializer for ResponseDeserializer {
 }
 
 impl StructuredDeserializer for ResponseDeserializer {
-    fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(
+    fn deserialize_structured<R: Sized, V: StructuredSerializer<R>>(self, visitor: V) -> Result<R> {
-        self,
-        visitor: V,
-    ) -> Result<R> {
         if self.encoding() != Encoding::STRUCTURED {
             return Err(message::Error::WrongEncoding {});
         }
@@ -92,21 +89,22 @@ impl MessageDeserializer for ResponseDeserializer {
                 .map(|r| r.ok())
                 .flatten()
                 .map(|e| e.starts_with("application/cloudevents+json")),
-            self.headers.get::<&'static HeaderName>(&headers::SPEC_VERSION_HEADER)
+            self.headers
+                .get::<&'static HeaderName>(&headers::SPEC_VERSION_HEADER),
         ) {
             (Some(true), _) => Encoding::STRUCTURED,
             (_, Some(_)) => Encoding::BINARY,
-            _ => Encoding::UNKNOWN
+            _ => Encoding::UNKNOWN,
         }
     }
 }
 
 /// Method to transform an incoming [`Response`] to [`Event`]
-pub async fn response_to_event(
+pub async fn response_to_event(res: Response) -> Result<Event> {
-    res: Response,
-) -> Result<Event> {
     let h = res.headers().to_owned();
-    let b = res.bytes().await.map_err(|e| Error::Other {source: Box::new(e)})?;
+    let b = res.bytes().await.map_err(|e| Error::Other {
+        source: Box::new(e),
+    })?;
 
     MessageDeserializer::into_event(ResponseDeserializer::new(h, b))
 }
@@ -118,8 +116,8 @@ mod tests {
 
     use cloudevents::EventBuilder;
     use serde_json::json;
-    use url::Url;
     use std::str::FromStr;
+    use url::Url;
 
     #[tokio::test]
     async fn test_response() {
@@ -141,10 +139,7 @@ mod tests {
             .build();
 
         let client = reqwest::Client::new();
-        let res = client.get(&url)
+        let res = client.get(&url).send().await.unwrap();
-            .send()
-            .await
-            .unwrap();
 
         let resp = response_to_event(res).await.unwrap();
         assert_eq!(expected, resp);
@@ -174,12 +169,8 @@ mod tests {
             .extension("someint", "10")
             .build();
 
-
         let client = reqwest::Client::new();
-        let res = client.get(&url)
+        let res = client.get(&url).send().await.unwrap();
-            .send()
-            .await
-            .unwrap();
 
         let resp = response_to_event(res).await.unwrap();
         assert_eq!(expected, resp);
@@ -199,15 +190,15 @@ mod tests {
         let url = mockito::server_url();
         let _m = mock("GET", "/")
             .with_status(200)
-            .with_header("content-type", "application/cloudevents+json; charset=utf-8")
+            .with_header(
+                "content-type",
+                "application/cloudevents+json; charset=utf-8",
+            )
             .with_body(serde_json::to_string(&expected).unwrap())
             .create();
 
         let client = reqwest::Client::new();
-        let res = client.get(&url)
+        let res = client.get(&url).send().await.unwrap();
-            .send()
-            .await
-            .unwrap();
 
         let resp = response_to_event(res).await.unwrap();
         assert_eq!(expected, resp);

src/event/message.rs

@@ -3,8 +3,8 @@ use super::Event;
 use super::{Attributes, AttributesReader};
 use crate::event::SpecVersion;
 use crate::message::{
-    BinaryDeserializer, BinarySerializer, Result, MessageAttributeValue,
+    BinaryDeserializer, BinarySerializer, MessageAttributeValue, Result, StructuredDeserializer,
-    StructuredDeserializer, StructuredSerializer,
+    StructuredSerializer,
 };
 
 impl StructuredDeserializer for Event {
@@ -15,10 +15,7 @@ impl StructuredDeserializer for Event {
 }
 
 impl BinaryDeserializer for Event {
-    fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(
+    fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<R> {
-        self,
-        mut visitor: V,
-    ) -> Result<R> {
         visitor = visitor.set_spec_version(self.get_specversion())?;
         visitor = self.attributes.deserialize_attributes(visitor)?;
         for (k, v) in self.extensions.into_iter() {
@@ -37,25 +34,15 @@ impl BinaryDeserializer for Event {
 }
 
 pub(crate) trait AttributesDeserializer {
-    fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
+    fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(self, visitor: V) -> Result<V>;
-        self,
-        visitor: V,
-    ) -> Result<V>;
 }
 
 pub(crate) trait AttributesSerializer {
-    fn serialize_attribute(
+    fn serialize_attribute(&mut self, name: &str, value: MessageAttributeValue) -> Result<()>;
-        &mut self,
-        name: &str,
-        value: MessageAttributeValue,
-    ) -> Result<()>;
 }
 
 impl AttributesDeserializer for Attributes {
-    fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
+    fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(self, visitor: V) -> Result<V> {
-        self,
-        visitor: V,
-    ) -> Result<V> {
         match self {
             Attributes::V03(v03) => v03.deserialize_attributes(visitor),
             Attributes::V10(v10) => v10.deserialize_attributes(visitor),
@@ -64,11 +51,7 @@ impl AttributesDeserializer for Attributes {
 }
 
 impl AttributesSerializer for Attributes {
-    fn serialize_attribute(
+    fn serialize_attribute(&mut self, name: &str, value: MessageAttributeValue) -> Result<()> {
-        &mut self,
-        name: &str,
-        value: MessageAttributeValue,
-    ) -> Result<()> {
         match self {
             Attributes::V03(v03) => v03.serialize_attribute(name, value),
             Attributes::V10(v10) => v10.serialize_attribute(name, value),

src/event/v03/message.rs

@@ -1,13 +1,8 @@
-use crate::message::{
+use crate::message::{BinarySerializer, Error, MessageAttributeValue, Result};
-    BinarySerializer, Result, Error, MessageAttributeValue,
-};
 use std::convert::TryInto;
 
 impl crate::event::message::AttributesDeserializer for super::Attributes {
-    fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
+    fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<V> {
-        self,
-        mut visitor: V,
-    ) -> Result<V> {
         visitor = visitor.set_attribute("id", MessageAttributeValue::String(self.id))?;
         visitor = visitor.set_attribute("type", MessageAttributeValue::String(self.ty))?;
         visitor = visitor.set_attribute("source", MessageAttributeValue::UriRef(self.source))?;
@@ -30,18 +25,15 @@ impl crate::event::message::AttributesDeserializer for super::Attributes {
             )?;
         }
         if self.time.is_some() {
-            visitor = visitor.set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
+            visitor = visitor
+                .set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
         }
         Ok(visitor)
     }
 }
 
 impl crate::event::message::AttributesSerializer for super::Attributes {
-    fn serialize_attribute(
+    fn serialize_attribute(&mut self, name: &str, value: MessageAttributeValue) -> Result<()> {
-        &mut self,
-        name: &str,
-        value: MessageAttributeValue,
-    ) -> Result<()> {
         match name {
             "id" => self.id = value.to_string(),
             "type" => self.ty = value.to_string(),

src/event/v10/message.rs

@@ -1,13 +1,8 @@
-use crate::message::{
+use crate::message::{BinarySerializer, Error, MessageAttributeValue, Result};
-    BinarySerializer, Error, MessageAttributeValue, Result,
-};
 use std::convert::TryInto;
 
 impl crate::event::message::AttributesDeserializer for super::Attributes {
-    fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(
+    fn deserialize_attributes<R: Sized, V: BinarySerializer<R>>(self, mut visitor: V) -> Result<V> {
-        self,
-        mut visitor: V,
-    ) -> Result<V> {
         visitor = visitor.set_attribute("id", MessageAttributeValue::String(self.id))?;
         visitor = visitor.set_attribute("type", MessageAttributeValue::String(self.ty))?;
         visitor = visitor.set_attribute("source", MessageAttributeValue::UriRef(self.source))?;
@@ -30,18 +25,15 @@ impl crate::event::message::AttributesDeserializer for super::Attributes {
             )?;
         }
         if self.time.is_some() {
-            visitor = visitor.set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
+            visitor = visitor
+                .set_attribute("time", MessageAttributeValue::DateTime(self.time.unwrap()))?;
         }
         Ok(visitor)
     }
 }
 
 impl crate::event::message::AttributesSerializer for super::Attributes {
-    fn serialize_attribute(
+    fn serialize_attribute(&mut self, name: &str, value: MessageAttributeValue) -> Result<()> {
-        &mut self,
-        name: &str,
-        value: MessageAttributeValue,
-    ) -> Result<()> {
         match name {
             "id" => self.id = value.to_string(),
             "type" => self.ty = value.to_string(),

src/message/deserializer.rs

@@ -1,4 +1,4 @@
-use super::{BinarySerializer, Encoding, StructuredSerializer, Result};
+use super::{BinarySerializer, Encoding, Result, StructuredSerializer};
 use crate::Event;
 
 pub trait StructuredDeserializer
@@ -19,10 +19,7 @@ pub trait BinaryDeserializer
 where
     Self: Sized,
 {
-    fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(
+    fn deserialize_binary<R: Sized, V: BinarySerializer<R>>(self, serializer: V) -> Result<R>;
-        self,
-        serializer: V,
-    ) -> Result<R>;
 
     fn into_event(self) -> Result<Event> {
         self.deserialize_binary(Event::default())
@@ -39,10 +36,7 @@ where
         self.deserialize_to(Event::default())
     }
 
-    fn deserialize_to_binary<R: Sized, T: BinarySerializer<R>>(
+    fn deserialize_to_binary<R: Sized, T: BinarySerializer<R>>(self, serializer: T) -> Result<R> {
-        self,
-        serializer: T,
-    ) -> Result<R> {
         if self.encoding() == Encoding::BINARY {
             return self.deserialize_binary(serializer);
         }

src/message/serializer.rs

@@ -5,7 +5,10 @@ pub trait StructuredSerializer<RETURN: Sized> {
     fn set_structured_event(self, bytes: Vec<u8>) -> Result<RETURN>;
 }
 
-pub trait BinarySerializer<RETURN: Sized> where Self: Sized {
+pub trait BinarySerializer<RETURN: Sized>
+where
+    Self: Sized,
+{
     fn set_spec_version(self, spec_version: SpecVersion) -> Result<Self>;
 
     fn set_attribute(self, name: &str, value: MessageAttributeValue) -> Result<Self>;

tests/message.rs

@@ -1,7 +1,7 @@
 mod test_data;
 use cloudevents::message::{
-    BinaryDeserializer, BinarySerializer, Error, MessageAttributeValue,
+    BinaryDeserializer, BinarySerializer, Error, MessageAttributeValue, Result,
-    StructuredDeserializer, Result,
+    StructuredDeserializer,
 };
 
 use test_data::*;