Struct Converter 

pub struct Converter {
    pub boundaries: Vec<Boundary>,
    pub patterns: Vec<Pattern>,
    pub delimiter: String,
}

The parameters for performing a case conversion.

A Converter stores three fields needed for case conversion.

1. boundaries: how a string is split into words.
2. patterns: how words are mutated, or how each character’s case will change.
3. delimiter: how the mutated words are joined into the final string.

Then calling convert on a Converter will apply a case conversion defined by those fields. The Converter struct is what is used underneath those functions available in the Casing struct.

You can use Converter when you need more specificity on conversion than those provided in Casing, or if it is simply more convenient or explicit.

use convert_case::{Boundary, Case, Casing, Converter, Pattern};

let s = "DialogueBox-border-shadow";

// Convert using Casing trait
assert_eq!(
    s.from_case(Case::Kebab).to_case(Case::Snake),
    "dialoguebox_border_shadow",
);

// Convert using similar methods on Converter
let conv = Converter::new()
    .from_case(Case::Kebab)
    .to_case(Case::Snake);
assert_eq!(conv.convert(s), "dialoguebox_border_shadow");

// Convert by setting each field explicitly
let conv = Converter::new()
    .set_boundaries(&[Boundary::Hyphen])
    .set_patterns(&[Pattern::Lowercase])
    .set_delimiter("_");
assert_eq!(conv.convert(s), "dialoguebox_border_shadow");

Or you can use Converter when you are performing a transformation not provided as a variant of Case.

let dot_camel = Converter::new()
    .set_boundaries(&[Boundary::LowerUpper, Boundary::LowerDigit])
    .set_patterns(&[Pattern::Camel])
    .set_delimiter(".");
assert_eq!(dot_camel.convert("CollisionShape2D"), "collision.Shape.2d");

Fields

boundaries: Vec<Boundary>

How a string is split into words.

patterns: Vec<Pattern>

How each word is mutated before joining.

delimiter: String

The string used to join mutated words together.

Implementations

impl Converter

pub fn new() -> Converter

Creates a new Converter with default fields. This is the same as Default::default(). The Converter will use Boundary::defaults() for boundaries, no patterns, and an empty string as a delimiter.

let conv = Converter::new();
assert_eq!(conv.convert("Ice-cream TRUCK"), "IcecreamTRUCK")

pub fn convert<T>(&self, s: T) -> String

where T: AsRef<str>,

Converts a string.

let conv = Converter::new()
    .to_case(Case::Camel);
assert_eq!(conv.convert("XML_HTTP_Request"), "xmlHttpRequest")

