Enum Case 

#[non_exhaustive]
pub enum Case<'b> {
    Custom {
        boundaries: &'b [Boundary],
        pattern: Pattern,
        delimiter: &'static str,
    },
    Snake,
    Constant,
    UpperSnake,
    Ada,
    Kebab,
    Cobol,
    UpperKebab,
    Train,
    Flat,
    UpperFlat,
    Pascal,
    UpperCamel,
    Camel,
    Lower,
    Upper,
    Title,
    Sentence,
}

Defines the case of an identifier.

use convert_case::ccase;
assert_eq!(ccase!(title, "super_mario_64"), "Super Mario 64");

use convert_case::{Case, Casing};
assert_eq!("super_mario_64".to_case(Case::Title), "Super Mario 64");

A case is the pair of a pattern and a delimiter (a string). Given a list of words, a pattern describes how to mutate the words and a delimiter is how the mutated words are joined together.

pattern	underscore _	hyphen -	empty string	space
lowercase	snake_case	kebab-case	flatcase	lower case
uppercase	CONSTANT_CASE	COBOL-CASE	UPPERFLATCASE	UPPER CASE
capital	Ada_Case	Train-Case	PascalCase	Title Case
camel			camelCase

There are additionally Case::Sentence.

This crate provides the ability to convert “from” a case. This introduces a different feature of cases which are the word boundaries that segment the identifier into words. For example, a snake case identifier my_var_name can be split on underscores _ to segment into words. A camel case identifier myVarName is split where a lowercase letter is followed by an uppercase letter. Each case is also associated with a list of boundaries that are used when converting “from” a particular case.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Custom

Custom cases can be delimited by any static string slice and mutate words using any pattern. Further, they can use any list of boundaries for splitting identifiers into words.

This flexibility can create cases not present as another variant of the Case enum. For instance, you could create a “dot case” like so.

use convert_case::{Case, Casing, separator, Pattern};
let dot_case = Case::Custom {
    boundaries: &[separator!(".")],
    pattern: Pattern::Lowercase,
    delimiter: ".",
};

assert_eq!(
    "myNewCase".to_case(dot_case),
    "my.new.case",
);
assert_eq!(
    "my.new.case".from_case(dot_case).to_case(Case::Title),
    "My New Case",
);

Fields

boundaries: &'b [Boundary]

pattern: Pattern

delimiter: &'static str

Snake

Snake case strings are delimited by underscores _ and are all lowercase.

• Boundaries : Underscore
• Pattern : Lowercase
• Delimiter : Underscore "_"

use convert_case::ccase;
assert_eq!(ccase!(snake, "My variable NAME"), "my_variable_name");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Snake), "my_variable_name");

Constant

Constant case strings are delimited by underscores _ and are all uppercase.

• Boundaries: Underscore
• Pattern: Uppercase
• Delimiter: Underscore "_"

use convert_case::ccase;
assert_eq!(ccase!(constant, "My variable NAME"), "MY_VARIABLE_NAME");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Constant), "MY_VARIABLE_NAME");

UpperSnake

Upper snake case is an alternative name for constant case.

Ada

Ada case strings are delimited by underscores _. The leading letter of each word is uppercase, while the rest is lowercase.

• Boundaries: Underscore
• Pattern: Capital
• Delimiter: Underscore "_"

use convert_case::ccase;
assert_eq!(ccase!(ada, "My variable NAME"), "My_Variable_Name");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Ada), "My_Variable_Name");

Kebab

Kebab case strings are delimited by hyphens - and are all lowercase.

• Boundaries: Hyphen
• Pattern: Lowercase
• Delimiter: Hyphen "-"

use convert_case::ccase;
assert_eq!(ccase!(kebab, "My variable NAME"), "my-variable-name");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Kebab), "my-variable-name");

Cobol

Cobol case strings are delimited by hyphens - and are all uppercase.

• Boundaries: Hyphen
• Pattern: Uppercase
• Delimiter: Hyphen "-"

use convert_case::ccase;
assert_eq!(ccase!(cobol, "My variable NAME"), "MY-VARIABLE-NAME");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Cobol), "MY-VARIABLE-NAME");

UpperKebab

Upper kebab case is an alternative name for Cobol case.

Train

Train case strings are delimited by hyphens -. The leading letter of each word is uppercase, while the rest is lowercase.

• Boundaries: Hyphen
• Pattern: Capital
• Delimiter: Hyphen "-"

use convert_case::ccase;
assert_eq!(ccase!(train, "My variable NAME"), "My-Variable-Name");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Train), "My-Variable-Name");

Flat

Flat case strings are all lowercase, with no delimiter. Note that word boundaries are lost.

• Boundaries: No boundaries
• Pattern: Lowercase
• Delimiter: Empty string ""

use convert_case::ccase;
assert_eq!(ccase!(flat, "My variable NAME"), "myvariablename");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Flat), "myvariablename");

UpperFlat

Upper flat case strings are all uppercase, with no delimiter. Note that word boundaries are lost.

• Boundaries: No boundaries
• Pattern: Uppercase
• Delimiter: Empty string ""

use convert_case::ccase;
assert_eq!(ccase!(upper_flat, "My variable NAME"), "MYVARIABLENAME");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::UpperFlat), "MYVARIABLENAME");

