Enhance code quality across the entire codebase

17 files changed, 53 insertions, 27 deletions

diff --git a/examples/example-argument-parse/src/main.rs b/examples/example-argument-parse/src/main.rs
index f63fdad..316e52f 100644
--- a/examples/example-argument-parse/src/main.rs
+++ b/examples/example-argument-parse/src/main.rs
@@ -39,7 +39,7 @@ fn handle_transfer_parse(args: EntryTransfer) -> Next {
         // Name
         // ^^^^_ finally, pick positional arg
         .pick::<String>(())
-        .after(|str| str.trim().replace(" ", ""))
+        .after(|str| str.trim().replace(' ', ""))
         // Unpack to tuple (is_dir, size, name)
         .unpack()
         // Convert into ResultFile
@@ -60,7 +60,7 @@ fn handle_strict_transfer_parse(args: EntryStrictTransfer) -> Next {
             .pick_or::<usize>("--size", 1024 * 1024_usize)
             // Finally parse the positional argument; if not found, route to `ErrorNoNameProvided`
             .pick_or_route::<String, _>((), ErrorNoNameProvided::default().to_chain())
-            .after(|str| str.trim().replace(" ", ""))
+            .after(|str| str.trim().replace(' ', ""))
             .unpack()
     }
     // Convert into ResultFile
@@ -69,6 +69,7 @@ fn handle_strict_transfer_parse(args: EntryStrictTransfer) -> Next {
     result.to_chain()
 }
 
+/// Renders the parsed transfer result (file/dir, size, name).
 #[renderer]
 fn render_result_file(result: ResultFile) {
     let (is_dir, size, name) = result.into();
@@ -80,6 +81,7 @@ fn render_result_file(result: ResultFile) {
     )
 }
 
+/// Renders the error when no name is provided.
 #[renderer]
 fn render_error_no_name_provided(_: ErrorNoNameProvided) {
     r_println!("Error: name is not provided")
diff --git a/examples/example-async-support/src/main.rs b/examples/example-async-support/src/main.rs
index 12b1b9c..5ded5e5 100644
--- a/examples/example-async-support/src/main.rs
+++ b/examples/example-async-support/src/main.rs
@@ -53,6 +53,7 @@ pub async fn handle_download(args: EntryDownload) -> Next {
     fake_download(file_name).await
 }
 
+/// Renders the downloaded file name.
 #[renderer]
 // But renderers cannot use the `async` keyword
 pub fn render_downloaded(result: ResultDownloaded) {
diff --git a/examples/example-basic/src/main.rs b/examples/example-basic/src/main.rs
index d741c3b..3d94a4b 100644
--- a/examples/example-basic/src/main.rs
+++ b/examples/example-basic/src/main.rs
@@ -58,6 +58,7 @@ fn handle_greet(args: EntryGreet) -> Next {
 }
 
 // Define renderer `render_name`, used to render `ResultName`
+/// Renders the greeting message with the provided name.
 #[renderer]
 fn render_name(name: ResultName) {
     r_println!("Hello, {}!", *name);
diff --git a/examples/example-clap-binding/src/main.rs b/examples/example-clap-binding/src/main.rs
index d3ad573..19d794b 100644
--- a/examples/example-clap-binding/src/main.rs
+++ b/examples/example-clap-binding/src/main.rs
@@ -87,6 +87,7 @@ pub struct EntryGreet {
     repeat: i32,
 }
 
+/// Renders the greet output with optional repetition.
 #[renderer]
 fn render_greet(greet: EntryGreet) {
     let name = greet.name;
@@ -102,9 +103,10 @@ fn render_greet(greet: EntryGreet) {
     r_println!("!");
 }
 
+/// Renders the error message when greet argument parsing fails.
 #[renderer]
 fn render_greet_parse_failed(err: ErrorGreetParsed) {
-    r_println!("{}", err.to_string());
+    r_println!("{}", *err);
 }
 
 gen_program!();
diff --git a/examples/example-completion/src/main.rs b/examples/example-completion/src/main.rs
index a34ccab..0c64d03 100644
--- a/examples/example-completion/src/main.rs
+++ b/examples/example-completion/src/main.rs
@@ -116,6 +116,7 @@ fn handle_greet(args: EntryGreet) -> Next {
     result
 }
 
+/// Renders the greeting with the result name and repeat count.
 #[renderer]
 fn render_name(result: ResultName) {
     let (repeat, name) = result.inner;
diff --git a/examples/example-custom-pickable/src/main.rs b/examples/example-custom-pickable/src/main.rs
index 466ae43..a2aa662 100644
--- a/examples/example-custom-pickable/src/main.rs
+++ b/examples/example-custom-pickable/src/main.rs
@@ -14,7 +14,7 @@
 //! Failed to parse address
 //! ```
 
-use mingling::{Groupped, macros::route, parser::Pickable, prelude::*};
+use mingling::{macros::route, parser::Pickable, prelude::*, Groupped};
 
 // Define types that can be recognized by Mingling
 //               ________________________ `Pickable` trait needs to implement Default
@@ -32,7 +32,7 @@ impl Pickable for Address {
     type Output = Address;
     fn pick(args: &mut mingling::parser::Argument, flag: mingling::Flag) -> Option<Self::Output> {
         // Extract the raw string from Argument using the Flag
-        let raw: String = args.pick_argument(flag)?.to_string();
+        let raw: String = args.pick_argument(flag)?.clone();
 
         // Use TryFrom to parse the address
         Address::try_from(raw).ok()
@@ -50,11 +50,13 @@ fn handle_connect(prev: EntryConnect) -> Next {
     connect.to_chain()
 }
 
+/// Renders the connected address.
 #[renderer]
 fn render_address(addr: Address) {
     r_println!("Connected to \"{}\"", addr.to_string());
 }
 
+/// Renders the error message when address parsing fails.
 #[renderer]
 fn render_error_parse_address_failed(_: ErrorParseAddressFailed) {
     r_println!("Failed to parse address");
@@ -93,13 +95,13 @@ impl TryFrom<String> for Address {
         for (i, part) in ip_parts.iter().enumerate() {
             ip[i] = part
                 .parse::<u8>()
-                .map_err(|_| format!("Invalid IP octet: {}", part))?;
+                .map_err(|_| format!("Invalid IP octet: {part}"))?;
         }
 
         // Parse port
         let port = port_str
             .parse::<u16>()
-            .map_err(|_| format!("Invalid port: {}", port_str))?;
+            .map_err(|_| format!("Invalid port: {port_str}"))?;
 
         Ok(Address { ip, port })
     }
diff --git a/examples/example-dispatch-tree/src/main.rs b/examples/example-dispatch-tree/src/main.rs
index 08714d1..e087b1e 100644
--- a/examples/example-dispatch-tree/src/main.rs
+++ b/examples/example-dispatch-tree/src/main.rs
@@ -48,9 +48,10 @@ fn main() {
     // // it'll be collected automatically once the `dispatch_tree` feature is enabled
     // program.with_dispatcher(...);
 
-    program.exec_and_exit()
+    program.exec_and_exit();
 }
 
+/// Renders the confirmation message for the `cmd5` command.
 #[renderer]
 fn render_cmd5(_: Entry5) {
     r_println!("It's works!");
diff --git a/examples/example-enum-tag/src/main.rs b/examples/example-enum-tag/src/main.rs
index 30439f5..ad9db82 100644
--- a/examples/example-enum-tag/src/main.rs
+++ b/examples/example-enum-tag/src/main.rs
@@ -81,6 +81,7 @@ fn handle_language_selection(args: EntryLanguageSelection) -> Next {
     lang
 }
 
+/// Renders the selected programming language with its name and description.
 #[renderer]
 fn render_programming_language(lang: ProgrammingLanguages) {
     // You can use `enum_info()` to get the name and description of the current enum
diff --git a/examples/example-error-handling/src/main.rs b/examples/example-error-handling/src/main.rs
index d4d073e..ae79b97 100644
--- a/examples/example-error-handling/src/main.rs
+++ b/examples/example-error-handling/src/main.rs
@@ -59,29 +59,34 @@ fn handle_hello(args: EntryHello) -> Next {
     ResultName::new(name).to_render()
 }
 
+/// Renders a successful greeting with the given name.
 #[renderer]
 fn render_result_name(name: ResultName) {
     r_println!("Hello, {}", *name);
 }
 
+/// Renders the error when no name is provided.
 #[renderer]
 fn render_error_no_name_provided(_: ErrorNoNameProvided) {
     // Prompt when no name is provided
     r_println!("No name provided");
 }
 
+/// Renders the error when the name is already taken.
 #[renderer]
 fn render_error_name_not_available(_: ErrorNameNotAvailable) {
     // Prompt when name is already taken
     r_println!("Name not available");
 }
 
+/// Renders the error when the name exceeds the maximum length.
 #[renderer]
 fn render_error_name_too_long(len: ErrorNameTooLong) {
     // Prompt when name is too long, showing actual length
     r_println!("Name too long: {} > 10", *len);
 }
 
+/// Renders the error when the dispatcher (subcommand) is not found.
 #[renderer]
 fn render_dispatcher_not_found(err: ErrorDispatcherNotFound) {
     // Prompt when command is not found, showing the input command
diff --git a/examples/example-exitcode/src/main.rs b/examples/example-exitcode/src/main.rs
index 178fa78..e1f60ee 100644
--- a/examples/example-exitcode/src/main.rs
+++ b/examples/example-exitcode/src/main.rs
@@ -44,6 +44,7 @@ fn handle_hello(args: EntryHello) -> Next {
     ResultName::new(name).to_render()
 }
 
+/// Renders a successful greeting with the given name.
 #[renderer]
 fn render_result_name(name: ResultName) {
     r_println!("Hello, {}", *name);
@@ -51,6 +52,7 @@ fn render_result_name(name: ResultName) {
 
 // Define renderer, render error message                      _____________ Inject exit code resource
 //                                                           /
+/// Renders the error when no name is provided               |
 #[renderer] //                                               vvvvvvvvvvvvv
 fn render_error_no_name_provided(_: ErrorNoNameProvided, ec: &mut ExitCode) {
     ec.exit_code = 1;
diff --git a/examples/example-general-renderer/src/main.rs b/examples/example-general-renderer/src/main.rs
index 3ba4433..c923d28 100644
--- a/examples/example-general-renderer/src/main.rs
+++ b/examples/example-general-renderer/src/main.rs
@@ -18,7 +18,7 @@
 //! ```
 
 use mingling::prelude::*;
-use mingling::{Groupped, parser::Picker, setup::GeneralRendererSetup};
+use mingling::{parser::Picker, setup::GeneralRendererSetup, Groupped};
 use serde::Serialize;
 
 dispatcher!("render", CMDRender => EntryRender);
@@ -28,7 +28,7 @@ fn main() {
     // Add `GeneralRendererSetup` to receive user input `--json` `--yaml` parameters
     program.with_setup(GeneralRendererSetup);
     program.with_dispatcher(CMDRender);
-    program.exec();
+    let _ = program.exec();
 }
 
 // --------- IMPORTANT ---------
@@ -61,7 +61,7 @@ fn parse_render(prev: EntryRender) -> Next {
     Info { name, age }.to_render()
 }
 
-// Implement default renderer for when general_renderer is not specified
+/// Implement default renderer for when general_renderer is not specified
 #[renderer]
 fn render_info(prev: Info) {
     r_println!("{} is {} years old", prev.name, prev.age);
diff --git a/examples/example-hook/src/main.rs b/examples/example-hook/src/main.rs
index 373c76d..d6a2dd0 100644
--- a/examples/example-hook/src/main.rs
+++ b/examples/example-hook/src/main.rs
@@ -31,17 +31,17 @@ fn main() {
     program.with_hook(
         ProgramHook::<ThisProgram>::empty()
             .on_begin(|| println!("[DEBUG] Program is begin"))
-            .on_pre_dispatch(|args| println!("[DEBUG] Pre dispatch: {:?}", args))
-            .on_post_dispatch(|c: &_| println!("[DEBUG] Post dispatch: {:?}", c))
+            .on_pre_dispatch(|args| println!("[DEBUG] Pre dispatch: {args:?}"))
+            .on_post_dispatch(|c: &_| println!("[DEBUG] Post dispatch: {c:?}"))
             .on_pre_chain(|c: &_, _| {
-                println!("[DEBUG] Pre chain: {}", c);
+                println!("[DEBUG] Pre chain: {c}");
             })
             .on_post_chain(|any_output| println!("[DEBUG] Post chain: {}", any_output.member_id))
             .on_finish(|| {
                 println!("[DEBUG] Loop end");
                 0 // Override exit code
             })
-            .on_pre_render(|c: &_, _| println!("[DEBUG] Pre render: {}", c))
+            .on_pre_render(|c: &_, _| println!("[DEBUG] Pre render: {c}"))
             .on_post_render(|_| println!("[DEBUG] Post render")),
     );
     // --------- IMPORTANT ---------
@@ -63,6 +63,7 @@ fn handle_greet(args: EntryGreet) -> Next {
     name
 }
 
+/// Renders the greeting message with the provided name.
 #[renderer]
 fn render_name(name: ResultName) {
     r_println!("Hello, {}!", *name);
diff --git a/examples/example-panic-unwind/src/main.rs b/examples/example-panic-unwind/src/main.rs
index 18cf4d6..bb25541 100644
--- a/examples/example-panic-unwind/src/main.rs
+++ b/examples/example-panic-unwind/src/main.rs
@@ -29,11 +29,10 @@ fn main() {
     program.stdout_setting.silence_panic = true;
 
     // Define a hook to output &ProgramPanic when a Panic occurs
-    program
-        .with_hook(ProgramHook::empty().on_exec_panic(|info| println!("Program panic: {}", info)));
+    program.with_hook(ProgramHook::empty().on_exec_panic(|info| println!("Program panic: {info}")));
     // --------- IMPORTANT ---------
 
-    program.exec();
+    let _ = program.exec();
 }
 
 #[chain]
@@ -48,6 +47,7 @@ fn handle_panic(prev: EntryPanic) -> Next {
     }
 }
 
+/// Renders the message when no panic occurs.
 #[renderer]
 fn render(_: NotPanic) {
     r_println!("Program not panic");
diff --git a/examples/example-repl-basic/src/main.rs b/examples/example-repl-basic/src/main.rs
index 630c419..d44c92a 100644
--- a/examples/example-repl-basic/src/main.rs
+++ b/examples/example-repl-basic/src/main.rs
@@ -66,7 +66,7 @@ fn main() {
     // Add hooks to handle REPL-related events
     program.with_hook(ProgramHook::empty().on_repl_begin(|| {
         // Print welcome message
-        println!("Welcome!")
+        println!("Welcome!");
     }));
 
     // Start the REPL loop
@@ -118,11 +118,11 @@ fn handle_ls(_prev: EntryLs, current_dir: &ResCurrentDir) -> Next {
     let dir = &current_dir.dir;
     let entries: Vec<String> = std::fs::read_dir(dir)
         .into_iter()
-        .flat_map(|rd| rd.filter_map(|e| e.ok()))
+        .flat_map(|rd| rd.filter_map(std::result::Result::ok))
         .map(|e| {
             let name = e.file_name().to_string_lossy().to_string();
             if e.file_type().map(|t| t.is_dir()).unwrap_or(false) {
-                format!("{}/", name)
+                format!("{name}/")
             } else {
                 name
             }
@@ -133,11 +133,11 @@ fn handle_ls(_prev: EntryLs, current_dir: &ResCurrentDir) -> Next {
     ResultList::new(entries).to_render()
 }
 
-// Render ResultList data
+/// Render ResultList data
 #[renderer]
 fn render_list(list: ResultList) {
     for item in list.inner {
-        r_println!("{}", item)
+        r_println!("{}", item);
     }
 }
 
@@ -151,20 +151,21 @@ fn handle_exit(
     repl.exit = true;
 }
 
-// Handle clear command event
+/// Handle clear command event
 #[chain]
 fn handle_clear(_prev: EntryClear) {
     // Clear the terminal screen
     print!("\x1B[2J\x1B[1;1H");
 }
 
-// Handle path not found event
+/// Handle path not found event
 #[renderer]
 fn render_error_directory_not_exist(err: ErrorDirectoryNotExist) {
     r_println!("Directory not found: {}", err.inner.display())
 }
 
-// Handle dispatcher not found event
+/// Handle dispatcher not found event
+/// Renders the error when a command is not found.
 #[renderer]
 fn dispatcher_not_found(prev: ErrorDispatcherNotFound) {
     r_println!("Command not found: \"{}\"", prev.join(", "))
diff --git a/examples/example-resources/src/main.rs b/examples/example-resources/src/main.rs
index ae2c8f2..6c5bf84 100644
--- a/examples/example-resources/src/main.rs
+++ b/examples/example-resources/src/main.rs
@@ -56,6 +56,7 @@ fn render_modify_current(args: EntryModifyCurrent, current_dir: &mut ResCurrentD
 
 // Define renderer for output current path       _____________ Injected resource
 //                                              /
+/// Renders the current directory path.         |
 #[renderer] //                                  vvvvvvvvvvvvvv
 fn render_current(_: EntryCurrent, current_dir: &ResCurrentDir) {
     r_println!("Current directory: {}", current_dir.current_dir.display());
diff --git a/examples/example-setup/src/main.rs b/examples/example-setup/src/main.rs
index c445276..cd432dd 100644
--- a/examples/example-setup/src/main.rs
+++ b/examples/example-setup/src/main.rs
@@ -2,7 +2,7 @@
 //!
 //! > This example demonstrates how to build a custom Setup for modular management of project components
 
-use mingling::{Program, macros::program_setup, prelude::*};
+use mingling::{macros::program_setup, prelude::*, Program};
 
 fn main() {
     let mut program = ThisProgram::new();
diff --git a/examples/example-unit-test/src/main.rs b/examples/example-unit-test/src/main.rs
index 62c7fbf..7808d0d 100644
--- a/examples/example-unit-test/src/main.rs
+++ b/examples/example-unit-test/src/main.rs
@@ -89,26 +89,31 @@ fn handle_hello(args: EntryHello) -> Next {
     ResultName::new(name).to_render()
 }
 
+/// Renders a successful greeting with the given name.
 #[renderer]
 fn render_result_name(name: ResultName) -> String {
     r_println!("Hello, {}!", *name);
 }
 
+/// Renders the error when no name is provided.
 #[renderer]
 fn render_error_no_name_provided(_: ErrorNoNameProvided) -> String {
     r_println!("No name provided");
 }
 
+/// Renders the error when the name is already taken.
 #[renderer]
 fn render_error_name_not_available(_: ErrorNameNotAvailable) -> String {
     r_println!("Name not available");
 }
 
+/// Renders the error when the name exceeds the maximum length.
 #[renderer]
 fn render_error_name_too_long(len: ErrorNameTooLong) -> String {
     r_println!("Name too long: {} > 10", *len);
 }
 
+/// Renders the error when the dispatcher (subcommand) is not found.
 #[renderer]
 fn render_dispatcher_not_found(err: ErrorDispatcherNotFound) {
     r_println!("Command not found: \"{}\"", err.inner.join(" "));