Derive Macro VariantName 

#[derive(VariantName)]
{
    // Attributes available to this derive:
    #[variant_name]
}

Automatically implements [more_convert::VariantName] on enum

Where to use:

• Only want the kind

Note:

• prefix and suffix are applied after rename_all

EnumAttribute:

• rename_all: apply rule to field name
  • default is “none”
  • The possible values are (“lowercase”, “UPPERCASE”, “PascalCase”, “camelCase”, “snake_case”, “SCREAMING_SNAKE_CASE”, “kebab-case”, “SCREAMING-KEBAB-CASE”)
• prefix: add prefix to field name
• suffix: add suffix to field name

Variant Attribute:

• rename: rename field, (prefix, suffix and rename_all are not applied)
• nest: call VariantName on the first field of the variant

Examples

Normal

use more_convert::VariantName;

#[derive(VariantName)]
pub enum Error {
  InvalidCode,
  ServerError,
}

assert_eq!("InvalidCode", Error::InvalidCode.variant_name());
assert_eq!("ServerError", Error::ServerError.variant_name());

rename and rename_all

use more_convert::VariantName;

#[derive(VariantName)]
#[variant_name(rename_all = "snake_case")]
pub enum Error {
  InvalidCode,
  ServerError,
  #[variant_name(rename = "NotFound")]
  NotFoundError,
}

assert_eq!("invalid_code", Error::InvalidCode.variant_name());
assert_eq!("server_error", Error::ServerError.variant_name());
assert_eq!("NotFound", Error::NotFoundError.variant_name());

prefix and suffix

use more_convert::VariantName;

#[derive(VariantName)]
#[variant_name(prefix = "Error", suffix  = "What")]
pub enum Error {
 InvalidCode,
 ServerError,
}

assert_eq!("ErrorInvalidCodeWhat", Error::InvalidCode.variant_name());
assert_eq!("ErrorServerErrorWhat", Error::ServerError.variant_name());

nest

use more_convert::VariantName;

#[derive(VariantName)]
#[variant_name(prefix = "Inner")]
pub enum Inner {
    A,
    B,
}

#[derive(VariantName)]
pub enum TestVariantName {
    InvalidCode,

    #[variant_name(nest)]
    Inner(Inner),
}

assert_eq!("InvalidCode", TestVariantName::InvalidCode.variant_name());

assert_eq!("InnerA", TestVariantName::Inner(Inner::A).variant_name());
assert_eq!("InnerB", TestVariantName::Inner(Inner::B).variant_name());

without_trait

#[derive(more_convert::VariantName)]
#[variant_name(without_trait)]
pub enum Error {
 InvalidCode,
 ServerError,
}

// call at const
const INVALID_CODE: &str = Error::InvalidCode.variant_name();

mod test {
    fn something() {
        // not depend on VariantName trait
        crate::Error::InvalidCode.variant_name();
    }
}