Merge pull request #118 from j-mie6/dev

Merge breakpoint interactivity to main

Author: josh-ja-walker

backend/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "dill"
-version = "0.3.0"
+version = "0.4.0"
 description = "A cross-platform debugging UI for `parsley-debug`"
 authors = ["Jamie Willis (@j-mie6)", "Josh Walker (@josh-ja-walker)", "Aniket Gupta (@aniket1101)", "Priyansh Chugh (@PriyanshC)", "Alejandro Perez Fadon (@Aito0)", "Riley Horrix (@Riley-horrix)", "Adam Watson (@AdamW1087)"]
 license = "BSD 3-Clause"

backend/Cargo.toml

@@ -1,5 +1,6 @@
 mod fetch;
 mod save;
+mod breakpoint;
 
 /* Expose command handlers for Tauri setup */
 pub fn handlers() -> impl Fn(tauri::ipc::Invoke) -> bool {
@@ -9,6 +10,7 @@ pub fn handlers() -> impl Fn(tauri::ipc::Invoke) -> bool {
         save::save_tree, 
         save::fetch_saved_tree_names, 
         save::load_saved_tree,
-        save::delete_tree
+        save::delete_tree,
+        breakpoint::skip_breakpoints,
     ]
 }

backend/src/commands.rs

@@ -0,0 +1,21 @@
+use crate::state::{StateError, StateManager};
+use crate::AppState;
+
+#[tauri::command]
+pub fn skip_breakpoints(state: tauri::State<'_, AppState>, skips: i32) -> Result<(), SkipBreakpointError> {
+    state.transmit_breakpoint_skips(skips).map_err(SkipBreakpointError::from)
+}
+
+#[derive(Debug, serde::Serialize)]
+pub enum SkipBreakpointError {
+    ChannelError,
+}
+
+impl From<StateError> for SkipBreakpointError {
+    fn from(err: StateError) -> Self {
+        match err {
+            StateError::ChannelError => Self::ChannelError,
+            _ => panic!("Unexpected error on skip_breakpoints"),
+        }
+    }
+}

backend/src/commands/breakpoint.rs

@@ -1,11 +1,13 @@
 use tauri::Manager;
 use tauri::RunEvent;
 
+use rocket::tokio::sync::{Mutex, mpsc};
+
+mod server;
 mod state;
 mod commands;
 mod events;
 mod trees;
-mod server;
 mod files;
 
 use state::AppState;
@@ -22,14 +24,16 @@ fn setup(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
         )?;
     }
 
+    let (tx, rx): (state::SkipsSender, server::SkipsReceiver) = mpsc::channel::<i32>(1);
+
     /* Manage the app state using Tauri */
-    let app_state: AppState = AppState::new(app.app_handle().clone());
+    let app_state: AppState = AppState::new(app.app_handle().clone(), Mutex::new(tx));
     app.manage(app_state);
 
     files::create_saved_trees_dir().expect("Error occured while making saved_trees folder");
 
     /* Clone the app handle and use to create a ServerState */
