From ce493e016d927fdf10d061d40c2a995902f8099f Mon Sep 17 00:00:00 2001 From: Shaun Reed Date: Sun, 22 Feb 2026 19:37:09 -0500 Subject: [PATCH] Loggable trait and derive macro. --- Cargo.lock | 1 + libclide-macros/src/lib.rs | 11 +++--- libclide/Cargo.toml | 1 + libclide/src/log.rs | 4 +++ libclide/src/log/macros.rs | 74 ++++++++------------------------------ src/tui.rs | 7 ++-- src/tui/about.rs | 4 +-- src/tui/app.rs | 33 +++++++++-------- src/tui/component.rs | 5 ++- src/tui/editor.rs | 19 +++++----- src/tui/editor_tab.rs | 41 +++++++++++++-------- src/tui/explorer.rs | 10 +++--- src/tui/logger.rs | 7 ++-- src/tui/menu_bar.rs | 6 ++-- 14 files changed, 99 insertions(+), 124 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0ae1fc8..2bb2160 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1171,6 +1171,7 @@ version = "0.1.0" dependencies = [ "anyhow", "devicons", + "libclide-macros", "log", "strum", ] diff --git a/libclide-macros/src/lib.rs b/libclide-macros/src/lib.rs index 9ccb788..b92f58b 100644 --- a/libclide-macros/src/lib.rs +++ b/libclide-macros/src/lib.rs @@ -6,8 +6,8 @@ use proc_macro::TokenStream; use quote::quote; use syn::{ItemStruct, parse_macro_input}; -#[proc_macro_attribute] -pub fn log_id(_attr: TokenStream, item: TokenStream) -> TokenStream { +#[proc_macro_derive(Loggable)] +pub fn loggable(item: TokenStream) -> TokenStream { let input = parse_macro_input!(item as ItemStruct); let struct_name = &input.ident; let generics = &input.generics; @@ -15,11 +15,8 @@ pub fn log_id(_attr: TokenStream, item: TokenStream) -> TokenStream { let (impl_generics, type_generics, where_clause) = generics.split_for_impl(); let struct_name_str = struct_name.to_string(); let expanded = quote! { - #input - - impl #impl_generics #struct_name #type_generics #where_clause { - #[allow(unused)] - pub const ID: &'static str = #struct_name_str; + impl #impl_generics libclide::log::Loggable for #struct_name #type_generics #where_clause { + const ID: &'static str = #struct_name_str; } }; diff --git a/libclide/Cargo.toml b/libclide/Cargo.toml index e239386..f5014f3 100644 --- a/libclide/Cargo.toml +++ b/libclide/Cargo.toml @@ -8,3 +8,4 @@ anyhow = { workspace = true } strum = { workspace = true } log = { workspace = true } devicons = { workspace = true } +libclide-macros = { path = "../libclide-macros" } diff --git a/libclide/src/log.rs b/libclide/src/log.rs index dbb82f2..04fb61d 100644 --- a/libclide/src/log.rs +++ b/libclide/src/log.rs @@ -3,3 +3,7 @@ // SPDX-License-Identifier: GNU General Public License v3.0 or later pub mod macros; + +pub trait Loggable { + const ID: &'static str; +} diff --git a/libclide/src/log/macros.rs b/libclide/src/log/macros.rs index ab2827e..593e070 100644 --- a/libclide/src/log/macros.rs +++ b/libclide/src/log/macros.rs @@ -9,111 +9,67 @@ //! explicitly set. This is to avoid implicit pooling of log messages under the same default target, //! which can make it difficult to filter log messages by their source. //! -//! The target argument can be overridden using one of the following macros. -//! ``` -//! libclide::log!(target: "CustomTarget", "This log message will have the target 'CustomTarget'"); +//! The Loggable trait can be implemented to automatically associate log messages with a struct. //! ``` +//! use libclide_macros::Loggable; //! -//! The target argument will default to Self::ID if not provided. -//! This is an error if Self::ID is not defined, forcing you to use the explicit form. -//! ``` -//! libclide::log!("This log message will use target Self::ID, the name of the struct it was invoked in"); -//! ``` -//! -//! Self::ID can be defined using the `#[log_id]` attribute macro, which will automatically generate -//! a constant ID field with the name of the struct as its value. -//! ``` -//! #[log_id] +//! #[derive(Loggable)] //! struct MyStruct; //! impl MyStruct { //! fn my_method(&self) { -//! libclide::log!("This log message will use target Self::ID, which is 'MyStruct'"); +//! libclide::info!("This log message will use target ::ID, which is 'MyStruct'"); //! } //! } //! ``` //! +//! If the struct does not derive or implement Loggable, the target variant of the log macros must +//! be used instead. +//! ``` +//! libclide::info!(target: "CustomTarget", "This log message will have the target 'CustomTarget'"); +//! ``` +//! #[macro_export] macro_rules! info { - (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ - log::info!(logger: $logger, target: $target, $($arg)+) - }); - (target: $target:expr, $($arg:tt)+) => ({ log::info!(target: $target, $($arg)+) }); - (logger: $logger:expr, $($arg:tt)+) => ({ - log::info!(logger: $logger, target: Self::ID, $($arg)+) - }); - - ($($arg:tt)+) => (log::info!(target: Self::ID, $($arg)+)) + ($($arg:tt)+) => (log::info!(target: ::ID, $($arg)+)) } #[macro_export] macro_rules! debug { - (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ - log::debug!(logger: $logger, target: $target, $($arg)+) - }); - (target: $target:expr, $($arg:tt)+) => ({ log::debug!(target: $target, $($arg)+) }); - (logger: $logger:expr, $($arg:tt)+) => ({ - log::debug!(logger: $logger, target: Self::ID, $($arg)+) - }); - - ($($arg:tt)+) => (log::debug!(target: Self::ID, $($arg)+)) + ($($arg:tt)+) => (log::debug!(target: ::ID, $($arg)+)) } #[macro_export] macro_rules! warn { - (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ - log::warn!(logger: $logger, target: $target, $($arg)+) - }); - (target: $target:expr, $($arg:tt)+) => ({ log::warn!(target: $target, $($arg)+) }); - (logger: $logger:expr, $($arg:tt)+) => ({ - log::warn!(logger: $logger, target: Self::ID, $($arg)+) - }); - - ($($arg:tt)+) => (log::warn!(target: Self::ID, $($arg)+)) + ($($arg:tt)+) => (log::warn!(target: ::ID, $($arg)+)) } #[macro_export] macro_rules! error { - (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ - log::error!(logger: $logger, target: $target, $($arg)+) - }); - (target: $target:expr, $($arg:tt)+) => ({ log::error!(target: $target, $($arg)+) }); - (logger: $logger:expr, $($arg:tt)+) => ({ - log::error!(logger: $logger, target: Self::ID, $($arg)+) - }); - - ($($arg:tt)+) => (log::error!(target: Self::ID, $($arg)+)) + ($($arg:tt)+) => (log::error!(target: ::ID, $($arg)+)) } #[macro_export] macro_rules! trace { - (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ - log::trace!(logger: $logger, target: $target, $($arg)+) - }); - (target: $target:expr, $($arg:tt)+) => ({ log::trace!(target: $target, $($arg)+) }); - (logger: $logger:expr, $($arg:tt)+) => ({ - log::trace!(logger: $logger, target: Self::ID, $($arg)+) - }); - - ($($arg:tt)+) => (log::trace!(target: Self::ID, $($arg)+)) + ($($arg:tt)+) => (log::trace!(target: ::ID, $($arg)+)) } diff --git a/src/tui.rs b/src/tui.rs index 88a55d7..bc5e433 100644 --- a/src/tui.rs +++ b/src/tui.rs @@ -13,7 +13,7 @@ mod menu_bar; use crate::AppContext; use anyhow::{Context, Result}; -use libclide_macros::log_id; +use libclide_macros::Loggable; use log::LevelFilter; use ratatui::Terminal; use ratatui::backend::CrosstermBackend; @@ -29,20 +29,19 @@ use tui_logger::{ TuiLoggerFile, TuiLoggerLevelOutput, init_logger, set_default_level, set_log_file, }; -#[log_id] +#[derive(Loggable)] struct Tui { terminal: Terminal>, root_path: std::path::PathBuf, } pub fn run(app_context: AppContext) -> Result<()> { - libclide::trace!(target:Tui::ID, "Starting TUI"); + libclide::trace!(target: "clide::tui::run", "Starting TUI"); Tui::new(app_context)?.start() } impl Tui { fn new(app_context: AppContext) -> Result { - libclide::trace!("Building {}", Self::ID); init_logger(LevelFilter::Trace)?; set_default_level(LevelFilter::Trace); libclide::debug!("Logging initialized"); diff --git a/src/tui/about.rs b/src/tui/about.rs index f5334f4..c5b0d9a 100644 --- a/src/tui/about.rs +++ b/src/tui/about.rs @@ -2,13 +2,13 @@ // // SPDX-License-Identifier: GNU General Public License v3.0 or later -use libclide_macros::log_id; +use libclide_macros::Loggable; use ratatui::buffer::Buffer; use ratatui::layout::{Constraint, Direction, Layout, Rect}; use ratatui::text::{Line, Span}; use ratatui::widgets::{Block, Borders, Clear, Padding, Paragraph, Widget, Wrap}; -#[log_id] +#[derive(Loggable)] pub struct About {} impl About { diff --git a/src/tui/app.rs b/src/tui/app.rs index 3e02c82..a0d2f90 100644 --- a/src/tui/app.rs +++ b/src/tui/app.rs @@ -9,7 +9,8 @@ use crate::tui::explorer::Explorer; use crate::tui::logger::Logger; use crate::tui::menu_bar::MenuBar; use anyhow::{Context, Result}; -use libclide_macros::log_id; +use libclide::log::Loggable; +use libclide_macros::Loggable; use ratatui::DefaultTerminal; use ratatui::buffer::Buffer; use ratatui::crossterm::event; @@ -30,7 +31,7 @@ pub enum AppComponent { MenuBar, } -#[log_id] +#[derive(Loggable)] pub struct App<'a> { editor_tab: EditorTab, explorer: Explorer<'a>, @@ -42,7 +43,7 @@ pub struct App<'a> { impl<'a> App<'a> { pub fn new(root_path: PathBuf) -> Result { - libclide::trace!(target:Self::ID, "Building {}", Self::ID); + libclide::trace!("Building {}", ::ID); let app = Self { editor_tab: EditorTab::new(), explorer: Explorer::new(&root_path)?, @@ -56,13 +57,13 @@ impl<'a> App<'a> { /// Logic that should be executed once on application startup. pub fn start(&mut self) -> Result<()> { - libclide::trace!(target:Self::ID, "Starting App"); + libclide::trace!("Starting App"); Ok(()) } pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> { self.start()?; - libclide::trace!(target:Self::ID, "Entering App run loop"); + libclide::trace!("Entering App run loop"); loop { terminal.draw(|f| { f.render_widget(&mut self, f.area()); @@ -88,7 +89,7 @@ impl<'a> App<'a> { Some(editor) => editor.component_state.help_text.clone(), None => { if !self.editor_tab.is_empty() { - libclide::error!(target:Self::ID, "Failed to get Editor while drawing bottom status bar"); + libclide::error!("Failed to get Editor while drawing bottom status bar"); } "Failed to get current Editor while getting widget help text".to_string() } @@ -112,26 +113,26 @@ impl<'a> App<'a> { } fn clear_focus(&mut self) { - libclide::info!(target:Self::ID, "Clearing all widget focus"); + libclide::info!("Clearing all widget focus"); self.explorer.component_state.set_focus(Focus::Inactive); self.explorer.component_state.set_focus(Focus::Inactive); self.logger.component_state.set_focus(Focus::Inactive); self.menu_bar.component_state.set_focus(Focus::Inactive); match self.editor_tab.current_editor_mut() { None => { - libclide::error!(target:Self::ID, "Failed to get current Editor while clearing focus") + libclide::error!("Failed to get current Editor while clearing focus") } Some(editor) => editor.component_state.set_focus(Focus::Inactive), } } fn change_focus(&mut self, focus: AppComponent) { - libclide::info!(target:Self::ID, "Changing widget focus to {:?}", focus); + libclide::info!("Changing widget focus to {:?}", focus); self.clear_focus(); match focus { AppComponent::Editor => match self.editor_tab.current_editor_mut() { None => { - libclide::error!(target:Self::ID, "Failed to get current Editor while changing focus") + libclide::error!("Failed to get current Editor while changing focus") } Some(editor) => editor.component_state.set_focus(Focus::Active), }, @@ -274,13 +275,15 @@ impl<'a> Component for App<'a> { Action::Quit | Action::Handled => Ok(action), Action::Save => match self.editor_tab.current_editor_mut() { None => { - libclide::error!(target:Self::ID, "Failed to get current editor while handling App Action::Save"); + libclide::error!( + "Failed to get current editor while handling App Action::Save" + ); Ok(Action::Noop) } Some(editor) => match editor.save() { Ok(_) => Ok(Action::Handled), Err(e) => { - libclide::error!(target:Self::ID, "Failed to save editor contents: {e}"); + libclide::error!("Failed to save editor contents: {e}"); Ok(Action::Noop) } }, @@ -299,14 +302,16 @@ impl<'a> Component for App<'a> { Err(_) => Ok(Action::Noop), }, Action::ReloadFile => { - libclide::trace!(target:Self::ID, "Reloading file for current editor"); + libclide::trace!("Reloading file for current editor"); if let Some(editor) = self.editor_tab.current_editor_mut() { editor .reload_contents() .map(|_| Action::Handled) .context("Failed to handle Action::ReloadFile") } else { - libclide::error!(target:Self::ID, "Failed to get current editor while handling App Action::ReloadFile"); + libclide::error!( + "Failed to get current editor while handling App Action::ReloadFile" + ); Ok(Action::Noop) } } diff --git a/src/tui/component.rs b/src/tui/component.rs index 30ffd47..5cd3304 100644 --- a/src/tui/component.rs +++ b/src/tui/component.rs @@ -8,7 +8,7 @@ use crate::tui::component::Focus::Inactive; use Focus::Active; use anyhow::Result; use libclide::theme::colors::Colors; -use libclide_macros::log_id; +use libclide_macros::Loggable; use ratatui::crossterm::event::{Event, KeyEvent, MouseEvent}; use ratatui::style::Color; @@ -62,8 +62,7 @@ pub trait Component { } } -#[derive(Debug, Clone, Default)] -#[log_id] +#[derive(Debug, Clone, Default, Loggable)] pub struct ComponentState { pub(crate) focus: Focus, pub(crate) vis: Visibility, diff --git a/src/tui/editor.rs b/src/tui/editor.rs index 42adcb1..fdd7dc3 100644 --- a/src/tui/editor.rs +++ b/src/tui/editor.rs @@ -7,7 +7,8 @@ use anyhow::{Context, Result, bail}; use edtui::{ EditorEventHandler, EditorState, EditorTheme, EditorView, LineNumbers, Lines, SyntaxHighlighter, }; -use libclide_macros::log_id; +use libclide::log::Loggable; +use libclide_macros::Loggable; use ratatui::buffer::Buffer; use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers}; use ratatui::layout::{Alignment, Rect}; @@ -16,18 +17,18 @@ use ratatui::widgets::{Block, Borders, Padding, Widget}; use std::path::PathBuf; use syntect::parsing::SyntaxSet; -#[log_id] +#[derive(Loggable)] pub struct Editor { pub state: EditorState, pub event_handler: EditorEventHandler, - pub file_path: Option, + pub file_path: Option, syntax_set: SyntaxSet, pub(crate) component_state: ComponentState, } impl Editor { pub fn new(path: &std::path::Path) -> Self { - libclide::trace!(target:Self::ID, "Building {}", Self::ID); + libclide::trace!("Building {}", ::ID); Editor { state: EditorState::default(), event_handler: EditorEventHandler::default(), @@ -41,10 +42,10 @@ impl Editor { } pub fn reload_contents(&mut self) -> Result<()> { - libclide::trace!(target:Self::ID, "Reloading editor file contents {:?}", self.file_path); + libclide::trace!("Reloading editor file contents {:?}", self.file_path); match self.file_path.clone() { None => { - libclide::error!(target:Self::ID, "Failed to reload editor contents with None file_path"); + libclide::error!("Failed to reload editor contents with None file_path"); bail!("Failed to reload editor contents with None file_path") } Some(path) => self.set_contents(&path), @@ -52,7 +53,7 @@ impl Editor { } pub fn set_contents(&mut self, path: &std::path::Path) -> Result<()> { - libclide::trace!(target:Self::ID, "Setting Editor contents from path {:?}", path); + libclide::trace!("Setting Editor contents from path {:?}", path); if let Ok(contents) = std::fs::read_to_string(path) { let lines: Vec<_> = contents .lines() @@ -68,10 +69,10 @@ impl Editor { pub fn save(&self) -> Result<()> { if let Some(path) = &self.file_path { - libclide::trace!(target:Self::ID, "Saving Editor contents {:?}", path); + libclide::trace!("Saving Editor contents {:?}", path); return std::fs::write(path, self.state.lines.to_string()).map_err(|e| e.into()); }; - libclide::error!(target:Self::ID, "Failed saving Editor contents; file_path was None"); + libclide::error!("Failed saving Editor contents; file_path was None"); bail!("File not saved. No file path set.") } } diff --git a/src/tui/editor_tab.rs b/src/tui/editor_tab.rs index ec7da9e..234ed04 100644 --- a/src/tui/editor_tab.rs +++ b/src/tui/editor_tab.rs @@ -5,7 +5,8 @@ use crate::tui::component::{Action, Component, Focus, FocusState}; use crate::tui::editor::Editor; use anyhow::{Context, Result, anyhow}; -use libclide_macros::log_id; +use libclide::log::Loggable; +use libclide_macros::Loggable; use ratatui::buffer::Buffer; use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers}; use ratatui::layout::Rect; @@ -16,7 +17,7 @@ use std::collections::HashMap; // Render the tabs with keys as titles // Tab keys can be file names. // Render the editor using the key as a reference for lookup -#[log_id] +#[derive(Loggable)] pub struct EditorTab { pub(crate) editors: HashMap, tab_order: Vec, @@ -25,7 +26,7 @@ pub struct EditorTab { impl EditorTab { pub fn new() -> Self { - libclide::trace!(target:Self::ID, "Building {}", Self::ID); + libclide::trace!("Building {}", ::ID); Self { editors: HashMap::new(), tab_order: Vec::new(), @@ -35,7 +36,11 @@ impl EditorTab { pub fn next_editor(&mut self) { let next = (self.current_editor + 1) % self.tab_order.len(); - libclide::trace!(target:Self::ID, "Moving from {} to next editor tab at {}", self.current_editor, next); + libclide::trace!( + "Moving from {} to next editor tab at {}", + self.current_editor, + next + ); self.set_tab_focus(Focus::Active, next); self.current_editor = next; } @@ -45,7 +50,11 @@ impl EditorTab { .current_editor .checked_sub(1) .unwrap_or(self.tab_order.len() - 1); - libclide::trace!(target:Self::ID, "Moving from {} to previous editor tab at {}", self.current_editor, prev); + libclide::trace!( + "Moving from {} to previous editor tab at {}", + self.current_editor, + prev + ); self.set_tab_focus(Focus::Active, prev); self.current_editor = prev; } @@ -54,7 +63,7 @@ impl EditorTab { match self.tab_order.get(index) { None => { if !self.tab_order.is_empty() { - libclide::error!(target:Self::ID, "Failed to get editor tab key with invalid index {index}"); + libclide::error!("Failed to get editor tab key with invalid index {index}"); } None } @@ -72,16 +81,19 @@ impl EditorTab { } pub fn set_current_tab_focus(&mut self, focus: Focus) { - libclide::trace!(target:Self::ID, "Setting current tab {} focus to {:?}", self.current_editor, focus); + libclide::trace!( + "Setting current tab {} focus to {:?}", + self.current_editor, + focus + ); self.set_tab_focus(focus, self.current_editor) } pub fn set_tab_focus(&mut self, focus: Focus, index: usize) { - libclide::trace!(target:Self::ID, "Setting tab {} focus to {:?}", index, focus); + libclide::trace!("Setting tab {} focus to {:?}", index, focus); if focus == Focus::Active && index != self.current_editor { // If we are setting another tab to active, disable the current one. libclide::trace!( - target:Self::ID, "New tab {} focus set to Active; Setting current tab {} to Inactive", index, self.current_editor @@ -90,12 +102,11 @@ impl EditorTab { } match self.get_editor_key(index) { None => { - libclide::error!(target:Self::ID, "Failed setting tab focus for invalid key {index}"); + libclide::error!("Failed setting tab focus for invalid key {index}"); } Some(key) => match self.editors.get_mut(&key) { None => { libclide::error!( - target:Self::ID, "Failed to update tab focus at index {} with invalid key: {}", self.current_editor, self.tab_order[self.current_editor] @@ -107,12 +118,12 @@ impl EditorTab { } pub fn open_tab(&mut self, path: &std::path::Path) -> Result<()> { - libclide::trace!(target:Self::ID, "Opening new EditorTab with path {:?}", path); + libclide::trace!("Opening new EditorTab with path {:?}", path); if self .editors .contains_key(&path.to_string_lossy().to_string()) { - libclide::warn!(target:Self::ID, "EditorTab already opened with this file"); + libclide::warn!("EditorTab already opened with this file"); return Ok(()); } @@ -137,12 +148,12 @@ impl EditorTab { .to_owned(); match self.editors.remove(&key) { None => { - libclide::error!(target:Self::ID, "Failed to remove editor tab {key} with invalid index {index}") + libclide::error!("Failed to remove editor tab {key} with invalid index {index}") } Some(_) => { self.prev_editor(); self.tab_order.remove(index); - libclide::info!(target:Self::ID, "Closed editor tab {key} at index {index}") + libclide::info!("Closed editor tab {key} at index {index}") } } Ok(()) diff --git a/src/tui/explorer.rs b/src/tui/explorer.rs index 672ca4b..4a63a50 100644 --- a/src/tui/explorer.rs +++ b/src/tui/explorer.rs @@ -5,7 +5,8 @@ use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState}; use anyhow::{Context, Result, bail}; use libclide::fs::entry_meta::EntryMeta; -use libclide_macros::log_id; +use libclide::log::Loggable; +use libclide_macros::Loggable; use ratatui::buffer::Buffer; use ratatui::crossterm::event::{Event, KeyCode, KeyEvent, MouseEvent, MouseEventKind}; use ratatui::layout::{Alignment, Position, Rect}; @@ -16,8 +17,7 @@ use std::fs; use std::path::{Path, PathBuf}; use tui_tree_widget::{Tree, TreeItem, TreeState}; -#[derive(Debug)] -#[log_id] +#[derive(Debug, Loggable)] pub struct Explorer<'a> { root_path: EntryMeta, tree_items: TreeItem<'a, String>, @@ -27,7 +27,7 @@ pub struct Explorer<'a> { impl<'a> Explorer<'a> { pub fn new(path: &PathBuf) -> Result { - libclide::trace!("Building {}", Self::ID); + libclide::trace!("Building {}", ::ID); let explorer = Explorer { root_path: EntryMeta::new(path)?, tree_items: Self::build_tree_from_path(path)?, @@ -69,7 +69,7 @@ impl<'a> Explorer<'a> { } } - // Note: The first argument is a unique identifier, where no 2 TreeItems may share the same. + // Note: The first argument is a unique identifier, where no. 2 TreeItems may share the same. // For a file tree this is fine because we shouldn't list the same object twice. TreeItem::new( path_meta.abs_path.clone(), diff --git a/src/tui/logger.rs b/src/tui/logger.rs index 122d5fc..a5f7680 100644 --- a/src/tui/logger.rs +++ b/src/tui/logger.rs @@ -3,7 +3,8 @@ // SPDX-License-Identifier: GNU General Public License v3.0 or later use crate::tui::component::{Action, Component, ComponentState, Focus, FocusState}; -use libclide_macros::log_id; +use libclide::log::Loggable; +use libclide_macros::Loggable; use log::LevelFilter; use ratatui::buffer::Buffer; use ratatui::crossterm::event::{Event, KeyCode, KeyEvent}; @@ -14,7 +15,7 @@ use tui_logger::{TuiLoggerLevelOutput, TuiLoggerSmartWidget, TuiWidgetEvent, Tui /// Any log written as info!(target:self.id(), "message") will work with this logger. /// The logger is bound to info!, debug!, error!, trace! macros within Tui::new(). -#[log_id] +#[derive(Loggable)] pub struct Logger { state: TuiWidgetState, pub(crate) component_state: ComponentState, @@ -22,7 +23,7 @@ pub struct Logger { impl Logger { pub fn new() -> Self { - libclide::trace!(target:Self::ID, "Building {}", Self::ID); + libclide::trace!("Building {}", ::ID); let state = TuiWidgetState::new(); state.transition(TuiWidgetEvent::HideKey); Self { diff --git a/src/tui/menu_bar.rs b/src/tui/menu_bar.rs index a197188..c71651e 100644 --- a/src/tui/menu_bar.rs +++ b/src/tui/menu_bar.rs @@ -7,7 +7,7 @@ use crate::tui::menu_bar::MenuBarItemOption::{ About, CloseTab, Exit, Reload, Save, ShowHideExplorer, ShowHideLogger, }; use anyhow::Context; -use libclide_macros::log_id; +use libclide_macros::Loggable; use ratatui::buffer::Buffer; use ratatui::crossterm::event::{KeyCode, KeyEvent}; use ratatui::layout::Rect; @@ -80,7 +80,7 @@ impl MenuBarItem { } } -#[log_id] +#[derive(Debug, Loggable)] pub struct MenuBar { selected: MenuBarItem, opened: Option, @@ -91,7 +91,7 @@ pub struct MenuBar { impl MenuBar { const DEFAULT_HELP: &str = "(←/h)/(→/l): Select option | Enter: Choose selection"; pub fn new() -> Self { - libclide::trace!("Building {}", Self::ID); + libclide::trace!("Building"); Self { selected: MenuBarItem::File, opened: None,