Pascal

Pascal case strings are lowercase, but for every word the first letter is capitalized.

• Boundaries: LowerUpper, DigitUpper, UpperDigit, DigitLower, LowerDigit, Acronym
• Pattern: Capital
• Delimiter: Empty string ""

use convert_case::ccase;
assert_eq!(ccase!(pascal, "My variable NAME"), "MyVariableName");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Pascal), "MyVariableName");

UpperCamel

Upper camel case is an alternative name for Pascal case.

Camel

Camel case strings are lowercase, but for every word except the first the first letter is capitalized.

• Boundaries: LowerUpper, DigitUpper, UpperDigit, DigitLower, LowerDigit, Acronym
• Pattern: Camel
• Delimiter: Empty string ""

use convert_case::ccase;
assert_eq!(ccase!(camel, "My variable NAME"), "myVariableName");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Camel), "myVariableName");

Lower

Lowercase strings are delimited by spaces and all characters are lowercase.

• Boundaries: Space
• Pattern: Lowercase
• Delimiter: Space " "

use convert_case::ccase;
assert_eq!(ccase!(lower, "My variable NAME"), "my variable name");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Lower), "my variable name");

Upper

Uppercase strings are delimited by spaces and all characters are uppercase.

• Boundaries: Space
• Pattern: Uppercase
• Delimiter: Space " "

use convert_case::ccase;
assert_eq!(ccase!(upper, "My variable NAME"), "MY VARIABLE NAME");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Upper), "MY VARIABLE NAME");

Title

Title case strings are delimited by spaces. Only the leading character of each word is uppercase. No inferences are made about language, so words like “as”, “to”, and “for” will still be capitalized.

• Boundaries: Space
• Pattern: Capital
• Delimiter: Space " "

use convert_case::ccase;
assert_eq!(ccase!(title, "My variable NAME"), "My Variable Name");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Title), "My Variable Name");

Sentence

Sentence case strings are delimited by spaces. Only the leading character of the first word is uppercase.

• Boundaries: Space
• Pattern: Sentence
• Delimiter: Space " "

use convert_case::ccase;
assert_eq!(ccase!(sentence, "My variable NAME"), "My variable name");

use convert_case::{Case, Casing};
assert_eq!("My variable NAME".to_case(Case::Sentence), "My variable name");

Implementations

impl Case<'_>

pub fn boundaries(&self) -> &[Boundary]

Returns the boundaries used in the corresponding case. That is, where can word boundaries be distinguished in a string of the given case. The table outlines which cases use which set of boundaries.

Cases	Boundaries
Snake, Constant, UpperSnake, Ada	Underscore
Kebab, Cobol, UpperKebab, Train	Hyphen
Lower, Upper, Title	Space
Pascal, UpperCamel, Camel	LowerUpper, LowerDigit, UpperDigit, DigitLower, DigitUpper, Acronym
Flat, UpperFlat	No boundaries

pub const fn delimiter(&self) -> &'static str

Returns the delimiter used in the corresponding case. The following table outlines which cases use which delimiter.

Cases	Delimiter
Snake, Constant, UpperSnake, Ada	Underscore "_"
Kebab, Cobol, UpperKebab, Train	Hyphen "-"
Upper, Lower, Title, Sentence	Space " "
Flat, UpperFlat, Pascal, UpperCamel, Camel	Empty string ""

pub const fn pattern(&self) -> Pattern

Returns the pattern used in the corresponding case. The following table outlines which cases use which pattern.

Cases	Pattern
Constant, UpperSnake, Cobol, UpperKebab, UpperFlat, Upper	Uppercase
Snake, Kebab, Flat, Lower	Lowercase
Ada, Train, Pascal, UpperCamel, Title	Capital
Camel	Camel

pub fn split<T>(self, s: &T) -> Vec<&str>

where T: AsRef<str>,

Split an identifier into words based on the boundaries of this case.

use convert_case::Case;
assert_eq!(
    Case::Pascal.split(&"getTotalLength"),
    vec!["get", "Total", "Length"],
);

pub fn mutate(self, words: &[&str]) -> Vec<String>

Mutate a list of words based on the pattern of this case.

use convert_case::Case;
assert_eq!(
    Case::Snake.mutate(&["get", "Total", "Length"]),
    vec!["get", "total", "length"],
);

pub fn join(self, words: &[String]) -> String

Join a list of words into a single identifier using the delimiter of this case.

use convert_case::Case;
assert_eq!(
    Case::Snake.join(&[
        String::from("get"),
        String::from("total"),
        String::from("length")
    ]),
    String::from("get_total_length"),
);

pub fn all_cases() -> &'static [Case<'static>]

Array of all non-custom case enum variants. Does not include aliases.

Trait Implementations

impl<'b> Clone for Case<'b>

fn clone(&self) -> Case<'b>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'b> Debug for Case<'b>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'b> Hash for Case<'b>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'b> PartialEq for Case<'b>

fn eq(&self, other: &Case<'b>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'b> Copy for Case<'b>

impl<'b> Eq for Case<'b>

impl<'b> StructuralPartialEq for Case<'b>