From c9c2d1fd91f6e27ee15996e65db5698cdb400eaa Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 12:07:49 +0200
Subject: [PATCH 01/19] Implement nested format parsing

---
 decoder/src/log/format.rs        | 285 +++++++++++++++++++++++++++----
 decoder/src/log/stdout_logger.rs |   1 +
 2 files changed, 255 insertions(+), 31 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index a63f4582..081f132b 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -4,8 +4,9 @@ use nom::{
     character::complete::{char, digit1, one_of},
     combinator::{map, map_res, opt},
     multi::{many0, separated_list1},
-    sequence::delimited,
-    IResult, Parser,
+    sequence::{delimited, preceded},
+    error::{Error, ErrorKind, ParseError},
+    Err, IResult, Parser,
 };
 
 use std::str::FromStr;
@@ -21,6 +22,7 @@ pub(super) enum LogMetadata {
     ModulePath,
     String(String),
     Timestamp,
+    NestedLogSegments(Vec<LogSegment>),
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]
@@ -63,6 +65,7 @@ enum IntermediateOutput {
     WidthAndAlignment((usize, Option<Alignment>)),
     Color(LogColor),
     Style(colored::Styles),
+    NestedLogSegment(LogSegment),
 }
 
 impl LogSegment {
@@ -105,7 +108,58 @@ impl LogSegment {
     }
 }
 
