moving simple output handler into handlers/output

src/handlers/mod.rs

@@ -8,7 +8,7 @@ pub mod outputs;
 // export Handlers
 pub use debug::DebugHandler;
 pub use msg_count::MessageCountHandler;
-pub use outputs::OutputHandler;
+pub use outputs::SimpleOutputHandler;
 
 #[async_trait::async_trait]
 pub trait Handler: Debug + Send + Sync {

src/handlers/outputs.rs

@@ -1,13 +1,17 @@
+use tokio::sync::RwLock;
+
 use crate::handlers::Handler;
 use crate::jupyter::response::Response;
 use crate::notebook::Output;
 
-use std::fmt::Debug;
+use std::{fmt::Debug, sync::Arc};
 
 #[async_trait::async_trait]
 pub trait OutputHandler: Handler + Debug + Send + Sync {
+    // expect a struct implementing this to have a .clear_on_next_output bool attribute
     async fn add_cell_content(&self, content: Output);
     async fn clear_cell_content(&self);
+    async fn sync_display_data(&self, content: Output);
 
     async fn handle_output(&self, msg: &Response) {
         match msg {
@@ -43,3 +47,36 @@ impl<T: OutputHandler + Send + Sync> Handler for T {
         self.handle_output(msg).await;
     }
 }
+
+#[derive(Debug, Clone)]
+pub struct SimpleOutputHandler {
+    pub output: Arc<RwLock<Vec<Output>>>,
+}
+
+impl SimpleOutputHandler {
+    pub fn new() -> Self {
+        Self {
+            output: Arc::new(RwLock::new(Vec::new())),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl OutputHandler for SimpleOutputHandler {
+    async fn add_cell_content(&self, content: Output) {
+        self.output.write().await.push(content);
+        println!("add_cell_content");
+    }
+
+    async fn clear_cell_content(&self) {
+        self.output.write().await.clear();
+        println!("clear_cell_content");
+    }
+
+    async fn sync_display_data(&self, _content: Output) {
+        // Don't do anything for sync display data in SimpleOutputHandler
+        // we aren't keeping any reference to the full Notebook document in order to
+        // update the display data by id outside of this "current cell" context
+        ()
+    }
+}

src/main.rs

@@ -8,38 +8,11 @@ use tokio::signal::unix::{signal, SignalKind};
 use tokio::time::sleep;
 
 use indoc::indoc;
-use kernel_sidecar_rs::notebook::Output;
+
 use std::sync::Arc;
 use std::time::Duration;
-use tokio::sync::RwLock;
-
-use kernel_sidecar_rs::handlers::OutputHandler;
-
-#[derive(Debug, Clone)]
-struct SimpleOutputHandler {
-    pub output: Arc<RwLock<Vec<Output>>>,
-}
-
-impl SimpleOutputHandler {
-    pub fn new() -> Self {
-        Self {
-            output: Arc::new(RwLock::new(Vec::new())),
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl OutputHandler for SimpleOutputHandler {
-    async fn add_cell_content(&self, content: Output) {
-        self.output.write().await.push(content);
-        println!("add_cell_content");
-    }
 
-    async fn clear_cell_content(&self) {
-        self.output.write().await.clear();
-        println!("clear_cell_content");
-    }
-}
+use kernel_sidecar_rs::handlers::SimpleOutputHandler;
 
 #[tokio::main]
 async fn main() {
@@ -61,7 +34,6 @@ async fn main() {
     // let action = client.kernel_info_request(handlers).await;
     let code = indoc! {r#"
     from IPython.display import clear_output
-    import time
 
 
     print("Before Clear Output")

tests/test_outputs.rs

@@ -1,40 +1,13 @@
 #![cfg(feature = "test_ipython")]
 use indoc::indoc;
-use kernel_sidecar_rs::handlers::{Handler, OutputHandler};
+use kernel_sidecar_rs::handlers::{Handler, SimpleOutputHandler};
 use kernel_sidecar_rs::jupyter::iopub_content::stream::StreamName;
-use kernel_sidecar_rs::notebook::Output;
+
 use std::sync::Arc;
-use tokio::sync::RwLock;
 
 mod test_utils;
 use test_utils::start_kernel;
 
-#[derive(Debug, Clone)]
-struct SimpleOutputHandler {
-    pub output: Arc<RwLock<Vec<Output>>>,
-}
-
-impl SimpleOutputHandler {
-    pub fn new() -> Self {
-        Self {
-            output: Arc::new(RwLock::new(Vec::new())),
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl OutputHandler for SimpleOutputHandler {
-    async fn add_cell_content(&self, content: Output) {
-        self.output.write().await.push(content);
-        println!("add_cell_content");
-    }
-
-    async fn clear_cell_content(&self) {
-        self.output.write().await.clear();
-        println!("clear_cell_content");
-    }
-}
-
 #[tokio::test]
 async fn test_mixed_outputs() {
     // Show that stream and execute result can be mixed