Support for transparent

Author: Porges

errful-derive/src/lib.rs

@@ -29,6 +29,10 @@ struct BasicOptions {
 
     /// The severity of the error
     severity: Option<syn::Path>,
+
+    /// Don’t show the error message for this error when printing a chain
+    #[darling(default)]
+    transparent: bool,
 }
 
 type Data = ast::Data<EnumVariant, StructField>;
@@ -91,6 +95,14 @@ pub fn derive_errful(input: proc_macro::TokenStream) -> proc_macro::TokenStream
             |severity| quote! { &#severity },
         );
 
+        let transparent_fn = generate_required_value_function(
+            &opts,
+            Ident::new("transparent", Span::call_site()),
+            quote! { bool },
+            |o| o.transparent,
+            |transparent| quote! { #transparent },
+        );
+
         let source_code = find_source_code(&opts.data)?;
         let source_code = source_code.map(|source_code| {
             quote! {
@@ -117,6 +129,7 @@ pub fn derive_errful(input: proc_macro::TokenStream) -> proc_macro::TokenStream
                 #url_fn
                 #code_fn
                 #severity_fn
+                #transparent_fn
                 #labels_fn
                 #source_code
             }
@@ -403,6 +416,45 @@ fn generate_value_function<'a, T: ?Sized + 'a>(
     })
 }
 
+fn generate_required_value_function<'a, T: 'a>(
+    opts: &'a Opts,
+    name: proc_macro2::Ident,
+    result_t: TokenStream,
+    proj: impl Fn(&'a BasicOptions) -> T,
+    quote_t: impl Fn(T) -> TokenStream,
+) -> TokenStream {
+    if let ast::Data::Enum(variants) = &opts.data {
+        let cases = Vec::from_iter(variants.iter().map(|v| {
+            let ident = &v.ident;
+            let quoted = quote_t(proj(&v.basic));
+            quote! { Self::#ident{..} => #quoted, }
+        }));
+
+        if !cases.is_empty() {
+            let base_case = {
+                let quoted = quote_t(proj(&opts.basic));
+                quote! { _ => #quoted, }
+            };
+
+            return quote! {
+                fn #name(&self) -> #result_t {
+                    match self {
+                        #(#cases)*
+                        #base_case
+                    }
+                }
+            };
+        }
+    }
+
+    let quoted = quote_t(proj(&opts.basic));
+    quote! {
+        fn #name(&self) -> #result_t {
+            #quoted
+        }
+    }
+}
+
 fn provide_value<'a, T: ?Sized + 'a>(
     opts: &'a Opts,
     request: &Ident,

errful/src/formatting/pretty.rs

@@ -90,10 +90,8 @@ impl PrettyDisplay<'_> {
             writeln!(f, "{}", line)?;
         }
 
-        let errful = err.errful();
-
         // output any additional information
-        self.render_sourcelabels(body_indent, errful, colors, f)?;
+        self.render_sourcelabels(body_indent, err, colors, f)?;
 
         Ok(())
     }
@@ -171,49 +169,50 @@ impl Display for PrettyDisplay<'_> {
 
         // TODO: termwidth
         let body_indent = format!("{}", base_color.style("    │ "));
+        let message_indent = format!("{}", base_color.style("    │  "));
         let wrap_opts = if let Some(width) = self.width {
             textwrap::Options::new(width)
         } else {
             textwrap::Options::with_termwidth()
         }
         .subsequent_indent(&body_indent);
 
-        let first_indent = format!(
-            "{} 0 {} ",
-            base_color.style(severity.symbol()),
-            base_color.style("┐")
-        );
-
-        self.print_chain_entry(
-            f,
-            wrap_opts.clone().initial_indent(&first_indent),
-            &body_indent,
-            err,
-            &mut colors,
-        )?;
-
-        // message must be indented one more level than the body
-        let message_indent = format!("{}", base_color.style("    │  "));
-
-        let mut index = 1;
-        let mut next = err.source();
+        let mut index = 0;
+        let mut next: Option<&dyn std::error::Error> = Some(self.err);
         while let Some(err) = next {
-            // `:3`: if someone has nested errors a thousand layers deep, i can’t save them
-            let first_indent = format!("{index:3} {} ", base_color.style("├▷"));
-            self.print_chain_entry(
-                f,
-                wrap_opts
-                    .clone()
-                    .initial_indent(&first_indent)
-                    .subsequent_indent(&message_indent),
-                &body_indent,
-                err.errful(),
-                &mut colors,
-            )?;
+            let enhanced = err.errful();
+            if !enhanced.transparent() {
+                let first_indent = if index == 0 {
+                    format!(
+                        "{} 0 {} ",
+                        base_color.style(severity.symbol()),
+                        base_color.style("┐")
+                    )
+                } else {
+                    format!("{index:3} {} ", base_color.style("├▷"))
+                };
+
+                self.print_chain_entry(
+                    f,
+                    if index == 0 {
+                        wrap_opts.clone().initial_indent(&first_indent)
+                    } else {
+                        // message must be indented one more level than the body
+                        wrap_opts
+                            .clone()
+                            .initial_indent(&first_indent)
+                            .subsequent_indent(&message_indent)
+                    },
+                    &body_indent,
+                    enhanced,
+                    &mut colors,
+                )?;
+
+                index += 1;
+            }
 
             // proceed
             next = err.source();
-            index += 1;
         }
 
         // terminate the chain

errful/src/protocol.rs

@@ -142,6 +142,12 @@ pub trait Errful: Error {
     fn labels(&self) -> Option<Vec<Label>> {
         None
     }
+
+    /// Whether or not this error should be skipped when printing
+    /// cause chains.
+    fn transparent(&self) -> bool {
+        false
+    }
 }
 
 pub struct Label<'a> {