+/// This function is taken as-is from the parse-hyperlinks crate
+/// https://docs.rs/parse-hyperlinks/0.9.3/src/parse_hyperlinks/lib.rs.html#24-68
+/// There is an open issue in nom to include this parser in nom 8.0
+/// https://github.com/rust-bakery/nom/issues/1253
+pub fn take_until_unbalanced(
+    opening_bracket: char,
+    closing_bracket: char,
+) -> impl Fn(&str) -> IResult<&str, &str, ()> {
+    move |i: &str| {
+        let mut index = 0;
+        let mut bracket_counter = 0;
+        while let Some(n) = &i[index..].find(&[opening_bracket, closing_bracket, '\\'][..]) {
+            index += n;
+            let mut it = i[index..].chars();
+            match it.next().unwrap_or_default() {
+                c if c == '\\' => {
+                    // Skip the escape char `\`.
+                    index += '\\'.len_utf8();
+                    // Skip also the following char.
+                    let c = it.next().unwrap_or_default();
+                    index += c.len_utf8();
+                }
+                c if c == opening_bracket => {
+                    bracket_counter += 1;
+                    index += opening_bracket.len_utf8();
+                }
+                c if c == closing_bracket => {
+                    // Closing bracket.
+                    bracket_counter -= 1;
+                    index += closing_bracket.len_utf8();
+                }
+                // Can not happen.
+                _ => unreachable!(),
+            };
+            // We found the unmatched closing bracket.
+            if bracket_counter == -1 {
+                // We do not consume it.
+                index -= closing_bracket.len_utf8();
+                return Ok((&i[index..], &i[0..index]));
+            };
+        }
+
+        if bracket_counter == 0 {
+            Ok(("", i))
+        } else {
+            Err(nom::Err::Error(()))
+        }
+    }
+}
+
 fn parse_metadata(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    println!("parse_metadata: \"{input}\"");
     let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| {
         let metadata = match s {
             "f" => LogMetadata::FileName,
@@ -124,6 +178,7 @@ fn parse_metadata(input: &str) -> IResult<&str, IntermediateOutput, ()> {
 }
 
 fn parse_color(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    println!("parse_color: \"{input}\"");
     let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| {
         let color = match s {
             "severity" => LogColor::SeverityLevel,
@@ -140,6 +195,7 @@ fn parse_color(input: &str) -> IResult<&str, IntermediateOutput, ()> {
 }
 
 fn parse_style(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    println!("parse_style: \"{input}\"");
     let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| {
         let style = match s {
             "bold" => colored::Styles::Bold,
@@ -156,6 +212,7 @@ fn parse_style(input: &str) -> IResult<&str, IntermediateOutput, ()> {
 }
 
 fn parse_width_and_alignment(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    println!("parse_width_and_alignment: \"{input}\"");
     let (input, alignment) = opt(map_res(one_of("<^>"), move |c| match c {
         '^' => Ok(Alignment::Center),
         '<' => Ok(Alignment::Left),
@@ -171,44 +228,92 @@ fn parse_width_and_alignment(input: &str) -> IResult<&str, IntermediateOutput, (
     ))
 }
 
-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)?;
+fn parse_format(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    alt((
+        parse_color,
+        parse_style,
+        parse_width_and_alignment,
+    )).parse(input)
+}
 
+fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutput>) -> Result<LogSegment, nom::Err<()>> {
+    println!("\nbuild_log_segment ({NEST}): {:?}", intermediate_output);
     let mut metadata = None;
     let mut color = None;
     let mut style = None;
     let mut width_and_alignment = None;
-    for item in output {
+    let mut nested_segments = None;
+    for item in intermediate_output {
         match item {
-            IntermediateOutput::Metadata(m) if metadata.is_none() => metadata = Some(m),
-            IntermediateOutput::Color(c) if color.is_none() => color = Some(c),
+            IntermediateOutput::Metadata(m) if metadata.is_none() => {
+                println!("Found metadata");
+                metadata = Some(m)
+            },
+            IntermediateOutput::Color(c) if color.is_none() => {
+                println!("Found color");
+                color = Some(c)
+            },
             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) {
+                    println!("Style fail");
                     return Err(nom::Err::Failure(()));
                 }
 
+                println!("Found style");
                 styles.push(s);
                 style = Some(styles);
             }
             IntermediateOutput::WidthAndAlignment(w) if width_and_alignment.is_none() => {
+                println!("Found width and alignment");
                 width_and_alignment = Some(w)
             }
-            _ => return Err(nom::Err::Failure(())),
+            IntermediateOutput::NestedLogSegment(s) => {
+                let mut segments: Vec<LogSegment> = nested_segments.unwrap_or_default();
+
+                println!("Found nested");
+                segments.push(s);
+                nested_segments = Some(segments);
+            }
+            _ => {
+                println!("Intermediate output fail");
+                return Err(nom::Err::Failure(()))
+            },
+        }
+    }
+
+    if NEST {
+        let Some(nested_segments) = nested_segments else {
+            println!("Nested segments fail");
+            return Err(nom::Err::Failure(()));
+        };
+
+        println!("Adding nested log segments to metadata for nested segment");
+        metadata = Some(LogMetadata::NestedLogSegments(nested_segments));
+    } else {
+        // We either have nested segments, or a metadata specifier, we can't have both
+        // This means we either have:
+        //  metadata specifier: {L:underline}
+        //  nested segments specifier: {[{L:<5:bold}]%underline}
+        if metadata.is_some() && nested_segments.is_some() {
+            return Err(nom::Err::Failure(()));
+        }
+
+        // If we have a nested segment there must be exactly one,
+        // otherwise there's something weird going on
+        if let Some(segments) = nested_segments {
+            if segments.iter().count() == 1 {
+                return Ok(segments[0].clone());
+            } else {
+                return Err(nom::Err::Failure(()));
+            }
         }
     }
 
     let Some(metadata) = metadata else {
+        println!("Metadata fail");
         return Err(nom::Err::Failure(()));
     };
 
@@ -216,7 +321,7 @@ fn parse_log_segment(input: &str) -> IResult<&str, LogSegment, ()> {
         .map(|(w, a)| (Some(w), a))
         .unwrap_or((None, None));
 
-    let log_segment = LogSegment {
+    Ok(LogSegment {
         metadata,
         format: LogFormat {
             color,
@@ -224,25 +329,90 @@ fn parse_log_segment(input: &str) -> IResult<&str, LogSegment, ()> {
             width,
             alignment,
         },
-    };
+    })
+}
+
 
+fn parse_log_segment<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()> {
+    println!("parse_log_segment ({NEST}): \"{input}\"");
+
+    let (input, output) = if !NEST {
+        separated_list1(
+            char(':'),
+            alt((
+                parse_metadata,
+                parse_format,
+                parse_nested::<true>,
+            )),
+        )(input)
+    } else {
+        let parse_nested_argument = separated_list1(
+            char(':'),
+            alt((parse_metadata, parse_format)),
+        );
+
+        let parse_nested_log_segment = map_res(parse_nested_argument, |result| {
+            let log_segment = build_log_segment::<false>(result)?;
+            Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(log_segment))
+        });
+
+        separated_list1(
+            char('%'),
+            alt((
+                parse_nested_log_segment,
+                parse_format,
+                parse_nested::<false>,
+            )),
+        )(input)
+    }?;
+
+    let log_segment = build_log_segment::<false>(output)?;
     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_argument<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()> {
+    println!("parse_argument ({NEST}): \"{input}\"");
+    let take_between_matching_brackets = delimited(
+        char('{'), 
+        take_until_unbalanced('{', '}'), 
+        char('}')
+    );
+    
+    take_between_matching_brackets.and_then(parse_log_segment::<NEST>).parse(input)
 }
 
-fn parse_string_segment(input: &str) -> IResult<&str, LogSegment, ()> {
-    map(take_till1(|c| c == '{'), |s: &str| {
+fn parse_string_segment<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()> {
+    println!("parse_string_segment: \"{input}\"");
+    map(take_till1(|c| {
+        if !NEST {
+            c == '{'
+        } else {
+            c == '{' || c == '%' 
+        }
+    }), |s: &str| {
         LogSegment::new(LogMetadata::String(s.to_string()))
     })
     .parse(input)
 }
 
+fn parse_nested<const NEST: bool>(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    println!("\nIN parse_nested ({NEST}): \"{input}\" ----------------");
+
+    let parse_nested_argument = map_res(parse_argument::<NEST>, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
+    let parse_nested_string_segment = map_res(parse_string_segment::<NEST>, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
+    let parse_nested_format = preceded(char('%'), parse_format);
+    let mut parse_all = many0(alt((parse_nested_argument, parse_nested_format, parse_nested_string_segment)));
+
+    let (new_input, output) = parse_all(input)?;
+
+    let log_segment = build_log_segment::<true>(output)?;
+
+    println!("\nOUT parse_nested ({NEST}): \"{new_input}\" ---------------");
+    Ok((new_input, IntermediateOutput::NestedLogSegment(log_segment)))
+}
+
 pub(super) fn parse(input: &str) -> Result<Vec<LogSegment>, String> {
-    let mut parse_all = many0(alt((parse_argument, parse_string_segment)));
+    let mut parse_all = many0(alt((parse_argument::<false>, parse_string_segment::<false>)));
 
     parse_all(input)
         .map(|(_, output)| output)
@@ -277,7 +447,7 @@ mod tests {
 
     #[test]
     fn test_parse_string_segment() {
-        let result = parse_string_segment("Log: {t}");
+        let result = parse_string_segment::<false>("Log: {t}");
         let (input, output) = result.unwrap();
         assert_eq!(input, "{t}");
         assert_eq!(
@@ -288,19 +458,19 @@ mod tests {
 
     #[test]
     fn test_parse_empty_string_segment() {
-        let result = parse_string_segment("");
+        let result = parse_string_segment::<false>("");
         assert!(result.is_err());
     }
 
     #[test]
     fn test_parse_timestamp_argument() {
-        let result = parse_argument("{t}");
+        let result = parse_argument::<false>("{t}");
         assert_eq!(result, Ok(("", LogSegment::new(LogMetadata::Timestamp))));
     }
 
     #[test]
     fn test_parse_argument_with_color() {
-        let result = parse_log_segment("t:werror");
+        let result = parse_log_segment::<false>("t:werror");
         let expected_output =
             LogSegment::new(LogMetadata::Timestamp).with_color(LogColor::WarnError);
         assert_eq!(result, Ok(("", expected_output)));
@@ -308,7 +478,7 @@ mod tests {
 
     #[test]
     fn test_parse_argument_with_extra_format_parameters_width_first() {
-        let result = parse_argument("{t:>8:white}");
+        let result = parse_argument::<false>("{t:>8:white}");
         let expected_output = LogSegment::new(LogMetadata::Timestamp)
             .with_width(8)
             .with_alignment(Alignment::Right)
@@ -318,7 +488,7 @@ mod tests {
 
     #[test]
     fn test_parse_argument_with_extra_format_parameters_color_first() {
-        let result = parse_argument("{f:werror:<25}");
+        let result = parse_argument::<false>("{f:werror:<25}");
         let expected_output = LogSegment::new(LogMetadata::FileName)
             .with_width(25)
             .with_alignment(Alignment::Left)
@@ -328,7 +498,7 @@ mod tests {
 
     #[test]
     fn test_parse_invalid_argument() {
-        let result = parse_argument("{foo}");
+        let result = parse_argument::<false>("{foo}");
         assert_eq!(result, Result::Err(nom::Err::Error(())));
     }
 
@@ -414,4 +584,57 @@ mod tests {
         let result = parse(log_template);
         assert!(result.is_err());
     }
+
+    #[test]
+    fn test_parse_single_nested_format() {
+        let log_template = "{[{L:<5:bold}]%underline%italic} {s}";
+        let expected_output = vec![
+            LogSegment::new(LogMetadata::NestedLogSegments(
+                vec![
+                    LogSegment::new(LogMetadata::String("[".to_string())),
+                    LogSegment::new(LogMetadata::LogLevel)
+                        .with_alignment(Alignment::Left)
+                        .with_width(5)
+                        .with_style(colored::Styles::Bold),
+                    LogSegment::new(LogMetadata::String("]".to_string())),
+                ]
+            ))
+            .with_style(colored::Styles::Underline)
+            .with_style(colored::Styles::Italic),
+            LogSegment::new(LogMetadata::String(" ".to_string())),
+            LogSegment::new(LogMetadata::Log),
+        ];
+        let result = parse(log_template);
+        assert_eq!(result, Ok(expected_output));
+    }
+
+
+    /// Note: A format string with a bad format specifier doesn't actually make the parser fail.
+    /// It will just "eat" the bad specifier and will output a Log
+    #[test]
+    fn test_parse_single_nested_format_with_bad_specifier() {
+        let log_template = "{[{L:<5:bold}]%bad%underline} {s}";
+        let expected_output = vec![
+            LogSegment::new(LogMetadata::NestedLogSegments(
+                vec![
+                    LogSegment::new(LogMetadata::String("[".to_string())),
+                    LogSegment::new(LogMetadata::LogLevel)
+                        .with_alignment(Alignment::Left)
+                        .with_width(5)
+                        .with_style(colored::Styles::Bold),
+                    LogSegment::new(LogMetadata::String("]".to_string())),
+                ]
+            )).with_style(colored::Styles::Underline),
+            LogSegment::new(LogMetadata::String(" ".to_string())),
+            LogSegment::new(LogMetadata::Log),
+        ];
+        let result = parse(log_template);
+        assert_eq!(result, Ok(expected_output));
+    }
+
+    #[test]
+    fn test_parse_double_nested_format() {
+        let log_template = "{{[{L:<5}]%bold} {f:>20}:%<30} {s}";
+        assert!(true);
+    }
 }
diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index 1e3ff12c..53578f5d 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -164,6 +164,7 @@ impl<'a> Printer<'a> {
                 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),
+                _ => return Ok(())
             }?;
         }
         writeln!(sink)

From 093ebc805fb4372b6dd8d50d57125ec6a9ac9851 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 15:41:25 +0200
Subject: [PATCH 02/19] Fix issue with bad specifiers on nested format

---
 decoder/src/log/format.rs | 68 +++++++++++++++++++++++----------------
 1 file changed, 40 insertions(+), 28 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 081f132b..13a88f27 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -25,6 +25,17 @@ pub(super) enum LogMetadata {
     NestedLogSegments(Vec<LogSegment>),
 }
 
+impl LogMetadata {
+    /// Checks whether this `LogMetadata` came from a specifier such as
+    /// {t}, {f}, etc.
+    fn is_metadata_specifier(&self) -> bool {
+        match self {
+            LogMetadata::String(_) | LogMetadata::NestedLogSegments(_) => false,
+            _ => true,
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub(super) enum LogColor {
     /// User-defined color
@@ -228,12 +239,21 @@ fn parse_width_and_alignment(input: &str) -> IResult<&str, IntermediateOutput, (
     ))
 }
 
-fn parse_format(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    alt((
+fn parse_format<const FAIL_ON_ERR: bool>(input: &str) -> IResult<&str, IntermediateOutput, ()> {
+    let result = alt((
         parse_color,
         parse_style,
         parse_width_and_alignment,
-    )).parse(input)
+    )).parse(input);
+
+    if !FAIL_ON_ERR {
+        result
+    } else {
+        match result {
+            Ok(r) => Ok(r),
+            Err(_) => Err(nom::Err::Failure(())),
+        }
+    }
 }
 
 fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutput>) -> Result<LogSegment, nom::Err<()>> {
@@ -290,6 +310,13 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
             return Err(nom::Err::Failure(()));
         };
 
+        // A nested segment must have at least a valid specifier such as {t} or {f},
+        // it isn't allowed to have {foo} and consider foo a string segment.
+        let has_metadata_specifier = nested_segments.iter().any(|segment| segment.metadata.is_metadata_specifier());
+        if !has_metadata_specifier {
+            return Err(nom::Err::Failure(()));
+        }
+
         println!("Adding nested log segments to metadata for nested segment");
         metadata = Some(LogMetadata::NestedLogSegments(nested_segments));
     } else {
@@ -334,21 +361,21 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
 
 
 fn parse_log_segment<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()> {
-    println!("parse_log_segment ({NEST}): \"{input}\"");
+    println!("IN parse_log_segment ({NEST}): \"{input}\"");
 
     let (input, output) = if !NEST {
         separated_list1(
             char(':'),
             alt((
                 parse_metadata,
-                parse_format,
+                parse_format::<false>,
                 parse_nested::<true>,
             )),
         )(input)
     } else {
         let parse_nested_argument = separated_list1(
             char(':'),
-            alt((parse_metadata, parse_format)),
+            alt((parse_metadata, parse_format::<false>)),
         );
 
         let parse_nested_log_segment = map_res(parse_nested_argument, |result| {
@@ -360,12 +387,14 @@ fn parse_log_segment<const NEST: bool>(input: &str) -> IResult<&str, LogSegment,
             char('%'),
             alt((
                 parse_nested_log_segment,
-                parse_format,
+                parse_format::<false>,
                 parse_nested::<false>,
             )),
         )(input)
     }?;
 
+    println!("OUT parse_log_segment ({NEST}): \"{input}\"");
+
     let log_segment = build_log_segment::<false>(output)?;
     Ok((input, log_segment))
 }
@@ -400,8 +429,8 @@ fn parse_nested<const NEST: bool>(input: &str) -> IResult<&str, IntermediateOutp
 
     let parse_nested_argument = map_res(parse_argument::<NEST>, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
     let parse_nested_string_segment = map_res(parse_string_segment::<NEST>, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
-    let parse_nested_format = preceded(char('%'), parse_format);
-    let mut parse_all = many0(alt((parse_nested_argument, parse_nested_format, parse_nested_string_segment)));
+    let parse_nested_format = preceded(char('%'), parse_format::<true>);
+    let mut parse_all = many0(alt((parse_nested_argument, parse_nested_string_segment, parse_nested_format)));
 
     let (new_input, output) = parse_all(input)?;
 
@@ -499,7 +528,7 @@ mod tests {
     #[test]
     fn test_parse_invalid_argument() {
         let result = parse_argument::<false>("{foo}");
-        assert_eq!(result, Result::Err(nom::Err::Error(())));
+        assert!(result.is_err());
     }
 
     #[test]
@@ -608,28 +637,11 @@ mod tests {
         assert_eq!(result, Ok(expected_output));
     }
 
-
-    /// Note: A format string with a bad format specifier doesn't actually make the parser fail.
-    /// It will just "eat" the bad specifier and will output a Log
     #[test]
     fn test_parse_single_nested_format_with_bad_specifier() {
         let log_template = "{[{L:<5:bold}]%bad%underline} {s}";
-        let expected_output = vec![
-            LogSegment::new(LogMetadata::NestedLogSegments(
-                vec![
-                    LogSegment::new(LogMetadata::String("[".to_string())),
-                    LogSegment::new(LogMetadata::LogLevel)
-                        .with_alignment(Alignment::Left)
-                        .with_width(5)
-                        .with_style(colored::Styles::Bold),
-                    LogSegment::new(LogMetadata::String("]".to_string())),
-                ]
-            )).with_style(colored::Styles::Underline),
-            LogSegment::new(LogMetadata::String(" ".to_string())),
-            LogSegment::new(LogMetadata::Log),
-        ];
         let result = parse(log_template);
-        assert_eq!(result, Ok(expected_output));
+        assert!(result.is_err());
     }
 
     #[test]

From 05635769f3f4acafe0c1fa0cfb271e993e4484c0 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 16:22:32 +0200
Subject: [PATCH 03/19] Implement support for doubly nested formats

---
 decoder/src/log/format.rs | 45 ++++++++++++++++++++++++++++-----------
 1 file changed, 32 insertions(+), 13 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 13a88f27..4db58082 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -410,15 +410,9 @@ fn parse_argument<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()
     take_between_matching_brackets.and_then(parse_log_segment::<NEST>).parse(input)
 }
 
-fn parse_string_segment<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()> {
+fn parse_string_segment(input: &str) -> IResult<&str, LogSegment, ()> {
     println!("parse_string_segment: \"{input}\"");
-    map(take_till1(|c| {
-        if !NEST {
-            c == '{'
-        } else {
-            c == '{' || c == '%' 
-        }
-    }), |s: &str| {
+    map(take_till1(|c| c == '{' || c == '%'), |s: &str| {
         LogSegment::new(LogMetadata::String(s.to_string()))
     })
     .parse(input)
@@ -428,7 +422,7 @@ fn parse_nested<const NEST: bool>(input: &str) -> IResult<&str, IntermediateOutp
     println!("\nIN parse_nested ({NEST}): \"{input}\" ----------------");
 
     let parse_nested_argument = map_res(parse_argument::<NEST>, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
-    let parse_nested_string_segment = map_res(parse_string_segment::<NEST>, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
+    let parse_nested_string_segment = map_res(parse_string_segment, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
     let parse_nested_format = preceded(char('%'), parse_format::<true>);
     let mut parse_all = many0(alt((parse_nested_argument, parse_nested_string_segment, parse_nested_format)));
 
@@ -441,7 +435,7 @@ fn parse_nested<const NEST: bool>(input: &str) -> IResult<&str, IntermediateOutp
 }
 
 pub(super) fn parse(input: &str) -> Result<Vec<LogSegment>, String> {
-    let mut parse_all = many0(alt((parse_argument::<false>, parse_string_segment::<false>)));
+    let mut parse_all = many0(alt((parse_argument::<false>, parse_string_segment)));
 
     parse_all(input)
         .map(|(_, output)| output)
@@ -476,7 +470,7 @@ mod tests {
 
     #[test]
     fn test_parse_string_segment() {
-        let result = parse_string_segment::<false>("Log: {t}");
+        let result = parse_string_segment("Log: {t}");
         let (input, output) = result.unwrap();
         assert_eq!(input, "{t}");
         assert_eq!(
@@ -487,7 +481,7 @@ mod tests {
 
     #[test]
     fn test_parse_empty_string_segment() {
-        let result = parse_string_segment::<false>("");
+        let result = parse_string_segment("");
         assert!(result.is_err());
     }
 
@@ -647,6 +641,31 @@ mod tests {
     #[test]
     fn test_parse_double_nested_format() {
         let log_template = "{{[{L:<5}]%bold} {f:>20}:%<30} {s}";
-        assert!(true);
+        let expected_output = vec![
+            LogSegment::new(LogMetadata::NestedLogSegments(
+                vec![
+                    LogSegment::new(LogMetadata::NestedLogSegments(
+                        vec![
+                            LogSegment::new(LogMetadata::String("[".to_string())),
+                            LogSegment::new(LogMetadata::LogLevel)
+                                .with_alignment(Alignment::Left)
+                                .with_width(5),
+                            LogSegment::new(LogMetadata::String("]".to_string())),
+                        ]
+                    )).with_style(colored::Styles::Bold),
+                    LogSegment::new(LogMetadata::String(" ".to_string())),
+                    LogSegment::new(LogMetadata::FileName)
+                        .with_alignment(Alignment::Right)
+                        .with_width(20),
+                    LogSegment::new(LogMetadata::String(":".to_string())),
+                ]
+            ))
+            .with_alignment(Alignment::Left)
+            .with_width(30),
+            LogSegment::new(LogMetadata::String(" ".to_string())),
+            LogSegment::new(LogMetadata::Log),
+        ];
+        let result = parse(log_template);
+        assert_eq!(result, Ok(expected_output));
     }
 }

From cb1cd7d5281ea17bc18d38f61ab424eb66551403 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 16:24:39 +0200
Subject: [PATCH 04/19] Remove debug prints

---
 decoder/src/log/format.rs | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 4db58082..a5588375 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -170,7 +170,6 @@ pub fn take_until_unbalanced(
 }
 
 fn parse_metadata(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    println!("parse_metadata: \"{input}\"");
     let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| {
         let metadata = match s {
             "f" => LogMetadata::FileName,
@@ -189,7 +188,6 @@ fn parse_metadata(input: &str) -> IResult<&str, IntermediateOutput, ()> {
 }
 
 fn parse_color(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    println!("parse_color: \"{input}\"");
     let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| {
         let color = match s {
             "severity" => LogColor::SeverityLevel,
@@ -206,7 +204,6 @@ fn parse_color(input: &str) -> IResult<&str, IntermediateOutput, ()> {
 }
 
 fn parse_style(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    println!("parse_style: \"{input}\"");
     let mut parse_type = map_res(take_while(char::is_alphabetic), move |s| {
         let style = match s {
             "bold" => colored::Styles::Bold,
@@ -223,7 +220,6 @@ fn parse_style(input: &str) -> IResult<&str, IntermediateOutput, ()> {
 }
 
 fn parse_width_and_alignment(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    println!("parse_width_and_alignment: \"{input}\"");
     let (input, alignment) = opt(map_res(one_of("<^>"), move |c| match c {
         '^' => Ok(Alignment::Center),
         '<' => Ok(Alignment::Left),
@@ -257,7 +253,6 @@ fn parse_format<const FAIL_ON_ERR: bool>(input: &str) -> IResult<&str, Intermedi
 }
 
 fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutput>) -> Result<LogSegment, nom::Err<()>> {
-    println!("\nbuild_log_segment ({NEST}): {:?}", intermediate_output);
     let mut metadata = None;
     let mut color = None;
     let mut style = None;
@@ -266,11 +261,9 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
     for item in intermediate_output {
         match item {
             IntermediateOutput::Metadata(m) if metadata.is_none() => {
-                println!("Found metadata");
                 metadata = Some(m)
             },
             IntermediateOutput::Color(c) if color.is_none() => {
-                println!("Found color");
                 color = Some(c)
             },
             IntermediateOutput::Style(s) => {
@@ -278,27 +271,21 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
 
                 // A format with repeated style specifiers is not valid
                 if styles.contains(&s) {
-                    println!("Style fail");
                     return Err(nom::Err::Failure(()));
                 }
 
-                println!("Found style");
                 styles.push(s);
                 style = Some(styles);
             }
             IntermediateOutput::WidthAndAlignment(w) if width_and_alignment.is_none() => {
-                println!("Found width and alignment");
                 width_and_alignment = Some(w)
             }
             IntermediateOutput::NestedLogSegment(s) => {
                 let mut segments: Vec<LogSegment> = nested_segments.unwrap_or_default();
-
-                println!("Found nested");
                 segments.push(s);
                 nested_segments = Some(segments);
             }
             _ => {
-                println!("Intermediate output fail");
                 return Err(nom::Err::Failure(()))
             },
         }
@@ -306,7 +293,6 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
 
     if NEST {
         let Some(nested_segments) = nested_segments else {
-            println!("Nested segments fail");
             return Err(nom::Err::Failure(()));
         };
 
@@ -316,8 +302,6 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
         if !has_metadata_specifier {
             return Err(nom::Err::Failure(()));
         }
-
-        println!("Adding nested log segments to metadata for nested segment");
         metadata = Some(LogMetadata::NestedLogSegments(nested_segments));
     } else {
         // We either have nested segments, or a metadata specifier, we can't have both
@@ -340,7 +324,6 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
     }
 
     let Some(metadata) = metadata else {
-        println!("Metadata fail");
         return Err(nom::Err::Failure(()));
     };
 
@@ -361,8 +344,6 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
 
 
 fn parse_log_segment<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()> {
-    println!("IN parse_log_segment ({NEST}): \"{input}\"");
-
     let (input, output) = if !NEST {
         separated_list1(
             char(':'),
@@ -393,14 +374,11 @@ fn parse_log_segment<const NEST: bool>(input: &str) -> IResult<&str, LogSegment,
         )(input)
     }?;
 
-    println!("OUT parse_log_segment ({NEST}): \"{input}\"");
-
     let log_segment = build_log_segment::<false>(output)?;
     Ok((input, log_segment))
 }
 
 fn parse_argument<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()> {
-    println!("parse_argument ({NEST}): \"{input}\"");
     let take_between_matching_brackets = delimited(
         char('{'), 
         take_until_unbalanced('{', '}'), 
@@ -411,7 +389,6 @@ fn parse_argument<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()
 }
 
 fn parse_string_segment(input: &str) -> IResult<&str, LogSegment, ()> {
-    println!("parse_string_segment: \"{input}\"");
     map(take_till1(|c| c == '{' || c == '%'), |s: &str| {
         LogSegment::new(LogMetadata::String(s.to_string()))
     })
@@ -419,18 +396,13 @@ fn parse_string_segment(input: &str) -> IResult<&str, LogSegment, ()> {
 }
 
 fn parse_nested<const NEST: bool>(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    println!("\nIN parse_nested ({NEST}): \"{input}\" ----------------");
-
     let parse_nested_argument = map_res(parse_argument::<NEST>, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
     let parse_nested_string_segment = map_res(parse_string_segment, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
     let parse_nested_format = preceded(char('%'), parse_format::<true>);
     let mut parse_all = many0(alt((parse_nested_argument, parse_nested_string_segment, parse_nested_format)));
 
     let (new_input, output) = parse_all(input)?;
-
     let log_segment = build_log_segment::<true>(output)?;
-
-    println!("\nOUT parse_nested ({NEST}): \"{new_input}\" ---------------");
     Ok((new_input, IntermediateOutput::NestedLogSegment(log_segment)))
 }
 

From a0c784a87a79afe670dec3492551c07eff6bb130 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 16:25:27 +0200
Subject: [PATCH 05/19] cargo fmt

---
 decoder/src/log/format.rs | 123 ++++++++++++++++++--------------------
 1 file changed, 57 insertions(+), 66 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index a5588375..db654eb1 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -3,9 +3,9 @@ use nom::{
     bytes::complete::{take_till1, take_while},
     character::complete::{char, digit1, one_of},
     combinator::{map, map_res, opt},
+    error::{Error, ErrorKind, ParseError},
     multi::{many0, separated_list1},
     sequence::{delimited, preceded},
-    error::{Error, ErrorKind, ParseError},
     Err, IResult, Parser,
 };
 
@@ -236,11 +236,7 @@ fn parse_width_and_alignment(input: &str) -> IResult<&str, IntermediateOutput, (
 }
 
 fn parse_format<const FAIL_ON_ERR: bool>(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    let result = alt((
-        parse_color,
-        parse_style,
-        parse_width_and_alignment,
-    )).parse(input);
+    let result = alt((parse_color, parse_style, parse_width_and_alignment)).parse(input);
 
     if !FAIL_ON_ERR {
         result
@@ -252,7 +248,9 @@ fn parse_format<const FAIL_ON_ERR: bool>(input: &str) -> IResult<&str, Intermedi
     }
 }
 
-fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutput>) -> Result<LogSegment, nom::Err<()>> {
+fn build_log_segment<const NEST: bool>(
+    intermediate_output: Vec<IntermediateOutput>,
+) -> Result<LogSegment, nom::Err<()>> {
     let mut metadata = None;
     let mut color = None;
     let mut style = None;
@@ -260,12 +258,8 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
     let mut nested_segments = None;
     for item in intermediate_output {
         match item {
-            IntermediateOutput::Metadata(m) if metadata.is_none() => {
-                metadata = Some(m)
-            },
-            IntermediateOutput::Color(c) if color.is_none() => {
-                color = Some(c)
-            },
+            IntermediateOutput::Metadata(m) if metadata.is_none() => metadata = Some(m),
+            IntermediateOutput::Color(c) if color.is_none() => color = Some(c),
             IntermediateOutput::Style(s) => {
                 let mut styles: Vec<colored::Styles> = style.unwrap_or_default();
 
@@ -285,9 +279,7 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
                 segments.push(s);
                 nested_segments = Some(segments);
             }
-            _ => {
-                return Err(nom::Err::Failure(()))
-            },
+            _ => return Err(nom::Err::Failure(())),
         }
     }
 
@@ -298,7 +290,9 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
 
         // A nested segment must have at least a valid specifier such as {t} or {f},
         // it isn't allowed to have {foo} and consider foo a string segment.
-        let has_metadata_specifier = nested_segments.iter().any(|segment| segment.metadata.is_metadata_specifier());
+        let has_metadata_specifier = nested_segments
+            .iter()
+            .any(|segment| segment.metadata.is_metadata_specifier());
         if !has_metadata_specifier {
             return Err(nom::Err::Failure(()));
         }
@@ -342,26 +336,21 @@ fn build_log_segment<const NEST: bool>(intermediate_output: Vec<IntermediateOutp
     })
 }
 
-
 fn parse_log_segment<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()> {
     let (input, output) = if !NEST {
         separated_list1(
             char(':'),
-            alt((
-                parse_metadata,
-                parse_format::<false>,
-                parse_nested::<true>,
-            )),
+            alt((parse_metadata, parse_format::<false>, parse_nested::<true>)),
         )(input)
     } else {
-        let parse_nested_argument = separated_list1(
-            char(':'),
-            alt((parse_metadata, parse_format::<false>)),
-        );
+        let parse_nested_argument =
+            separated_list1(char(':'), alt((parse_metadata, parse_format::<false>)));
 
         let parse_nested_log_segment = map_res(parse_nested_argument, |result| {
             let log_segment = build_log_segment::<false>(result)?;
-            Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(log_segment))
+            Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(
+                log_segment,
+            ))
         });
 
         separated_list1(
@@ -379,13 +368,12 @@ fn parse_log_segment<const NEST: bool>(input: &str) -> IResult<&str, LogSegment,
 }
 
 fn parse_argument<const NEST: bool>(input: &str) -> IResult<&str, LogSegment, ()> {
-    let take_between_matching_brackets = delimited(
-        char('{'), 
-        take_until_unbalanced('{', '}'), 
-        char('}')
-    );
-    
-    take_between_matching_brackets.and_then(parse_log_segment::<NEST>).parse(input)
+    let take_between_matching_brackets =
+        delimited(char('{'), take_until_unbalanced('{', '}'), char('}'));
+
+    take_between_matching_brackets
+        .and_then(parse_log_segment::<NEST>)
+        .parse(input)
 }
 
 fn parse_string_segment(input: &str) -> IResult<&str, LogSegment, ()> {
@@ -396,10 +384,18 @@ fn parse_string_segment(input: &str) -> IResult<&str, LogSegment, ()> {
 }
 
 fn parse_nested<const NEST: bool>(input: &str) -> IResult<&str, IntermediateOutput, ()> {
-    let parse_nested_argument = map_res(parse_argument::<NEST>, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
-    let parse_nested_string_segment = map_res(parse_string_segment, |result| Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result)));
+    let parse_nested_argument = map_res(parse_argument::<NEST>, |result| {
+        Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result))
+    });
+    let parse_nested_string_segment = map_res(parse_string_segment, |result| {
+        Ok::<IntermediateOutput, nom::Err<()>>(IntermediateOutput::NestedLogSegment(result))
+    });
     let parse_nested_format = preceded(char('%'), parse_format::<true>);
-    let mut parse_all = many0(alt((parse_nested_argument, parse_nested_string_segment, parse_nested_format)));
+    let mut parse_all = many0(alt((
+        parse_nested_argument,
+        parse_nested_string_segment,
+        parse_nested_format,
+    )));
 
     let (new_input, output) = parse_all(input)?;
     let log_segment = build_log_segment::<true>(output)?;
@@ -584,16 +580,14 @@ mod tests {
     fn test_parse_single_nested_format() {
         let log_template = "{[{L:<5:bold}]%underline%italic} {s}";
         let expected_output = vec![
-            LogSegment::new(LogMetadata::NestedLogSegments(
-                vec![
-                    LogSegment::new(LogMetadata::String("[".to_string())),
-                    LogSegment::new(LogMetadata::LogLevel)
-                        .with_alignment(Alignment::Left)
-                        .with_width(5)
-                        .with_style(colored::Styles::Bold),
-                    LogSegment::new(LogMetadata::String("]".to_string())),
-                ]
-            ))
+            LogSegment::new(LogMetadata::NestedLogSegments(vec![
+                LogSegment::new(LogMetadata::String("[".to_string())),
+                LogSegment::new(LogMetadata::LogLevel)
+                    .with_alignment(Alignment::Left)
+                    .with_width(5)
+                    .with_style(colored::Styles::Bold),
+                LogSegment::new(LogMetadata::String("]".to_string())),
+            ]))
             .with_style(colored::Styles::Underline)
             .with_style(colored::Styles::Italic),
             LogSegment::new(LogMetadata::String(" ".to_string())),
@@ -614,24 +608,21 @@ mod tests {
     fn test_parse_double_nested_format() {
         let log_template = "{{[{L:<5}]%bold} {f:>20}:%<30} {s}";
         let expected_output = vec![
-            LogSegment::new(LogMetadata::NestedLogSegments(
-                vec![
-                    LogSegment::new(LogMetadata::NestedLogSegments(
-                        vec![
-                            LogSegment::new(LogMetadata::String("[".to_string())),
-                            LogSegment::new(LogMetadata::LogLevel)
-                                .with_alignment(Alignment::Left)
-                                .with_width(5),
-                            LogSegment::new(LogMetadata::String("]".to_string())),
-                        ]
-                    )).with_style(colored::Styles::Bold),
-                    LogSegment::new(LogMetadata::String(" ".to_string())),
-                    LogSegment::new(LogMetadata::FileName)
-                        .with_alignment(Alignment::Right)
-                        .with_width(20),
-                    LogSegment::new(LogMetadata::String(":".to_string())),
-                ]
-            ))
+            LogSegment::new(LogMetadata::NestedLogSegments(vec![
+                LogSegment::new(LogMetadata::NestedLogSegments(vec![
+                    LogSegment::new(LogMetadata::String("[".to_string())),
+                    LogSegment::new(LogMetadata::LogLevel)
+                        .with_alignment(Alignment::Left)
+                        .with_width(5),
+                    LogSegment::new(LogMetadata::String("]".to_string())),
+                ]))
+                .with_style(colored::Styles::Bold),
+                LogSegment::new(LogMetadata::String(" ".to_string())),
+                LogSegment::new(LogMetadata::FileName)
+                    .with_alignment(Alignment::Right)
+                    .with_width(20),
+                LogSegment::new(LogMetadata::String(":".to_string())),
+            ]))
             .with_alignment(Alignment::Left)
             .with_width(30),
             LogSegment::new(LogMetadata::String(" ".to_string())),

From 40a964c6349bfa1f9fee0bdec6807dbc8793fe09 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 16:27:31 +0200
Subject: [PATCH 06/19] cargo clippy

---
 decoder/src/log/format.rs | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index db654eb1..ebd4d570 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -3,10 +3,9 @@ use nom::{
     bytes::complete::{take_till1, take_while},
     character::complete::{char, digit1, one_of},
     combinator::{map, map_res, opt},
-    error::{Error, ErrorKind, ParseError},
     multi::{many0, separated_list1},
     sequence::{delimited, preceded},
-    Err, IResult, Parser,
+    IResult, Parser,
 };
 
 use std::str::FromStr;
@@ -29,10 +28,10 @@ impl LogMetadata {
     /// Checks whether this `LogMetadata` came from a specifier such as
     /// {t}, {f}, etc.
     fn is_metadata_specifier(&self) -> bool {
-        match self {
-            LogMetadata::String(_) | LogMetadata::NestedLogSegments(_) => false,
-            _ => true,
-        }
+        !matches!(
+            self,
+            LogMetadata::String(_) | LogMetadata::NestedLogSegments(_)
+        )
     }
 }
 
@@ -309,7 +308,7 @@ fn build_log_segment<const NEST: bool>(
         // If we have a nested segment there must be exactly one,
         // otherwise there's something weird going on
         if let Some(segments) = nested_segments {
-            if segments.iter().count() == 1 {
+            if segments.len() == 1 {
                 return Ok(segments[0].clone());
             } else {
                 return Err(nom::Err::Failure(()));

From f1c0544e649b7abe10234148bc4199172ec8046b Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 18:39:00 +0200
Subject: [PATCH 07/19] Implement support for printing nested formats

---
 decoder/src/log/stdout_logger.rs | 108 +++++++++++++++++--------------
 1 file changed, 59 insertions(+), 49 deletions(-)

diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index 53578f5d..096c6096 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -147,6 +147,7 @@ impl<'a> Printer<'a> {
     }
 
     /// Pads the defmt timestamp to take up at least the given number of characters.
+    /// TODO: Remove this, shouldn't be needed now that we have width field support
     pub fn min_timestamp_width(&mut self, min_timestamp_width: usize) -> &mut Self {
         self.min_timestamp_width = min_timestamp_width;
         self
@@ -155,42 +156,60 @@ 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.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),
-                _ => return Ok(())
-            }?;
+            let s = match &segment.metadata {
+                LogMetadata::String(s) => s.to_string(),
+                LogMetadata::Timestamp => self.build_timestamp(&segment.format),
+                LogMetadata::FileName => self.build_file_name(&segment.format),
+                LogMetadata::FilePath => self.build_file_path(&segment.format),
+                LogMetadata::ModulePath => self.build_module_path(&segment.format),
+                LogMetadata::LineNumber => self.build_line_number(&segment.format),
+                LogMetadata::LogLevel => self.build_log_level(&segment.format),
+                LogMetadata::Log => self.build_log(&segment.format),
+                LogMetadata::NestedLogSegments(segments) => self.build_nested(segments, &segment.format),
+            };
+
+            write!(sink, "{s}")?;
         }
         writeln!(sink)
     }
 
-    fn print_string<W: io::Write>(&self, sink: &mut W, s: &str) -> io::Result<()> {
-        write!(sink, "{s}")
+    fn build_nested(&self, segments: &[LogSegment], format: &LogFormat) -> String {
+        let mut result = String::new();
+        for segment in segments {
+            let s = match &segment.metadata {
+                LogMetadata::String(s) => s.to_string(),
+                LogMetadata::Timestamp => self.build_timestamp(&segment.format),
+                LogMetadata::FileName => self.build_file_name(&segment.format),
+                LogMetadata::FilePath => self.build_file_path(&segment.format),
+                LogMetadata::ModulePath => self.build_module_path(&segment.format),
+                LogMetadata::LineNumber => self.build_line_number(&segment.format),
+                LogMetadata::LogLevel => self.build_log_level(&segment.format),
+                LogMetadata::Log => self.build_log(&segment.format),
+                LogMetadata::NestedLogSegments(segments) => self.build_nested(segments, &segment.format),
+            };
+            result.push_str(&s);
+        }
+
+        build_formatted_string(&result, format, 0, self.record_log_level(), format.color)
     }
 
-    fn print_timestamp<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
+    fn build_timestamp(&self, format: &LogFormat) -> String {
         let s = match self.record {
             Record::Defmt(record) if !record.timestamp().is_empty() => record.timestamp(),
             _ => "<time>",
         }
         .to_string();
 
-        write_string(
+        build_formatted_string(
             s.as_str(),
-            sink,
             format,
             self.min_timestamp_width,
             self.record_log_level(),
+            format.color,
         )
     }
 
-    fn print_log_level<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
+    fn build_log_level(&self, format: &LogFormat) -> String {
         let s = match self.record_log_level() {
             Some(level) => level.to_string(),
             None => "<lvl>".to_string(),
@@ -198,9 +217,8 @@ impl<'a> Printer<'a> {
 
         let color = format.color.unwrap_or(LogColor::SeverityLevel);
 
-        write_string_with_color(
+        build_formatted_string(
             s.as_str(),
-            sink,
             format,
             5,
             self.record_log_level(),
@@ -208,17 +226,17 @@ impl<'a> Printer<'a> {
         )
     }
 
-    fn print_file_path<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
+    fn build_file_path(&self, format: &LogFormat) -> String {
         let file_path = match self.record {
             Record::Defmt(record) => record.file(),
             Record::Host(record) => record.file(),
         }
         .unwrap_or("<file>");
 
-        write_string(file_path, sink, format, 0, self.record_log_level())
+        build_formatted_string(file_path, format, 0, self.record_log_level(), format.color)
     }
 
-    fn print_file_name<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
+    fn build_file_name(&self, format: &LogFormat) -> String {
         let file = match self.record {
             Record::Defmt(record) => record.file(),
             Record::Host(record) => record.file(),
@@ -235,20 +253,20 @@ impl<'a> Printer<'a> {
             "<file>"
         };
 
-        write_string(s, sink, format, 0, self.record_log_level())
+        build_formatted_string(s, format, 0, self.record_log_level(), format.color)
     }
 
-    fn print_module_path<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
+    fn build_module_path(&self, format: &LogFormat) -> String {
         let s = match self.record {
             Record::Defmt(record) => record.module_path(),
             Record::Host(record) => record.module_path(),
         }
         .unwrap_or("<mod path>");
 
-        write_string(s, sink, format, 0, self.record_log_level())
+        build_formatted_string(s, format, 0, self.record_log_level(), format.color)
     }
 
-    fn print_line_number<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
+    fn build_line_number(&self, format: &LogFormat) -> String {
         let s = match self.record {
             Record::Defmt(record) => record.line(),
             Record::Host(record) => record.line(),
@@ -256,18 +274,19 @@ impl<'a> Printer<'a> {
         .unwrap_or(0)
         .to_string();
 
-        write_string(s.as_str(), sink, format, 4, self.record_log_level())
+        build_formatted_string(s.as_str(), format, 4, self.record_log_level(), format.color)
     }
 
-    fn print_log<W: io::Write>(&self, sink: &mut W, format: &LogFormat) -> io::Result<()> {
+    fn build_log(&self, format: &LogFormat) -> String {
         match self.record {
             Record::Defmt(record) => match color_diff(record.args().to_string()) {
-                Ok(s) => write!(sink, "{s}"),
-                Err(s) => write_string(s.as_str(), sink, format, 0, self.record_log_level()),
+                Ok(s) => s.to_string(),
+                Err(s) => {
+                    build_formatted_string(s.as_str(), format, 0, self.record_log_level(), format.color)
+                },
             },
             Record::Host(record) => {
-                let s = record.args().to_string();
-                write!(sink, "{s}")
+                record.args().to_string()
             }
         }
     }
@@ -402,24 +421,13 @@ fn apply_styles(s: ColoredString, log_style: Option<&Vec<Styles>>) -> ColoredStr
     stylized_string
 }
 
-fn write_string<W: io::Write>(
+fn build_formatted_string(
     s: &str,
-    sink: &mut W,
-    format: &LogFormat,
-    default_width: usize,
-    level: Option<Level>,
-) -> io::Result<()> {
-    write_string_with_color(s, sink, format, default_width, level, format.color)
-}
-
-fn write_string_with_color<W: io::Write>(
-    s: &str,
-    sink: &mut W,
     format: &LogFormat,
     default_width: usize,
     level: Option<Level>,
     log_color: Option<LogColor>,
-) -> io::Result<()> {
+) -> String {
     let s = ColoredString::from(s);
     let s = apply_color(s, log_color, level);
     let colored_str = apply_styles(s, format.style.as_ref());
@@ -427,9 +435,11 @@ fn write_string_with_color<W: io::Write>(
     let alignment = format.alignment.unwrap_or(Alignment::Left);
     let width = format.width.unwrap_or(default_width);
 
+    let mut result = String::new();
     match alignment {
-        Alignment::Left => write!(sink, "{colored_str:<0$}", width),
-        Alignment::Center => write!(sink, "{colored_str:^0$}", width),
-        Alignment::Right => write!(sink, "{colored_str:>0$}", width),
-    }
+        Alignment::Left => write!(&mut result, "{colored_str:<0$}", width),
+        Alignment::Center => write!(&mut result, "{colored_str:^0$}", width),
+        Alignment::Right => write!(&mut result, "{colored_str:>0$}", width),
+    }.expect("Failed to format string: \"{colored_str}\"");
+    result
 }

From 078fb3edf2e3728d7f72cdba5335fd0571a3b030 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 23:21:50 +0200
Subject: [PATCH 08/19] Add test for triple nested format

---
 decoder/src/log/format.rs | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index ebd4d570..877abe55 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -630,4 +630,33 @@ mod tests {
         let result = parse(log_template);
         assert_eq!(result, Ok(expected_output));
     }
+
+    #[test]
+    fn test_parse_triple_nested_format() {
+        let log_template = "{{{[{L:<5}]%bold} {f:>20}:%<30} {s}%werror}";
+        let expected_output = vec![LogSegment::new(LogMetadata::NestedLogSegments(vec![
+            LogSegment::new(LogMetadata::NestedLogSegments(vec![
+                LogSegment::new(LogMetadata::NestedLogSegments(vec![
+                    LogSegment::new(LogMetadata::String("[".to_string())),
+                    LogSegment::new(LogMetadata::LogLevel)
+                        .with_alignment(Alignment::Left)
+                        .with_width(5),
+                    LogSegment::new(LogMetadata::String("]".to_string())),
+                ]))
+                .with_style(colored::Styles::Bold),
+                LogSegment::new(LogMetadata::String(" ".to_string())),
+                LogSegment::new(LogMetadata::FileName)
+                    .with_alignment(Alignment::Right)
+                    .with_width(20),
+                LogSegment::new(LogMetadata::String(":".to_string())),
+            ]))
+            .with_alignment(Alignment::Left)
+            .with_width(30),
+            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));
+    }
 }

From 39ce78058915be4705c8307cca0be3e4bcdb013e Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 23:22:12 +0200
Subject: [PATCH 09/19] cargo fmt

---
 decoder/src/log/stdout_logger.rs | 33 ++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/decoder/src/log/stdout_logger.rs b/decoder/src/log/stdout_logger.rs
index 096c6096..0b0997ee 100644
--- a/decoder/src/log/stdout_logger.rs
+++ b/decoder/src/log/stdout_logger.rs
@@ -165,7 +165,9 @@ impl<'a> Printer<'a> {
                 LogMetadata::LineNumber => self.build_line_number(&segment.format),
                 LogMetadata::LogLevel => self.build_log_level(&segment.format),
                 LogMetadata::Log => self.build_log(&segment.format),
-                LogMetadata::NestedLogSegments(segments) => self.build_nested(segments, &segment.format),
+                LogMetadata::NestedLogSegments(segments) => {
+                    self.build_nested(segments, &segment.format)
+                }
             };
 
             write!(sink, "{s}")?;
@@ -185,7 +187,9 @@ impl<'a> Printer<'a> {
                 LogMetadata::LineNumber => self.build_line_number(&segment.format),
                 LogMetadata::LogLevel => self.build_log_level(&segment.format),
                 LogMetadata::Log => self.build_log(&segment.format),
-                LogMetadata::NestedLogSegments(segments) => self.build_nested(segments, &segment.format),
+                LogMetadata::NestedLogSegments(segments) => {
+                    self.build_nested(segments, &segment.format)
+                }
             };
             result.push_str(&s);
         }
@@ -217,13 +221,7 @@ impl<'a> Printer<'a> {
 
         let color = format.color.unwrap_or(LogColor::SeverityLevel);
 
-        build_formatted_string(
-            s.as_str(),
-            format,
-            5,
-            self.record_log_level(),
-            Some(color),
-        )
+        build_formatted_string(s.as_str(), format, 5, self.record_log_level(), Some(color))
     }
 
     fn build_file_path(&self, format: &LogFormat) -> String {
@@ -281,13 +279,15 @@ impl<'a> Printer<'a> {
         match self.record {
             Record::Defmt(record) => match color_diff(record.args().to_string()) {
                 Ok(s) => s.to_string(),
-                Err(s) => {
-                    build_formatted_string(s.as_str(), format, 0, self.record_log_level(), format.color)
-                },
+                Err(s) => build_formatted_string(
+                    s.as_str(),
+                    format,
+                    0,
+                    self.record_log_level(),
+                    format.color,
+                ),
             },
-            Record::Host(record) => {
-                record.args().to_string()
-            }
+            Record::Host(record) => record.args().to_string(),
         }
     }
 
@@ -440,6 +440,7 @@ fn build_formatted_string(
         Alignment::Left => write!(&mut result, "{colored_str:<0$}", width),
         Alignment::Center => write!(&mut result, "{colored_str:^0$}", width),
         Alignment::Right => write!(&mut result, "{colored_str:>0$}", width),
-    }.expect("Failed to format string: \"{colored_str}\"");
+    }
+    .expect("Failed to format string: \"{colored_str}\"");
     result
 }

From 2acab3d59e5432d23a1e738ba18696253affa29d Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 23:53:56 +0200
Subject: [PATCH 10/19] Fix format strings without log specifiers being
 accepted as valid formats

---
 decoder/src/log/format.rs | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 877abe55..82de15de 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -401,12 +401,29 @@ fn parse_nested<const NEST: bool>(input: &str) -> IResult<&str, IntermediateOutp
     Ok((new_input, IntermediateOutput::NestedLogSegment(log_segment)))
 }
 
+fn format_contains_log_specifier(segments: &[LogSegment]) -> bool {
+    for segment in segments {
+        match &segment.metadata {
+            LogMetadata::Log => return true,
+            LogMetadata::NestedLogSegments(s) => return format_contains_log_specifier(s),
+            _ => continue,
+        }
+    }
+    false
+}
+
 pub(super) fn parse(input: &str) -> Result<Vec<LogSegment>, String> {
     let mut parse_all = many0(alt((parse_argument::<false>, parse_string_segment)));
 
-    parse_all(input)
+    let result = parse_all(input)
         .map(|(_, output)| output)
-        .map_err(|e| e.to_string())
+        .map_err(|e| e.to_string())?;
+
+    if !format_contains_log_specifier(&result) {
+        return Err("log format must contain a `{s}` format specifier".to_string());
+    }
+
+    Ok(result)
 }
 
 #[cfg(test)]
@@ -435,6 +452,12 @@ mod tests {
         assert_eq!(result, Ok(expected_output));
     }
 
+    #[test]
+    fn test_parse_format_without_log() {
+        let result = parse("{t}");
+        assert!(result.is_err());
+    }
+
     #[test]
     fn test_parse_string_segment() {
         let result = parse_string_segment("Log: {t}");

From d70401c558b1ace1f382d06058d68079d4584916 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Sun, 1 Oct 2023 23:58:26 +0200
Subject: [PATCH 11/19] Fix format_contains_log_specifier

---
 decoder/src/log/format.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 82de15de..57bc115d 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -405,7 +405,11 @@ fn format_contains_log_specifier(segments: &[LogSegment]) -> bool {
     for segment in segments {
         match &segment.metadata {
             LogMetadata::Log => return true,
-            LogMetadata::NestedLogSegments(s) => return format_contains_log_specifier(s),
+            LogMetadata::NestedLogSegments(s) => {
+                if format_contains_log_specifier(s) {
+                    return true;
+                }
+            },
             _ => continue,
         }
     }

From 3992dd5998cccf9b49e2d9a68d7e9996eb3e46f2 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Mon, 2 Oct 2023 01:03:51 +0200
Subject: [PATCH 12/19] Add documentation

---
 decoder/src/log/format.rs | 178 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 175 insertions(+), 3 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 57bc115d..e6f24b7e 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -1,3 +1,120 @@
+//! Formatting for `defmt` log frames.
+//!
+//! This module contains the parsers for the `defmt` custom log formatting strings.
+//!
+//! # Format strings
+//!
+//! A format string takes a set of [format specifiers] written
+//! in the way a log should be printed by the logger.
+//! 
+//! ## Basics
+//! 
+//! Format strings allow the customization of how the logger prints logs.
+//! 
+//! The following log will be used as reference in the examples below:
+//! 
+//! ```
+//! defmt::error!("hello");
+//! ```
+//! 
+//! The simplest format string is `"{s}"`. This prints the log and nothing else:
+//! 
+//! ```text
+//! hello
+//! ```
+//! 
+//! Arbitrary text can be added to the format string, which will be printed as specified with each log.
+//! For example, `"Log: {s}"`:
+//! 
+//! ```text
+//! Log: hello
+//! ```
+//! 
+//! Multiple specifiers can be included within a format string, in any order. For example `"[{L}] {s}"` prints:
+//! 
+//! ```text
+//! [ERROR] hello
+//! ```
+//! 
+//! ## Customizing log segments
+//! 
+//! The way a format specifier is printed can be customized by providing additional, optional [format parameters].
+//! 
+//! Format parameters are provided by adding the parameters after the format specifier, separated by colons (`:`),
+//! like this: `"{L:bold:5} {f:white:<10} {s}"`.
+//! 
+//! ### Color
+//! 
+//! A log segment can be specified to be colored by providing a color in the format parameters.
+//! 
+//! There are three different options for coloring a log segment:
+//! - a string that can be parsed by the FromStr implementation of [colored::Color].
+//! - `severity` colors the log segment using the predefined color for the log level of log.
+//! - `werror` is similar to `severity`, but it only applies the color if the log level is WARN or ERROR.
+//! 
+//! Only one coloring option can be provided in format parameters for a given format specifier.
+//! 
+//! ### Styles
+//! 
+//! A log segment can be specified to be printed with a given style by providing a style in the format parameters.
+//! 
+//! The style specifier must be one of the following strings:
+//! - `bold`
+//! - `italic`
+//! - `underline`
+//! - `strike`
+//! - `dimmed`
+//! 
+//! Multiple styles can be applied to a single format specifier, but they must not be repeated, i.e.
+//! `"{s:bold:underline:italic}"` is allowed, but `"{s:bold:bold}"` isn't.
+//! 
+//! ### Width and alignment
+//! 
+//! A log segment can be specified to be printed with a given minimum width and alignment by providing a format parameter.
+//! 
+//! The alignment can be specified to be left (`<`), right (`>`), or center-aligned (`^`).
+//! If no alignment is specified, left alignment is used by default.
+//! 
+//! The minimum width is specified after the alignment
+//! 
+//! For example, "{L} {f:>10}: {s}" is printed as follows:
+//! 
+//! ```text
+//! [ERROR]    main.rs: hello
+//! ```
+//! 
+//! ## Nested formatting
+//! 
+//! Log segments can be grouped and formatted together by nesting formats. Format parameters for the grouped log segments
+//! must be provided after the group, separated by `%`.
+//! 
+//! Nested formats allow for more intricate formatting. For example, `"{[{L:bold}]%underline} {s}"` prints
+//! 
+//! ```text
+//! [ERROR] hello
+//! ```
+//! 
+//! where `ERROR` is formatted bold, and `[ERROR]` is underlined.
+//! 
+//! Formats can be nested several levels. This provides a great level of flexibility to customize the logger formatting.
+//! For example, the width and alignment of a group of log segments can be specified with nested formats.
+//! `"{{[{L}]%bold} {f:>20}:%<35} {s}"` prints:
+//! 
+//! ```text
+//! [ERROR]              main.rs:       hello
+//! ```
+//! 
+//! ## Restrictions
+//! 
+//! - Format strings *must* include the `{s}` format specifier (log specifier).
+//! - At the moment it is not possible to escape curly brackets (i.e. `{`, `}`)
+//! in the format string, therefore curly brackets cannot be printed as part
+//! of the logger format.
+//! - The same restriction exists for the `%` character.
+//! 
+//! [format specifiers]: LogMetadata
+//! [format parameters]: LogFormat
+
 use nom::{
     branch::alt,
     bytes::complete::{take_till1, take_while},
@@ -10,17 +127,63 @@ use nom::{
 
 use std::str::FromStr;
 
+/// Representation of what a [LogSegment] can be.
 #[derive(Debug, PartialEq, Clone)]
 #[non_exhaustive]
 pub(super) enum LogMetadata {
+    /// `{f}` format specifier.
+    ///
+    /// For a file "src/foo/bar.rs", this option prints "bar.rs".
     FileName,
+
+    /// `{F}` format specifier.
+    ///
+    /// For a file "src/foo/bar.rs", this option prints "src/foo/bar.rs".
     FilePath,
+
+    /// `{l}` format specifier.
+    ///
+    /// Prints the line number where the log is coming from.
     LineNumber,
+
+    /// `{s}` format specifier.
+    ///
+    /// Prints the actual log contents.
+    /// For `defmt::info!("hello")`, this prints "hello".
     Log,
+
+    /// `{L}` format specifier.
+    ///
+    /// Prints the log level.
+    /// For `defmt::info!("hello")`, this prints "INFO".
     LogLevel,
+
+    /// `{m}` format specifier.
+    ///
+    /// Prints the module path of the function where the log is coming from.
+    /// For the following log:
+    ///
+    /// ```
+    /// // crate: my_crate
+    /// mod foo {
+    ///     fn bar() {
+    ///         defmt::info!("hello");
+    ///     }
+    /// }
+    /// ```
+    /// this prints "my_crate::foo::bar".
     ModulePath,
+
+    /// Represents the parts of the formatting string that is not specifiers.
     String(String),
+
+    /// `{t}` format specifier.
+    ///
+    /// Prints the timestamp at which something was logged.
+    /// For a log printed with a timestamp 123456 ms, this prints "123456".
     Timestamp,
+
+    /// Represents formats specified within nested curly brackets in the formatting string.
     NestedLogSegments(Vec<LogSegment>),
 }
 
@@ -35,19 +198,27 @@ impl LogMetadata {
     }
 }
 
+/// Coloring options for [LogSegment]s.
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub(super) enum LogColor {
-    /// User-defined color
+    /// User-defined color.
+    /// 
+    /// Use a string that can be parsed by the FromStr implementation
+    /// of [colored::Color].
     Color(colored::Color),
 
-    /// Color matching the default color for the log level
+    /// Color matching the default color for the log level.
+    /// Use `"severity"` as a format parameter to use this option.
     SeverityLevel,
 
     /// Color matching the default color for the log level,
-    /// but only if the log level is WARN or ERROR
+    /// but only if the log level is WARN or ERROR.
+    /// 
+    /// Use `"werror"` as a format parameter to use this option.
     WarnError,
 }
 
+/// Alignment options for [LogSegment]s.
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub(super) enum Alignment {
     Center,
@@ -55,6 +226,7 @@ pub(super) enum Alignment {
     Right,
 }
 
+/// Representation of a segment of the formatting string.
 #[derive(Debug, PartialEq, Clone)]
 pub(super) struct LogSegment {
     pub(super) metadata: LogMetadata,

From a513c12bcd8819e0afc594e053e2e115e3571762 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Mon, 2 Oct 2023 01:04:25 +0200
Subject: [PATCH 13/19] cargo fmt

---
 decoder/src/log/format.rs | 80 +++++++++++++++++++--------------------
 1 file changed, 40 insertions(+), 40 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index e6f24b7e..7ffda1c6 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -6,112 +6,112 @@
 //!
 //! A format string takes a set of [format specifiers] written
 //! in the way a log should be printed by the logger.
-//! 
+//!
 //! ## Basics
-//! 
+//!
 //! Format strings allow the customization of how the logger prints logs.
-//! 
+//!
 //! The following log will be used as reference in the examples below:
-//! 
+//!
 //! ```
 //! defmt::error!("hello");
 //! ```
-//! 
+//!
 //! The simplest format string is `"{s}"`. This prints the log and nothing else:
-//! 
+//!
 //! ```text
 //! hello
 //! ```
-//! 
+//!
 //! Arbitrary text can be added to the format string, which will be printed as specified with each log.
 //! For example, `"Log: {s}"`:
-//! 
+//!
 //! ```text
 //! Log: hello
 //! ```
-//! 
+//!
 //! Multiple specifiers can be included within a format string, in any order. For example `"[{L}] {s}"` prints:
-//! 
+//!
 //! ```text
 //! [ERROR] hello
 //! ```
-//! 
+//!
 //! ## Customizing log segments
-//! 
+//!
 //! The way a format specifier is printed can be customized by providing additional, optional [format parameters].
-//! 
+//!
 //! Format parameters are provided by adding the parameters after the format specifier, separated by colons (`:`),
 //! like this: `"{L:bold:5} {f:white:<10} {s}"`.
-//! 
+//!
 //! ### Color
-//! 
+//!
 //! A log segment can be specified to be colored by providing a color in the format parameters.
-//! 
+//!
 //! There are three different options for coloring a log segment:
 //! - a string that can be parsed by the FromStr implementation of [colored::Color].
 //! - `severity` colors the log segment using the predefined color for the log level of log.
 //! - `werror` is similar to `severity`, but it only applies the color if the log level is WARN or ERROR.
-//! 
+//!
 //! Only one coloring option can be provided in format parameters for a given format specifier.
-//! 
+//!
 //! ### Styles
-//! 
+//!
 //! A log segment can be specified to be printed with a given style by providing a style in the format parameters.
-//! 
+//!
 //! The style specifier must be one of the following strings:
 //! - `bold`
 //! - `italic`
 //! - `underline`
 //! - `strike`
 //! - `dimmed`
-//! 
+//!
 //! Multiple styles can be applied to a single format specifier, but they must not be repeated, i.e.
 //! `"{s:bold:underline:italic}"` is allowed, but `"{s:bold:bold}"` isn't.
-//! 
+//!
 //! ### Width and alignment
-//! 
+//!
 //! A log segment can be specified to be printed with a given minimum width and alignment by providing a format parameter.
-//! 
+//!
 //! The alignment can be specified to be left (`<`), right (`>`), or center-aligned (`^`).
 //! If no alignment is specified, left alignment is used by default.
-//! 
+//!
 //! The minimum width is specified after the alignment
-//! 
+//!
 //! For example, "{L} {f:>10}: {s}" is printed as follows:
-//! 
+//!
 //! ```text
 //! [ERROR]    main.rs: hello
 //! ```
-//! 
+//!
 //! ## Nested formatting
-//! 
+//!
 //! Log segments can be grouped and formatted together by nesting formats. Format parameters for the grouped log segments
 //! must be provided after the group, separated by `%`.
-//! 
+//!
 //! Nested formats allow for more intricate formatting. For example, `"{[{L:bold}]%underline} {s}"` prints
-//! 
+//!
 //! ```text
 //! [ERROR] hello
 //! ```
-//! 
+//!
 //! where `ERROR` is formatted bold, and `[ERROR]` is underlined.
-//! 
+//!
 //! Formats can be nested several levels. This provides a great level of flexibility to customize the logger formatting.
 //! For example, the width and alignment of a group of log segments can be specified with nested formats.
 //! `"{{[{L}]%bold} {f:>20}:%<35} {s}"` prints:
-//! 
+//!
 //! ```text
 //! [ERROR]              main.rs:       hello
 //! ```
-//! 
+//!
 //! ## Restrictions
-//! 
+//!
 //! - Format strings *must* include the `{s}` format specifier (log specifier).
 //! - At the moment it is not possible to escape curly brackets (i.e. `{`, `}`)
 //! in the format string, therefore curly brackets cannot be printed as part
 //! of the logger format.
 //! - The same restriction exists for the `%` character.
-//! 
+//!
 //! [format specifiers]: LogMetadata
 //! [format parameters]: LogFormat
 
@@ -202,7 +202,7 @@ impl LogMetadata {
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub(super) enum LogColor {
     /// User-defined color.
-    /// 
+    ///
     /// Use a string that can be parsed by the FromStr implementation
     /// of [colored::Color].
     Color(colored::Color),
@@ -213,7 +213,7 @@ pub(super) enum LogColor {
 
     /// Color matching the default color for the log level,
     /// but only if the log level is WARN or ERROR.
-    /// 
+    ///
     /// Use `"werror"` as a format parameter to use this option.
     WarnError,
 }
@@ -581,7 +581,7 @@ fn format_contains_log_specifier(segments: &[LogSegment]) -> bool {
                 if format_contains_log_specifier(s) {
                     return true;
                 }
-            },
+            }
             _ => continue,
         }
     }

From a1bc819f34b1784329cf2d8832374dd586120163 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Mon, 2 Oct 2023 01:08:03 +0200
Subject: [PATCH 14/19] Improve documentation

---
 decoder/src/log/format.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 7ffda1c6..dfa80b81 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -75,13 +75,14 @@
 //! The alignment can be specified to be left (`<`), right (`>`), or center-aligned (`^`).
 //! If no alignment is specified, left alignment is used by default.
 //!
-//! The minimum width is specified after the alignment
-//!
+//! The minimum width is specified after the alignment.
 //! For example, "{L} {f:>10}: {s}" is printed as follows:
 //!
 //! ```text
 //! [ERROR]    main.rs: hello
 //! ```
+//! 
+//! The log level format specifier is printed with a minimum width of 5 by default.
 //!
 //! ## Nested formatting
 //!

From 971b4740f1e8bda0a50370aff351fab3a63a9819 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Mon, 2 Oct 2023 01:25:42 +0200
Subject: [PATCH 15/19] Update CHANGELOG.md

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

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f09a8ee3..e08fde65 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,11 +7,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- [#778]: `defmt-decoder`: Add support for nested log formatting
 - [#777]: `defmt-decoder`: Simplify StdoutLogger
 - [#775]: `defmt-decoder`: Ignore AArch64 mapping symbols
 - [#771]: `defmt-macros`: Ignore empty items in DEFMT_LOG
 - [#769]: `defmt-decoder`: Add support for color, style, width and alignment to format
 
+[#778]: https://github.com/knurling-rs/defmt/pull/778
 [#777]: https://github.com/knurling-rs/defmt/pull/777
 [#775]: https://github.com/knurling-rs/defmt/pull/775
 [#771]: https://github.com/knurling-rs/defmt/pull/771

From ae7abd2347f1afcf427916832273fe0489cbeafb Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Mon, 2 Oct 2023 01:36:07 +0200
Subject: [PATCH 16/19] Ignore code blocks in documentation for cargo test

---
 decoder/src/log/format.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index dfa80b81..41a2e41b 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -13,7 +13,7 @@
 //!
 //! The following log will be used as reference in the examples below:
 //!
-//! ```
+//! ```ignore
 //! defmt::error!("hello");
 //! ```
 //!
@@ -164,7 +164,7 @@ pub(super) enum LogMetadata {
     /// Prints the module path of the function where the log is coming from.
     /// For the following log:
     ///
-    /// ```
+    /// ```ignore
     /// // crate: my_crate
     /// mod foo {
     ///     fn bar() {

From 03e92e3e0384c4a5f92f84f43001e1c15fafdda5 Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Mon, 2 Oct 2023 01:36:35 +0200
Subject: [PATCH 17/19] Doc fix

---
 decoder/src/log/format.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 41a2e41b..7337807c 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -109,8 +109,8 @@
 //!
 //! - Format strings *must* include the `{s}` format specifier (log specifier).
 //! - At the moment it is not possible to escape curly brackets (i.e. `{`, `}`)
-//! in the format string, therefore curly brackets cannot be printed as part
-//! of the logger format.
+//!   in the format string, therefore curly brackets cannot be printed as part
+//!   of the logger format.
 //! - The same restriction exists for the `%` character.
 //!
 //! [format specifiers]: LogMetadata

From 98e6ffd99cccd1ebeb37002082426ec48631939f Mon Sep 17 00:00:00 2001
From: "Andres O. Vela" <andresovela@gmail.com>
Date: Mon, 2 Oct 2023 01:38:23 +0200
Subject: [PATCH 18/19] cargo fmt

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

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 7337807c..0b20f659 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -81,7 +81,7 @@
 //! ```text
 //! [ERROR]    main.rs: hello
 //! ```
-//! 
+//!
 //! The log level format specifier is printed with a minimum width of 5 by default.
 //!
 //! ## Nested formatting

From 5d25fa9da9825b13f3aa7ba411733c548a29a450 Mon Sep 17 00:00:00 2001
From: Johann Hemmann <johann.hemmann@code.berlin>
Date: Mon, 2 Oct 2023 16:16:25 +0200
Subject: [PATCH 19/19] Update decoder/src/log/format.rs

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

diff --git a/decoder/src/log/format.rs b/decoder/src/log/format.rs
index 0b20f659..0cfb8654 100644
--- a/decoder/src/log/format.rs
+++ b/decoder/src/log/format.rs
@@ -48,7 +48,7 @@
 //! A log segment can be specified to be colored by providing a color in the format parameters.
 //!
 //! There are three different options for coloring a log segment:
-//! - a string that can be parsed by the FromStr implementation of [colored::Color].
+//! - a string that can be parsed by the FromStr implementation of [colored::Color] (`red`, `green` etc.).
 //! - `severity` colors the log segment using the predefined color for the log level of log.
 //! - `werror` is similar to `severity`, but it only applies the color if the log level is WARN or ERROR.
 //!