Merge pull request #6 from AndresCdo/dev

Refactor markdown content and code structure in Stock Market Monitor and config_man

Author: AndresCdo

.github/workflows/CI.yml

@@ -42,6 +42,8 @@ jobs:
           - Module02/Web1
           - Module02/Web2
           # - Module03/zip_cracker
+          - DesignModule04/config_man
+          - DesignModule04/StockMarket
     steps:
       - name: Checkout code
         uses: actions/checkout@v2
@@ -55,4 +57,5 @@ jobs:
         working-directory: ${{ matrix.module }}
         run: |
           cargo build --verbose
-          cargo test --verbose
+          cargo test --verbose
+    

DesignModule04/Observer.rs

@@ -1,19 +1,57 @@
 use std::cell::RefCell;
+use std::rc::Rc;
 
-fn main()
-{
+struct WeatherStation {
+    observers: Vec<Rc<RefCell<dyn Observer>>>,
+}
+
+impl WeatherStation {
+    fn new() -> Self {
+        WeatherStation {
+            observers: Vec::new(),
+        }
+    }
+
+    fn add_observer(&mut self, observer: Rc<RefCell<dyn Observer>>) {
+        self.observers.push(observer);
+    }
+
+    fn set_measurements(&self, temperature: f32, humidity: f32) {
+        for observer in &self.observers {
+            observer.borrow_mut().update(temperature, humidity);
+        }
+    }
+}
+
+trait Observer {
+    fn update(&self, temperature: f32, humidity: f32);
+}
+
+struct DisplayDevice {
+    name: String,
+}
+
+impl Observer for DisplayDevice {
+    fn update(&self, temperature: f32, humidity: f32) {
+        println!(
+            "{}: Temperature = {}°C, Humidity = {}%",
+            self.name, temperature, humidity
+        );
+    }
+}
+
+fn main() {
     let mut weather_station = WeatherStation::new();
-    let display1 = Rc::new(RefCell::new(DisplayDevice{
+    let display1 = Rc::new(RefCell::new(DisplayDevice {
         name: String::from("Display 1"),
     }));
-    let display2 = Rc::new(RefCell::new(DisplayDevice{
+    let display2 = Rc::new(RefCell::new(DisplayDevice {
         name: String::from("Display 2"),
     }));
 
-    weather_station.add_observer(display1);
-    weather_station.add_observer(display2);
+    weather_station.add_observer(display1.clone());
+    weather_station.add_observer(display2.clone());
 
     weather_station.set_measurements(25.5, 60.0);
     weather_station.set_measurements(26.0, 58.5);
-
 }

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/StockMarket/src/README.md

@@ -1,15 +1,15 @@
 # Stock Market Monitor (Observer Pattern)
 
-This project demonstrates the implementation of the Observer pattern in Rust using a Stock Market monitoring system as a real-world example.
+This markdown content has been refactored:
 
 ## Overview
 
-The Stock Market Monitor allows multiple observers (displays and alert systems) to receive updates whenever stock prices change. This showcases how the Observer pattern can be used to implement a publish-subscribe model.
+This project showcases the implementation of the Observer pattern in Rust using a Stock Market monitoring system as an example.
 
 ## Features
 
 - Real-time updates of stock prices to multiple observers
-- Different types of observers (displays and alert systems)
+- Support for different types of observers (displays and alert systems)
 - Easy addition of new observers
 
 ## Mermaid Diagram
@@ -81,4 +81,4 @@ stock_market.set_price("AAPL", 150.0);
 
 ## Notes
 
-The Observer pattern is excellent for implementing distributed event handling systems. It's widely used in implementing distributed event handling systems, MVC architectural pattern, and in designing user interface toolkits. However, if overused, it can lead to complex systems where observers are difficult to track and maintain.
+The Observer pattern is excellent for implementing distributed event handling systems. It's widely used in implementing distributed event handling systems, MVC architectural pattern, and in designing user interface toolkits. However, if overused, it can lead to complex systems where observers are difficult to track and maintain.

DesignModule04/StockMarket/src/main.rs

@@ -1,27 +1,27 @@
 use std::collections::HashMap;
-use std::cell::RefCell;
 use std::rc::Rc;
+use std::borrow::Cow;
 
 // Observer trait
 trait StockObserver {
-    fn update(&self, symbol: &str, price: f64);
+    fn update(&self, symbol: Cow<str>, price: f64);
 }
 
 // Subject (Observable)
 struct StockMarket {
     prices: HashMap<String, f64>,
-    observers: Vec<Rc<RefCell<dyn StockObserver>>>,
+    observers: Vec<Rc<dyn StockObserver>>,
 }
 
 impl StockMarket {
     fn new() -> Self {
         StockMarket {
-            prices: HashMap::new(),
-            observers: Vec::new(),
+            prices: HashMap::with_capacity(10),
+            observers: Vec::with_capacity(10),
         }
     }
 
-    fn add_observer(&mut self, observer: Rc<RefCell<dyn StockObserver>>) {
+    fn add_observer(&mut self, observer: Rc<dyn StockObserver>) {
         self.observers.push(observer);
     }
 
@@ -31,8 +31,9 @@ impl StockMarket {
     }
 
     fn notify_observers(&self, symbol: &str, price: f64) {
+        let symbol = Cow::Borrowed(symbol);
         for observer in &self.observers {
-            observer.borrow().update(symbol, price);
+            observer.update(symbol.clone(), price);
         }
     }
 }
@@ -43,7 +44,7 @@ struct PriceDisplay {
 }
 
 impl StockObserver for PriceDisplay {
-    fn update(&self, symbol: &str, price: f64) {
+    fn update(&self, symbol: Cow<str>, price: f64) {
         println!("{}: {} stock updated to ${:.2}", self.name, symbol, price);
     }
 }
@@ -53,7 +54,7 @@ struct AlertSystem {
 }
 
 impl StockObserver for AlertSystem {
-    fn update(&self, symbol: &str, price: f64) {
+    fn update(&self, symbol: Cow<str>, price: f64) {
         if price > self.threshold {
             println!("ALERT: {} stock price ${:.2} exceeds threshold ${:.2}", symbol, price, self.threshold);
         }
@@ -63,15 +64,15 @@ impl StockObserver for AlertSystem {
 fn main() {
     let mut stock_market = StockMarket::new();
 
-    let display1 = Rc::new(RefCell::new(PriceDisplay {
+    let display1 = Rc::new(PriceDisplay {
         name: String::from("Display 1"),
-    }));
-    let display2 = Rc::new(RefCell::new(PriceDisplay {
+    });
+    let display2 = Rc::new(PriceDisplay {
         name: String::from("Display 2"),
-    }));
-    let alert_system = Rc::new(RefCell::new(AlertSystem {
+    });
+    let alert_system = Rc::new(AlertSystem {
         threshold: 100.0,
-    }));
+    });
 
     stock_market.add_observer(display1);
     stock_market.add_observer(display2);
@@ -82,4 +83,76 @@ fn main() {
     stock_market.set_price("GOOGL", 1330.0);
     stock_market.set_price("MSFT", 95.0);
     stock_market.set_price("MSFT", 120.0);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_stock_market() {
+        let mut stock_market = StockMarket::new();
+
+        let display1 = Rc::new(PriceDisplay {
+            name: String::from("Display 1"),
+        });
+        let display2 = Rc::new(PriceDisplay {
+            name: String::from("Display 2"),
+        });
+        let alert_system = Rc::new(AlertSystem {
+            threshold: 100.0,
+        });
+
+        stock_market.add_observer(display1);
+        stock_market.add_observer(display2);
+        stock_market.add_observer(alert_system);
+
+        stock_market.set_price("AAPL", 15.0);
+        stock_market.set_price("GOOGL", 1330.0);
+        stock_market.set_price("MSFT", 95.0);
+        stock_market.set_price("MSFT", 120.0);
+    }
+
+    #[test]
+    fn test_price_display() {
+        let display = PriceDisplay {
+            name: String::from("Display 1"),
+        };
+        display.update(Cow::Borrowed("AAPL"), 15.0);
+    }
+
+    #[test]
+    fn test_alert_system() {
+        let alert = AlertSystem {
+            threshold: 100.0,
+        };
+        alert.update(Cow::Borrowed("AAPL"), 105.0);
+    }
+
+    #[test]
+    fn test_stock_observer() {
+        let display = PriceDisplay {
+            name: String::from("Display 1"),
+        };
+        let observer: &dyn StockObserver = &display;
+        observer.update(Cow::Borrowed("AAPL"), 15.0);
+    }
+
+    #[test]
+    fn test_stock_observer_vec() {
+        let display1 = Rc::new(PriceDisplay {
+            name: String::from("Display 1"),
+        });
+        let display2 = Rc::new(PriceDisplay {
+            name: String::from("Display 2"),
+        });
+
+        let mut observers: Vec<Rc<dyn StockObserver>> = Vec::new();
+        observers.push(display1);
+        observers.push(display2);
+
+        for observer in &observers {
+            observer.update(Cow::Borrowed("AAPL"), 15.0);
+        }
+    }
 }

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.