Add macros for logging.

Author: shaunrd0

.github/workflows/check.yaml

@@ -26,6 +26,9 @@ jobs:
       - name: Build libclide
         run: |
           cargo b -p libclide --release
+      - name: Build libclide-macros
+        run: |
+          cargo b -p libclide-macros --release
       - name: Build clide
         run: |
           cargo b --release
@@ -44,6 +47,9 @@ jobs:
       - name: Test libclide
         run: |
           cargo test -p libclide
+      - name: Test libclide-macros
+        run: |
+          cargo test -p libclide-macros
       - name: Test clide
         run: |
           cargo test
@@ -62,6 +68,9 @@ jobs:
       - name: Lint libclide
         run: |
           cargo clippy -p libclide -- -D warnings
+      - name: Lint libclide-macros
+        run: |
+          cargo clippy -p libclide-macros -- -D warnings
       - name: Lint clide
         run: |
           cargo clippy -- -D warnings
@@ -80,6 +89,9 @@ jobs:
       - name: Format libclide
         run: |
           cargo fmt -p libclide --verbose -- --check
+      - name: Format libclide-macros
+        run: |
+          cargo fmt -p libclide-macros -- --check
       - name: Format clide
         run: |
           cargo fmt --verbose -- --check

Cargo.lock

@@ -5,20 +5,17 @@ edition = "2024"
 
 [workspace]
 resolver = "3"
-members = [
-    ".",
-    "libclide",
-]
+members = [".", "libclide", "libclide-macros", ]
 
 [workspace.dependencies]
 anyhow = "1.0.100"
 strum = "0.27.2"
+log = { version = "0.4.27", features = [] }
 
 [dependencies]
 cxx = "1.0.95"
 cxx-qt = "0.8.0"
 cxx-qt-lib = { version = "0.8.0", features = ["qt_full", "qt_gui", "qt_qml"] }
-log = { version = "0.4.27", features = [] }
 dirs = "6.0.0"
 syntect = "5.2.0"
 clap = { version = "4.5.54", features = ["derive"] }
@@ -28,9 +25,11 @@ tui-logger = "0.18.1"
 edtui = "0.11.1"
 devicons = "0.6.12"
 libclide = { path = "./libclide" }
+libclide-macros = { path = "./libclide-macros" }
 anyhow = { workspace = true }
 strum = { workspace = true }
+log = { workspace = true }
 
 [build-dependencies]
 # The link_qt_object_files feature is required for statically linking Qt 6.
-cxx-qt-build = { version = "0.8.0", features = ["link_qt_object_files"] }
+cxx-qt-build = { version = "0.8.0", features = ["link_qt_object_files"] }

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "libclide-macros"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2", features = ["full"] }
+quote = "1"
+proc-macro2 = "1"

libclide-macros/Cargo.toml

@@ -0,0 +1,27 @@
+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 {
+    let input = parse_macro_input!(item as ItemStruct);
+
+    let struct_name = &input.ident;
+    let generics = &input.generics;
+
+    // This is the important part
+    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;
+        }
+    };
+
+    TokenStream::from(expanded)
+}

libclide-macros/src/lib.rs

@@ -6,3 +6,4 @@ edition = "2024"
 [dependencies]
 anyhow = { workspace = true }
 strum = { workspace = true }
+log = { workspace = true }

libclide/Cargo.toml

@@ -3,4 +3,5 @@
 // SPDX-License-Identifier: GNU General Public License v3.0 or later
 
 pub mod fs;
+pub mod log;
 pub mod theme;

libclide/src/lib.rs

@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: 2026, Shaun Reed <shaunrd0@gmail.com>
+//
+// SPDX-License-Identifier: GNU General Public License v3.0 or later
+
+pub mod macros;

libclide/src/log.rs

@@ -0,0 +1,106 @@
+//! 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.
+
+#[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)+)
+    });
+
+    (target: $target:expr, $($arg:tt)+) => ({
+        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)+)
+    });
+
+    ($($arg:tt)+) => (log::info!(target: Self::ID, $($arg)+))
+}
+
+#[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)+)
+    });
+
+    (target: $target:expr, $($arg:tt)+) => ({
+        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)+)
+    });
+
+    ($($arg:tt)+) => (log::debug!(target: Self::ID, $($arg)+))
+}
+
+#[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)+)
+    });
+
+    (target: $target:expr, $($arg:tt)+) => ({
+        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)+)
+    });
+
+    ($($arg:tt)+) => (log::warn!(target: Self::ID, $($arg)+))
+}
+
+#[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)+)
+    });
+
+    (target: $target:expr, $($arg:tt)+) => ({
+        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)+)
+    });
+
+    ($($arg:tt)+) => (log::error!(target: Self::ID, $($arg)+))
+}
+
+#[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)+)
+    });
+
+    (target: $target:expr, $($arg:tt)+) => ({
+        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)+)
+    });
+
+    ($($arg:tt)+) => (log::trace!(target: Self::ID, $($arg)+))
+}

libclide/src/log/macros.rs

@@ -41,7 +41,7 @@ impl Colors {
         let hex_full = match hex.len() {
             3 => hex
                 .chars()
-                .map(|c| std::iter::repeat(c).take(2).collect::<String>())
+                .map(|c| std::iter::repeat_n(c, 2).collect::<String>())
                 .collect::<String>(),
             6 => hex.to_string(),
             _ => panic!("Invalid hex color length: {hex:?}"),