From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001 From: Valentin Popov Date: Fri, 19 Jul 2024 16:37:58 +0400 Subject: Deleted vendor folder --- vendor/serde_derive/src/internals/case.rs | 200 ------------------------------ 1 file changed, 200 deletions(-) delete mode 100644 vendor/serde_derive/src/internals/case.rs (limited to 'vendor/serde_derive/src/internals/case.rs') diff --git a/vendor/serde_derive/src/internals/case.rs b/vendor/serde_derive/src/internals/case.rs deleted file mode 100644 index 8c8c02e..0000000 --- a/vendor/serde_derive/src/internals/case.rs +++ /dev/null @@ -1,200 +0,0 @@ -//! Code to convert the Rust-styled field/variant (e.g. `my_field`, `MyType`) to the -//! case of the source (e.g. `my-field`, `MY_FIELD`). - -use self::RenameRule::*; -use std::fmt::{self, Debug, Display}; - -/// The different possible ways to change case of fields in a struct, or variants in an enum. -#[derive(Copy, Clone, PartialEq)] -pub enum RenameRule { - /// Don't apply a default rename rule. - None, - /// Rename direct children to "lowercase" style. - LowerCase, - /// Rename direct children to "UPPERCASE" style. - UpperCase, - /// Rename direct children to "PascalCase" style, as typically used for - /// enum variants. - PascalCase, - /// Rename direct children to "camelCase" style. - CamelCase, - /// Rename direct children to "snake_case" style, as commonly used for - /// fields. - SnakeCase, - /// Rename direct children to "SCREAMING_SNAKE_CASE" style, as commonly - /// used for constants. - ScreamingSnakeCase, - /// Rename direct children to "kebab-case" style. - KebabCase, - /// Rename direct children to "SCREAMING-KEBAB-CASE" style. - ScreamingKebabCase, -} - -static RENAME_RULES: &[(&str, RenameRule)] = &[ - ("lowercase", LowerCase), - ("UPPERCASE", UpperCase), - ("PascalCase", PascalCase), - ("camelCase", CamelCase), - ("snake_case", SnakeCase), - ("SCREAMING_SNAKE_CASE", ScreamingSnakeCase), - ("kebab-case", KebabCase), - ("SCREAMING-KEBAB-CASE", ScreamingKebabCase), -]; - -impl RenameRule { - pub fn from_str(rename_all_str: &str) -> Result { - for (name, rule) in RENAME_RULES { - if rename_all_str == *name { - return Ok(*rule); - } - } - Err(ParseError { - unknown: rename_all_str, - }) - } - - /// Apply a renaming rule to an enum variant, returning the version expected in the source. - pub fn apply_to_variant(self, variant: &str) -> String { - match self { - None | PascalCase => variant.to_owned(), - LowerCase => variant.to_ascii_lowercase(), - UpperCase => variant.to_ascii_uppercase(), - CamelCase => variant[..1].to_ascii_lowercase() + &variant[1..], - SnakeCase => { - let mut snake = String::new(); - for (i, ch) in variant.char_indices() { - if i > 0 && ch.is_uppercase() { - snake.push('_'); - } - snake.push(ch.to_ascii_lowercase()); - } - snake - } - ScreamingSnakeCase => SnakeCase.apply_to_variant(variant).to_ascii_uppercase(), - KebabCase => SnakeCase.apply_to_variant(variant).replace('_', "-"), - ScreamingKebabCase => ScreamingSnakeCase - .apply_to_variant(variant) - .replace('_', "-"), - } - } - - /// Apply a renaming rule to a struct field, returning the version expected in the source. - pub fn apply_to_field(self, field: &str) -> String { - match self { - None | LowerCase | SnakeCase => field.to_owned(), - UpperCase => field.to_ascii_uppercase(), - PascalCase => { - let mut pascal = String::new(); - let mut capitalize = true; - for ch in field.chars() { - if ch == '_' { - capitalize = true; - } else if capitalize { - pascal.push(ch.to_ascii_uppercase()); - capitalize = false; - } else { - pascal.push(ch); - } - } - pascal - } - CamelCase => { - let pascal = PascalCase.apply_to_field(field); - pascal[..1].to_ascii_lowercase() + &pascal[1..] - } - ScreamingSnakeCase => field.to_ascii_uppercase(), - KebabCase => field.replace('_', "-"), - ScreamingKebabCase => ScreamingSnakeCase.apply_to_field(field).replace('_', "-"), - } - } - - /// Returns the `RenameRule` if it is not `None`, `rule_b` otherwise. - pub fn or(self, rule_b: Self) -> Self { - match self { - None => rule_b, - _ => self, - } - } -} - -pub struct ParseError<'a> { - unknown: &'a str, -} - -impl<'a> Display for ParseError<'a> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.write_str("unknown rename rule `rename_all = ")?; - Debug::fmt(self.unknown, f)?; - f.write_str("`, expected one of ")?; - for (i, (name, _rule)) in RENAME_RULES.iter().enumerate() { - if i > 0 { - f.write_str(", ")?; - } - Debug::fmt(name, f)?; - } - Ok(()) - } -} - -#[test] -fn rename_variants() { - for &(original, lower, upper, camel, snake, screaming, kebab, screaming_kebab) in &[ - ( - "Outcome", "outcome", "OUTCOME", "outcome", "outcome", "OUTCOME", "outcome", "OUTCOME", - ), - ( - "VeryTasty", - "verytasty", - "VERYTASTY", - "veryTasty", - "very_tasty", - "VERY_TASTY", - "very-tasty", - "VERY-TASTY", - ), - ("A", "a", "A", "a", "a", "A", "a", "A"), - ("Z42", "z42", "Z42", "z42", "z42", "Z42", "z42", "Z42"), - ] { - assert_eq!(None.apply_to_variant(original), original); - assert_eq!(LowerCase.apply_to_variant(original), lower); - assert_eq!(UpperCase.apply_to_variant(original), upper); - assert_eq!(PascalCase.apply_to_variant(original), original); - assert_eq!(CamelCase.apply_to_variant(original), camel); - assert_eq!(SnakeCase.apply_to_variant(original), snake); - assert_eq!(ScreamingSnakeCase.apply_to_variant(original), screaming); - assert_eq!(KebabCase.apply_to_variant(original), kebab); - assert_eq!( - ScreamingKebabCase.apply_to_variant(original), - screaming_kebab - ); - } -} - -#[test] -fn rename_fields() { - for &(original, upper, pascal, camel, screaming, kebab, screaming_kebab) in &[ - ( - "outcome", "OUTCOME", "Outcome", "outcome", "OUTCOME", "outcome", "OUTCOME", - ), - ( - "very_tasty", - "VERY_TASTY", - "VeryTasty", - "veryTasty", - "VERY_TASTY", - "very-tasty", - "VERY-TASTY", - ), - ("a", "A", "A", "a", "A", "a", "A"), - ("z42", "Z42", "Z42", "z42", "Z42", "z42", "Z42"), - ] { - assert_eq!(None.apply_to_field(original), original); - assert_eq!(UpperCase.apply_to_field(original), upper); - assert_eq!(PascalCase.apply_to_field(original), pascal); - assert_eq!(CamelCase.apply_to_field(original), camel); - assert_eq!(SnakeCase.apply_to_field(original), original); - assert_eq!(ScreamingSnakeCase.apply_to_field(original), screaming); - assert_eq!(KebabCase.apply_to_field(original), kebab); - assert_eq!(ScreamingKebabCase.apply_to_field(original), screaming_kebab); - } -} -- cgit v1.2.3