add: support YAML configuration format (#39)

* add: support YAML configuration format

* chore: var name

---------

Co-authored-by: queil <queil@users.noreply.github.com>

Author: queil

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rooz"
-version = "0.60.0"
+version = "0.61.0"
 edition = "2021"
 
 [dependencies]
@@ -19,6 +19,7 @@ log = "0.4.20"
 rand = "0.8.5"
 regex = "1.7.1"
 serde = "1.0.188"
+serde_yaml = "0.9.34"
 termion = "2.0.1"
 tokio = { version = "1.32.0", features = ["rt-multi-thread", "macros"] }
 toml = "0.7.8"

Cargo.toml

@@ -216,7 +216,6 @@ impl<'a> WorkspaceApi<'a> {
         root: bool,
         ephemeral: bool,
     ) -> Result<(), AnyError> {
-
         println!("{}", termion::clear::All);
 
         let enter_labels = Labels::new(Some(workspace_key), None)

src/api/workspace.rs

@@ -1,9 +1,9 @@
 use crate::{
-    api::{container, GitApi},
+    api::{container, ExecApi, GitApi},
     id,
     labels::Labels,
     model::{
-        config::RoozCfg,
+        config::{FileFormat, RoozCfg},
         types::{AnyError, ContainerResult, GitCloneSpec, RunSpec},
         volume::RoozVolume,
     },
@@ -26,6 +26,35 @@ fn get_clone_dir(root_dir: &str, git_ssh_url: &str) -> String {
     work_dir
 }
 
+impl<'a> ExecApi<'a> {
+    pub async fn read_rooz_config(
+        &self,
+        container_id: &str,
+        clone_dir: &str,
+        file_format: FileFormat,
+    ) -> Result<(FileFormat, String), AnyError> {
+        let file_path = &format!("{}/.rooz.{}", clone_dir, file_format.to_string());
+
+        let config = self
+            .output(
+                "rooz-cfg",
+                &container_id,
+                None,
+                Some(vec![
+                    "sh",
+                    "-c",
+                    format!(
+                        "ls {} > /dev/null 2>&1 && cat `ls {} | head -1`",
+                        file_path, file_path
+                    )
+                    .as_ref(),
+                ]),
+            )
+            .await?;
+        Ok((file_format, config))
+    }
+}
+
 impl<'a> GitApi<'a> {
     pub async fn clone_repo(
         &self,
@@ -96,24 +125,16 @@ impl<'a> GitApi<'a> {
                 .await?;
         };
 
-        let rooz_cfg = self
+        let (file_format, rooz_cfg) = self
             .api
             .exec
-            .output(
-                "rooz-toml",
-                &container_id,
-                None,
-                Some(vec![
-                    "sh",
-                    "-c",
-                    format!(
-                        "ls {}/.rooz.toml > /dev/null 2>&1 && cat {}/.rooz.toml",
-                        clone_dir, clone_dir
-                    )
-                    .as_ref(),
-                ]),
-            )
-            .await?;
+            .read_rooz_config(container_id, &clone_dir, FileFormat::Toml)
+            .await
+            .or(self
+                .api
+                .exec
+                .read_rooz_config(container_id, &clone_dir, FileFormat::Yaml)
+                .await)?;
 
         log::debug!("Repo config result: {}", &rooz_cfg);
 
@@ -123,7 +144,7 @@ impl<'a> GitApi<'a> {
             if rooz_cfg.is_empty() {
                 None
             } else {
-                Some(RoozCfg::from_string(rooz_cfg))
+                Some(RoozCfg::from_string(rooz_cfg, file_format))
             },
             GitCloneSpec { dir: clone_dir },
         ))

src/git.rs

@@ -36,14 +36,18 @@ async fn main() -> Result<(), AnyError> {
 
     let args = Cli::parse();
 
-    let connection = if let Cli{env_remote:Some(true), command:_ } = args {
+    let connection = if let Cli {
+        env_remote: Some(true),
+        command: _,
+    } = args
+    {
         Docker::connect_with_ssl_defaults()
     } else {
         Docker::connect_with_local_defaults()
     };
 
     let docker = connection.expect("Docker API connection established");
-     
+
     log::debug!("Client ver: {}", &docker.client_version());
 
     let version = &docker.version().await?;
@@ -211,7 +215,13 @@ async fn main() -> Result<(), AnyError> {
                 .await?
         }
 
-        Cli {command:System(cli::System{command:cli::SystemCommands::Completion(CompletionParams{shell}),}), env_remote: _ } => {
+        Cli {
+            command:
+                System(cli::System {
+                    command: cli::SystemCommands::Completion(CompletionParams { shell }),
+                }),
+            env_remote: _,
+        } => {
             let mut cli = Cli::command()
                 .disable_help_flag(true)
                 .disable_help_subcommand(true);

src/main.rs

@@ -1,6 +1,6 @@
 use crate::{cli::WorkParams, constants};
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, fs};
+use std::{collections::HashMap, ffi::OsStr, fs, path::Path};
 
 use super::types::AnyError;
 
@@ -28,18 +28,42 @@ pub struct RoozCfg {
     pub privileged: Option<bool>,
 }
 
-impl RoozCfg {
-    pub fn from_file(path: &str) -> Result<RoozCfg, Box<dyn std::error::Error + 'static>> {
-        Self::from_string(fs::read_to_string(path)?)
+#[derive(Debug, Clone)]
+pub enum FileFormat {
+    Toml,
+    Yaml,
+}
+
+impl FileFormat {
+    pub fn to_string(&self) -> String {
+        match self {
+            FileFormat::Toml => "toml".into(),
+            FileFormat::Yaml => "y*ml".into(),
+        }
     }
 
-    pub fn from_string(config: String) -> Result<RoozCfg, Box<dyn std::error::Error + 'static>> {
-        let f = RoozCfg::deserialize(toml::de::Deserializer::new(&config));
-        match f {
-            Ok(val) => Ok(val),
-            Err(e) => Err(Box::new(e)),
+    pub fn from_path(path: &str) -> FileFormat {
+        match Path::new(path).extension().and_then(OsStr::to_str) {
+            Some("yaml") => FileFormat::Yaml,
+            Some("yml") => FileFormat::Yaml,
+            Some("toml") => FileFormat::Toml,
+            Some(other) => panic!("Config file format: {} is not supported", other),
+            None => panic!("Only toml and yaml config file formats are supported."),
         }
     }
+}
+
+impl RoozCfg {
+    pub fn from_file(path: &str) -> Result<RoozCfg, AnyError> {
+        Self::from_string(fs::read_to_string(path)?, FileFormat::from_path(&path))
+    }
+
+    pub fn from_string(config: String, file_format: FileFormat) -> Result<RoozCfg, AnyError> {
+        Ok(match file_format {
+            FileFormat::Yaml => RoozCfg::deserialize(serde_yaml::Deserializer::from_str(&config))?,
+            FileFormat::Toml => RoozCfg::deserialize(toml::de::Deserializer::new(&config))?,
+        })
+    }
 
     fn extend_if_any<A, T: Extend<A> + IntoIterator<Item = A>>(
         target: Option<T>,