From 5b356781badd61f2d76653a9ef00b287143af4be Mon Sep 17 00:00:00 2001 From: Shaun Reed Date: Sun, 22 Feb 2026 10:25:00 -0500 Subject: [PATCH] Fix comments. --- libclide-macros/src/lib.rs | 4 ++++ libclide/src/log/macros.rs | 43 +++++++++++++++++++++++++------------- src/main.rs | 5 ++--- 3 files changed, 34 insertions(+), 18 deletions(-) diff --git a/libclide-macros/src/lib.rs b/libclide-macros/src/lib.rs index 9f69c0b..03d4fda 100644 --- a/libclide-macros/src/lib.rs +++ b/libclide-macros/src/lib.rs @@ -1,3 +1,7 @@ +// SPDX-FileCopyrightText: 2026, Shaun Reed +// +// SPDX-License-Identifier: GNU General Public License v3.0 or later + use proc_macro::TokenStream; use quote::quote; use syn::{ItemStruct, parse_macro_input}; diff --git a/libclide/src/log/macros.rs b/libclide/src/log/macros.rs index 50baf84..ab2827e 100644 --- a/libclide/src/log/macros.rs +++ b/libclide/src/log/macros.rs @@ -1,13 +1,40 @@ +// SPDX-FileCopyrightText: 2026, Shaun Reed +// +// SPDX-License-Identifier: GNU General Public License v3.0 or later + //! Logging targets allow filtering of log messages by their source. By default, the log crate sets //! the target to the module path where the log macro was invoked if no target is provided. //! //! These macros essentially disable using the default target and instead require the target to be //! 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"); +//! ``` +//! +//! 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] +//! struct MyStruct; +//! impl MyStruct { +//! fn my_method(&self) { +//! libclide::log!("This log message will use target Self::ID, which is 'MyStruct'"); +//! } +//! } +//! ``` +//! #[macro_export] macro_rules! info { - // The target argument can be overridden using one of the following macros. (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ log::info!(logger: $logger, target: $target, $($arg)+) }); @@ -16,8 +43,6 @@ macro_rules! info { log::info!(target: $target, $($arg)+) }); - // The target argument will default to Self::ID if not provided. - // Obviously, this is an error if Self::ID is not defined, forcing you to use the explicit form. (logger: $logger:expr, $($arg:tt)+) => ({ log::info!(logger: $logger, target: Self::ID, $($arg)+) }); @@ -27,7 +52,6 @@ macro_rules! info { #[macro_export] macro_rules! debug { - // The target argument can be overridden using one of the following macros. (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ log::debug!(logger: $logger, target: $target, $($arg)+) }); @@ -36,8 +60,6 @@ macro_rules! debug { log::debug!(target: $target, $($arg)+) }); - // The target argument will default to Self::ID if not provided. - // Obviously, this is an error if Self::ID is not defined, forcing you to use the explicit form. (logger: $logger:expr, $($arg:tt)+) => ({ log::debug!(logger: $logger, target: Self::ID, $($arg)+) }); @@ -47,7 +69,6 @@ macro_rules! debug { #[macro_export] macro_rules! warn { - // The target argument can be overridden using one of the following macros. (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ log::warn!(logger: $logger, target: $target, $($arg)+) }); @@ -56,8 +77,6 @@ macro_rules! warn { log::warn!(target: $target, $($arg)+) }); - // The target argument will default to Self::ID if not provided. - // Obviously, this is an error if Self::ID is not defined, forcing you to use the explicit form. (logger: $logger:expr, $($arg:tt)+) => ({ log::warn!(logger: $logger, target: Self::ID, $($arg)+) }); @@ -67,7 +86,6 @@ macro_rules! warn { #[macro_export] macro_rules! error { - // The target argument can be overridden using one of the following macros. (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ log::error!(logger: $logger, target: $target, $($arg)+) }); @@ -76,8 +94,6 @@ macro_rules! error { log::error!(target: $target, $($arg)+) }); - // The target argument will default to Self::ID if not provided. - // Obviously, this is an error if Self::ID is not defined, forcing you to use the explicit form. (logger: $logger:expr, $($arg:tt)+) => ({ log::error!(logger: $logger, target: Self::ID, $($arg)+) }); @@ -87,7 +103,6 @@ macro_rules! error { #[macro_export] macro_rules! trace { - // The target argument can be overridden using one of the following macros. (logger: $logger:expr, target: $target:expr, $($arg:tt)+) => ({ log::trace!(logger: $logger, target: $target, $($arg)+) }); @@ -96,8 +111,6 @@ macro_rules! trace { log::trace!(target: $target, $($arg)+) }); - // The target argument will default to Self::ID if not provided. - // Obviously, this is an error if Self::ID is not defined, forcing you to use the explicit form. (logger: $logger:expr, $($arg:tt)+) => ({ log::trace!(logger: $logger, target: Self::ID, $($arg)+) }); diff --git a/src/main.rs b/src/main.rs index 80ef06c..e8c3851 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,7 +4,6 @@ use anyhow::{Context, Result, anyhow}; use clap::Parser; -use log::{info, trace}; use std::process::{Command, Stdio}; pub mod gui; @@ -56,7 +55,7 @@ impl AppContext { // If no path was provided, use the current directory. None => std::env::current_dir().context("Failed to obtain current directory")?, }; - info!(target:"main()", "Root path detected: {path:?}"); + libclide::info!(target:"main()", "Root path detected: {path:?}"); Ok(Self { path, @@ -80,7 +79,7 @@ fn main() -> Result<()> { RunMode::GuiAttached => gui::run(app_context), RunMode::Tui => tui::run(app_context), RunMode::Gui => { - trace!(target:"main()", "Starting GUI in a new process"); + libclide::trace!(target:"main()", "Starting GUI in a new process"); Command::new(std::env::current_exe()?) .args(["--gui", app_context.path.to_str().unwrap()]) .stdout(Stdio::null())