src/tui.rs

@@ -33,7 +33,10 @@ impl Tui {
 
         let mut dir = env::temp_dir();
         dir.push("clide.log");
-        let file_options = TuiLoggerFile::new(dir.to_str().unwrap())
+        let file_options = TuiLoggerFile::new(
+            dir.to_str()
+                .context("Failed to set temp directory for file logging")?,
+        )
         .output_level(Some(TuiLoggerLevelOutput::Abbreviated))
         .output_file(false)
         .output_separator(':');

src/tui/app.rs

@@ -1,15 +1,15 @@
+use crate::tui::app::AppComponent::{AppEditor, AppExplorer, AppLogger};
 use crate::tui::component::{Action, Component, Focus, FocusState};
 use crate::tui::editor::Editor;
 use crate::tui::explorer::Explorer;
 use crate::tui::logger::Logger;
-use anyhow::{Context, Result, bail};
+use anyhow::{Context, Result};
 use log::{debug, error, info, trace, warn};
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
 use ratatui::layout::{Constraint, Direction, Layout, Rect};
 use ratatui::prelude::{Color, Style, Widget};
-use ratatui::text::Text;
 use ratatui::widgets::{Block, Borders, Padding, Paragraph, Tabs, Wrap};
 use ratatui::{DefaultTerminal, symbols};
 use std::path::PathBuf;
@@ -17,61 +17,50 @@ use std::time::Duration;
 
 // TODO: Need a way to dynamically run Widget::render on all widgets.
 // TODO: + Need a way to map Rect to Component::id() to position each widget?
-// TODO: Need a way to dynamically run Component methods on all widgets.
+// TODO: Need a good way to dynamically run Component methods on all widgets.
-pub enum AppComponents<'a> {
+#[derive(PartialEq)]
-    AppEditor(Editor),
+pub enum AppComponent {
-    AppExplorer(Explorer<'a>),
+    AppEditor,
-    AppLogger(Logger),
+    AppExplorer,
-    #[allow(dead_code)]
+    AppLogger,
-    AppComponent(Box<dyn Component>),
-}
-
-/// Usage: get_component_mut::<Editor>() OR get_component::<Editor>()
-///
-/// Implementing this trait for each AppComponent allows for easy lookup in the vector.
-pub(crate) trait ComponentOf<T> {
-    fn as_ref(&self) -> Option<&T>;
-    fn as_mut(&mut self) -> Option<&mut T>;
 }
 
 pub struct App<'a> {
-    components: Vec<AppComponents<'a>>,
+    editor: Editor,
+    explorer: Explorer<'a>,
+    logger: Logger,
+    last_active: AppComponent,
 }
 
 impl<'a> App<'a> {
+    pub fn id() -> &'static str {
+        "App"
+    }
+
     pub fn new(root_path: PathBuf) -> Result<Self> {
-        let mut app = Self {
+        let app = Self {
-            components: vec![
+            editor: Editor::new(),
-                AppComponents::AppExplorer(Explorer::new(&root_path)?),
+            explorer: Explorer::new(&root_path)?,
-                AppComponents::AppEditor(Editor::new()),
+            logger: Logger::new(),
-                AppComponents::AppLogger(Logger::new()),
+            last_active: AppEditor,
-            ],
         };
-        let editor = app.get_component_mut::<Editor>().unwrap();
+        Ok(app)
-        editor
+    }
+
+    /// Logic that should be executed once on application startup.
+    pub fn start(&mut self) -> Result<()> {
+        let root_path = self.explorer.root_path.clone();
+        self.editor
             .set_contents(&root_path.join("src/tui/app.rs"))
             .context(format!(
                 "Failed to initialize editor contents to path: {root_path:?}"
             ))?;
-        editor.component_state.set_focus(Focus::Active);
+        self.editor.component_state.set_focus(Focus::Active);
-        Ok(app)
+        Ok(())
-    }
-
-    fn get_component<T>(&self) -> Option<&T>
-    where
-        AppComponents<'a>: ComponentOf<T>,
-    {
-        self.components.iter().find_map(|c| c.as_ref())
-    }
-
-    fn get_component_mut<T>(&mut self) -> Option<&mut T>
-    where
-        AppComponents<'a>: ComponentOf<T>,
-    {
-        self.components.iter_mut().find_map(|c| c.as_mut())
     }
 
     pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
+        self.start()?;
         loop {
             self.refresh_editor_contents()
                 .context("Failed to refresh editor contents.")?;
@@ -80,7 +69,6 @@ impl<'a> App<'a> {
                 f.render_widget(&mut self, f.area());
             })?;
 
-            // TODO: Handle events based on which component is active.
             if event::poll(Duration::from_millis(250)).context("event poll failed")? {
                 match self.handle_event(event::read()?)? {
                     Action::Quit => break,
@@ -103,14 +91,13 @@ impl<'a> App<'a> {
     }
 
     fn draw_bottom_status(&self, area: Rect, buf: &mut Buffer) {
-        // TODO: Set help text based on most recent component enabled.
+        // Determine help text from the most recently focused component.
-        Paragraph::new(
+        let help = match self.last_active {
-            self.get_component::<Logger>()
+            AppEditor => self.editor.component_state.help_text.clone(),
-                .unwrap()
+            AppExplorer => self.explorer.component_state.help_text.clone(),
-                .component_state
+            AppLogger => self.logger.component_state.help_text.clone(),
-                .help_text
+        };
-                .clone(),
+        Paragraph::new(help)
-        )
             .style(Color::Gray)
             .wrap(Wrap { trim: false })
             .centered()
@@ -119,16 +106,14 @@ impl<'a> App<'a> {
 
     fn draw_tabs(&self, area: Rect, buf: &mut Buffer) {
         // Determine the tab title from the current file (or use a fallback).
-        let mut title: Option<&str> = None;
+        if let Some(title) = self.editor.file_path.clone() {
-        if let Some(editor) = self.get_component::<Editor>() {
+            Tabs::new(vec![
-            title = editor
+                title
-                .file_path
+                    .file_name()
-                .as_ref()
+                    .map(|f| f.to_str())
-                .and_then(|p| p.file_name())
+                    .unwrap_or(Some("Unknown"))
-                .and_then(|s| s.to_str())
+                    .unwrap(),
-        }
+            ])
-
-        Tabs::new(vec![title.unwrap_or("Unknown")])
             .divider(symbols::DOT)
             .block(
                 Block::default()
@@ -137,30 +122,44 @@ impl<'a> App<'a> {
             )
             .highlight_style(Style::default().fg(Color::LightRed))
             .render(area, buf);
+        } else {
+            error!(target:Self::id(), "Failed to get Editor file_path while drawing Tabs widget.");
+        }
+    }
+
+    fn change_focus(&mut self, focus: AppComponent) {
+        if self.last_active == AppEditor {
+            self.editor.state.cursor.row = 0;
+            self.editor.state.cursor.col = 0;
+        }
+        match focus {
+            AppEditor => self.editor.component_state.set_focus(Focus::Active),
+            AppExplorer => self.explorer.component_state.set_focus(Focus::Active),
+            AppLogger => self.logger.component_state.set_focus(Focus::Active),
+        }
+        self.last_active = focus;
     }
 
     /// Refresh the contents of the editor to match the selected TreeItem in the file Explorer.
     /// If the selected item is not a file, this does nothing.
     fn refresh_editor_contents(&mut self) -> Result<()> {
         // Use the currently selected TreeItem or get an absolute path to this source file.
-        let selected_pathbuf = match self.get_component::<Explorer>().unwrap().selected() {
+        let selected_pathbuf = match self.explorer.selected() {
             Ok(path) => PathBuf::from(path),
             Err(_) => PathBuf::from(std::path::absolute(file!())?.to_string_lossy().to_string()),
         };
-        let editor = self
+        let current_file_path = self
-            .get_component_mut::<Editor>()
+            .editor
-            .context("Failed to get active editor while refreshing contents.")?;
+            .file_path
-        if let Some(current_file_path) = editor.file_path.clone() {
+            .clone()
+            .context("Failed to get Editor current file_path")?;
         if selected_pathbuf == current_file_path || !selected_pathbuf.is_file() {
             return Ok(());
         }
-            return editor.set_contents(&selected_pathbuf);
+        self.editor.set_contents(&selected_pathbuf)
-        }
-        bail!("Failed to refresh editor contents")
     }
 }
 
-// TODO: Separate complex components into their own widgets.
 impl<'a> Widget for &mut App<'a> {
     fn render(self, area: Rect, buf: &mut Buffer)
     where
@@ -195,35 +194,17 @@ impl<'a> Widget for &mut App<'a> {
         self.draw_top_status(vertical[0], buf);
         self.draw_bottom_status(vertical[3], buf);
         self.draw_tabs(editor_layout[0], buf);
-        let id = self.id().to_string();
+        let id = App::id().to_string();
-        for component in &mut self.components {
+        self.editor.render(editor_layout[1], buf);
-            match component {
+        self.explorer
-                AppComponents::AppEditor(editor) => editor.render(editor_layout[1], buf),
-                AppComponents::AppExplorer(explorer) => {
-                    explorer
             .render(horizontal[0], buf)
             .context("Failed to render Explorer")
             .unwrap_or_else(|e| error!(target:id.as_str(), "{}", e));
-                }
+        self.logger.render(vertical[2], buf);
-                AppComponents::AppLogger(logger) => logger.render(vertical[2], buf),
-                AppComponents::AppComponent(_) => {}
-            }
-        }
     }
 }
 
 impl<'a> Component for App<'a> {
-    fn id(&self) -> &str {
-        "App"
-    }
-
-    /// TODO: Get active widget with some Component trait function helper?
-    /// trait Component { fn get_state() -> ComponentState; }
-    /// if component.get_state() = ComponentState::Active { component.handle_event(); }
-    ///
-    /// App could then provide helpers for altering Component state based on TUI grouping..
-    ///    (such as editor tabs, file explorer, status bars, etc..)
-    ///
     /// Handles events for the App and delegates to attached Components.
     fn handle_event(&mut self, event: Event) -> Result<Action> {
         // Handle events in the primary application.
@@ -238,26 +219,22 @@ impl<'a> Component for App<'a> {
         }
 
         // Handle events for all components.
-        for component in &mut self.components {
+        let action = match self.last_active {
-            let c = match component {
+            AppEditor => self.editor.handle_event(event)?,
-                AppComponents::AppEditor(e) => e as &mut dyn Component,
+            AppExplorer => self.explorer.handle_event(event)?,
-                AppComponents::AppExplorer(e) => e as &mut dyn Component,
+            AppLogger => self.logger.handle_event(event)?,
-                AppComponents::AppLogger(e) => e as &mut dyn Component,
-                AppComponents::AppComponent(e) => e.as_mut(),
         };
-            if !c.is_active() {
+        // if !c.is_active() {
-                if let Some(mouse) = event.as_mouse_event() {
+        //     if let Some(mouse) = event.as_mouse_event() {
-                    // Always handle mouse events for click interaction.
+        //         // Always handle mouse events for click interaction.
-                    c.handle_mouse_events(mouse)?;
+        //         c.handle_mouse_events(mouse)?;
-                }
+        //     }
-                continue;
+        //     continue;
-            }
+        // }
-            let action = c.handle_event(event.clone())?;
         match action {
             Action::Quit | Action::Handled => return Ok(action),
             _ => {}
         }
-        }
         Ok(Action::Noop)
     }
 
@@ -270,10 +247,7 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                self.get_component_mut::<Explorer>()
+                self.change_focus(AppExplorer);
-                    .unwrap()
-                    .component_state
-                    .toggle_focus();
                 Ok(Action::Handled)
             }
             KeyEvent {
@@ -282,10 +256,7 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                self.get_component_mut::<Editor>()
+                self.change_focus(AppEditor);
-                    .unwrap()
-                    .component_state
-                    .toggle_focus();
                 Ok(Action::Handled)
             }
             KeyEvent {
@@ -294,10 +265,7 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                self.get_component_mut::<Logger>()
+                self.change_focus(AppLogger);
-                    .unwrap()
-                    .component_state
-                    .toggle_focus();
                 Ok(Action::Handled)
             }
             KeyEvent {
@@ -306,11 +274,11 @@ impl<'a> Component for App<'a> {
                 kind: KeyEventKind::Press,
                 state: _state,
             } => {
-                error!(target:self.id(), "an error");
+                error!(target:App::id(), "an error");
-                warn!(target:self.id(), "a warning");
+                warn!(target:App::id(), "a warning");
-                info!(target:self.id(), "a two line info\nsecond line");
+                info!(target:App::id(), "a two line info\nsecond line");
-                debug!(target:self.id(), "a debug");
+                debug!(target:App::id(), "a debug");
-                trace!(target:self.id(), "a trace");
+                trace!(target:App::id(), "a trace");
                 Ok(Action::Handled)
             }
             KeyEvent {

src/tui/component.rs

@@ -22,10 +22,6 @@ pub enum Action {
 }
 
 pub trait Component {
-    /// Returns a unique identifier for the component.
-    /// This is used for lookup in a container of Components.
-    fn id(&self) -> &str;
-
     fn handle_event(&mut self, event: Event) -> Result<Action> {
         match event {
             Event::Key(key_event) => self.handle_key_events(key_event),

src/tui/editor.rs

@@ -1,6 +1,4 @@
 use crate::tui::component::{Action, Component, ComponentState, Focus};
-
-use crate::tui::app::{AppComponents, ComponentOf};
 use anyhow::{Context, Result, bail};
 use edtui::{
     EditorEventHandler, EditorState, EditorTheme, EditorView, LineNumbers, Lines, SyntaxHighlighter,
@@ -24,22 +22,11 @@ pub struct Editor {
     pub(crate) component_state: ComponentState,
 }
 
-impl<'a> ComponentOf<Editor> for AppComponents<'a> {
+impl Editor {
-    fn as_ref(&self) -> Option<&Editor> {
+    pub fn id() -> &'static str {
-        if let AppComponents::AppEditor(ref e) = *self {
+        "Editor"
-            return Some(e);
-        }
-        None
-    }
-    fn as_mut(&mut self) -> Option<&mut Editor> {
-        if let AppComponents::AppEditor(ref mut e) = *self {
-            return Some(e);
-        }
-        None
-    }
     }
 
-impl Editor {
     pub fn new() -> Self {
         Editor {
             state: EditorState::default(),
@@ -104,14 +91,6 @@ impl Widget for &mut Editor {
 }
 
 impl Component for Editor {
-    fn id(&self) -> &str {
-        "Editor"
-    }
-
-    fn is_active(&self) -> bool {
-        self.component_state.focus == Focus::Active
-    }
-
     fn handle_event(&mut self, event: Event) -> Result<Action> {
         if let Some(key_event) = event.as_key_event() {
             // Handle events here that should not be passed on to the vim emulation handler.
@@ -140,4 +119,8 @@ impl Component for Editor {
             _ => Ok(Action::Noop),
         }
     }
+
+    fn is_active(&self) -> bool {
+        self.component_state.focus == Focus::Active
+    }
 }

src/tui/explorer.rs

@@ -1,4 +1,3 @@
-use crate::tui::app::{AppComponents, ComponentOf};
 use crate::tui::component::{Action, Component, ComponentState, Focus};
 use anyhow::{Context, Result, bail};
 use ratatui::buffer::Buffer;
@@ -12,28 +11,17 @@ use tui_tree_widget::{Tree, TreeItem, TreeState};
 
 #[derive(Debug)]
 pub struct Explorer<'a> {
-    root_path: std::path::PathBuf,
+    pub(crate) root_path: std::path::PathBuf,
     tree_items: TreeItem<'a, String>,
     tree_state: TreeState<String>,
     pub(crate) component_state: ComponentState,
 }
 
-impl<'a> ComponentOf<Explorer<'a>> for AppComponents<'a> {
+impl<'a> Explorer<'a> {
-    fn as_ref(&self) -> Option<&Explorer<'a>> {
+    pub fn id() -> &'static str {
-        if let AppComponents::AppExplorer(ref e) = *self {
+        "Explorer"
-            return Some(e);
-        }
-        None
-    }
-    fn as_mut(&mut self) -> Option<&mut Explorer<'a>> {
-        if let AppComponents::AppExplorer(ref mut e) = *self {
-            return Some(e);
-        }
-        None
-    }
     }
 
-impl<'a> Explorer<'a> {
     pub fn new(path: &std::path::PathBuf) -> Result<Self> {
         let explorer = Explorer {
             root_path: path.to_owned(),
@@ -123,21 +111,16 @@ impl<'a> Explorer<'a> {
 
     pub fn selected(&self) -> Result<String> {
         if let Some(path) = self.tree_state.selected().last() {
-            return Ok(std::path::absolute(path)?.to_str().unwrap().to_string());
+            return Ok(std::path::absolute(path)?
+                .to_str()
+                .context("Failed to get absolute path to selected TreeItem")?
+                .to_string());
         }
         bail!("Failed to get selected TreeItem")
     }
 }
 
 impl<'a> Component for Explorer<'a> {
-    fn id(&self) -> &str {
-        "Explorer"
-    }
-
-    fn is_active(&self) -> bool {
-        self.component_state.focus == Focus::Active
-    }
-
     fn handle_event(&mut self, event: Event) -> Result<Action> {
         if let Some(key_event) = event.as_key_event() {
             // Handle events here that should not be passed on to the vim emulation handler.
@@ -188,4 +171,8 @@ impl<'a> Component for Explorer<'a> {
         }
         Ok(Action::Noop)
     }
+
+    fn is_active(&self) -> bool {
+        self.component_state.focus == Focus::Active
+    }
 }

src/tui/logger.rs

@@ -1,4 +1,3 @@
-use crate::tui::app::{AppComponents, ComponentOf};
 use crate::tui::component::{Action, Component, ComponentState, Focus};
 use ratatui::buffer::Buffer;
 use ratatui::crossterm::event::{Event, KeyCode, KeyEvent};
@@ -14,27 +13,16 @@ pub struct Logger {
     pub(crate) component_state: ComponentState,
 }
 
-impl<'a> ComponentOf<Logger> for AppComponents<'a> {
+impl Logger {
-    fn as_ref(&self) -> Option<&Logger> {
+    pub fn id() -> &'static str {
-        if let AppComponents::AppLogger(ref e) = *self {
+        "Logger"
-            return Some(e);
-        }
-        None
-    }
-    fn as_mut(&mut self) -> Option<&mut Logger> {
-        if let AppComponents::AppLogger(ref mut e) = *self {
-            return Some(e);
-        }
-        None
-    }
     }
 
-impl Logger {
     pub fn new() -> Self {
         Self {
             state: TuiWidgetState::new(),
             component_state: ComponentState::default().with_help_text(concat!(
-                "Q: Quit | Tab: Switch state | ↑/↓: Select target | f: Focus target",
+                "Q: Quit | ↑/↓: Select target | f: Focus target",
                 " | ←/→: Display level | +/-: Filter level | Space: Toggle hidden targets",
                 " | h: Hide target selector | PageUp/Down: Scroll | Esc: Cancel scroll"
             )),
@@ -47,7 +35,6 @@ impl Widget for &Logger {
     where
         Self: Sized,
     {
-        // TODO: Use output_file?
         TuiLoggerSmartWidget::default()
             .style_error(Style::default().fg(Color::Red))
             .style_debug(Style::default().fg(Color::Green))
@@ -66,14 +53,6 @@ impl Widget for &Logger {
 }
 
 impl Component for Logger {
-    fn id(&self) -> &str {
-        "Logger"
-    }
-
-    fn is_active(&self) -> bool {
-        self.component_state.focus == Focus::Active
-    }
-
     fn handle_event(&mut self, event: Event) -> anyhow::Result<Action> {
         if let Some(key_event) = event.as_key_event() {
             return self.handle_key_events(key_event);
@@ -99,4 +78,8 @@ impl Component for Logger {
         }
         Ok(Action::Pass)
     }
+
+    fn is_active(&self) -> bool {
+        self.component_state.focus == Focus::Active
+    }
 }