Loggable trait and derive macro.

Author: shaunrd0

Cargo.lock

@@ -6,20 +6,17 @@ 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;
 
     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;
         }
     };
 

libclide-macros/src/lib.rs

@@ -8,3 +8,4 @@ anyhow = { workspace = true }
 strum = { workspace = true }
 log = { workspace = true }
 devicons = { workspace = true }
+libclide-macros = { path = "../libclide-macros" }

libclide/Cargo.toml

@@ -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;
+}

libclide/src/log.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 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");
+//! The Loggable trait can be implemented to automatically associate log messages with a struct.
 //! ```
+//! use libclide_macros::Loggable;
 //!
-//! 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 <Self as Loggable>::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: <Self as libclide::log::Loggable>::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: <Self as libclide::log::Loggable>::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: <Self as libclide::log::Loggable>::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: <Self as libclide::log::Loggable>::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: <Self as libclide::log::Loggable>::ID, $($arg)+))
 }

libclide/src/log/macros.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<CrosstermBackend<Stdout>>,
     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<Self> {
-        libclide::trace!("Building {}", Self::ID);
         init_logger(LevelFilter::Trace)?;
         set_default_level(LevelFilter::Trace);
         libclide::debug!("Logging initialized");

src/tui.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 {

src/tui/about.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<Self> {
-        libclide::trace!(target:Self::ID, "Building {}", Self::ID);
+        libclide::trace!("Building {}", <Self as Loggable>::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)
                 }
             }

src/tui/app.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,