feat: Observer pattern made dynamic + tests

Author: aureat

patterns/src/lib.rs

@@ -1,3 +1,4 @@
 mod proxy;
 mod singleton;
+#[allow(dead_code)]
 mod observer;

patterns/src/observer/editor.rs

@@ -0,0 +1,95 @@
+use crate::observer::events::EditorEvent;
+use crate::observer::subject::Subject;
+
+pub struct Editor {
+    listeners: Subject,
+    mentions: i32,
+    comments: i32,
+}
+
+impl Editor {
+    pub fn new() -> Editor {
+        Editor {
+            listeners: Subject::default(),
+            mentions: 0,
+            comments: 0,
+        }
+    }
+
+    pub fn listeners(&mut self) -> &mut Subject {
+        &mut self.listeners
+    }
+
+    pub fn comments(&self) -> i32 {
+        self.comments
+    }
+
+    pub fn mentions(&self) -> i32 {
+        self.mentions
+    }
+
+    pub fn mention(&mut self, person: String) {
+        // do stuff internally as an editor
+        self.mentions += 1;
+
+        // do event dispatching
+        let event = EditorEvent::Mention {
+            person: person.clone(),
+        };
+        self.listeners.notify(&event);
+    }
+
+    pub fn comment(&mut self, person: String, comment: String) {
+        // do stuff internally as an editor
+        self.comments += 1;
+
+        // do event dispatching
+        let event = EditorEvent::Comment {
+            person: person.clone(),
+            comment: comment.clone(),
+        };
+        self.listeners.notify(&event);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::observer::email::EmailAlerts;
+    use crate::observer::events::ListenerCell;
+
+    #[test]
+    fn basic_test() {
+        // a publisher that emits the events
+        let mut editor = Editor::new();
+
+        // a subscriber that subscribes to the publisher
+        let alerts = EmailAlerts::new();
+        let alerts = ListenerCell::from(alerts);
+        editor.listeners().add_listener(&alerts);
+
+        // update the state of the editor
+        for _ in 0..5 {
+            editor.comment(String::from("John"), String::from("Some comment"));
+            editor.mention(String::from("Alice"));
+        }
+
+        // confirm that the subscriber received the events
+        let editor_count = editor.comments() + editor.mentions();
+        assert_eq!(alerts.as_ref().count(), editor_count);
+
+        // remove the listener
+        editor.listeners().remove_listener(&alerts);
+
+        for _ in 0..10 {
+            editor.mention(String::from("John"))
+        }
+
+        // confirm that the subscriber didn't receive the events after removal
+        assert_eq!(alerts.as_ref().count(), editor_count);
+        assert_ne!(
+            alerts.as_ref().count(),
+            editor.comments() + editor.mentions()
+        );
+    }
+}

patterns/src/observer/email.rs

@@ -0,0 +1,37 @@
+use crate::observer::events::{EditorEvent, ListenerUpdate};
+use std::cell::Cell;
+
+pub struct EmailAlerts {
+    count: Cell<i32>,
+}
+
+impl EmailAlerts {
+    pub fn new() -> EmailAlerts {
+        EmailAlerts {
+            count: Cell::new(0),
+        }
+    }
+
+    pub fn count(&self) -> i32 {
+        self.count.get()
+    }
+
+    pub fn reset(&mut self) {
+        self.count.set(0);
+    }
+}
+
+impl ListenerUpdate for EmailAlerts {
+    fn update(&mut self, event: &EditorEvent) {
+        let count = self.count.get();
+        self.count.set(count + 1);
+        match event {
+            EditorEvent::Mention { person } => {
+                eprintln!("{person} mentioned you!");
+            }
+            EditorEvent::Comment { person, .. } => {
+                eprintln!("{person} commented on your project.");
+            }
+        }
+    }
+}

patterns/src/observer/events.rs

@@ -0,0 +1,116 @@
+use std::cell::{Ref, RefCell, RefMut};
+use std::rc::{Rc, Weak};
+
+/// Events that can be emitted represented using an enum
+pub enum EditorEvent {
+    Mention { person: String },
+    Comment { person: String, comment: String },
+}
+
+/// Interface for a listener
+pub trait ListenerUpdate {
+    fn update(&mut self, event: &EditorEvent);
+}
+
+/// `Listener` wraps the updater `EventListener` and gives out references.
+pub struct ListenerCell<T> {
+    rc: Rc<RefCell<T>>,
+}
+
+impl<T> ListenerCell<T>
+where
+    T: ListenerUpdate + 'static,
+{
+    pub fn from(listener: T) -> Self {
+        ListenerCell {
+            rc: Rc::new(RefCell::new(listener)),
+        }
+    }
+
+    /// This is used by `Subject` to obtain the listener.
+    pub fn get_ref(&self) -> ListenerRef {
+        let rc: Rc<RefCell<dyn ListenerUpdate>> = self.rc.clone();
+        ListenerRef {
+            weak: Rc::downgrade(&rc),
+        }
+    }
+
+    pub fn as_ref(&self) -> Ref<'_, T> {
+        self.rc.borrow()
+    }
+
+    pub fn as_mut(&mut self) -> RefMut<'_, T> {
+        self.rc.borrow_mut()
+    }
+}
+
+impl<T> Clone for ListenerCell<T> {
+    fn clone(&self) -> Self {
+        ListenerCell {
+            rc: self.rc.clone(),
+        }
+    }
+}
+
+#[derive(Eq)]
+pub struct ListenerRef {
+    weak: Weak<RefCell<dyn ListenerUpdate>>,
+}
+
+pub enum ListenerError {
+    Invalid,
+}
+
+impl ListenerRef {
+    #[inline]
+    pub fn is_valid(&self) -> bool {
+        self.weak.upgrade().is_some()
+    }
+
+    pub fn try_update(&mut self, event: &EditorEvent) -> Result<(), ListenerError> {
+        if let Some(rc) = self.weak.upgrade() {
+            rc.borrow_mut().update(event);
+            Ok(())
+        } else {
+            Err(ListenerError::Invalid)
+        }
+    }
+
+    pub fn update(&mut self, event: &EditorEvent) {
+        match self.try_update(event) {
+            Ok(_) => (),
+            Err(ListenerError::Invalid) => panic!("Listener doesn't exist anymore"),
+        }
+    }
+}
+
+impl PartialEq for ListenerRef {
+    fn eq(&self, other: &Self) -> bool {
+        self.weak.ptr_eq(&other.weak)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::observer::email::EmailAlerts;
+    use crate::observer::subject::Subject;
+
+    use super::*;
+
+    #[test]
+    fn listener_drop() {
+        let listener = EmailAlerts::new();
+        let mut subject = Subject::new();
+        {
+            let listener = ListenerCell::from(listener);
+            assert_eq!(Rc::weak_count(&listener.rc), 0);
+            assert_eq!(Rc::strong_count(&listener.rc), 1);
+            subject.add_listener(&listener);
+            subject.add_listener(&listener);
+            assert_eq!(subject.listener_count(), 2);
+            assert_eq!(Rc::weak_count(&listener.rc), 2);
+            assert_eq!(Rc::strong_count(&listener.rc), 1);
+        }
+        assert_eq!(subject.listener_count(), 0);
+    }
+}