Struct ReCase 

pub struct ReCase<'a> { /* private fields */ }

An instance that holds the text to be re-cased.

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.snake_case(), "example_string");          
assert_eq!(recase.upper_snake_case(), "EXAMPLE_STRING");

Implementations

impl<'a> ReCase<'a>

pub fn new(original_text: &'a str) -> Self

Examples found in repository

examples/main.rs (line 9)

fn main() {
    const INPUT: &str = "Löng and meaningless-Ẽxample_Text";

    // Using the Casing Trait
    println!("{}", INPUT.to_kebab_case()); // Prints "löng-and-meaningless-ẽxample-text"

    let recase = ReCase::new(INPUT);

    println!("{}", recase.snake_case()); // Prints "löng_and_meaningless_ẽxample_text"
    println!("{}", recase.camel_case()); // Prints "löngAndMeaninglessẼxampleText"
}

pub fn normal_case(&self) -> String

Returns a normal case version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.normal_case(), "example string");

pub fn camel_case(&self) -> String

Returns a camelCase version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.camel_case(), "exampleString");

Examples found in repository

examples/main.rs (line 12)

fn main() {
    const INPUT: &str = "Löng and meaningless-Ẽxample_Text";

    // Using the Casing Trait
    println!("{}", INPUT.to_kebab_case()); // Prints "löng-and-meaningless-ẽxample-text"

    let recase = ReCase::new(INPUT);

    println!("{}", recase.snake_case()); // Prints "löng_and_meaningless_ẽxample_text"
    println!("{}", recase.camel_case()); // Prints "löngAndMeaninglessẼxampleText"
}

pub fn pascal_case(&self) -> String

Returns a PascalCase version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.pascal_case(), "ExampleString");

pub fn snake_case(&self) -> String

Returns a snake_case version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.snake_case(), "example_string");

Examples found in repository

examples/main.rs (line 11)

fn main() {
    const INPUT: &str = "Löng and meaningless-Ẽxample_Text";

    // Using the Casing Trait
    println!("{}", INPUT.to_kebab_case()); // Prints "löng-and-meaningless-ẽxample-text"

    let recase = ReCase::new(INPUT);

    println!("{}", recase.snake_case()); // Prints "löng_and_meaningless_ẽxample_text"
    println!("{}", recase.camel_case()); // Prints "löngAndMeaninglessẼxampleText"
}

pub fn kebab_case(&self) -> String

Returns a kebab-case version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.kebab_case(), "example-string");

pub fn dot_case(&self) -> String

Returns a dot.case version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.dot_case(), "example.string");

pub fn path_case(&self) -> String

Returns a path/case version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.path_case(), "example/string");

pub fn windows_path_case(&self) -> String

Returns a windows\path\case version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.windows_path_case(), "example\\string");

pub fn sentence_case(&self) -> String

Returns a Sentence case version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.sentence_case(), "Example string");

pub fn title_case(&self) -> String

Returns a Title Case version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.title_case(), "Example String");

pub fn header_case(&self) -> String

Returns a Header-Case version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.header_case(), "Example-String");

pub fn upper_snake_case(&self) -> String

Returns a UPPER_SNAKE_CASE version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.upper_snake_case(), "EXAMPLE_STRING");

pub fn alternating_case(&self) -> String

Returns a AlTeRnAtInG cAsE version of the input text as a new String

Example

let recase = recase::ReCase::new("Example String");
assert_eq!(recase.alternating_case(), "eXaMpLe StRiNg");

Trait Implementations

impl<'a> Debug for ReCase<'a>

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

Formats the value using the given formatter.