Format manually written files

Author: svix-mman

rust/src/api/client.rs

@@ -1,6 +1,12 @@
-use std::{sync::Arc, time::Duration};
+use std::{
+    sync::Arc,
+    time::Duration,
+};
 
-use hyper_util::{client::legacy::Client as HyperClient, rt::TokioExecutor};
+use hyper_util::{
+    client::legacy::Client as HyperClient,
+    rt::TokioExecutor,
+};
 
 use crate::Configuration;
 
@@ -64,20 +70,25 @@ pub struct Svix {
 }
 
 impl Svix {
-    pub fn new(token: String, options: Option<SvixOptions>) -> Self {
+    pub fn new(
+        token: String,
+        options: Option<SvixOptions>,
+    ) -> Self {
         let options = options.unwrap_or_default();
 
-        let cfg = Arc::new(Configuration {
-            user_agent: Some(format!("svix-libs/{CRATE_VERSION}/rust")),
-            client: HyperClient::builder(TokioExecutor::new())
-                .build(crate::make_connector(options.proxy_address)),
-            timeout: options.timeout,
-            // These fields will be set by `with_token` below
-            base_path: String::new(),
-            bearer_access_token: None,
-            num_retries: options.num_retries.unwrap_or(2),
-            retry_schedule: options.retry_schedule,
-        });
+        let cfg = Arc::new(
+            Configuration {
+                user_agent: Some(format!("svix-libs/{CRATE_VERSION}/rust")),
+                client: HyperClient::builder(TokioExecutor::new())
+                    .build(crate::make_connector(options.proxy_address)),
+                timeout: options.timeout,
+                // These fields will be set by `with_token` below
+                base_path: String::new(),
+                bearer_access_token: None,
+                num_retries: options.num_retries.unwrap_or(2),
+                retry_schedule: options.retry_schedule,
+            },
+        );
         let svix = Self {
             cfg,
             server_url: options.server_url,
@@ -91,27 +102,34 @@ impl Svix {
     ///
     /// This can be used to change the token without incurring
     /// the cost of TLS initialization.
-    pub fn with_token(&self, token: String) -> Self {
-        let base_path = self.server_url.clone().unwrap_or_else(|| {
-            match token.split('.').next_back() {
-                Some("us") => "https://api.us.svix.com",
-                Some("eu") => "https://api.eu.svix.com",
-                Some("in") => "https://api.in.svix.com",
-                Some("ca") => "https://api.ca.svix.com",
-                Some("au") => "https://api.au.svix.com",
-                _ => "https://api.svix.com",
-            }
-            .to_string()
-        });
-        let cfg = Arc::new(Configuration {
-            base_path,
-            user_agent: self.cfg.user_agent.clone(),
-            bearer_access_token: Some(token),
-            client: self.cfg.client.clone(),
-            timeout: self.cfg.timeout,
-            num_retries: self.cfg.num_retries,
-            retry_schedule: self.cfg.retry_schedule.clone(),
-        });
+    pub fn with_token(
+        &self,
+        token: String,
+    ) -> Self {
+        let base_path = self.server_url.clone().unwrap_or_else(
+            || {
+                match token.split('.').next_back() {
+                    Some("us") => "https://api.us.svix.com",
+                    Some("eu") => "https://api.eu.svix.com",
+                    Some("in") => "https://api.in.svix.com",
+                    Some("ca") => "https://api.ca.svix.com",
+                    Some("au") => "https://api.au.svix.com",
+                    _ => "https://api.svix.com",
+                }
+                .to_string()
+            },
+        );
+        let cfg = Arc::new(
+            Configuration {
+                base_path,
+                user_agent: self.cfg.user_agent.clone(),
+                bearer_access_token: Some(token),
+                client: self.cfg.client.clone(),
+                timeout: self.cfg.timeout,
+                num_retries: self.cfg.num_retries,
+                retry_schedule: self.cfg.retry_schedule.clone(),
+            },
+        );
 
         Self {
             cfg,
@@ -133,9 +151,15 @@ mod tests {
     fn test_future_send_sync() {
         fn require_send_sync<T: Send + Sync>(_: T) {}
 
-        let svix = Svix::new(String::new(), None);
+        let svix = Svix::new(
+            String::new(),
+            None,
+        );
         let message_api = svix.message();
-        let fut = message_api.expunge_content(String::new(), String::new());
+        let fut = message_api.expunge_content(
+            String::new(),
+            String::new(),
+        );
         require_send_sync(fut);
     }
 }

rust/src/connector.rs

@@ -1,9 +1,15 @@
-use std::{future::Future, pin::Pin};
+use std::{
+    future::Future,
+    pin::Pin,
+};
 
 use http1::Uri;
 use hyper_util::{
     client::legacy::connect::{
-        proxy::{SocksV5, Tunnel},
+        proxy::{
+            SocksV5,
+            Tunnel,
+        },
         HttpConnector,
     },
     rt::TokioIo,
@@ -19,11 +25,17 @@ type MaybeHttpsStream<T> = T;
 
 // If only native TLS is enabled, use that.
 #[cfg(all(feature = "native-tls", not(feature = "rustls-tls")))]
-use hyper_tls::{HttpsConnector as HttpsIfAvailable, MaybeHttpsStream};
+use hyper_tls::{
+    HttpsConnector as HttpsIfAvailable,
+    MaybeHttpsStream,
+};
 
 // If rustls is enabled, use that.
 #[cfg(feature = "rustls-tls")]
-use hyper_rustls::{HttpsConnector as HttpsIfAvailable, MaybeHttpsStream};
+use hyper_rustls::{
+    HttpsConnector as HttpsIfAvailable,
+    MaybeHttpsStream,
+};
 
 fn wrap_connector<H>(conn: H) -> HttpsIfAvailable<H> {
     #[cfg(not(any(feature = "native-tls", feature = "rustls-tls")))]
@@ -64,7 +76,12 @@ pub(crate) enum Connector {
 // to be fallible and bubble the error up from `Svix::new`.
 pub(crate) fn make_connector(proxy_addr: Option<String>) -> Connector {
     let mut http = hyper_util::client::legacy::connect::HttpConnector::new();
-    if cfg!(any(feature = "native-tls", feature = "rustls-tls")) {
+    if cfg!(
+        any(
+            feature = "native-tls",
+            feature = "rustls-tls"
+        )
+    ) {
         http.enforce_http(false);
     }
 
@@ -84,15 +101,22 @@ pub(crate) fn make_connector(proxy_addr: Option<String>) -> Connector {
 
     match proxy_addr.scheme_str() {
         Some("http" | "https") => {
-            let tunnel = Tunnel::new(proxy_addr, http);
+            let tunnel = Tunnel::new(
+                proxy_addr, http,
+            );
             Connector::HttpProxy(wrap_connector(tunnel))
         }
         Some("socks5") => {
-            let socks = SocksV5::new(proxy_addr, http).local_dns(true);
+            let socks = SocksV5::new(
+                proxy_addr, http,
+            )
+            .local_dns(true);
             Connector::Socks5Proxy(wrap_connector(socks))
         }
         Some("socks5h") => {
-            let socks = SocksV5::new(proxy_addr, http);
+            let socks = SocksV5::new(
+                proxy_addr, http,
+            );
             Connector::Socks5Proxy(wrap_connector(socks))
         }
         scheme => {
@@ -121,7 +145,10 @@ impl Service<Uri> for Connector {
         }
     }
 
-    fn call(&mut self, req: Uri) -> Self::Future {
+    fn call(
+        &mut self,
+        req: Uri,
+    ) -> Self::Future {
         match self {
             Self::Regular(inner) => Box::pin(inner.call(req)),
             Self::Socks5Proxy(inner) => Box::pin(inner.call(req)),

rust/src/error.rs

@@ -26,20 +26,27 @@ impl Error {
         Self::Generic(format!("{err:?}"))
     }
 
-    pub(crate) async fn from_response(status_code: http1::StatusCode, body: Incoming) -> Self {
+    pub(crate) async fn from_response(
+        status_code: http1::StatusCode,
+        body: Incoming,
+    ) -> Self {
         match body.collect().await {
             Ok(collected) => {
                 let bytes = collected.to_bytes();
                 if status_code == http1::StatusCode::UNPROCESSABLE_ENTITY {
-                    Self::Validation(HttpErrorContent {
-                        status: http02::StatusCode::UNPROCESSABLE_ENTITY,
-                        payload: serde_json::from_slice(&bytes).ok(),
-                    })
+                    Self::Validation(
+                        HttpErrorContent {
+                            status: http02::StatusCode::UNPROCESSABLE_ENTITY,
+                            payload: serde_json::from_slice(&bytes).ok(),
+                        },
+                    )
                 } else {
-                    Error::Http(HttpErrorContent {
-                        status: http1_to_02_status_code(status_code),
-                        payload: serde_json::from_slice(&bytes).ok(),
-                    })
+                    Error::Http(
+                        HttpErrorContent {
+                            status: http1_to_02_status_code(status_code),
+                            payload: serde_json::from_slice(&bytes).ok(),
+                        },
+                    )
                 }
             }
             Err(e) => Self::Generic(e.to_string()),
@@ -55,11 +62,22 @@ impl From<Error> for String {
 }
 
 impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(
+        &self,
+        f: &mut fmt::Formatter,
+    ) -> fmt::Result {
         match self {
             Error::Generic(s) => s.fmt(f),
-            Error::Http(e) => format!("Http error (status={}) {:?}", e.status, e.payload).fmt(f),
-            Error::Validation(e) => format!("Validation error {:?}", e.payload).fmt(f),
+            Error::Http(e) => format!(
+                "Http error (status={}) {:?}",
+                e.status, e.payload
+            )
+            .fmt(f),
+            Error::Validation(e) => format!(
+                "Validation error {:?}",
+                e.payload
+            )
+            .fmt(f),
         }
     }
 }

rust/src/lib.rs

@@ -21,7 +21,10 @@ mod models;
 mod request;
 pub mod webhooks;
 
-pub(crate) use connector::{make_connector, Connector};
+pub(crate) use connector::{
+    make_connector,
+    Connector,
+};
 
 pub struct Configuration {
     pub base_path: String,

rust/src/model_ext.rs

@@ -5,7 +5,11 @@ use std::str::FromStr;
 use serde_json::json;
 
 use crate::{
-    api::{MessageStatus, Ordering, StatusCodeClass},
+    api::{
+        MessageStatus,
+        Ordering,
+        StatusCodeClass,
+    },
     models::MessageIn,
 };
 
@@ -22,15 +26,24 @@ impl MessageIn {
     /// The default `content-type` of `application/json` will still be used for
     /// the webhook sent by Svix, unless overwritten with
     /// [`with_content_type`][Self::with_content_type].
-    pub fn new_raw_payload(event_type: String, payload: String) -> Self {
+    pub fn new_raw_payload(
+        event_type: String,
+        payload: String,
+    ) -> Self {
         Self {
             transformations_params: Some(json!({ "rawPayload": payload })),
-            ..Self::new(event_type, json!({}))
+            ..Self::new(
+                event_type,
+                json!({}),
+            )
         }
     }
 
     /// Set the `content-type` header to use for the webhook sent by Svix.
-    pub fn with_content_type(mut self, content_type: String) -> Self {
+    pub fn with_content_type(
+        mut self,
+        content_type: String,
+    ) -> Self {
         let transformations_params = self.transformations_params.get_or_insert_with(|| json!({}));
 
         // This will panic if transformations_params, its headers field, or the

rust/src/models/http_error_out.rs

@@ -11,7 +11,10 @@
 #[allow(unused_imports)]
 use crate::models;
 #[allow(unused_imports)]
-use serde::{Deserialize, Serialize};
+use serde::{
+    Deserialize,
+    Serialize,
+};
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct HttpErrorOut {
@@ -22,7 +25,13 @@ pub struct HttpErrorOut {
 }
 
 impl HttpErrorOut {
-    pub fn new(code: String, detail: String) -> HttpErrorOut {
-        HttpErrorOut { code, detail }
+    pub fn new(
+        code: String,
+        detail: String,
+    ) -> HttpErrorOut {
+        HttpErrorOut {
+            code,
+            detail,
+        }
     }
 }

rust/src/models/http_validation_error.rs

@@ -1,4 +1,7 @@
-use serde::{Deserialize, Serialize};
+use serde::{
+    Deserialize,
+    Serialize,
+};
 
 #[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
 pub struct HttpValidationError {
@@ -8,6 +11,8 @@ pub struct HttpValidationError {
 
 impl HttpValidationError {
     pub fn new(detail: Vec<super::ValidationError>) -> HttpValidationError {
-        HttpValidationError { detail }
+        HttpValidationError {
+            detail,
+        }
     }
 }