chore: format code

Author: kwaa

.rustfmt.toml

@@ -0,0 +1,18 @@
+# https://github.com/rust-lang/rustfmt/blob/master/Configurations.md
+
+edition = "2024"
+tab_spaces = 2
+# empty_item_single_line = true # nightly
+# group_imports = "StdExternalCrate" # nightly
+# imports_granularity = "Crate" # nightly
+# imports_layout = "HorizontalVertical" # nightly
+# match_arm_blocks = false # nightly
+match_block_trailing_comma = true
+# normalize_comments = true # nightly
+# normalize_doc_attributes = true # nightly
+# overflow_delimited_expr = true # nightly
+# reorder_impl_items = true # nightly
+# spaces_around_ranges = true # nightly
+# unstable_features = true # nightly
+use_field_init_shorthand = true
+use_try_shorthand = true

crates/provider_openai/src/speech.rs

@@ -1,10 +1,10 @@
-use axum::{body::Bytes, http::{header, HeaderMap}};
+use axum::{
+  body::Bytes,
+  http::{HeaderMap, header},
+};
 use reqwest::Client;
 use serde::Serialize;
-use unspeech_shared::{
-  AppError,
-  speech::ProcessedSpeechOptions,
-};
+use unspeech_shared::{AppError, speech::ProcessedSpeechOptions};
 
 #[derive(Serialize)]
 // https://platform.openai.com/docs/api-reference/audio/createSpeech
@@ -40,21 +40,26 @@ pub async fn handle(
     speed: options.speed,
   };
 
-  let res = client.post("https://api.openai.com/v1/audio/speech")
+  let res = client
+    .post("https://api.openai.com/v1/audio/speech")
     .bearer_auth(token)
     .json(&body)
     .send()
     .await?;
 
   if !res.status().is_success() {
     let status = res.status();
-    let body = res.text().await.unwrap_or_else(|err| format!("Could not read error body: {}", err));
-    return Err(AppError::new(anyhow::anyhow!("API request failed with status: {}\nBody: {}", status, body), None));
+    let body = res
+      .text()
+      .await
+      .unwrap_or_else(|err| format!("Could not read error body: {}", err));
+    return Err(AppError::new(
+      anyhow::anyhow!("API request failed with status: {}\nBody: {}", status, body),
+      None,
+    ));
   }
 
-  let bytes = res
-    .bytes()
-    .await?;
+  let bytes = res.bytes().await?;
 
   let mut headers = HeaderMap::new();
   // TODO: remove unwrap

crates/shared/src/error.rs

@@ -1,7 +1,7 @@
 use axum::{
+  Json,
   http::StatusCode,
-  response::{Response, IntoResponse},
-  Json
+  response::{IntoResponse, Response},
 };
 use serde::Serialize;
 
@@ -39,7 +39,7 @@ impl AppErrorResponse {
 
 impl IntoResponse for AppError {
   fn into_response(self) -> Response {
-      (self.status, Json(AppErrorResponse::new(self))).into_response()
+    (self.status, Json(AppErrorResponse::new(self))).into_response()
   }
 }
 

crates/shared/src/speech.rs

@@ -47,16 +47,21 @@ pub struct ProcessedSpeechOptions {
 
 pub fn process_speech_options(options: SpeechOptions) -> Result<ProcessedSpeechOptions, AppError> {
   match options.model.split_once('/') {
-    Some((provider, model)) if !provider.is_empty() && !model.is_empty() => Ok(ProcessedSpeechOptions {
-      input: options.input,
-      model: model.to_string(),
-      voice: options.voice,
-      instructions: options.instructions,
-      response_format: options.response_format,
-      speed: options.speed,
-      extra: options.extra,
-      provider: provider.to_string(),
-    }),
-    _ => Err(AppError::new(anyhow::anyhow!("Invalid model: {}", options.model), Some(StatusCode::BAD_REQUEST)))
+    Some((provider, model)) if !provider.is_empty() && !model.is_empty() => {
+      Ok(ProcessedSpeechOptions {
+        input: options.input,
+        model: model.to_string(),
+        voice: options.voice,
+        instructions: options.instructions,
+        response_format: options.response_format,
+        speed: options.speed,
+        extra: options.extra,
+        provider: provider.to_string(),
+      })
+    },
+    _ => Err(AppError::new(
+      anyhow::anyhow!("Invalid model: {}", options.model),
+      Some(StatusCode::BAD_REQUEST),
+    )),
   }
 }

src/main.rs

@@ -1,8 +1,8 @@
 use std::time::Duration;
 
 use axum::{
-  routing::{get, post},
   Router,
+  routing::{get, post},
 };
 use reqwest::Client;
 
@@ -17,24 +17,21 @@ use unspeech_shared::AppError;
 async fn main() -> Result<(), AppError> {
   tracing_subscriber::fmt::init();
 
-  let client = Client::builder()
-    .timeout(Duration::from_secs(60))
-    .build()?;
+  let client = Client::builder().timeout(Duration::from_secs(60)).build()?;
 
   let app = Router::new()
     .route("/", get(root))
     .route("/v1/audio/speech", post(speech))
     .with_state(client);
 
-  let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
-    .await?;
+  let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await?;
 
   tracing::debug!("listening on {}", listener.local_addr()?);
 
   Ok(
     axum::serve(listener, app)
       .with_graceful_shutdown(shutdown_signal())
-      .await?
+      .await?,
   )
 }
 

src/speech.rs

@@ -1,17 +1,12 @@
-use axum::{
-  body::Bytes, debug_handler, extract::State, http::HeaderMap, Json
-};
+use axum::{Json, body::Bytes, debug_handler, extract::State, http::HeaderMap};
 use axum_extra::{
-  headers::{authorization::Bearer, Authorization},
-  TypedHeader
+  TypedHeader,
+  headers::{Authorization, authorization::Bearer},
 };
 use reqwest::Client;
 use unspeech_shared::{
   AppError,
-  speech::{
-    SpeechOptions,
-    process_speech_options
-  }
+  speech::{SpeechOptions, process_speech_options},
 };
 
 #[debug_handler]
@@ -26,6 +21,9 @@ pub async fn speech(
   match options.provider.as_str() {
     #[cfg(feature = "openai")]
     "openai" => unspeech_provider_openai::speech::handle(options, client, token).await,
-    _ => Err(AppError::new(anyhow::anyhow!("Unsupported provider: {}", options.provider), None)),
+    _ => Err(AppError::new(
+      anyhow::anyhow!("Unsupported provider: {}", options.provider),
+      None,
+    )),
   }
 }