update

Author: ZR233

Cargo.lock

@@ -11,6 +11,8 @@ categories = ["encoding", "config", "development-tools"]
 
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
+schemars = "1.0.4"
+serde_json = "1.0"
 anyhow = "1.0"
 thiserror = "2"
 

kconfig-serde/Cargo.toml

@@ -0,0 +1,142 @@
+//! Comprehensive example demonstrating JSON Schema to Kconfig conversion
+//!
+//! This example shows how to use the new two-step serialization process
+//! to generate complex Kconfig files with nested structures, help text,
+//! and type safety.
+
+use kconfig_serde::{from_json_schema_with_help, SimpleSchemaHelpProvider};
+use schemars::JsonSchema;
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize, JsonSchema)]
+struct AppConfig {
+    /// Application basic settings
+    general: GeneralConfig,
+    /// Database connection settings
+    database: DatabaseConfig,
+    /// Web server configuration
+    server: ServerConfig,
+}
+
+#[derive(Serialize, Deserialize, JsonSchema)]
+struct GeneralConfig {
+    /// Enable debug logging and features
+    debug_mode: bool,
+    /// Application version string
+    version: String,
+    /// Maximum number of worker threads
+    max_workers: u32,
+}
+
+#[derive(Serialize, Deserialize, JsonSchema)]
+struct DatabaseConfig {
+    /// Database connection settings
+    connection: ConnectionConfig,
+    /// Connection pool settings
+    pool: PoolConfig,
+}
+
+#[derive(Serialize, Deserialize, JsonSchema)]
+struct ConnectionConfig {
+    /// Database server hostname
+    host: String,
+    /// Database server port
+    port: u16,
+    /// Database name
+    database: String,
+    /// Enable SSL/TLS encryption
+    ssl_enabled: bool,
+}
+
+#[derive(Serialize, Deserialize, JsonSchema)]
+struct PoolConfig {
+    /// Maximum number of connections in pool
+    max_connections: u32,
+    /// Connection timeout in seconds
+    timeout_seconds: u64,
+    /// Enable connection health checks
+    health_checks: bool,
+}
+
+#[derive(Serialize, Deserialize, JsonSchema)]
+struct ServerConfig {
+    /// Server bind address
+    bind_address: String,
+    /// Server listen port
+    port: u16,
+    /// Enable HTTPS
+    https_enabled: bool,
+    /// SSL/TLS certificate path
+    cert_path: Option<String>,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Create a comprehensive help provider with detailed documentation
+    let mut help_provider = SimpleSchemaHelpProvider::new();
+
+    // General configuration help
+    help_provider.add_help_text("general.debug_mode", "Enable debug mode for development and troubleshooting");
+    help_provider.add_help_text("general.version", "Application version string for identification");
+    help_provider.add_help_text("general.max_workers", "Maximum number of concurrent worker threads");
+
+    // Database connection help
+    help_provider.add_help_text("database.connection.host", "Database server hostname or IP address");
+    help_provider.add_help_text("database.connection.port", "Database server port number (typically 5432 for PostgreSQL, 3306 for MySQL)");
+    help_provider.add_help_text("database.connection.database", "Name of the database to connect to");
+    help_provider.add_help_text("database.connection.ssl_enabled", "Enable SSL/TLS encryption for database connections");
+
+    // Database pool help
+    help_provider.add_help_text("database.pool.max_connections", "Maximum number of database connections in the pool");
+    help_provider.add_help_text("database.pool.timeout_seconds", "Timeout in seconds for database connection attempts");
+    help_provider.add_help_text("database.pool.health_checks", "Enable periodic connection health checks");
+
+    // Server configuration help
+    help_provider.add_help_text("server.bind_address", "IP address to bind the server to (0.0.0.0 for all interfaces)");
+    help_provider.add_help_text("server.port", "Port number for the server to listen on");
+    help_provider.add_help_text("server.https_enabled", "Enable HTTPS/TLS for secure connections");
+    help_provider.add_help_text("server.cert_path", "Path to SSL/TLS certificate file (required when HTTPS is enabled)");
+
+    // Create example configuration
+    let config = AppConfig {
+        general: GeneralConfig {
+            debug_mode: false,
+            version: "1.0.0".to_string(),
+            max_workers: 8,
+        },
+        database: DatabaseConfig {
+            connection: ConnectionConfig {
+                host: "localhost".to_string(),
+                port: 5432,
+                database: "myapp".to_string(),
+                ssl_enabled: true,
+            },
+            pool: PoolConfig {
+                max_connections: 20,
+                timeout_seconds: 30,
+                health_checks: true,
+            },
+        },
+        server: ServerConfig {
+            bind_address: "0.0.0.0".to_string(),
+            port: 8080,
+            https_enabled: true,
+            cert_path: Some("/etc/ssl/certs/server.crt".to_string()),
+        },
+    };
+
+    // Convert to Kconfig using the new two-step approach
+    let kconfig = from_json_schema_with_help(&config, help_provider)?;
+
+    println!("# Generated Kconfig from JSON Schema\n");
+    println!("{}", kconfig.to_string());
+
+    println!("\n# Key Features Demonstrated:");
+    println!("- ✅ Nested structure support with automatic menu generation");
+    println!("- ✅ Type-safe conversion using schemars");
+    println!("- ✅ Comprehensive help text integration");
+    println!("- ✅ Support for optional fields (cert_path)");
+    println!("- ✅ Proper boolean, string, and integer handling");
+    println!("- ✅ Human-readable field name formatting");
+
+    Ok(())
+}

