chore: Refactor markdown content and code structure in config_man

Author: AndresCdo

DesignModule04/Singleton.rs

@@ -2,14 +2,14 @@ use std::collections::HashMap;
 use std::sync::{Arc, Mutex, Once};
 use std::fs;
 use std::io;
+use std::thread;
 
 struct ConfigManager {
     config: HashMap<String, String>,
 }
 
 impl ConfigManager {
     fn new() -> Result<Self, io::Error> {
-        // Simulate loading configuration from a file
         let config_str = fs::read_to_string("config.toml")?;
         let config = parse_config(&config_str);
         Ok(ConfigManager { config })
@@ -24,7 +24,6 @@ impl ConfigManager {
     }
 
     fn save(&self) -> Result<(), io::Error> {
-        // Simulate saving configuration to a file
         let config_str = format_config(&self.config);
         fs::write("config.toml", config_str)
     }
@@ -52,7 +51,6 @@ fn get_config() -> Arc<Mutex<ConfigManager>> {
 }
 
 fn parse_config(config_str: &str) -> HashMap<String, String> {
-    // This is a simplified parser. In a real application, you'd use a proper TOML parser.
     config_str
         .lines()
         .filter_map(|line| {
@@ -74,26 +72,21 @@ fn format_config(config: &HashMap<String, String>) -> String {
         .join("\n")
 }
 
-use std::thread;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Simulate multiple parts of an application accessing and modifying the configuration
     let handles: Vec<_> = (0..3)
         .map(|i| {
             thread::spawn(move || {
                 let config = get_config();
                 let mut config = config.lock().unwrap();
 
-                // Read a configuration value
                 let db_url = config.get("database_url").cloned().unwrap_or_default();
                 println!("Thread {} read database_url: {}", i, db_url);
 
-                // Modify a configuration value
                 let new_value = format!("new_value_from_thread_{}", i);
                 config.set(format!("key_from_thread_{}", i), new_value.clone());
                 println!("Thread {} set new value: {}", i, new_value);
 
-                // Simulate some work
                 thread::sleep(std::time::Duration::from_millis(100));
             })
         })
@@ -103,11 +96,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         handle.join().unwrap();
     }
 
-    // After all threads have finished, save the configuration
     let config = get_config();
     let config = config.lock().unwrap();
     config.save()?;
     println!("Configuration saved.");
 
     Ok(())
-}
+}

DesignModule04/config_man/Readme.md

@@ -1,6 +1,6 @@
 # ConfigManager Singleton
 
-This project demonstrates the implementation of the Singleton pattern in Rust using a `ConfigManager` as a real-world example.
+This project demonstrates the Singleton pattern in Rust using a `ConfigManager` as a real-world example.
 
 ## Overview
 
@@ -10,8 +10,8 @@ The `ConfigManager` is a thread-safe, globally accessible configuration manager
 
 - Thread-safe access to configuration
 - Lazy initialization
-- Ability to read and write configuration values
-- Persistence of configuration to a file
+- Read and write configuration values
+- Persist configuration to a file
 
 ## Mermaid Diagram
 
@@ -32,7 +32,7 @@ graph TD
     G & H & I --> J[Save Config to File]
 ```
 
-## How it works
+## How It Works
 
 1. The application requests access to the ConfigManager via the `get_config()` function.
 2. If it's the first access, a new ConfigManager is created, the configuration is loaded from a file, and the instance is stored in a static variable.
@@ -42,7 +42,7 @@ graph TD
 
 ## Usage
 
-To use the ConfigManager in your code:
+To use the ConfigManager Singleton in your code:
 
 ```rust
 let config = get_config();
@@ -67,4 +67,4 @@ config_guard.save().unwrap();
 
 ## Notes
 
-While the Singleton pattern can be useful for managing global state, it should be used judiciously. Consider whether dependency injection or simple module-level variables might be more appropriate for your use case.
+While the Singleton pattern can be useful for managing global state, it should be used judiciously. Consider whether dependency injection or simple module-level variables might be more appropriate for your use case.

DesignModule04/config_man/src/main.rs

@@ -2,15 +2,15 @@ use std::collections::HashMap;
 use std::sync::{Arc, Mutex, Once};
 use std::fs;
 use std::io;
+use std::thread;
 
 struct ConfigManager {
     config: HashMap<String, String>,
 }
 
 impl ConfigManager {
     fn new() -> Result<Self, io::Error> {
-        // Simulate loading configuration from a file
-        let config_str = fs::read_to_string("config.toml")?;
+        let config_str = fs::read_to_string("src/config.toml")?;
         let config = parse_config(&config_str);
         Ok(ConfigManager { config })
     }
@@ -24,7 +24,6 @@ impl ConfigManager {
     }
 
     fn save(&self) -> Result<(), io::Error> {
-        // Simulate saving configuration to a file
         let config_str = format_config(&self.config);
         fs::write("config.toml", config_str)
     }
@@ -52,7 +51,6 @@ fn get_config() -> Arc<Mutex<ConfigManager>> {
 }
 
 fn parse_config(config_str: &str) -> HashMap<String, String> {
-    // This is a simplified parser. In a real application, you'd use a proper TOML parser.
     config_str
         .lines()
         .filter_map(|line| {
@@ -67,33 +65,29 @@ fn parse_config(config_str: &str) -> HashMap<String, String> {
 }
 
 fn format_config(config: &HashMap<String, String>) -> String {
-    config
-        .iter()
-        .map(|(k, v)| format!("{} = {}", k, v))
+    let mut keys: Vec<&String> = config.keys().collect();
+    keys.sort();
+    keys.iter()
+        .map(|k| format!("{} = {}", k, config.get(*k).unwrap()))
         .collect::<Vec<String>>()
         .join("\n")
 }
 
-use std::thread;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Simulate multiple parts of an application accessing and modifying the configuration
     let handles: Vec<_> = (0..3)
         .map(|i| {
             thread::spawn(move || {
                 let config = get_config();
                 let mut config = config.lock().unwrap();
 
-                // Read a configuration value
                 let db_url = config.get("database_url").cloned().unwrap_or_default();
                 println!("Thread {} read database_url: {}", i, db_url);
 
-                // Modify a configuration value
                 let new_value = format!("new_value_from_thread_{}", i);
                 config.set(format!("key_from_thread_{}", i), new_value.clone());
                 println!("Thread {} set new value: {}", i, new_value);
 
-                // Simulate some work
                 thread::sleep(std::time::Duration::from_millis(100));
             })
         })
@@ -103,11 +97,36 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         handle.join().unwrap();
     }
 
-    // After all threads have finished, save the configuration
     let config = get_config();
     let config = config.lock().unwrap();
     config.save()?;
     println!("Configuration saved.");
 
     Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_config() {
+        let config_str = "key1 = value1\nkey2 = value2\nkey3 = value3";
+        let config = parse_config(config_str);
+        assert_eq!(config.len(), 3);
+        assert_eq!(config.get("key1"), Some(&"value1".to_string()));
+        assert_eq!(config.get("key2"), Some(&"value2".to_string()));
+        assert_eq!(config.get("key3"), Some(&"value3".to_string()));
+    }
+
+    #[test]
+    fn test_format_config() {
+        let mut config = HashMap::new();
+        config.insert("key1".to_string(), "value1".to_string());
+        config.insert("key2".to_string(), "value2".to_string());
+        config.insert("key3".to_string(), "value3".to_string());
+
+        let config_str = format_config(&config);
+        assert_eq!(config_str, "key1 = value1\nkey2 = value2\nkey3 = value3");
+    }
 }