shaunrd0/clide
1
0
Fork 0
Code Issues 12 Pull Requests 1 Packages Projects Releases Wiki Activity

Loggable trait and derive macro.

Browse Source
This commit is contained in:
Shaun Reed
2026-02-22 19:37:09 -05:00
parent b0ed2e6e1f
commit fed1d43ac9
14 changed files with 99 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@@ -1171,6 +1171,7 @@ version = "0.1.0"
dependencies = [
"anyhow",
"devicons",
"libclide-macros",
"log",
"strum",
]

11
libclide-macros/src/lib.rs
View File

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

1
libclide/Cargo.toml
View File

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

4
libclide/src/log.rs
View File

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

74
libclide/src/log/macros.rs
View File

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

7
src/tui.rs
View File

@@ -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");

4
src/tui/about.rs
View File

@@ -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 {

33
src/tui/app.rs
View File

@@ -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)
}
}

5
src/tui/component.rs
View File

@@ -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,

19
src/tui/editor.rs
View File

@@ -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<std::path::PathBuf>,
pub file_path: Option<PathBuf>,
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 {}", <Self as Loggable>::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.")
}
}

41
src/tui/editor_tab.rs
View File

@@ -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<String, Editor>,
tab_order: Vec<String>,
@@ -25,7 +26,7 @@ pub struct EditorTab {
impl EditorTab {
pub fn new() -> Self {
libclide::trace!(target:Self::ID, "Building {}", Self::ID);
libclide::trace!("Building {}", <Self as Loggable>::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(())

10
src/tui/explorer.rs
View File

@@ -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<Self> {
libclide::trace!("Building {}", Self::ID);
libclide::trace!("Building {}", <Self as Loggable>::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(),

7
src/tui/logger.rs
View File

@@ -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 {}", <Self as Loggable>::ID);
let state = TuiWidgetState::new();
state.transition(TuiWidgetEvent::HideKey);
Self {

6
src/tui/menu_bar.rs
View File

@@ -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<MenuBarItem>,
@@ -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,