Refactorings and bug fixes

Author: dantleech

src/app.rs

@@ -447,6 +447,7 @@ impl App {
                 }
             }
             AppEvent::Listen => {
+                self.channels.reset();
                 self.listening_status = ListenStatus::Listening;
                 self.view_current = SelectedView::Listen;
                 self.session_view.mode = SessionViewMode::Current;
@@ -554,6 +555,10 @@ impl App {
             AppEvent::Disconnect => {
                 let _ = self.client.lock().await.deref_mut().disonnect().await;
                 self.listening_status = ListenStatus::Refusing;
+
+                // capture any remaining stdout/stderr
+                self.channels.savepoint(self.history.offset).await;
+                self.focus_current_channel();
                 self.sender
                     .send(AppEvent::ChangeSessionViewMode(SessionViewMode::History))
                     .await?;
@@ -568,7 +573,8 @@ impl App {
                 }
             }
             AppEvent::NextChannel => {
-                self.session_view.eval_state.channel = (self.session_view.eval_state.channel + 1) % self.channels.count()
+                self.session_view.eval_state.channel = (self.session_view.eval_state.channel + 1) % self.channels.count();
+                self.focus_current_channel();
             },
             AppEvent::NotifyError(message) => {
                 self.notification = Notification::error(message);
@@ -811,28 +817,6 @@ impl App {
             entry.push(stack);
         }
 
-        // *xdebug* only evalutes expressions on the current stack frame
-        let eval = if !self.session_view.eval_state.input.to_string().is_empty() {
-            let response = self
-                .client
-                .lock()
-                .await
-                .eval(
-                    self.session_view.eval_state.input.to_string(),
-                    self.session_view.stack_depth(),
-                )
-                .await?;
-
-                Some(EvalEntry{
-                    expr: self.session_view.eval_state.input.to_string(),
-                    response
-                })
-        } else {
-            None
-        };
-
-        entry.eval = eval;
-
         self.session_view.reset();
         self.history.push(entry);
         self.channels.savepoint(self.history.offset).await;
@@ -877,6 +861,10 @@ impl App {
             self.session_view
                 .scroll_to_line(entry.source(self.session_view.stack_depth()).line_no)
         }
+        self.focus_current_channel();
+    }
+
+    fn focus_current_channel(&mut self) {
         if let Some(c) = self.channels.channel_by_offset(self.session_view.eval_state.channel) { self.focus_channel(c.name.clone()) }
     }
 

src/channel.rs

@@ -96,15 +96,7 @@ impl Channel {
                 content[0..*offset].lines().map(|s|s.to_string()).collect()
             }
             Entry::Vacant(_) => {
-                match self.current_offset {
-                    // if we previously resolved a snapshot then use that
-                    Some(current_offset) => {
-                        content[0..current_offset].lines().map(|s|s.to_string()).collect()
-                    },
-                    None => {
-                        content.lines().map(|s|s.to_string()).collect()
-                    }
-                }
+                vec![]
             }
         };
     }

src/php_process.rs

@@ -1,6 +1,7 @@
 use std::{process::Stdio, str::from_utf8};
-use tokio::io::AsyncReadExt;
+use tokio::io::{AsyncReadExt, Stdout};
 
+use tokio::process::{ChildStderr, ChildStdout};
 use tokio::select;
 use tokio::sync::mpsc::Receiver;
 use tokio::{io::BufReader, process::Command, sync::mpsc::Sender, task};
@@ -13,22 +14,16 @@ pub enum ProcessEvent {
     Stop,
 }
 
-pub fn process_manager_start(
-    receiver: Receiver<ProcessEvent>,
-    parent_sender: Sender<AppEvent>,
-) {
+pub fn process_manager_start(receiver: Receiver<ProcessEvent>, parent_sender: Sender<AppEvent>) {
     task::spawn(async move {
         match process_manager_loop(receiver, parent_sender.clone()).await {
             Ok(_) => (),
             Err(e) => {
                 parent_sender
-                    .send(AppEvent::ChannelLog(
-                        "notice".to_string(),
-                        e.to_string(),
-                    ))
+                    .send(AppEvent::ChannelLog("notice".to_string(), e.to_string()))
                     .await
                     .unwrap_or_default();
-            },
+            }
         };
     });
 }
