Extend Property struct to support examples and handle complex additionalProperties (#37)

* Add examples field to Property conversion

Initializes the examples field as an empty vector when converting Attribute to schema::Property. This prepares the Property struct for future use of example values.

* Handle object type for additionalProperties in schema

Added custom deserializer to support 'additionalProperties' as an object in SchemaObject. Updated tests to cover this case and added support for 'examples' in Property struct.

* Add JSON schema validation to CLI

Introduces support for validating JSON schema files in the CLI by checking the input type and delegating to a new validate_from_json_schema function. Handles validation errors and logs results appropriately.

* Remove whitespace from title during deserialization

Added a custom deserializer for the SchemaObject title field to strip all whitespace characters during deserialization. Includes tests to verify whitespace removal for various input cases.

* Change Property examples type to Vec<Value>

Updated the Property struct so that the examples field is now a Vec<Value> instead of Vec<String>, allowing for more flexible example types in JSON schema properties.

* Bump version to 0.2.7 in project files

Updated version numbers to 0.2.7 in Cargo.toml, Cargo.lock, and pyproject.toml for the mdmodels and mdmodels_core projects.

Author: JR-1991

Cargo.lock

@@ -2,7 +2,7 @@
 name = "mdmodels"
 authors = ["Jan Range <jan.range@simtech.uni-stuttgart.de>"]
 description = "A tool to generate models, code and schemas from markdown files"
-version = "0.2.6"
+version = "0.2.7"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/FAIRChemistry/md-models"

Cargo.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "mdmodels_core"
-version = "0.2.6"
+version = "0.2.7"
 description = "A tool to generate models, code and schemas from markdown files"
 requires-python = ">=3.8"
 classifiers = [

pyproject.toml

@@ -26,6 +26,7 @@ use colored::Colorize;
 use log::error;
 use mdmodels::{
     datamodel::DataModel,
+    error::DataModelError,
     exporters::{render_jinja_template, Templates},
     json::validation::validate_json,
     linkml::export::serialize_linkml,
@@ -34,7 +35,13 @@ use mdmodels::{
 };
 use serde::{Deserialize, Serialize};
 use std::{
-    collections::HashMap, error::Error, fmt::Display, fs, io::Write, path::PathBuf, str::FromStr,
+    collections::HashMap,
+    error::Error,
+    fmt::Display,
+    fs,
+    io::Write,
+    path::{Path, PathBuf},
+    str::FromStr,
 };
 
 /// Command-line interface for MD-Models CLI.
@@ -246,7 +253,13 @@ fn validate(args: ValidateArgs) -> Result<(), Box<dyn Error>> {
 
     let path = resolve_input_path(&args.input);
 
-    match DataModel::from_markdown(&path) {
+    if is_json_schema(&path)? {
+        return validate_from_json_schema(&path);
+    }
+
+    let model = DataModel::from_markdown(&path);
+
+    match model {
         Ok(_) => {
             print_validation_result(true);
             Ok(())
@@ -259,6 +272,26 @@ fn validate(args: ValidateArgs) -> Result<(), Box<dyn Error>> {
     }
 }
 
+/// Validates a JSON schema file.
+///
+/// # Arguments
+///
+/// * `path` - Path to the JSON schema file.
+fn validate_from_json_schema(path: &Path) -> Result<(), Box<dyn Error>> {
+    if let Err(err) = DataModel::from_json_schema(path) {
+        match err {
+            DataModelError::ValidationError(validator) => {
+                validator.log_result();
+                Err("Model is invalid".into())
+            }
+            _ => Err(err.into()),
+        }
+    } else {
+        print_validation_result(true);
+        Ok(())
+    }
+}
+
 /// Prints the result of the validation.
 ///
 /// # Arguments

src/bin/cli.rs

@@ -616,6 +616,7 @@ impl TryFrom<&Attribute> for schema::Property {
             enum_values,
             any_of: None,
             all_of: None,
+            examples: Vec::new(),
         })
     }
 }

src/json/export.rs

@@ -930,4 +930,27 @@ mod tests {
         assert_eq!(clean_key("Test__Hello"), "TEST_HELLO");
         assert_eq!(clean_key("!Test"), "TEST");
     }
+
+    #[test]
+    fn test_additional_properties_object() {
+        let schema = json!({
+            "title": "Test",
+            "type": "object",
+            "properties": {
+                "test": {
+                    "type": "string"
+                }
+            },
+            "additionalProperties": {
+                "type": "string"
+            }
+        });
+
+        let schema: SchemaObject = serde_json::from_value(schema).unwrap();
+        let data_model = DataModel::try_from(schema.clone()).unwrap();
+
+        assert!(schema.additional_properties);
+        assert_eq!(data_model.objects.len(), 1);
+        assert_eq!(data_model.objects[0].attributes.len(), 1);
+    }
 }

src/json/import.rs

@@ -54,7 +54,10 @@ pub struct SchemaObject {
     pub schema: Option<String>,
     #[serde(rename = "$id", skip_serializing_if = "Option::is_none")]
     pub id: Option<String>,
-    #[serde(default = "generate_unique_title")]
+    #[serde(
+        default = "generate_unique_title",
+        deserialize_with = "deserialize_title_with_whitespace_removal"
+    )]
     pub title: String,
     #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
     pub dtype: Option<DataType>,
@@ -70,7 +73,11 @@ pub struct SchemaObject {
     pub definitions: BTreeMap<String, SchemaType>,
     #[serde(default)]
     pub required: Vec<String>,
-    #[serde(rename = "additionalProperties", default = "default_false")]
+    #[serde(
+        rename = "additionalProperties",
+        default = "default_false",
+        deserialize_with = "deserialize_additional_properties"
+    )]
     pub additional_properties: bool,
 }
 
