feat(schema): impl deserialize an instance of type T from a string of YAML text

Author: wangeguo

Cargo.lock

@@ -28,6 +28,7 @@ dotenv = "0.15.0"
 indexmap = {version = "2.9.0", features = ["serde"] }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.140"
+serde_yml = "0.0.12"
 thiserror = "2.0.12"
 tokio = { version = "1.45.1", features = ["full"] }
 tracing = "0.1.41"

Cargo.toml

@@ -12,10 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::str::FromStr;
+
 use indexmap::IndexSet;
 use serde::{Deserialize, Serialize};
 
-use crate::schema::{Extension, Stage};
+use crate::schema::{Extensions, Stage};
 
 /// Schema for the course.yml file.
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -39,11 +41,20 @@ pub struct Course {
     pub summary: String,
 
     /// Sequential stages of the course.
+    #[serde(skip)]
     pub stages: IndexSet<Stage>,
 
     /// Sets of additional stages.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub extensions: Option<IndexSet<Extension>>,
+    #[serde(skip)]
+    pub extensions: Option<Extensions>,
+}
+
+impl FromStr for Course {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        serde_yml::from_str(s).map_err(|e| e.to_string())
+    }
 }
 
 /// The release status of the course.
@@ -53,3 +64,36 @@ pub enum Status {
     Beta,
     Live,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_course_from_str() {
+        let yaml = r#"
+            slug: rust-course
+            name: Rust Programming
+            short_name: Rust
+            release_status: Beta
+            description: A comprehensive course on Rust programming language.
+            summary: Learn Rust programming
+        "#;
+
+        let course = Course::from_str(yaml).unwrap();
+
+        assert_eq!(course.slug, "rust-course");
+        assert_eq!(course.name, "Rust Programming");
+        assert_eq!(course.short_name, "Rust");
+        assert!(matches!(course.release_status, Status::Beta));
+        assert_eq!(course.description, "A comprehensive course on Rust programming language.");
+        assert_eq!(course.summary, "Learn Rust programming");
+    }
+
+    #[test]
+    fn test_course_from_str_error() {
+        let invalid_yaml = "invalid: yaml: content";
+        let result = Course::from_str(invalid_yaml);
+        assert!(result.is_err());
+    }
+}

src/schema/course.rs

@@ -12,13 +12,31 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::hash::Hash;
+use std::{hash::Hash, str::FromStr};
 
 use indexmap::IndexSet;
 use serde::{Deserialize, Serialize};
 
 use crate::schema::Stage;
 
+/// Schema for the extensions.yml file.
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
+pub struct Extensions(IndexSet<Extension>);
+
+impl Extensions {
+    pub fn iter(&self) -> indexmap::set::Iter<Extension> {
+        self.0.iter()
+    }
+}
+
+impl FromStr for Extensions {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        serde_yml::from_str(s).map_err(|e| e.to_string())
+    }
+}
+
 /// Schema for the extension.
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
 pub struct Extension {
@@ -32,6 +50,7 @@ pub struct Extension {
     pub description: String,
 
     /// Sequential stages of the extension.
+    #[serde(skip)]
     pub stages: IndexSet<Stage>,
 }
 
@@ -40,3 +59,40 @@ impl Hash for Extension {
         self.slug.hash(state);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extensions_from_str() {
+        let yaml = r#"
+            - slug: test1
+              name: Test Extension 1
+              description: Test description 1
+            - slug: test2
+              name: Test Extension 2
+              description: Test description 2
+        "#;
+
+        let extensions = Extensions::from_str(yaml).unwrap();
+
+        let mut iter = extensions.iter();
+
+        let first = iter.next().unwrap();
+        assert_eq!(first.slug, "test1");
+        assert_eq!(first.name, "Test Extension 1");
+
+        let second = iter.next().unwrap();
+        assert_eq!(second.slug, "test2");
+        assert_eq!(second.name, "Test Extension 2");
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_extensions_from_str_invalid() {
+        let invalid_yaml = "invalid: yaml";
+        let result = Extensions::from_str(invalid_yaml);
+        assert!(result.is_err());
+    }
+}

src/schema/extension.rs

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::str::FromStr;
+
 use serde::{Deserialize, Serialize};
 
 /// Schema for the codecraft.yml file.
@@ -29,3 +31,39 @@ pub struct Manifest {
     /// The main source file that users can edit for this project.
     pub user_editable_file: String,
 }
+
+impl FromStr for Manifest {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        serde_yml::from_str(s).map_err(|e| e.to_string())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_manifest_from_str() {
+        let yaml = r#"
+            debug: true
+            language_pack: "rust-1.70.0"
+            required_executable: "cargo"
+            user_editable_file: "src/main.rs"
+        "#;
+
+        let manifest = Manifest::from_str(yaml).unwrap();
+        assert!(manifest.debug);
+        assert_eq!(manifest.language_pack, "rust-1.70.0");
+        assert_eq!(manifest.required_executable, "cargo");
+        assert_eq!(manifest.user_editable_file, "src/main.rs");
+    }
+
+    #[test]
+    fn test_manifest_from_str_error() {
+        let invalid_yaml = "invalid: yaml: content";
+        let result = Manifest::from_str(invalid_yaml);
+        assert!(result.is_err());
+    }
+}

src/schema/manifest.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 use serde::{Deserialize, Serialize};
-use std::hash::Hash;
+use std::{hash::Hash, str::FromStr};
 
 /// A self-contained coding task with specific objectives and validation.
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
@@ -34,10 +34,11 @@ pub struct Stage {
     pub description: String,
 
     /// A markdown description for this stage.
+    #[serde(skip)]
     pub instruction: String,
 
     /// The solution to this stage, if available.
-    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(skip)]
     pub solution: Option<Solution>,
 }
 
@@ -47,6 +48,14 @@ impl Hash for Stage {
     }
 }
 
+impl FromStr for Stage {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        serde_yml::from_str(s).map_err(|e| e.to_string())
+    }
+}
+
 /// A difficulty rating,
 /// from the perspective of a proficient programmer.
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
@@ -80,3 +89,31 @@ impl Solution {
         self.patches.push((path, content));
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_stage_from_str() {
+        let yaml = r#"
+            slug: test-stage
+            name: Test Stage
+            difficulty: Easy
+            description: A test stage
+        "#;
+
+        let stage = Stage::from_str(yaml).unwrap();
+        assert_eq!(stage.slug, "test-stage");
+        assert_eq!(stage.name, "Test Stage");
+        assert_eq!(stage.difficulty, Difficulty::Easy);
+        assert_eq!(stage.description, "A test stage");
+    }
+
+    #[test]
+    fn test_stage_from_str_invalid() {
+        let invalid_yaml = "invalid: yaml: content";
+        let result = Stage::from_str(invalid_yaml);
+        assert!(result.is_err());
+    }
+}