unicode_titlecase 2.0.0

A crate to add Unicode titlecase options to chars and strings
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

# Unicode Titlecase


Unicode titlecasing operations for chars and strings. The crate supports additional
functionality for the TR/AZ locales.
---
[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/Teh-Bobo/unicode-title-case/Rust)](https://github.com/Teh-Bobo/unicode-title-case/actions)
[![docs.rs](https://img.shields.io/docsrs/unicode_titlecase)](https://docs.rs/unicode_titlecase/latest/unicode_titlecase/)
![Crates.io](https://img.shields.io/crates/l/unicode_titlecase)
[![Crates.io](https://img.shields.io/crates/v/unicode_titlecase)](https://crates.io/crates/unicode_titlecase)
![](https://img.shields.io/badge/-no__std-green)
![](https://img.shields.io/badge/-forbid__unsafe-green)

## Installation


Add this to your `Cargo.toml`:

```toml
[dependencies]
unicode_titlecase = "2.0.0"
```

## Usage


### Chars


To turn a ```char``` into its titlecase equivalent ```[char; 3]```array:

```rust
use unicode_titlecase::to_titlecase;

assert_eq!(to_titlecase('A'), ['A', '\0', '\0']);
assert_eq!(to_titlecase('DŽ'), ['Dž', '\0', '\0']);
assert_eq!(to_titlecase('ffl'), ['F', 'f', 'l']);
```

Or use the iterator version that follows the same format as the std library. The crate defines
a ```Trait``` that is implemented on ```char```:

```rust
use unicode_titlecase::TitleCase;
assert_eq!('i'.to_titlecase().to_string(), "I");
assert_eq!('A'.to_titlecase().to_string(), "A");
assert_eq!('DŽ'.to_titlecase().to_string(), "Dž");
assert_eq!('ffl'.to_titlecase().to_string(), "Ffl");
```

### Strings


A similar trait is defined on ```str```. This
will titlecase the first char of the string, leave the rest unchanged, and return a newly
allocated ```String```.

```rust
use unicode_titlecase::StrTitleCase;
assert_eq!("iii".to_titlecase(), "Iii");
assert_eq!("ABC".to_titlecase(), "ABC");
assert_eq!("DŽDŽ".to_titlecase(), "DžDŽ");
assert_eq!("fflabc".to_titlecase(), "Fflabc");
```

Alternatively, you could lowercase the rest of the ```str```:

```rust
use unicode_titlecase::StrTitleCase;
assert_eq!("iIi".to_titlecase_lower_rest(), "Iii");
assert_eq!("ABC".to_titlecase_lower_rest(), "Abc");
assert_eq!("DŽDŽ".to_titlecase_lower_rest(), "Dždž");
assert_eq!("fflabc".to_titlecase_lower_rest(), "Fflabc");
```

### Testing a char or str


To see if the char is already titlecase, ```is_titlecase``` is provided:

```rust
use unicode_titlecase::TitleCase;
assert!('A'.is_titlecase());
assert!('Dž'.is_titlecase());
assert!('İ'.is_titlecase());

assert!(!'a'.is_titlecase());
assert!(!'DŽ'.is_titlecase());
assert!(!'ffl'.is_titlecase());
```

To test if a str is already titlecase, two options are provided. The first, ```starts_titlecase```
returns true if the first character is titlecased--ignoring the rest of the str. The second
```starts_titlecase_rest_lower``` only returns true if the first char is titlecase and the rest
of the str is lowercase.

```rust
use unicode_titlecase::StrTitleCase;
assert!("Abc".starts_titlecase());
assert!("ABC".starts_titlecase());
assert!(!"abc".starts_titlecase());

assert!("Abc".starts_titlecase_rest_lower());
assert!("İbc".starts_titlecase_rest_lower());
assert!(!"abc".starts_titlecase_rest_lower());
assert!(!"ABC".starts_titlecase_rest_lower());
assert!(!"İİ".starts_titlecase_rest_lower());
```

All testing functions work the same regardless of locale.

### Locale


The TR and AZ locales have different rules for how to titlecase certain characters.
The ```to_titlecase``` functions assume the locale is neither of these locations. A "tr_or_az"
version of each function is provided instead.

```rust
use unicode_titlecase::{to_titlecase_tr_or_az, StrTitleCase};
assert_eq!(to_titlecase_tr_or_az('i'), ['İ', '\0', '\0']);
assert_eq!('i'.to_titlecase_tr_or_az().to_string(), "İ");
assert_eq!("iIi".to_titlecase_tr_or_az(), "İIi");
assert_eq!("iIi".to_titlecase_tr_or_az_lower_rest(), "İii");
```

## License


Licensed under either of

* Apache License, Version 2.0
  ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
* MIT license
  ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

at your option.

## Contribution


Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.