feat: working cuddle actions,

although I am not entirely happy with it, as we're missing args, state and project variables

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

crates/cuddle-actions/src/lib.rs

@@ -6,7 +6,7 @@ use serde::Serialize;
 
 // Fix design make it so that it works like axum!
 
-type ActionFn = dyn Fn() + 'static;
+type ActionFn = dyn Fn() -> anyhow::Result<()> + 'static;
 
 struct Action {
     name: String,
@@ -38,7 +38,7 @@ impl CuddleActions {
         options: &AddActionOptions,
     ) -> &mut Self
     where
-        F: Fn() + 'static,
+        F: Fn() -> anyhow::Result<()> + 'static,
     {
         self.actions.insert(
             name.into(),
@@ -53,41 +53,68 @@ impl CuddleActions {
     }
 
     pub fn execute(&mut self) -> anyhow::Result<()> {
-        let output = self.execute_from(std::env::args())?;
-
-        // Write all stdout to buffer
-        std::io::stdout().write_all(output.as_bytes())?;
-        std::io::stdout().write_all("\n".as_bytes())?;
+        self.execute_from(std::env::args())?;
 
         Ok(())
     }
 
-    pub fn execute_from<I, T>(&mut self, items: I) -> anyhow::Result<String>
+    pub fn execute_from<I, T>(&mut self, items: I) -> anyhow::Result<()>
     where
         I: IntoIterator<Item = T>,
         T: Into<OsString> + Clone,
     {
+        let mut do_cmd = clap::Command::new("do").subcommand_required(true);
+
+        for action in self.actions.values() {
+            let mut do_action_cmd = clap::Command::new(action.name.clone());
+            if let Some(description) = &action.description {
+                do_action_cmd = do_action_cmd.about(description.clone());
+            }
+
+            do_cmd = do_cmd.subcommand(do_action_cmd);
+        }
+
         let root = clap::Command::new("cuddle-action")
             .subcommand_required(true)
-            .subcommand(clap::Command::new("schema"));
+            .subcommand(clap::Command::new("schema"))
+            .subcommand(do_cmd);
 
-        let matches = root.get_matches_from(items);
+        let matches = root.try_get_matches_from(items)?;
         match matches.subcommand().expect("subcommand to be required") {
             ("schema", _args) => {
-                let schema = self
-                    .actions
-                    .values()
-                    .map(|a| ActionSchema {
-                        name: &a.name,
-                        description: a.description.as_ref().map(|d| d.as_str()),
-                    })
-                    .collect::<Vec<_>>();
+                let output = self.get_pretty_actions()?;
 
-                let output = serde_json::to_string_pretty(&schema)?;
+                // Write all stdout to buffer
+                std::io::stdout().write_all(output.as_bytes())?;
+                std::io::stdout().write_all("\n".as_bytes())?;
 
-                Ok(output)
+                Ok(())
             }
-            _ => Ok("".into()),
+            ("do", args) => {
+                let (command_name, _args) = args.subcommand().unwrap();
+                match self.actions.get_mut(command_name) {
+                    Some(action) => (*action.f)(),
+                    None => {
+                        anyhow::bail!("command not found: {}", command_name);
+                    }
+                }
+            }
+            _ => anyhow::bail!("no command found"),
         }
     }
+
+    pub fn get_pretty_actions(&self) -> anyhow::Result<String> {
+        let schema = self
+            .actions
+            .values()
+            .map(|a| ActionSchema {
+                name: &a.name,
+                description: a.description.as_deref(),
+            })
+            .collect::<Vec<_>>();
+
+        let output = serde_json::to_string_pretty(&schema)?;
+
+        Ok(output)
+    }
 }