Allow custom formatting (#37)

* Initial suppport for entering and exiting custom formatting

Argument parsing done

* Added example/test for custom formatting

* Custom formatting now works, just needs examples, and better errors

* Seperated the code for parsing custom formating

* the parser for custom formatting gives back more reasonable errors

Also fixed bug in parser which lead to non interpolated things being interpolated

* custom formatting also for return values use {r}  to interpolate return values

the parser is getting a drop messy

* added some documentation for custom formatting

* more clean up from implementing custom formatting

* made the logic for format_exit a little more simple

* added error for when pretty and custom formatting are used together

* changed custom formatting interpolation

custom formatting interpolation now follows (mostly) the same rules as `fomat!`
custom formatting interpolation now report (mostly) the same errors as `format!`
fixed some copy pasted error reporting

* Apply suggestions from code review

---------

Co-authored-by: Gulshan Singh <[email protected]>

Author: mendelsshop

examples/example_custom_format.rs

@@ -0,0 +1,19 @@
+use trace::trace;
+
+trace::init_depth_var!();
+
+fn main() {
+    foo(5, 4);
+}
+
+#[trace(format_enter = "{y} and {z} {{7}}", format_exit = "{r} * {r}")]
+fn foo(z: u32, y: u32) -> u32 {
+    z
+}
+
+#[cfg(test)]
+#[macro_use]
+mod trace_test;
+
+#[cfg(test)]
+trace_test!(test_custom_format, main());

examples/expected_test_outputs/test_custom_format.expected

@@ -0,0 +1,2 @@
+[+] Entering foo(4 and 5 {7})
+[-] Exiting foo = 5 * 5

src/args.rs

@@ -5,6 +5,8 @@ use syn::{self, spanned::Spanned};
 pub(crate) struct Args {
     pub(crate) prefix_enter: String,
     pub(crate) prefix_exit: String,
+    pub(crate) format_enter: Option<String>,
+    pub(crate) format_exit: Option<String>,
     pub(crate) filter: Filter,
     pub(crate) pause: bool,
     pub(crate) pretty: bool,
@@ -23,6 +25,17 @@ const DEFAULT_PAUSE: bool = false;
 const DEFAULT_PRETTY: bool = false;
 const DEFAULT_LOGGING: bool = false;
 
+macro_rules! try_extract_str {
+    ($lit:expr, $meta:expr, $arg_ty:ident) => {{
+        match *$lit {
+            syn::Lit::Str(ref lit_str) => Ok(Arg::$arg_ty($meta.span(), lit_str.value())),
+            _ => Err(vec![syn::Error::new_spanned(
+                $lit,
+                format!("`{}` must have a string value", stringify!($arg_ty)),
+            )]),
+        }
+    }};
+}
 impl Args {
     pub(crate) fn from_raw_args(raw_args: syn::AttributeArgs) -> Result<Self, Vec<syn::Error>> {
         // Different types of arguments accepted by `#[trace]`;
@@ -35,6 +48,8 @@ impl Args {
             Pause(proc_macro2::Span, bool),
             Pretty(proc_macro2::Span, bool),
             Logging(proc_macro2::Span, bool),
+            FormatEnter(proc_macro2::Span, String),
+            FormatExit(proc_macro2::Span, String),
         }
 
         // Parse arguments
@@ -43,6 +58,8 @@ impl Args {
                 enum ArgName {
                     PrefixEnter,
                     PrefixExit,
+                    FormatEnter,
+                    FormatExit,
                     Enable,
                     Disable,
                     Pause,
@@ -54,6 +71,8 @@ impl Args {
                 let arg_name = match ident.to_string().as_str() {
                     "prefix_enter" => ArgName::PrefixEnter,
                     "prefix_exit" => ArgName::PrefixExit,
+                    "format_enter" => ArgName::FormatEnter,
+                    "format_exit" => ArgName::FormatExit,
                     "enable" => ArgName::Enable,
                     "disable" => ArgName::Disable,
                     "pause" => ArgName::Pause,
@@ -79,6 +98,18 @@ impl Args {
                         "`prefix_exit` requires a string value",
                     )]
                 };
+                let format_enter_type_error = || {
+                    vec![syn::Error::new_spanned(
+                        ident.clone(),
+                        "`format_enter` requires a string value",
+                    )]
+                };
+                let format_exit_type_error = || {
+                    vec![syn::Error::new_spanned(
+                        ident.clone(),
+                        "`format_exit` requires a string value",
+                    )]
+                };
                 let enable_type_error = || {
                     vec![syn::Error::new_spanned(
                         ident.clone(),
@@ -115,11 +146,12 @@ impl Args {
                         ArgName::Pause => Ok(Arg::Pause(meta.span(), true)),
                         ArgName::Pretty => Ok(Arg::Pretty(meta.span(), true)),
                         ArgName::Logging => Ok(Arg::Logging(meta.span(), true)),
-
                         ArgName::PrefixEnter => Err(prefix_enter_type_error()),
                         ArgName::PrefixExit => Err(prefix_exit_type_error()),
                         ArgName::Enable => Err(enable_type_error()),
                         ArgName::Disable => Err(disable_type_error()),
+                        ArgName::FormatEnter => Err(format_enter_type_error()),
+                        ArgName::FormatExit => Err(format_exit_type_error()),
                     },
                     syn::Meta::List(syn::MetaList { ref nested, .. }) => match arg_name {
                         ArgName::Enable => {
@@ -172,27 +204,14 @@ impl Args {
                         ArgName::Pause => Err(pause_type_error()),
                         ArgName::Pretty => Err(pretty_type_error()),
                         ArgName::Logging => Err(logging_type_error()),
+                        ArgName::FormatEnter => Err(format_enter_type_error()),
+                        ArgName::FormatExit => Err(format_exit_type_error()),
                     },
                     syn::Meta::NameValue(syn::MetaNameValue { ref lit, .. }) => match arg_name {
-                        ArgName::PrefixEnter => match *lit {
-                            syn::Lit::Str(ref lit_str) => {
-                                Ok(Arg::PrefixEnter(meta.span(), lit_str.value()))
-                            }
-                            _ => Err(vec![syn::Error::new_spanned(
-                                lit,
-                                "`prefix_enter` must have a string value",
-                            )]),
-                        },
-                        ArgName::PrefixExit => match *lit {
-                            syn::Lit::Str(ref lit_str) => {
-                                Ok(Arg::PrefixExit(meta.span(), lit_str.value()))
-                            }
-                            _ => Err(vec![syn::Error::new_spanned(
-                                lit,
-                                "`prefix_exit` must have a string value",
-                            )]),
-                        },
-
+                        ArgName::PrefixEnter => try_extract_str!(lit, meta, PrefixEnter),
+                        ArgName::PrefixExit => try_extract_str!(lit, meta, PrefixExit),
+                        ArgName::FormatEnter => try_extract_str!(lit, meta, FormatEnter),
+                        ArgName::FormatExit => try_extract_str!(lit, meta, FormatExit),
                         ArgName::Enable => Err(enable_type_error()),
                         ArgName::Disable => Err(disable_type_error()),
                         ArgName::Pause => Err(pause_type_error()),
@@ -209,6 +228,8 @@ impl Args {
 
         let mut prefix_enter_args = vec![];
         let mut prefix_exit_args = vec![];
+        let mut format_enter_args = vec![];
+        let mut format_exit_args = vec![];
         let mut enable_args = vec![];
         let mut disable_args = vec![];
         let mut pause_args = vec![];
@@ -227,6 +248,8 @@ impl Args {
                     Arg::Pause(span, b) => pause_args.push((span, b)),
                     Arg::Pretty(span, b) => pretty_args.push((span, b)),
                     Arg::Logging(span, b) => logging_args.push((span, b)),
+                    Arg::FormatEnter(span, s) => format_enter_args.push((span, s)),
+                    Arg::FormatExit(span, s) => format_exit_args.push((span, s)),
                 },
                 Err(es) => errors.extend(es),
             }
@@ -247,6 +270,20 @@ impl Args {
                     .map(|(span, _)| syn::Error::new(*span, "duplicate `prefix_exit`")),
             );
         }
+        if format_enter_args.len() >= 2 {
+            errors.extend(
+                format_enter_args
+                    .iter()
+                    .map(|(span, _)| syn::Error::new(*span, "duplicate `format_enter`")),
+            );
+        }
+        if format_exit_args.len() >= 2 {
+            errors.extend(
+                format_exit_args
+                    .iter()
+                    .map(|(span, _)| syn::Error::new(*span, "duplicate `format_exit`")),
+            );
+        }
         if enable_args.len() >= 2 {
             errors.extend(
                 enable_args
@@ -294,6 +331,26 @@ impl Args {
                 "cannot have both `enable` and `disable`",
             ));
         }
+        if pretty_args.len() == 1 && format_enter_args.len() == 1 {
+            errors.push(syn::Error::new(
+                pretty_args[0].0,
+                "cannot have both `pretty` and `format_enter`",
+            ));
+            errors.push(syn::Error::new(
+                format_enter_args[0].0,
+                "cannot have both `pretty` and `format_enter`",
+            ));
+        }
+        if pretty_args.len() == 1 && format_exit_args.len() == 1 {
+            errors.push(syn::Error::new(
+                pretty_args[0].0,
+                "cannot have both `pretty` and `format_exit`",
+            ));
+            errors.push(syn::Error::new(
+                format_exit_args[0].0,
+                "cannot have both `pretty` and `format_exit`",
+            ));
+        }
 
         if errors.is_empty() {
             macro_rules! first_no_span {
@@ -306,6 +363,8 @@ impl Args {
                 .unwrap_or_else(|| DEFAULT_PREFIX_ENTER.to_owned());
             let prefix_exit =
                 first_no_span!(prefix_exit_args).unwrap_or_else(|| DEFAULT_PREFIX_EXIT.to_owned());
+            let format_enter = first_no_span!(format_enter_args);
+            let format_exit = first_no_span!(format_exit_args);
             let filter = match (first_no_span!(enable_args), first_no_span!(disable_args)) {
                 (None, None) => Filter::None,
                 (Some(idents), None) => Filter::Enable(idents),
@@ -323,6 +382,8 @@ impl Args {
                 pause,
                 pretty,
                 logging,
+                format_enter,
+                format_exit,
             })
         } else {
             Err(errors)