Enum Case

Variants

Custom { boundaries: &'b [Boundary], pattern: Pattern, delim: &'static str }

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, delim_boundary, Pattern};
let dot_case = Case::Custom {
    boundaries: &[delim_boundary!(".")],
    pattern: Pattern::Lowercase,
    delim: ".",
};

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",
);

Snake

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

• Boundaries : Underscore
• Pattern : Lowercase
• Delimeter : 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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
• Delimeter: 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");