chore: change format

Author: dancixx

examples/auth/src/main.rs

@@ -1,61 +1,61 @@
 use anyhow::Result;
 use tako::{
-    Method,
-    middleware::{IntoMiddleware, basic_auth, bearer_auth},
-    responder::Responder,
-    types::Request,
+  Method,
+  middleware::{IntoMiddleware, basic_auth, bearer_auth},
+  responder::Responder,
+  types::Request,
 };
 
 async fn basic_auth_route(_: Request) -> impl Responder {
-    "Basic Auth Route"
+  "Basic Auth Route"
 }
 
 async fn bearer_auth_route(_: Request) -> impl Responder {
-    "Bearer Auth Route"
+  "Bearer Auth Route"
 }
 
 async fn basic_auth_with_verify(_: Request) -> impl Responder {
-    "Basic Auth Route with Verify"
+  "Basic Auth Route with Verify"
 }
 
 async fn bearer_auth_with_verify(_: Request) -> impl Responder {
-    "Bearer Auth Route with Verify"
+  "Bearer Auth Route with Verify"
 }
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let listener = tokio::net::TcpListener::bind("127.0.0.1:8080")
-        .await
-        .unwrap();
-    let mut router = tako::router::Router::new();
-
-    let basic = basic_auth::BasicAuth::single("admin", "pw")
-        .realm("Admin Area")
-        .into_middleware();
-    let bearer = bearer_auth::BearerAuth::static_token("my-secret-token").into_middleware();
-
-    router
-        .route_with_tsr(Method::GET, "/basic", basic_auth_route)
-        .middleware(basic);
-    router
-        .route_with_tsr(Method::POST, "/bearer", bearer_auth_route)
-        .middleware(bearer);
-
-    let basic_with_verify =
-        basic_auth::BasicAuth::with_verify(|user, password| user == "admin" && password == "pw")
-            .realm("Admin Area")
-            .into_middleware();
-    let bearer_with_verify =
-        bearer_auth::BearerAuth::with_verify(|token| token == "my-secret-token").into_middleware();
-
-    router
-        .route_with_tsr(Method::GET, "/basic_with_verify", basic_auth_with_verify)
-        .middleware(basic_with_verify);
-    router
-        .route_with_tsr(Method::POST, "/bearer_with_verify", bearer_auth_with_verify)
-        .middleware(bearer_with_verify);
-
-    tako::serve(listener, router).await;
-
-    Ok(())
+  let listener = tokio::net::TcpListener::bind("127.0.0.1:8080")
+    .await
+    .unwrap();
+  let mut router = tako::router::Router::new();
+
+  let basic = basic_auth::BasicAuth::single("admin", "pw")
+    .realm("Admin Area")
+    .into_middleware();
+  let bearer = bearer_auth::BearerAuth::static_token("my-secret-token").into_middleware();
+
+  router
+    .route_with_tsr(Method::GET, "/basic", basic_auth_route)
+    .middleware(basic);
+  router
+    .route_with_tsr(Method::POST, "/bearer", bearer_auth_route)
+    .middleware(bearer);
+
+  let basic_with_verify =
+    basic_auth::BasicAuth::with_verify(|user, password| user == "admin" && password == "pw")
+      .realm("Admin Area")
+      .into_middleware();
+  let bearer_with_verify =
+    bearer_auth::BearerAuth::with_verify(|token| token == "my-secret-token").into_middleware();
+
+  router
+    .route_with_tsr(Method::GET, "/basic_with_verify", basic_auth_with_verify)
+    .middleware(basic_with_verify);
+  router
+    .route_with_tsr(Method::POST, "/bearer_with_verify", bearer_auth_with_verify)
+    .middleware(bearer_with_verify);
+
+  tako::serve(listener, router).await;
+
+  Ok(())
 }

examples/extractors-multi/src/main.rs

