Support #[from_str(rename_all = "...")] attribute (#467, #216)

Resolves #216   
Requires #468, #469

## Synopsis

We have `#[display(rename_all = "...")]` attribute for flat enums. The
counterpart for `FromStr` derive is missing.

## Solution

This PR adds support `#[from_str(rename_all = "...")]` attribute on
enums. Once this attribute is specified, the matching is always exact
(for now, by default, matching could be fuzzy if there is no similarly
named variants).

Author: tyranron

CHANGELOG.md

@@ -12,6 +12,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Support `#[display(rename_all = "<casing>")]` attribute to change output for
   implicit naming of unit enum variants or unit structs when deriving `Display`.
   ([#443](https://github.com/JelteF/derive_more/pull/443))
+- Support `#[from_str(rename_all = "<casing>")]` attribute for unit enum variants
+  and unit structs when deriving `FromStr`.
+  ([#467](https://github.com/JelteF/derive_more/pull/467))
 - Support `Option` fields for `Error::source()` in `Error` derive.
   ([#459](https://github.com/JelteF/derive_more/pull/459))
 - Support structs with no fields in `FromStr` derive.

impl/Cargo.toml

@@ -59,7 +59,7 @@ deref_mut = []
 display = ["syn/extra-traits", "dep:unicode-xid", "dep:convert_case"]
 error = ["syn/extra-traits"]
 from = ["syn/extra-traits"]
-from_str = []
+from_str = ["dep:convert_case"]
 index = []
 index_mut = []
 into = ["syn/extra-traits"]

impl/doc/from_str.md

@@ -170,3 +170,61 @@ impl derive_more::core::str::FromStr for Foo {
     }
 }
 ```
+
+
+### The `rename_all` attribute
+
+To control the concrete string representation of the name verbatim,
+the `#[from_str(rename_all = "...")]` attribute can be placed on structs,
+enums and variants.
+
+The available casings are:
+- `lowercase`
+- `UPPERCASE`
+- `PascalCase`
+- `camelCase`
+- `snake_case`
+- `SCREAMING_SNAKE_CASE`
+- `kebab-case`
+- `SCREAMING-KEBAB-CASE`
+
+```rust
+# use derive_more::FromStr;
+#
+#[derive(FromStr, Debug, Eq, PartialEq)]
+#[from_str(rename_all = "lowercase")]
+enum Enum {
+    VariantOne,
+    #[from_str(rename_all = "kebab-case")] // overrides the top-level one
+    VariantTwo
+}
+
+assert_eq!("variantone".parse::<Enum>().unwrap(), Enum::VariantOne);
+assert_eq!("variant-two".parse::<Enum>().unwrap(), Enum::VariantTwo);
+```
+
+> **NOTE**: Using `#[from_str(rename_all = "...")]` attribute disables
+> any case-insensitivity where applied. This is also true for any enum
+> variant whose name or string representation is similar to the variant
+> being marked:
+> ```rust
+> # use derive_more::FromStr;
+> #
+> # #[allow(non_camel_case_types)]
+> #[derive(FromStr, Debug, Eq, PartialEq)]
+> enum Enum {
+>    Foo,  // case-insensitive
+>    #[from_str(rename_all = "SCREAMING_SNAKE_CASE")]
+>    BaR,  // case-sensitive (marked with attribute)
+>    Bar,  // case-sensitive (name is similar to the marked `BaR` variant)
+>    Ba_R, // case-sensitive (string representation is similar to the marked `BaR` variant)
+> }
+> #
+> # assert_eq!("Foo".parse::<Enum>().unwrap(), Enum::Foo);
+> # assert_eq!("FOO".parse::<Enum>().unwrap(), Enum::Foo);
+> # assert_eq!("foo".parse::<Enum>().unwrap(), Enum::Foo);
+> #
+> # assert_eq!("BA_R".parse::<Enum>().unwrap(), Enum::BaR);
+> # assert_eq!("Bar".parse::<Enum>().unwrap(), Enum::Bar);
+> # assert_eq!("Ba_R".parse::<Enum>().unwrap(), Enum::Ba_R);
+> ```

impl/src/fmt/display.rs

@@ -3,7 +3,6 @@
 #[cfg(doc)]
 use std::fmt;
 
-use convert_case::Casing;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use syn::{
@@ -95,8 +94,8 @@ pub fn expand(input: &syn::DeriveInput, trait_name: &str) -> syn::Result<TokenSt
 /// while multiple `#[<attribute>(bound(...))]` are allowed.
 #[derive(Debug, Default)]
 struct ContainerAttributes {
-    /// [`RenameAllAttribute`] for case convertion.
-    rename_all: Option<RenameAllAttribute>,
+    /// [`attr::RenameAll`] for case convertion.
+    rename_all: Option<attr::RenameAll>,
 
     /// Common [`ContainerAttributes`].
     ///
@@ -180,80 +179,6 @@ impl attr::ParseMultiple for ContainerAttributes {
     }
 }
 
-/// Representation of a `rename_all` macro attribute.
-///
-/// ```rust,ignore
-/// #[<attribute>(rename_all = "...")]
-/// ```
-///
-/// Possible cases:
-/// - `lowercase`
-/// - `UPPERCASE`
-/// - `PascalCase`
-/// - `camelCase`
-/// - `snake_case`
-/// - `SCREAMING_SNAKE_CASE`
-/// - `kebab-case`
-/// - `SCREAMING-KEBAB-CASE`
-#[derive(Debug, Clone, Copy)]
-enum RenameAllAttribute {
-    Lower,
-    Upper,
-    Pascal,
-    Camel,
-    Snake,
-    ScreamingSnake,
-    Kebab,
-    ScreamingKebab,
-}
-
-impl RenameAllAttribute {
-    /// Converts the provided `name` into the case of this [`RenameAllAttribute`].
-    fn convert_case(&self, name: &str) -> String {
-        let case = match self {
-            Self::Lower => convert_case::Case::Flat,
-            Self::Upper => convert_case::Case::UpperFlat,
-            Self::Pascal => convert_case::Case::Pascal,
-            Self::Camel => convert_case::Case::Camel,
-            Self::Snake => convert_case::Case::Snake,
-            Self::ScreamingSnake => convert_case::Case::UpperSnake,
-            Self::Kebab => convert_case::Case::Kebab,
-            Self::ScreamingKebab => convert_case::Case::UpperKebab,
-        };
-        name.to_case(case)
-    }
-}
-
-impl Parse for RenameAllAttribute {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let _ = input.parse::<syn::Path>().and_then(|p| {
-            if p.is_ident("rename_all") {
-                Ok(p)
-            } else {
-                Err(syn::Error::new(
-                    p.span(),
-                    "unknown attribute argument, expected `rename_all = \"...\"`",
-                ))
-            }
-        })?;
-
-        input.parse::<token::Eq>()?;
-
-        let value: LitStr = input.parse()?;
-        Ok(match value.value().replace(['-', '_'], "").to_lowercase().as_str() {
-            "lowercase" => Self::Lower,
-            "uppercase" => Self::Upper,
-            "pascalcase" => Self::Pascal,
-            "camelcase" => Self::Camel,
-            "snakecase" => Self::Snake,
-            "screamingsnakecase" => Self::ScreamingSnake,
-            "kebabcase" => Self::Kebab,
-            "screamingkebabcase" => Self::ScreamingKebab,
-            _ => return Err(syn::Error::new_spanned(value, "unexpected casing expected one of: \"lowercase\", \"UPPERCASE\", \"PascalCase\", \"camelCase\", \"snake_case\", \"SCREAMING_SNAKE_CASE\", \"kebab-case\", or \"SCREAMING-KEBAB-CASE\""))
-        })
-    }
-}
-
 /// Type alias for an expansion context:
 /// - [`ContainerAttributes`].
 /// - Type parameters. Slice of [`syn::Ident`].