Add interface segregation

Author: diego-bearing

better-rust/solid/src/interface_segregation_after.rs

@@ -0,0 +1,117 @@
+use std::cell::RefCell;
+
+pub struct Order<'a> {
+    pub items: Vec<&'a str>,
+    pub quantities: Vec<u32>,
+    pub prices: Vec<f32>,
+    pub status: &'a str,
+}
+
+impl<'a> Order<'a> {
+    pub fn new() -> Self {
+        Self { items: vec![], quantities: vec![], prices: vec![], status: "open" }
+    }
+
+    pub fn add_item(&mut self, name: &'a str, quantity: u32, price: f32) {
+        self.items.push(name);
+        self.quantities.push(quantity);
+        self.prices.push(price);
+    }
+
+    pub fn total_price(&self) -> f32 {
+        let mut total: f32 = 0.0;
+
+        for (i, price) in self.prices.iter().enumerate() {
+            total += self.quantities[i] as f32 * price;
+        }
+
+        total
+    }
+}
+
+pub struct SMSAuthorizer {
+    pub authorized: bool,
+}
+
+impl SMSAuthorizer {
+    pub fn new() -> Self {
+        Self { authorized: false }
+    }
+
+    pub fn verify_code(&mut self, code: u32) {
+        println!("Verifying SMS code {code}");
+        self.authorized = true;
+    }
+
+    fn is_authorized(&self) -> bool {
+        self.authorized
+    }
+}
+
+pub trait PaymentProcessor {
+    fn pay(&self, order: &mut Order);
+}
+
+pub struct DebitPaymentProcessor<'a> {
+    pub security_code: &'a str,
+    pub authorizer: &'a RefCell<SMSAuthorizer>,
+}
+
+impl<'a> DebitPaymentProcessor<'a> {
+    pub fn new(security_code: &'a str, authorizer: &'a RefCell<SMSAuthorizer>) -> Self {
+        Self { security_code, authorizer }
+    }
+}
+
+impl PaymentProcessor for DebitPaymentProcessor<'_> {
+    fn pay(&self, order: &mut Order) {
+        if !self.authorizer.borrow().is_authorized() {
+            panic!("Not authorized");
+        }
+
+        println!("Processing debit payment type");
+        println!("Verifying security code: {}", {self.security_code});
+        order.status = "paid";
+    }
+}
+
+pub struct CreditPaymentProcessor<'a> {
+    pub security_code: &'a str, 
+}
+
+impl<'a> CreditPaymentProcessor<'a> {
+    pub fn new(security_code: &'a str) -> Self {
+        Self { security_code }
+    }
+}
+
+impl PaymentProcessor for CreditPaymentProcessor<'_> {
+    fn pay(&self, order: &mut Order) {
+        println!("Processing credit payment type");
+        println!("Verifying security code: {}", {self.security_code});
+        order.status = "paid";        
+    }
+}
+
+pub struct PaypalPaymentProcessor<'a> {
+    pub email_address: &'a str,
+    pub authorizer: &'a RefCell<SMSAuthorizer>,
+}
+
+impl<'a> PaypalPaymentProcessor<'a> {
+    pub fn new(email_address: &'a str, authorizer: &'a RefCell<SMSAuthorizer>) -> Self {
+        Self { email_address, authorizer }
+    }
+}
+
+impl PaymentProcessor for PaypalPaymentProcessor<'_> {
+    fn pay(&self, order: &mut Order) {
+        if !self.authorizer.borrow().is_authorized() {
+            panic!("Not authorized");
+        }
+
+        println!("Processing paypal payment type");
+        println!("Using email address: {}", {self.email_address});
+        order.status = "paid";        
+    }
+}

better-rust/solid/src/interface_segregation_before.rs

