From 055d7e27e987c33332d258ab8dac80e2fc51376c Mon Sep 17 00:00:00 2001 From: Piepmatz Date: Wed, 28 Aug 2024 15:02:25 +0200 Subject: [PATCH] Use `heck` instead of `convert_case` for `nu-derive-value` (#13708) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # Description @sholderbach mentioned that I introduced `convert_case` as a dependency while we already had `heck` for case conversion. So in this PR replaced the use `convert_case` with `heck`. Mostly I rebuilt the `convert_case` API with `heck` to work with it as I like the API of `convert_case` more than `heck`. # User-Facing Changes Nothing changed, the use of `convert_case` wasn't exposed anywhere and all case conversions are still available. # Tests + Formatting No new tests required but my tests in `test_derive` captured some errors I made while developing this change, (hurray, tests work 🎉) - :green_circle: `toolkit fmt` - :green_circle: `toolkit clippy` - :green_circle: `toolkit test` - :green_circle: `toolkit test stdlib` # After Submitting --- Cargo.lock | 13 +--- Cargo.toml | 1 - crates/nu-derive-value/Cargo.toml | 2 +- crates/nu-derive-value/src/attributes.rs | 35 +++-------- crates/nu-derive-value/src/case.rs | 72 ++++++++++++++++++++++ crates/nu-derive-value/src/from.rs | 8 ++- crates/nu-derive-value/src/into.rs | 6 +- crates/nu-derive-value/src/lib.rs | 1 + crates/nu-protocol/Cargo.toml | 2 +- crates/nu-protocol/src/value/from_value.rs | 4 +- crates/nu-protocol/src/value/into_value.rs | 6 +- 11 files changed, 100 insertions(+), 50 deletions(-) create mode 100644 crates/nu-derive-value/src/case.rs diff --git a/Cargo.lock b/Cargo.lock index 017a32cd11..0aa064bbdc 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -933,15 +933,6 @@ dependencies = [ "unicode-xid", ] -[[package]] -name = "convert_case" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca" -dependencies = [ - "unicode-segmentation", -] - [[package]] name = "core-foundation" version = "0.9.4" @@ -3213,7 +3204,7 @@ dependencies = [ name = "nu-derive-value" version = "0.97.2" dependencies = [ - "convert_case", + "heck", "proc-macro-error", "proc-macro2", "quote", @@ -3417,10 +3408,10 @@ dependencies = [ "bytes", "chrono", "chrono-humanize", - "convert_case", "dirs", "dirs-sys", "fancy-regex", + "heck", "indexmap", "log", "lru", diff --git a/Cargo.toml b/Cargo.toml index 9dd07f6902..2a1b9a0439 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -76,7 +76,6 @@ chardetng = "0.1.17" chrono = { default-features = false, version = "0.4.34" } chrono-humanize = "0.2.3" chrono-tz = "0.8" -convert_case = "0.6" crossbeam-channel = "0.5.8" crossterm = "0.27" csv = "1.3" diff --git a/crates/nu-derive-value/Cargo.toml b/crates/nu-derive-value/Cargo.toml index d7d1ff6e4c..bf28ec878f 100644 --- a/crates/nu-derive-value/Cargo.toml +++ b/crates/nu-derive-value/Cargo.toml @@ -18,4 +18,4 @@ proc-macro2 = { workspace = true } syn = { workspace = true } quote = { workspace = true } proc-macro-error = { workspace = true } -convert_case = { workspace = true } \ No newline at end of file +heck = { workspace = true } \ No newline at end of file diff --git a/crates/nu-derive-value/src/attributes.rs b/crates/nu-derive-value/src/attributes.rs index 2ecfb97dd0..ef353685ab 100644 --- a/crates/nu-derive-value/src/attributes.rs +++ b/crates/nu-derive-value/src/attributes.rs @@ -1,7 +1,6 @@ -use convert_case::Case; use syn::{spanned::Spanned, Attribute, Fields, LitStr}; -use crate::{error::DeriveError, HELPER_ATTRIBUTE}; +use crate::{case::Case, error::DeriveError, HELPER_ATTRIBUTE}; #[derive(Debug, Default)] pub struct ContainerAttributes { @@ -22,35 +21,19 @@ impl ContainerAttributes { let ident = meta.path.require_ident()?; match ident.to_string().as_str() { "rename_all" => { - // The matched case are all useful variants from `convert_case` with aliases - // that `serde` uses. let case: LitStr = meta.value()?.parse()?; - let case = match case.value().as_str() { - "UPPER CASE" | "UPPER WITH SPACES CASE" => Case::Upper, - "lower case" | "lower with spaces case" => Case::Lower, - "Title Case" => Case::Title, - "camelCase" => Case::Camel, - "PascalCase" | "UpperCamelCase" => Case::Pascal, - "snake_case" => Case::Snake, - "UPPER_SNAKE_CASE" | "SCREAMING_SNAKE_CASE" => Case::UpperSnake, - "kebab-case" => Case::Kebab, - "COBOL-CASE" | "UPPER-KEBAB-CASE" | "SCREAMING-KEBAB-CASE" => { - Case::Cobol - } - "Train-Case" => Case::Train, - "flatcase" | "lowercase" => Case::Flat, - "UPPERFLATCASE" | "UPPERCASE" => Case::UpperFlat, - // Although very funny, we don't support `Case::{Toggle, Alternating}`, - // as we see no real benefit. - c => { + let value_span = case.span(); + let case = case.value(); + match Case::from_str(&case) { + Some(case) => container_attrs.rename_all = Some(case), + None => { err = Err(DeriveError::InvalidAttributeValue { - value_span: case.span(), - value: Box::new(c.to_string()), + value_span, + value: Box::new(case), }); return Ok(()); // We stored the err in `err`. } - }; - container_attrs.rename_all = Some(case); + } } "type_name" => { let type_name: LitStr = meta.value()?.parse()?; diff --git a/crates/nu-derive-value/src/case.rs b/crates/nu-derive-value/src/case.rs new file mode 100644 index 0000000000..02ca5ba255 --- /dev/null +++ b/crates/nu-derive-value/src/case.rs @@ -0,0 +1,72 @@ +use heck::*; + +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum Case { + // directly supported by heck + Pascal, + Camel, + Snake, + Kebab, + ScreamingSnake, + Title, + Cobol, + Train, + + // custom variants + Upper, + Lower, + Flat, + ScreamingFlat, +} + +impl Case { + pub fn from_str(s: impl AsRef) -> Option { + match s.as_ref() { + // The matched case are all useful variants from `convert_case` with aliases + // that `serde` uses. + "PascalCase" | "UpperCamelCase" => Case::Pascal, + "camelCase" | "lowerCamelCase" => Case::Camel, + "snake_case" => Case::Snake, + "kebab-case" => Case::Kebab, + "SCREAMING_SNAKE_CASE" | "UPPER_SNAKE_CASE" | "SHOUTY_SNAKE_CASE" => { + Case::ScreamingSnake + } + "Title Case" => Case::Title, + "COBOL-CASE" | "SCREAMING-KEBAB-CASE" | "UPPER-KEBAB-CASE" => Case::Cobol, + "Train-Case" => Case::Train, + + "UPPER CASE" | "UPPER WITH SPACES CASE" => Case::Upper, + "lower case" | "lower with spaces case" => Case::Lower, + "flatcase" | "lowercase" => Case::Flat, + "SCREAMINGFLATCASE" | "UPPERFLATCASE" | "UPPERCASE" => Case::ScreamingFlat, + + _ => return None, + } + .into() + } +} + +pub trait Casing { + fn to_case(&self, case: Case) -> String; +} + +impl> Casing for T { + fn to_case(&self, case: Case) -> String { + let s = self.as_ref(); + match case { + Case::Pascal => s.to_upper_camel_case(), + Case::Camel => s.to_lower_camel_case(), + Case::Snake => s.to_snake_case(), + Case::Kebab => s.to_kebab_case(), + Case::ScreamingSnake => s.to_shouty_snake_case(), + Case::Title => s.to_title_case(), + Case::Cobol => s.to_shouty_kebab_case(), + Case::Train => s.to_train_case(), + + Case::Upper => s.to_shouty_snake_case().replace('_', " "), + Case::Lower => s.to_snake_case().replace('_', " "), + Case::Flat => s.to_snake_case().replace('_', ""), + Case::ScreamingFlat => s.to_shouty_snake_case().replace('_', ""), + } + } +} diff --git a/crates/nu-derive-value/src/from.rs b/crates/nu-derive-value/src/from.rs index e5a83375f4..820fa46bc6 100644 --- a/crates/nu-derive-value/src/from.rs +++ b/crates/nu-derive-value/src/from.rs @@ -1,4 +1,3 @@ -use convert_case::{Case, Casing}; use proc_macro2::TokenStream as TokenStream2; use quote::{quote, ToTokens}; use syn::{ @@ -6,7 +5,10 @@ use syn::{ Type, }; -use crate::attributes::{self, ContainerAttributes}; +use crate::{ + attributes::{self, ContainerAttributes}, + case::{Case, Casing}, +}; #[derive(Debug)] pub struct FromValue; @@ -393,7 +395,7 @@ fn derive_enum_from_value( /// all possible variants. /// The input value is expected to be a `Value::String` containing the name of the variant formatted /// as defined by the `#[nu_value(rename_all = "...")]` attribute. -/// If no attribute is given, [`convert_case::Case::Snake`] is expected. +/// If no attribute is given, [`snake_case`](heck::ToSnakeCase) is expected. /// /// If no matching variant is found, `ShellError::CantConvert` is returned. /// diff --git a/crates/nu-derive-value/src/into.rs b/crates/nu-derive-value/src/into.rs index 5c8553ef60..3dfb92d28e 100644 --- a/crates/nu-derive-value/src/into.rs +++ b/crates/nu-derive-value/src/into.rs @@ -1,4 +1,3 @@ -use convert_case::{Case, Casing}; use proc_macro2::TokenStream as TokenStream2; use quote::{quote, ToTokens}; use syn::{ @@ -6,7 +5,10 @@ use syn::{ Index, }; -use crate::attributes::{self, ContainerAttributes}; +use crate::{ + attributes::{self, ContainerAttributes}, + case::{Case, Casing}, +}; #[derive(Debug)] pub struct IntoValue; diff --git a/crates/nu-derive-value/src/lib.rs b/crates/nu-derive-value/src/lib.rs index 269566fc88..4fa038f2fd 100644 --- a/crates/nu-derive-value/src/lib.rs +++ b/crates/nu-derive-value/src/lib.rs @@ -32,6 +32,7 @@ use proc_macro2::TokenStream as TokenStream2; use proc_macro_error::{proc_macro_error, Diagnostic}; mod attributes; +mod case; mod error; mod from; mod into; diff --git a/crates/nu-protocol/Cargo.toml b/crates/nu-protocol/Cargo.toml index 5a3829bbfe..ead8ee8089 100644 --- a/crates/nu-protocol/Cargo.toml +++ b/crates/nu-protocol/Cargo.toml @@ -23,9 +23,9 @@ bytes = { workspace = true } byte-unit = { version = "5.1", features = [ "serde" ] } chrono = { workspace = true, features = [ "serde", "std", "unstable-locales" ], default-features = false } chrono-humanize = { workspace = true } -convert_case = { workspace = true } dirs = { workspace = true } fancy-regex = { workspace = true } +heck = { workspace = true } indexmap = { workspace = true } lru = { workspace = true } miette = { workspace = true, features = ["fancy-no-backtrace"] } diff --git a/crates/nu-protocol/src/value/from_value.rs b/crates/nu-protocol/src/value/from_value.rs index 430ff63da4..1b8e9536d7 100644 --- a/crates/nu-protocol/src/value/from_value.rs +++ b/crates/nu-protocol/src/value/from_value.rs @@ -22,7 +22,7 @@ use std::{ /// the struct maps to a corresponding field in the record. /// You can customize the case conversion of these field names by using /// `#[nu_value(rename_all = "...")]` on the struct. -/// Supported case conversions include those provided by [`convert_case::Case`], such as +/// Supported case conversions include those provided by [`heck`], such as /// "snake_case", "kebab-case", "PascalCase", and others. /// Additionally, all values accepted by /// [`#[serde(rename_all = "...")]`](https://serde.rs/container-attrs.html#rename_all) are valid here. @@ -35,7 +35,7 @@ use std::{ /// /// Only enums with no fields may derive this trait. /// The expected value representation will be the name of the variant as a [`Value::String`]. -/// By default, variant names will be expected in ["snake_case"](convert_case::Case::Snake). +/// By default, variant names will be expected in ["snake_case"](heck::ToSnakeCase). /// You can customize the case conversion using `#[nu_value(rename_all = "kebab-case")]` on the enum. /// /// Additionally, you can use `#[nu_value(type_name = "...")]` in the derive macro to set a custom type name diff --git a/crates/nu-protocol/src/value/into_value.rs b/crates/nu-protocol/src/value/into_value.rs index 934525e033..d95de9d96a 100644 --- a/crates/nu-protocol/src/value/into_value.rs +++ b/crates/nu-protocol/src/value/into_value.rs @@ -12,8 +12,8 @@ use crate::{Record, ShellError, Span, Value}; /// [`Value::Record`], where each field of the record corresponds to a field of the struct. /// By default, field names will be kept as-is, but you can customize the case conversion /// for all fields in a struct by using `#[nu_value(rename_all = "kebab-case")]` on the struct. -/// All useful case options from [`convert_case::Case`] are supported, as well as the -/// values allowed by [`#[serde(rename_all)]`](https://serde.rs/container-attrs.html#rename_all). +/// All case options from [`heck`] are supported, as well as the values allowed by +/// [`#[serde(rename_all)]`](https://serde.rs/container-attrs.html#rename_all). /// /// For structs with unnamed fields, the value representation will be [`Value::List`], with all /// fields inserted into a list. @@ -21,7 +21,7 @@ use crate::{Record, ShellError, Span, Value}; /// /// Only enums with no fields may derive this trait. /// The resulting value representation will be the name of the variant as a [`Value::String`]. -/// By default, variant names will be converted to ["snake_case"](convert_case::Case::Snake). +/// By default, variant names will be converted to ["snake_case"](heck::ToSnakeCase). /// You can customize the case conversion using `#[nu_value(rename_all = "kebab-case")]` on the enum. /// /// ```