Add response formatter; refactor stats formatter

This adds support for formatting responses in different ways.
For now the options are
* `plain`: No color, basic formatting
* `color`: Color, indented formatting (default)
* `emoji`: Fancy mode with emoji icons

Fixes #546
Related to #271

Author: mre

lychee-bin/src/commands/check.rs

@@ -15,7 +15,8 @@ use lychee_lib::{InputSource, Result};
 use lychee_lib::{ResponseBody, Status};
 
 use crate::archive::{Archive, Suggestion};
-use crate::formatters::response::ResponseFormatter;
+use crate::formatters::get_response_formatter;
+use crate::formatters::response::ResponseBodyFormatter;
 use crate::verbosity::Verbosity;
 use crate::{cache::Cache, stats::ResponseStats, ExitCode};
 
@@ -62,11 +63,13 @@ where
         accept,
     ));
 
+    let formatter = get_response_formatter(&params.cfg.mode);
+
     let show_results_task = tokio::spawn(progress_bar_task(
         recv_resp,
         params.cfg.verbose,
         pb.clone(),
-        Arc::new(params.formatter),
+        formatter,
         stats,
     ));
 
@@ -178,11 +181,17 @@ async fn progress_bar_task(
     mut recv_resp: mpsc::Receiver<Response>,
     verbose: Verbosity,
     pb: Option<ProgressBar>,
-    formatter: Arc<Box<dyn ResponseFormatter>>,
+    formatter: Box<dyn ResponseBodyFormatter>,
     mut stats: ResponseStats,
 ) -> Result<(Option<ProgressBar>, ResponseStats)> {
     while let Some(response) = recv_resp.recv().await {
-        show_progress(&mut io::stderr(), &pb, &response, &formatter, &verbose)?;
+        show_progress(
+            &mut io::stderr(),
+            &pb,
+            &response,
+            formatter.as_ref(),
+            &verbose,
+        )?;
         stats.add(response);
     }
     Ok((pb, stats))
@@ -275,10 +284,11 @@ fn show_progress(
     output: &mut dyn Write,
     progress_bar: &Option<ProgressBar>,
     response: &Response,
-    formatter: &Arc<Box<dyn ResponseFormatter>>,
+    formatter: &dyn ResponseBodyFormatter,
     verbose: &Verbosity,
 ) -> Result<()> {
-    let out = formatter.write_response(response)?;
+    let out = formatter.format_response(response.body());
+
     if let Some(pb) = progress_bar {
         pb.inc(1);
         pb.set_message(out.clone());
@@ -317,30 +327,26 @@ fn get_failed_urls(stats: &mut ResponseStats) -> Vec<(InputSource, Url)> {
 #[cfg(test)]
 mod tests {
     use log::info;
+    use lychee_lib::{CacheStatus, InputSource, Uri};
 
-    use lychee_lib::{CacheStatus, InputSource, ResponseBody, Uri};
-
-    use crate::formatters;
+    use crate::{formatters::get_response_formatter, options};
 
     use super::*;
 
     #[test]
     fn test_skip_cached_responses_in_progress_output() {
         let mut buf = Vec::new();
-        let response = Response(
+        let response = Response::new(
+            Uri::try_from("http://127.0.0.1").unwrap(),
+            Status::Cached(CacheStatus::Ok(200)),
             InputSource::Stdin,
-            ResponseBody {
-                uri: Uri::try_from("http://127.0.0.1").unwrap(),
-                status: Status::Cached(CacheStatus::Ok(200)),
-            },
         );
-        let formatter: Arc<Box<dyn ResponseFormatter>> =
-            Arc::new(Box::new(formatters::response::Raw::new()));
+        let formatter = get_response_formatter(&options::ResponseFormat::Plain);
         show_progress(
             &mut buf,
             &None,
             &response,
-            &formatter,
+            formatter.as_ref(),
             &Verbosity::default(),
         )
         .unwrap();
@@ -352,16 +358,20 @@ mod tests {
     #[test]
     fn test_show_cached_responses_in_progress_debug_output() {
         let mut buf = Vec::new();
-        let response = Response(
+        let response = Response::new(
+            Uri::try_from("http://127.0.0.1").unwrap(),
+            Status::Cached(CacheStatus::Ok(200)),
             InputSource::Stdin,
-            ResponseBody {
-                uri: Uri::try_from("http://127.0.0.1").unwrap(),
-                status: Status::Cached(CacheStatus::Ok(200)),
-            },
         );
-        let formatter: Arc<Box<dyn ResponseFormatter>> =
-            Arc::new(Box::new(formatters::response::Raw::new()));
-        show_progress(&mut buf, &None, &response, &formatter, &Verbosity::debug()).unwrap();
+        let formatter = get_response_formatter(&options::ResponseFormat::Plain);
+        show_progress(
+            &mut buf,
+            &None,
+            &response,
+            formatter.as_ref(),
+            &Verbosity::debug(),
+        )
+        .unwrap();
 
         assert!(!buf.is_empty());
         let buf = String::from_utf8_lossy(&buf);

lychee-bin/src/commands/mod.rs

@@ -8,7 +8,6 @@ pub(crate) use dump::dump_inputs;
 use std::sync::Arc;
 
 use crate::cache::Cache;
-use crate::formatters::response::ResponseFormatter;
 use crate::options::Config;
 use lychee_lib::Result;
 use lychee_lib::{Client, Request};
@@ -18,6 +17,5 @@ pub(crate) struct CommandParams<S: futures::Stream<Item = Result<Request>>> {
     pub(crate) client: Client,
     pub(crate) cache: Arc<Cache>,
     pub(crate) requests: S,
-    pub(crate) formatter: Box<dyn ResponseFormatter>,
     pub(crate) cfg: Config,
 }

lychee-bin/src/color.rs lychee-bin/src/formatters/color.rs

@@ -1,16 +1,21 @@
+//! Defines the colors used in the output of the CLI.
+
 use console::Style;
 use once_cell::sync::Lazy;
 
 pub(crate) static NORMAL: Lazy<Style> = Lazy::new(Style::new);
 pub(crate) static DIM: Lazy<Style> = Lazy::new(|| Style::new().dim());
 
-pub(crate) static GREEN: Lazy<Style> = Lazy::new(|| Style::new().color256(82).bright());
+pub(crate) static GREEN: Lazy<Style> = Lazy::new(|| Style::new().color256(2).bold().bright());
 pub(crate) static BOLD_GREEN: Lazy<Style> = Lazy::new(|| Style::new().color256(82).bold().bright());
 pub(crate) static YELLOW: Lazy<Style> = Lazy::new(|| Style::new().yellow().bright());
 pub(crate) static BOLD_YELLOW: Lazy<Style> = Lazy::new(|| Style::new().yellow().bold().bright());
 pub(crate) static PINK: Lazy<Style> = Lazy::new(|| Style::new().color256(197));
 pub(crate) static BOLD_PINK: Lazy<Style> = Lazy::new(|| Style::new().color256(197).bold());
 
+// Used for debug log messages
+pub(crate) static BLUE: Lazy<Style> = Lazy::new(|| Style::new().blue().bright());
+
 // Write output using predefined colors
 macro_rules! color {
     ($f:ident, $color:ident, $text:tt, $($tts:tt)*) => {

lychee-bin/src/formatters/log.rs

@@ -0,0 +1,53 @@
+use log::Level;
+use std::io::Write;
+
+use crate::{formatters, options::ResponseFormat, verbosity::Verbosity};
+
+/// Initialize the logging system with the given verbosity level
+pub(crate) fn init_logging(verbose: &Verbosity, mode: &ResponseFormat) {
+    let mut builder = env_logger::Builder::new();
+
+    builder
+        .format_timestamp(None) // Disable timestamps
+        .format_module_path(false) // Disable module path to reduce clutter
+        .format_target(false) // Disable target
+        .filter_module("lychee", verbose.log_level_filter()) // Re-add module filtering
+        .filter_module("lychee_lib", verbose.log_level_filter()); // Re-add module filtering
+
+    // Enable color unless the user has disabled it
+    if !matches!(mode, ResponseFormat::Plain) {
+        builder.format(|buf, record| {
+            let level = record.level();
+            let level_text = match level {
+                Level::Error => "ERROR",
+                Level::Warn => " WARN",
+                Level::Info => " INFO",
+                Level::Debug => "DEBUG",
+                Level::Trace => "TRACE",
+            };
+
+            // Desired total width including brackets
+            let numeric_padding: usize = 10;
+            // Calculate the effective padding. Ensure it's non-negative to avoid panic.
+            let effective_padding = numeric_padding.saturating_sub(level_text.len() + 2); // +2 for brackets
+
+            // Construct the log prefix with the log level.
+            // The spaces added before "WARN" and "INFO" are to visually align them with "ERROR", "DEBUG", and "TRACE"
+            let level_label = format!("[{level_text}]");
+            let c = match level {
+                Level::Error => &formatters::color::BOLD_PINK,
+                Level::Warn => &formatters::color::BOLD_YELLOW,
+                Level::Info | Level::Debug => &formatters::color::BLUE,
+                Level::Trace => &formatters::color::DIM,
+            };
+            let colored_level = c.apply_to(level_label);
+
+            let prefix = format!("{}{}", " ".repeat(effective_padding), colored_level);
+
+            // Write formatted log message with aligned level and original log message.
+            writeln!(buf, "{} {}", prefix, record.args())
+        });
+    }
+
+    builder.init();
+}

lychee-bin/src/formatters/mod.rs

@@ -1,47 +1,41 @@
+pub(crate) mod color;
 pub(crate) mod duration;
+pub(crate) mod log;
 pub(crate) mod response;
 pub(crate) mod stats;
 
-use lychee_lib::{CacheStatus, ResponseBody, Status};
+use self::{response::ResponseBodyFormatter, stats::StatsFormatter};
+use crate::options::{ResponseFormat, StatsFormat};
 use supports_color::Stream;
 
-use crate::{
-    color::{DIM, GREEN, NORMAL, PINK, YELLOW},
-    options::{self, Format},
-};
-
-use self::response::ResponseFormatter;
-
 /// Detects whether a terminal supports color, and gives details about that
 /// support. It takes into account the `NO_COLOR` environment variable.
 fn supports_color() -> bool {
     supports_color::on(Stream::Stdout).is_some()
 }
 
-/// Color the response body for TTYs that support it
-pub(crate) fn color_response(body: &ResponseBody) -> String {
-    if supports_color() {
-        let out = match body.status {
-            Status::Ok(_) | Status::Cached(CacheStatus::Ok(_)) => GREEN.apply_to(body),
-            Status::Excluded
-            | Status::Unsupported(_)
-            | Status::Cached(CacheStatus::Excluded | CacheStatus::Unsupported) => {
-                DIM.apply_to(body)
-            }
-            Status::Redirected(_) => NORMAL.apply_to(body),
-            Status::UnknownStatusCode(_) | Status::Timeout(_) => YELLOW.apply_to(body),
-            Status::Error(_) | Status::Cached(CacheStatus::Error(_)) => PINK.apply_to(body),
-        };
-        out.to_string()
-    } else {
-        body.to_string()
+pub(crate) fn get_stats_formatter(
+    format: &StatsFormat,
+    response_format: &ResponseFormat,
+) -> Box<dyn StatsFormatter> {
+    match format {
+        StatsFormat::Compact => Box::new(stats::Compact::new(response_format.clone())),
+        StatsFormat::Detailed => Box::new(stats::Detailed::new(response_format.clone())),
+        StatsFormat::Json => Box::new(stats::Json::new()),
+        StatsFormat::Markdown => Box::new(stats::Markdown::new()),
+        StatsFormat::Raw => Box::new(stats::Raw::new()),
     }
 }
 
 /// Create a response formatter based on the given format option
-pub(crate) fn get_formatter(format: &options::Format) -> Box<dyn ResponseFormatter> {
-    if matches!(format, Format::Raw) || !supports_color() {
-        return Box::new(response::Raw::new());
+///
+pub(crate) fn get_response_formatter(format: &ResponseFormat) -> Box<dyn ResponseBodyFormatter> {
+    if !supports_color() {
+        return Box::new(response::PlainFormatter);
+    }
+    match format {
+        ResponseFormat::Plain => Box::new(response::PlainFormatter),
+        ResponseFormat::Color => Box::new(response::ColorFormatter),
+        ResponseFormat::Emoji => Box::new(response::EmojiFormatter),
     }
-    Box::new(response::Color::new())
 }

lychee-bin/src/formatters/response.rs

@@ -0,0 +1,105 @@
+use lychee_lib::{CacheStatus, ResponseBody, Status};
+
+use super::color::{DIM, GREEN, NORMAL, PINK, YELLOW};
+
+/// A trait for formatting a response body
+///
+/// This trait is used to format a response body into a string.
+/// It can be implemented for different formatting styles such as
+/// colorized output or plain text.
+pub(crate) trait ResponseBodyFormatter: Send + Sync {
+    fn format_response(&self, body: &ResponseBody) -> String;
+}
+
+/// A basic formatter that just returns the response body as a string
+/// without any color codes or other formatting.
+///
+/// Under the hood, it calls the `Display` implementation of the `ResponseBody`
+/// type.
+///
+/// This formatter is used when the user has requested raw output
+/// or when the terminal does not support color.
+pub(crate) struct PlainFormatter;
+
+impl ResponseBodyFormatter for PlainFormatter {
+    fn format_response(&self, body: &ResponseBody) -> String {
+        body.to_string()
+    }
+}
+
+/// A colorized formatter for the response body
+///
+/// This formatter is used when the terminal supports color and the user
+/// has not explicitly requested raw, uncolored output.
+pub(crate) struct ColorFormatter;
+
+impl ResponseBodyFormatter for ColorFormatter {
+    fn format_response(&self, body: &ResponseBody) -> String {
+        // Determine the color based on the status.
+        let status_color = match body.status {
+            Status::Ok(_) | Status::Cached(CacheStatus::Ok(_)) => &GREEN,
+            Status::Excluded
+            | Status::Unsupported(_)
+            | Status::Cached(CacheStatus::Excluded | CacheStatus::Unsupported) => &DIM,
+            Status::Redirected(_) => &NORMAL,
+            Status::UnknownStatusCode(_) | Status::Timeout(_) => &YELLOW,
+            Status::Error(_) | Status::Cached(CacheStatus::Error(_)) => &PINK,
+        };
+
+        let status_formatted = format_status(&body.status);
+
+        let colored_status = status_color.apply_to(status_formatted);
+
+        // Construct the output.
+        format!("{} {}", colored_status, body.uri)
+    }
+}
+
+/// Desired total width of formatted string for color formatter
+///
+/// The longest string, which needs to be formatted, is currently `[Excluded]`
+/// which is 10 characters long (including brackets).
+///
+/// Keep in sync with `Status::code_as_string`, which converts status codes to
+/// strings.
+const STATUS_CODE_PADDING: usize = 10;
+
+/// Format the status code or text for the color formatter.
+///
+/// Numeric status codes are right-aligned.
+/// Textual statuses are left-aligned.
+/// Padding is taken into account.
+fn format_status(status: &Status) -> String {
+    let status_code_or_text = status.code_as_string();
+
+    // Calculate the effective padding. Ensure it's non-negative to avoid panic.
+    let padding = STATUS_CODE_PADDING.saturating_sub(status_code_or_text.len() + 2); // +2 for brackets
+
+    format!(
+        "{}[{:>width$}]",
+        " ".repeat(padding),
+        status_code_or_text,
+        width = status_code_or_text.len()
+    )
+}
+
+/// An emoji formatter for the response body
+///
+/// This formatter replaces certain textual elements with emojis for a more
+/// visual output.
+pub(crate) struct EmojiFormatter;
+
+impl ResponseBodyFormatter for EmojiFormatter {
+    fn format_response(&self, body: &ResponseBody) -> String {
+        let emoji = match body.status {
+            Status::Ok(_) | Status::Cached(CacheStatus::Ok(_)) => "✅",
+            Status::Excluded
+            | Status::Unsupported(_)
+            | Status::Cached(CacheStatus::Excluded | CacheStatus::Unsupported) => "🚫",
+            Status::Redirected(_) => "↪️",
+            Status::UnknownStatusCode(_) | Status::Timeout(_) => "⚠️",
+            Status::Error(_) | Status::Cached(CacheStatus::Error(_)) => "❌",
+        };
+        format!("{} {}", emoji, body.uri)
+    }
+}

lychee-bin/src/formatters/response/color.rs

@@ -1,23 +1,22 @@
+use anyhow::Result;
 use std::{
     fmt::{self, Display},
     time::Duration,
 };
 
-use crate::{
-    color::{color, BOLD_GREEN, BOLD_PINK, BOLD_YELLOW, DIM, NORMAL},
-    formatters::color_response,
-    stats::ResponseStats,
-};
+use crate::formatters::color::{color, BOLD_GREEN, BOLD_PINK, BOLD_YELLOW, DIM, NORMAL};
+use crate::{formatters::get_response_formatter, options, stats::ResponseStats};
 
 use super::StatsFormatter;
 
-use anyhow::Result;
-
-struct CompactResponseStats(ResponseStats);
+struct CompactResponseStats {
+    stats: ResponseStats,
+    mode: options::ResponseFormat,
+}
 
 impl Display for CompactResponseStats {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let stats = &self.0;
+        let stats = &self.stats;
 
         if !stats.fail_map.is_empty() {
             let input = if stats.fail_map.len() == 1 {
@@ -33,10 +32,13 @@ impl Display for CompactResponseStats {
                 stats.fail_map.len()
             )?;
         }
+
+        let response_formatter = get_response_formatter(&self.mode);
+
         for (source, responses) in &stats.fail_map {
             color!(f, BOLD_YELLOW, "[{}]:\n", source)?;
             for response in responses {
-                writeln!(f, "{}", color_response(response))?;
+                writeln!(f, "{}", response_formatter.format_response(response))?;
             }
 
             if let Some(suggestions) = &stats.suggestion_map.get(source) {
@@ -68,17 +70,22 @@ impl Display for CompactResponseStats {
     }
 }
 
-pub(crate) struct Compact;
+pub(crate) struct Compact {
+    mode: options::ResponseFormat,
+}
 
 impl Compact {
-    pub(crate) const fn new() -> Self {
-        Self {}
+    pub(crate) const fn new(mode: options::ResponseFormat) -> Self {
+        Self { mode }
     }
 }
 
 impl StatsFormatter for Compact {
-    fn format_stats(&self, stats: ResponseStats) -> Result<Option<String>> {
-        let compact = CompactResponseStats(stats);
+    fn format(&self, stats: ResponseStats) -> Result<Option<String>> {
+        let compact = CompactResponseStats {
+            stats,
+            mode: self.mode.clone(),
+        };
         Ok(Some(compact.to_string()))
     }
 }

lychee-bin/src/formatters/response/mod.rs

@@ -1,5 +1,5 @@
 use super::StatsFormatter;
-use crate::{formatters::color_response, stats::ResponseStats};
+use crate::{formatters::get_response_formatter, options, stats::ResponseStats};
 
 use anyhow::Result;
 use pad::{Alignment, PadStr};
@@ -24,9 +24,16 @@ fn write_stat(f: &mut fmt::Formatter, title: &str, stat: usize, newline: bool) -
     Ok(())
 }
 
+/// Wrap as newtype because multiple `Display` implementations are not allowed
+/// for `ResponseStats`
+struct DetailedResponseStats {
+    stats: ResponseStats,
+    mode: options::ResponseFormat,
+}
+
 impl Display for DetailedResponseStats {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let stats = &self.0;
+        let stats = &self.stats;
         let separator = "-".repeat(MAX_PADDING + 1);
 
         writeln!(f, "\u{1f4dd} Summary")?; // 📝
@@ -39,12 +46,15 @@ impl Display for DetailedResponseStats {
         write_stat(f, "\u{2753} Unknown", stats.unknown, true)?; //❓
         write_stat(f, "\u{1f6ab} Errors", stats.errors, false)?; // 🚫
 
+        let response_formatter = get_response_formatter(&self.mode);
+
         for (source, responses) in &stats.fail_map {
             // Using leading newlines over trailing ones (e.g. `writeln!`)
             // lets us avoid extra newlines without any additional logic.
             write!(f, "\n\nErrors in {source}")?;
+
             for response in responses {
-                write!(f, "\n{}", color_response(response))?;
+                write!(f, "\n{}", response_formatter.format_response(response))?;
 
                 if let Some(suggestions) = &stats.suggestion_map.get(source) {
                     writeln!(f, "\nSuggestions in {source}")?;
@@ -59,21 +69,22 @@ impl Display for DetailedResponseStats {
     }
 }
 
-/// Wrap as newtype because multiple `Display` implementations are not allowed
-/// for `ResponseStats`
-struct DetailedResponseStats(ResponseStats);
-
-pub(crate) struct Detailed;
+pub(crate) struct Detailed {
+    mode: options::ResponseFormat,
+}
 
 impl Detailed {
-    pub(crate) const fn new() -> Self {
-        Self
+    pub(crate) const fn new(mode: options::ResponseFormat) -> Self {
+        Self { mode }
     }
 }
 
 impl StatsFormatter for Detailed {
-    fn format_stats(&self, stats: ResponseStats) -> Result<Option<String>> {
-        let detailed = DetailedResponseStats(stats);
+    fn format(&self, stats: ResponseStats) -> Result<Option<String>> {
+        let detailed = DetailedResponseStats {
+            stats,
+            mode: self.mode.clone(),
+        };
         Ok(Some(detailed.to_string()))
     }
 }

lychee-bin/src/formatters/response/raw.rs

@@ -13,7 +13,7 @@ impl Json {
 
 impl StatsFormatter for Json {
     /// Format stats as JSON object
-    fn format_stats(&self, stats: ResponseStats) -> Result<Option<String>> {
+    fn format(&self, stats: ResponseStats) -> Result<Option<String>> {
         serde_json::to_string_pretty(&stats)
             .map(Some)
             .context("Cannot format stats as JSON")

lychee-bin/src/formatters/stats/compact.rs

@@ -147,7 +147,7 @@ impl Markdown {
 }
 
 impl StatsFormatter for Markdown {
-    fn format_stats(&self, stats: ResponseStats) -> Result<Option<String>> {
+    fn format(&self, stats: ResponseStats) -> Result<Option<String>> {
         let markdown = MarkdownResponseStats(stats);
         Ok(Some(markdown.to_string()))
     }
@@ -222,12 +222,10 @@ mod tests {
     #[test]
     fn test_render_summary() {
         let mut stats = ResponseStats::default();
-        let response = Response(
+        let response = Response::new(
+            Uri::try_from("http://127.0.0.1").unwrap(),
+            Status::Cached(CacheStatus::Error(Some(404))),
             InputSource::Stdin,
-            ResponseBody {
-                uri: Uri::try_from("http://127.0.0.1").unwrap(),
-                status: Status::Cached(CacheStatus::Error(Some(404))),
-            },
         );
         stats.add(response);
         stats

lychee-bin/src/formatters/stats/detailed.rs

@@ -15,5 +15,5 @@ use anyhow::Result;
 
 pub(crate) trait StatsFormatter {
     /// Format the stats of all responses and write them to stdout
-    fn format_stats(&self, stats: ResponseStats) -> Result<Option<String>>;
+    fn format(&self, stats: ResponseStats) -> Result<Option<String>>;
 }

lychee-bin/src/formatters/stats/json.rs

@@ -12,7 +12,7 @@ impl Raw {
 
 impl StatsFormatter for Raw {
     /// Don't print stats in raw mode
-    fn format_stats(&self, _stats: ResponseStats) -> Result<Option<String>> {
+    fn format(&self, _stats: ResponseStats) -> Result<Option<String>> {
         Ok(None)
     }
 }

lychee-bin/src/formatters/stats/markdown.rs

@@ -65,9 +65,8 @@ use std::sync::Arc;
 
 use anyhow::{bail, Context, Error, Result};
 use clap::Parser;
-use color::YELLOW;
 use commands::CommandParams;
-use formatters::response::ResponseFormatter;
+use formatters::{get_stats_formatter, log::init_logging};
 use log::{error, info, warn};
 
 #[cfg(feature = "native-tls")]
@@ -83,7 +82,6 @@ use lychee_lib::CookieJar;
 mod archive;
 mod cache;
 mod client;
-mod color;
 mod commands;
 mod formatters;
 mod options;
@@ -92,12 +90,12 @@ mod stats;
 mod time;
 mod verbosity;
 
+use crate::formatters::color;
 use crate::formatters::duration::Duration;
 use crate::{
     cache::{Cache, StoreExt},
-    color::color,
     formatters::stats::StatsFormatter,
-    options::{Config, Format, LycheeOptions, LYCHEE_CACHE_FILE, LYCHEE_IGNORE_FILE},
+    options::{Config, LycheeOptions, LYCHEE_CACHE_FILE, LYCHEE_IGNORE_FILE},
 };
 
 /// A C-like enum that can be cast to `i32` and used as process exit code.
@@ -143,15 +141,7 @@ fn read_lines(file: &File) -> Result<Vec<String>> {
 fn load_config() -> Result<LycheeOptions> {
     let mut opts = LycheeOptions::parse();
 
-    env_logger::Builder::new()
-        // super basic formatting; no timestamps, no module path, no target
-        .format_timestamp(None)
-        .format_indent(Some(0))
-        .format_module_path(false)
-        .format_target(false)
-        .filter_module("lychee", opts.config.verbose.log_level_filter())
-        .filter_module("lychee_lib", opts.config.verbose.log_level_filter())
-        .init();
+    init_logging(&opts.config.verbose, &opts.config.mode);
 
     // Load a potentially existing config file and merge it into the config from
     // the CLI
@@ -333,16 +323,12 @@ async fn run(opts: &LycheeOptions) -> Result<i32> {
         )
     })?;
 
-    let response_formatter: Box<dyn ResponseFormatter> =
-        formatters::get_formatter(&opts.config.format);
-
     let client = client::create(&opts.config, cookie_jar.as_deref())?;
 
     let params = CommandParams {
         client,
         cache,
         requests,
-        formatter: response_formatter,
         cfg: opts.config.clone(),
     };
 
@@ -357,33 +343,28 @@ async fn run(opts: &LycheeOptions) -> Result<i32> {
             .flatten()
             .any(|body| body.uri.domain() == Some("github.com"));
 
-        let writer: Box<dyn StatsFormatter> = match opts.config.format {
-            Format::Compact => Box::new(formatters::stats::Compact::new()),
-            Format::Detailed => Box::new(formatters::stats::Detailed::new()),
-            Format::Json => Box::new(formatters::stats::Json::new()),
-            Format::Markdown => Box::new(formatters::stats::Markdown::new()),
-            Format::Raw => Box::new(formatters::stats::Raw::new()),
-        };
+        let stats_formatter: Box<dyn StatsFormatter> =
+            get_stats_formatter(&opts.config.format, &opts.config.mode);
+
         let is_empty = stats.is_empty();
-        let formatted = writer.format_stats(stats)?;
+        let formatted_stats = stats_formatter.format(stats)?;
 
-        if let Some(formatted) = formatted {
+        if let Some(formatted_stats) = formatted_stats {
             if let Some(output) = &opts.config.output {
-                fs::write(output, formatted).context("Cannot write status output to file")?;
+                fs::write(output, formatted_stats).context("Cannot write status output to file")?;
             } else {
                 if opts.config.verbose.log_level() >= log::Level::Info && !is_empty {
                     // separate summary from the verbose list of links above
                     // with a newline
                     writeln!(io::stdout())?;
                 }
                 // we assume that the formatted stats don't have a final newline
-                writeln!(io::stdout(), "{formatted}")?;
+                writeln!(io::stdout(), "{formatted_stats}")?;
             }
         }
 
         if github_issues && opts.config.github_token.is_none() {
-            let mut handle = io::stderr();
-            color!(handle, YELLOW, "\u{1f4a1} There were issues with Github URLs. You could try setting a Github token and running lychee again.",)?;
+            warn!("There were issues with GitHub URLs. You could try setting a GitHub token and running lychee again.",);
         }
 
         if opts.config.cache {

lychee-bin/src/formatters/stats/mod.rs

@@ -44,8 +44,9 @@ const HELP_MSG_CONFIG_FILE: &str = formatcp!(
 const TIMEOUT_STR: &str = concatcp!(DEFAULT_TIMEOUT_SECS);
 const RETRY_WAIT_TIME_STR: &str = concatcp!(DEFAULT_RETRY_WAIT_TIME_SECS);
 
+/// The format to use for the final status report
 #[derive(Debug, Deserialize, Default, Clone)]
-pub(crate) enum Format {
+pub(crate) enum StatsFormat {
     #[default]
     Compact,
     Detailed,
@@ -54,20 +55,46 @@ pub(crate) enum Format {
     Raw,
 }
 
-impl FromStr for Format {
+impl FromStr for StatsFormat {
     type Err = Error;
+
     fn from_str(format: &str) -> Result<Self, Self::Err> {
         match format.to_lowercase().as_str() {
-            "compact" | "string" => Ok(Format::Compact),
-            "detailed" => Ok(Format::Detailed),
-            "json" => Ok(Format::Json),
-            "markdown" | "md" => Ok(Format::Markdown),
-            "raw" => Ok(Format::Raw),
+            "compact" | "string" => Ok(StatsFormat::Compact),
+            "detailed" => Ok(StatsFormat::Detailed),
+            "json" => Ok(StatsFormat::Json),
+            "markdown" | "md" => Ok(StatsFormat::Markdown),
+            "raw" => Ok(StatsFormat::Raw),
             _ => Err(anyhow!("Unknown format {}", format)),
         }
     }
 }
 
+/// The different formatter modes
+///
+/// This decides over whether to use color,
+/// emojis, or plain text for the output.
+#[derive(Debug, Deserialize, Default, Clone)]
+pub(crate) enum ResponseFormat {
+    Plain,
+    #[default]
+    Color,
+    Emoji,
+}
+
+impl FromStr for ResponseFormat {
+    type Err = Error;
+
+    fn from_str(mode: &str) -> Result<Self, Self::Err> {
+        match mode.to_lowercase().as_str() {
+            "plain" | "plaintext" | "raw" => Ok(ResponseFormat::Plain),
+            "color" => Ok(ResponseFormat::Color),
+            "emoji" => Ok(ResponseFormat::Emoji), // Shows emojis
+            _ => Err(anyhow!("Unknown formatter mode {mode}")),
+        }
+    }
+}
+
 // Macro for generating default functions to be used by serde
 macro_rules! default_function {
     ( $( $name:ident : $T:ty = $e:expr; )* ) => {
@@ -105,12 +132,12 @@ macro_rules! fold_in {
     };
 }
 
-#[derive(Parser, Debug)]
-#[command(version, about)]
 /// A fast, async link checker
 ///
 /// Finds broken URLs and mail addresses inside Markdown, HTML,
 /// `reStructuredText`, websites and more!
+#[derive(Parser, Debug)]
+#[command(version, about)]
 pub(crate) struct LycheeOptions {
     /// The inputs (where to get links to check from).
     /// These can be: files (e.g. `README.md`), file globs (e.g. `"~/git/*/README.md"`),
@@ -147,6 +174,7 @@ impl LycheeOptions {
     }
 }
 
+/// The main configuration for lychee
 #[allow(clippy::struct_excessive_bools)]
 #[derive(Parser, Debug, Deserialize, Clone, Default)]
 pub(crate) struct Config {
@@ -385,10 +413,15 @@ separated list of accepted status codes. This example will accept 200, 201,
     #[serde(default)]
     pub(crate) output: Option<PathBuf>,
 
+    /// Set the output display mode. Determines how results are presented in the terminal (color, plain, emoji).
+    #[arg(long, default_value = "color")]
+    #[serde(default)]
+    pub(crate) mode: ResponseFormat,
+
     /// Output format of final status report (compact, detailed, json, markdown)
     #[arg(short, long, default_value = "compact")]
     #[serde(default)]
-    pub(crate) format: Format,
+    pub(crate) format: StatsFormat,
 
     /// When HTTPS is available, treat HTTP links as errors
     #[arg(long)]

lychee-bin/src/formatters/stats/raw.rs

@@ -55,25 +55,22 @@ impl ResponseStats {
 
     pub(crate) fn add(&mut self, response: Response) {
         self.total += 1;
+        let status = response.status();
 
-        let Response(source, ResponseBody { ref status, .. }) = response;
         self.increment_status_counters(status);
 
-        match status {
-            _ if status.is_failure() => {
-                let fail = self.fail_map.entry(source).or_default();
-                fail.insert(response.1);
-            }
-            Status::Ok(_) if self.detailed_stats => {
-                let success = self.success_map.entry(source).or_default();
-                success.insert(response.1);
-            }
-            Status::Excluded if self.detailed_stats => {
-                let excluded = self.excluded_map.entry(source).or_default();
-                excluded.insert(response.1);
+        let input_source = {
+            let source: InputSource = response.source().clone();
+            match status {
+                _ if status.is_failure() => self.fail_map.entry(source).or_default(),
+                Status::Ok(_) if self.detailed_stats => self.success_map.entry(source).or_default(),
+                Status::Excluded if self.detailed_stats => {
+                    self.excluded_map.entry(source).or_default()
+                }
+                _ => return,
             }
-            _ => (),
-        }
+        };
+        input_source.insert(response.1);
     }
 
     #[inline]
@@ -107,8 +104,7 @@ mod tests {
     // and it's a lot faster to just generate a fake response
     fn mock_response(status: Status) -> Response {
         let uri = website("https://some-url.com/ok");
-        let response_body = ResponseBody { uri, status };
-        Response(InputSource::Stdin, response_body)
+        Response::new(uri, status, InputSource::Stdin)
     }
 
     fn dummy_ok() -> Response {
@@ -142,9 +138,9 @@ mod tests {
         stats.add(dummy_error());
         stats.add(dummy_ok());
 
-        let Response(source, body) = dummy_error();
+        let response = dummy_error();
         let expected_fail_map: HashMap<InputSource, HashSet<ResponseBody>> =
-            HashMap::from_iter([(source, HashSet::from_iter([body]))]);
+            HashMap::from_iter([(response.source().clone(), HashSet::from_iter([response.1]))]);
         assert_eq!(stats.fail_map, expected_fail_map);
 
         assert!(stats.success_map.is_empty());
@@ -162,21 +158,27 @@ mod tests {
         stats.add(dummy_ok());
 
         let mut expected_fail_map: HashMap<InputSource, HashSet<ResponseBody>> = HashMap::new();
-        let Response(source, response_body) = dummy_error();
-        let entry = expected_fail_map.entry(source).or_default();
-        entry.insert(response_body);
+        let response = dummy_error();
+        let entry = expected_fail_map
+            .entry(response.source().clone())
+            .or_default();
+        entry.insert(response.1);
         assert_eq!(stats.fail_map, expected_fail_map);
 
         let mut expected_success_map: HashMap<InputSource, HashSet<ResponseBody>> = HashMap::new();
-        let Response(source, response_body) = dummy_ok();
-        let entry = expected_success_map.entry(source).or_default();
-        entry.insert(response_body);
+        let response = dummy_ok();
+        let entry = expected_success_map
+            .entry(response.source().clone())
+            .or_default();
+        entry.insert(response.1);
         assert_eq!(stats.success_map, expected_success_map);
 
         let mut expected_excluded_map: HashMap<InputSource, HashSet<ResponseBody>> = HashMap::new();
-        let Response(source, response_body) = dummy_excluded();
-        let entry = expected_excluded_map.entry(source).or_default();
-        entry.insert(response_body);
+        let response = dummy_excluded();
+        let entry = expected_excluded_map
+            .entry(response.source().clone())
+            .or_default();
+        entry.insert(response.1);
         assert_eq!(stats.excluded_map, expected_excluded_map);
     }
 }

lychee-bin/src/main.rs

@@ -153,11 +153,13 @@ mod cli {
         // Parse site error status from the fail_map
         let output_json = serde_json::from_slice::<Value>(&output.stdout).unwrap();
         let site_error_status = &output_json["fail_map"][&test_path.to_str().unwrap()][0]["status"];
-        let error_details = site_error_status["details"].to_string();
 
-        assert!(error_details
-            .contains("error:0A000086:SSL routines:tls_post_process_server_certificate:"));
-        assert!(error_details.contains("(certificate has expired)"));
+        assert_eq!(
+            "error:0A000086:SSL routines:tls_post_process_server_certificate:\
+            certificate verify failed:../ssl/statem/statem_clnt.c:1883: \
+            (certificate has expired)",
+            site_error_status["details"]
+        );
         Ok(())
     }
 

lychee-bin/src/options.rs

@@ -6,8 +6,15 @@ use serde::Serialize;
 use crate::{InputSource, Status, Uri};
 
 /// Response type returned by lychee after checking a URI
+//
+// Body is public to allow inserting into stats maps (fail_map, success_map,
+// etc.) without `Clone`, because the inner `ErrorKind` in `response.status` is
+// not `Clone`. Use `body()` to access the body in the rest of the code.
+//
+// `pub(crate)` is insufficient, because the `stats` module is in the `bin`
+// crate crate.
 #[derive(Debug)]
-pub struct Response(pub InputSource, pub ResponseBody);
+pub struct Response(InputSource, pub ResponseBody);
 
 impl Response {
     #[inline]
@@ -23,6 +30,21 @@ impl Response {
     pub const fn status(&self) -> &Status {
         &self.1.status
     }
+
+    #[inline]
+    #[must_use]
+    /// Retrieve the underlying source of the response
+    /// (e.g. the input file or the URL)
+    pub const fn source(&self) -> &InputSource {
+        &self.0
+    }
+
+    #[inline]
+    #[must_use]
+    /// Retrieve the underlying body of the response
+    pub const fn body(&self) -> &ResponseBody {
+        &self.1
+    }
 }
 
 impl Display for Response {
@@ -57,13 +79,7 @@ pub struct ResponseBody {
 // matching in these cases.
 impl Display for ResponseBody {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{} [{}] {}",
-            self.status.icon(),
-            self.status.code_as_string(),
-            self.uri
-        )?;
+        write!(f, "[{}] {}", self.status.code_as_string(), self.uri)?;
 
         if let Status::Ok(StatusCode::OK) = self.status {
             // Don't print anything else if the status code is 200.

lychee-bin/src/stats.rs

@@ -209,8 +209,8 @@ impl Status {
         }
     }
 
-    /// Return the HTTP status code (if any)
     #[must_use]
+    /// Return the HTTP status code (if any)
     pub fn code(&self) -> Option<StatusCode> {
         match self {
             Status::Ok(code)
@@ -250,9 +250,9 @@ impl Status {
                 | ErrorKind::ReadResponseBody(e)
                 | ErrorKind::BuildRequestClient(e) => match e.status() {
                     Some(code) => code.as_str().to_string(),
-                    None => "ERR".to_string(),
+                    None => "ERROR".to_string(),
                 },
-                _ => "ERR".to_string(),
+                _ => "ERROR".to_string(),
             },
             Status::Timeout(code) => match code {
                 Some(code) => code.as_str().to_string(),
@@ -263,7 +263,7 @@ impl Status {
                 CacheStatus::Ok(code) => code.to_string(),
                 CacheStatus::Error(code) => match code {
                     Some(code) => code.to_string(),
-                    None => "ERR".to_string(),
+                    None => "ERROR".to_string(),
                 },
                 CacheStatus::Excluded => "EXCLUDED".to_string(),
                 CacheStatus::Unsupported => "IGNORED".to_string(),