@@ -118,6 +125,8 @@ pub struct Property {
     pub all_of: Option<Vec<Item>>,
     #[serde(skip_serializing_if = "skip_empty", rename = "enum")]
     pub enum_values: Option<Vec<String>>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub examples: Vec<Value>,
 }
 
 #[derive(Debug, Deserialize, Variantly, Clone)]
@@ -356,6 +365,80 @@ fn default_false() -> bool {
     false
 }
 
+fn deserialize_title_with_whitespace_removal<'de, D>(deserializer: D) -> Result<String, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use serde::de::{self, Visitor};
+    use std::fmt;
+
+    struct TitleVisitor;
+
+    impl<'de> Visitor<'de> for TitleVisitor {
+        type Value = String;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a string")
+        }
+
+        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(value.chars().filter(|c| !c.is_whitespace()).collect())
+        }
+
+        fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(value.chars().filter(|c| !c.is_whitespace()).collect())
+        }
+    }
+
+    deserializer.deserialize_str(TitleVisitor)
+}
+
+fn deserialize_additional_properties<'de, D>(deserializer: D) -> Result<bool, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use serde::de::{self, Visitor};
+    use serde_json::Value;
+    use std::fmt;
+
+    struct AdditionalPropertiesVisitor;
+
+    impl<'de> Visitor<'de> for AdditionalPropertiesVisitor {
+        type Value = bool;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a boolean or an object")
+        }
+
+        fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(value)
+        }
+
+        fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+        where
+            M: de::MapAccess<'de>,
+        {
+            // Consume all entries in the map to avoid "trailing characters" error
+            while map.next_entry::<String, Value>()?.is_some() {
+                // Just consume and discard
+            }
+            // Any object/map means additionalProperties = true
+            Ok(true)
+        }
+    }
+
+    deserializer.deserialize_any(AdditionalPropertiesVisitor)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -371,4 +454,46 @@ mod tests {
         assert_eq!(DataType::from_str("object").unwrap(), DataType::Object);
         assert_eq!(DataType::from_str("array").unwrap(), DataType::Array);
     }
+
+    #[test]
+    /// Tests that title deserialization removes all whitespaces from the title string.
+    fn test_title_whitespace_removal() {
+        use serde_json;
+
+        // Test with spaces, tabs, and newlines
+        let json_with_whitespace = r#"
+        {
+            "title": "My Test Title",
+            "type": "object",
+            "properties": {}
+        }
+        "#;
+
+        let schema: SchemaObject = serde_json::from_str(json_with_whitespace).unwrap();
+        assert_eq!(schema.title, "MyTestTitle");
+
+        // Test with various whitespace characters
+        let json_with_various_whitespace = r#"
+        {
+            "title": "  My\t\nTest\r Title  ",
+            "type": "object",
+            "properties": {}
+        }
+        "#;
+
+        let schema2: SchemaObject = serde_json::from_str(json_with_various_whitespace).unwrap();
+        assert_eq!(schema2.title, "MyTestTitle");
+
+        // Test with no whitespace (should remain unchanged)
+        let json_no_whitespace = r#"
+        {
+            "title": "MyTitle",
+            "type": "object",
+            "properties": {}
+        }
+        "#;
+
+        let schema3: SchemaObject = serde_json::from_str(json_no_whitespace).unwrap();
+        assert_eq!(schema3.title, "MyTitle");
+    }
 }