provisional migration to cling

This allows us to experiment with cling's design and limitations in practice. There will be further improvements but this is a fully functional migration.

cronback-cli/Cargo.toml

@@ -26,6 +26,7 @@ admin = ["cronback-client/admin", "cronback-api-model/admin"]
 [dependencies]
 cronback-client = { workspace = true }
 cronback-api-model = { workspace = true, features = ["client", "clap"] }
+cling = { git = "https://github.com/AhmedSoliman/cling.git", version = "0.0.0-alpha.2" }
 
 anyhow = { version = "1.0.71" }
 async-trait = { workspace = true }

cronback-cli/src/admin/api_keys/create.rs

@@ -1,45 +1,32 @@
 use anyhow::Result;
-use async_trait::async_trait;
-use clap::Parser;
+use cling::prelude::*;
 use cronback_api_model::admin::APIKeyMetaData;
 
 use crate::args::CommonOptions;
-use crate::{emitln, Command};
 
-#[derive(Clone, Debug, Parser)]
+#[derive(CliRunnable, CliParam, Clone, Debug, Parser)]
+#[cling(run = "create")]
 pub struct Create {
     /// The name of the key to be created
     name: String,
 }
 
-#[async_trait]
-impl Command for Create {
-    async fn run<
-        A: tokio::io::AsyncWrite + Send + Sync + Unpin,
-        B: tokio::io::AsyncWrite + Send + Sync + Unpin,
-    >(
-        &self,
-        out: &mut tokio::io::BufWriter<A>,
-        _err: &mut tokio::io::BufWriter<B>,
-        common_options: &CommonOptions,
-    ) -> Result<()> {
-        let client = common_options.new_client()?;
+async fn create(common_options: &CommonOptions, opts: &Create) -> Result<()> {
+    let client = common_options.new_client()?;
 
-        let response = cronback_client::api_keys::gen(
-            &client,
-            &self.name,
-            APIKeyMetaData::default(),
-        )
-        .await?;
+    let response = cronback_client::api_keys::gen(
+        &client,
+        &opts.name,
+        APIKeyMetaData::default(),
+    )
+    .await?;
 
-        let response = response.into_inner()?;
+    let response = response.into_inner()?;
 
-        emitln!(
-            out,
-            "API key with the name '{}' was created successfully.",
-            self.name
-        );
-        emitln!(out, "Secret key: '{}'", response.key);
-        Ok(())
-    }
+    println!(
+        "API key with the name '{}' was created successfully.",
+        opts.name
+    );
+    println!("Secret key: '{}'", response.key);
+    Ok(())
 }

cronback-cli/src/admin/api_keys/list.rs

@@ -1,45 +1,29 @@
 use anyhow::Result;
-use async_trait::async_trait;
-use clap::Parser;
+use cling::prelude::*;
 use prettytable::{row, Table};
 
 use crate::args::CommonOptions;
-use crate::{emitln, Command};
 
-#[derive(Clone, Debug, Parser)]
-pub struct List {}
+#[derive(CliRunnable, Clone, Debug, Parser)]
+#[cling(run = "list")]
+pub struct List;
 
-#[async_trait]
-impl Command for List {
-    async fn run<
-        A: tokio::io::AsyncWrite + Send + Sync + Unpin,
-        B: tokio::io::AsyncWrite + Send + Sync + Unpin,
-    >(
-        &self,
-        out: &mut tokio::io::BufWriter<A>,
-        _err: &mut tokio::io::BufWriter<B>,
-        common_options: &CommonOptions,
-    ) -> Result<()> {
-        let client = common_options.new_client()?;
+async fn list(common_options: &CommonOptions) -> Result<()> {
+    let client = common_options.new_client()?;
 
-        let response = cronback_client::api_keys::list(&client).await?;
+    let response = cronback_client::api_keys::list(&client).await?;
 
-        let response = response.into_inner()?;
-        // Print Table
-        if !response.data.is_empty() {
-            let mut table = Table::new();
-            table.set_titles(row!["Id", "Name", "Created At"]);
-            for key in response.data {
-                table.add_row(row![
-                    key.id,
-                    key.name,
-                    key.created_at.to_rfc2822(),
-                ]);
-            }
-
-            emitln!(out, "{}", table);
+    let response = response.into_inner()?;
+    // Print Table
+    if !response.data.is_empty() {
+        let mut table = Table::new();
+        table.set_titles(row!["Id", "Name", "Created At"]);
+        for key in response.data {
+            table.add_row(row![key.id, key.name, key.created_at.to_rfc2822(),]);
         }
 
-        Ok(())
+        println!("{}", table);
     }
+
+    Ok(())
 }

cronback-cli/src/admin/api_keys/mod.rs

@@ -1,15 +1,10 @@
-use anyhow::Result;
-use async_trait::async_trait;
-use clap::clap_derive::Parser;
-
-use crate::args::CommonOptions;
-use crate::Command;
+use cling::prelude::*;
 
 mod create;
 mod list;
 mod revoke;
 
-#[derive(Parser, Debug, Clone)]
+#[derive(CliRunnable, Subcommand, Debug, Clone)]
 pub enum ApiKeysCommand {
     /// List API keys
     #[command(visible_alias = "ls")]
@@ -19,26 +14,3 @@ pub enum ApiKeysCommand {
     /// Revokes an API key
     Revoke(revoke::Revoke),
 }
-
-#[async_trait]
-impl Command for ApiKeysCommand {
-    async fn run<
-        A: tokio::io::AsyncWrite + Send + Sync + Unpin,
-        B: tokio::io::AsyncWrite + Send + Sync + Unpin,
-    >(
-        &self,
-        out: &mut tokio::io::BufWriter<A>,
-        err: &mut tokio::io::BufWriter<B>,
-        common_options: &CommonOptions,
-    ) -> Result<()> {
-        match self {
-            | ApiKeysCommand::List(c) => c.run(out, err, common_options).await,
-            | ApiKeysCommand::Create(c) => {
-                c.run(out, err, common_options).await
-            }
-            | ApiKeysCommand::Revoke(c) => {
-                c.run(out, err, common_options).await
-            }
-        }
-    }
-}

cronback-cli/src/admin/api_keys/revoke.rs

@@ -1,12 +1,11 @@
 use anyhow::Result;
-use async_trait::async_trait;
-use clap::Parser;
+use cling::prelude::*;
 
 use crate::args::CommonOptions;
 use crate::confirm::confirm_or_abort;
-use crate::{emitln, Command};
 
-#[derive(Clone, Debug, Parser)]
+#[derive(CliRunnable, CliParam, Clone, Debug, Parser)]
+#[cling(run = "revoke")]
 pub struct Revoke {
     /// The Id of the key to be revoked
     id: String,
@@ -16,33 +15,21 @@ pub struct Revoke {
     yes: bool,
 }
 
-#[async_trait]
-impl Command for Revoke {
-    async fn run<
-        A: tokio::io::AsyncWrite + Send + Sync + Unpin,
-        B: tokio::io::AsyncWrite + Send + Sync + Unpin,
-    >(
-        &self,
-        out: &mut tokio::io::BufWriter<A>,
-        _err: &mut tokio::io::BufWriter<B>,
-        common_options: &CommonOptions,
-    ) -> Result<()> {
-        confirm_or_abort!(
-            self,
-            "Are you sure you want to revoke the key '{}'? All API calls with \
-             this key will start failing.",
-            self.id
-        );
-        let client = common_options.new_client()?;
-
-        let response =
-            cronback_client::api_keys::revoke(&client, &self.id).await?;
-
-        // Ensure that the request actually succeeded
-        response.into_inner()?;
-
-        emitln!(out, "Key with id '{}' was revoked!", self.id);
-
-        Ok(())
-    }
+async fn revoke(common_options: &CommonOptions, opts: &Revoke) -> Result<()> {
+    confirm_or_abort!(
+        opts,
+        "Are you sure you want to revoke the key '{}'? All API calls with \
+         this key will start failing.",
+        opts.id
+    );
+    let client = common_options.new_client()?;
+
+    let response = cronback_client::api_keys::revoke(&client, &opts.id).await?;
+
+    // Ensure that the request actually succeeded
+    response.into_inner()?;
+
+    println!("Key with id '{}' was revoked!", opts.id);
+
+    Ok(())
 }

cronback-cli/src/admin/mod.rs

@@ -1,46 +1,14 @@
-use anyhow::Result;
-use async_trait::async_trait;
-use clap::clap_derive::Parser;
-
-use crate::args::CommonOptions;
-use crate::Command;
+use cling::prelude::*;
 
 mod api_keys;
 mod projects;
 
-#[derive(Parser, Debug, Clone)]
+#[derive(CliRunnable, Subcommand, Debug, Clone)]
 pub enum AdminCommand {
     /// Commands for api key management. This subcommand requires admin
     /// privilliages.
-    ApiKeys {
-        #[command(subcommand)]
-        command: api_keys::ApiKeysCommand,
-    },
-
-    Projects {
-        #[command(subcommand)]
-        command: projects::ProjectsCommand,
-    },
-}
-
-#[async_trait]
-impl Command for AdminCommand {
-    async fn run<
-        A: tokio::io::AsyncWrite + Send + Sync + Unpin,
-        B: tokio::io::AsyncWrite + Send + Sync + Unpin,
-    >(
-        &self,
-        out: &mut tokio::io::BufWriter<A>,
-        err: &mut tokio::io::BufWriter<B>,
-        common_options: &CommonOptions,
-    ) -> Result<()> {
-        match self {
-            | AdminCommand::ApiKeys { command } => {
-                command.run(out, err, common_options).await
-            }
-            | AdminCommand::Projects { command } => {
-                command.run(out, err, common_options).await
-            }
-        }
-    }
+    #[command(subcommand)]
+    ApiKeys(api_keys::ApiKeysCommand),
+    #[command(subcommand)]
+    Projects(projects::ProjectsCommand),
 }