From 061ccd7c4e9c0aecc8420df803026c063b64ff09 Mon Sep 17 00:00:00 2001
From: Maxim Zhiburt <zhiburt@gmail.com>
Date: Fri, 19 Nov 2021 11:13:40 +0300
Subject: [PATCH] tabled_derive/ fix requirment for fmt::Display on hidden
 fields in inline mode

Signed-off-by: Maxim Zhiburt <zhiburt@gmail.com>
---
 Cargo.toml               |   2 +-
 tabled_derive/src/lib.rs |   7 +++
 tests/derive_test.rs     | 124 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 132 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index d1b72687..47800299 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,7 +24,7 @@ maintenance = { status = "actively-developed" }
 color = ["papergrid/color", "ansi-cut"]
 
 [dependencies]
-tabled_derive = "0.1.8"
+tabled_derive = { path = "./tabled_derive" }
 papergrid = { path = "./papergrid" }
 ansi-cut = { version = "0.1.1", optional = true }
 
diff --git a/tabled_derive/src/lib.rs b/tabled_derive/src/lib.rs
index d11f47ba..edbb6d32 100644
--- a/tabled_derive/src/lib.rs
+++ b/tabled_derive/src/lib.rs
@@ -124,6 +124,10 @@ fn variant_headers(variant: &Variant, attr: &Attr) -> Vec<proc_macro2::TokenStre
         let mut calls = Vec::new();
         for (index, field) in variant.fields.iter().enumerate() {
             let field_attr = Attr::parse(&field.attrs);
+            if field_attr.is_ignored() {
+                continue;
+            }
+
             let call = field_headers(field, &field_attr, index, prefix);
             calls.push(call);
         }
@@ -303,6 +307,7 @@ fn variant_fields(v: &Variant, attr: &Attr) -> Vec<proc_macro2::TokenStream> {
     branch_idents
         .into_iter()
         .zip(v.fields.iter().map(|field| Attr::parse(&field.attrs)))
+        .filter(|(_, attr)| !attr.is_ignored())
         .map(|(ident, attr)| get_field_fields(ident.to_token_stream(), &attr))
         .collect()
 }
@@ -311,6 +316,8 @@ fn variant_idents(v: &Variant) -> Vec<Ident> {
     v.fields
         .iter()
         .enumerate()
+        // we intentionally not ignore these fields to be able to build a pattern correctly
+        // .filter(|(_, field)| !Attr::parse(&field.attrs).is_ignored())
         .map(|(index, field)| {
             if let Some(ident) = field.ident.as_ref() {
                 ident.clone()
diff --git a/tests/derive_test.rs b/tests/derive_test.rs
index b6033cb7..dae94321 100644
--- a/tests/derive_test.rs
+++ b/tests/derive_test.rs
@@ -589,3 +589,127 @@ mod structure {
         assert_eq!(vec!["f1".to_owned(), "f2".to_owned()], St::headers());
     }
 }
+
+#[test]
+fn hidden_fields_may_not_implement_display() {
+    {
+        struct Something;
+
+        #[derive(Tabled)]
+        struct TupleStruct(#[header(hidden = true)] Something, &'static str);
+
+        let st = TupleStruct(Something, "nrdxp");
+
+        assert_eq!(vec!["nrdxp".to_owned()], st.fields());
+        assert_eq!(vec!["1".to_owned()], TupleStruct::headers());
+    }
+
+    {
+        struct Something;
+
+        #[derive(Tabled)]
+        struct Struct {
+            #[header(hidden = true)]
+            _gem: Something,
+            name: &'static str,
+        }
+
+        let st = Struct {
+            _gem: Something,
+            name: "nrdxp",
+        };
+
+        assert_eq!(vec!["nrdxp".to_owned()], st.fields());
+        assert_eq!(vec!["name".to_owned()], Struct::headers());
+    }
+
+    {
+        struct Something;
+
+        #[derive(Tabled)]
+        enum Enum {
+            #[field(inline("A::"))]
+            A {
+                name: &'static str,
+            },
+            #[field(inline("B::"))]
+            B {
+                issue: usize,
+                #[header(hidden = true)]
+                _gem: Something,
+                name: &'static str,
+            },
+            #[field(inline("C::"))]
+            C(usize, #[header(hidden = true)] Something, &'static str),
+            D,
+        }
+
+        assert_eq!(
+            vec![
+                "A::name".to_owned(),
+                "B::issue".to_owned(),
+                "B::name".to_owned(),
+                "C::0".to_owned(),
+                "C::2".to_owned(),
+                "D".to_owned()
+            ],
+            Enum::headers()
+        );
+
+        let st = Enum::A { name: "nrdxp" };
+        assert_eq!(
+            vec![
+                "nrdxp".to_owned(),
+                "".to_owned(),
+                "".to_owned(),
+                "".to_owned(),
+                "".to_owned(),
+                "".to_owned()
+            ],
+            st.fields()
+        );
+
+        let st = Enum::B {
+            _gem: Something,
+            issue: 32,
+            name: "nrdxp",
+        };
+        assert_eq!(
+            vec![
+                "".to_owned(),
+                "32".to_owned(),
+                "nrdxp".to_owned(),
+                "".to_owned(),
+                "".to_owned(),
+                "".to_owned()
+            ],
+            st.fields()
+        );
+
+        let st = Enum::C(32, Something, "nrdxp");
+        assert_eq!(
+            vec![
+                "".to_owned(),
+                "".to_owned(),
+                "".to_owned(),
+                "32".to_owned(),
+                "nrdxp".to_owned(),
+                "".to_owned()
+            ],
+            st.fields()
+        );
+
+        let st = Enum::D;
+        assert_eq!(
+            vec![
+                "".to_owned(),
+                "".to_owned(),
+                "".to_owned(),
+                "".to_owned(),
+                "".to_owned(),
+                "+".to_owned()
+            ],
+            st.fields()
+        );
+    }
+}