Set version 0.0.1

Author: greyblake

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "kinded"
-version = "0.1.0"
+version = "0.0.1"
 edition = "2021"
 authors = ["Serhii Potapov <blake131313@gmail.com>"]
 

kinded/Cargo.toml

@@ -43,8 +43,10 @@ fn gen_enum_kind(meta: &Meta) -> TokenStream {
     let vis = &meta.vis;
     let kind_name = meta.kind_name();
     let variant_name_idents = meta.variants.iter().map(|v| &v.ident);
+    let traits = meta.derive_traits();
+
     quote!(
-        #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+        #[derive(#(#traits),*)]
         #vis enum #kind_name {
             #(#variant_name_idents),*
         }

kinded_macros/src/gen.rs

@@ -7,15 +7,17 @@ use syn::DeriveInput;
 
 // DONE:
 // * Allow renaming of kind type
+// * Allow to derive custom traits
 
 // TODO:
-// * Allow to derive custom traits
 // * Consider supporting FromStr / Display?
 // * Allow to iterate, access ALL variants of Kind
+// * Features:
+//   * enum-map
 // * Write documentation
 //   * lib.rs
 //   * README
-//   * How it differs from enum-kind ?
+//   * How it differs from enum-kinds ?
 //
 
 #[proc_macro_derive(Kinded, attributes(kinded))]

kinded_macros/src/lib.rs

@@ -1,6 +1,6 @@
 use proc_macro2::Ident;
 use quote::format_ident;
-use syn::Visibility;
+use syn::{Visibility, Path};
 
 #[derive(Debug)]
 pub struct Meta {
@@ -17,13 +17,36 @@ pub struct Meta {
 }
 
 impl Meta {
+    /// Get the name for the kind type.
     pub fn kind_name(&self) -> Ident {
         if let Some(ref kind_name) = self.kinded_attrs.kind {
             kind_name.clone()
         } else {
             format_ident!("{}Kind", self.ident)
         }
     }
+
+    /// Get the traits that need to be derived.
+    pub fn derive_traits(&self) -> Vec<Path> {
+        const DEFAULT_DERIVE_TRAITS: &[&'static str] = &[
+            "Debug", "Clone", "Copy", "PartialEq", "Eq",
+        ];
+
+        let mut traits: Vec<Path> = DEFAULT_DERIVE_TRAITS.iter().map(|trait_name| {
+            Path::from(format_ident!("{trait_name}"))
+        }).collect();
+
+        // Add the extra specified traits, if they're different from the default ones
+        if let Some(ref extra_traits) = self.kinded_attrs.derive {
+            for extra_trait in extra_traits {
+                if !traits.contains(extra_trait) {
+                    traits.push(extra_trait.clone());
+                }
+            }
+        }
+
+        traits
+    }
 }
 
 #[derive(Debug)]
@@ -48,6 +71,9 @@ pub enum FieldsType {
 /// Attributes specified with #[kinded(..)]
 #[derive(Debug, Default)]
 pub struct KindedAttributes {
-    /// Name for the kind type
+    /// Name for the kind type, specified with `kind = ...`
     pub kind: Option<Ident>,
+
+    /// Traits to derive, specified with `derive(...)`
+    pub derive: Option<Vec<Path>>,
 }

kinded_macros/src/models.rs

@@ -5,12 +5,10 @@ use syn::{
     bracketed, parenthesized,
     parse::{Parse, ParseStream},
     spanned::Spanned,
-    Attribute, Data, DeriveInput, Token,
+    Attribute, Data, DeriveInput, Token, Path,
 };
 
 pub fn parse_derive_input(input: DeriveInput) -> Result<Meta, syn::Error> {
-    eprintln!("{input:#?}");
-
     let kinded_attrs: KindedAttributes = {
         match find_kinded_attr(&input)? {
             Some(kinded_attr) => syn::parse2(kinded_attr.to_token_stream())?,
@@ -89,19 +87,38 @@ impl Parse for KindedAttributes {
             parenthesized_content
         };
 
-        let attr_name: Ident = input.parse()?;
-        if attr_name == "kind" {
-            let _: Token!(=) = input.parse()?;
-            let kind: Ident = input.parse()?;
-            if kinded_attrs.kind.is_none() {
-                kinded_attrs.kind = Some(kind);
+
+        while !input.is_empty() {
+            let attr_name: Ident = input.parse()?;
+            if attr_name == "kind" {
+                let _: Token!(=) = input.parse()?;
+                let kind: Ident = input.parse()?;
+                if kinded_attrs.kind.is_none() {
+                    kinded_attrs.kind = Some(kind);
+                } else {
+                    let msg = format!("Duplicated attribute: {attr_name}");
+                    return Err(syn::Error::new(attr_name.span(), msg));
+                }
+            } else if attr_name == "derive" {
+                let derive_input;
+                parenthesized!(derive_input in input);
+                let parsed_traits = derive_input.parse_terminated(Path::parse, Token![,])?;
+                let traits: Vec<Path> = parsed_traits.into_iter().collect();
+                if kinded_attrs.derive.is_none() {
+                    kinded_attrs.derive = Some(traits);
+                } else {
+                    let msg = format!("Duplicated attribute: {attr_name}");
+                    return Err(syn::Error::new(attr_name.span(), msg));
+                }
             } else {
-                let msg = format!("Duplicated attribute: {attr_name}");
+                let msg = format!("Unknown attribute: {attr_name}");
                 return Err(syn::Error::new(attr_name.span(), msg));
             }
-        } else {
-            let msg = format!("Unknown attribute: {attr_name}");
-            return Err(syn::Error::new(attr_name.span(), msg));
+
+            // Parse `,` unless it's the end of the stream
+            if !input.is_empty() {
+                let _comma: Token![,] = input.parse()?;
+            }
         }
 
         Ok(kinded_attrs)

kinded_macros/src/parse.rs

@@ -1,6 +1,6 @@
 [package]
 name = "sandbox"
-version = "0.1.0"
+version = "0.0.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

sandbox/Cargo.toml

@@ -110,3 +110,20 @@ fn should_allow_to_give_custom_name_kind_type() {
     let green_tea = Drink::Tea("Green");
     assert_eq!(green_tea.kind(), SimpleDrink::Tea);
 }
+
+#[test]
+fn should_allow_to_derive_custom_traits() {
+    use std::collections::HashMap;
+
+    #[derive(Kinded)]
+    #[kinded(derive(Hash, Eq))]
+    enum Drink {
+        Tea(&'static str),
+        Coffee(&'static str),
+    }
+
+    let mut drinks =  HashMap::new();
+    drinks.insert(DrinkKind::Tea, 5);
+
+    assert!(false);
+}