Struct convert_case::Converter

pub struct Converter {
    pub boundaries: Vec<Boundary>,
    pub pattern: Option<Pattern>,
    pub delim: String,
}

The parameters for performing a case conversion.

A Converter stores three fields needed for case conversion.

1. boundaries: how a string is segmented into words.
2. pattern: how words are mutated, or how each character’s case will change.
3. delim or delimeter: 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!(
    "dialoguebox_border_shadow",
    s.from_case(Case::Kebab).to_case(Case::Snake)
);

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

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

Or you can use Converter when you are trying to make a unique case not provided as a variant of Case.

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

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

Fields

boundaries: Vec<Boundary>

How a string is segmented into words.

pattern: Option<Pattern>

How each word is mutated before joining. In the case that there is no pattern, none of the words will be mutated before joining and will maintain whatever case they were in the original string.

delim: String

The string used to join mutated words together.

Implementations

impl Converter

pub fn new() -> Self

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

use convert_case::Converter;

let conv = Converter::new();
assert_eq!("DeathPerennialQUEST", conv.convert("Death-Perennial QUEST"))

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

Converts a string.

use convert_case::{Case, Converter};

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

pub fn to_case(self, case: Case) -> Self

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

use convert_case::{Case, Converter};

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

pub fn from_case(self, case: Case) -> Self

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

use convert_case::{Case, Converter};

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

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

Sets the boundaries to those provided.

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

let conv = Converter::new()
    .set_boundaries(&[Boundary::Underscore, Boundary::LowerUpper])
    .to_case(Case::Lower);
assert_eq!("panic attack dream theater", conv.convert("panicAttack_dreamTheater"))

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

Adds a boundary to the list of boundaries.

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

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

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

Adds a vector of boundaries to the list of boundaries.

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

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

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

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

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

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

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

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

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

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

pub fn set_delim<T>(self, d: T) -> Self where
    T: ToString, 

Sets the delimeter.

use convert_case::{Case, Converter};

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

pub fn remove_delim(self) -> Self

Sets the delimeter to an empty string.

use convert_case::{Case, Converter};

let conv = Converter::new()
    .to_case(Case::Snake)
    .remove_delim();
assert_eq!("nodelimshere", conv.convert("No Delims Here"));

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

Sets the pattern.

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

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

pub fn remove_pattern(self) -> Self

Sets the pattern field to None. Where there is no pattern, a character’s case is never mutated and will be maintained at the end of conversion.

use convert_case::{Case, Converter};

let conv = Converter::new()
    .from_case(Case::Title)
    .to_case(Case::Snake)
    .remove_pattern();
assert_eq!("KoRn_Alone_I_Break", conv.convert("KoRn Alone I Break"));

Trait Implementations

impl Default for Converter

fn default() -> Self

Returns the “default value” for a type.