Add dependency inversion

Author: diego-bearing

better-rust/solid/src/dependency_inversion_after.rs

@@ -0,0 +1,144 @@
+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 trait Authorizer {
+    fn is_authorized(&self) -> bool;
+}
+
+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;
+    }
+}
+
+impl Authorizer for SMSAuthorizer {
+    fn is_authorized(&self) -> bool {
+        self.authorized
+    }
+}
+
+pub struct AuthorizerRobot {
+    pub authorized: bool,
+}
+
+impl AuthorizerRobot {
+    pub fn new() -> Self {
+        Self { authorized: false }
+    }
+
+    pub fn not_a_robot(&mut self) {
+        println!("Are you a robot?");
+        self.authorized = true;
+    }
+}
+
+impl Authorizer for AuthorizerRobot {
+    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<dyn Authorizer>,
+}
+
+impl<'a> PaypalPaymentProcessor<'a> {
+    pub fn new(email_address: &'a str, authorizer: &'a RefCell<dyn Authorizer>) -> 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/dependency_inversion_before.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/lib.rs

@@ -5,4 +5,6 @@ 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;
+pub mod interface_segregation_after;
+pub mod dependency_inversion_before;
+pub mod dependency_inversion_after;

better-rust/solid/src/main.rs

@@ -12,6 +12,8 @@ fn main() {
     interface_segregation_before();
 
     interface_segregation_after();
+
+    dependency_inversion();
 }
 
 #[macros::example]
@@ -113,4 +115,25 @@ fn interface_segregation_after() {
     let processor = PaypalPaymentProcessor::new("[email protected]", &authorizer);
     authorizer.borrow_mut().verify_code(465839);
     processor.pay(&mut order);
+}
+
+#[macros::example]
+fn dependency_inversion() {
+    use solid::dependency_inversion_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 authorizer = RefCell::new(AuthorizerRobot::new());
+
+    let processor = PaypalPaymentProcessor::new("[email protected]", &authorizer);
+    // authorizer.borrow_mut().verify_code(465839);
+    authorizer.borrow_mut().not_a_robot();
+    processor.pay(&mut order);
 }