Enum Pattern 

pub enum Pattern {
    Lowercase,
    Uppercase,
    Capital,
    Camel,
    Sentence,
    RemoveEmpty,
    Custom(fn(&[&str]) -> Vec<String>),
}

Transformations on a list of words.

A pattern is a function that maps a list of words into another list after changing the casing of each letter. How a patterns mutates each letter can be dependent on the word the letters are present in.

Custom Pattern

A pattern is a function that maps from a borrowed list of words &[&str] to an owned list of owned words Vec<String> by applying a transformation. One example of custom behavior might be a pattern that detects a fixed list of two-letter acronyms, and capitalizes them appropriately on output.

use convert_case::{Converter, Pattern};

fn pascal_upper_acronyms(words: &[&str]) -> Vec<String> {
    Pattern::Capital.mutate(words).into_iter()
        .map(|word| match word.as_ref() {
            "Io" | "Xml" => word.to_uppercase(),
            _ => word,
        })
        .collect()
}

let acronym_converter = Converter::new()
    .set_patterns(&[Pattern::Custom(pascal_upper_acronyms)]);

assert_eq!(acronym_converter.convert("io_stream"), "IOStream");
assert_eq!(acronym_converter.convert("xml request"), "XMLRequest");

Another example might be a one that explicitly adds leading and trailing double underscores. We do this by modifying the words directly, which will get passed as-is to the join function.

use convert_case::{Converter, Pattern};

fn snake_dunder(mut words: &[&str]) -> Vec<String> {
    words
        .into_iter()
        .map(|word| word.to_lowercase())
        .enumerate()
        .map(|(i, word)| {
            if words.len() == 1 {
                format!("__{}__", word)
            } else if i == 0 {
                format!("__{}", word)
            } else if i == words.len() - 1 {
                format!("{}__", word)
            } else {
                word
            }
        })
        .collect()
}

let dunder_converter = Converter::new()
    .set_patterns(&[Pattern::Custom(snake_dunder)])
    .set_delimiter("_");

assert_eq!(dunder_converter.convert("getAttr"), "__get_attr__");
assert_eq!(dunder_converter.convert("ITER"), "__iter__");

Variants

Lowercase

Makes all words lowercase.

assert_eq!(
    Pattern::Lowercase.mutate(&["Case", "CONVERSION", "library"]),
    vec!["case", "conversion", "library"],
);

Uppercase

Makes all words uppercase.

assert_eq!(
    Pattern::Uppercase.mutate(&["Case", "CONVERSION", "library"]),
    vec!["CASE", "CONVERSION", "LIBRARY"],
);

Capital

Makes the first letter of each word uppercase and the remaining letters of each word lowercase.

assert_eq!(
    Pattern::Capital.mutate(&["Case", "CONVERSION", "library"]),
    vec!["Case", "Conversion", "Library"],
);

Camel

Makes the first non-empty word lowercase and the remaining capitalized.

assert_eq!(
    Pattern::Camel.mutate(&["Case", "CONVERSION", "library"]),
    vec!["case", "Conversion", "Library"],
);

Sentence

Makes the first non-empty word capitalized and the remaining lowercase.

assert_eq!(
    Pattern::Sentence.mutate(&["Case", "CONVERSION", "library"]),
    vec!["Case", "conversion", "library"],
);

RemoveEmpty

Filters out empty words from the list. Useful when splitting produces empty words from leading/trailing/duplicate delimiters.

assert_eq!(
    Pattern::RemoveEmpty.mutate(&["", "first", "", "second", ""]),
    vec!["first", "second"],
);

Custom(fn(&[&str]) -> Vec<String>)

Define custom behavior to transform a set of words.

See the Pattern documentation for examples.

Implementations

impl Pattern

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

where S: AsRef<str>,

Applies the pattern transformation to a list of words.

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Pattern

impl Debug for Pattern

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

Formats the value using the given formatter.

impl Eq for Pattern

impl Hash for Pattern

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

where H: Hasher,

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 Pattern

fn eq(&self, other: &Pattern) -> 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.