feat: with example

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

crates/dagger-cuddle-please/Cargo.toml

@@ -6,3 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+dagger-sdk.workspace = true
+eyre.workspace = true
+async-trait = "*"

crates/dagger-cuddle-please/src/lib.rs

@@ -1 +1,195 @@
+use std::sync::Arc;
 
+#[derive(Clone, Debug)]
+pub struct CuddlePleaseArgs {
+    pub repository: String,
+    pub owner: String,
+    pub branch: String,
+
+    pub cuddle_image: String,
+    pub server: Server,
+
+    pub log_level: Option<LogLevel>,
+
+    pub use_ssh_socket: bool,
+}
+
+#[derive(Clone, Debug)]
+pub enum LogLevel {
+    Trace,
+    Debug,
+    Info,
+    Warn,
+    Error,
+}
+
+#[derive(Clone, Debug)]
+pub enum Server {
+    Gitea {
+        url: String,
+        user: String,
+        token: String,
+        insecure: Option<bool>,
+    },
+    GitHub {
+        token: String,
+    },
+}
+
+#[async_trait::async_trait]
+pub trait CuddlePlease {
+    async fn execute(&self, args: &CuddlePleaseArgs) -> eyre::Result<()>;
+}
+
+pub struct DaggerCuddlePleaseAction(Arc<dyn CuddlePlease + Send + Sync + 'static>);
+
+impl DaggerCuddlePleaseAction {
+    pub fn dagger(client: Arc<dagger_sdk::Query>) -> Self {
+        Self(Arc::new(DaggerCuddlePlease::new(client)))
+    }
+
+    pub async fn execute(&self, args: &CuddlePleaseArgs) -> eyre::Result<()> {
+        self.0.execute(args).await
+    }
+}
+
+#[derive(Clone)]
+pub struct DaggerCuddlePlease {
+    client: Arc<dagger_sdk::Query>,
+}
+
+#[async_trait::async_trait]
+impl CuddlePlease for DaggerCuddlePlease {
+    async fn execute(&self, args: &CuddlePleaseArgs) -> eyre::Result<()> {
+        self.cuddle_please(self.client.clone(), args).await
+    }
+}
+
+impl DaggerCuddlePlease {
+    pub fn new(client: Arc<dagger_sdk::Query>) -> Self {
+        Self { client }
+    }
+
+    pub async fn cuddle_please(
+        &self,
+        client: Arc<dagger_sdk::Query>,
+        args: &CuddlePleaseArgs,
+    ) -> eyre::Result<()> {
+        let build_image = client.container().from(&args.cuddle_image);
+
+        let repo_url = match &args.server {
+            Server::Gitea {
+                url,
+                user,
+                token,
+                insecure,
+            } => {
+                if args.use_ssh_socket {
+                    format!(
+                        "ssh://{}:{}@{}/{}/{}",
+                        user, token, url, &args.owner, &args.repository
+                    )
+                } else {
+                    format!(
+                        "{}://{}:{}@{}/{}/{}",
+                        if insecure.unwrap_or(false) {
+                            "http"
+                        } else {
+                            "https"
+                        },
+                        user,
+                        token,
+                        url,
+                        &args.owner,
+                        &args.repository
+                    )
+                }
+            }
+            Server::GitHub { .. } => {
+                format!("https://github.com/{}/{}", &args.owner, &args.repository)
+            }
+        };
+        let api_url = match &args.server {
+            Server::Gitea { url, insecure, .. } => {
+                format!(
+                    "{}://{}",
+                    if insecure.unwrap_or(false) {
+                        "http"
+                    } else {
+                        "https"
+                    },
+                    url,
+                )
+            }
+            Server::GitHub { .. } => "https://github.com".into(),
+        };
+
+        let src = client
+            .git_opts(
+                &repo_url,
+                dagger_sdk::QueryGitOpts {
+                    experimental_service_host: None,
+                    keep_git_dir: Some(true),
+                },
+            )
+            .branch("main")
+            .tree();
+
+        let res = build_image
+            .with_secret_variable(
+                "CUDDLE_PLEASE_TOKEN",
+                client
+                    .set_secret(
+                        "CUDDLE_PLEASE_TOKEN",
+                        match &args.server {
+                            Server::Gitea { token, .. } => token,
+                            Server::GitHub { token } => token,
+                        },
+                    )
+                    .id()
+                    .await?,
+            )
+            .with_workdir("/mnt/app")
+            .with_directory(".", src.id().await?)
+            .with_exec(vec!["git", "remote", "set-url", "origin", &repo_url])
+            .with_exec(vec![
+                "cuddle-please",
+                "release",
+                &format!(
+                    "--engine={}",
+                    match &args.server {
+                        Server::Gitea { .. } => "gitea",
+                        Server::GitHub { .. } => "github",
+                    }
+                ),
+                "--owner",
+                &args.owner,
+                "--repo",
+                &args.repository,
+                "--branch",
+                &args.branch,
+                "--api-url",
+                &api_url,
+                "--log-level",
+                match args.log_level.as_ref().unwrap_or(&LogLevel::Info) {
+                    LogLevel::Trace => "trace",
+                    LogLevel::Debug => "debug",
+                    LogLevel::Info => "info",
+                    LogLevel::Warn => "warn",
+                    LogLevel::Error => "error",
+                },
+            ]);
+
+        let exit_code = res.exit_code().await?;
+        if exit_code != 0 {
+            eyre::bail!("failed to run cuddle-please");
+        }
+
+        let please_out = res.stdout().await?;
+        println!("{please_out}");
+        let please_out = res.stderr().await?;
+        println!("{please_out}");
+
+        Ok(())
+    }
+}