@@ -0,0 +1,105 @@
+
+pub struct Order<'a> {
+    pub items: Vec<&'a str>,
+    pub quantities: Vec<u32>,
+    pub prices: Vec<f32>,
+    pub status: &'a str,
+}
+
+impl<'a> Order<'a> {
+    pub fn new() -> Self {
+        Self { items: vec![], quantities: vec![], prices: vec![], status: "open" }
+    }
+
+    pub fn add_item(&mut self, name: &'a str, quantity: u32, price: f32) {
+        self.items.push(name);
+        self.quantities.push(quantity);
+        self.prices.push(price);
+    }
+
+    pub fn total_price(&self) -> f32 {
+        let mut total: f32 = 0.0;
+
+        for (i, price) in self.prices.iter().enumerate() {
+            total += self.quantities[i] as f32 * price;
+        }
+
+        total
+    }
+}
+
+pub trait PaymentProcessor {
+    fn auth_sms(&mut self, code: u32);
+
+    fn pay(&self, order: &mut Order);
+}
+
+pub struct DebitPaymentProcessor<'a> {
+    pub security_code: &'a str,
+    pub verified: bool,
+}
+
+impl<'a> DebitPaymentProcessor<'a> {
+    pub fn new(security_code: &'a str) -> Self {
+        Self { security_code, verified: false }
+    }
+}
+
+impl PaymentProcessor for DebitPaymentProcessor<'_> {
+    fn auth_sms(&mut self, code: u32) {
+        println!("Verifying SMS code {code}");
+        self.verified = true;
+    }
+
+    fn pay(&self, order: &mut Order) {
+        println!("Processing debit payment type");
+        println!("Verifying security code: {}", {self.security_code});
+        order.status = "paid";
+    }
+}
+
+pub struct CreditPaymentProcessor<'a> {
+    pub security_code: &'a str, 
+}
+
+impl<'a> CreditPaymentProcessor<'a> {
+    pub fn new(security_code: &'a str) -> Self {
+        Self { security_code }
+    }
+}
+
+impl PaymentProcessor for CreditPaymentProcessor<'_> {
+    fn auth_sms(&mut self, _code: u32) {
+        panic!("Credit card payments don't support SMS code authorization.");
+    }
+    
+    fn pay(&self, order: &mut Order) {
+        println!("Processing credit payment type");
+        println!("Verifying security code: {}", {self.security_code});
+        order.status = "paid";        
+    }
+}
+
+pub struct PaypalPaymentProcessor<'a> {
+    pub email_address: &'a str,
+    pub verified: bool,
+}
+
+impl<'a> PaypalPaymentProcessor<'a> {
+    pub fn new(email_address: &'a str) -> Self {
+        Self { email_address, verified: false }
+    }
+}
+
+impl PaymentProcessor for PaypalPaymentProcessor<'_> {
+    fn auth_sms(&mut self, code: u32) {
+        println!("Verifying SMS code {code}");
+        self.verified = true;
+    }
+    
+    fn pay(&self, order: &mut Order) {
+        println!("Processing paypal payment type");
+        println!("Using email address: {}", {self.email_address});
+        order.status = "paid";        
+    }
+}

better-rust/solid/src/lib.rs

@@ -4,3 +4,5 @@ pub mod open_closed_before;
 pub mod open_closed_after;
 pub mod liskov_substitution_before;
 pub mod liskov_substitution_after;
+pub mod interface_segregation_before;
+pub mod interface_segregation_after;

better-rust/solid/src/main.rs

@@ -1,3 +1,5 @@
+use std::cell::RefCell;
+
 fn main() {
     single_responsibility_before();
 
@@ -6,6 +8,10 @@ fn main() {
     open_closed();
 
     liskov_substitution();
+
+    interface_segregation_before();
+
+    interface_segregation_after();
 }
 
 #[macros::example]
@@ -70,5 +76,41 @@ fn liskov_substitution() {
 
     let processor = PaypalPaymentProcessor::new("[email protected]");
 
+    processor.pay(&mut order);
+}
+
+#[macros::example]
+fn interface_segregation_before() {
+    use solid::interface_segregation_before::*;
+
+    let mut order = Order::new();
+
+    order.add_item("Keyboard", 1, 50.0);
+    order.add_item("SSD", 1, 150.0);
+    order.add_item("USB cable", 2, 5.0);
+
+    println!("{}", order.total_price());
+    
+    let mut processor = DebitPaymentProcessor::new("2349875");
+    processor.auth_sms(465839);
+    processor.pay(&mut order);
+}
+
+#[macros::example]
+fn interface_segregation_after() {
+    use solid::interface_segregation_after::*;
+
+    let mut order = Order::new();
+
+    order.add_item("Keyboard", 1, 50.0);
+    order.add_item("SSD", 1, 150.0);
+    order.add_item("USB cable", 2, 5.0);
+
+    println!("{}", order.total_price());
+    
+    let authorizer = RefCell::new(SMSAuthorizer::new());
+
+    let processor = PaypalPaymentProcessor::new("[email protected]", &authorizer);
+    authorizer.borrow_mut().verify_code(465839);
     processor.pay(&mut order);
 }