feat: refactor projects

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

crates/cuddle-actions/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "cuddle-actions"
+edition = "2021"
+version.workspace = true
+
+[dependencies]
+cuddle-rust-actions.workspace = true
+cuddle-actions-api.workspace = true
+cuddle-value.workspace = true
+
+serde.workspace = true
+tokio.workspace = true
+tracing.workspace = true
+anyhow.workspace = true
+dirs.workspace = true
+walkdir.workspace = true
+sha256.workspace = true
+blake3.workspace = true

crates/cuddle-actions/src/lib.rs

@@ -0,0 +1,101 @@
+use std::path::{Path, PathBuf};
+
+use cuddle_actions_api::ExecutableActions;
+use cuddle_rust_actions::RustActionsBuilder;
+use cuddle_value::Value;
+
+pub struct Actions {
+    variants: Vec<ActionVariant>,
+}
+
+impl Actions {
+    pub async fn new(path: &Path, value: &Value) -> anyhow::Result<Option<Self>> {
+        let Some(project) = value.get(&["project", "actions"]) else {
+            tracing::debug!("found no actions folder");
+            return Ok(None);
+        };
+
+        let mut variants = Vec::default();
+        if let Some(Value::Bool(true)) = project.get(&["rust"]) {
+            tracing::debug!("rust actions enabled");
+            variants.push(ActionVariant::Rust {
+                root_path: path.to_path_buf(),
+            });
+        } else {
+            tracing::trace!("rust actions not enabled");
+        }
+
+        Ok(Some(Self { variants }))
+    }
+
+    pub async fn build(&mut self) -> anyhow::Result<ExecutableActions> {
+        let mut executable_actions = Vec::default();
+
+        self.clean_cache().await?;
+
+        for variant in &mut self.variants {
+            match variant {
+                ActionVariant::Rust { root_path } => {
+                    let actions = RustActionsBuilder::new(root_path.clone()).build().await?;
+
+                    executable_actions.push(actions);
+                }
+                ActionVariant::Docker => todo!(),
+            }
+        }
+
+        let mut exec_actions = ExecutableActions::default();
+        for mut actions in executable_actions {
+            exec_actions.actions.append(&mut actions.actions);
+        }
+
+        Ok(exec_actions)
+    }
+
+    fn global_registry(&self) -> anyhow::Result<Option<PathBuf>> {
+        if let Some(dir) = dirs::cache_dir().map(|c| c.join("sh.cuddle/registry/actions/rust")) {
+            if !dir.exists() {
+                std::fs::create_dir_all(&dir)?;
+            }
+
+            Ok(Some(dir))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// clean_cache checks whether a given function has been used in the last month, if it hasn't it is automatically removed, and potentially reconstructed again on demand
+    pub async fn clean_cache(&mut self) -> anyhow::Result<()> {
+        let now = std::time::SystemTime::now();
+
+        let mut file_stream = tokio::fs::read_dir(
+            self.global_registry()?
+                .ok_or(anyhow::anyhow!("failed to get global registry"))?,
+        )
+        .await?;
+        while let Ok(Some(entry)) = file_stream.next_entry().await {
+            tracing::trace!("checking file: {}", entry.path().display());
+            let metadata = entry.metadata().await?;
+
+            if metadata.is_dir() {
+                let modified = metadata.modified()?;
+
+                let cache_threshold = now
+                    .checked_sub(std::time::Duration::from_secs(60 * 24 * 30)) // Cache duration is a month
+                    .expect("to be able to have a systemtime above a week");
+
+                if modified < cache_threshold {
+                    tracing::debug!("cleaning up entry: {}", entry.path().display());
+                    tokio::fs::remove_dir_all(entry.path()).await?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+pub enum ActionVariant {
+    Rust { root_path: PathBuf },
+    Docker,
+}