From 030d8662c55299c56a5a822b770cde1f810b554e Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 11:57:49 +1100
Subject: [PATCH 01/33] added boilerplate

---
 quork-proc/src/lib.rs        | 28 +++++++++++++++++-----------
 quork-proc/src/strip_enum.rs |  5 +++++
 2 files changed, 22 insertions(+), 11 deletions(-)
 create mode 100644 quork-proc/src/strip_enum.rs

diff --git a/quork-proc/src/lib.rs b/quork-proc/src/lib.rs
index 1d53514..52620e1 100644
--- a/quork-proc/src/lib.rs
+++ b/quork-proc/src/lib.rs
@@ -3,6 +3,7 @@
 #![warn(clippy::pedantic)]
 #![warn(missing_docs)]
 
+use proc_macro::TokenStream;
 use proc_macro_error::proc_macro_error;
 use syn::{parse_macro_input, DeriveInput, LitStr};
 
@@ -11,15 +12,23 @@ mod enum_list;
 mod from_tuple;
 mod new;
 mod strip;
+mod strip_enum;
 mod time_fn;
 
 #[macro_use]
 extern crate quote;
 
+#[proc_macro_derive(Strip)]
+pub fn strip_enum(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    strip_enum::strip_enum(&ast).into()
+}
+
 /// Implement [`quork::ListVariants`] for enums
 #[proc_macro_derive(ListVariants)]
 #[proc_macro_error]
