Enum Case

pub enum Case {
    Upper,
    Lower,
    Title,
    Toggle,
    Camel,
    Pascal,
    UpperCamel,
    Snake,
    UpperSnake,
    ScreamingSnake,
    Kebab,
    Cobol,
    UpperKebab,
    Train,
    Flat,
    UpperFlat,
    Alternating,
    Random,
    PseudoRandom,
}

Defines the type of casing a string can be.

use convert_case::{Case, Casing};

let super_mario_title: String = "super_mario_64".to_case(Case::Title);
assert_eq!("Super Mario 64", super_mario_title);

A case is the pair of a pattern and a delimeter (a string). Given a list of words, a pattern describes how to mutate the words and a delimeter is how the mutated words are joined together. These inherantly are the properties of what makes a “multiword identifier case”, or simply “case”.

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

Upper

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

• Boundaries: Space
• Pattern: Uppercase
• Delimeter: Space

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

Lower

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

• Boundaries: Space
• Pattern: Lowercase
• Delimeter: Space

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

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
• Delimeter: Space

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

Toggle

Toggle case strings are delimited by spaces. All characters are uppercase except for the leading character of each word, which is lowercase.

• Boundaries: Space
• Pattern: Toggle
• Delimeter: Space

use convert_case::{Case, Casing};
assert_eq!("mY vARIABLE nAME", "My variable NAME".to_case(Case::Toggle))

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
• Delimeter: No delimeter

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

Pascal

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

• Boundaries: LowerUpper, DigitUpper, UpperDigit, DigitLower, LowerDigit, Acronym
• Pattern: Capital
• Delimeter: No delimeter

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

UpperCamel

Upper camel case is an alternative name for Pascal case.

Snake

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

• Boundaries: Underscore
• Pattern: Lowercase
• Delimeter: Underscore _

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

UpperSnake

Upper snake case strings are delimited by underscores _ and are all uppercase.

• Boundaries: Underscore
• Pattern: Uppercase
• Delimeter: Underscore _

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

ScreamingSnake

Screaming snake case is an alternative name for upper snake case.

Kebab

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

• Boundaries: Hyphen
• Pattern: Lowercase
• Delimeter: Hyphen -

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

Cobol

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

• Boundaries: Hyphen
• Pattern: Uppercase
• Delimeter: Hyphen -

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

UpperKebab

Upper kebab case is an alternative name for Cobol case.

Train

Train case strings are delimited by hyphens -. All characters are lowercase except for the leading character of each word.

• Boundaries: Hyphen
• Pattern: Capital
• Delimeter: Hyphen -

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

Flat

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

• Boundaries: No boundaries
• Pattern: Lowercase
• Delimeter: No delimeter

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

UpperFlat

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

• Boundaries: No boundaries
• Pattern: Uppercase
• Delimeter: No delimeter

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

Alternating

Alternating case strings are delimited by spaces. Characters alternate between uppercase and lowercase.

• Boundaries: Space
• Pattern: Alternating
• Delimeter: Space

use convert_case::{Case, Casing};
assert_eq!("mY vArIaBlE nAmE", "My variable NAME".to_case(Case::Alternating));

Random

Random case strings are delimited by spaces and characters are randomly upper case or lower case. This uses the rand crate and is only available with the “random” feature.

• Boundaries: Space
• Pattern: Random
• Delimeter: Space

use convert_case::{Case, Casing};
let new = "My variable NAME".to_case(Case::Random);

String new could be “My vaRIAbLE nAme” for example.

PseudoRandom

Pseudo-random case strings are delimited by spaces and characters are randomly upper case or lower case, but there will never more than two consecutive lower case or upper case letters in a row. This uses the rand crate and is only available with the “random” feature.

• Boundaries: Space
• Pattern: PseudoRandom
• Delimeter: Space

use convert_case::{Case, Casing};
let new = "My variable NAME".to_case(Case::Random);

String new could be “mY vArIAblE NamE” for example.

Implementations

impl Case

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

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

Cases	Delimeter
Upper, Lower, Title, Toggle, Alternating, Random, PseudoRandom	Space
Snake, UpperSnake, ScreamingSnake	Underscore _
Kebab, Cobol, UpperKebab, Train	Hyphen -
UpperFlat, Flat, Camel, UpperCamel, Pascal	Empty string, no delimeter

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
Upper, UpperSnake, ScreamingSnake, UpperFlat, Cobol, UpperKebab	Uppercase
Lower, Snake, Kebab, Flat	Lowercase
Title, Pascal, UpperCamel, Train	Capital
Camel	Camel
Alternating	Alternating
Random	Random
PseudoRandom	PseudoRandom

pub fn boundaries(&self) -> Vec<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
Upper, Lower, Title, Toggle, Alternating, Random, PseudoRandom	Space
Snake, UpperSnake, ScreamingSnake	Underscore _
Kebab, Cobol, UpperKebab, Train	Hyphen -
Camel, UpperCamel, Pascal	LowerUpper, LowerDigit, UpperDigit, DigitLower, DigitUpper, Acronym
UpperFlat, Flat	No boundaries

pub fn all_cases() -> Vec<Case>

Returns a vector with all case enum variants in no particular order.

pub fn deterministic_cases() -> Vec<Case>

Returns a vector with all the cases that do not depend on randomness. This is all the cases not in the “random” feature.

Trait Implementations

impl Clone for Case

fn clone(&self) -> Case

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Case

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

Formats the value using the given formatter.

impl Hash for Case

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 PartialEq for Case

fn eq(&self, other: &Case) -> 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 Copy for Case

impl Eq for Case

impl StructuralPartialEq for Case