From 0fc32b274a9671def0ee600492ead0ea82daa195 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Tue, 1 Aug 2023 22:22:01 +0200
Subject: [PATCH 1/9] Add support for color, style, width and alignment to
 --log_format options

---
 decoder/src/log/format.rs        | 372 ++++++++++++++++++++++++++++---
 decoder/src/log/stdout_logger.rs | 217 ++++++++++++++----
 2 files changed, 516 insertions(+), 73 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 428799fa..fa7d3432 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -1,16 +1,16 @@
 use nom::{
     branch::alt,
-    bytes::complete::{take, take_till1},
-    character::complete::char,
-    combinator::{map, map_res},
-    multi::many0,
+    bytes::complete::{take_till1, take_while},
+    character::complete::{char, digit1, one_of},
+    combinator::{map, map_res, opt},
+    multi::{many0, separated_list1},
     sequence::delimited,
     IResult, Parser,
 };
 
 #[derive(Debug, PartialEq, Clone)]
 #[non_exhaustive]
-pub(super) enum LogSegment {
+pub(super) enum LogMetadata {
     FileName,
     FilePath,
     LineNumber,
@@ -21,25 +21,252 @@ pub(super) enum LogSegment {
     Timestamp,
 }
 
-fn parse_argument(input: &str) -> IResult<&str, LogSegment, ()> {
-    let parse_enclosed = delimited(char('{'), take(1u32), char('}'));
-    let mut parse_type = map_res(parse_enclosed, move |s| match s {
-        "f" => Ok(LogSegment::FileName),
-        "F" => Ok(LogSegment::FilePath),
-        "l" => Ok(LogSegment::LineNumber),
-        "s" => Ok(LogSegment::Log),
-        "L" => Ok(LogSegment::LogLevel),
-        "m" => Ok(LogSegment::ModulePath),
-        "t" => Ok(LogSegment::Timestamp),
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub(super) enum LogColor {
+    Black,
+    Red,
+    Green,
+    Yellow,
+    Blue,
+    Magenta,
+    Cyan,
+    White,
+    BrightBlack,
+    BrightRed,
+    BrightGreen,
+    BrightYellow,
+    BrightBlue,
+    BrightMagenta,
+    BrightCyan,
+    BrightWhite,
+
+    /// Color matching the default color for the log level
+    SeverityLevel,
+
+    /// Color matching the default color for the log level,
+    /// but only if the log level is WARN or ERROR
+    WarnError,
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub(super) enum LogStyle {
+    Bold,
+    Italic,
+    Underline,
+    Strikethrough,
+    Dimmed,
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub(super) enum Alignment {
+    Center,
+    Left,
+    Right,
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub(super) struct LogSegment {
+    pub(super) metadata: LogMetadata,
+    pub(super) format: LogFormat,
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub(super) struct LogFormat {
+    pub(super) width: Option<usize>,
+    pub(super) color: Option<LogColor>,
+    pub(super) style: Option<LogStyle>,
+    pub(super) alignment: Option<Alignment>,
+}
+
+#[derive(Debug, PartialEq, Clone)]
+enum IntermediateOutput {
+    Metadata(LogMetadata),
+    WidthAndAlignment((usize, Option<Alignment>)),
+    Color(LogColor),
+    Style(LogStyle),
+}
+
+impl LogSegment {
+    pub(super) const fn new(metadata: LogMetadata) -> Self {
+        Self {
+            metadata,
+            format: LogFormat {
+                color: None,
+                style: None,
+                width: None,
+                alignment: None,
+            },
+        }
+    }
+
+    #[allow(dead_code)]
+    const fn with_color(mut self, color: LogColor) -> Self {
+        self.format.color = Some(color);
+        self
+    }
+
+    #[allow(dead_code)]
+    const fn with_style(mut self, style: LogStyle) -> Self {
+        self.format.style = Some(style);
+        self
+    }
+
+    #[allow(dead_code)]
+    const fn with_width(mut self, width: usize) -> Self {
+        self.format.width = Some(width);
+        self
+    }
+
+    #[allow(dead_code)]
+    const fn with_alignment(mut self, alignment: Alignment) -> Self {
+        self.format.alignment = Some(alignment);
+        self
+    }
+}
+
+fn parse_metadata(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| match s {
+        "f" => Ok(IntermediateOutput::Metadata(LogMetadata::FileName)),
+        "F" => Ok(IntermediateOutput::Metadata(LogMetadata::FilePath)),
+        "l" => Ok(IntermediateOutput::Metadata(LogMetadata::LineNumber)),
+        "s" => Ok(IntermediateOutput::Metadata(LogMetadata::Log)),
+        "L" => Ok(IntermediateOutput::Metadata(LogMetadata::LogLevel)),
+        "m" => Ok(IntermediateOutput::Metadata(LogMetadata::ModulePath)),
+        "t" => Ok(IntermediateOutput::Metadata(LogMetadata::Timestamp)),
         _ => Err(()),
     });
 
     parse_type.parse(input)
 }
 
+fn parse_color(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| match s {
+        "black" => Ok(IntermediateOutput::Color(LogColor::Black)),
+        "red" => Ok(IntermediateOutput::Color(LogColor::Red)),
+        "green" => Ok(IntermediateOutput::Color(LogColor::Green)),
+        "yellow" => Ok(IntermediateOutput::Color(LogColor::Yellow)),
+        "blue" => Ok(IntermediateOutput::Color(LogColor::Blue)),
+        "magenta" => Ok(IntermediateOutput::Color(LogColor::Magenta)),
+        "cyan" => Ok(IntermediateOutput::Color(LogColor::Cyan)),
+        "white" => Ok(IntermediateOutput::Color(LogColor::White)),
+        "brightblack" => Ok(IntermediateOutput::Color(LogColor::BrightBlack)),
+        "brightred" => Ok(IntermediateOutput::Color(LogColor::BrightRed)),
+        "brightgreen" => Ok(IntermediateOutput::Color(LogColor::BrightGreen)),
+        "brightyellow" => Ok(IntermediateOutput::Color(LogColor::BrightYellow)),
+        "brightblue" => Ok(IntermediateOutput::Color(LogColor::BrightBlue)),
+        "brightmagenta" => Ok(IntermediateOutput::Color(LogColor::BrightMagenta)),
+        "brightcyan" => Ok(IntermediateOutput::Color(LogColor::BrightCyan)),
+        "brightwhite" => Ok(IntermediateOutput::Color(LogColor::BrightWhite)),
+        "severity" => Ok(IntermediateOutput::Color(LogColor::SeverityLevel)),
+        "werror" => Ok(IntermediateOutput::Color(LogColor::WarnError)),
+        _ => Err(()),
+    });
+
+    parse_type.parse(input)
+}
+
+fn parse_style(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| match s {
+        "bold" => Ok(IntermediateOutput::Style(LogStyle::Bold)),
+        "italic" => Ok(IntermediateOutput::Style(LogStyle::Italic)),
+        "underline" => Ok(IntermediateOutput::Style(LogStyle::Underline)),
+        "strike" => Ok(IntermediateOutput::Style(LogStyle::Strikethrough)),
+        "dimmed" => Ok(IntermediateOutput::Style(LogStyle::Dimmed)),
+        _ => Err(()),
+    });
+
+    parse_type.parse(input)
+}
+
+fn parse_width_and_alignment(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    let (input, alignment) = opt(map_res(one_of("<^>"), move |c| match c {
+        '^' => Ok(Alignment::Center),
+        '<' => Ok(Alignment::Left),
+        '>' => Ok(Alignment::Right),
+        _ => Err(()),
+    }))(input)?;
+
+    let (input, width) = map_res(digit1, move |s: &str| s.parse::<usize>())(input)?;
+
+    Ok((
+        input,
+        IntermediateOutput::WidthAndAlignment((width, alignment)),
+    ))
+}
+
+fn parse_log_segment(input: &str) -> IResult<&str, LogSegment, ()> {
+    let (input, output) = separated_list1(
+        char(':'),
+        alt((
+            parse_metadata,
+            parse_color,
+            parse_style,
+            parse_width_and_alignment,
+        )),
+    )(input)?;
+
+    let mut metadata = None;
+    let mut color = None;
+    let mut style = None;
+    let mut width_and_alignment = None;
+    for item in output {
+        match item {
+            IntermediateOutput::Metadata(m) => {
+                if metadata.is_some() {
+                    return Err(nom::Err::Error(()));
+                }
+                metadata = Some(m);
+            }
+            IntermediateOutput::Color(c) => {
+                if color.is_some() {
+                    return Err(nom::Err::Error(()));
+                }
+                color = Some(c);
+            }
+            IntermediateOutput::Style(s) => {
+                if style.is_some() {
+                    return Err(nom::Err::Error(()));
+                }
+                style = Some(s);
+            }
+            IntermediateOutput::WidthAndAlignment(w) => {
+                if width_and_alignment.is_some() {
+                    return Err(nom::Err::Error(()));
+                }
+                width_and_alignment = Some(w);
+            }
+        }
+    }
+
+    let Some(metadata) = metadata else {
+        return Err(nom::Err::Error(()));
+    };
+
+    let (width, alignment) = width_and_alignment
+        .map(|(w, a)| (Some(w), a))
+        .unwrap_or((None, None));
+
+    let log_segment = LogSegment {
+        metadata,
+        format: LogFormat {
+            color,
+            style,
+            width,
+            alignment,
+        },
+    };
+
+    Ok((input, log_segment))
+}
+
+fn parse_argument(input: &str) -> IResult<&str, LogSegment, ()> {
+    let mut parse_enclosed = delimited(char('{'), parse_log_segment, char('}'));
+    parse_enclosed.parse(input)
+}
+
 fn parse_string_segment(input: &str) -> IResult<&str, LogSegment, ()> {
     map(take_till1(|c| c == '{'), |s: &str| {
-        LogSegment::String(s.to_string())
+        LogSegment::new(LogMetadata::String(s.to_string()))
     })
     .parse(input)
 }
@@ -61,17 +288,17 @@ mod tests {
         let log_template = "{t} [{L}] {s}\n└─ {m} @ {F}:{l}";
 
         let expected_output = vec![
-            LogSegment::Timestamp,
-            LogSegment::String(" [".to_string()),
-            LogSegment::LogLevel,
-            LogSegment::String("] ".to_string()),
-            LogSegment::Log,
-            LogSegment::String("\n└─ ".to_string()),
-            LogSegment::ModulePath,
-            LogSegment::String(" @ ".to_string()),
-            LogSegment::FilePath,
-            LogSegment::String(":".to_string()),
-            LogSegment::LineNumber,
+            LogSegment::new(LogMetadata::Timestamp),
+            LogSegment::new(LogMetadata::String(" [".to_string())),
+            LogSegment::new(LogMetadata::LogLevel),
+            LogSegment::new(LogMetadata::String("] ".to_string())),
+            LogSegment::new(LogMetadata::Log),
+            LogSegment::new(LogMetadata::String("\n└─ ".to_string())),
+            LogSegment::new(LogMetadata::ModulePath),
+            LogSegment::new(LogMetadata::String(" @ ".to_string())),
+            LogSegment::new(LogMetadata::FilePath),
+            LogSegment::new(LogMetadata::String(":".to_string())),
+            LogSegment::new(LogMetadata::LineNumber),
         ];
 
         let result = parse(log_template);
@@ -83,7 +310,10 @@ mod tests {
         let result = parse_string_segment("Log: {t}");
         let (input, output) = result.unwrap();
         assert_eq!(input, "{t}");
-        assert_eq!(output, LogSegment::String("Log: ".to_string()));
+        assert_eq!(
+            output,
+            LogSegment::new(LogMetadata::String("Log: ".to_string()))
+        );
     }
 
     #[test]
@@ -95,7 +325,35 @@ mod tests {
     #[test]
     fn test_parse_timestamp_argument() {
         let result = parse_argument("{t}");
-        assert_eq!(result, Ok(("", LogSegment::Timestamp)));
+        assert_eq!(result, Ok(("", LogSegment::new(LogMetadata::Timestamp))));
+    }
+
+    #[test]
+    fn test_parse_argument_with_color() {
+        let result = parse_log_segment("t:werror");
+        let expected_output =
+            LogSegment::new(LogMetadata::Timestamp).with_color(LogColor::WarnError);
+        assert_eq!(result, Ok(("", expected_output)));
+    }
+
+    #[test]
+    fn test_parse_argument_with_extra_format_parameters_width_first() {
+        let result = parse_argument("{t:>8:white}");
+        let expected_output = LogSegment::new(LogMetadata::Timestamp)
+            .with_width(8)
+            .with_alignment(Alignment::Right)
+            .with_color(LogColor::White);
+        assert_eq!(result, Ok(("", expected_output)));
+    }
+
+    #[test]
+    fn test_parse_argument_with_extra_format_parameters_color_first() {
+        let result = parse_argument("{f:werror:<25}");
+        let expected_output = LogSegment::new(LogMetadata::FileName)
+            .with_width(25)
+            .with_alignment(Alignment::Left)
+            .with_color(LogColor::WarnError);
+        assert_eq!(result, Ok(("", expected_output)));
     }
 
     #[test]
@@ -103,4 +361,60 @@ mod tests {
         let result = parse_argument("{foo}");
         assert_eq!(result, Result::Err(nom::Err::Error(())));
     }
+
+    #[test]
+    fn test_parse_width_no_alignment() {
+        let result = parse_width_and_alignment("12");
+        assert_eq!(
+            result,
+            Ok(("", IntermediateOutput::WidthAndAlignment((12, None))))
+        );
+    }
+
+    #[test]
+    fn test_parse_width_and_alignment() {
+        let result = parse_width_and_alignment(">12");
+        assert_eq!(
+            result,
+            Ok((
+                "",
+                IntermediateOutput::WidthAndAlignment((12, Some(Alignment::Right)))
+            ))
+        );
+    }
+
+    #[test]
+    fn test_parse_color() {
+        let result = parse_color("blue");
+        assert_eq!(result, Ok(("", IntermediateOutput::Color(LogColor::Blue))));
+    }
+
+    #[test]
+    fn test_parse_log_template_with_color_style_width_and_alignment() {
+        let log_template = "T{t:>8} [{L:severity:bold}] {f:white:underline}:{l:white:3} {s:werror}";
+
+        let expected_output = vec![
+            LogSegment::new(LogMetadata::String("T".to_string())),
+            LogSegment::new(LogMetadata::Timestamp)
+                .with_width(8)
+                .with_alignment(Alignment::Right),
+            LogSegment::new(LogMetadata::String(" [".to_string())),
+            LogSegment::new(LogMetadata::LogLevel)
+                .with_color(LogColor::SeverityLevel)
+                .with_style(LogStyle::Bold),
+            LogSegment::new(LogMetadata::String("] ".to_string())),
+            LogSegment::new(LogMetadata::FileName)
+                .with_color(LogColor::White)
+                .with_style(LogStyle::Underline),
+            LogSegment::new(LogMetadata::String(":".to_string())),
+            LogSegment::new(LogMetadata::LineNumber)
+                .with_color(LogColor::White)
+                .with_width(3),
+            LogSegment::new(LogMetadata::String(" ".to_string())),
+            LogSegment::new(LogMetadata::Log).with_color(LogColor::WarnError),
+        ];
+
+        let result = parse(log_template);
+        assert_eq!(result, Ok(expected_output));
+    }
 }
diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index d87a6a82..368f6cd9 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -10,7 +10,7 @@ use std::{
 };
 
 use super::{
-    format::{self, LogSegment},
+    format::{self, Alignment, LogColor, LogFormat, LogMetadata, LogSegment, LogStyle},
     DefmtLoggerInfo, DefmtRecord,
 };
 
@@ -91,7 +91,10 @@ impl StdoutLogger {
     }
 
     pub fn info(&self) -> DefmtLoggerInfo {
-        let has_timestamp = self.log_format.contains(&LogSegment::Timestamp);
+        let has_timestamp = self
+            .log_format
+            .iter()
+            .any(|s| s.metadata == LogMetadata::Timestamp);
         DefmtLoggerInfo { has_timestamp }
     }
 
@@ -111,7 +114,7 @@ impl StdoutLogger {
         record: DefmtRecord,
         mut sink: StdoutLock,
     ) {
-        const RAW_FORMAT: &[LogSegment] = &[LogSegment::Log];
+        const RAW_FORMAT: &[LogSegment] = &[LogSegment::new(LogMetadata::Log)];
         Printer::new(Record::Defmt(&record), RAW_FORMAT)
             .print_frame(&mut sink)
             .ok();
@@ -151,15 +154,15 @@ impl<'a> Printer<'a> {
     /// Prints the formatted log frame to `sink`.
     pub fn print_frame<W: io::Write>(&self, sink: &mut W) -> io::Result<()> {
         for segment in self.format {
-            match segment {
-                LogSegment::String(s) => self.print_string(sink, s),
-                LogSegment::Timestamp => self.print_timestamp(sink),
-                LogSegment::FileName => self.print_file_name(sink),
-                LogSegment::FilePath => self.print_file_path(sink),
-                LogSegment::ModulePath => self.print_module_path(sink),
-                LogSegment::LineNumber => self.print_line_number(sink),
-                LogSegment::LogLevel => self.print_log_level(sink),
-                LogSegment::Log => self.print_log(sink),
+            match &segment.metadata {
+                LogMetadata::String(s) => self.print_string(sink, s),
+                LogMetadata::Timestamp => self.print_timestamp(sink, &segment.format),
+                LogMetadata::FileName => self.print_file_name(sink, &segment.format),
+                LogMetadata::FilePath => self.print_file_path(sink, &segment.format),
+                LogMetadata::ModulePath => self.print_module_path(sink, &segment.format),
+                LogMetadata::LineNumber => self.print_line_number(sink, &segment.format),
+                LogMetadata::LogLevel => self.print_log_level(sink, &segment.format),
+                LogMetadata::Log => self.print_log(sink, &segment.format),
             }?;
         }
         writeln!(sink)
@@ -169,7 +172,7 @@ impl<'a> Printer<'a> {
         write!(sink, "{s}")
     }
 
-    fn print_timestamp<W: io::Write>(&self, sink: &mut W) -> io::Result<()> {
+    fn print_timestamp<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
         let timestamp = match self.record {
             Record::Defmt(record) => {
                 if record.timestamp().is_empty() {
@@ -181,36 +184,48 @@ impl<'a> Printer<'a> {
             Record::Host(_) => String::from("<time>"),
         };
 
-        write!(sink, "{timestamp:>0$}", self.min_timestamp_width,)
-    }
+        let timestamp = ColoredString::from(timestamp.as_str());
+        let timestamp = apply_color(timestamp, format.color, self.record_log_level());
+        let timestamp = apply_style(timestamp, format.style);
+        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let width = format.width.unwrap_or(self.min_timestamp_width);
 
-    fn print_log_level<W: io::Write>(&self, sink: &mut W) -> io::Result<()> {
-        let level = match self.record {
-            Record::Defmt(record) => record.level(),
-            Record::Host(record) => Some(record.level()),
-        };
+        write_string(timestamp, sink, width, alignment)
+    }
 
-        let level = if let Some(level) = level {
-            // TODO: Should the color be customizable via the format too?
-            level.to_string().color(color_for_log_level(level))
+    fn print_log_level<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
+        let level = if let Some(level) = self.record_log_level() {
+            level.to_string()
         } else {
-            ColoredString::from("<lvl>")
+            String::from("<lvl>")
         };
 
-        write!(sink, "{level:5}")
+        let level = ColoredString::from(level.as_str());
+        let level = apply_color(level, format.color, self.record_log_level());
+        let level = apply_style(level, format.style);
+        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let width = format.width.unwrap_or(5);
+
+        write_string(level, sink, width, alignment)
     }
 
-    fn print_file_path<W: io::Write>(&self, sink: &mut W) -> io::Result<()> {
+    fn print_file_path<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
         let file_path = match self.record {
             Record::Defmt(record) => record.file(),
             Record::Host(record) => record.file(),
         }
         .unwrap_or("<file>");
 
-        write!(sink, "{file_path}")
+        let file_path = ColoredString::from(file_path);
+        let file_path = apply_color(file_path, format.color, self.record_log_level());
+        let file_path = apply_style(file_path, format.style);
+        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let width = format.width.unwrap_or(0);
+
+        write_string(file_path, sink, width, alignment)
     }
 
-    fn print_file_name<W: io::Write>(&self, sink: &mut W) -> io::Result<()> {
+    fn print_file_name<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
         let file = match self.record {
             Record::Defmt(record) => record.file(),
             Record::Host(record) => record.file(),
@@ -227,43 +242,80 @@ impl<'a> Printer<'a> {
             "<file>"
         };
 
-        write!(sink, "{file_name}")
+        let file_name = ColoredString::from(file_name);
+        let file_name = apply_color(file_name, format.color, self.record_log_level());
+        let file_name = apply_style(file_name, format.style);
+        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let width = format.width.unwrap_or(0);
+
+        write_string(file_name, sink, width, alignment)
     }
 
-    fn print_module_path<W: io::Write>(&self, sink: &mut W) -> io::Result<()> {
+    fn print_module_path<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
         let module_path = match self.record {
             Record::Defmt(record) => record.module_path(),
             Record::Host(record) => record.module_path(),
         }
         .unwrap_or("<mod path>");
 
-        write!(sink, "{module_path}")
+        let module_path = ColoredString::from(module_path);
+        let module_path = apply_color(module_path, format.color, self.record_log_level());
+        let module_path = apply_style(module_path, format.style);
+        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let width = format.width.unwrap_or(0);
+
+        write_string(module_path, sink, width, alignment)
     }
 
-    fn print_line_number<W: io::Write>(&self, sink: &mut W) -> io::Result<()> {
+    fn print_line_number<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
         let line_number = match self.record {
             Record::Defmt(record) => record.line(),
             Record::Host(record) => record.line(),
         }
-        .unwrap_or(0);
+        .unwrap_or(0)
+        .to_string();
+
+        let line_number = ColoredString::from(line_number.as_str());
+        let line_number = apply_color(line_number, format.color, self.record_log_level());
+        let line_number = apply_style(line_number, format.style);
+        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let width = format.width.unwrap_or(4);
 
-        write!(sink, "{line_number}")
+        write_string(line_number, sink, width, alignment)
     }
 
-    fn print_log<W: io::Write>(&self, sink: &mut W) -> io::Result<()> {
-        let log = match self.record {
-            Record::Defmt(record) => color_diff(record.args().to_string()),
-            Record::Host(record) => record.args().to_string(),
-        };
+    fn print_log<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
+        match self.record {
+            Record::Defmt(record) => match color_diff(record.args().to_string()) {
+                Ok(s) => write!(sink, "{s}"),
+                Err(s) => {
+                    let log = ColoredString::from(s.as_str());
+                    let log = apply_color(log, format.color, self.record_log_level());
+                    let log = apply_style(log, format.style);
+                    let alignment = format.alignment.unwrap_or(Alignment::Left);
+                    let width = format.width.unwrap_or(0);
+                    write_string(log, sink, width, alignment)
+                }
+            },
+            Record::Host(record) => {
+                let s = record.args().to_string();
+                write!(sink, "{s}")
+            }
+        }
+    }
 
-        write!(sink, "{log}")
+    fn record_log_level(&self) -> Option<Level> {
+        match self.record {
+            Record::Defmt(record) => record.level(),
+            Record::Host(record) => Some(record.level()),
+        }
     }
 }
 
 // color the output of `defmt::assert_eq`
 // HACK we should not re-parse formatted output but instead directly format into a color diff
 // template; that may require specially tagging log messages that come from `defmt::assert_eq`
-fn color_diff(text: String) -> String {
+fn color_diff(text: String) -> Result<String, String> {
     let lines = text.lines().collect::<Vec<_>>();
     let nlines = lines.len();
     if nlines > 2 {
@@ -321,12 +373,11 @@ fn color_diff(text: String) -> String {
                     }
                 }
             }
-            return buf;
+            return Ok(buf);
         }
     }
 
-    // keep output as it is
-    text.bold().to_string()
+    Err(text)
 }
 
 fn color_for_log_level(level: Level) -> Color {
@@ -338,3 +389,81 @@ fn color_for_log_level(level: Level) -> Color {
         Level::Trace => Color::BrightBlack,
     }
 }
+
+fn apply_color(
+    s: ColoredString,
+    log_color: Option<LogColor>,
+    level: Option<Level>,
+) -> ColoredString {
+    if let Some(log_color) = log_color {
+        match log_color {
+            LogColor::Black => s.black(),
+            LogColor::Red => s.red(),
+            LogColor::Green => s.green(),
+            LogColor::Yellow => s.yellow(),
+            LogColor::Blue => s.blue(),
+            LogColor::Magenta => s.magenta(),
+            LogColor::Cyan => s.cyan(),
+            LogColor::White => s.white(),
+            LogColor::BrightBlack => s.bright_black(),
+            LogColor::BrightRed => s.bright_red(),
+            LogColor::BrightGreen => s.bright_green(),
+            LogColor::BrightYellow => s.bright_yellow(),
+            LogColor::BrightBlue => s.bright_blue(),
+            LogColor::BrightMagenta => s.bright_magenta(),
+            LogColor::BrightCyan => s.bright_cyan(),
+            LogColor::BrightWhite => s.bright_white(),
+            LogColor::SeverityLevel => {
+                if let Some(level) = level {
+                    let color = color_for_log_level(level);
+                    s.color(color)
+                } else {
+                    s
+                }
+            }
+            LogColor::WarnError => {
+                if level.is_some_and(|l| l == Level::Warn || l == Level::Error) {
+                    let color = color_for_log_level(level.unwrap());
+                    s.color(color)
+                } else {
+                    s
+                }
+            }
+        }
+    } else {
+        s
+    }
+}
+
+fn apply_style(s: ColoredString, log_style: Option<LogStyle>) -> ColoredString {
+    if let Some(log_style) = log_style {
+        match log_style {
+            LogStyle::Bold => s.bold(),
+            LogStyle::Italic => s.italic(),
+            LogStyle::Underline => s.underline(),
+            LogStyle::Strikethrough => s.strikethrough(),
+            LogStyle::Dimmed => s.dimmed(),
+        }
+    } else {
+        s
+    }
+}
+
+fn write_string<W: io::Write>(
+    s: ColoredString,
+    sink: &mut W,
+    width: usize,
+    alignment: Alignment,
+) -> io::Result<()> {
+    match alignment {
+        Alignment::Left => {
+            write!(sink, "{s:<0$}", width)
+        }
+        Alignment::Center => {
+            write!(sink, "{s:^0$}", width)
+        }
+        Alignment::Right => {
+            write!(sink, "{s:>0$}", width)
+        }
+    }
+}

From 8a2d6256d10a9eb0091344a12cf5b2db0f5fdd76 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Tue, 1 Aug 2023 22:46:26 +0200
Subject: [PATCH 2/9] Use `LogColor::SeverityLevel` as default color for
 LogLevel

---
 decoder/src/log/stdout_logger.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index 368f6cd9..05078f29 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -200,8 +200,10 @@ impl<'a> Printer<'a> {
             String::from("<lvl>")
         };
 
+        let color = format.color.unwrap_or(LogColor::SeverityLevel);
+
         let level = ColoredString::from(level.as_str());
-        let level = apply_color(level, format.color, self.record_log_level());
+        let level = apply_color(level, Some(color), self.record_log_level());
         let level = apply_style(level, format.style);
         let alignment = format.alignment.unwrap_or(Alignment::Left);
         let width = format.width.unwrap_or(5);

From 0e317e7d592aa13f3e1db90e675a5ab88be3811e Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Tue, 1 Aug 2023 22:54:05 +0200
Subject: [PATCH 3/9] Update CHANGELOG.md

---
 CHANGELOG.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 89c9082c..be848eb7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- [#769]: `defmt-decoder`: Add support for color, style, width and alignment to format
+
+[#769]: https://github.com/knurling-rs/defmt/pull/769
+
 ## defmt-decoder v0.3.8, defmt-print v0.3.8 - 2023-08-01
 
 - [#766] `decoder::log`: Rename `PrettyLogger` to `StdoutLogger`

From 9b7fad43770eb441c73a12dc20b4ef796443a6d9 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Wed, 2 Aug 2023 20:31:55 +0200
Subject: [PATCH 4/9] Remove color and style duplication from colored crate

---
 decoder/src/log/format.rs        | 81 ++++++++++----------------------
 decoder/src/log/stdout_logger.rs | 37 +++++----------
 2 files changed, 38 insertions(+), 80 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index fa7d3432..36db29e8 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -8,6 +8,8 @@ use nom::{
     IResult, Parser,
 };
 
+use std::str::FromStr;
+
 #[derive(Debug, PartialEq, Clone)]
 #[non_exhaustive]
 pub(super) enum LogMetadata {
@@ -23,22 +25,8 @@ pub(super) enum LogMetadata {
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub(super) enum LogColor {
-    Black,
-    Red,
-    Green,
-    Yellow,
-    Blue,
-    Magenta,
-    Cyan,
-    White,
-    BrightBlack,
-    BrightRed,
-    BrightGreen,
-    BrightYellow,
-    BrightBlue,
-    BrightMagenta,
-    BrightCyan,
-    BrightWhite,
+    /// User-defined color
+    Color(colored::Color),
 
     /// Color matching the default color for the log level
     SeverityLevel,
@@ -48,15 +36,6 @@ pub(super) enum LogColor {
     WarnError,
 }
 
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub(super) enum LogStyle {
-    Bold,
-    Italic,
-    Underline,
-    Strikethrough,
-    Dimmed,
-}
-
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub(super) enum Alignment {
     Center,
@@ -74,7 +53,7 @@ pub(super) struct LogSegment {
 pub(super) struct LogFormat {
     pub(super) width: Option<usize>,
     pub(super) color: Option<LogColor>,
-    pub(super) style: Option<LogStyle>,
+    pub(super) style: Option<colored::Styles>,
     pub(super) alignment: Option<Alignment>,
 }
 
@@ -83,7 +62,7 @@ enum IntermediateOutput {
     Metadata(LogMetadata),
     WidthAndAlignment((usize, Option<Alignment>)),
     Color(LogColor),
-    Style(LogStyle),
+    Style(colored::Styles),
 }
 
 impl LogSegment {
@@ -106,7 +85,7 @@ impl LogSegment {
     }
 
     #[allow(dead_code)]
-    const fn with_style(mut self, style: LogStyle) -> Self {
+    const fn with_style(mut self, style: colored::Styles) -> Self {
         self.format.style = Some(style);
         self
     }
@@ -141,25 +120,9 @@ fn parse_metadata(input: &str) -> IResult<&str, IntermediateOutput, ()> {
 
 fn parse_color(input: &str) -> IResult<&str, IntermediateOutput, ()> {
     let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| match s {
-        "black" => Ok(IntermediateOutput::Color(LogColor::Black)),
-        "red" => Ok(IntermediateOutput::Color(LogColor::Red)),
-        "green" => Ok(IntermediateOutput::Color(LogColor::Green)),
-        "yellow" => Ok(IntermediateOutput::Color(LogColor::Yellow)),
-        "blue" => Ok(IntermediateOutput::Color(LogColor::Blue)),
-        "magenta" => Ok(IntermediateOutput::Color(LogColor::Magenta)),
-        "cyan" => Ok(IntermediateOutput::Color(LogColor::Cyan)),
-        "white" => Ok(IntermediateOutput::Color(LogColor::White)),
-        "brightblack" => Ok(IntermediateOutput::Color(LogColor::BrightBlack)),
-        "brightred" => Ok(IntermediateOutput::Color(LogColor::BrightRed)),
-        "brightgreen" => Ok(IntermediateOutput::Color(LogColor::BrightGreen)),
-        "brightyellow" => Ok(IntermediateOutput::Color(LogColor::BrightYellow)),
-        "brightblue" => Ok(IntermediateOutput::Color(LogColor::BrightBlue)),
-        "brightmagenta" => Ok(IntermediateOutput::Color(LogColor::BrightMagenta)),
-        "brightcyan" => Ok(IntermediateOutput::Color(LogColor::BrightCyan)),
-        "brightwhite" => Ok(IntermediateOutput::Color(LogColor::BrightWhite)),
         "severity" => Ok(IntermediateOutput::Color(LogColor::SeverityLevel)),
         "werror" => Ok(IntermediateOutput::Color(LogColor::WarnError)),
-        _ => Err(()),
+        s => colored::Color::from_str(s).map(|c| IntermediateOutput::Color(LogColor::Color(c))),
     });
 
     parse_type.parse(input)
@@ -167,11 +130,11 @@ fn parse_color(input: &str) -> IResult<&str, IntermediateOutput, ()> {
 
 fn parse_style(input: &str) -> IResult<&str, IntermediateOutput, ()> {
     let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| match s {
-        "bold" => Ok(IntermediateOutput::Style(LogStyle::Bold)),
-        "italic" => Ok(IntermediateOutput::Style(LogStyle::Italic)),
-        "underline" => Ok(IntermediateOutput::Style(LogStyle::Underline)),
-        "strike" => Ok(IntermediateOutput::Style(LogStyle::Strikethrough)),
-        "dimmed" => Ok(IntermediateOutput::Style(LogStyle::Dimmed)),
+        "bold" => Ok(IntermediateOutput::Style(colored::Styles::Bold)),
+        "italic" => Ok(IntermediateOutput::Style(colored::Styles::Italic)),
+        "underline" => Ok(IntermediateOutput::Style(colored::Styles::Underline)),
+        "strike" => Ok(IntermediateOutput::Style(colored::Styles::Strikethrough)),
+        "dimmed" => Ok(IntermediateOutput::Style(colored::Styles::Dimmed)),
         _ => Err(()),
     });
 
@@ -342,7 +305,7 @@ mod tests {
         let expected_output = LogSegment::new(LogMetadata::Timestamp)
             .with_width(8)
             .with_alignment(Alignment::Right)
-            .with_color(LogColor::White);
+            .with_color(LogColor::Color(colored::Color::White));
         assert_eq!(result, Ok(("", expected_output)));
     }
 
@@ -386,7 +349,13 @@ mod tests {
     #[test]
     fn test_parse_color() {
         let result = parse_color("blue");
-        assert_eq!(result, Ok(("", IntermediateOutput::Color(LogColor::Blue))));
+        assert_eq!(
+            result,
+            Ok((
+                "",
+                IntermediateOutput::Color(LogColor::Color(colored::Color::Blue))
+            ))
+        );
     }
 
     #[test]
@@ -401,14 +370,14 @@ mod tests {
             LogSegment::new(LogMetadata::String(" [".to_string())),
             LogSegment::new(LogMetadata::LogLevel)
                 .with_color(LogColor::SeverityLevel)
-                .with_style(LogStyle::Bold),
+                .with_style(colored::Styles::Bold),
             LogSegment::new(LogMetadata::String("] ".to_string())),
             LogSegment::new(LogMetadata::FileName)
-                .with_color(LogColor::White)
-                .with_style(LogStyle::Underline),
+                .with_color(LogColor::Color(colored::Color::White))
+                .with_style(colored::Styles::Underline),
             LogSegment::new(LogMetadata::String(":".to_string())),
             LogSegment::new(LogMetadata::LineNumber)
-                .with_color(LogColor::White)
+                .with_color(LogColor::Color(colored::Color::White))
                 .with_width(3),
             LogSegment::new(LogMetadata::String(" ".to_string())),
             LogSegment::new(LogMetadata::Log).with_color(LogColor::WarnError),
diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index 05078f29..59e0ed76 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -1,4 +1,4 @@
-use colored::{Color, ColoredString, Colorize};
+use colored::{Color, ColoredString, Colorize, Styles};
 use dissimilar::Chunk;
 use log::{Level, Log, Metadata, Record as LogRecord};
 
@@ -10,7 +10,7 @@ use std::{
 };
 
 use super::{
-    format::{self, Alignment, LogColor, LogFormat, LogMetadata, LogSegment, LogStyle},
+    format::{self, Alignment, LogColor, LogFormat, LogMetadata, LogSegment},
     DefmtLoggerInfo, DefmtRecord,
 };
 
@@ -399,22 +399,7 @@ fn apply_color(
 ) -> ColoredString {
     if let Some(log_color) = log_color {
         match log_color {
-            LogColor::Black => s.black(),
-            LogColor::Red => s.red(),
-            LogColor::Green => s.green(),
-            LogColor::Yellow => s.yellow(),
-            LogColor::Blue => s.blue(),
-            LogColor::Magenta => s.magenta(),
-            LogColor::Cyan => s.cyan(),
-            LogColor::White => s.white(),
-            LogColor::BrightBlack => s.bright_black(),
-            LogColor::BrightRed => s.bright_red(),
-            LogColor::BrightGreen => s.bright_green(),
-            LogColor::BrightYellow => s.bright_yellow(),
-            LogColor::BrightBlue => s.bright_blue(),
-            LogColor::BrightMagenta => s.bright_magenta(),
-            LogColor::BrightCyan => s.bright_cyan(),
-            LogColor::BrightWhite => s.bright_white(),
+            LogColor::Color(color) => s.color(color),
             LogColor::SeverityLevel => {
                 if let Some(level) = level {
                     let color = color_for_log_level(level);
@@ -437,14 +422,18 @@ fn apply_color(
     }
 }
 
-fn apply_style(s: ColoredString, log_style: Option<LogStyle>) -> ColoredString {
+fn apply_style(s: ColoredString, log_style: Option<Styles>) -> ColoredString {
     if let Some(log_style) = log_style {
         match log_style {
-            LogStyle::Bold => s.bold(),
-            LogStyle::Italic => s.italic(),
-            LogStyle::Underline => s.underline(),
-            LogStyle::Strikethrough => s.strikethrough(),
-            LogStyle::Dimmed => s.dimmed(),
+            Styles::Bold => s.bold(),
+            Styles::Italic => s.italic(),
+            Styles::Underline => s.underline(),
+            Styles::Strikethrough => s.strikethrough(),
+            Styles::Dimmed => s.dimmed(),
+            Styles::Clear => s.clear(),
+            Styles::Reversed => s.reversed(),
+            Styles::Blink => s.blink(),
+            Styles::Hidden => s.hidden(),
         }
     } else {
         s

From 8fc2db2746c2c90f02f5448eda15ee7146c0b775 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Thu, 3 Aug 2023 23:47:53 +0200
Subject: [PATCH 5/9] Apply code review suggestions

---
 decoder/src/log/format.rs        | 89 +++++++++++++++-----------------
 decoder/src/log/stdout_logger.rs | 56 +++++++-------------
 2 files changed, 62 insertions(+), 83 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 36db29e8..d77f873a 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -78,25 +78,25 @@ impl LogSegment {
         }
     }
 
-    #[allow(dead_code)]
+    #[cfg(test)]
     const fn with_color(mut self, color: LogColor) -> Self {
         self.format.color = Some(color);
         self
     }
 
-    #[allow(dead_code)]
+    #[cfg(test)]
     const fn with_style(mut self, style: colored::Styles) -> Self {
         self.format.style = Some(style);
         self
     }
 
-    #[allow(dead_code)]
+    #[cfg(test)]
     const fn with_width(mut self, width: usize) -> Self {
         self.format.width = Some(width);
         self
     }
 
-    #[allow(dead_code)]
+    #[cfg(test)]
     const fn with_alignment(mut self, alignment: Alignment) -> Self {
         self.format.alignment = Some(alignment);
         self
@@ -104,38 +104,50 @@ impl LogSegment {
 }
 
 fn parse_metadata(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| match s {
-        "f" => Ok(IntermediateOutput::Metadata(LogMetadata::FileName)),
-        "F" => Ok(IntermediateOutput::Metadata(LogMetadata::FilePath)),
-        "l" => Ok(IntermediateOutput::Metadata(LogMetadata::LineNumber)),
-        "s" => Ok(IntermediateOutput::Metadata(LogMetadata::Log)),
-        "L" => Ok(IntermediateOutput::Metadata(LogMetadata::LogLevel)),
-        "m" => Ok(IntermediateOutput::Metadata(LogMetadata::ModulePath)),
-        "t" => Ok(IntermediateOutput::Metadata(LogMetadata::Timestamp)),
-        _ => Err(()),
+    let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| {
+        let metadata = match s {
+            "f" => LogMetadata::FileName,
+            "F" => LogMetadata::FilePath,
+            "l" => LogMetadata::LineNumber,
+            "s" => LogMetadata::Log,
+            "L" => LogMetadata::LogLevel,
+            "m" => LogMetadata::ModulePath,
+            "t" => LogMetadata::Timestamp,
+            _ => return Err(()),
+        };
+        Ok(IntermediateOutput::Metadata(metadata))
     });
 
     parse_type.parse(input)
 }
 
 fn parse_color(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| match s {
-        "severity" => Ok(IntermediateOutput::Color(LogColor::SeverityLevel)),
-        "werror" => Ok(IntermediateOutput::Color(LogColor::WarnError)),
-        s => colored::Color::from_str(s).map(|c| IntermediateOutput::Color(LogColor::Color(c))),
+    let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| {
+        let color = match s {
+            "severity" => LogColor::SeverityLevel,
+            "werror" => LogColor::WarnError,
+            s => match colored::Color::from_str(s) {
+                Ok(c) => LogColor::Color(c),
+                Err(()) => return Err(()),
+            },
+        };
+        Ok(IntermediateOutput::Color(color))
     });
 
     parse_type.parse(input)
 }
 
 fn parse_style(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| match s {
-        "bold" => Ok(IntermediateOutput::Style(colored::Styles::Bold)),
-        "italic" => Ok(IntermediateOutput::Style(colored::Styles::Italic)),
-        "underline" => Ok(IntermediateOutput::Style(colored::Styles::Underline)),
-        "strike" => Ok(IntermediateOutput::Style(colored::Styles::Strikethrough)),
-        "dimmed" => Ok(IntermediateOutput::Style(colored::Styles::Dimmed)),
-        _ => Err(()),
+    let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| {
+        let style = match s {
+            "bold" => colored::Styles::Bold,
+            "italic" => colored::Styles::Italic,
+            "underline" => colored::Styles::Underline,
+            "strike" => colored::Styles::Strikethrough,
+            "dimmed" => colored::Styles::Dimmed,
+            _ => return Err(()),
+        };
+        Ok(IntermediateOutput::Style(style))
     });
 
     parse_type.parse(input)
@@ -174,30 +186,13 @@ fn parse_log_segment(input: &str) -> IResult<&str, LogSegment, ()> {
     let mut width_and_alignment = None;
     for item in output {
         match item {
-            IntermediateOutput::Metadata(m) => {
-                if metadata.is_some() {
-                    return Err(nom::Err::Error(()));
-                }
-                metadata = Some(m);
-            }
-            IntermediateOutput::Color(c) => {
-                if color.is_some() {
-                    return Err(nom::Err::Error(()));
-                }
-                color = Some(c);
-            }
-            IntermediateOutput::Style(s) => {
-                if style.is_some() {
-                    return Err(nom::Err::Error(()));
-                }
-                style = Some(s);
-            }
-            IntermediateOutput::WidthAndAlignment(w) => {
-                if width_and_alignment.is_some() {
-                    return Err(nom::Err::Error(()));
-                }
-                width_and_alignment = Some(w);
+            IntermediateOutput::Metadata(m) if metadata.is_none() => metadata = Some(m),
+            IntermediateOutput::Color(c) if color.is_none() => color = Some(c),
+            IntermediateOutput::Style(s) if style.is_none() => style = Some(s),
+            IntermediateOutput::WidthAndAlignment(w) if width_and_alignment.is_none() => {
+                width_and_alignment = Some(w)
             }
+            _ => return Err(nom::Err::Error(())),
         }
     }
 
diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index 59e0ed76..30c1cfa1 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -397,34 +397,25 @@ fn apply_color(
     log_color: Option<LogColor>,
     level: Option<Level>,
 ) -> ColoredString {
-    if let Some(log_color) = log_color {
-        match log_color {
-            LogColor::Color(color) => s.color(color),
-            LogColor::SeverityLevel => {
-                if let Some(level) = level {
-                    let color = color_for_log_level(level);
-                    s.color(color)
-                } else {
-                    s
-                }
-            }
-            LogColor::WarnError => {
-                if level.is_some_and(|l| l == Level::Warn || l == Level::Error) {
-                    let color = color_for_log_level(level.unwrap());
-                    s.color(color)
-                } else {
-                    s
-                }
-            }
-        }
-    } else {
-        s
+    match log_color {
+        Some(color) => match color {
+            LogColor::Color(c) => s.color(c),
+            LogColor::SeverityLevel => match level {
+                Some(level) => s.color(color_for_log_level(level)),
+                None => s,
+            },
+            LogColor::WarnError => match level {
+                Some(level @ (Level::Warn | Level::Error)) => s.color(color_for_log_level(level)),
+                _ => s,
+            },
+        },
+        None => s,
     }
 }
 
 fn apply_style(s: ColoredString, log_style: Option<Styles>) -> ColoredString {
-    if let Some(log_style) = log_style {
-        match log_style {
+    match log_style {
+        Some(log_style) => match log_style {
             Styles::Bold => s.bold(),
             Styles::Italic => s.italic(),
             Styles::Underline => s.underline(),
@@ -434,9 +425,8 @@ fn apply_style(s: ColoredString, log_style: Option<Styles>) -> ColoredString {
             Styles::Reversed => s.reversed(),
             Styles::Blink => s.blink(),
             Styles::Hidden => s.hidden(),
-        }
-    } else {
-        s
+        },
+        None => s,
     }
 }
 
@@ -447,14 +437,8 @@ fn write_string<W: io::Write>(
     alignment: Alignment,
 ) -> io::Result<()> {
     match alignment {
-        Alignment::Left => {
-            write!(sink, "{s:<0$}", width)
-        }
-        Alignment::Center => {
-            write!(sink, "{s:^0$}", width)
-        }
-        Alignment::Right => {
-            write!(sink, "{s:>0$}", width)
-        }
+        Alignment::Left => write!(sink, "{s:<0$}", width),
+        Alignment::Center => write!(sink, "{s:^0$}", width),
+        Alignment::Right => write!(sink, "{s:>0$}", width),
     }
 }

From 4c651fb53c2522ebeae41c8e21152155350a266d Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Fri, 4 Aug 2023 00:02:58 +0200
Subject: [PATCH 6/9] Add utility function apply_format()

---
 decoder/src/log/stdout_logger.rs | 101 +++++++++++++++++++------------
 1 file changed, 63 insertions(+), 38 deletions(-)

diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index 30c1cfa1..bbe0dc8b 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -184,13 +184,15 @@ impl<'a> Printer<'a> {
             Record::Host(_) => String::from("<time>"),
         };
 
-        let timestamp = ColoredString::from(timestamp.as_str());
-        let timestamp = apply_color(timestamp, format.color, self.record_log_level());
-        let timestamp = apply_style(timestamp, format.style);
-        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let timestamp = apply_format(
+            timestamp.as_str(),
+            format.color,
+            format.style,
+            self.record_log_level(),
+        );
         let width = format.width.unwrap_or(self.min_timestamp_width);
 
-        write_string(timestamp, sink, width, alignment)
+        write_string(timestamp, sink, width, format.alignment)
     }
 
     fn print_log_level<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
@@ -201,14 +203,15 @@ impl<'a> Printer<'a> {
         };
 
         let color = format.color.unwrap_or(LogColor::SeverityLevel);
-
-        let level = ColoredString::from(level.as_str());
-        let level = apply_color(level, Some(color), self.record_log_level());
-        let level = apply_style(level, format.style);
-        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let level = apply_format(
+            level.as_str(),
+            Some(color),
+            format.style,
+            self.record_log_level(),
+        );
         let width = format.width.unwrap_or(5);
 
-        write_string(level, sink, width, alignment)
+        write_string(level, sink, width, format.alignment)
     }
 
     fn print_file_path<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
@@ -218,13 +221,15 @@ impl<'a> Printer<'a> {
         }
         .unwrap_or("<file>");
 
-        let file_path = ColoredString::from(file_path);
-        let file_path = apply_color(file_path, format.color, self.record_log_level());
-        let file_path = apply_style(file_path, format.style);
-        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let file_path = apply_format(
+            file_path,
+            format.color,
+            format.style,
+            self.record_log_level(),
+        );
         let width = format.width.unwrap_or(0);
 
-        write_string(file_path, sink, width, alignment)
+        write_string(file_path, sink, width, format.alignment)
     }
 
     fn print_file_name<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
@@ -244,13 +249,15 @@ impl<'a> Printer<'a> {
             "<file>"
         };
 
-        let file_name = ColoredString::from(file_name);
-        let file_name = apply_color(file_name, format.color, self.record_log_level());
-        let file_name = apply_style(file_name, format.style);
-        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let file_name = apply_format(
+            file_name,
+            format.color,
+            format.style,
+            self.record_log_level(),
+        );
         let width = format.width.unwrap_or(0);
 
-        write_string(file_name, sink, width, alignment)
+        write_string(file_name, sink, width, format.alignment)
     }
 
     fn print_module_path<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
@@ -260,13 +267,15 @@ impl<'a> Printer<'a> {
         }
         .unwrap_or("<mod path>");
 
-        let module_path = ColoredString::from(module_path);
-        let module_path = apply_color(module_path, format.color, self.record_log_level());
-        let module_path = apply_style(module_path, format.style);
-        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let module_path = apply_format(
+            module_path,
+            format.color,
+            format.style,
+            self.record_log_level(),
+        );
         let width = format.width.unwrap_or(0);
 
-        write_string(module_path, sink, width, alignment)
+        write_string(module_path, sink, width, format.alignment)
     }
 
     fn print_line_number<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
@@ -277,13 +286,15 @@ impl<'a> Printer<'a> {
         .unwrap_or(0)
         .to_string();
 
-        let line_number = ColoredString::from(line_number.as_str());
-        let line_number = apply_color(line_number, format.color, self.record_log_level());
-        let line_number = apply_style(line_number, format.style);
-        let alignment = format.alignment.unwrap_or(Alignment::Left);
+        let line_number = apply_format(
+            line_number.as_str(),
+            format.color,
+            format.style,
+            self.record_log_level(),
+        );
         let width = format.width.unwrap_or(4);
 
-        write_string(line_number, sink, width, alignment)
+        write_string(line_number, sink, width, format.alignment)
     }
 
     fn print_log<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
@@ -291,12 +302,14 @@ impl<'a> Printer<'a> {
             Record::Defmt(record) => match color_diff(record.args().to_string()) {
                 Ok(s) => write!(sink, "{s}"),
                 Err(s) => {
-                    let log = ColoredString::from(s.as_str());
-                    let log = apply_color(log, format.color, self.record_log_level());
-                    let log = apply_style(log, format.style);
-                    let alignment = format.alignment.unwrap_or(Alignment::Left);
+                    let log = apply_format(
+                        s.as_str(),
+                        format.color,
+                        format.style,
+                        self.record_log_level(),
+                    );
                     let width = format.width.unwrap_or(0);
-                    write_string(log, sink, width, alignment)
+                    write_string(log, sink, width, format.alignment)
                 }
             },
             Record::Host(record) => {
@@ -392,6 +405,18 @@ fn color_for_log_level(level: Level) -> Color {
     }
 }
 
+fn apply_format(
+    s: &str,
+    color: Option<LogColor>,
+    style: Option<Styles>,
+    level: Option<Level>,
+) -> ColoredString {
+    let s = ColoredString::from(s);
+    let s = apply_color(s, color, level);
+    let s = apply_style(s, style);
+    s
+}
+
 fn apply_color(
     s: ColoredString,
     log_color: Option<LogColor>,
@@ -434,9 +459,9 @@ fn write_string<W: io::Write>(
     s: ColoredString,
     sink: &mut W,
     width: usize,
-    alignment: Alignment,
+    alignment: Option<Alignment>,
 ) -> io::Result<()> {
-    match alignment {
+    match alignment.unwrap_or(Alignment::Left) {
         Alignment::Left => write!(sink, "{s:<0$}", width),
         Alignment::Center => write!(sink, "{s:^0$}", width),
         Alignment::Right => write!(sink, "{s:>0$}", width),

From e35117821e4c779911c6d4dbb77d070a1787d749 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Fri, 4 Aug 2023 00:07:18 +0200
Subject: [PATCH 7/9] cargo clippy

---
 decoder/src/log/stdout_logger.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index bbe0dc8b..0c5f29d2 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -413,8 +413,7 @@ fn apply_format(
 ) -> ColoredString {
     let s = ColoredString::from(s);
     let s = apply_color(s, color, level);
-    let s = apply_style(s, style);
-    s
+    apply_style(s, style)
 }
 
 fn apply_color(

From 636cffaa2ac9494d8d0796725d3e463bf3ce6f0c Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Wed, 27 Sep 2023 22:48:48 +0200
Subject: [PATCH 8/9] Fix issues with repeated style specifiers

---
 decoder/src/log/format.rs        | 45 +++++++++++++++++++++++----
 decoder/src/log/stdout_logger.rs | 52 ++++++++++++++++++--------------
 2 files changed, 68 insertions(+), 29 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index d77f873a..a63f4582 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -53,7 +53,7 @@ pub(super) struct LogSegment {
 pub(super) struct LogFormat {
     pub(super) width: Option<usize>,
     pub(super) color: Option<LogColor>,
-    pub(super) style: Option<colored::Styles>,
+    pub(super) style: Option<Vec<colored::Styles>>,
     pub(super) alignment: Option<Alignment>,
 }
 
@@ -85,8 +85,10 @@ impl LogSegment {
     }
 
     #[cfg(test)]
-    const fn with_style(mut self, style: colored::Styles) -> Self {
-        self.format.style = Some(style);
+    fn with_style(mut self, style: colored::Styles) -> Self {
+        let mut styles = self.format.style.unwrap_or_default();
+        styles.push(style);
+        self.format.style = Some(styles);
         self
     }
 
@@ -188,16 +190,26 @@ fn parse_log_segment(input: &str) -> IResult<&str, LogSegment, ()> {
         match item {
             IntermediateOutput::Metadata(m) if metadata.is_none() => metadata = Some(m),
             IntermediateOutput::Color(c) if color.is_none() => color = Some(c),
-            IntermediateOutput::Style(s) if style.is_none() => style = Some(s),
+            IntermediateOutput::Style(s) => {
+                let mut styles: Vec<colored::Styles> = style.unwrap_or_default();
+
+                // A format with repeated style specifiers is not valid
+                if styles.contains(&s) {
+                    return Err(nom::Err::Failure(()));
+                }
+
+                styles.push(s);
+                style = Some(styles);
+            }
             IntermediateOutput::WidthAndAlignment(w) if width_and_alignment.is_none() => {
                 width_and_alignment = Some(w)
             }
-            _ => return Err(nom::Err::Error(())),
+            _ => return Err(nom::Err::Failure(())),
         }
     }
 
     let Some(metadata) = metadata else {
-        return Err(nom::Err::Error(()));
+        return Err(nom::Err::Failure(()));
     };
 
     let (width, alignment) = width_and_alignment
@@ -381,4 +393,25 @@ mod tests {
         let result = parse(log_template);
         assert_eq!(result, Ok(expected_output));
     }
+
+    #[test]
+    fn test_parse_log_with_multiple_different_styles() {
+        let log_template = "{s:bold:underline:italic:dimmed}";
+
+        let expected_output = vec![LogSegment::new(LogMetadata::Log)
+            .with_style(colored::Styles::Bold)
+            .with_style(colored::Styles::Underline)
+            .with_style(colored::Styles::Italic)
+            .with_style(colored::Styles::Dimmed)];
+
+        let result = parse(log_template);
+        assert_eq!(result, Ok(expected_output));
+    }
+
+    #[test]
+    fn test_parse_log_with_repeated_styles() {
+        let log_template = "{s:bold:bold}";
+        let result = parse(log_template);
+        assert!(result.is_err());
+    }
 }
diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index 0c5f29d2..a7f650e7 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -187,7 +187,7 @@ impl<'a> Printer<'a> {
         let timestamp = apply_format(
             timestamp.as_str(),
             format.color,
-            format.style,
+            format.style.as_ref(),
             self.record_log_level(),
         );
         let width = format.width.unwrap_or(self.min_timestamp_width);
@@ -206,7 +206,7 @@ impl<'a> Printer<'a> {
         let level = apply_format(
             level.as_str(),
             Some(color),
-            format.style,
+            format.style.as_ref(),
             self.record_log_level(),
         );
         let width = format.width.unwrap_or(5);
@@ -224,7 +224,7 @@ impl<'a> Printer<'a> {
         let file_path = apply_format(
             file_path,
             format.color,
-            format.style,
+            format.style.as_ref(),
             self.record_log_level(),
         );
         let width = format.width.unwrap_or(0);
@@ -252,7 +252,7 @@ impl<'a> Printer<'a> {
         let file_name = apply_format(
             file_name,
             format.color,
-            format.style,
+            format.style.as_ref(),
             self.record_log_level(),
         );
         let width = format.width.unwrap_or(0);
@@ -270,7 +270,7 @@ impl<'a> Printer<'a> {
         let module_path = apply_format(
             module_path,
             format.color,
-            format.style,
+            format.style.as_ref(),
             self.record_log_level(),
         );
         let width = format.width.unwrap_or(0);
@@ -289,7 +289,7 @@ impl<'a> Printer<'a> {
         let line_number = apply_format(
             line_number.as_str(),
             format.color,
-            format.style,
+            format.style.as_ref(),
             self.record_log_level(),
         );
         let width = format.width.unwrap_or(4);
@@ -305,7 +305,7 @@ impl<'a> Printer<'a> {
                     let log = apply_format(
                         s.as_str(),
                         format.color,
-                        format.style,
+                        format.style.as_ref(),
                         self.record_log_level(),
                     );
                     let width = format.width.unwrap_or(0);
@@ -408,12 +408,12 @@ fn color_for_log_level(level: Level) -> Color {
 fn apply_format(
     s: &str,
     color: Option<LogColor>,
-    style: Option<Styles>,
+    styles: Option<&Vec<Styles>>,
     level: Option<Level>,
 ) -> ColoredString {
     let s = ColoredString::from(s);
     let s = apply_color(s, color, level);
-    apply_style(s, style)
+    apply_styles(s, styles)
 }
 
 fn apply_color(
@@ -437,21 +437,27 @@ fn apply_color(
     }
 }
 
-fn apply_style(s: ColoredString, log_style: Option<Styles>) -> ColoredString {
-    match log_style {
-        Some(log_style) => match log_style {
-            Styles::Bold => s.bold(),
-            Styles::Italic => s.italic(),
-            Styles::Underline => s.underline(),
-            Styles::Strikethrough => s.strikethrough(),
-            Styles::Dimmed => s.dimmed(),
-            Styles::Clear => s.clear(),
-            Styles::Reversed => s.reversed(),
-            Styles::Blink => s.blink(),
-            Styles::Hidden => s.hidden(),
-        },
-        None => s,
+fn apply_styles(s: ColoredString, log_style: Option<&Vec<Styles>>) -> ColoredString {
+    let Some(log_styles) =  log_style else {
+        return s;
+    };
+
+    let mut stylized_string = s;
+    for style in log_styles {
+        stylized_string = match style {
+            Styles::Bold => stylized_string.bold(),
+            Styles::Italic => stylized_string.italic(),
+            Styles::Underline => stylized_string.underline(),
+            Styles::Strikethrough => stylized_string.strikethrough(),
+            Styles::Dimmed => stylized_string.dimmed(),
+            Styles::Clear => stylized_string.clear(),
+            Styles::Reversed => stylized_string.reversed(),
+            Styles::Blink => stylized_string.blink(),
+            Styles::Hidden => stylized_string.hidden(),
+        };
     }
+
+    stylized_string
 }
 
 fn write_string<W: io::Write>(

From 3cd66ba011eb7cbe24d1813ad447f8ea6c2f6881 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Wed, 27 Sep 2023 22:56:44 +0200
Subject: [PATCH 9/9] cargo fmt

---
 decoder/src/log/stdout_logger.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index a7f650e7..c6e5183a 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -438,7 +438,7 @@ fn apply_color(
 }
 
 fn apply_styles(s: ColoredString, log_style: Option<&Vec<Styles>>) -> ColoredString {
-    let Some(log_styles) =  log_style else {
+    let Some(log_styles) = log_style else {
         return s;
     };