pub fn to_case(self, case: Case<'_>) -> Converter

Set the pattern and delimiter to those associated with the given case.

let conv = Converter::new()
    .to_case(Case::Pascal);
assert_eq!(conv.convert("variable name"), "VariableName")

pub fn from_case(self, case: Case<'_>) -> Converter

Sets the boundaries to those associated with the provided case. This is used by the from_case function in the Casing trait.

let conv = Converter::new()
    .from_case(Case::Snake)
    .to_case(Case::Title);
assert_eq!(conv.convert("dot_productValue"), "Dot Productvalue")

pub fn set_boundaries(self, bs: &[Boundary]) -> Converter

Sets the boundaries to those provided.

let conv = Converter::new()
    .set_boundaries(&[Boundary::Underscore, Boundary::LowerUpper])
    .to_case(Case::Lower);
assert_eq!(conv.convert("firstName_lastName"), "first name last name");

pub fn add_boundary(self, b: Boundary) -> Converter

Adds a boundary to the list of boundaries.

let conv = Converter::new()
    .from_case(Case::Title)
    .add_boundary(Boundary::Hyphen)
    .to_case(Case::Snake);
assert_eq!(conv.convert("My Biography - Video 1"), "my_biography___video_1")

pub fn add_boundaries(self, bs: &[Boundary]) -> Converter

Adds a vector of boundaries to the list of boundaries.

let conv = Converter::new()
    .from_case(Case::Kebab)
    .to_case(Case::Title)
    .add_boundaries(&[Boundary::Underscore, Boundary::LowerUpper]);
assert_eq!(conv.convert("2020-10_firstDay"), "2020 10 First Day");

pub fn remove_boundary(self, b: Boundary) -> Converter

Removes a boundary from the list of boundaries if it exists.

Note: Boundary::Custom variants are never considered equal due to function pointer comparison limitations, so they cannot be removed using this method. Recall that the default boundaries include no custom enumerations.

let conv = Converter::new()
    .remove_boundary(Boundary::Acronym)
    .to_case(Case::Kebab);
assert_eq!(conv.convert("HTTPRequest_parser"), "httprequest-parser");

pub fn remove_boundaries(self, bs: &[Boundary]) -> Converter

Removes all the provided boundaries from the list of boundaries if it exists.

Note: Boundary::Custom variants are never considered equal due to function pointer comparison limitations, so they cannot be removed using this method. Recall that the default boundaries include no custom enumerations.

let conv = Converter::new()
    .remove_boundaries(&Boundary::digits())
    .to_case(Case::Snake);
assert_eq!(conv.convert("C04 S03 Path Finding.pdf"), "c04_s03_path_finding.pdf");

pub fn set_pattern(self, p: Pattern) -> Converter

Sets a single pattern, replacing any existing patterns.

let conv = Converter::new()
    .set_delimiter("_")
    .set_pattern(Pattern::Sentence);
assert_eq!(conv.convert("BJARNE CASE"), "Bjarne_case");

pub fn set_patterns(self, ps: &[Pattern]) -> Converter

Sets the patterns to those provided, replacing any existing patterns. An empty slice means no mutation (words pass through unchanged).

let conv = Converter::new()
    .set_delimiter("_")
    .set_patterns(&[Pattern::Sentence]);
assert_eq!(conv.convert("BJARNE CASE"), "Bjarne_case");

pub fn add_pattern(self, p: Pattern) -> Converter

Adds a pattern to the end of the pattern list. Patterns are applied in order, so this pattern will be applied last.

let conv = Converter::new()
    .from_case(Case::Kebab)
    .add_pattern(Pattern::RemoveEmpty)
    .add_pattern(Pattern::Camel);
assert_eq!(conv.convert("--leading-delims"), "leadingDelims");

pub fn add_patterns(self, ps: &[Pattern]) -> Converter

Adds multiple patterns to the end of the pattern list.

let conv = Converter::new()
    .add_patterns(&[Pattern::RemoveEmpty, Pattern::Lowercase]);

pub fn remove_pattern(self, p: Pattern) -> Converter

Removes a pattern from the list if it exists.

Note: Pattern::Custom variants are never considered equal due to function pointer comparison limitations, so they cannot be removed using this method.

let conv = Converter::new()
    .set_boundaries(&[Boundary::Space])
    .to_case(Case::Snake)
    .remove_pattern(Pattern::Lowercase);
assert_eq!(conv.convert("HeLLo WoRLD"), "HeLLo_WoRLD");

pub fn remove_patterns(self, ps: &[Pattern]) -> Converter

Removes all specified patterns from the list.

Note: Pattern::Custom variants are never considered equal due to function pointer comparison limitations, so they cannot be removed using this method.

let conv = Converter::new()
    .set_patterns(&[Pattern::RemoveEmpty, Pattern::Lowercase, Pattern::Capital])
    .remove_patterns(&[Pattern::Lowercase, Pattern::Capital]);
// Only RemoveEmpty remains

pub fn set_delimiter<T>(self, d: T) -> Converter

where T: ToString,

Sets the delimiter.

let conv = Converter::new()
    .to_case(Case::Snake)
    .set_delimiter(".");
assert_eq!(conv.convert("LowerWithDots"), "lower.with.dots");

Trait Implementations

impl Default for Converter

fn default() -> Converter

Returns the “default value” for a type.