Converts to and from various cases.

Convert case is written in Rust and is ready to be used inline with your rust code as a library.

use convert_case::ccase;

assert_eq!(
    ccase!(camel, "My_Var_Name"),
    "myVarName",
);
assert_eq!(
    ccase!(snake, "IOStream"),
    "io_stream",
);
assert_eq!(
    ccase!(snake -> title, "2020-04-16_family_photo"),
    "2020-04-16 Family Photo",
);

You can read the API documentation on docs.rs for a list of all features and read lots of examples.

This is list of cases that convert_case provides out of the box. You can always make your own custom case.

The command line utility ccase was made to expose the tools of the convert_case library to the command line.

$ ccase -t title super_mario_64
Super Mario 64

$ ccase -f snake -t title 2020-04-15_my_cat
2020-04-16 My Cat

$ ccase -t camel "convert to camel"
convertToCamel

Some cases and utilies that didn't feel appropriate in this library are made available in a distinct crate called convert_case_extras. This crate is a demonstration of what can be built on top of the convert_case API.

Since the library is so extensible with its new API, there is no longer a need for some niche or fun transformations to be made available in this library. Some of the features that are removed are now in a new library convert_case_extras. That library will have a lower threshold on what is included (i.e. more features), and will also serve as a demonstration of what's capable with the convert_case API.

Removed:

• Case::Toggle and Pattern::Toggle
• Case::Alternating and Pattern::Alternating
• Case::Random and Pattern::Random
• Case::PseudoRandom and Pattern::PseudoRandom
• random feature is removed. The library no longer has any features.
• Case::deterministic_cases is removed
• Case::random_cases is removed

Other breaking changes:

• Boundary::Custom has lost the arg parameter and Boundary::Custom.condition is more simply fn(&[&str]) -> bool.
  • arg was originally used for building boundaries from delimiters with the Boundary::from_delim function, which is also removed because
  • delim_boundary! macro has replaced Boundary::from_delim functionality, without the need of the arg parameters
• Casing::with_boundaries is now Casing::set_boundaries and Casing::without_boundaries is now Casing::remove_boundaries to align with Converter

This release is trying to finalize the API for a 1.0.0 release. In hindsight, making Pattern a function and Boundary a struct were poor decisions. While trying to add customized behavior, I made it harder to use. Luckily, by following the convention that was done with Case in 0.8.0, which was providing a struct-variant Case::Custom, I can keep the new customization options while reverting back to the enum pattern the library has had since the beginning.

If you are updating from before 0.7.0, I don't think any changes are necessary. If you're coming from 0.7.0 or higher,

• Change boundaries from constants to enum variants: Boundary::UPPER_SNAKE into Boundary::UpperSnake
• Change patterns from functions to enum variants on Pattern: pattern::lowercase into Pattern::Lowercase

Most excitingly, I've introduced a brand new way to use the crate for 99% of use cases, which is the default behavior out of the box to just convert a string to a case, with no modifications to behavior. Instead of

use convert_case::{Case, Casing};
"MyVarName".to_case(Case::Snake);
"my-var name".from_case(Case::Title).to_case(Case::Snake);

You can use the ccase! macro:

use convert_case::ccase;
ccase!(snake, "MyVarName");
ccase!(title -> snake, "my-var name");

This means only one import and its invocation is brief and easy to read. This is now the first thing you see when viewing the docs, which themselves have gotten a huge overhaul and many improvements in this version.

New features:

• ccase! macro that performs case conversion on a string without needing to import Case or Casing. It has two forms:
  • ccase!(snake, "string") is equivalent to "string".to_case(Case::Snake)
  • ccase!(kebab -> snake, "string") is equivalent to "string".from_case(Case::Kebab).to_case(Case::Snake)
• While not intended to be used directly, the new case! macro returns a Case variant from the snake case version of the variant. For instance, case!(snake) is substituted for Case::Snake and case!(upper_flat) for Case::UpperFlat.

Other breaking changes:

• Leading, trailing, and duplicate delimiters are no longer removed and are returned as is.
• Boundary is reverted back to being an enum, but with a Custom variant that gives all the same flexibility that Boundary had as a struct. This aligns with the Case::Custom pattern.
  • Boundary.match will return true if a set of graphemes matches the boundary condition
  • Boundary methods for start and len describe how enum variants consume letters when matched
• Pattern is reverted back to being an enum, but with a Custom variant that allowed you to pass your own fn (&[&str]) -> Vec<String> as input.
  • Pattern.mutate will perform the associated mutation function
• Converter.with_boundaries has been renamed to Converter.set_boundaries.
• Removed Converter.remove_delim and Converter.remove_pattern. You can use set_delim("") and set_pattern(Pattern::Noop) instead.
• ToString is no longer a required trait for using is_case
• word_pattern module has been removed

Pattern is no longer an enum. It is now a type alias for fn(&[&str]) -> Vec<String>. The variants of Pattern can now be referenced as functions inside the pattern module. For upgrading this means changing Pattern::Lowercase to pattern::lowercase, and calling the function directly instead of invoking the mutate method on the enum.

Inside the pattern module is also the type alias Pattern itself.

Other breaking changes:

• Add Case::Ada (capital pattern with underscore delimiter.)
• Add Case::Custom variant. It is a struct variant that takes three parameters:
  • pattern with type Pattern
  • delim with type &static str, and
  • boundaries with type &'static [Boundary].
• Because of the new pattern::noop function, Converter attribute pattern is now of type Pattern and not Option<Pattern>
• Case::deterministic_cases, Case::all_cases, and Case::random_cases now return static arrays instead of vecs

Other changes:

• Added Case::split, Case::mutate, and Case::join which expose operations related to the boundaries, pattern, and delimiter of a case
• Is now no_std compatible

• Removed debug print statement.

Boundary is no longer an enum. It now is a struct, and each enum variant cooresponds to an associated constant. For upgrading this just means changing Boundary::LowerUpper to just Boundary::LOWER_UPPER.

The benefit of this is that you can make your boundary conditions now, by instantiating the Boundary struct, or using Boundary::from_delim(). Now you can split on newlines, periods, double-colons, emojis, or a more complex case like a symbol followed by a digit. You also define which characters, if any, are removed during segmentation, and where the split happens.

Changes from this feature:

• Previous Boundary::PascalName enum variants now much refered to as Boundary::CONSTANT_NAME constants.
• All functions that returned groups of boundaries (such as Boundary::defaults(), Boundary::digit_letter(), etc) now are const and return fixed-sized arrays [Boundary; N], not Vec<Boundary>.
• Boundary::all() was removed, since there's no longer a sense of "all" boundaries, since you can create your own.
• Boundary::list_from() has been renamed to Boundary::defaults_from() and no longer outputs Boundary::UPPER_LOWER, since this function now only checks default boundaries.
• Create custom delimiter boundaries using Boundary::from_delim().

Other breaking changes:

• Rename Case::ScreamingSnake to Case::Constant.
• Add Case::Sentence (sentence pattern and space delimiter.)
• Casing trait implemented for Arc<str> and Rc<str> again.

Other changes:

• Remove most imports from doc comments.
• Remove loop over str::chars in favor of graphemes from unicode-segmentation.