style: format code

formats code according to `cargo fmt` standards

src/edge_storage.rs

@@ -95,20 +95,24 @@ pub struct Storage {
 
 impl<'a> Storage {
     /// Sets endpoint and storage zone used by Edge Storage API
-    /// 
+    ///
     /// ```
     /// use bunny_api_tokio::{Client, error::Error, edge_storage::Endpoint};
-    /// 
+    ///
     /// #[tokio::main]
     /// async fn main() -> Result<(), Error> {
     ///     let mut client = Client::new("api_key").await?;
-    /// 
+    ///
     ///     client.storage.init(Endpoint::Frankfurt, "MyStorageZone");
-    /// 
+    ///
     ///     Ok(())
     /// }
     /// ```
-    pub fn init<T: AsRef<str>>(&mut self, endpoint: Endpoint, storage_zone: T) -> Result<(), Error> {
+    pub fn init<T: AsRef<str>>(
+        &mut self,
+        endpoint: Endpoint,
+        storage_zone: T,
+    ) -> Result<(), Error> {
         let endpoint: Url = endpoint.try_into()?;
         let storage_zone = String::from("/") + storage_zone.as_ref() + "/";
 
@@ -117,120 +121,126 @@ impl<'a> Storage {
     }
 
     /// Uploads a file to the Storage Zone
-    /// 
+    ///
     /// ```
     /// use bunny_api_tokio::{Client, error::Error, edge_storage::Endpoint};
     /// use tokio::fs;
-    /// 
+    ///
     /// #[tokio::main]
     /// async fn main() -> Result<(), Error> {
     ///     let mut client = Client::new("api_key").await?;
-    /// 
+    ///
     ///     client.storage.init(Endpoint::Frankfurt, "MyStorageZone");
-    /// 
+    ///
     ///     let file_bytes = fs::read("path/to/file.png").await?;
-    /// 
+    ///
     ///     // Will put a file in STORAGE_ZONE/images/file.png
     ///     client.storage.upload("/images/file.png", file_bytes).await?;
-    /// 
+    ///
     ///     Ok(())
     /// }
     /// ```
     pub async fn upload<T: AsRef<str>>(&self, path: T, file: Bytes) -> Result<(), Error> {
-        let response  = self.reqwest.put(self.url.join(path.as_ref())?)
+        let response = self
+            .reqwest
+            .put(self.url.join(path.as_ref())?)
             .header("Content-Type", "application/octet-stream")
             .body(file)
             .send()
             .await?;
 
         if response.status().as_u16() == 401 {
-            return Err(Error::Authentication(response.text().await?))
+            return Err(Error::Authentication(response.text().await?));
         } else if response.status().as_u16() == 400 {
-            return Err(Error::BadRequest(response.text().await?))
+            return Err(Error::BadRequest(response.text().await?));
         }
 
         Ok(())
     }
 
     /// Downloads a file from the Storage Zone
-    /// 
+    ///
     /// ```
     /// use bunny_api_tokio::{Client, error::Error, edge_storage::Endpoint};
     /// use tokio::fs;
     /// use tokio::io::AsyncWriteExt;
-    /// 
+    ///
     /// #[tokio::main]
     /// async fn main() -> Result<(), Error> {
     ///     let mut client = Client::new("api_key").await?;
-    /// 
+    ///
     ///     client.storage.init(Endpoint::Frankfurt, "MyStorageZone");
-    /// 
+    ///
     ///     // Will download the file STORAGE_ZONE/images/file.png
     ///     let contents = client.storage.download("/images/file.png").await?;
-    /// 
+    ///
     ///     let mut file = fs::File::create("file.png").await?;
     ///     file.write_all(contents).await?;
-    /// 
+    ///
     ///     Ok(())
     /// }
     /// ```
     pub async fn download<T: AsRef<str>>(&self, path: T) -> Result<Bytes, Error> {
-        let response  = self.reqwest.get(self.url.join(path.as_ref())?)
+        let response = self
+            .reqwest
+            .get(self.url.join(path.as_ref())?)
             .header("accept", "*/*")
             .send()
             .await?;
 
         if response.status().as_u16() == 401 {
-            return Err(Error::Authentication(response.text().await?))
+            return Err(Error::Authentication(response.text().await?));
         } else if response.status().as_u16() == 404 {
-            return Err(Error::NotFound(response.text().await?))
+            return Err(Error::NotFound(response.text().await?));
         }
 
         Ok(response.bytes().await?)
     }
 
     /// Deletes a file from the Storage Zone
-    /// 
+    ///
     /// ```
     /// use bunny_api_tokio::{Client, error::Error, edge_storage::Endpoint};
-    /// 
+    ///
     /// #[tokio::main]
     /// async fn main() -> Result<(), Error> {
     ///     let mut client = Client::new("api_key").await?;
-    /// 
+    ///
     ///     client.storage.init(Endpoint::Frankfurt, "MyStorageZone");
-    /// 
+    ///
     ///     // Will delete the file STORAGE_ZONE/images/file.png
     ///     client.storage.delete("/images/file.png").await?;
-    /// 
+    ///
     ///     Ok(())
     /// }
     /// ```
     pub async fn delete<T: AsRef<str>>(&self, path: T) -> Result<(), Error> {
-        let response  = self.reqwest.delete(self.url.join(path.as_ref())?)
+        let response = self
+            .reqwest
+            .delete(self.url.join(path.as_ref())?)
             .send()
             .await?;
 
         if response.status().as_u16() == 401 {
-            return Err(Error::Authentication(response.text().await?))
+            return Err(Error::Authentication(response.text().await?));
         } else if response.status().as_u16() == 400 {
-            return Err(Error::BadRequest(response.text().await?))
+            return Err(Error::BadRequest(response.text().await?));
         }
 
         Ok(())
     }
 
     /// Lists files on the Storage Zone
-    /// 
+    ///
     /// ```
     /// use bunny_api_tokio::{Client, error::Error, edge_storage::Endpoint};
-    /// 
+    ///
     /// #[tokio::main]
     /// async fn main() -> Result<(), Error> {
     ///     let mut client = Client::new("api_key").await?;
-    /// 
+    ///
     ///     client.storage.init(Endpoint::Frankfurt, "MyStorageZone");
-    /// 
+    ///
     ///     // Will list the files in STORAGE_ZONE/images/
     ///     let files = client.storage.list("/images/").await?;
     ///     
@@ -240,14 +250,16 @@ impl<'a> Storage {
     /// }
     /// ```
     pub async fn list<T: AsRef<str>>(&self, path: T) -> Result<Vec<ListFile>, Error> {
-        let response = self.reqwest.get(self.url.join(path.as_ref())?)
+        let response = self
+            .reqwest
+            .get(self.url.join(path.as_ref())?)
             .send()
             .await?;
 
         if response.status().as_u16() == 401 {
-            return Err(Error::Authentication(response.text().await?))
+            return Err(Error::Authentication(response.text().await?));
         } else if response.status().as_u16() == 400 {
-            return Err(Error::BadRequest(response.text().await?))
+            return Err(Error::BadRequest(response.text().await?));
         }
 
         Ok(response.json().await?)

src/lib.rs

@@ -1,48 +1,51 @@
 //! This library provides access to the Bunny API asynchronously using tokio, it's not fully implemented but PRs are welcome.
-//! 
+//!
 //! # Getting started
 //! 1. add package to your project using cargo
-//! 
+//!
 //! `$ cargo add bunny-api-tokio`
-//! 
+//!
 //! 2. Start coding
-//! 
+//!
 //! ```
 //! use bunny_api_tokio::{Client, error::Error};
-//! 
+//!
 //! #[tokio::main]
 //! async fn main() -> Result<(), Error> {
 //!     let mut client = Client::new("api_key").await?;
-//! 
+//!
 //!     Ok(())
 //! }
 //! ```
 #![deny(missing_docs)]
 
-use std::sync::Arc;
-use reqwest::{header::{HeaderMap, HeaderValue}, Client as RClient};
 use error::Error;
+use reqwest::{
+    Client as RClient,
+    header::{HeaderMap, HeaderValue},
+};
+use std::sync::Arc;
 use url::Url;
 
-pub mod error;
 pub mod edge_storage;
+pub mod error;
 
 /// API Client for bunny
 pub struct Client {
     /// Used to interact with the Edge Storage API
-    pub storage: edge_storage::Storage
+    pub storage: edge_storage::Storage,
 }
 
 impl Client {
     /// Creates a new Client using the supplied `api_key`
-    /// 
+    ///
     /// ```
     /// use bunny_api_tokio::{Client, error::Error};
-    /// 
+    ///
     /// #[tokio::main]
     /// async fn main() -> Result<(), Error> {
     ///     let mut client = Client::new("api_key").await?;
-    /// 
+    ///
     ///     Ok(())
     /// }
     /// ```
@@ -50,9 +53,7 @@ impl Client {
         let mut headers = HeaderMap::new();
         headers.append("AccessKey", HeaderValue::from_str(api_key.as_ref())?);
 
-        let reqwest = Arc::new(RClient::builder()
+        let reqwest = Arc::new(RClient::builder().default_headers(headers).build()?);
-            .default_headers(headers)
-            .build()?);
 
         Ok(Self {
             storage: edge_storage::Storage {