remove default yaml usage, relying on serde instead

Author: bengl

Cargo.lock

@@ -13,12 +13,13 @@ rust-version = "1.84.1"
 lto = true
 
 [dependencies]
-nodejs-semver = "4.1.0"
+nodejs-semver = { version = "4.1.0", features = ["serde"] }
+serde = { version = "1.0.219", features = ["derive"] }
 swc = "21.0.0"
 swc_core = { version = "22.4.0", features = ["ecma_plugin_transform","ecma_quote"] }
 swc_ecma_parser = "11.1.2"
 swc_ecma_visit = { version = "8.0.0", features = ["path"] }
-yaml-rust2 = "0.10.0"
 
 [dev-dependencies]
 assert_cmd = "2.0.16"
+serde_yaml = "0.9.34"

Cargo.toml

@@ -2,57 +2,34 @@ use std::path::PathBuf;
 
 use nodejs_semver::{Range, Version};
 
-use crate::error::OrchestrionError;
 use crate::function_query::FunctionQuery;
 
-use yaml_rust2::{Yaml, YamlLoader};
+use serde::Deserialize;
 
-macro_rules! get_str {
-    ($property:expr, $name:expr) => {
-        $property[$name]
-            .as_str()
-            .ok_or(format!("Invalid config: '{}' must be a string", $name))?
-    };
-}
-
-macro_rules! get_arr {
-    ($property:expr, $name:expr) => {
-        $property[$name]
-            .as_vec()
-            .ok_or(format!("Invalid config: '{}' must be a array", $name))?
-    };
-}
-
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Deserialize)]
 pub enum InstrumentationOperator {
+    #[serde(rename = "traceCallback")]
     Callback,
+    #[serde(rename = "tracePromise")]
     Promise,
+    #[serde(rename = "traceSync")]
     Sync,
+    #[serde(rename = "traceAsync")]
     Async,
 }
 
 impl InstrumentationOperator {
-    pub fn as_str(&self) -> &'static str {
+    pub fn as_str(&self) -> &str {
         match self {
             InstrumentationOperator::Callback => "traceCallback",
             InstrumentationOperator::Promise => "tracePromise",
             InstrumentationOperator::Sync => "traceSync",
             InstrumentationOperator::Async => "traceAsync",
         }
     }
-
-    pub fn from_str(s: &str) -> Option<InstrumentationOperator> {
-        match s {
-            "traceCallback" => Some(InstrumentationOperator::Callback),
-            "tracePromise" => Some(InstrumentationOperator::Promise),
-            "traceSync" => Some(InstrumentationOperator::Sync),
-            "traceAsync" => Some(InstrumentationOperator::Async),
-            _ => None,
-        }
-    }
 }
 
-#[derive(Debug)]
+#[derive(Deserialize, Debug, Clone)]
 pub struct InstrumentationConfig {
     pub module_name: String,
     pub version_range: Range,
@@ -62,49 +39,20 @@ pub struct InstrumentationConfig {
     pub channel_name: String,
 }
 
-pub struct Config {
+#[derive(Deserialize, Clone)]
+pub struct OrchestrionConfig {
     pub instrumentations: Vec<InstrumentationConfig>,
+    #[serde(default = "OrchestrionConfig::dc_module_default")]
     pub dc_module: String,
 }
 
-impl Config {
-    pub fn from_yaml_data(yaml_str: &str) -> Result<Config, OrchestrionError> {
-        let docs = YamlLoader::load_from_str(yaml_str)?;
-        let doc = &docs[0];
-
-        let version = doc["version"]
-            .as_i64()
-            .ok_or("Invalid config: 'version' must be a number")?;
-        if version != 1 {
-            return Err("Invalid config version".into());
-        }
-
-        let dc_module = doc["dc_module"].as_str().unwrap_or("diagnostics_channel");
-
-        let configs = InstrumentationConfig::from_yaml(doc)?;
-
-        Ok(Config {
-            instrumentations: configs,
-            dc_module: dc_module.to_string(),
-        })
+impl OrchestrionConfig {
+    fn dc_module_default() -> String {
+        "diagnostics_channel".to_string()
     }
 }
 
 impl InstrumentationConfig {
-    pub fn from_yaml(doc: &Yaml) -> Result<Vec<InstrumentationConfig>, OrchestrionError> {
-        let instrumentations = get_arr!(doc, "instrumentations");
-        let mut configs = Vec::new();
-
-        for instr in instrumentations {
-            instr
-                .as_hash()
-                .ok_or("Invalid config: 'instrumentations' must be a array of objects")?;
-            configs.push(instr.try_into()?);
-        }
-
-        Ok(configs)
-    }
-
     pub fn matches(&self, module_name: &str, version: &str, file_path: &PathBuf) -> bool {
         let version: Version = match version.parse() {
             Ok(v) => v,
@@ -115,32 +63,3 @@ impl InstrumentationConfig {
             && self.file_path == *file_path
     }
 }
-
-impl TryFrom<&Yaml> for InstrumentationConfig {
-    type Error = OrchestrionError;
-
-    fn try_from(instr: &Yaml) -> Result<Self, Self::Error> {
-        let module_name = get_str!(instr, "module_name");
-        let version_range = get_str!(instr, "version_range");
-        let version_range: Range = version_range
-            .parse()
-            .map_err(|_| format!("Invalid version range: {version_range}"))?;
-        let file_path = PathBuf::from(get_str!(instr, "file_path"));
-        if instr["function_query"].as_hash().is_none() {
-            return Err("Invalid config: 'function_query' must be a object".into());
-        }
-        let function_query = (&instr["function_query"]).try_into()?;
-        let operator = InstrumentationOperator::from_str(get_str!(instr, "operator"))
-            .unwrap_or(InstrumentationOperator::Sync);
-        let channel_name = get_str!(instr, "channel_name");
-
-        Ok(InstrumentationConfig {
-            module_name: module_name.to_string(),
-            version_range,
-            file_path,
-            function_query,
-            operator,
-            channel_name: channel_name.to_string(),
-        })
-    }
-}

src/config.rs

@@ -2,9 +2,7 @@ use std::fmt::{self, Display, Formatter};
 
 #[derive(Debug)]
 pub enum OrchestrionError {
-    InvalidVersionRange(String),
     IoError(std::io::Error),
-    YamlParseError(yaml_rust2::ScanError),
     StrError(String),
 }
 
@@ -14,12 +12,6 @@ impl From<std::io::Error> for OrchestrionError {
     }
 }
 
-impl From<yaml_rust2::ScanError> for OrchestrionError {
-    fn from(e: yaml_rust2::ScanError) -> Self {
-        OrchestrionError::YamlParseError(e)
-    }
-}
-
 impl From<String> for OrchestrionError {
     fn from(s: String) -> Self {
         OrchestrionError::StrError(s)
@@ -35,9 +27,7 @@ impl From<&str> for OrchestrionError {
 impl Display for OrchestrionError {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
-            OrchestrionError::InvalidVersionRange(s) => write!(f, "Invalid version range: {s}"),
             OrchestrionError::IoError(e) => write!(f, "IO error: {e}"),
-            OrchestrionError::YamlParseError(e) => write!(f, "YAML parse error: {e}"),
             OrchestrionError::StrError(s) => write!(f, "String error: {s}"),
         }
     }