1//! **heck** is a case conversion library.
2//!
3//! This library exists to provide case conversion between common cases like
4//! CamelCase and snake_case. It is intended to be unicode aware, internally
5//! consistent, and reasonably well performing.
6//!
7//! ## Definition of a word boundary
8//!
9//! Word boundaries are defined by non-alphanumeric characters, as well as
10//! within those words in this manner:
11//!
12//! 1. If an uppercase character is followed by lowercase letters, a word
13//! boundary is considered to be just prior to that uppercase character.
14//! 2. If multiple uppercase characters are consecutive, they are considered to
15//! be within a single word, except that the last will be part of the next word
16//! if it is followed by lowercase characters (see rule 1).
17//!
18//! That is, "HelloWorld" is segmented `Hello|World` whereas "XMLHttpRequest" is
19//! segmented `XML|Http|Request`.
20//!
21//! Characters not within words (such as spaces, punctuations, and underscores)
22//! are not included in the output string except as they are a part of the case
23//! being converted to. Multiple adjacent word boundaries (such as a series of
24//! underscores) are folded into one. ("hello__world" in snake case is therefore
25//! "hello_world", not the exact same string). Leading or trailing word boundary
26//! indicators are dropped, except insofar as CamelCase capitalizes the first
27//! word.
28//!
29//! ### Cases contained in this library:
30//!
31//! 1. UpperCamelCase
32//! 2. lowerCamelCase
33//! 3. snake_case
34//! 4. kebab-case
35//! 5. SHOUTY_SNAKE_CASE
36//! 6. Title Case
37//! 7. SHOUTY-KEBAB-CASE
38//! 8. Train-Case
39#![deny(missing_docs)]
40#![forbid(unsafe_code)]
41#![no_std]
42
43extern crate alloc;
44
45mod kebab;
46mod lower_camel;
47mod shouty_kebab;
48mod shouty_snake;
49mod snake;
50mod title;
51mod train;
52mod upper_camel;
53
54pub use kebab::{AsKebabCase, ToKebabCase};
55pub use lower_camel::{AsLowerCamelCase, ToLowerCamelCase};
56pub use shouty_kebab::{AsShoutyKebabCase, ToShoutyKebabCase};
57pub use shouty_snake::{
58 AsShoutySnakeCase, AsShoutySnakeCase as AsShoutySnekCase, ToShoutySnakeCase, ToShoutySnekCase,
59};
60pub use snake::{AsSnakeCase, AsSnakeCase as AsSnekCase, ToSnakeCase, ToSnekCase};
61pub use title::{AsTitleCase, ToTitleCase};
62pub use train::{AsTrainCase, ToTrainCase};
63pub use upper_camel::{
64 AsUpperCamelCase, AsUpperCamelCase as AsPascalCase, ToPascalCase, ToUpperCamelCase,
65};
66
67use core::fmt;
68
69fn transform<F, G>(
70 s: &str,
71 mut with_word: F,
72 mut boundary: G,
73 f: &mut fmt::Formatter,
74) -> fmt::Result
75where
76 F: FnMut(&str, &mut fmt::Formatter) -> fmt::Result,
77 G: FnMut(&mut fmt::Formatter) -> fmt::Result,
78{
79 /// Tracks the current 'mode' of the transformation algorithm as it scans
80 /// the input string.
81 ///
82 /// The mode is a tri-state which tracks the case of the last cased
83 /// character of the current word. If there is no cased character
84 /// (either lowercase or uppercase) since the previous word boundary,
85 /// than the mode is `Boundary`. If the last cased character is lowercase,
86 /// then the mode is `Lowercase`. Othertherwise, the mode is
87 /// `Uppercase`.
88 #[derive(Clone, Copy, PartialEq)]
89 enum WordMode {
90 /// There have been no lowercase or uppercase characters in the current
91 /// word.
92 Boundary,
93 /// The previous cased character in the current word is lowercase.
94 Lowercase,
95 /// The previous cased character in the current word is uppercase.
96 Uppercase,
97 }
98
99 let mut first_word = true;
100
101 for word in s.split(|c: char| !c.is_alphanumeric()) {
102 let mut char_indices = word.char_indices().peekable();
103 let mut init = 0;
104 let mut mode = WordMode::Boundary;
105
106 while let Some((i, c)) = char_indices.next() {
107 if let Some(&(next_i, next)) = char_indices.peek() {
108 // The mode including the current character, assuming the
109 // current character does not result in a word boundary.
110 let next_mode = if c.is_lowercase() {
111 WordMode::Lowercase
112 } else if c.is_uppercase() {
113 WordMode::Uppercase
114 } else {
115 mode
116 };
117
118 // Word boundary after if current is not uppercase and next
119 // is uppercase
120 if next_mode == WordMode::Lowercase && next.is_uppercase() {
121 if !first_word {
122 boundary(f)?;
123 }
124 with_word(&word[init..next_i], f)?;
125 first_word = false;
126 init = next_i;
127 mode = WordMode::Boundary;
128
129 // Otherwise if current and previous are uppercase and next
130 // is lowercase, word boundary before
131 } else if mode == WordMode::Uppercase && c.is_uppercase() && next.is_lowercase() {
132 if !first_word {
133 boundary(f)?;
134 } else {
135 first_word = false;
136 }
137 with_word(&word[init..i], f)?;
138 init = i;
139 mode = WordMode::Boundary;
140
141 // Otherwise no word boundary, just update the mode
142 } else {
143 mode = next_mode;
144 }
145 } else {
146 // Collect trailing characters as a word
147 if !first_word {
148 boundary(f)?;
149 } else {
150 first_word = false;
151 }
152 with_word(&word[init..], f)?;
153 break;
154 }
155 }
156 }
157
158 Ok(())
159}
160
161fn lowercase(s: &str, f: &mut fmt::Formatter) -> fmt::Result {
162 let mut chars: impl Iterator = s.chars().peekable();
163 while let Some(c: char) = chars.next() {
164 if c == 'Σ' && chars.peek().is_none() {
165 write!(f, "ς")?;
166 } else {
167 write!(f, "{}", c.to_lowercase())?;
168 }
169 }
170
171 Ok(())
172}
173
174fn uppercase(s: &str, f: &mut fmt::Formatter) -> fmt::Result {
175 for c: char in s.chars() {
176 write!(f, "{}", c.to_uppercase())?;
177 }
178
179 Ok(())
180}
181
182fn capitalize(s: &str, f: &mut fmt::Formatter) -> fmt::Result {
183 let mut char_indices: CharIndices<'_> = s.char_indices();
184 if let Some((_, c: char)) = char_indices.next() {
185 write!(f, "{}", c.to_uppercase())?;
186 if let Some((i: usize, _)) = char_indices.next() {
187 lowercase(&s[i..], f)?;
188 }
189 }
190
191 Ok(())
192}
193