@@ -6,57 +6,57 @@ use tokio::net::TcpListener;
 
 #[derive(Deserialize)]
 struct Pagination {
-    page: u32,
-    per_page: u32,
+  page: u32,
+  per_page: u32,
 }
 
 #[derive(Deserialize)]
 struct UserPath {
-    id: u64,
+  id: u64,
 }
 
 #[derive(Deserialize, Serialize, Clone)]
 struct CreateUser {
-    name: String,
-    email: String,
+  name: String,
+  email: String,
 }
 
 #[derive(Serialize)]
 struct Created {
-    id: u64,
-    name: String,
-    email: String,
+  id: u64,
+  name: String,
+  email: String,
 }
 
 // GET /users/{id}/posts?per_page=10&page=2
 // Demonstrates multiple extractors: Params + Query
 async fn list_user_posts(Params(user): Params<UserPath>, Query(p): Query<Pagination>) -> String {
-    format!(
-        "user_id={}, page={}, per_page={}",
-        user.id, p.page, p.per_page
-    )
+  format!(
+    "user_id={}, page={}, per_page={}",
+    user.id, p.page, p.per_page
+  )
 }
 
 // POST /users with JSON body {"name":"...","email":"..."}
 // Demonstrates a body extractor
 async fn create(Json(user): Json<CreateUser>) -> Json<Created> {
-    // Normally you'd persist the user; here we just echo back with an id
-    Json(Created {
-        id: 1,
-        name: user.name,
-        email: user.email,
-    })
+  // Normally you'd persist the user; here we just echo back with an id
+  Json(Created {
+    id: 1,
+    name: user.name,
+    email: user.email,
+  })
 }
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let listener = TcpListener::bind("127.0.0.1:8080").await?;
+  let listener = TcpListener::bind("127.0.0.1:8080").await?;
 
-    let mut router = Router::new();
-    router.route(Method::GET, "/users/{id}/posts", list_user_posts);
-    router.route(Method::POST, "/users", create);
+  let mut router = Router::new();
+  router.route(Method::GET, "/users/{id}/posts", list_user_posts);
+  router.route(Method::POST, "/users", create);
 
-    tako::serve(listener, router).await;
+  tako::serve(listener, router).await;
 
-    Ok(())
+  Ok(())
 }

examples/file-stream/src/main.rs

@@ -4,19 +4,19 @@ use tokio::{fs::File, net::TcpListener};
 use tokio_util::io::ReaderStream;
 
 async fn serve_file(_: Request) -> impl Responder {
-    let file = File::open("test.txt").await.unwrap();
-    let stream = ReaderStream::new(file);
-    let file_stream = FileStream::new(stream, Some("test.txt".to_string()), None);
-    file_stream.into_response()
+  let file = File::open("test.txt").await.unwrap();
+  let stream = ReaderStream::new(file);
+  let file_stream = FileStream::new(stream, Some("test.txt".to_string()), None);
+  file_stream.into_response()
 }
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let listener = TcpListener::bind("127.0.0.1:8080").await?;
+  let listener = TcpListener::bind("127.0.0.1:8080").await?;
 
-    let mut router = Router::new();
-    router.route(Method::GET, "/file", serve_file);
+  let mut router = Router::new();
+  router.route(Method::GET, "/file", serve_file);
 
-    tako::serve(listener, router).await;
-    Ok(())
+  tako::serve(listener, router).await;
+  Ok(())
 }

examples/graphql/src/main.rs

@@ -1,69 +1,70 @@
 use anyhow::Result;
-use async_graphql::{Context, EmptyMutation, Object, Schema, Subscription};
 use async_graphql::futures_util::Stream;
 use async_graphql::futures_util::stream;
-use tako::{Method, router::Router};
+use async_graphql::{Context, EmptyMutation, Object, Schema, Subscription};
+use std::time::Duration;
 use tako::extractors::FromRequest;
 use tako::graphql::{GraphQLRequest, GraphQLResponse, GraphQLSubscription};
 use tako::types::Request as TakoRequest;
+use tako::{Method, router::Router};
 use tokio::net::TcpListener;
-use std::time::Duration;
 
 struct QueryRoot;
 
 #[Object]
 impl QueryRoot {
-    async fn hello(&self) -> &str { "Hello, GraphQL!" }
+  async fn hello(&self) -> &str {
+    "Hello, GraphQL!"
+  }
 }
 
 struct SubscriptionRoot;
 
 #[Subscription]
 impl SubscriptionRoot {
-    async fn tick(&self, _ctx: &Context<'_>) -> impl Stream<Item = i32> {
-        stream::unfold(0, |i| async move {
-            tokio::time::sleep(Duration::from_millis(200)).await;
-            Some((i, i + 1))
-        })
-    }
+  async fn tick(&self, _ctx: &Context<'_>) -> impl Stream<Item = i32> {
+    stream::unfold(0, |i| async move {
+      tokio::time::sleep(Duration::from_millis(200)).await;
+      Some((i, i + 1))
+    })
+  }
 }
 
 type AppSchema = Schema<QueryRoot, EmptyMutation, SubscriptionRoot>;
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let listener = TcpListener::bind("127.0.0.1:8080").await?;
+  let listener = TcpListener::bind("127.0.0.1:8080").await?;
 