kconfig-serde/examples/comprehensive_schema_demo.rs

@@ -0,0 +1,53 @@
+use kconfig_serde::from_json_schema;
+use schemars::{schema_for, JsonSchema};
+use serde_json;
+use serde::Serialize;
+
+#[derive(Serialize, JsonSchema)]
+struct DatabaseConfig {
+    connection: ConnectionConfig,
+    pool: PoolConfig,
+}
+
+#[derive(Serialize, JsonSchema)]
+struct ConnectionConfig {
+    host: String,
+    port: u16,
+    ssl_enabled: bool,
+}
+
+#[derive(Serialize, JsonSchema)]
+struct PoolConfig {
+    max_connections: u32,
+    timeout_seconds: u64,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let schema = schema_for!(DatabaseConfig);
+    println!("Generated JSON Schema:");
+    println!("{}", serde_json::to_string_pretty(&schema)?);
+
+    let config = DatabaseConfig {
+        connection: ConnectionConfig {
+            host: "localhost".to_string(),
+            port: 5432,
+            ssl_enabled: true,
+        },
+        pool: PoolConfig {
+            max_connections: 20,
+            timeout_seconds: 30,
+        },
+    };
+
+    match from_json_schema(&config) {
+        Ok(result) => {
+            println!("\nGenerated Kconfig:");
+            println!("{}", result.to_string());
+        }
+        Err(e) => {
+            println!("\nError: {}", e);
+        }
+    }
+
+    Ok(())
+}

kconfig-serde/examples/debug_complex_schema.rs

@@ -0,0 +1,48 @@
+use kconfig_serde::from_json_schema;
+use schemars::JsonSchema;
+
+#[derive(JsonSchema)]
+struct NestedConfig {
+    general: GeneralConfig,
+    network: NetworkConfig,
+}
+
+#[derive(JsonSchema)]
+struct GeneralConfig {
+    debug_mode: bool,
+    log_level: String,
+}
+
+#[derive(JsonSchema)]
+struct NetworkConfig {
+    enabled: bool,
+    hostname: String,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let config = NestedConfig {
+        general: GeneralConfig {
+            debug_mode: true,
+            log_level: "info".to_string(),
+        },
+        network: NetworkConfig {
+            enabled: true,
+            hostname: "localhost".to_string(),
+        },
+    };
+
+    let result = from_json_schema(&config)?;
+    let output = result.to_string();
+
+    println!("Generated Kconfig:");
+    println!("{}", output);
+    println!("=== DEBUG INFO ===");
+    println!("Contains 'menu \"GeneralConfig\"': {}", output.contains("menu \"GeneralConfig\""));
+    println!("Contains 'menu \"NetworkConfig\"': {}", output.contains("menu \"NetworkConfig\""));
+    println!("Contains 'config DEBUG_MODE': {}", output.contains("config DEBUG_MODE"));
+    println!("Contains 'config LOG_LEVEL': {}", output.contains("config LOG_LEVEL"));
+    println!("Contains 'config ENABLED': {}", output.contains("config ENABLED"));
+    println!("Contains 'config HOSTNAME': {}", output.contains("config HOSTNAME"));
+
+    Ok(())
+}

kconfig-serde/examples/debug_nested_test.rs

@@ -0,0 +1,37 @@
+use kconfig_serde::from_json_schema;
+use schemars::{schema_for, JsonSchema};
+use serde_json;
+use serde::Serialize;
+
+#[derive(Serialize, JsonSchema)]
+struct ServerConfig {
+    bind_address: String,
+    port: u16,
+    https_enabled: bool,
+    cert_path: Option<String>,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let schema = schema_for!(ServerConfig);
+    println!("Generated JSON Schema:");
+    println!("{}", serde_json::to_string_pretty(&schema)?);
+
+    let config = ServerConfig {
+        bind_address: "0.0.0.0".to_string(),
+        port: 8080,
+        https_enabled: true,
+        cert_path: Some("/etc/ssl/certs/server.crt".to_string()),
+    };
+
+    match from_json_schema(&config) {
+        Ok(result) => {
+            println!("\nGenerated Kconfig:");
+            println!("{}", result.to_string());
+        }
+        Err(e) => {
+            println!("\nError: {}", e);
+        }
+    }
+
+    Ok(())
+}