@@ -39,10 +34,12 @@ async fn process_manager_loop(
 ) -> Result<(), anyhow::Error> {
     loop {
         let cmd = receiver.recv().await;
+
         let event = match cmd {
             Some(event) => event,
             None => continue,
         };
+
         let args = match event {
             ProcessEvent::Start(args) => args,
             ProcessEvent::Stop => continue,
@@ -61,58 +58,35 @@ async fn process_manager_loop(
             .args(&args[1..])
             .spawn()?;
 
-        let mut stdoutreader = BufReader::new(process.stdout.take().unwrap());
-        let mut stderrreader = BufReader::new(process.stderr.take().unwrap());
 
         let sender = parent_sender.clone();
 
-        let io_task = task::spawn(async move {
-            loop {
-                let mut stdout_buff = [0; 255];
-                let mut stderr_buff = [0; 255];
-
-                select! {
-                    read = stdoutreader.read(&mut stdout_buff) => {
-                        if let Ok(s) = from_utf8(&stdout_buff[..read.unwrap()]) {
-                            if s.is_empty() {
-                                return;
-                            }
-                            sender
-                                .send(AppEvent::ChannelLog("stdout".to_string(), s.to_string()))
-                                .await.unwrap_or_default();
-                        };
-                    },
-                    read = stderrreader.read(&mut stderr_buff) => {
-                        if let Ok(s) = from_utf8(&stderr_buff[..read.unwrap()]) {
-                            if s.is_empty() {
-                                return;
-                            }
-                            sender
-                                .send(
-                                    AppEvent::ChannelLog("stderr".to_string(), s.to_string())
-                                ).await.unwrap_or_default();
-                        };
-                    },
-                };
-            }
-        });
+        let io_task = task::spawn(io_loop(
+            process.stdout.take().unwrap(),
+            process.stderr.take().unwrap(),
+            sender
+        ));
 
         let sender = parent_sender.clone();
+
         loop {
             select! {
                 exit_code = process.wait() => {
-                    if let Ok(exit_code) = exit_code {
-                        if exit_code.code().unwrap_or_default() != 0 {
-                            let _ = sender.send(
-                                AppEvent::NotifyError(
-                                    format!(
-                                        "Process '{:?}' exited with code {}",
-                                        args,
-                                        exit_code.code().unwrap_or_default()
-                                    )
+                    let exit_code = match exit_code {
+                        Ok(e) => e,
+                        // if we 
+                        Err(_) => break,
+                    };
+                    if exit_code.code().unwrap_or_default() != 0 {
+                        let _ = sender.send(
+                            AppEvent::NotifyError(
+                                format!(
+                                    "Process '{:?}' exited with code {}",
+                                    args,
+                                    exit_code.code().unwrap_or_default()
                                 )
-                            ).await;
-                        }
+                            )
+                        ).await;
                     }
                     break;
                 },
@@ -134,3 +108,41 @@ async fn process_manager_loop(
         }
     }
 }
+
+async fn io_loop(
+    stdout: ChildStdout,
+    stderr: ChildStderr,
+    sender: Sender<AppEvent>,
+) {
+
+    let mut stdoutreader = BufReader::new(stdout);
+    let mut stderrreader = BufReader::new(stderr);
+    loop {
+        let mut stdout_buff = [0; 255];
+        let mut stderr_buff = [0; 255];
+
+        select! {
+            read = stdoutreader.read(&mut stdout_buff) => {
+                if let Ok(s) = from_utf8(&stdout_buff[..read.unwrap()]) {
+                    if s.is_empty() {
+                        return;
+                    }
+                    sender
+                        .send(AppEvent::ChannelLog("stdout".to_string(), s.to_string()))
+                        .await.unwrap_or_default();
+                };
+            },
+            read = stderrreader.read(&mut stderr_buff) => {
+                if let Ok(s) = from_utf8(&stderr_buff[..read.unwrap()]) {
+                    if s.is_empty() {
+                        return;
+                    }
+                    sender
+                        .send(
+                            AppEvent::ChannelLog("stderr".to_string(), s.to_string())
+                        ).await.unwrap_or_default();
+                };
+            },
+        };
+    }
+}

src/view/context.rs

@@ -45,7 +45,7 @@ impl View for ContextComponent {
         }
     }
 
-    fn draw(app: &App, frame: &mut Frame, _inner_area: Rect, area: Rect) {
+    fn draw(app: &App, frame: &mut Frame, inner_area: Rect, _area: Rect) {
         let entry = match app.history.current() {
             Some(e) => e,
             None => return,
@@ -61,18 +61,18 @@ impl View for ContextComponent {
             .constraints([Constraint::Length(
                 if app.session_view.context_filter.show { 3 } else { 0 }
             ), Constraint::Min(1)]);
-        let areas = layout.split(area);
+        let areas = layout.split(inner_area);
 
         frame.render_widget(Paragraph::new(Line::from(vec![
             Span::raw(app.session_view.context_filter.input.value()).style(app.theme().text_input),
         ])
         ).block(Block::default().borders(Borders::all())), areas[0]);
 
         if app.session_view.context_filter.show {
-            let width = area.width.max(3);
+            let width = inner_area.width.max(3);
             let scroll = app.session_view.context_filter.input.visual_scroll(width as usize);
             let x = app.session_view.context_filter.input.visual_cursor().max(scroll) - scroll + 1;
-            frame.set_cursor_position((area.x + x as u16, area.y + 1));
+            frame.set_cursor_position((inner_area.x + x as u16, inner_area.y + 1));
         }
 
         let mut filter_path = app.session_view.context_filter.segments().clone();

src/view/eval.rs

@@ -102,8 +102,8 @@ impl View for EvalDialog {
         }
     }
 
-    fn draw(app: &App, frame: &mut Frame, _inner_area: Rect, area: Rect) {
-        let darea = centered_rect_absolute(area.width - 10, 3, area);
+    fn draw(app: &App, frame: &mut Frame, inner_area: Rect, _area: Rect) {
+        let darea = centered_rect_absolute(inner_area.width - 10, 3, inner_area);
         frame.render_widget(Clear, darea);
         frame.render_widget(
             Paragraph::new(Line::from(vec![Span::raw(

src/view/help.rs

@@ -21,9 +21,9 @@ impl View for HelpView {
         }
     }
 
-    fn draw(_app: &App, frame: &mut Frame, _inner_area: Rect, area: Rect) {
+    fn draw(_app: &App, frame: &mut Frame, inner_area: Rect, _area: Rect) {
 
-        frame.render_widget(Paragraph::new(help()), area);
+        frame.render_widget(Paragraph::new(help()), inner_area);
 
     }
 }

src/view/layout.rs

@@ -27,7 +27,7 @@ impl View for LayoutView {
         None
     }
 
-    fn draw(app: &App, f: &mut Frame, _: Rect, area: Rect) {
+    fn draw(app: &App, f: &mut Frame, area: Rect, _outer_area: Rect) {
         let constraints = vec![Constraint::Length(1), Constraint::Min(4)];
 
         let rows = Layout::default()

src/view/listen.rs

@@ -13,7 +13,7 @@ impl View for ListenView {
         None
     }
 
-    fn draw(app: &App, frame: &mut Frame, _inner_area: Rect, area: Rect) {
+    fn draw(app: &App, frame: &mut Frame, area: Rect, _outer_area: Rect) {
 
         let block = Block::default()
             .borders(Borders::all())

src/view/mod.rs

@@ -17,7 +17,7 @@ use ratatui::Frame;
 
 pub trait View {
     fn handle(app: &mut App, event: AppEvent) -> Option<AppEvent>;
-    fn draw(app: &App, frame: &mut Frame, inner_area: Rect, area: Rect);
+    fn draw(app: &App, frame: &mut Frame, area: Rect, outer_area: Rect);
 }
 
 #[derive(Debug)]

src/view/session.rs

@@ -104,7 +104,7 @@ impl View for SessionView {
         delegate_event_to_pane(app, event)
     }
 
-    fn draw(app: &App, frame: &mut Frame, _inner_area: ratatui::prelude::Rect, area: Rect) {
+    fn draw(app: &App, frame: &mut Frame, area: ratatui::prelude::Rect, _area: Rect) {
         if app.session_view.full_screen {
             build_pane_widget(
                 frame,