-    let schema = Schema::build(QueryRoot, EmptyMutation, SubscriptionRoot)
-        .finish();
+  let schema = Schema::build(QueryRoot, EmptyMutation, SubscriptionRoot).finish();
 
-    let mut router = Router::new();
+  let mut router = Router::new();
 
-    // POST /graphql
-    router.route(Method::POST, "/graphql", {
-        let schema = schema.clone();
-        move |mut req: TakoRequest| {
-            let schema = schema.clone();
-            async move {
-                let gql_req: GraphQLRequest = GraphQLRequest::from_request(&mut req).await.unwrap();
-                let resp = schema.execute(gql_req.0).await;
-                GraphQLResponse(resp)
-            }
-        }
-    });
+  // POST /graphql
+  router.route(Method::POST, "/graphql", {
+    let schema = schema.clone();
+    move |mut req: TakoRequest| {
+      let schema = schema.clone();
+      async move {
+        let gql_req: GraphQLRequest = GraphQLRequest::from_request(&mut req).await.unwrap();
+        let resp = schema.execute(gql_req.0).await;
+        GraphQLResponse(resp)
+      }
+    }
+  });
 
-    // GET /ws for subscriptions (graphql-transport-ws or graphql-ws)
-    router.route(Method::GET, "/ws", {
-        let schema = schema.clone();
-        move |req: TakoRequest| {
-            let schema = schema.clone();
-            async move { GraphQLSubscription::new(req, schema) }
-        }
-    });
+  // GET /ws for subscriptions (graphql-transport-ws or graphql-ws)
+  router.route(Method::GET, "/ws", {
+    let schema = schema.clone();
+    move |req: TakoRequest| {
+      let schema = schema.clone();
+      async move { GraphQLSubscription::new(req, schema) }
+    }
+  });
 
-    println!("GraphQL: POST http://127.0.0.1:8080/graphql");
-    println!("Subscriptions (WS): ws://127.0.0.1:8080/ws");
+  println!("GraphQL: POST http://127.0.0.1:8080/graphql");
+  println!("Subscriptions (WS): ws://127.0.0.1:8080/ws");
 
-    tako::serve(listener, router).await;
-    Ok(())
+  tako::serve(listener, router).await;
+  Ok(())
 }

examples/health/src/main.rs

@@ -5,23 +5,23 @@ use tokio::net::TcpListener;
 
 #[derive(Serialize)]
 pub struct HealthCheck {
-    status: String,
+  status: String,
 }
 
 async fn health() -> Json<HealthCheck> {
-    Json(HealthCheck {
-        status: "OK".to_string(),
-    })
+  Json(HealthCheck {
+    status: "OK".to_string(),
+  })
 }
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let listener = TcpListener::bind("127.0.0.1:8080").await?;
+  let listener = TcpListener::bind("127.0.0.1:8080").await?;
 
-    let mut router = Router::new();
-    router.route(Method::GET, "/health", health);
+  let mut router = Router::new();
+  router.route(Method::GET, "/health", health);
 
-    tako::serve(listener, router).await;
+  tako::serve(listener, router).await;
 
-    Ok(())
+  Ok(())
 }

examples/hello-world/src/main.rs

@@ -3,17 +3,17 @@ use tako::{Method, responder::Responder, router::Router};
 use tokio::net::TcpListener;
 
 async fn hello_world() -> impl Responder {
-    "Hello, World!".into_response()
+  "Hello, World!".into_response()
 }
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let listener = TcpListener::bind("127.0.0.1:8080").await?;
+  let listener = TcpListener::bind("127.0.0.1:8080").await?;
 
-    let mut router = Router::new();
-    router.route(Method::GET, "/", hello_world);
+  let mut router = Router::new();
+  router.route(Method::GET, "/", hello_world);
 
-    tako::serve(listener, router).await;
+  tako::serve(listener, router).await;
 
-    Ok(())
+  Ok(())
 }