-    let server_state: ServerState = ServerState::new(app.handle().clone());
+    let server_state: ServerState = ServerState::new(app.handle().clone(), Mutex::new(rx));
 
     /* Mount the Rocket server to the running instance of Tauri */
     tauri::async_runtime::spawn(async move {

backend/src/lib.rs

@@ -3,13 +3,16 @@ mod request;
 mod server_state;
 
 pub use launch::launch;
-pub use server_state::ServerState;
+pub use server_state::{ServerState, SkipsReceiver};
+
+pub type TokioMutex<T> = rocket::tokio::sync::Mutex<T>;
 
 #[cfg(test)]
 pub mod test {
 
     use mockall::predicate;
     use rocket::{http, local::blocking};
+    use rocket::tokio::sync::mpsc;
 
     use super::{launch, ServerState};
     use crate::events::Event;
@@ -22,10 +25,16 @@ pub mod test {
     /* Start a blocking, tracked client for rocket
     The mock should already be set with expectations */
     pub fn tracked_client(mock: MockStateManager) -> blocking::Client {
-        let state = ServerState::new(mock);
+        let rx = empty_channel::<i32>();
+        let state = ServerState::new(mock, super::TokioMutex::new(rx));
         blocking::Client::tracked(launch::build(state)).expect("Could not launch rocket")
     }
 
+    pub fn empty_channel<T>() -> mpsc::Receiver<T> {
+        let (_, rx) = mpsc::channel::<T>(1);
+        rx
+    }
+
     #[test]
     fn server_handles_many_requests() {
         const NUM_REPEATS: usize = 1000;

backend/src/server.rs

@@ -42,7 +42,8 @@ mod test {
     #[test]
     fn rocket_client_launches_successfully() {
         let mock = MockStateManager::new();
-        let state = ServerState::new(mock);
+        let rx = server::test::empty_channel::<i32>();
+        let state = ServerState::new(mock, rocket::tokio::sync::Mutex::new(rx));
 
         let rocket: Rocket<Build> = super::build(state);
 

backend/src/server/launch.rs

@@ -13,6 +13,28 @@ pub fn routes() -> Vec<rocket::Route> {
     rocket::routes![get_index, get_tree, post_tree]
 }
 
+#[derive(Debug, serde::Serialize)]
+struct PostTreeResponse {
+    message: String,
+    #[serde(skip_serializing_if = "Option::is_none")] skip_breakpoint: Option<i32>,
+}
+
+impl PostTreeResponse {
+    fn new(msg: impl Into<String>, skips: i32) -> Json<PostTreeResponse> {
+        Json(PostTreeResponse {
+            message: msg.into(),
+            skip_breakpoint: Some(skips),
+        })
+    }
+
+    fn no_skips(msg: impl Into<String>) -> Json<PostTreeResponse> {
+        Json(PostTreeResponse {
+            message: msg.into(),
+            skip_breakpoint: None,
+        })
+    }
+}
+
 /* Placeholder GET request handler to print 'Hello world!' */
 #[get("/")]
 fn get_index() -> String {
@@ -21,14 +43,15 @@ fn get_index() -> String {
 
 /* Post request handler to accept debug tree */
 #[post("/api/remote/tree", format = "application/json", data = "<data>")]
-fn post_tree(data: Json<ParsleyTree>, state: &rocket::State<ServerState>) -> (http::Status, String) {
+async fn post_tree(data: Json<ParsleyTree>, state: &rocket::State<ServerState>) -> (http::Status, Json<PostTreeResponse>) {
     /* Deserialise and unwrap json data */
     let parsley_tree: ParsleyTree = data.into_inner();
+    let is_debugging: bool = parsley_tree.is_debugging();
     let debug_tree: DebugTree = parsley_tree.into();
 
     /* Format informative response for RemoteView */
     let input: &str = debug_tree.get_input();
-    let response: String = format!(
+    let message: String = format!(
         "Posted parser tree handling input: \"{}{}\" to Dill",
         /* Include first few chars of input */
         &input[..std::cmp::min(input.len(), RESPONSE_INPUT_LEN)],
@@ -41,13 +64,23 @@ fn post_tree(data: Json<ParsleyTree>, state: &rocket::State<ServerState>) -> (ht
 
     /* Update state with new debug_tree and return response */
     match state.set_tree(debug_tree).and(state.emit(Event::NewTree)) {
-        Ok(()) => (http::Status::Ok, response),
-        
-        Err(StateError::EventEmitFailed) => 
-            (http::Status::InternalServerError, String::from("New Tree event could not be emitted - try again")), 
+        Ok(()) => {
+            if !is_debugging {
+                return (http::Status::Ok, PostTreeResponse::no_skips(message))
+            };
+
+            match state.receive_breakpoint_skips().await {
+                Some(skips) => (http::Status::Ok, PostTreeResponse::new(message, skips)),
+                None => (http::Status::InternalServerError, PostTreeResponse::no_skips(message)),
+            }
 
+        },
+        
         Err(StateError::LockFailed) => 
-            (http::Status::InternalServerError, String::from("Locking state mutex failed - try again")), 
+            (http::Status::InternalServerError, PostTreeResponse::no_skips("Locking state mutex failed - try again")),
+
+        Err(StateError::ChannelError) =>
+            (http::Status::InternalServerError, PostTreeResponse::no_skips("Failed to receive value from channel - try again")),
 
         Err(_) => panic!("Unexpected error on post_tree"),
     }
@@ -64,6 +97,7 @@ fn get_tree(state: &rocket::State<ServerState>) -> String {
     }
 }
 
+
 #[cfg(test)]
 pub mod test {
 

backend/src/server/request.rs

@@ -2,13 +2,17 @@ use crate::events::Event;
 use crate::state::{StateError, StateManager};
 use crate::trees::{DebugTree, DebugNode};
 
+use super::TokioMutex;
+
+pub type SkipsReceiver = rocket::tokio::sync::mpsc::Receiver<i32>;
+
 
 /* Wrapper for StateManager implementation used for Rocket server state management */
-pub struct ServerState(Box<dyn StateManager>);
+pub struct ServerState(Box<dyn StateManager>, TokioMutex<SkipsReceiver>);
 
 impl ServerState {
-    pub fn new<S: StateManager>(state: S) -> Self {
-        ServerState(Box::new(state))
+    pub fn new<S: StateManager>(state: S, rx: TokioMutex<SkipsReceiver>) -> Self {
+        ServerState(Box::new(state), rx)
     }
 
     /* Get wrapped StateManager implementation */
@@ -34,4 +38,14 @@ impl StateManager for ServerState {
     fn emit<'a>(&self, event: Event<'a>) -> Result<(), StateError> {
         self.inner().emit(event)
     }
+
+    fn transmit_breakpoint_skips(&self, skips: i32) -> Result<(),StateError> {
+        self.0.as_ref().transmit_breakpoint_skips(skips)
+    }
+}
+
+impl ServerState {
+    pub async fn receive_breakpoint_skips(&self) -> Option<i32> {
+        self.1.lock().await.recv().await
+    }
 }

backend/src/server/server_state.rs

@@ -2,7 +2,7 @@ mod app_state;
 mod state_manager;
 mod app_handle;
 
-pub use app_state::AppState;
+pub use app_state::{AppState, SkipsSender};
 pub use app_handle::AppHandle;
 
 pub use state_manager::{StateManager, StateError};