chore: fmt

Signed-off-by: kjuulh <contact@kjuulh.io>

crates/cuddle-ci/src/cli.rs

@@ -1,4 +1,4 @@
-use std::{env::Args, sync::Arc};
+use std::{sync::Arc};
 
 use async_trait::async_trait;
 
@@ -50,17 +50,17 @@ impl CuddleCI {
 
         match matches.subcommand() {
             Some((name, args)) => match (name, args) {
-                ("pr", args) => {
+                ("pr", _args) => {
                     eprintln!("starting pr validate");
                     self.pr_action.execute_pull_request().await?;
                     eprintln!("finished pr validate");
                 }
-                ("main", args) => {
+                ("main", _args) => {
                     eprintln!("starting main validate");
                     self.main_action.execute_main().await?;
                     eprintln!("finished main validate");
                 }
-                ("release", args) => {
+                ("release", _args) => {
                     eprintln!("starting release validate");
                     self.release_action.execute_release().await?;
                     eprintln!("finished release validate");

crates/cuddle-ci/src/lib.rs

@@ -2,110 +2,4 @@ pub mod cli;
 pub use cli::*;
 
 pub mod dagger_middleware;
-
-pub mod rust_service {
-    use std::{future::Future, pin::Pin, sync::Arc};
-
-    use async_trait::async_trait;
-    use dagger_sdk::Container;
-    use futures::future::BoxFuture;
-
-    use crate::{dagger_middleware::DaggerMiddleware, MainAction, PullRequestAction};
-
-    pub type DynMiddleware = Box<dyn DaggerMiddleware + Send + Sync>;
-
-    pub enum RustServiceStage {
-        BeforeBase(DynMiddleware),
-        AfterBase(DynMiddleware),
-        BeforeRelease(DynMiddleware),
-        AfterRelease(DynMiddleware),
-    }
-
-    pub struct RustService {
-        client: dagger_sdk::Query,
-
-        base_image: Option<dagger_sdk::Container>,
-
-        stages: Vec<RustServiceStage>,
-    }
-
-    impl From<dagger_sdk::Query> for RustService {
-        fn from(value: dagger_sdk::Query) -> Self {
-            Self {
-                client: value,
-                base_image: None,
-                stages: Vec::new(),
-            }
-        }
-    }
-
-    impl RustService {
-        pub async fn new() -> eyre::Result<Self> {
-            Ok(Self {
-                client: dagger_sdk::connect().await?,
-                base_image: None,
-                stages: Vec::new(),
-            })
-        }
-
-        pub fn with_base_image(&mut self, base: dagger_sdk::Container) -> &mut Self {
-            self.base_image = Some(base);
-
-            self
-        }
-
-        pub fn add_stage(&mut self, stage: RustServiceStage) -> &mut Self {
-            self
-        }
-
-        pub fn with_sqlx(&mut self) -> &mut Self {
-            self
-        }
-
-        pub async fn build_release(&self) -> eyre::Result<Vec<Container>> {
-            Ok(Vec::new())
-        }
-    }
-
-    #[async_trait]
-    impl PullRequestAction for RustService {
-        async fn execute_pull_request(&self) -> eyre::Result<()> {
-            self.build_release().await?;
-
-            Ok(())
-        }
-    }
-
-    #[async_trait]
-    impl MainAction for RustService {
-        async fn execute_main(&self) -> eyre::Result<()> {
-            Ok(())
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use futures::FutureExt;
-
-    use crate::{
-        dagger_middleware::middleware,
-        rust_service::{RustService, RustServiceStage},
-    };
-
-    use super::*;
-
-    #[tokio::test]
-    async fn can_build_rust() -> eyre::Result<()> {
-        let client = dagger_sdk::connect().await?;
-
-        RustService::from(client.clone())
-            .with_base_image(client.container().from("rustlang/rust:nightly"))
-            .with_sqlx()
-            .add_stage(RustServiceStage::BeforeBase(middleware(|c| async move { Ok(c) }.boxed())))
-            .build_release()
-            .await?;
-
-        Ok(())
-    }
-}
+pub mod rust_service;

crates/cuddle-ci/src/rust_service.rs

@@ -0,0 +1,104 @@
+
+
+use async_trait::async_trait;
+use dagger_sdk::Container;
+
+
+use crate::{dagger_middleware::DaggerMiddleware, MainAction, PullRequestAction};
+
+pub type DynMiddleware = Box<dyn DaggerMiddleware + Send + Sync>;
+
+pub enum RustServiceStage {
+    BeforeBase(DynMiddleware),
+    AfterBase(DynMiddleware),
+    BeforeRelease(DynMiddleware),
+    AfterRelease(DynMiddleware),
+}
+
+pub struct RustService {
+    client: dagger_sdk::Query,
+
+    base_image: Option<dagger_sdk::Container>,
+
+    stages: Vec<RustServiceStage>,
+}
+
+impl From<dagger_sdk::Query> for RustService {
+    fn from(value: dagger_sdk::Query) -> Self {
+        Self {
+            client: value,
+            base_image: None,
+            stages: Vec::new(),
+        }
+    }
+}
+
+impl RustService {
+    pub async fn new() -> eyre::Result<Self> {
+        Ok(Self {
+            client: dagger_sdk::connect().await?,
+            base_image: None,
+            stages: Vec::new(),
+        })
+    }
+
+    pub fn with_base_image(&mut self, base: dagger_sdk::Container) -> &mut Self {
+        self.base_image = Some(base);
+
+        self
+    }
+
+    pub fn with_stage(&mut self, _stage: RustServiceStage) -> &mut Self {
+        self
+    }
+
+    pub fn with_sqlx(&mut self) -> &mut Self {
+        self
+    }
+
+    pub async fn build_release(&self) -> eyre::Result<Vec<Container>> {
+        Ok(Vec::new())
+    }
+}
+
+#[async_trait]
+impl PullRequestAction for RustService {
+    async fn execute_pull_request(&self) -> eyre::Result<()> {
+        self.build_release().await?;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl MainAction for RustService {
+    async fn execute_main(&self) -> eyre::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use futures::FutureExt;
+
+    use crate::{
+        dagger_middleware::middleware,
+        rust_service::{RustService, RustServiceStage},
+    };
+
+    
+
+    #[tokio::test]
+    async fn can_build_rust() -> eyre::Result<()> {
+        let client = dagger_sdk::connect().await?;
+
+        RustService::from(client.clone())
+            .with_base_image(client.container().from("rustlang/rust:nightly"))
+            .with_sqlx()
+            .with_stage(RustServiceStage::BeforeBase(middleware(|c| async move { Ok(c) }.boxed())))
+            .build_release()
+            .await?;
+
+        Ok(())
+    }
+}