-pub fn derive_enum_list(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn derive_enum_list(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
     enum_list::enum_list(&ast).into()
 }
@@ -29,7 +38,7 @@ pub fn derive_enum_list(input: proc_macro::TokenStream) -> proc_macro::TokenStre
 ///
 /// Converts an enum variant to a string literal, within a constant context.
 #[proc_macro_derive(ConstStr)]
-pub fn derive_const_str(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn derive_const_str(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
     const_str::derive(&ast).into()
 }
@@ -39,7 +48,7 @@ pub fn derive_const_str(input: proc_macro::TokenStream) -> proc_macro::TokenStre
 /// Will follow the form of `new(field: Type, ...) -> Self`, where all fields are required.
 #[proc_macro_derive(New)]
 #[proc_macro_error]
-pub fn derive_new(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn derive_new(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
     new::derive(&ast).into()
 }
@@ -47,7 +56,7 @@ pub fn derive_new(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 /// Implement the [`std::convert::From`] trait for converting tuples into tuple structs
 #[proc_macro_derive(FromTuple)]
 #[proc_macro_error]
-pub fn derive_from_tuple(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn derive_from_tuple(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
     from_tuple::derive(&ast).into()
 }
@@ -59,10 +68,7 @@ pub fn derive_from_tuple(input: proc_macro::TokenStream) -> proc_macro::TokenStr
 /// You can pass "s", "ms", "ns"
 #[proc_macro_attribute]
 #[proc_macro_error]
-pub fn time(
-    args: proc_macro::TokenStream,
-    input: proc_macro::TokenStream,
-) -> proc_macro::TokenStream {
+pub fn time(args: TokenStream, input: TokenStream) -> TokenStream {
     let args_str = args.to_string();
     let fmt = match args_str.as_str() {
         "ms" | "milliseconds" => time_fn::TimeFormat::Milliseconds,
@@ -74,7 +80,7 @@ pub fn time(
 
 /// Strip whitespace from the right of a string literal on each line
 #[proc_macro]
-pub fn strip_lines(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn strip_lines(input: TokenStream) -> TokenStream {
     let literal = parse_macro_input!(input as LitStr);
 
     strip::funclike(&literal, &strip::Alignment::None).into()
@@ -82,7 +88,7 @@ pub fn strip_lines(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 
 /// Strip whitespace from the left and right of a string literal on each line
 #[proc_macro]
-pub fn rstrip_lines(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn rstrip_lines(input: TokenStream) -> TokenStream {
     let literal = parse_macro_input!(input as LitStr);
 
     strip::funclike(&literal, &strip::Alignment::Right).into()
@@ -90,7 +96,7 @@ pub fn rstrip_lines(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 
 /// Strip whitespace from the left of a string literal on each line
 #[proc_macro]
-pub fn lstrip_lines(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn lstrip_lines(input: TokenStream) -> TokenStream {
     let literal = parse_macro_input!(input as LitStr);
 
     strip::funclike(&literal, &strip::Alignment::Left).into()
diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
new file mode 100644
index 0000000..41ee35e
--- /dev/null
+++ b/quork-proc/src/strip_enum.rs
@@ -0,0 +1,5 @@
+use proc_macro2::TokenStream;
+
+pub fn strip_enum(ast: &syn::DeriveInput) -> TokenStream {
+    todo!()
+}

From f0387756a8211e3ea3b9ad69858fc1b73cd3d53d Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:01:44 +1100
Subject: [PATCH 02/33] add heck dep and template

---
 quork-proc/Cargo.toml        |  1 +
 quork-proc/src/strip_enum.rs | 65 ++++++++++++++++++++++++++++++++++--
 2 files changed, 63 insertions(+), 3 deletions(-)

diff --git a/quork-proc/Cargo.toml b/quork-proc/Cargo.toml
index 6161231..a824ac0 100644
--- a/quork-proc/Cargo.toml
+++ b/quork-proc/Cargo.toml
@@ -15,6 +15,7 @@ proc-macro = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+heck = { version = "0.4.1", features = ["unicode"] }
 proc-macro-crate = "2.0"
 proc-macro-error = "1.0"
 proc-macro2 = "1.0"
diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 41ee35e..4c54f97 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -1,5 +1,64 @@
-use proc_macro2::TokenStream;
+use proc_macro2::{Ident, Span, TokenStream};
+use proc_macro_crate::{crate_name, FoundCrate};
+use proc_macro_error::{abort, abort_call_site};
+use quote::{quote, ToTokens};
+use syn::{spanned::Spanned, DeriveInput};
 
-pub fn strip_enum(ast: &syn::DeriveInput) -> TokenStream {
-    todo!()
+pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
+    let struct_name = {
+        let original_ident = &ast.ident;
+        let og_ident_span = original_ident.span();
+        Ident::new(&format!("{}Hooks", original_ident), og_ident_span)
+    };
+
+    let data = &ast.data;
+
+    let variants = match data {
+        syn::Data::Enum(ref e) => e
+            .variants
+            .iter()
+            .filter_map(|variant| {
+                if variant.attrs.iter().any(|attr| match attr.meta {
+                    syn::Meta::Path(ref p) => p.is_ident("no_hook"),
+                    _ => abort!(
+                        attr.span(),
+                        "Expected path-style (i.e #[no_hook]), found other style attribute macro"
+                    ),
+                }) {
+                    None
+                } else {
+                    Some(variant.ident.to_token_stream())
+                }
+            })
+            .collect::<Vec<_>>(),
+        _ => abort_call_site!("Can only be derived for enums"),
+    };
+
+    let command_names = variants
+        .iter()
+        .map(|variant| heck::AsKebabCase(variant.to_string()).to_string())
+        .collect::<Vec<_>>();
+
+    let strum = match crate_name("strum").expect("strum is present in `Cargo.toml`") {
+        FoundCrate::Itself => Ident::new("strum", Span::call_site()),
+        FoundCrate::Name(name) => Ident::new(&name, Span::call_site()),
+    };
+
+    quote! {
+        // TODO: Better way of doing this? or add support for meta in proc macro
+        #[derive(Debug, Clone, #strum::Display, #strum::IntoStaticStr, #strum::EnumIter, PartialEq, Eq)]
+        #[strum(serialize_all = "kebab-case")]
+        pub enum #struct_name {
+            #(#variants),*
+        }
+
+        impl From<String> for #struct_name {
+            fn from(string: String) -> Self {
+                match string.as_str() {
+                    #(#command_names => #struct_name::#variants,)*
+                    _ => panic!("Invalid command name: {}", string),
+                }
+            }
+        }
+    }
 }

From 923fe56b395abd45eae0ea739c188873d7548a42 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:02:40 +1100
Subject: [PATCH 03/33] fixes

---
 quork-proc/src/lib.rs        | 3 ++-
 quork-proc/src/strip_enum.rs | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/quork-proc/src/lib.rs b/quork-proc/src/lib.rs
index 52620e1..77ab869 100644
--- a/quork-proc/src/lib.rs
+++ b/quork-proc/src/lib.rs
@@ -18,7 +18,8 @@ mod time_fn;
 #[macro_use]
 extern crate quote;
 
-#[proc_macro_derive(Strip)]
+#[proc_macro_derive(Strip, attributes(strip))]
+#[proc_macro_error]
 pub fn strip_enum(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
 
diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 4c54f97..7f5dda9 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -19,7 +19,8 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
             .iter()
             .filter_map(|variant| {
                 if variant.attrs.iter().any(|attr| match attr.meta {
-                    syn::Meta::Path(ref p) => p.is_ident("no_hook"),
+                    // TODO: Any point checking this?
+                    syn::Meta::Path(ref p) => p.is_ident("strip"),
                     _ => abort!(
                         attr.span(),
                         "Expected path-style (i.e #[no_hook]), found other style attribute macro"

From 308254d0dab341e0f831739aaa68b99fe88acd8e Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:03:45 +1100
Subject: [PATCH 04/33] fixes

---
 quork-proc/src/lib.rs        | 2 +-
 quork-proc/src/strip_enum.rs | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/quork-proc/src/lib.rs b/quork-proc/src/lib.rs
index 77ab869..5452c2d 100644
--- a/quork-proc/src/lib.rs
+++ b/quork-proc/src/lib.rs
@@ -18,7 +18,7 @@ mod time_fn;
 #[macro_use]
 extern crate quote;
 
-#[proc_macro_derive(Strip, attributes(strip))]
+#[proc_macro_derive(Strip, attributes(strip, ignore))]
 #[proc_macro_error]
 pub fn strip_enum(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 7f5dda9..90d4bf3 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -19,11 +19,10 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
             .iter()
             .filter_map(|variant| {
                 if variant.attrs.iter().any(|attr| match attr.meta {
-                    // TODO: Any point checking this?
-                    syn::Meta::Path(ref p) => p.is_ident("strip"),
+                    syn::Meta::Path(ref p) => p.is_ident("ignore"),
                     _ => abort!(
                         attr.span(),
-                        "Expected path-style (i.e #[no_hook]), found other style attribute macro"
+                        "Expected path-style (i.e #[ignore]), found other style attribute macro"
                     ),
                 }) {
                     None
@@ -32,7 +31,7 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 }
             })
             .collect::<Vec<_>>(),
-        _ => abort_call_site!("Can only be derived for enums"),
+        _ => abort_call_site!("`Strip` can only be derived for enums"),
     };
 
     let command_names = variants

From 8822de762b8de5752dfed6a9ce2a51326f8d4aa2 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:07:11 +1100
Subject: [PATCH 05/33] updated variant ignore

---
 quork-proc/src/strip_enum.rs | 54 +++++++++++++++++++++++-------------
 1 file changed, 35 insertions(+), 19 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 90d4bf3..463ffa6 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -2,7 +2,22 @@ use proc_macro2::{Ident, Span, TokenStream};
 use proc_macro_crate::{crate_name, FoundCrate};
 use proc_macro_error::{abort, abort_call_site};
 use quote::{quote, ToTokens};
-use syn::{spanned::Spanned, DeriveInput};
+use syn::{spanned::Spanned, DeriveInput, Variant};
+
+fn ignore_variant(variant: &Variant) -> bool {
+    variant.attrs.iter().any(|attr| match attr.meta {
+        syn::Meta::Path(ref p) => p.is_ident("ignore"),
+        _ => abort!(
+            attr.span(),
+            "Expected path-style (i.e #[ignore]), found other style attribute macro"
+        ),
+    })
+}
+
+struct StrippedData {
+    ident: Ident,
+    variants: Vec<TokenStream>,
+}
 
 pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
     let struct_name = {
@@ -13,24 +28,25 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
 
     let data = &ast.data;
 
-    let variants = match data {
-        syn::Data::Enum(ref e) => e
-            .variants
-            .iter()
-            .filter_map(|variant| {
-                if variant.attrs.iter().any(|attr| match attr.meta {
-                    syn::Meta::Path(ref p) => p.is_ident("ignore"),
-                    _ => abort!(
-                        attr.span(),
-                        "Expected path-style (i.e #[ignore]), found other style attribute macro"
-                    ),
-                }) {
-                    None
-                } else {
-                    Some(variant.ident.to_token_stream())
-                }
-            })
-            .collect::<Vec<_>>(),
+    let info: StrippedData = match data {
+        syn::Data::Enum(ref e) => {
+            let variants = e
+                .variants
+                .iter()
+                .filter_map(|variant| {
+                    if ignore_variant(variant) {
+                        None
+                    } else {
+                        Some(variant.ident.to_token_stream())
+                    }
+                })
+                .collect::<Vec<_>>();
+
+            StrippedData {
+                ident: todo!(),
+                var iants,
+            }
+        }
         _ => abort_call_site!("`Strip` can only be derived for enums"),
     };
 

From 145297a50d8d5a9781d20b8203a34cd54f84ed8d Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:17:44 +1100
Subject: [PATCH 06/33] fixes

---
 quork-proc/src/lib.rs        |  2 +-
 quork-proc/src/strip_enum.rs | 32 +++++++++++++++++++++++++++++---
 2 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/quork-proc/src/lib.rs b/quork-proc/src/lib.rs
index 5452c2d..828054d 100644
--- a/quork-proc/src/lib.rs
+++ b/quork-proc/src/lib.rs
@@ -18,7 +18,7 @@ mod time_fn;
 #[macro_use]
 extern crate quote;
 
-#[proc_macro_derive(Strip, attributes(strip, ignore))]
+#[proc_macro_derive(Strip, attributes(stripped_ident, stripped_meta, ignore))]
 #[proc_macro_error]
 pub fn strip_enum(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 463ffa6..5a6ed50 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -2,7 +2,7 @@ use proc_macro2::{Ident, Span, TokenStream};
 use proc_macro_crate::{crate_name, FoundCrate};
 use proc_macro_error::{abort, abort_call_site};
 use quote::{quote, ToTokens};
-use syn::{spanned::Spanned, DeriveInput, Variant};
+use syn::{spanned::Spanned, DeriveInput, ExprLit, Lit, Variant};
 
 fn ignore_variant(variant: &Variant) -> bool {
     variant.attrs.iter().any(|attr| match attr.meta {
@@ -27,6 +27,7 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
     };
 
     let data = &ast.data;
+    let attrs = &ast.attrs;
 
     let info: StrippedData = match data {
         syn::Data::Enum(ref e) => {
@@ -42,15 +43,40 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 })
                 .collect::<Vec<_>>();
 
+            if let Some(info_attr) = attrs
+                .iter()
+                .find(|attr| attr.path().is_ident("stripped_ident"))
+            {
+                match info_attr.meta {
+                    syn::Meta::NameValue(name_value) => {
+                        let ident = name_value.value;
+
+                        if let syn::Expr::Lit(ExprLit {
+                            lit: Lit::Str(string),
+                            ..
+                        }) = ident
+                        {
+                        } else {
+                            abort!(ident.span(), "Expected string literal.")
+                        }
+                    }
+                    _ => abort!(
+                        info_attr.span(),
+                        "Expected #[stripped_ident = \"\"]. Found other style attribute."
+                    ),
+                }
+            }
+
             StrippedData {
                 ident: todo!(),
-                var iants,
+                variants,
             }
         }
         _ => abort_call_site!("`Strip` can only be derived for enums"),
     };
 
-    let command_names = variants
+    let command_names = info
+        .variants
         .iter()
         .map(|variant| heck::AsKebabCase(variant.to_string()).to_string())
         .collect::<Vec<_>>();

From 50720a80cd20b8c9280cb9b5acd24fa4922bad58 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:24:05 +1100
Subject: [PATCH 07/33] fixes

---
 quork-proc/src/strip_enum.rs | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 5a6ed50..0b5a8a9 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -2,7 +2,7 @@ use proc_macro2::{Ident, Span, TokenStream};
 use proc_macro_crate::{crate_name, FoundCrate};
 use proc_macro_error::{abort, abort_call_site};
 use quote::{quote, ToTokens};
-use syn::{spanned::Spanned, DeriveInput, ExprLit, Lit, Variant};
+use syn::{parse::Parse, spanned::Spanned, token, DeriveInput, ExprLit, Lit, Variant};
 
 fn ignore_variant(variant: &Variant) -> bool {
     variant.attrs.iter().any(|attr| match attr.meta {
@@ -43,7 +43,7 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 })
                 .collect::<Vec<_>>();
 
-            if let Some(info_attr) = attrs
+            let new_ident = if let Some(info_attr) = attrs
                 .iter()
                 .find(|attr| attr.path().is_ident("stripped_ident"))
             {
@@ -56,6 +56,10 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                             ..
                         }) = ident
                         {
+                            Ident::new(
+                                &string.value().replace("{}", &ast.ident.to_string()),
+                                ast.ident.span(),
+                            )
                         } else {
                             abort!(ident.span(), "Expected string literal.")
                         }
@@ -65,10 +69,12 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                         "Expected #[stripped_ident = \"\"]. Found other style attribute."
                     ),
                 }
-            }
+            } else {
+                ast.ident
+            };
 
             StrippedData {
-                ident: todo!(),
+                ident: new_ident,
                 variants,
             }
         }

From 107e190da4e8e9a8b281a14492889a1b82fd4659 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:25:40 +1100
Subject: [PATCH 08/33] fix

---
 quork-proc/src/strip_enum.rs | 33 +++------------------------------
 1 file changed, 3 insertions(+), 30 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 0b5a8a9..8e62d92 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -20,12 +20,6 @@ struct StrippedData {
 }
 
 pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
-    let struct_name = {
-        let original_ident = &ast.ident;
-        let og_ident_span = original_ident.span();
-        Ident::new(&format!("{}Hooks", original_ident), og_ident_span)
-    };
-
     let data = &ast.data;
     let attrs = &ast.attrs;
 
@@ -70,7 +64,7 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                     ),
                 }
             } else {
-                ast.ident
+                ast.ident.clone()
             };
 
             StrippedData {
@@ -81,32 +75,11 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
         _ => abort_call_site!("`Strip` can only be derived for enums"),
     };
 
-    let command_names = info
-        .variants
-        .iter()
-        .map(|variant| heck::AsKebabCase(variant.to_string()).to_string())
-        .collect::<Vec<_>>();
-
-    let strum = match crate_name("strum").expect("strum is present in `Cargo.toml`") {
-        FoundCrate::Itself => Ident::new("strum", Span::call_site()),
-        FoundCrate::Name(name) => Ident::new(&name, Span::call_site()),
-    };
+    let StrippedData { ident, variants } = info;
 
     quote! {
-        // TODO: Better way of doing this? or add support for meta in proc macro
-        #[derive(Debug, Clone, #strum::Display, #strum::IntoStaticStr, #strum::EnumIter, PartialEq, Eq)]
-        #[strum(serialize_all = "kebab-case")]
-        pub enum #struct_name {
+        pub enum #ident {
             #(#variants),*
         }
-
-        impl From<String> for #struct_name {
-            fn from(string: String) -> Self {
-                match string.as_str() {
-                    #(#command_names => #struct_name::#variants,)*
-                    _ => panic!("Invalid command name: {}", string),
-                }
-            }
-        }
     }
 }

From 11f1dbbee428b26221a18be4e4f14b716d7a2307 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:25:56 +1100
Subject: [PATCH 09/33] fix

---
 quork-proc/src/strip_enum.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 8e62d92..ed1354d 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -41,9 +41,9 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 .iter()
                 .find(|attr| attr.path().is_ident("stripped_ident"))
             {
-                match info_attr.meta {
+                match &info_attr.meta {
                     syn::Meta::NameValue(name_value) => {
-                        let ident = name_value.value;
+                        let ident = &name_value.value;
 
                         if let syn::Expr::Lit(ExprLit {
                             lit: Lit::Str(string),

From dd3e75b9bf3897faa280c5f19f54d5581f28d04b Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:27:31 +1100
Subject: [PATCH 10/33] added test

---
 quork-proc/Cargo.toml          |  3 +++
 quork-proc/tests/strip_enum.rs | 43 ++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)
 create mode 100644 quork-proc/tests/strip_enum.rs

diff --git a/quork-proc/Cargo.toml b/quork-proc/Cargo.toml
index a824ac0..c0428ad 100644
--- a/quork-proc/Cargo.toml
+++ b/quork-proc/Cargo.toml
@@ -21,3 +21,6 @@ proc-macro-error = "1.0"
 proc-macro2 = "1.0"
 quote = "1.0"
 syn = { version = "2.0", features = ["full"] }
+
+[dev-dependencies]
+strum = { version = "0.25.0", features = ["derive"] }
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
new file mode 100644
index 0000000..f555f45
--- /dev/null
+++ b/quork-proc/tests/strip_enum.rs
@@ -0,0 +1,43 @@
+#![allow(dead_code)]
+
+use std::fmt::Display;
+
+use strum::IntoEnumIterator;
+
+pub fn enum_to_string<T: IntoEnumIterator + Display>() -> String {
+    T::iter().map(|v| v.to_string()).collect::<String>()
+}
+
+use sfsu_derive::Hooks;
+
+use helpers::enum_to_string;
+
+struct DummyStruct;
+
+#[derive(Hooks)]
+enum EnumWithData {
+    Test1(DummyStruct),
+    Test2(DummyStruct),
+}
+
+#[test]
+fn has_all_variants() {
+    let variants = enum_to_string::<EnumWithDataHooks>();
+
+    assert_eq!(variants, "test1test2");
+}
+
+#[derive(Hooks)]
+enum EnumExclude {
+    Test1(DummyStruct),
+    #[no_hook]
+    Test2(DummyStruct),
+    Test3(DummyStruct),
+}
+
+#[test]
+fn excludes_no_hook_variant() {
+    let variants = enum_to_string::<EnumExcludeHooks>();
+
+    assert_eq!(variants, "test1test3");
+}

From c967b81c3429968e6967a6824a32c3c2c9872f3b Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:29:43 +1100
Subject: [PATCH 11/33] fix

---
 quork-proc/src/lib.rs          |  2 +-
 quork-proc/src/strip_enum.rs   |  5 ++++-
 quork-proc/tests/strip_enum.rs | 16 +++++++---------
 3 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/quork-proc/src/lib.rs b/quork-proc/src/lib.rs
index 828054d..3bd36ab 100644
--- a/quork-proc/src/lib.rs
+++ b/quork-proc/src/lib.rs
@@ -18,7 +18,7 @@ mod time_fn;
 #[macro_use]
 extern crate quote;
 
-#[proc_macro_derive(Strip, attributes(stripped_ident, stripped_meta, ignore))]
+#[proc_macro_derive(Strip, attributes(stripped_ident, stripped_meta, stripped_ignore))]
 #[proc_macro_error]
 pub fn strip_enum(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index ed1354d..1ac338e 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -64,7 +64,10 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                     ),
                 }
             } else {
-                ast.ident.clone()
+                Ident::new(
+                    &format!("{}Stripped", ast.ident.to_string()),
+                    ast.ident.span(),
+                )
             };
 
             StrippedData {
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index f555f45..767b2aa 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -4,17 +4,15 @@ use std::fmt::Display;
 
 use strum::IntoEnumIterator;
 
+use quork_proc::Strip;
+
 pub fn enum_to_string<T: IntoEnumIterator + Display>() -> String {
     T::iter().map(|v| v.to_string()).collect::<String>()
 }
 
-use sfsu_derive::Hooks;
-
-use helpers::enum_to_string;
-
 struct DummyStruct;
 
-#[derive(Hooks)]
+#[derive(Strip)]
 enum EnumWithData {
     Test1(DummyStruct),
     Test2(DummyStruct),
@@ -22,22 +20,22 @@ enum EnumWithData {
 
 #[test]
 fn has_all_variants() {
-    let variants = enum_to_string::<EnumWithDataHooks>();
+    let variants = enum_to_string::<EnumWithDataStripped>();
 
     assert_eq!(variants, "test1test2");
 }
 
-#[derive(Hooks)]
+#[derive(Strip)]
 enum EnumExclude {
     Test1(DummyStruct),
-    #[no_hook]
+    #[stripped_ignore]
     Test2(DummyStruct),
     Test3(DummyStruct),
 }
 
 #[test]
 fn excludes_no_hook_variant() {
-    let variants = enum_to_string::<EnumExcludeHooks>();
+    let variants = enum_to_string::<EnumExcludeStripped>();
 
     assert_eq!(variants, "test1test3");
 }

From 71fe83ae2f83c31f6512445826d8bce3b4f1a79f Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:30:31 +1100
Subject: [PATCH 12/33] fixes

---
 quork-proc/tests/strip_enum.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index 767b2aa..9339375 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -2,7 +2,7 @@
 
 use std::fmt::Display;
 
-use strum::IntoEnumIterator;
+use strum::{EnumIter, IntoEnumIterator};
 
 use quork_proc::Strip;
 
@@ -13,6 +13,7 @@ pub fn enum_to_string<T: IntoEnumIterator + Display>() -> String {
 struct DummyStruct;
 
 #[derive(Strip)]
+#[stripped_meta = derive(EnumIter)]
 enum EnumWithData {
     Test1(DummyStruct),
     Test2(DummyStruct),

From 5c56d078954e55ce4fd2285a8bcfbbb1fa480c9d Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:37:54 +1100
Subject: [PATCH 13/33] fix

---
 quork-proc/src/strip_enum.rs | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 1ac338e..58c3484 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -2,7 +2,7 @@ use proc_macro2::{Ident, Span, TokenStream};
 use proc_macro_crate::{crate_name, FoundCrate};
 use proc_macro_error::{abort, abort_call_site};
 use quote::{quote, ToTokens};
-use syn::{parse::Parse, spanned::Spanned, token, DeriveInput, ExprLit, Lit, Variant};
+use syn::{parse::Parse, spanned::Spanned, token, DeriveInput, Expr, ExprLit, Lit, Variant};
 
 fn ignore_variant(variant: &Variant) -> bool {
     variant.attrs.iter().any(|attr| match attr.meta {
@@ -17,6 +17,7 @@ fn ignore_variant(variant: &Variant) -> bool {
 struct StrippedData {
     ident: Ident,
     variants: Vec<TokenStream>,
+    meta: Vec<Expr>,
 }
 
 pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
@@ -70,17 +71,37 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 )
             };
 
+            let meta_attrs = attrs
+                .iter()
+                .filter(|attr| !attr.path().is_ident("stripped_meta"));
+
+            let meta = meta_attrs
+                .map(|attr| match &attr.meta {
+                    syn::Meta::NameValue(meta) => meta.value.clone(),
+                    _ => abort!(
+                        attr.span(),
+                        "Expected #[stripped_meta = ...]. Found other style attribute."
+                    ),
+                })
+                .collect();
+
             StrippedData {
                 ident: new_ident,
                 variants,
+                meta,
             }
         }
         _ => abort_call_site!("`Strip` can only be derived for enums"),
     };
 
-    let StrippedData { ident, variants } = info;
+    let StrippedData {
+        ident,
+        variants,
+        meta,
+    } = info;
 
     quote! {
+        #(#[#meta])*
         pub enum #ident {
             #(#variants),*
         }

From 21b0b3e97e56443ba84c4492e0e06606ea3da616 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Thu, 19 Oct 2023 12:40:38 +1100
Subject: [PATCH 14/33] fixes

---
 quork-proc/src/strip_enum.rs   | 6 +++---
 quork-proc/tests/strip_enum.rs | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 58c3484..d41720e 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -76,8 +76,8 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 .filter(|attr| !attr.path().is_ident("stripped_meta"));
 
             let meta = meta_attrs
-                .map(|attr| match &attr.meta {
-                    syn::Meta::NameValue(meta) => meta.value.clone(),
+                .flat_map(|attr| match &attr.meta {
+                    syn::Meta::List(meta) => meta.parse_args(),
                     _ => abort!(
                         attr.span(),
                         "Expected #[stripped_meta = ...]. Found other style attribute."
@@ -101,7 +101,7 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
     } = info;
 
     quote! {
-        #(#[#meta])*
+        #(#meta)*
         pub enum #ident {
             #(#variants),*
         }
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index 9339375..26fd02f 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -13,7 +13,7 @@ pub fn enum_to_string<T: IntoEnumIterator + Display>() -> String {
 struct DummyStruct;
 
 #[derive(Strip)]
-#[stripped_meta = derive(EnumIter)]
+#[stripped_meta(derive(EnumIter))]
 enum EnumWithData {
     Test1(DummyStruct),
     Test2(DummyStruct),

From 4ddac455186807c6f28934b0f588743260feb8c9 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Fri, 20 Oct 2023 08:54:32 +1100
Subject: [PATCH 15/33] fix

---
 quork-proc/src/strip_enum.rs | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index d41720e..8d0e696 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -76,12 +76,15 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 .filter(|attr| !attr.path().is_ident("stripped_meta"));
 
             let meta = meta_attrs
-                .flat_map(|attr| match &attr.meta {
-                    syn::Meta::List(meta) => meta.parse_args(),
-                    _ => abort!(
-                        attr.span(),
-                        "Expected #[stripped_meta = ...]. Found other style attribute."
-                    ),
+                .flat_map(|attr| {
+                    panic!();
+                    match &attr.meta {
+                        syn::Meta::List(meta) => meta.parse_args(),
+                        _ => abort!(
+                            attr.span(),
+                            "Expected #[stripped_meta = ...]. Found other style attribute."
+                        ),
+                    }
                 })
                 .collect();
 
@@ -101,7 +104,7 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
     } = info;
 
     quote! {
-        #(#meta)*
+        #(#[#meta])*
         pub enum #ident {
             #(#variants),*
         }

From bc8b714a9c09f39c0e46b1a84ae467362a4917e1 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Fri, 20 Oct 2023 09:08:04 +1100
Subject: [PATCH 16/33] fixes

---
 quork-proc/src/strip_enum.rs   | 29 +++++++++++++++++++----------
 quork-proc/tests/strip_enum.rs |  5 +++--
 2 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 8d0e696..1a0fca3 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -20,6 +20,16 @@ struct StrippedData {
     meta: Vec<Expr>,
 }
 
+struct MetaArgs {
+    meta: Vec<Expr>,
+}
+
+impl Parse for MetaArgs {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        // input.peek3(token)
+    }
+}
+
 pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
     let data = &ast.data;
     let attrs = &ast.attrs;
@@ -73,18 +83,15 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
 
             let meta_attrs = attrs
                 .iter()
-                .filter(|attr| !attr.path().is_ident("stripped_meta"));
+                .filter(|attr| attr.path().is_ident("stripped_meta"));
 
             let meta = meta_attrs
-                .flat_map(|attr| {
-                    panic!();
-                    match &attr.meta {
-                        syn::Meta::List(meta) => meta.parse_args(),
-                        _ => abort!(
-                            attr.span(),
-                            "Expected #[stripped_meta = ...]. Found other style attribute."
-                        ),
-                    }
+                .flat_map(|attr| match &attr.meta {
+                    syn::Meta::List(meta) => syn::parse2::<Vec<Expr>>(meta.tokens),
+                    _ => abort!(
+                        attr.span(),
+                        "Expected #[stripped_meta(...)]. Found other style attribute."
+                    ),
                 })
                 .collect();
 
@@ -97,6 +104,8 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
         _ => abort_call_site!("`Strip` can only be derived for enums"),
     };
 
+    panic!("{:?}", info.meta);
+
     let StrippedData {
         ident,
         variants,
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index 26fd02f..16c45f1 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -2,7 +2,7 @@
 
 use std::fmt::Display;
 
-use strum::{EnumIter, IntoEnumIterator};
+use strum::{Display, EnumIter, IntoEnumIterator};
 
 use quork_proc::Strip;
 
@@ -13,7 +13,7 @@ pub fn enum_to_string<T: IntoEnumIterator + Display>() -> String {
 struct DummyStruct;
 
 #[derive(Strip)]
-#[stripped_meta(derive(EnumIter))]
+#[stripped_meta(derive(EnumIter, Display))]
 enum EnumWithData {
     Test1(DummyStruct),
     Test2(DummyStruct),
@@ -27,6 +27,7 @@ fn has_all_variants() {
 }
 
 #[derive(Strip)]
+#[stripped_meta(derive(EnumIter, Display), strum(serialize_all = "kebab-case"))]
 enum EnumExclude {
     Test1(DummyStruct),
     #[stripped_ignore]

From 5a32040adda1f3f8ef73eaa5c051d3d86fc13651 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Fri, 20 Oct 2023 09:10:20 +1100
Subject: [PATCH 17/33] fix

---
 quork-proc/src/strip_enum.rs   | 33 ++++++++++++++-------------------
 quork-proc/tests/strip_enum.rs |  3 ++-
 2 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 1a0fca3..4533647 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -1,8 +1,7 @@
-use proc_macro2::{Ident, Span, TokenStream};
-use proc_macro_crate::{crate_name, FoundCrate};
+use proc_macro2::{Ident, TokenStream};
 use proc_macro_error::{abort, abort_call_site};
 use quote::{quote, ToTokens};
-use syn::{parse::Parse, spanned::Spanned, token, DeriveInput, Expr, ExprLit, Lit, Variant};
+use syn::{spanned::Spanned, DeriveInput, Expr, ExprLit, Lit, Variant};
 
 fn ignore_variant(variant: &Variant) -> bool {
     variant.attrs.iter().any(|attr| match attr.meta {
@@ -20,15 +19,15 @@ struct StrippedData {
     meta: Vec<Expr>,
 }
 
-struct MetaArgs {
-    meta: Vec<Expr>,
-}
+// struct MetaArgs {
+//     meta: Vec<Expr>,
+// }
 
-impl Parse for MetaArgs {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        // input.peek3(token)
-    }
-}
+// impl Parse for MetaArgs {
+//     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+//          input.peek3(token)
+//     }
+// }
 
 pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
     let data = &ast.data;
@@ -81,13 +80,11 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 )
             };
 
-            let meta_attrs = attrs
+            let meta = attrs
                 .iter()
-                .filter(|attr| attr.path().is_ident("stripped_meta"));
-
-            let meta = meta_attrs
-                .flat_map(|attr| match &attr.meta {
-                    syn::Meta::List(meta) => syn::parse2::<Vec<Expr>>(meta.tokens),
+                .filter(|attr| attr.path().is_ident("stripped_meta"))
+                .map(|attr| match &attr.meta {
+                    syn::Meta::List(meta) => meta.parse_args().expect("single meta attribute"),
                     _ => abort!(
                         attr.span(),
                         "Expected #[stripped_meta(...)]. Found other style attribute."
@@ -104,8 +101,6 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
         _ => abort_call_site!("`Strip` can only be derived for enums"),
     };
 
-    panic!("{:?}", info.meta);
-
     let StrippedData {
         ident,
         variants,
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index 16c45f1..970413b 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -27,7 +27,8 @@ fn has_all_variants() {
 }
 
 #[derive(Strip)]
-#[stripped_meta(derive(EnumIter, Display), strum(serialize_all = "kebab-case"))]
+#[stripped_meta(derive(EnumIter, Display))]
+#[stripped_meta(strum(serialize_all = "kebab-case"))]
 enum EnumExclude {
     Test1(DummyStruct),
     #[stripped_ignore]

From 51033308817c02d9b8cd44d95de2fec30e9b79f3 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Fri, 20 Oct 2023 09:13:42 +1100
Subject: [PATCH 18/33] fixed ignoring variants

---
 quork-proc/src/strip_enum.rs   | 4 ++--
 quork-proc/tests/strip_enum.rs | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 4533647..6cdbd88 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -5,10 +5,10 @@ use syn::{spanned::Spanned, DeriveInput, Expr, ExprLit, Lit, Variant};
 
 fn ignore_variant(variant: &Variant) -> bool {
     variant.attrs.iter().any(|attr| match attr.meta {
-        syn::Meta::Path(ref p) => p.is_ident("ignore"),
+        syn::Meta::Path(ref p) => p.is_ident("stripped_ignore"),
         _ => abort!(
             attr.span(),
-            "Expected path-style (i.e #[ignore]), found other style attribute macro"
+            "Expected path-style (i.e #[stripped_ignore]), found other style attribute macro"
         ),
     })
 }
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index 970413b..235d635 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -14,6 +14,7 @@ struct DummyStruct;
 
 #[derive(Strip)]
 #[stripped_meta(derive(EnumIter, Display))]
+#[stripped_meta(strum(serialize_all = "kebab-case"))]
 enum EnumWithData {
     Test1(DummyStruct),
     Test2(DummyStruct),

From 11b45f1420e8362687ed14066bdbc6be35caf6c6 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <juliette@jewelexx.com>
Date: Fri, 20 Oct 2023 09:14:33 +1100
Subject: [PATCH 19/33] added todo

---
 quork-proc/src/strip_enum.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 6cdbd88..6d44a2b 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -84,6 +84,7 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 .iter()
                 .filter(|attr| attr.path().is_ident("stripped_meta"))
                 .map(|attr| match &attr.meta {
+                    // TODO: Add inherit metadata
                     syn::Meta::List(meta) => meta.parse_args().expect("single meta attribute"),
                     _ => abort!(
                         attr.span(),

From 6cd39aeb6de444fe5961a4c0f045673932cf0c92 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Tue, 10 Dec 2024 13:05:47 +1100
Subject: [PATCH 20/33] added vis support

---
 quork-proc/src/strip_enum.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 6d44a2b..3af256b 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -1,7 +1,7 @@
 use proc_macro2::{Ident, TokenStream};
 use proc_macro_error::{abort, abort_call_site};
 use quote::{quote, ToTokens};
-use syn::{spanned::Spanned, DeriveInput, Expr, ExprLit, Lit, Variant};
+use syn::{spanned::Spanned, DeriveInput, Expr, ExprLit, Lit, Variant, Visibility};
 
 fn ignore_variant(variant: &Variant) -> bool {
     variant.attrs.iter().any(|attr| match attr.meta {
@@ -17,6 +17,7 @@ struct StrippedData {
     ident: Ident,
     variants: Vec<TokenStream>,
     meta: Vec<Expr>,
+    vis: Visibility,
 }
 
 // struct MetaArgs {
@@ -74,10 +75,7 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                     ),
                 }
             } else {
-                Ident::new(
-                    &format!("{}Stripped", ast.ident.to_string()),
-                    ast.ident.span(),
-                )
+                Ident::new(&format!("{}Stripped", ast.ident), ast.ident.span())
             };
 
             let meta = attrs
@@ -97,6 +95,7 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 ident: new_ident,
                 variants,
                 meta,
+                vis: ast.vis.clone(),
             }
         }
         _ => abort_call_site!("`Strip` can only be derived for enums"),
@@ -106,11 +105,12 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
         ident,
         variants,
         meta,
+        vis,
     } = info;
 
     quote! {
         #(#[#meta])*
-        pub enum #ident {
+        #vis enum #ident {
             #(#variants),*
         }
     }

From d36d4364f4b1ffa7502434cfae50f8ed939a9c8b Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Tue, 10 Dec 2024 13:17:26 +1100
Subject: [PATCH 21/33] updated meta parsing

---
 quork-proc/src/strip_enum.rs | 74 ++++++++++++++++++------------------
 1 file changed, 36 insertions(+), 38 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 3af256b..943aefc 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -1,7 +1,10 @@
 use proc_macro2::{Ident, TokenStream};
 use proc_macro_error::{abort, abort_call_site};
 use quote::{quote, ToTokens};
-use syn::{spanned::Spanned, DeriveInput, Expr, ExprLit, Lit, Variant, Visibility};
+use syn::{
+    punctuated::Punctuated, spanned::Spanned, DeriveInput, Expr, ExprLit, Lit, Meta, Token,
+    Variant, Visibility,
+};
 
 fn ignore_variant(variant: &Variant) -> bool {
     variant.attrs.iter().any(|attr| match attr.meta {
@@ -48,53 +51,48 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 })
                 .collect::<Vec<_>>();
 
-            let new_ident = if let Some(info_attr) = attrs
-                .iter()
-                .find(|attr| attr.path().is_ident("stripped_ident"))
+            let default_ident = || Ident::new(&format!("{}Stripped", ast.ident), ast.ident.span());
+
+            let (new_ident, ignored) = if let Some(info_attr) =
+                attrs.iter().find(|attr| attr.path().is_ident("stripped"))
             {
-                match &info_attr.meta {
-                    syn::Meta::NameValue(name_value) => {
-                        let ident = &name_value.value;
+                let mut new_ident: Option<Ident> = None;
+                let mut ignored = false;
 
-                        if let syn::Expr::Lit(ExprLit {
-                            lit: Lit::Str(string),
-                            ..
-                        }) = ident
-                        {
-                            Ident::new(
-                                &string.value().replace("{}", &ast.ident.to_string()),
-                                ast.ident.span(),
-                            )
-                        } else {
-                            abort!(ident.span(), "Expected string literal.")
-                        }
+                syn::meta::parser(|meta| {
+                    if meta.path.is_ident("ident") {
+                        new_ident = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else if meta.path.is_ident("ignore") {
+                        ignored = true;
+                        Ok(())
+                    } else {
+                        Err(meta.error("unsupported stripped property"))
                     }
-                    _ => abort!(
-                        info_attr.span(),
-                        "Expected #[stripped_ident = \"\"]. Found other style attribute."
-                    ),
-                }
+                });
+
+                (new_ident.unwrap_or_else(default_ident), ignored)
             } else {
-                Ident::new(&format!("{}Stripped", ast.ident), ast.ident.span())
+                (default_ident(), false)
             };
 
-            let meta = attrs
-                .iter()
-                .filter(|attr| attr.path().is_ident("stripped_meta"))
-                .map(|attr| match &attr.meta {
-                    // TODO: Add inherit metadata
-                    syn::Meta::List(meta) => meta.parse_args().expect("single meta attribute"),
-                    _ => abort!(
-                        attr.span(),
-                        "Expected #[stripped_meta(...)]. Found other style attribute."
-                    ),
-                })
-                .collect();
+            // let meta = attrs
+            //     .iter()
+            //     .filter(|attr| attr.path().is_ident("stripped_meta"))
+            //     .map(|attr| match &attr.meta {
+            //         // TODO: Add inherit metadata
+            //         syn::Meta::List(meta) => meta.parse_args().expect(&*"single meta attribute"),
+            //         _ => abort!(
+            //             attr.span(),
+            //             "Expected #[stripped_meta(...)]. Found other style attribute."
+            //         ),
+            //     })
+            //     .collect();
 
             StrippedData {
                 ident: new_ident,
                 variants,
-                meta,
+                meta: ast.,
                 vis: ast.vis.clone(),
             }
         }

From 33bc53a36316f1968c2e4dce44f97b829831abf2 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Tue, 10 Dec 2024 13:29:24 +1100
Subject: [PATCH 22/33] updated strip enum macro

---
 quork-proc/src/lib.rs        |  7 ++--
 quork-proc/src/strip_enum.rs | 74 ++++++++++++++++++++----------------
 2 files changed, 45 insertions(+), 36 deletions(-)

diff --git a/quork-proc/src/lib.rs b/quork-proc/src/lib.rs
index 3bd36ab..79243f8 100644
--- a/quork-proc/src/lib.rs
+++ b/quork-proc/src/lib.rs
@@ -18,12 +18,13 @@ mod time_fn;
 #[macro_use]
 extern crate quote;
 
-#[proc_macro_derive(Strip, attributes(stripped_ident, stripped_meta, stripped_ignore))]
+/// Create an additional enum with all values stripped
+#[proc_macro_derive(Strip, attributes(stripped))]
 #[proc_macro_error]
 pub fn strip_enum(input: TokenStream) -> TokenStream {
-    let ast = parse_macro_input!(input as DeriveInput);
+    let mut ast = parse_macro_input!(input as DeriveInput);
 
-    strip_enum::strip_enum(&ast).into()
+    strip_enum::strip_enum(&mut ast).into()
 }
 
 /// Implement [`quork::ListVariants`] for enums
diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 943aefc..c268c2e 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -1,17 +1,29 @@
 use proc_macro2::{Ident, TokenStream};
 use proc_macro_error::{abort, abort_call_site};
 use quote::{quote, ToTokens};
-use syn::{
-    punctuated::Punctuated, spanned::Spanned, DeriveInput, Expr, ExprLit, Lit, Meta, Token,
-    Variant, Visibility,
-};
+use syn::{spanned::Spanned, DeriveInput, Meta, Variant, Visibility};
 
 fn ignore_variant(variant: &Variant) -> bool {
     variant.attrs.iter().any(|attr| match attr.meta {
-        syn::Meta::Path(ref p) => p.is_ident("stripped_ignore"),
+        syn::Meta::List(ref list) if list.path.is_ident("stripped") => {
+            let mut ignored = false;
+
+            let list_parser = syn::meta::parser(|meta| {
+                if meta.path.is_ident("ignore") {
+                    ignored = true;
+                    Ok(())
+                } else {
+                    Err(meta.error("unsupported stripped property"))
+                }
+            });
+
+            list.parse_args_with(list_parser).unwrap();
+
+            ignored
+        }
         _ => abort!(
             attr.span(),
-            "Expected path-style (i.e #[stripped_ignore]), found other style attribute macro"
+            "Expected list-style (i.e #[stripped(...)]), found other style attribute macro"
         ),
     })
 }
@@ -19,7 +31,7 @@ fn ignore_variant(variant: &Variant) -> bool {
 struct StrippedData {
     ident: Ident,
     variants: Vec<TokenStream>,
-    meta: Vec<Expr>,
+    meta: Vec<Meta>,
     vis: Visibility,
 }
 
@@ -33,9 +45,9 @@ struct StrippedData {
 //     }
 // }
 
-pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
+pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
     let data = &ast.data;
-    let attrs = &ast.attrs;
+    let attrs = &mut ast.attrs;
 
     let info: StrippedData = match data {
         syn::Data::Enum(ref e) => {
@@ -51,48 +63,44 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
                 })
                 .collect::<Vec<_>>();
 
-            let default_ident = || Ident::new(&format!("{}Stripped", ast.ident), ast.ident.span());
+            let default_ident = {
+                let ident = ast.ident.clone();
+                let span = ident.span();
+                move || Ident::new(&format!("{ident}Stripped"), span)
+            };
 
-            let (new_ident, ignored) = if let Some(info_attr) =
-                attrs.iter().find(|attr| attr.path().is_ident("stripped"))
+            let (new_ident, meta_list) = if let Some(info_attr_pos) = attrs
+                .iter()
+                .position(|attr| attr.path().is_ident("stripped_ident"))
             {
+                let info_attr = attrs.remove(info_attr_pos);
+
                 let mut new_ident: Option<Ident> = None;
-                let mut ignored = false;
+                let mut meta_list = Vec::<syn::Meta>::new();
 
-                syn::meta::parser(|meta| {
+                let ident_parser = syn::meta::parser(|meta| {
                     if meta.path.is_ident("ident") {
                         new_ident = Some(meta.value()?.parse()?);
                         Ok(())
-                    } else if meta.path.is_ident("ignore") {
-                        ignored = true;
+                    } else if meta.path.is_ident("meta") {
+                        meta_list.push(meta.value()?.parse()?);
                         Ok(())
                     } else {
                         Err(meta.error("unsupported stripped property"))
                     }
                 });
 
-                (new_ident.unwrap_or_else(default_ident), ignored)
+                info_attr.parse_args_with(ident_parser).unwrap();
+
+                (new_ident.unwrap_or_else(default_ident), meta_list)
             } else {
-                (default_ident(), false)
+                (default_ident(), Vec::new())
             };
 
-            // let meta = attrs
-            //     .iter()
-            //     .filter(|attr| attr.path().is_ident("stripped_meta"))
-            //     .map(|attr| match &attr.meta {
-            //         // TODO: Add inherit metadata
-            //         syn::Meta::List(meta) => meta.parse_args().expect(&*"single meta attribute"),
-            //         _ => abort!(
-            //             attr.span(),
-            //             "Expected #[stripped_meta(...)]. Found other style attribute."
-            //         ),
-            //     })
-            //     .collect();
-
             StrippedData {
                 ident: new_ident,
                 variants,
-                meta: ast.,
+                meta: meta_list,
                 vis: ast.vis.clone(),
             }
         }
@@ -107,7 +115,7 @@ pub fn strip_enum(ast: &DeriveInput) -> TokenStream {
     } = info;
 
     quote! {
-        #(#[#meta])*
+        #(#meta)*
         #vis enum #ident {
             #(#variants),*
         }

From cea85c58159dc454c427c32d48ba12c563e6fd31 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Tue, 10 Dec 2024 13:34:36 +1100
Subject: [PATCH 23/33] updates and fixes

---
 quork-proc/src/strip_enum.rs   | 8 +++-----
 quork-proc/tests/strip_enum.rs | 3 +--
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index c268c2e..2b0980a 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -71,20 +71,16 @@ pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
 
             let (new_ident, meta_list) = if let Some(info_attr_pos) = attrs
                 .iter()
-                .position(|attr| attr.path().is_ident("stripped_ident"))
+                .position(|attr| attr.path().is_ident("stripped"))
             {
                 let info_attr = attrs.remove(info_attr_pos);
 
                 let mut new_ident: Option<Ident> = None;
-                let mut meta_list = Vec::<syn::Meta>::new();
 
                 let ident_parser = syn::meta::parser(|meta| {
                     if meta.path.is_ident("ident") {
                         new_ident = Some(meta.value()?.parse()?);
                         Ok(())
-                    } else if meta.path.is_ident("meta") {
-                        meta_list.push(meta.value()?.parse()?);
-                        Ok(())
                     } else {
                         Err(meta.error("unsupported stripped property"))
                     }
@@ -114,6 +110,8 @@ pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
         vis,
     } = info;
 
+    // panic!("{:?}", meta);
+
     quote! {
         #(#meta)*
         #vis enum #ident {
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index 235d635..0702b1d 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -13,8 +13,7 @@ pub fn enum_to_string<T: IntoEnumIterator + Display>() -> String {
 struct DummyStruct;
 
 #[derive(Strip)]
-#[stripped_meta(derive(EnumIter, Display))]
-#[stripped_meta(strum(serialize_all = "kebab-case"))]
+#[stripped(meta = derive(EnumIter, Display), meta = strum(serialize_all = "kebab-case"))]
 enum EnumWithData {
     Test1(DummyStruct),
     Test2(DummyStruct),

From e6bda77218a2c8d0d17390bb6301f01d6f02f891 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Tue, 10 Dec 2024 13:39:08 +1100
Subject: [PATCH 24/33] fixed stripped meta passing

---
 quork-proc/src/lib.rs          |  2 +-
 quork-proc/src/strip_enum.rs   | 25 +++++++++++++++++++++----
 quork-proc/tests/strip_enum.rs |  3 ++-
 3 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/quork-proc/src/lib.rs b/quork-proc/src/lib.rs
index 79243f8..3d6826b 100644
--- a/quork-proc/src/lib.rs
+++ b/quork-proc/src/lib.rs
@@ -19,7 +19,7 @@ mod time_fn;
 extern crate quote;
 
 /// Create an additional enum with all values stripped
-#[proc_macro_derive(Strip, attributes(stripped))]
+#[proc_macro_derive(Strip, attributes(stripped_meta, stripped))]
 #[proc_macro_error]
 pub fn strip_enum(input: TokenStream) -> TokenStream {
     let mut ast = parse_macro_input!(input as DeriveInput);
diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 2b0980a..13798b4 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -69,7 +69,7 @@ pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
                 move || Ident::new(&format!("{ident}Stripped"), span)
             };
 
-            let (new_ident, meta_list) = if let Some(info_attr_pos) = attrs
+            let new_ident = if let Some(info_attr_pos) = attrs
                 .iter()
                 .position(|attr| attr.path().is_ident("stripped"))
             {
@@ -88,9 +88,26 @@ pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
 
                 info_attr.parse_args_with(ident_parser).unwrap();
 
-                (new_ident.unwrap_or_else(default_ident), meta_list)
+                new_ident.unwrap_or_else(default_ident)
             } else {
-                (default_ident(), Vec::new())
+                default_ident()
+            };
+
+            let mut meta_list: Vec<syn::Meta> = vec![];
+
+            if let Some(stripped_meta_pos) = attrs
+                .iter()
+                .position(|attr| attr.path().is_ident("stripped_meta"))
+            {
+                let meta_attr = attrs.remove(stripped_meta_pos);
+
+                match meta_attr.meta {
+                    Meta::List(_) => meta_list.push(meta_attr.meta),
+                    _ => abort!(
+                        meta_attr.span(),
+                        "Expected #[stripped_meta(...)]. Found other style attribute."
+                    ),
+                }
             };
 
             StrippedData {
@@ -113,7 +130,7 @@ pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
     // panic!("{:?}", meta);
 
     quote! {
-        #(#meta)*
+        #(#[#meta])*
         #vis enum #ident {
             #(#variants),*
         }
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index 0702b1d..235d635 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -13,7 +13,8 @@ pub fn enum_to_string<T: IntoEnumIterator + Display>() -> String {
 struct DummyStruct;
 
 #[derive(Strip)]
-#[stripped(meta = derive(EnumIter, Display), meta = strum(serialize_all = "kebab-case"))]
+#[stripped_meta(derive(EnumIter, Display))]
+#[stripped_meta(strum(serialize_all = "kebab-case"))]
 enum EnumWithData {
     Test1(DummyStruct),
     Test2(DummyStruct),

From 29c4b82bd2526fa41fa3bb0e037c7b946158d4bf Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Tue, 10 Dec 2024 13:42:22 +1100
Subject: [PATCH 25/33] fixed missing meta

---
 quork-proc/src/strip_enum.rs | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 13798b4..55693a6 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -93,22 +93,17 @@ pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
                 default_ident()
             };
 
-            let mut meta_list: Vec<syn::Meta> = vec![];
-
-            if let Some(stripped_meta_pos) = attrs
+            let meta_list: Vec<syn::Meta> = attrs
                 .iter()
-                .position(|attr| attr.path().is_ident("stripped_meta"))
-            {
-                let meta_attr = attrs.remove(stripped_meta_pos);
-
-                match meta_attr.meta {
-                    Meta::List(_) => meta_list.push(meta_attr.meta),
+                .filter(|attr| attr.path().is_ident("stripped_meta"))
+                .map(|meta_attr| match meta_attr.meta {
+                    Meta::List(_) => meta_attr.meta.clone(),
                     _ => abort!(
                         meta_attr.span(),
                         "Expected #[stripped_meta(...)]. Found other style attribute."
                     ),
-                }
-            };
+                })
+                .collect();
 
             StrippedData {
                 ident: new_ident,

From bdd2808770d402f7fceb2963dbd5b7adc25212e1 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Tue, 10 Dec 2024 13:50:53 +1100
Subject: [PATCH 26/33] fixed meta parsing

---
 quork-proc/src/strip_enum.rs   | 2 +-
 quork-proc/tests/strip_enum.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index 55693a6..40970d4 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -97,7 +97,7 @@ pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
                 .iter()
                 .filter(|attr| attr.path().is_ident("stripped_meta"))
                 .map(|meta_attr| match meta_attr.meta {
-                    Meta::List(_) => meta_attr.meta.clone(),
+                    Meta::List(ref meta_data) => meta_data.parse_args::<syn::Meta>().unwrap(),
                     _ => abort!(
                         meta_attr.span(),
                         "Expected #[stripped_meta(...)]. Found other style attribute."
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index 235d635..6b3c9f6 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -32,7 +32,7 @@ fn has_all_variants() {
 #[stripped_meta(strum(serialize_all = "kebab-case"))]
 enum EnumExclude {
     Test1(DummyStruct),
-    #[stripped_ignore]
+    #[stripped(ignore)]
     Test2(DummyStruct),
     Test3(DummyStruct),
 }

From d513acf9fe10443eef5230e870aa6ccf68340171 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Tue, 10 Dec 2024 13:54:04 +1100
Subject: [PATCH 27/33] updated deps

---
 quork-proc/Cargo.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/quork-proc/Cargo.toml b/quork-proc/Cargo.toml
index 7adbf27..03a17d5 100644
--- a/quork-proc/Cargo.toml
+++ b/quork-proc/Cargo.toml
@@ -15,7 +15,7 @@ proc-macro = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-heck = { version = "0.4.1", features = ["unicode"] }
+heck = { version = "0.5" }
 proc-macro-crate = "3.1"
 proc-macro-error2 = "2.0"
 proc-macro2 = "1.0"
@@ -23,4 +23,4 @@ quote = "1.0"
 syn = { version = "2.0", features = ["full"] }
 
 [dev-dependencies]
-strum = { version = "0.25.0", features = ["derive"] }
+strum = { version = "0.26", features = ["derive"] }

From 27a50750723eafdd28e8b45714392cc870d7d091 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Tue, 10 Dec 2024 13:54:13 +1100
Subject: [PATCH 28/33] fixes

---
 quork-proc/Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quork-proc/Cargo.toml b/quork-proc/Cargo.toml
index 03a17d5..c52cbfb 100644
--- a/quork-proc/Cargo.toml
+++ b/quork-proc/Cargo.toml
@@ -15,7 +15,7 @@ proc-macro = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-heck = { version = "0.5" }
+heck = "0.5"
 proc-macro-crate = "3.1"
 proc-macro-error2 = "2.0"
 proc-macro2 = "1.0"

From 9d8a461105f9f57f45729be1dc95d7258601c951 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Tue, 10 Dec 2024 14:04:06 +1100
Subject: [PATCH 29/33] removed inherited meta

---
 quork-proc/src/strip_enum.rs   | 24 +++++++++++++++++++++---
 quork-proc/tests/strip_enum.rs |  7 +++++++
 2 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index efc9397..a2e9e62 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -1,7 +1,7 @@
 use proc_macro2::{Ident, TokenStream};
 use proc_macro_error2::{abort, abort_call_site};
 use quote::{quote, ToTokens};
-use syn::{spanned::Spanned, DeriveInput, Meta, Variant, Visibility};
+use syn::{spanned::Spanned, DeriveInput, Meta, MetaNameValue, Variant, Visibility};
 
 fn ignore_variant(variant: &Variant) -> bool {
     variant.attrs.iter().any(|attr| match attr.meta {
@@ -96,8 +96,26 @@ pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
             let meta_list: Vec<syn::Meta> = attrs
                 .iter()
                 .filter(|attr| attr.path().is_ident("stripped_meta"))
-                .map(|meta_attr| match meta_attr.meta {
-                    Meta::List(ref meta_data) => meta_data.parse_args::<syn::Meta>().unwrap(),
+                .flat_map(|meta_attr| match &meta_attr.meta {
+                    Meta::List(meta_data) => vec![meta_data.parse_args::<syn::Meta>().unwrap()],
+                    // Meta::NameValue(MetaNameValue {
+                    //     value:
+                    //         syn::Expr::Lit(syn::ExprLit {
+                    //             lit: syn::Lit::Str(path),
+                    //             ..
+                    //         }),
+                    //     ..
+                    // }) => {
+                    //     if &path.value() == "inherit" {
+                    //         attrs
+                    //             .iter()
+                    //             .filter(|attr| !attr.path().is_ident("stripped_meta"))
+                    //             .map(|attr| attr.meta.clone())
+                    //             .collect()
+                    //     } else {
+                    //         abort!(path.span(), "Expected `inherit`");
+                    //     }
+                    // }
                     _ => abort!(
                         meta_attr.span(),
                         "Expected #[stripped_meta(...)]. Found other style attribute."
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index 6b3c9f6..506ef8a 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -37,6 +37,13 @@ enum EnumExclude {
     Test3(DummyStruct),
 }
 
+#[derive(Strip, Display)]
+#[stripped_meta(derive(EnumIter))]
+#[stripped_meta(strum(serialize_all = "kebab-case"))]
+enum EnumWithInherit {
+    Test1(DummyStruct),
+}
+
 #[test]
 fn excludes_no_hook_variant() {
     let variants = enum_to_string::<EnumExcludeStripped>();

From 6f634db2df64143866a9b1172a4b3f45b3308d34 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Wed, 11 Dec 2024 10:58:30 +1100
Subject: [PATCH 30/33] handle errors for variant attributes parsing

---
 quork-proc/src/strip_enum.rs   | 8 +++++++-
 quork-proc/tests/strip_enum.rs | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index a2e9e62..e5a4d3c 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -17,7 +17,13 @@ fn ignore_variant(variant: &Variant) -> bool {
                 }
             });
 
-            list.parse_args_with(list_parser).unwrap();
+            if let Err(err) = list.parse_args_with(list_parser) {
+                abort! {
+                    err.span(),
+                    "Failed to parse stripped attribute: {}", err;
+                    help = "Only supported properties on enum variants are `ignore`"
+                }
+            }
 
             ignored
         }
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index 506ef8a..fa0d9ad 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -32,7 +32,7 @@ fn has_all_variants() {
 #[stripped_meta(strum(serialize_all = "kebab-case"))]
 enum EnumExclude {
     Test1(DummyStruct),
-    #[stripped(ignore)]
+    #[stripped(notignore)]
     Test2(DummyStruct),
     Test3(DummyStruct),
 }

From 722cdf5eadd8beb7330ad2ea0e8e99df26e2ea11 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Wed, 11 Dec 2024 11:02:31 +1100
Subject: [PATCH 31/33] update error handling in enum strip

---
 quork-proc/src/strip_enum.rs   | 25 ++++++++++++++++++++-----
 quork-proc/tests/strip_enum.rs | 12 ++++++++++--
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index e5a4d3c..eaff25c 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -13,14 +13,14 @@ fn ignore_variant(variant: &Variant) -> bool {
                     ignored = true;
                     Ok(())
                 } else {
-                    Err(meta.error("unsupported stripped property"))
+                    Err(meta.error("unsupported property"))
                 }
             });
 
             if let Err(err) = list.parse_args_with(list_parser) {
                 abort! {
                     err.span(),
-                    "Failed to parse stripped attribute: {}", err;
+                    "Failed to parse attribute: {}", err;
                     help = "Only supported properties on enum variants are `ignore`"
                 }
             }
@@ -88,11 +88,17 @@ pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
                         new_ident = Some(meta.value()?.parse()?);
                         Ok(())
                     } else {
-                        Err(meta.error("unsupported stripped property"))
+                        Err(meta.error("unsupported property"))
                     }
                 });
 
-                info_attr.parse_args_with(ident_parser).unwrap();
+                if let Err(err) = info_attr.parse_args_with(ident_parser) {
+                    abort! {
+                        err.span(),
+                        "Failed to parse attribute: {}", err;
+                        help = "Only supported properties on enum definitions are `ident`"
+                    }
+                }
 
                 new_ident.unwrap_or_else(default_ident)
             } else {
@@ -103,7 +109,16 @@ pub fn strip_enum(ast: &mut DeriveInput) -> TokenStream {
                 .iter()
                 .filter(|attr| attr.path().is_ident("stripped_meta"))
                 .flat_map(|meta_attr| match &meta_attr.meta {
-                    Meta::List(meta_data) => vec![meta_data.parse_args::<syn::Meta>().unwrap()],
+                    Meta::List(meta_data) => match meta_data.parse_args::<syn::Meta>() {
+                        Ok(meta) => vec![meta],
+                        Err(err) => {
+                            abort! {
+                                err.span(),
+                                "Failed to parse specified metadata: {}", err;
+                                help = "Make sure the provided arguments are in the form of Rust metadata. (i.e the tokens contained within `#[...]`)"
+                            }
+                        }
+                    },
                     // Meta::NameValue(MetaNameValue {
                     //     value:
                     //         syn::Expr::Lit(syn::ExprLit {
diff --git a/quork-proc/tests/strip_enum.rs b/quork-proc/tests/strip_enum.rs
index fa0d9ad..be4f4ee 100644
--- a/quork-proc/tests/strip_enum.rs
+++ b/quork-proc/tests/strip_enum.rs
@@ -32,18 +32,26 @@ fn has_all_variants() {
 #[stripped_meta(strum(serialize_all = "kebab-case"))]
 enum EnumExclude {
     Test1(DummyStruct),
-    #[stripped(notignore)]
+    #[stripped(ignore)]
     Test2(DummyStruct),
     Test3(DummyStruct),
 }
 
-#[derive(Strip, Display)]
+#[derive(Strip)]
 #[stripped_meta(derive(EnumIter))]
 #[stripped_meta(strum(serialize_all = "kebab-case"))]
 enum EnumWithInherit {
     Test1(DummyStruct),
 }
 
+#[derive(Strip)]
+#[stripped_meta(derive(EnumIter))]
+#[stripped_meta(strum(serialize_all = "kebab-case"))]
+#[stripped(ident = IChoseThisIdent)]
+enum EnumWithCustomIdent {
+    Test1(DummyStruct),
+}
+
 #[test]
 fn excludes_no_hook_variant() {
     let variants = enum_to_string::<EnumExcludeStripped>();

From fd8894057592602e08ff0ca0301bc540556882e1 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Wed, 11 Dec 2024 11:05:07 +1100
Subject: [PATCH 32/33] fixes

---
 quork-proc/src/strip_enum.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quork-proc/src/strip_enum.rs b/quork-proc/src/strip_enum.rs
index eaff25c..f31b634 100644
--- a/quork-proc/src/strip_enum.rs
+++ b/quork-proc/src/strip_enum.rs
@@ -1,7 +1,7 @@
 use proc_macro2::{Ident, TokenStream};
 use proc_macro_error2::{abort, abort_call_site};
 use quote::{quote, ToTokens};
-use syn::{spanned::Spanned, DeriveInput, Meta, MetaNameValue, Variant, Visibility};
+use syn::{spanned::Spanned, DeriveInput, Meta, Variant, Visibility};
 
 fn ignore_variant(variant: &Variant) -> bool {
     variant.attrs.iter().any(|attr| match attr.meta {

From 53cdd706e3d03f01cba906838a53aaa0267f6c28 Mon Sep 17 00:00:00 2001
From: Juliette Cordor <me@cordor.dev>
Date: Wed, 11 Dec 2024 11:06:36 +1100
Subject: [PATCH 33/33] remove heck dependency

---
 quork-proc/Cargo.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/quork-proc/Cargo.toml b/quork-proc/Cargo.toml
index c52cbfb..ee007c5 100644
--- a/quork-proc/Cargo.toml
+++ b/quork-proc/Cargo.toml
@@ -15,7 +15,6 @@ proc-macro = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-heck = "0.5"
 proc-macro-crate = "3.1"
 proc-macro-error2 = "2.0"
 proc-macro2 = "1.0"