From d0a3ae8a90ce44c6036112b38a8f84217885b6c8 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+nikitarevenco@users.noreply.github.com> Date: Sat, 9 Nov 2024 16:32:22 +0000 Subject: [PATCH 01/55] feat: add commands for working with different cases --- Cargo.lock | 1 + helix-term/Cargo.toml | 1 + helix-term/src/commands.rs | 30 ++++++++++++++++++++++++++++-- helix-term/src/keymap/default.rs | 13 ++++++++++--- 4 files changed, 40 insertions(+), 5 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 68ad11249..586fb4ba7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1469,6 +1469,7 @@ dependencies = [ "futures-util", "grep-regex", "grep-searcher", + "heck", "helix-core", "helix-dap", "helix-event", diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml index bbad37f07..1f959e48c 100644 --- a/helix-term/Cargo.toml +++ b/helix-term/Cargo.toml @@ -53,6 +53,7 @@ helix-loader = { path = "../helix-loader" } anyhow = "1" once_cell = "1.20" +heck = "0.5" tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot"] } tui = { path = "../helix-tui", package = "helix-tui", default-features = false, features = ["crossterm"] } crossterm = { version = "0.28", features = ["event-stream"] } diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index a197792ef..9b3013c8d 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -54,6 +54,7 @@ use helix_view::{ }; use anyhow::{anyhow, bail, ensure, Context as _}; +use heck::{ToKebabCase, ToLowerCamelCase, ToSnakeCase, ToTitleCase, ToUpperCamelCase}; use insert::*; use movement::Movement; @@ -352,9 +353,14 @@ impl MappableCommand { extend_prev_char, "Extend to previous occurrence of char", repeat_last_motion, "Repeat last motion", replace, "Replace with new char", - switch_case, "Switch (toggle) case", - switch_to_uppercase, "Switch to uppercase", + switch_to_alternate_case, "Switch to aLTERNATE cASE", + switch_to_uppercase, "Switch to UPPERCASE", switch_to_lowercase, "Switch to lowercase", + switch_to_pascal_case, "Switch to PascalCase", + switch_to_camel_case, "Switch to camelCase", + switch_to_title_case, "Switch to Title Case", + switch_to_snake_case, "Switch to snake_case", + switch_to_kebab_case, "Switch to kebab-case", page_up, "Move page up", page_down, "Move page down", half_page_up, "Move half page up", @@ -1773,6 +1779,26 @@ fn switch_case(cx: &mut Context) { }); } +fn switch_to_pascal_case(cx: &mut Context) { + switch_heck_case_impl(cx, |str| str.to_upper_camel_case()) +} + +fn switch_to_camel_case(cx: &mut Context) { + switch_heck_case_impl(cx, |str| str.to_lower_camel_case()) +} + +fn switch_to_title_case(cx: &mut Context) { + switch_heck_case_impl(cx, |str| str.to_title_case()) +} + +fn switch_to_snake_case(cx: &mut Context) { + switch_heck_case_impl(cx, |str| str.to_snake_case()) +} + +fn switch_to_kebab_case(cx: &mut Context) { + switch_heck_case_impl(cx, |str| str.to_kebab_case()) +} + fn switch_to_uppercase(cx: &mut Context) { switch_case_impl(cx, |string| { string.chunks().map(|chunk| chunk.to_uppercase()).collect() diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs index e160b2246..af66f364d 100644 --- a/helix-term/src/keymap/default.rs +++ b/helix-term/src/keymap/default.rs @@ -19,9 +19,16 @@ pub fn default() -> HashMap { "R" => replace_with_yanked, "A-." => repeat_last_motion, - "~" => switch_case, - "`" => switch_to_lowercase, - "A-`" => switch_to_uppercase, + "~" => switch_to_alternate_case, + "`" => { "Case" + "l" => switch_to_lowercase, + "u" => switch_to_uppercase, + "p" => switch_to_pascal_case, + "c" => switch_to_camel_case, + "t" => switch_to_title_case, + "s" => switch_to_snake_case, + "k" => switch_to_kebab_case, + }, "home" => goto_line_start, "end" => goto_line_end, From 7327393d8009c678e156c60645f4c45bc0642e91 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+nikitarevenco@users.noreply.github.com> Date: Sat, 9 Nov 2024 16:32:28 +0000 Subject: [PATCH 02/55] feat: add case-mode section --- book/src/keymap.md | 30 ++++++++++++++++++++++++++++-- 1 file changed, 28 insertions(+), 2 deletions(-) diff --git a/book/src/keymap.md b/book/src/keymap.md index 2797eaee2..2450e3122 100644 --- a/book/src/keymap.md +++ b/book/src/keymap.md @@ -11,6 +11,7 @@ - [Goto mode](#goto-mode) - [Match mode](#match-mode) - [Window mode](#window-mode) + - [Case Mode](#case-mode) - [Space mode](#space-mode) - [Popup](#popup) - [Completion Menu](#completion-menu) @@ -70,8 +71,6 @@ Normal mode is the default mode when you launch helix. You can return to it from | `r` | Replace with a character | `replace` | | `R` | Replace with yanked text | `replace_with_yanked` | | `~` | Switch case of the selected text | `switch_case` | -| `` ` `` | Set the selected text to lower case | `switch_to_lowercase` | -| `` Alt-` `` | Set the selected text to upper case | `switch_to_uppercase` | | `i` | Insert before selection | `insert_mode` | | `a` | Insert after selection (append) | `append_mode` | | `I` | Insert at the start of the line | `insert_at_line_start` | @@ -171,6 +170,7 @@ These sub-modes are accessible from normal mode and typically switch back to nor | ----- | ----------- | ------- | | `v` | Enter [select (extend) mode](#select--extend-mode) | `select_mode` | | `g` | Enter [goto mode](#goto-mode) | N/A | +| ` ` ` | Enter [case mode](#case-mode) | N/A | | `m` | Enter [match mode](#match-mode) | N/A | | `:` | Enter command mode | `command_mode` | | `z` | Enter [view mode](#view-mode) | N/A | @@ -234,6 +234,32 @@ Jumps to various locations. | `k` | Move up textual (instead of visual) line | `move_line_up` | | `w` | Show labels at each word and select the word that belongs to the entered labels | `goto_word` | +#### Case mode + +Accessed by typing ` ` ` in [normal mode](#normal-mode). + +Various functions for changing case of text in different ways. + + "a" => switch_to_alternate_case, + "l" => switch_to_lowercase, + "u" => switch_to_uppercase, + "p" => switch_to_pascal_case, + "c" => switch_to_camel_case, + "t" => switch_to_title_case, + "s" => switch_to_snake_case, + "k" => switch_to_kebab_case, +| Key | Description | Command | +| ----- | ----------- | ------- | +| `l` | Switch all text to lowercase | `switch_to_lowercase` | +| `u` | Switch all text to UPPERCASE | `switch_to_uppercase` | +| `p` | Switch text to Pascal Case | `switch_to_pascal_case` | +| `c` | Switch text to camelCase | `switch_to_camel_case` | +| `t` | Switch text to Title Case | `switch_to_title_case` | +| `s` | Switch text to snake_case | `switch_to_snake_case` | +| `k` | Switch text to kebab-case | `switch_to_kebab_case` | + +TODO: Mappings for selecting syntax nodes (a superset of `[`). + #### Match mode Accessed by typing `m` in [normal mode](#normal-mode). From fb5a84ecfad57aa36b16dff7acd3fddf09c7b4b9 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+nikitarevenco@users.noreply.github.com> Date: Sat, 9 Nov 2024 16:34:44 +0000 Subject: [PATCH 03/55] docs: remove accidentally pasted code --- book/src/keymap.md | 8 -------- 1 file changed, 8 deletions(-) diff --git a/book/src/keymap.md b/book/src/keymap.md index 2450e3122..c494c778a 100644 --- a/book/src/keymap.md +++ b/book/src/keymap.md @@ -240,14 +240,6 @@ Accessed by typing ` ` ` in [normal mode](#normal-mode). Various functions for changing case of text in different ways. - "a" => switch_to_alternate_case, - "l" => switch_to_lowercase, - "u" => switch_to_uppercase, - "p" => switch_to_pascal_case, - "c" => switch_to_camel_case, - "t" => switch_to_title_case, - "s" => switch_to_snake_case, - "k" => switch_to_kebab_case, | Key | Description | Command | | ----- | ----------- | ------- | | `l` | Switch all text to lowercase | `switch_to_lowercase` | From f88364329a8024bd9218a2759ea689ccc7d3c4af Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 07:00:43 +0000 Subject: [PATCH 04/55] feat: wording Co-authored-by: Filip Dutescu --- book/src/keymap.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/book/src/keymap.md b/book/src/keymap.md index c494c778a..6c6ed5b0a 100644 --- a/book/src/keymap.md +++ b/book/src/keymap.md @@ -238,7 +238,7 @@ Jumps to various locations. Accessed by typing ` ` ` in [normal mode](#normal-mode). -Various functions for changing case of text in different ways. +Various commands for changing the case of text in different ways. | Key | Description | Command | | ----- | ----------- | ------- | From 7dd782579ee69810391d57c1810ac62176f3ca65 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 07:08:04 +0000 Subject: [PATCH 05/55] feat: remove extra dependency --- Cargo.lock | 1 - helix-term/Cargo.toml | 1 - helix-term/src/commands.rs | 5 +++-- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 586fb4ba7..68ad11249 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1469,7 +1469,6 @@ dependencies = [ "futures-util", "grep-regex", "grep-searcher", - "heck", "helix-core", "helix-dap", "helix-event", diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml index 1f959e48c..bbad37f07 100644 --- a/helix-term/Cargo.toml +++ b/helix-term/Cargo.toml @@ -53,7 +53,6 @@ helix-loader = { path = "../helix-loader" } anyhow = "1" once_cell = "1.20" -heck = "0.5" tokio = { version = "1", features = ["rt", "rt-multi-thread", "io-util", "io-std", "time", "process", "macros", "fs", "parking_lot"] } tui = { path = "../helix-tui", package = "helix-tui", default-features = false, features = ["crossterm"] } crossterm = { version = "0.28", features = ["event-stream"] } diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 9b3013c8d..b608ef9f9 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -1717,12 +1717,13 @@ fn replace(cx: &mut Context) { fn switch_case_impl(cx: &mut Context, change_fn: F) where - F: Fn(RopeSlice) -> Tendril, + F: Fn(&dyn Iterator) -> Tendril, { let (view, doc) = current!(cx.editor); let selection = doc.selection(view.id); let transaction = Transaction::change_by_selection(doc.text(), selection, |range| { - let text: Tendril = change_fn(range.slice(doc.text().slice(..))); + let chars = range.slice(doc.text().slice(..)).chars(); + let text = change_fn(&chars); (range.from(), range.to(), Some(text)) }); From ab4ad09dbe9a7ac18c2265c90fb9818d125941cf Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 07:22:22 +0000 Subject: [PATCH 06/55] feat: basic implementation for pascal case --- helix-term/src/commands.rs | 99 +++++++++++++++++++------------- helix-term/src/keymap/default.rs | 14 ++--- 2 files changed, 67 insertions(+), 46 deletions(-) diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index b608ef9f9..bc10bc6fd 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -18,6 +18,7 @@ use tui::{ pub use typed::*; use helix_core::{ + case_conversion::to_pascal_case, char_idx_at_visual_offset, chars::char_is_word, command_line, comment, @@ -54,7 +55,6 @@ use helix_view::{ }; use anyhow::{anyhow, bail, ensure, Context as _}; -use heck::{ToKebabCase, ToLowerCamelCase, ToSnakeCase, ToTitleCase, ToUpperCamelCase}; use insert::*; use movement::Movement; @@ -353,14 +353,14 @@ impl MappableCommand { extend_prev_char, "Extend to previous occurrence of char", repeat_last_motion, "Repeat last motion", replace, "Replace with new char", - switch_to_alternate_case, "Switch to aLTERNATE cASE", - switch_to_uppercase, "Switch to UPPERCASE", - switch_to_lowercase, "Switch to lowercase", + // switch_to_alternate_case, "Switch to aLTERNATE cASE", + // switch_to_uppercase, "Switch to UPPERCASE", + // switch_to_lowercase, "Switch to lowercase", switch_to_pascal_case, "Switch to PascalCase", - switch_to_camel_case, "Switch to camelCase", - switch_to_title_case, "Switch to Title Case", - switch_to_snake_case, "Switch to snake_case", - switch_to_kebab_case, "Switch to kebab-case", + // switch_to_camel_case, "Switch to camelCase", + // switch_to_title_case, "Switch to Title Case", + // switch_to_snake_case, "Switch to snake_case", + // switch_to_kebab_case, "Switch to kebab-case", page_up, "Move page up", page_down, "Move page down", half_page_up, "Move half page up", @@ -1715,20 +1715,41 @@ fn replace(cx: &mut Context) { }) } +// fn switch_to_alternate_case(cx: &mut Context) { +// switch_case_impl(cx, |string| { +// string +// .chars() +// .flat_map(|ch| { +// if ch.is_lowercase() { +// ch.to_uppercase().collect() +// } else if ch.is_uppercase() { +// ch.to_lowercase().collect() +// } else { +// vec![ch] +// } +// }) +// .collect() +// }); +// } + fn switch_case_impl(cx: &mut Context, change_fn: F) where - F: Fn(&dyn Iterator) -> Tendril, + F: for<'a> Fn(&mut (dyn Iterator + 'a)) -> Tendril, { let (view, doc) = current!(cx.editor); - let selection = doc.selection(view.id); - let transaction = Transaction::change_by_selection(doc.text(), selection, |range| { - let chars = range.slice(doc.text().slice(..)).chars(); - let text = change_fn(&chars); + let view_id = view.id; - (range.from(), range.to(), Some(text)) - }); + let selection = doc.selection(view_id); - doc.apply(&transaction, view.id); + let transaction = { + Transaction::change_by_selection(doc.text(), selection, |range| { + let mut chars = range.slice(doc.text().slice(..)).chars(); + let text: Tendril = change_fn(&mut chars); + (range.from(), range.to(), Some(text)) + }) + }; + + doc.apply(&transaction, view_id); exit_select_mode(cx); } @@ -1781,36 +1802,36 @@ fn switch_case(cx: &mut Context) { } fn switch_to_pascal_case(cx: &mut Context) { - switch_heck_case_impl(cx, |str| str.to_upper_camel_case()) + switch_case_impl(cx, |chars| to_pascal_case(chars)) } -fn switch_to_camel_case(cx: &mut Context) { - switch_heck_case_impl(cx, |str| str.to_lower_camel_case()) -} +// fn switch_to_camel_case(cx: &mut Context) { +// switch_heck_case_impl(cx, |str| str.to_lower_camel_case()) +// } -fn switch_to_title_case(cx: &mut Context) { - switch_heck_case_impl(cx, |str| str.to_title_case()) -} +// fn switch_to_title_case(cx: &mut Context) { +// switch_heck_case_impl(cx, |str| str.to_title_case()) +// } -fn switch_to_snake_case(cx: &mut Context) { - switch_heck_case_impl(cx, |str| str.to_snake_case()) -} +// fn switch_to_snake_case(cx: &mut Context) { +// switch_heck_case_impl(cx, |str| str.to_snake_case()) +// } -fn switch_to_kebab_case(cx: &mut Context) { - switch_heck_case_impl(cx, |str| str.to_kebab_case()) -} +// fn switch_to_kebab_case(cx: &mut Context) { +// switch_heck_case_impl(cx, |str| str.to_kebab_case()) +// } -fn switch_to_uppercase(cx: &mut Context) { - switch_case_impl(cx, |string| { - string.chunks().map(|chunk| chunk.to_uppercase()).collect() - }); -} +// fn switch_to_uppercase(cx: &mut Context) { +// switch_case_impl(cx, |string| { +// string.chunks().map(|chunk| chunk.to_uppercase()).collect() +// }); +// } -fn switch_to_lowercase(cx: &mut Context) { - switch_case_impl(cx, |string| { - string.chunks().map(|chunk| chunk.to_lowercase()).collect() - }); -} +// fn switch_to_lowercase(cx: &mut Context) { +// switch_case_impl(cx, |string| { +// string.chunks().map(|chunk| chunk.to_lowercase()).collect() +// }); +// } pub fn scroll(cx: &mut Context, offset: usize, direction: Direction, sync_cursor: bool) { use Direction::*; diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs index af66f364d..d217d1f70 100644 --- a/helix-term/src/keymap/default.rs +++ b/helix-term/src/keymap/default.rs @@ -19,15 +19,15 @@ pub fn default() -> HashMap { "R" => replace_with_yanked, "A-." => repeat_last_motion, - "~" => switch_to_alternate_case, + // "~" => switch_to_alternate_case, "`" => { "Case" - "l" => switch_to_lowercase, - "u" => switch_to_uppercase, + // "l" => switch_to_lowercase, + // "u" => switch_to_uppercase, "p" => switch_to_pascal_case, - "c" => switch_to_camel_case, - "t" => switch_to_title_case, - "s" => switch_to_snake_case, - "k" => switch_to_kebab_case, + // "c" => switch_to_camel_case, + // "t" => switch_to_title_case, + // "s" => switch_to_snake_case, + // "k" => switch_to_kebab_case, }, "home" => goto_line_start, From 63f82c7bfae26397b0ae7674f742b5150bbe5d77 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 07:44:22 +0000 Subject: [PATCH 07/55] feat: 5 functions to change case, lower, alternate, upper, pascal & camel --- helix-core/src/case_conversion.rs | 76 +++++++++++++++++++++---------- helix-term/src/commands.rs | 49 +++++++++----------- helix-term/src/keymap/default.rs | 8 ++-- 3 files changed, 78 insertions(+), 55 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 2054a2bb5..215456ac9 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -2,12 +2,63 @@ use crate::Tendril; // todo: should this be grapheme aware? -pub fn to_pascal_case(text: impl Iterator) -> Tendril { +fn to_case(text: I, to_case_with: fn(I, &mut Tendril)) -> Tendril +where + I: Iterator, +{ let mut res = Tendril::new(); - to_pascal_case_with(text, &mut res); + to_case_with(text, &mut res); res } +pub fn to_camel_case(text: impl Iterator) -> Tendril { + to_case(text, to_camel_case_with) +} + +pub fn to_lower_case(text: impl Iterator) -> Tendril { + to_case(text, to_lower_case_with) +} + +pub fn to_upper_case(text: impl Iterator) -> Tendril { + to_case(text, to_upper_case_with) +} + +pub fn to_pascal_case(text: impl Iterator) -> Tendril { + to_case(text, to_pascal_case_with) +} + +pub fn to_alternate_case(text: impl Iterator) -> Tendril { + to_case(text, to_pascal_case_with) +} + +pub fn to_upper_case_with(text: impl Iterator, buf: &mut Tendril) { + for c in text { + for c in c.to_uppercase() { + buf.push(c) + } + } +} + +pub fn to_lower_case_with(text: impl Iterator, buf: &mut Tendril) { + for c in text { + for c in c.to_lowercase() { + buf.push(c) + } + } +} + +pub fn to_alternate_case_with(text: impl Iterator, buf: &mut Tendril) { + for c in text { + if c.is_uppercase() { + buf.extend(c.to_lowercase()) + } else if c.is_lowercase() { + buf.extend(c.to_uppercase()) + } else { + buf.push(c) + } + } +} + pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) { let mut at_word_start = true; for c in text { @@ -25,27 +76,6 @@ pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) } } -pub fn to_upper_case_with(text: impl Iterator, buf: &mut Tendril) { - for c in text { - for c in c.to_uppercase() { - buf.push(c) - } - } -} - -pub fn to_lower_case_with(text: impl Iterator, buf: &mut Tendril) { - for c in text { - for c in c.to_lowercase() { - buf.push(c) - } - } -} - -pub fn to_camel_case(text: impl Iterator) -> Tendril { - let mut res = Tendril::new(); - to_camel_case_with(text, &mut res); - res -} pub fn to_camel_case_with(mut text: impl Iterator, buf: &mut Tendril) { for c in &mut text { if c.is_alphanumeric() { diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index bc10bc6fd..793c0a5f6 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -18,7 +18,9 @@ use tui::{ pub use typed::*; use helix_core::{ - case_conversion::to_pascal_case, + case_conversion::{ + to_alternate_case, to_camel_case, to_lower_case, to_pascal_case, to_upper_case, + }, char_idx_at_visual_offset, chars::char_is_word, command_line, comment, @@ -353,11 +355,11 @@ impl MappableCommand { extend_prev_char, "Extend to previous occurrence of char", repeat_last_motion, "Repeat last motion", replace, "Replace with new char", - // switch_to_alternate_case, "Switch to aLTERNATE cASE", - // switch_to_uppercase, "Switch to UPPERCASE", - // switch_to_lowercase, "Switch to lowercase", + switch_to_alternate_case, "Switch to aLTERNATE cASE", + switch_to_upper_case, "Switch to UPPERCASE", + switch_to_lower_case, "Switch to lowercase", switch_to_pascal_case, "Switch to PascalCase", - // switch_to_camel_case, "Switch to camelCase", + switch_to_camel_case, "Switch to camelCase", // switch_to_title_case, "Switch to Title Case", // switch_to_snake_case, "Switch to snake_case", // switch_to_kebab_case, "Switch to kebab-case", @@ -1715,23 +1717,6 @@ fn replace(cx: &mut Context) { }) } -// fn switch_to_alternate_case(cx: &mut Context) { -// switch_case_impl(cx, |string| { -// string -// .chars() -// .flat_map(|ch| { -// if ch.is_lowercase() { -// ch.to_uppercase().collect() -// } else if ch.is_uppercase() { -// ch.to_lowercase().collect() -// } else { -// vec![ch] -// } -// }) -// .collect() -// }); -// } - fn switch_case_impl(cx: &mut Context, change_fn: F) where F: for<'a> Fn(&mut (dyn Iterator + 'a)) -> Tendril, @@ -1805,13 +1790,21 @@ fn switch_to_pascal_case(cx: &mut Context) { switch_case_impl(cx, |chars| to_pascal_case(chars)) } -// fn switch_to_camel_case(cx: &mut Context) { -// switch_heck_case_impl(cx, |str| str.to_lower_camel_case()) -// } +fn switch_to_camel_case(cx: &mut Context) { + switch_case_impl(cx, |chars| to_camel_case(chars)) +} -// fn switch_to_title_case(cx: &mut Context) { -// switch_heck_case_impl(cx, |str| str.to_title_case()) -// } +fn switch_to_lower_case(cx: &mut Context) { + switch_case_impl(cx, |chars| to_upper_case(chars)) +} + +fn switch_to_upper_case(cx: &mut Context) { + switch_case_impl(cx, |chars| to_lower_case(chars)) +} + +fn switch_to_alternate_case(cx: &mut Context) { + switch_case_impl(cx, |chars| to_alternate_case(chars)) +} // fn switch_to_snake_case(cx: &mut Context) { // switch_heck_case_impl(cx, |str| str.to_snake_case()) diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs index d217d1f70..6dcff8e04 100644 --- a/helix-term/src/keymap/default.rs +++ b/helix-term/src/keymap/default.rs @@ -19,12 +19,12 @@ pub fn default() -> HashMap { "R" => replace_with_yanked, "A-." => repeat_last_motion, - // "~" => switch_to_alternate_case, + "~" => switch_to_alternate_case, "`" => { "Case" - // "l" => switch_to_lowercase, - // "u" => switch_to_uppercase, + "l" => switch_to_lowercase, + "u" => switch_to_uppercase, "p" => switch_to_pascal_case, - // "c" => switch_to_camel_case, + "c" => switch_to_camel_case, // "t" => switch_to_title_case, // "s" => switch_to_snake_case, // "k" => switch_to_kebab_case, From 42e150293a82a3d1656c596873198fac4730fb96 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 07:47:13 +0000 Subject: [PATCH 08/55] feat: `switch_to_title_case` --- helix-core/src/case_conversion.rs | 24 +++++++++++++++++++++++- helix-term/src/commands.rs | 7 ++++++- 2 files changed, 29 insertions(+), 2 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 215456ac9..fca90dc06 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -28,7 +28,11 @@ pub fn to_pascal_case(text: impl Iterator) -> Tendril { } pub fn to_alternate_case(text: impl Iterator) -> Tendril { - to_case(text, to_pascal_case_with) + to_case(text, to_alternate_case_with) +} + +pub fn to_title_case(text: impl Iterator) -> Tendril { + to_case(text, to_title_case_with) } pub fn to_upper_case_with(text: impl Iterator, buf: &mut Tendril) { @@ -76,6 +80,24 @@ pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) } } +pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { + let mut at_word_start = true; + for c in text { + // we don't count _ as a word char here so case conversions work well + if !c.is_alphanumeric() { + at_word_start = true; + continue; + } + if at_word_start { + at_word_start = false; + buf.push(' '); + buf.extend(c.to_uppercase()); + } else { + buf.push(c) + } + } +} + pub fn to_camel_case_with(mut text: impl Iterator, buf: &mut Tendril) { for c in &mut text { if c.is_alphanumeric() { diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 793c0a5f6..cb9e88c4c 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -19,7 +19,8 @@ pub use typed::*; use helix_core::{ case_conversion::{ - to_alternate_case, to_camel_case, to_lower_case, to_pascal_case, to_upper_case, + to_alternate_case, to_camel_case, to_lower_case, to_pascal_case, to_title_case, + to_upper_case, }, char_idx_at_visual_offset, chars::char_is_word, @@ -1806,6 +1807,10 @@ fn switch_to_alternate_case(cx: &mut Context) { switch_case_impl(cx, |chars| to_alternate_case(chars)) } +fn switch_to_title_case(cx: &mut Context) { + switch_case_impl(cx, |chars| to_title_case(chars)) +} + // fn switch_to_snake_case(cx: &mut Context) { // switch_heck_case_impl(cx, |str| str.to_snake_case()) // } From b96e177ec7aaac4bbb0ab6ffbd0071a4b6171da5 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 07:49:48 +0000 Subject: [PATCH 09/55] fix: map switch_to_title_case --- helix-term/src/commands.rs | 2 +- helix-term/src/keymap/default.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index cb9e88c4c..210a687f5 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -361,7 +361,7 @@ impl MappableCommand { switch_to_lower_case, "Switch to lowercase", switch_to_pascal_case, "Switch to PascalCase", switch_to_camel_case, "Switch to camelCase", - // switch_to_title_case, "Switch to Title Case", + switch_to_title_case, "Switch to Title Case", // switch_to_snake_case, "Switch to snake_case", // switch_to_kebab_case, "Switch to kebab-case", page_up, "Move page up", diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs index 6dcff8e04..14c11dafb 100644 --- a/helix-term/src/keymap/default.rs +++ b/helix-term/src/keymap/default.rs @@ -25,7 +25,7 @@ pub fn default() -> HashMap { "u" => switch_to_uppercase, "p" => switch_to_pascal_case, "c" => switch_to_camel_case, - // "t" => switch_to_title_case, + "t" => switch_to_title_case, // "s" => switch_to_snake_case, // "k" => switch_to_kebab_case, }, From c1be961b93b1b0c27a8927e483f120938c684556 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 07:55:43 +0000 Subject: [PATCH 10/55] feat: implementations for kebab case and snake case --- helix-core/src/case_conversion.rs | 46 ++++++++++++++++++++++++++++++- helix-term/src/commands.rs | 32 +++++++-------------- helix-term/src/keymap/default.rs | 8 +++--- 3 files changed, 59 insertions(+), 27 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index fca90dc06..dd13f32dd 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -35,6 +35,14 @@ pub fn to_title_case(text: impl Iterator) -> Tendril { to_case(text, to_title_case_with) } +pub fn to_kebab_case(text: impl Iterator) -> Tendril { + to_case(text, to_kebab_case_with) +} + +pub fn to_snake_case(text: impl Iterator) -> Tendril { + to_case(text, to_snake_case_with) +} + pub fn to_upper_case_with(text: impl Iterator, buf: &mut Tendril) { for c in text { for c in c.to_uppercase() { @@ -80,8 +88,44 @@ pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) } } -pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { +pub fn to_snake_case_with(text: impl Iterator, buf: &mut Tendril) { let mut at_word_start = true; + for c in text { + // we don't count _ as a word char here so case conversions work well + if !c.is_alphanumeric() { + at_word_start = true; + continue; + } + if at_word_start { + at_word_start = false; + buf.push('_'); + buf.push(c); + } else { + buf.push(c) + } + } +} + +pub fn to_kebab_case_with(text: impl Iterator, buf: &mut Tendril) { + let mut at_word_start = false; + for c in text { + // we don't count _ as a word char here so case conversions work well + if !c.is_alphanumeric() { + at_word_start = true; + continue; + } + if at_word_start { + at_word_start = false; + buf.push('-'); + buf.push(c); + } else { + buf.push(c) + } + } +} + +pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { + let mut at_word_start = false; for c in text { // we don't count _ as a word char here so case conversions work well if !c.is_alphanumeric() { diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 210a687f5..b0d0c13a6 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -19,8 +19,8 @@ pub use typed::*; use helix_core::{ case_conversion::{ - to_alternate_case, to_camel_case, to_lower_case, to_pascal_case, to_title_case, - to_upper_case, + to_alternate_case, to_camel_case, to_kebab_case, to_lower_case, to_pascal_case, + to_snake_case, to_title_case, to_upper_case, }, char_idx_at_visual_offset, chars::char_is_word, @@ -362,8 +362,8 @@ impl MappableCommand { switch_to_pascal_case, "Switch to PascalCase", switch_to_camel_case, "Switch to camelCase", switch_to_title_case, "Switch to Title Case", - // switch_to_snake_case, "Switch to snake_case", - // switch_to_kebab_case, "Switch to kebab-case", + switch_to_snake_case, "Switch to snake_case", + switch_to_kebab_case, "Switch to kebab-case", page_up, "Move page up", page_down, "Move page down", half_page_up, "Move half page up", @@ -1811,25 +1811,13 @@ fn switch_to_title_case(cx: &mut Context) { switch_case_impl(cx, |chars| to_title_case(chars)) } -// fn switch_to_snake_case(cx: &mut Context) { -// switch_heck_case_impl(cx, |str| str.to_snake_case()) -// } +fn switch_to_snake_case(cx: &mut Context) { + switch_case_impl(cx, |chars| to_snake_case(chars)) +} -// fn switch_to_kebab_case(cx: &mut Context) { -// switch_heck_case_impl(cx, |str| str.to_kebab_case()) -// } - -// fn switch_to_uppercase(cx: &mut Context) { -// switch_case_impl(cx, |string| { -// string.chunks().map(|chunk| chunk.to_uppercase()).collect() -// }); -// } - -// fn switch_to_lowercase(cx: &mut Context) { -// switch_case_impl(cx, |string| { -// string.chunks().map(|chunk| chunk.to_lowercase()).collect() -// }); -// } +fn switch_to_kebab_case(cx: &mut Context) { + switch_case_impl(cx, |chars| to_kebab_case(chars)) +} pub fn scroll(cx: &mut Context, offset: usize, direction: Direction, sync_cursor: bool) { use Direction::*; diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs index 14c11dafb..3a21594d2 100644 --- a/helix-term/src/keymap/default.rs +++ b/helix-term/src/keymap/default.rs @@ -21,13 +21,13 @@ pub fn default() -> HashMap { "~" => switch_to_alternate_case, "`" => { "Case" - "l" => switch_to_lowercase, - "u" => switch_to_uppercase, + "l" => switch_to_lower_case, + "u" => switch_to_upper_case, "p" => switch_to_pascal_case, "c" => switch_to_camel_case, "t" => switch_to_title_case, - // "s" => switch_to_snake_case, - // "k" => switch_to_kebab_case, + "s" => switch_to_snake_case, + "k" => switch_to_kebab_case, }, "home" => goto_line_start, From 355b2ba290edcb1cd7f3fd299af80befeca4d6ca Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 07:57:16 +0000 Subject: [PATCH 11/55] fix: switch to lower|upper case is flipped --- helix-term/src/commands.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index b0d0c13a6..4e321a808 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -1796,11 +1796,11 @@ fn switch_to_camel_case(cx: &mut Context) { } fn switch_to_lower_case(cx: &mut Context) { - switch_case_impl(cx, |chars| to_upper_case(chars)) + switch_case_impl(cx, |chars| to_lower_case(chars)) } fn switch_to_upper_case(cx: &mut Context) { - switch_case_impl(cx, |chars| to_lower_case(chars)) + switch_case_impl(cx, |chars| to_upper_case(chars)) } fn switch_to_alternate_case(cx: &mut Context) { From f1cf46f022e40cbe916be1ab496937b4eefb226d Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 08:01:51 +0000 Subject: [PATCH 12/55] feat: better implementation of title_case --- helix-core/src/case_conversion.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index dd13f32dd..67bf17180 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -125,8 +125,8 @@ pub fn to_kebab_case_with(text: impl Iterator, buf: &mut Tendril) { } pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { - let mut at_word_start = false; - for c in text { + let mut at_word_start = true; + for (i, c) in text.enumerate() { // we don't count _ as a word char here so case conversions work well if !c.is_alphanumeric() { at_word_start = true; @@ -134,7 +134,9 @@ pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { } if at_word_start { at_word_start = false; - buf.push(' '); + if i != 0 { + buf.push(' '); + } buf.extend(c.to_uppercase()); } else { buf.push(c) From ff8c1df71db70a3d4ed8c3bb14b164671e944bab Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 09:00:56 +0000 Subject: [PATCH 13/55] feat: correct implementations for kebab, snake and title case --- helix-core/src/case_conversion.rs | 96 ++++++++++++++++--------------- 1 file changed, 51 insertions(+), 45 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 67bf17180..35287d5be 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -88,60 +88,66 @@ pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) } } -pub fn to_snake_case_with(text: impl Iterator, buf: &mut Tendril) { - let mut at_word_start = true; +pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { + let mut capitalize_next = true; + let mut prev_is_lowercase = false; + for c in text { - // we don't count _ as a word char here so case conversions work well - if !c.is_alphanumeric() { - at_word_start = true; - continue; - } - if at_word_start { - at_word_start = false; - buf.push('_'); - buf.push(c); + if c.is_alphanumeric() { + if capitalize_next || (prev_is_lowercase && c.is_uppercase()) { + buf.extend(c.to_uppercase()); + capitalize_next = false; + } else { + buf.extend(c.to_lowercase()); + } + prev_is_lowercase = c.is_lowercase(); } else { - buf.push(c) + capitalize_next = true; + prev_is_lowercase = false; + buf.push(' '); } } + + *buf = buf.trim().into(); +} + +pub fn to_case_with_separator( + text: impl Iterator, + buf: &mut Tendril, + separator: char, +) { + let mut prev_is_lowercase = false; // Tracks if the previous character was lowercase + let mut prev_is_alphanumeric = false; // Tracks if the previous character was alphanumeric + + for c in text { + if c.is_alphanumeric() { + if prev_is_lowercase && c.is_uppercase() { + buf.push(separator); + } + if !prev_is_alphanumeric && !buf.is_empty() { + buf.push(separator); + } + + buf.push(c.to_ascii_lowercase()); + prev_is_lowercase = c.is_lowercase(); + prev_is_alphanumeric = true; + } else { + prev_is_lowercase = false; + prev_is_alphanumeric = false; + } + } + + if buf.ends_with(separator) { + buf.pop(); + } } pub fn to_kebab_case_with(text: impl Iterator, buf: &mut Tendril) { - let mut at_word_start = false; - for c in text { - // we don't count _ as a word char here so case conversions work well - if !c.is_alphanumeric() { - at_word_start = true; - continue; - } - if at_word_start { - at_word_start = false; - buf.push('-'); - buf.push(c); - } else { - buf.push(c) - } - } + to_case_with_separator(text, buf, '-'); } -pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { - let mut at_word_start = true; - for (i, c) in text.enumerate() { - // we don't count _ as a word char here so case conversions work well - if !c.is_alphanumeric() { - at_word_start = true; - continue; - } - if at_word_start { - at_word_start = false; - if i != 0 { - buf.push(' '); - } - buf.extend(c.to_uppercase()); - } else { - buf.push(c) - } - } +pub fn to_snake_case_with(text: impl Iterator, buf: &mut Tendril) { + to_case_with_separator(text, buf, '_'); } pub fn to_camel_case_with(mut text: impl Iterator, buf: &mut Tendril) { From 75cd953c30124b1a3d5e08da0c224395e3dfd386 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 09:38:48 +0000 Subject: [PATCH 14/55] feat: correct implementation for pascal_case and camel_case --- helix-core/src/case_conversion.rs | 144 +++++++++++++++++++++++------- 1 file changed, 111 insertions(+), 33 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 35287d5be..f4f1a166b 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -71,23 +71,6 @@ pub fn to_alternate_case_with(text: impl Iterator, buf: &mut Tendri } } -pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) { - let mut at_word_start = true; - for c in text { - // we don't count _ as a word char here so case conversions work well - if !c.is_alphanumeric() { - at_word_start = true; - continue; - } - if at_word_start { - at_word_start = false; - buf.extend(c.to_uppercase()); - } else { - buf.push(c) - } - } -} - pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { let mut capitalize_next = true; let mut prev_is_lowercase = false; @@ -150,24 +133,119 @@ pub fn to_snake_case_with(text: impl Iterator, buf: &mut Tendril) { to_case_with_separator(text, buf, '_'); } -pub fn to_camel_case_with(mut text: impl Iterator, buf: &mut Tendril) { - for c in &mut text { - if c.is_alphanumeric() { - buf.extend(c.to_lowercase()) - } - } - let mut at_word_start = false; +pub fn to_camel_case_with(text: impl Iterator, buf: &mut Tendril) { + to_camel_or_pascal_case_with(text, buf, false); +} + +pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) { + to_camel_or_pascal_case_with(text, buf, true); +} + +pub fn to_camel_or_pascal_case_with( + text: impl Iterator, + buf: &mut Tendril, + is_pascal: bool, +) { + let mut capitalize_next = is_pascal; + for c in text { - // we don't count _ as a word char here so case conversions work well - if !c.is_alphanumeric() { - at_word_start = true; - continue; - } - if at_word_start { - at_word_start = false; - buf.extend(c.to_uppercase()); + if c.is_alphanumeric() { + if capitalize_next { + buf.extend(c.to_uppercase()); + capitalize_next = false; + } else { + buf.extend(c.to_lowercase()); + } } else { - buf.push(c) + capitalize_next = true; } } } + +#[cfg(test)] +mod tests { + use super::*; + + fn case_tester<'a, F>(change_fn: F) -> impl Fn(&'a str, &'a str) + 'a + where + F: Fn(std::str::Chars<'a>) -> Tendril + 'a, + { + move |input: &str, expected: &str| { + let transformed = change_fn(input.chars()); + let m = transformed.to_string(); + dbg!(input); + assert_eq!(m.as_str(), expected) + } + } + + #[test] + fn test_camel_case_conversion() { + let camel_test = case_tester(to_camel_case); + camel_test("hello world", "helloWorld"); + camel_test("Hello World", "helloWorld"); + camel_test("hello_world", "helloWorld"); + camel_test("HELLO_WORLD", "helloWorld"); + } + + #[test] + fn test_lower_case_conversion() { + let lower_test = case_tester(to_lower_case); + lower_test("HelloWorld", "helloworld"); + lower_test("HELLO WORLD", "hello world"); + lower_test("hello_world", "hello_world"); + lower_test("Hello-World", "hello-world"); + } + + #[test] + fn test_upper_case_conversion() { + let upper_test = case_tester(to_upper_case); + upper_test("helloWorld", "HELLOWORLD"); + upper_test("hello world", "HELLO WORLD"); + upper_test("hello_world", "HELLO_WORLD"); + upper_test("Hello-World", "HELLO-WORLD"); + } + + #[test] + fn test_pascal_case_conversion() { + let pascal_test = case_tester(to_pascal_case); + pascal_test("hello world", "HelloWorld"); + pascal_test("Hello World", "HelloWorld"); + pascal_test("hello_world", "HelloWorld"); + pascal_test("HELLO_WORLD", "HelloWorld"); + } + + #[test] + fn test_alternate_case_conversion() { + let alternate_test = case_tester(to_alternate_case); + alternate_test("hello world", "HELLO WORLD"); + alternate_test("Hello World", "hELLO wORLD"); + alternate_test("helLo_woRlD", "HELlO_WOrLd"); + } + + #[test] + fn test_title_case_conversion() { + let title_test = case_tester(to_title_case); + title_test("hello world", "Hello World"); + title_test("Hello World", "Hello World"); + title_test("hello_world", "Hello World"); + title_test("HELLO_WORLD", "Hello World"); + } + + #[test] + fn test_kebab_case_conversion() { + let kebab_test = case_tester(to_kebab_case); + kebab_test("helloWorld", "hello-world"); + kebab_test("HelloWorld", "hello-world"); + kebab_test("hello_world", "hello-world"); + kebab_test("HELLO_WORLD", "hello-world"); + } + + #[test] + fn test_snake_case_conversion() { + let snake_test = case_tester(to_snake_case); + snake_test("helloWorld", "hello_world"); + snake_test("HelloWorld", "hello_world"); + snake_test("hello world", "hello_world"); + snake_test("HELLO WORLD", "hello_world"); + } +} From 9047fafeaeef279d9652e7402da4025ebdaaa47c Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 09:50:35 +0000 Subject: [PATCH 15/55] test: comment out failing tests --- helix-core/src/case_conversion.rs | 65 +++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index f4f1a166b..619293b4b 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -185,6 +185,14 @@ mod tests { camel_test("Hello World", "helloWorld"); camel_test("hello_world", "helloWorld"); camel_test("HELLO_WORLD", "helloWorld"); + camel_test("hello-world", "helloWorld"); + camel_test("hello world", "helloWorld"); + // camel_test(" hello world", "helloWorld"); + camel_test("hello\tworld", "helloWorld"); + camel_test("HELLO WORLD", "helloWorld"); + camel_test("HELLO-world", "helloWorld"); + camel_test("hello WORLD ", "helloWorld"); + // camel_test("helloWorld", "helloWorld"); } #[test] @@ -194,6 +202,14 @@ mod tests { lower_test("HELLO WORLD", "hello world"); lower_test("hello_world", "hello_world"); lower_test("Hello-World", "hello-world"); + lower_test("Hello", "hello"); + lower_test("WORLD", "world"); + lower_test("hello world", "hello world"); + lower_test("HELLOworld", "helloworld"); + lower_test("hello-world", "hello-world"); + lower_test("hello_world_here", "hello_world_here"); + lower_test("HELLO_world", "hello_world"); + lower_test("MixEdCaseString", "mixedcasestring"); } #[test] @@ -203,6 +219,14 @@ mod tests { upper_test("hello world", "HELLO WORLD"); upper_test("hello_world", "HELLO_WORLD"); upper_test("Hello-World", "HELLO-WORLD"); + upper_test("Hello", "HELLO"); + upper_test("world", "WORLD"); + upper_test("hello world", "HELLO WORLD"); + upper_test("helloworld", "HELLOWORLD"); + upper_test("hello-world", "HELLO-WORLD"); + upper_test("hello_world_here", "HELLO_WORLD_HERE"); + upper_test("hello_WORLD", "HELLO_WORLD"); + upper_test("mixedCaseString", "MIXEDCASESTRING"); } #[test] @@ -212,6 +236,14 @@ mod tests { pascal_test("Hello World", "HelloWorld"); pascal_test("hello_world", "HelloWorld"); pascal_test("HELLO_WORLD", "HelloWorld"); + pascal_test("hello-world", "HelloWorld"); + pascal_test("hello world", "HelloWorld"); + pascal_test(" hello world", "HelloWorld"); + pascal_test("hello\tworld", "HelloWorld"); + pascal_test("HELLO WORLD", "HelloWorld"); + pascal_test("HELLO-world", "HelloWorld"); + pascal_test("hello WORLD ", "HelloWorld"); + // pascal_test("helloWorld", "HelloWorld"); } #[test] @@ -220,6 +252,15 @@ mod tests { alternate_test("hello world", "HELLO WORLD"); alternate_test("Hello World", "hELLO wORLD"); alternate_test("helLo_woRlD", "HELlO_WOrLd"); + alternate_test("HELLO_world", "hello_WORLD"); + alternate_test("hello-world", "HELLO-WORLD"); + alternate_test("Hello-world", "hELLO-WORLD"); + alternate_test("hello", "HELLO"); + alternate_test("HELLO", "hello"); + alternate_test("hello123", "HELLO123"); + alternate_test("hello WORLD", "HELLO world"); + alternate_test("HELLO123 world", "hello123 WORLD"); + alternate_test("world hello", "WORLD HELLO"); } #[test] @@ -229,6 +270,14 @@ mod tests { title_test("Hello World", "Hello World"); title_test("hello_world", "Hello World"); title_test("HELLO_WORLD", "Hello World"); + title_test("hello-world", "Hello World"); + // title_test("hello world", "Hello World"); + title_test(" hello world", "Hello World"); + title_test("hello\tworld", "Hello World"); + // title_test("HELLO WORLD", "Hello World"); + title_test("HELLO-world", "Hello World"); + // title_test("hello WORLD ", "Hello World"); + // title_test("helloWorld", "Hello World"); } #[test] @@ -238,6 +287,14 @@ mod tests { kebab_test("HelloWorld", "hello-world"); kebab_test("hello_world", "hello-world"); kebab_test("HELLO_WORLD", "hello-world"); + kebab_test("hello-world", "hello-world"); + kebab_test("hello world", "hello-world"); + kebab_test("hello\tworld", "hello-world"); + kebab_test("HELLO WORLD", "hello-world"); + kebab_test("HELLO-world", "hello-world"); + kebab_test("hello WORLD ", "hello-world"); + kebab_test("helloWorld", "hello-world"); + kebab_test("HelloWorld123", "hello-world123"); } #[test] @@ -247,5 +304,13 @@ mod tests { snake_test("HelloWorld", "hello_world"); snake_test("hello world", "hello_world"); snake_test("HELLO WORLD", "hello_world"); + snake_test("hello-world", "hello_world"); + snake_test("hello world", "hello_world"); + snake_test("hello\tworld", "hello_world"); + snake_test("HELLO WORLD", "hello_world"); + snake_test("HELLO-world", "hello_world"); + snake_test("hello WORLD ", "hello_world"); + snake_test("helloWorld", "hello_world"); + // snake_test("HELLOworld123", "hello_world123"); } } From 63161cee218cfd8a7e14049ddb7a4bf8d75fa7d4 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 10:27:40 +0000 Subject: [PATCH 16/55] fix: incorrect test --- helix-core/src/case_conversion.rs | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 619293b4b..2cd13f9e7 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -99,15 +99,12 @@ pub fn to_case_with_separator( buf: &mut Tendril, separator: char, ) { - let mut prev_is_lowercase = false; // Tracks if the previous character was lowercase - let mut prev_is_alphanumeric = false; // Tracks if the previous character was alphanumeric + let mut prev_is_lowercase = false; + let mut prev_is_alphanumeric = false; for c in text { if c.is_alphanumeric() { - if prev_is_lowercase && c.is_uppercase() { - buf.push(separator); - } - if !prev_is_alphanumeric && !buf.is_empty() { + if prev_is_lowercase && c.is_uppercase() || !prev_is_alphanumeric && !buf.is_empty() { buf.push(separator); } @@ -311,6 +308,6 @@ mod tests { snake_test("HELLO-world", "hello_world"); snake_test("hello WORLD ", "hello_world"); snake_test("helloWorld", "hello_world"); - // snake_test("HELLOworld123", "hello_world123"); + snake_test("helloWORLD123", "hello_world123"); } } From 1df5cb6c0d42fb8e6d6b7fd812950db5ddd54b68 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 10:31:09 +0000 Subject: [PATCH 17/55] fix: add separator on case change --- helix-core/src/case_conversion.rs | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 2cd13f9e7..0fb32bb83 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -144,17 +144,23 @@ pub fn to_camel_or_pascal_case_with( is_pascal: bool, ) { let mut capitalize_next = is_pascal; + let mut prev_is_lowercase = false; for c in text { if c.is_alphanumeric() { + if prev_is_lowercase && c.is_uppercase() { + capitalize_next = true; + } if capitalize_next { buf.extend(c.to_uppercase()); capitalize_next = false; } else { buf.extend(c.to_lowercase()); } + prev_is_lowercase = c.is_lowercase(); } else { capitalize_next = true; + prev_is_lowercase = false; } } } @@ -240,7 +246,7 @@ mod tests { pascal_test("HELLO WORLD", "HelloWorld"); pascal_test("HELLO-world", "HelloWorld"); pascal_test("hello WORLD ", "HelloWorld"); - // pascal_test("helloWorld", "HelloWorld"); + pascal_test("helloWorld", "HelloWorld"); } #[test] From 3cab65f330d02749c708a6fee2fdccd43ebd2504 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 10:33:59 +0000 Subject: [PATCH 18/55] fix: ignore leading whitespaces --- helix-core/src/case_conversion.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 0fb32bb83..58c6f8ecb 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -75,7 +75,7 @@ pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { let mut capitalize_next = true; let mut prev_is_lowercase = false; - for c in text { + for c in text.skip_while(|ch| ch.is_whitespace()) { if c.is_alphanumeric() { if capitalize_next || (prev_is_lowercase && c.is_uppercase()) { buf.extend(c.to_uppercase()); @@ -102,7 +102,7 @@ pub fn to_case_with_separator( let mut prev_is_lowercase = false; let mut prev_is_alphanumeric = false; - for c in text { + for c in text.skip_while(|ch| ch.is_whitespace()) { if c.is_alphanumeric() { if prev_is_lowercase && c.is_uppercase() || !prev_is_alphanumeric && !buf.is_empty() { buf.push(separator); @@ -146,7 +146,7 @@ pub fn to_camel_or_pascal_case_with( let mut capitalize_next = is_pascal; let mut prev_is_lowercase = false; - for c in text { + for c in text.skip_while(|ch| ch.is_whitespace()) { if c.is_alphanumeric() { if prev_is_lowercase && c.is_uppercase() { capitalize_next = true; @@ -190,12 +190,12 @@ mod tests { camel_test("HELLO_WORLD", "helloWorld"); camel_test("hello-world", "helloWorld"); camel_test("hello world", "helloWorld"); - // camel_test(" hello world", "helloWorld"); + camel_test(" hello world", "helloWorld"); camel_test("hello\tworld", "helloWorld"); camel_test("HELLO WORLD", "helloWorld"); camel_test("HELLO-world", "helloWorld"); camel_test("hello WORLD ", "helloWorld"); - // camel_test("helloWorld", "helloWorld"); + camel_test("helloWorld", "helloWorld"); } #[test] From 820963cb9008ca491b5e071e6911520a3c8b05fa Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 10:41:02 +0000 Subject: [PATCH 19/55] fix: failing test is now fixed --- helix-core/src/case_conversion.rs | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 58c6f8ecb..734a40b39 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -73,22 +73,24 @@ pub fn to_alternate_case_with(text: impl Iterator, buf: &mut Tendri pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { let mut capitalize_next = true; - let mut prev_is_lowercase = false; + let mut prev: Option = None; for c in text.skip_while(|ch| ch.is_whitespace()) { if c.is_alphanumeric() { - if capitalize_next || (prev_is_lowercase && c.is_uppercase()) { + if capitalize_next || (prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase()) { buf.extend(c.to_uppercase()); capitalize_next = false; } else { buf.extend(c.to_lowercase()); } - prev_is_lowercase = c.is_lowercase(); } else { capitalize_next = true; - prev_is_lowercase = false; - buf.push(' '); + // only if the previous char is not already space + if prev.is_some_and(|p| p != ' ') { + buf.push(' '); + } } + prev = Some(c); } *buf = buf.trim().into(); @@ -274,7 +276,9 @@ mod tests { title_test("hello_world", "Hello World"); title_test("HELLO_WORLD", "Hello World"); title_test("hello-world", "Hello World"); - // title_test("hello world", "Hello World"); + + title_test("hello world", "Hello World"); + title_test(" hello world", "Hello World"); title_test("hello\tworld", "Hello World"); // title_test("HELLO WORLD", "Hello World"); From 3414183ab6914fc22084e12f265df33a795023e9 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 10:43:31 +0000 Subject: [PATCH 20/55] refactor: move functon --- helix-core/src/case_conversion.rs | 56 +++++++++++++++---------------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 734a40b39..c9bec27c9 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -71,6 +71,33 @@ pub fn to_alternate_case_with(text: impl Iterator, buf: &mut Tendri } } +pub fn to_camel_or_pascal_case_with( + text: impl Iterator, + buf: &mut Tendril, + is_pascal: bool, +) { + let mut capitalize_next = is_pascal; + let mut prev_is_lowercase = false; + + for c in text.skip_while(|ch| ch.is_whitespace()) { + if c.is_alphanumeric() { + if prev_is_lowercase && c.is_uppercase() { + capitalize_next = true; + } + if capitalize_next { + buf.extend(c.to_uppercase()); + capitalize_next = false; + } else { + buf.extend(c.to_lowercase()); + } + prev_is_lowercase = c.is_lowercase(); + } else { + capitalize_next = true; + prev_is_lowercase = false; + } + } +} + pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { let mut capitalize_next = true; let mut prev: Option = None; @@ -93,7 +120,7 @@ pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { prev = Some(c); } - *buf = buf.trim().into(); + *buf = buf.trim_end().into(); } pub fn to_case_with_separator( @@ -140,33 +167,6 @@ pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) to_camel_or_pascal_case_with(text, buf, true); } -pub fn to_camel_or_pascal_case_with( - text: impl Iterator, - buf: &mut Tendril, - is_pascal: bool, -) { - let mut capitalize_next = is_pascal; - let mut prev_is_lowercase = false; - - for c in text.skip_while(|ch| ch.is_whitespace()) { - if c.is_alphanumeric() { - if prev_is_lowercase && c.is_uppercase() { - capitalize_next = true; - } - if capitalize_next { - buf.extend(c.to_uppercase()); - capitalize_next = false; - } else { - buf.extend(c.to_lowercase()); - } - prev_is_lowercase = c.is_lowercase(); - } else { - capitalize_next = true; - prev_is_lowercase = false; - } - } -} - #[cfg(test)] mod tests { use super::*; From 79d3e10c5c66b45cb5d00ed7cf09e98480be8884 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 10:52:13 +0000 Subject: [PATCH 21/55] refactor: title camel and pascal into a single function --- helix-core/src/case_conversion.rs | 48 +++++++++++-------------------- 1 file changed, 16 insertions(+), 32 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index c9bec27c9..e3e1a68d5 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -71,17 +71,18 @@ pub fn to_alternate_case_with(text: impl Iterator, buf: &mut Tendri } } -pub fn to_camel_or_pascal_case_with( +pub fn to_camel_or_pascal_or_title_case_with( text: impl Iterator, buf: &mut Tendril, - is_pascal: bool, + capitalize_first: bool, + separator: Option, ) { - let mut capitalize_next = is_pascal; - let mut prev_is_lowercase = false; + let mut capitalize_next = capitalize_first; + let mut prev: Option = None; for c in text.skip_while(|ch| ch.is_whitespace()) { if c.is_alphanumeric() { - if prev_is_lowercase && c.is_uppercase() { + if prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase() { capitalize_next = true; } if capitalize_next { @@ -90,37 +91,16 @@ pub fn to_camel_or_pascal_case_with( } else { buf.extend(c.to_lowercase()); } - prev_is_lowercase = c.is_lowercase(); } else { capitalize_next = true; - prev_is_lowercase = false; - } - } -} - -pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { - let mut capitalize_next = true; - let mut prev: Option = None; - - for c in text.skip_while(|ch| ch.is_whitespace()) { - if c.is_alphanumeric() { - if capitalize_next || (prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase()) { - buf.extend(c.to_uppercase()); - capitalize_next = false; - } else { - buf.extend(c.to_lowercase()); - } - } else { - capitalize_next = true; - // only if the previous char is not already space - if prev.is_some_and(|p| p != ' ') { - buf.push(' '); + if let Some(separator) = separator { + if prev.is_some_and(|p| p != separator) { + buf.push(separator); + } } } prev = Some(c); } - - *buf = buf.trim_end().into(); } pub fn to_case_with_separator( @@ -159,12 +139,16 @@ pub fn to_snake_case_with(text: impl Iterator, buf: &mut Tendril) { to_case_with_separator(text, buf, '_'); } +pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { + to_camel_or_pascal_or_title_case_with(text, buf, true, Some(' ')); +} + pub fn to_camel_case_with(text: impl Iterator, buf: &mut Tendril) { - to_camel_or_pascal_case_with(text, buf, false); + to_camel_or_pascal_or_title_case_with(text, buf, false, None); } pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) { - to_camel_or_pascal_case_with(text, buf, true); + to_camel_or_pascal_or_title_case_with(text, buf, true, None); } #[cfg(test)] From 1821000acd6b616c0f906830bc994e8861379aa6 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 11:25:27 +0000 Subject: [PATCH 22/55] refactor: extract common functions --- helix-core/src/case_conversion.rs | 216 +++++++++++++++--------------- 1 file changed, 108 insertions(+), 108 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index e3e1a68d5..5b1f64cc8 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -2,6 +2,114 @@ use crate::Tendril; // todo: should this be grapheme aware? +pub fn to_simple_case_with( + text: impl Iterator, + buf: &mut Tendril, + transform_char: impl Fn(&char) -> char, +) { + for c in text { + buf.push(transform_char(&c)) + } +} + +pub fn to_camel_or_pascal_or_title_case_with( + text: impl Iterator, + buf: &mut Tendril, + capitalize_first: bool, + capitalize_rest: bool, + separator: Option, +) { + let mut capitalize_next = capitalize_first; + let mut prev: Option = None; + + for c in text.skip_while(|ch| ch.is_whitespace()) { + if c.is_alphanumeric() { + if prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase() { + capitalize_next = true; + } + if capitalize_next && capitalize_rest { + buf.push(if capitalize_rest { + c.to_ascii_uppercase() + } else { + c + }); + capitalize_next = false; + } else { + buf.extend(c.to_lowercase()); + } + } else { + capitalize_next = true; + if let Some(separator) = separator { + if prev.is_some_and(|p| p != separator) { + buf.push(separator); + } + } + } + prev = Some(c); + } +} + +pub fn to_case_with_separator( + text: impl Iterator, + buf: &mut Tendril, + separator: char, +) { + let mut prev: Option = None; + + for c in text.skip_while(|ch| ch.is_whitespace()) { + if c.is_alphanumeric() { + if prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase() + || !prev.is_some_and(|p| p.is_alphanumeric()) && !buf.is_empty() + { + buf.push(separator); + } + + buf.push(c.to_ascii_lowercase()); + } + prev = Some(c); + } +} + +pub fn to_alternate_case_with(text: impl Iterator, buf: &mut Tendril) { + to_simple_case_with(text, buf, |c| { + if c.is_uppercase() { + c.to_ascii_lowercase() + } else if c.is_lowercase() { + c.to_ascii_uppercase() + } else { + *c + } + }); +} + +pub fn to_upper_case_with(text: impl Iterator, buf: &mut Tendril) { + to_simple_case_with(text, buf, char::to_ascii_uppercase); +} + +pub fn to_lower_case_with(text: impl Iterator, buf: &mut Tendril) { + to_simple_case_with(text, buf, char::to_ascii_lowercase); +} + +pub fn to_kebab_case_with(text: impl Iterator, buf: &mut Tendril) { + to_case_with_separator(text, buf, '-'); +} + +pub fn to_snake_case_with(text: impl Iterator, buf: &mut Tendril) { + to_case_with_separator(text, buf, '_'); +} + +pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { + to_camel_or_pascal_or_title_case_with(text, buf, true, true, Some(' ')); +} + +pub fn to_camel_case_with(text: impl Iterator, buf: &mut Tendril) { + to_camel_or_pascal_or_title_case_with(text, buf, false, true, None); +} + +pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) { + to_camel_or_pascal_or_title_case_with(text, buf, true, true, None); +} + fn to_case(text: I, to_case_with: fn(I, &mut Tendril)) -> Tendril where I: Iterator, @@ -43,114 +151,6 @@ pub fn to_snake_case(text: impl Iterator) -> Tendril { to_case(text, to_snake_case_with) } -pub fn to_upper_case_with(text: impl Iterator, buf: &mut Tendril) { - for c in text { - for c in c.to_uppercase() { - buf.push(c) - } - } -} - -pub fn to_lower_case_with(text: impl Iterator, buf: &mut Tendril) { - for c in text { - for c in c.to_lowercase() { - buf.push(c) - } - } -} - -pub fn to_alternate_case_with(text: impl Iterator, buf: &mut Tendril) { - for c in text { - if c.is_uppercase() { - buf.extend(c.to_lowercase()) - } else if c.is_lowercase() { - buf.extend(c.to_uppercase()) - } else { - buf.push(c) - } - } -} - -pub fn to_camel_or_pascal_or_title_case_with( - text: impl Iterator, - buf: &mut Tendril, - capitalize_first: bool, - separator: Option, -) { - let mut capitalize_next = capitalize_first; - let mut prev: Option = None; - - for c in text.skip_while(|ch| ch.is_whitespace()) { - if c.is_alphanumeric() { - if prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase() { - capitalize_next = true; - } - if capitalize_next { - buf.extend(c.to_uppercase()); - capitalize_next = false; - } else { - buf.extend(c.to_lowercase()); - } - } else { - capitalize_next = true; - if let Some(separator) = separator { - if prev.is_some_and(|p| p != separator) { - buf.push(separator); - } - } - } - prev = Some(c); - } -} - -pub fn to_case_with_separator( - text: impl Iterator, - buf: &mut Tendril, - separator: char, -) { - let mut prev_is_lowercase = false; - let mut prev_is_alphanumeric = false; - - for c in text.skip_while(|ch| ch.is_whitespace()) { - if c.is_alphanumeric() { - if prev_is_lowercase && c.is_uppercase() || !prev_is_alphanumeric && !buf.is_empty() { - buf.push(separator); - } - - buf.push(c.to_ascii_lowercase()); - prev_is_lowercase = c.is_lowercase(); - prev_is_alphanumeric = true; - } else { - prev_is_lowercase = false; - prev_is_alphanumeric = false; - } - } - - if buf.ends_with(separator) { - buf.pop(); - } -} - -pub fn to_kebab_case_with(text: impl Iterator, buf: &mut Tendril) { - to_case_with_separator(text, buf, '-'); -} - -pub fn to_snake_case_with(text: impl Iterator, buf: &mut Tendril) { - to_case_with_separator(text, buf, '_'); -} - -pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { - to_camel_or_pascal_or_title_case_with(text, buf, true, Some(' ')); -} - -pub fn to_camel_case_with(text: impl Iterator, buf: &mut Tendril) { - to_camel_or_pascal_or_title_case_with(text, buf, false, None); -} - -pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) { - to_camel_or_pascal_or_title_case_with(text, buf, true, None); -} - #[cfg(test)] mod tests { use super::*; From 47826f53a4ef4dfc2f8d023861880b2f5e52dd6a Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 11:32:14 +0000 Subject: [PATCH 23/55] refactor: better function naming --- helix-core/src/case_conversion.rs | 54 ++++++++++++++-------------- helix-core/src/snippets/elaborate.rs | 14 ++++---- 2 files changed, 34 insertions(+), 34 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 5b1f64cc8..d893d1009 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -2,7 +2,7 @@ use crate::Tendril; // todo: should this be grapheme aware? -pub fn to_simple_case_with( +pub fn simple_case_conversion( text: impl Iterator, buf: &mut Tendril, transform_char: impl Fn(&char) -> char, @@ -12,7 +12,7 @@ pub fn to_simple_case_with( } } -pub fn to_camel_or_pascal_or_title_case_with( +pub fn complex_case_conversion( text: impl Iterator, buf: &mut Tendril, capitalize_first: bool, @@ -49,7 +49,7 @@ pub fn to_camel_or_pascal_or_title_case_with( } } -pub fn to_case_with_separator( +pub fn separator_case_conversion( text: impl Iterator, buf: &mut Tendril, separator: char, @@ -70,8 +70,8 @@ pub fn to_case_with_separator( } } -pub fn to_alternate_case_with(text: impl Iterator, buf: &mut Tendril) { - to_simple_case_with(text, buf, |c| { +pub fn into_alternate_case(text: impl Iterator, buf: &mut Tendril) { + simple_case_conversion(text, buf, |c| { if c.is_uppercase() { c.to_ascii_lowercase() } else if c.is_lowercase() { @@ -82,32 +82,32 @@ pub fn to_alternate_case_with(text: impl Iterator, buf: &mut Tendri }); } -pub fn to_upper_case_with(text: impl Iterator, buf: &mut Tendril) { - to_simple_case_with(text, buf, char::to_ascii_uppercase); +pub fn into_upper_case(text: impl Iterator, buf: &mut Tendril) { + simple_case_conversion(text, buf, char::to_ascii_uppercase); } -pub fn to_lower_case_with(text: impl Iterator, buf: &mut Tendril) { - to_simple_case_with(text, buf, char::to_ascii_lowercase); +pub fn into_lower_case(text: impl Iterator, buf: &mut Tendril) { + simple_case_conversion(text, buf, char::to_ascii_lowercase); } -pub fn to_kebab_case_with(text: impl Iterator, buf: &mut Tendril) { - to_case_with_separator(text, buf, '-'); +pub fn into_kebab_case(text: impl Iterator, buf: &mut Tendril) { + separator_case_conversion(text, buf, '-'); } -pub fn to_snake_case_with(text: impl Iterator, buf: &mut Tendril) { - to_case_with_separator(text, buf, '_'); +pub fn into_snake_case(text: impl Iterator, buf: &mut Tendril) { + separator_case_conversion(text, buf, '_'); } -pub fn to_title_case_with(text: impl Iterator, buf: &mut Tendril) { - to_camel_or_pascal_or_title_case_with(text, buf, true, true, Some(' ')); +pub fn into_title_case(text: impl Iterator, buf: &mut Tendril) { + complex_case_conversion(text, buf, true, true, Some(' ')); } -pub fn to_camel_case_with(text: impl Iterator, buf: &mut Tendril) { - to_camel_or_pascal_or_title_case_with(text, buf, false, true, None); +pub fn into_camel_case(text: impl Iterator, buf: &mut Tendril) { + complex_case_conversion(text, buf, false, true, None); } -pub fn to_pascal_case_with(text: impl Iterator, buf: &mut Tendril) { - to_camel_or_pascal_or_title_case_with(text, buf, true, true, None); +pub fn into_pascal_case(text: impl Iterator, buf: &mut Tendril) { + complex_case_conversion(text, buf, true, true, None); } fn to_case(text: I, to_case_with: fn(I, &mut Tendril)) -> Tendril @@ -120,35 +120,35 @@ where } pub fn to_camel_case(text: impl Iterator) -> Tendril { - to_case(text, to_camel_case_with) + to_case(text, into_camel_case) } pub fn to_lower_case(text: impl Iterator) -> Tendril { - to_case(text, to_lower_case_with) + to_case(text, into_lower_case) } pub fn to_upper_case(text: impl Iterator) -> Tendril { - to_case(text, to_upper_case_with) + to_case(text, into_upper_case) } pub fn to_pascal_case(text: impl Iterator) -> Tendril { - to_case(text, to_pascal_case_with) + to_case(text, into_pascal_case) } pub fn to_alternate_case(text: impl Iterator) -> Tendril { - to_case(text, to_alternate_case_with) + to_case(text, into_alternate_case) } pub fn to_title_case(text: impl Iterator) -> Tendril { - to_case(text, to_title_case_with) + to_case(text, into_title_case) } pub fn to_kebab_case(text: impl Iterator) -> Tendril { - to_case(text, to_kebab_case_with) + to_case(text, into_kebab_case) } pub fn to_snake_case(text: impl Iterator) -> Tendril { - to_case(text, to_snake_case_with) + to_case(text, into_snake_case) } #[cfg(test)] diff --git a/helix-core/src/snippets/elaborate.rs b/helix-core/src/snippets/elaborate.rs index 012d1db77..0ae5e4adf 100644 --- a/helix-core/src/snippets/elaborate.rs +++ b/helix-core/src/snippets/elaborate.rs @@ -10,9 +10,9 @@ use regex_cursor::engines::meta::Regex; use regex_cursor::regex_automata::util::syntax::Config as RegexConfig; use ropey::RopeSlice; -use crate::case_conversion::to_lower_case_with; -use crate::case_conversion::to_upper_case_with; -use crate::case_conversion::{to_camel_case_with, to_pascal_case_with}; +use crate::case_conversion::into_lower_case; +use crate::case_conversion::into_upper_case; +use crate::case_conversion::{into_camel_case, into_pascal_case}; use crate::snippets::parser::{self, CaseChange, FormatItem}; use crate::snippets::{TabstopIdx, LAST_TABSTOP_IDX}; use crate::Tendril; @@ -348,15 +348,15 @@ impl Transform { if let Some(cap) = cap.get_group(i).filter(|i| !i.is_empty()) { let mut chars = doc.byte_slice(cap.range()).chars(); match change { - CaseChange::Upcase => to_upper_case_with(chars, &mut buf), - CaseChange::Downcase => to_lower_case_with(chars, &mut buf), + CaseChange::Upcase => into_upper_case(chars, &mut buf), + CaseChange::Downcase => into_lower_case(chars, &mut buf), CaseChange::Capitalize => { let first_char = chars.next().unwrap(); buf.extend(first_char.to_uppercase()); buf.extend(chars); } - CaseChange::PascalCase => to_pascal_case_with(chars, &mut buf), - CaseChange::CamelCase => to_camel_case_with(chars, &mut buf), + CaseChange::PascalCase => into_pascal_case(chars, &mut buf), + CaseChange::CamelCase => into_camel_case(chars, &mut buf), } } } From fc199e3d8c1130c2d7ed19bf47056f1478263179 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 11:37:14 +0000 Subject: [PATCH 24/55] refactor: remove unnecessary parameter --- helix-core/src/case_conversion.rs | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index d893d1009..751970d83 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -2,6 +2,7 @@ use crate::Tendril; // todo: should this be grapheme aware? +/// Converts each character into a different one, with zero context about surrounding characters pub fn simple_case_conversion( text: impl Iterator, buf: &mut Tendril, @@ -16,7 +17,6 @@ pub fn complex_case_conversion( text: impl Iterator, buf: &mut Tendril, capitalize_first: bool, - capitalize_rest: bool, separator: Option, ) { let mut capitalize_next = capitalize_first; @@ -27,12 +27,8 @@ pub fn complex_case_conversion( if prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase() { capitalize_next = true; } - if capitalize_next && capitalize_rest { - buf.push(if capitalize_rest { - c.to_ascii_uppercase() - } else { - c - }); + if capitalize_next { + buf.push(c.to_ascii_uppercase()); capitalize_next = false; } else { buf.extend(c.to_lowercase()); @@ -99,15 +95,15 @@ pub fn into_snake_case(text: impl Iterator, buf: &mut Tendril) { } pub fn into_title_case(text: impl Iterator, buf: &mut Tendril) { - complex_case_conversion(text, buf, true, true, Some(' ')); + complex_case_conversion(text, buf, true, Some(' ')); } pub fn into_camel_case(text: impl Iterator, buf: &mut Tendril) { - complex_case_conversion(text, buf, false, true, None); + complex_case_conversion(text, buf, false, None); } pub fn into_pascal_case(text: impl Iterator, buf: &mut Tendril) { - complex_case_conversion(text, buf, true, true, None); + complex_case_conversion(text, buf, true, None); } fn to_case(text: I, to_case_with: fn(I, &mut Tendril)) -> Tendril From efab176b06ccf7fc787e7b909283fe070310780c Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 11:44:06 +0000 Subject: [PATCH 25/55] docs: document new case conversion static commands --- book/src/generated/static-cmd.md | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/book/src/generated/static-cmd.md b/book/src/generated/static-cmd.md index af7515b8e..da9117d6b 100644 --- a/book/src/generated/static-cmd.md +++ b/book/src/generated/static-cmd.md @@ -53,9 +53,14 @@ | `extend_prev_char` | Extend to previous occurrence of char | select: `` F `` | | `repeat_last_motion` | Repeat last motion | normal: `` ``, select: `` `` | | `replace` | Replace with new char | normal: `` r ``, select: `` r `` | -| `switch_case` | Switch (toggle) case | normal: `` ~ ``, select: `` ~ `` | -| `switch_to_uppercase` | Switch to uppercase | normal: `` ``, select: `` `` | -| `switch_to_lowercase` | Switch to lowercase | normal: `` ` ``, select: `` ` `` | +| `switch_to_alternate_case` | Switch to aLTERNATE cASE | normal: `` ~ ``, select: `` ~ `` | +| `switch_to_upper_case` | Switch to UPPERCASE | normal: `` `u ``, select: `` `u `` | +| `switch_to_lower_case` | Switch to lowercase | normal: `` `l ``, select: `` `l `` | +| `switch_to_pascal_case` | Switch to PascalCase | normal: `` `p ``, select: `` `p `` | +| `switch_to_camel_case` | Switch to camelCase | normal: `` `c ``, select: `` `c `` | +| `switch_to_title_case` | Switch to Title Case | normal: `` `t ``, select: `` `t `` | +| `switch_to_snake_case` | Switch to snake_case | normal: `` `s ``, select: `` `s `` | +| `switch_to_kebab_case` | Switch to kebab-case | normal: `` `k ``, select: `` `k `` | | `page_up` | Move page up | normal: `` ``, `` Z ``, `` z ``, `` ``, `` Z ``, `` z ``, select: `` ``, `` Z ``, `` z ``, `` ``, `` Z ``, `` z ``, insert: `` `` | | `page_down` | Move page down | normal: `` ``, `` Z ``, `` z ``, `` ``, `` Z ``, `` z ``, select: `` ``, `` Z ``, `` z ``, `` ``, `` Z ``, `` z ``, insert: `` `` | | `half_page_up` | Move half page up | | From 58177afb2a666a49b800434bafb157bca1ee0837 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 11:55:37 +0000 Subject: [PATCH 26/55] refactor: remove complex test helper definition, use for loop instead --- helix-core/src/case_conversion.rs | 262 ++++++++++++++++-------------- 1 file changed, 144 insertions(+), 118 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 751970d83..320bdbdbc 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -151,153 +151,179 @@ pub fn to_snake_case(text: impl Iterator) -> Tendril { mod tests { use super::*; - fn case_tester<'a, F>(change_fn: F) -> impl Fn(&'a str, &'a str) + 'a - where - F: Fn(std::str::Chars<'a>) -> Tendril + 'a, - { - move |input: &str, expected: &str| { - let transformed = change_fn(input.chars()); - let m = transformed.to_string(); - dbg!(input); - assert_eq!(m.as_str(), expected) + #[test] + fn test_camel_case_conversion() { + let tests = [ + ("hello world", "helloWorld"), + ("Hello World", "helloWorld"), + ("hello_world", "helloWorld"), + ("HELLO_WORLD", "helloWorld"), + ("hello-world", "helloWorld"), + ("hello world", "helloWorld"), + (" hello world", "helloWorld"), + ("hello\tworld", "helloWorld"), + ("HELLO WORLD", "helloWorld"), + ("HELLO-world", "helloWorld"), + ("hello WORLD ", "helloWorld"), + ("helloWorld", "helloWorld"), + ]; + + for (input, expected) in tests { + assert_eq!(to_camel_case(input.chars()), expected) } } - #[test] - fn test_camel_case_conversion() { - let camel_test = case_tester(to_camel_case); - camel_test("hello world", "helloWorld"); - camel_test("Hello World", "helloWorld"); - camel_test("hello_world", "helloWorld"); - camel_test("HELLO_WORLD", "helloWorld"); - camel_test("hello-world", "helloWorld"); - camel_test("hello world", "helloWorld"); - camel_test(" hello world", "helloWorld"); - camel_test("hello\tworld", "helloWorld"); - camel_test("HELLO WORLD", "helloWorld"); - camel_test("HELLO-world", "helloWorld"); - camel_test("hello WORLD ", "helloWorld"); - camel_test("helloWorld", "helloWorld"); - } - #[test] fn test_lower_case_conversion() { - let lower_test = case_tester(to_lower_case); - lower_test("HelloWorld", "helloworld"); - lower_test("HELLO WORLD", "hello world"); - lower_test("hello_world", "hello_world"); - lower_test("Hello-World", "hello-world"); - lower_test("Hello", "hello"); - lower_test("WORLD", "world"); - lower_test("hello world", "hello world"); - lower_test("HELLOworld", "helloworld"); - lower_test("hello-world", "hello-world"); - lower_test("hello_world_here", "hello_world_here"); - lower_test("HELLO_world", "hello_world"); - lower_test("MixEdCaseString", "mixedcasestring"); + let tests = [ + ("HelloWorld", "helloworld"), + ("HELLO WORLD", "hello world"), + ("hello_world", "hello_world"), + ("Hello-World", "hello-world"), + ("Hello", "hello"), + ("WORLD", "world"), + ("hello world", "hello world"), + ("HELLOworld", "helloworld"), + ("hello-world", "hello-world"), + ("hello_world_here", "hello_world_here"), + ("HELLO_world", "hello_world"), + ("MixEdCaseString", "mixedcasestring"), + ]; + + for (input, expected) in tests { + assert_eq!(to_lower_case(input.chars()), expected) + } } #[test] fn test_upper_case_conversion() { - let upper_test = case_tester(to_upper_case); - upper_test("helloWorld", "HELLOWORLD"); - upper_test("hello world", "HELLO WORLD"); - upper_test("hello_world", "HELLO_WORLD"); - upper_test("Hello-World", "HELLO-WORLD"); - upper_test("Hello", "HELLO"); - upper_test("world", "WORLD"); - upper_test("hello world", "HELLO WORLD"); - upper_test("helloworld", "HELLOWORLD"); - upper_test("hello-world", "HELLO-WORLD"); - upper_test("hello_world_here", "HELLO_WORLD_HERE"); - upper_test("hello_WORLD", "HELLO_WORLD"); - upper_test("mixedCaseString", "MIXEDCASESTRING"); + let tests = [ + ("helloWorld", "HELLOWORLD"), + ("hello world", "HELLO WORLD"), + ("hello_world", "HELLO_WORLD"), + ("Hello-World", "HELLO-WORLD"), + ("Hello", "HELLO"), + ("world", "WORLD"), + ("hello world", "HELLO WORLD"), + ("helloworld", "HELLOWORLD"), + ("hello-world", "HELLO-WORLD"), + ("hello_world_here", "HELLO_WORLD_HERE"), + ("hello_WORLD", "HELLO_WORLD"), + ("mixedCaseString", "MIXEDCASESTRING"), + ]; + + for (input, expected) in tests { + assert_eq!(to_upper_case(input.chars()), expected) + } } #[test] fn test_pascal_case_conversion() { - let pascal_test = case_tester(to_pascal_case); - pascal_test("hello world", "HelloWorld"); - pascal_test("Hello World", "HelloWorld"); - pascal_test("hello_world", "HelloWorld"); - pascal_test("HELLO_WORLD", "HelloWorld"); - pascal_test("hello-world", "HelloWorld"); - pascal_test("hello world", "HelloWorld"); - pascal_test(" hello world", "HelloWorld"); - pascal_test("hello\tworld", "HelloWorld"); - pascal_test("HELLO WORLD", "HelloWorld"); - pascal_test("HELLO-world", "HelloWorld"); - pascal_test("hello WORLD ", "HelloWorld"); - pascal_test("helloWorld", "HelloWorld"); + let tests = [ + ("hello world", "HelloWorld"), + ("Hello World", "HelloWorld"), + ("hello_world", "HelloWorld"), + ("HELLO_WORLD", "HelloWorld"), + ("hello-world", "HelloWorld"), + ("hello world", "HelloWorld"), + (" hello world", "HelloWorld"), + ("hello\tworld", "HelloWorld"), + ("HELLO WORLD", "HelloWorld"), + ("HELLO-world", "HelloWorld"), + ("hello WORLD ", "HelloWorld"), + ("helloWorld", "HelloWorld"), + ]; + + for (input, expected) in tests { + assert_eq!(to_pascal_case(input.chars()), expected) + } } #[test] fn test_alternate_case_conversion() { - let alternate_test = case_tester(to_alternate_case); - alternate_test("hello world", "HELLO WORLD"); - alternate_test("Hello World", "hELLO wORLD"); - alternate_test("helLo_woRlD", "HELlO_WOrLd"); - alternate_test("HELLO_world", "hello_WORLD"); - alternate_test("hello-world", "HELLO-WORLD"); - alternate_test("Hello-world", "hELLO-WORLD"); - alternate_test("hello", "HELLO"); - alternate_test("HELLO", "hello"); - alternate_test("hello123", "HELLO123"); - alternate_test("hello WORLD", "HELLO world"); - alternate_test("HELLO123 world", "hello123 WORLD"); - alternate_test("world hello", "WORLD HELLO"); + let tests = [ + ("hello world", "HELLO WORLD"), + ("Hello World", "hELLO wORLD"), + ("helLo_woRlD", "HELlO_WOrLd"), + ("HELLO_world", "hello_WORLD"), + ("hello-world", "HELLO-WORLD"), + ("Hello-world", "hELLO-WORLD"), + ("hello", "HELLO"), + ("HELLO", "hello"), + ("hello123", "HELLO123"), + ("hello WORLD", "HELLO world"), + ("HELLO123 world", "hello123 WORLD"), + ("world hello", "WORLD HELLO"), + ]; + + for (input, expected) in tests { + assert_eq!(to_alternate_case(input.chars()), expected) + } } #[test] fn test_title_case_conversion() { - let title_test = case_tester(to_title_case); - title_test("hello world", "Hello World"); - title_test("Hello World", "Hello World"); - title_test("hello_world", "Hello World"); - title_test("HELLO_WORLD", "Hello World"); - title_test("hello-world", "Hello World"); + let tests = [ + ("hello world", "Hello World"), + ("Hello World", "Hello World"), + ("hello_world", "Hello World"), + ("HELLO_WORLD", "Hello World"), + ("hello-world", "Hello World"), + ("hello world", "Hello World"), + (" hello world", "Hello World"), + ("hello\tworld", "Hello World"), + // ("HELLO WORLD", "Hello World"), + ("HELLO-world", "Hello World"), + // ("hello WORLD ", "Hello World"), + // ("helloWorld", "Hello World"), + ]; - title_test("hello world", "Hello World"); - - title_test(" hello world", "Hello World"); - title_test("hello\tworld", "Hello World"); - // title_test("HELLO WORLD", "Hello World"); - title_test("HELLO-world", "Hello World"); - // title_test("hello WORLD ", "Hello World"); - // title_test("helloWorld", "Hello World"); + for (input, expected) in tests { + assert_eq!(to_title_case(input.chars()), expected) + } } #[test] fn test_kebab_case_conversion() { - let kebab_test = case_tester(to_kebab_case); - kebab_test("helloWorld", "hello-world"); - kebab_test("HelloWorld", "hello-world"); - kebab_test("hello_world", "hello-world"); - kebab_test("HELLO_WORLD", "hello-world"); - kebab_test("hello-world", "hello-world"); - kebab_test("hello world", "hello-world"); - kebab_test("hello\tworld", "hello-world"); - kebab_test("HELLO WORLD", "hello-world"); - kebab_test("HELLO-world", "hello-world"); - kebab_test("hello WORLD ", "hello-world"); - kebab_test("helloWorld", "hello-world"); - kebab_test("HelloWorld123", "hello-world123"); + let tests = [ + ("helloWorld", "hello-world"), + ("HelloWorld", "hello-world"), + ("hello_world", "hello-world"), + ("HELLO_WORLD", "hello-world"), + ("hello-world", "hello-world"), + ("hello world", "hello-world"), + ("hello\tworld", "hello-world"), + ("HELLO WORLD", "hello-world"), + ("HELLO-world", "hello-world"), + ("hello WORLD ", "hello-world"), + ("helloWorld", "hello-world"), + ("HelloWorld123", "hello-world123"), + ]; + + for (input, expected) in tests { + assert_eq!(to_kebab_case(input.chars()), expected) + } } #[test] fn test_snake_case_conversion() { - let snake_test = case_tester(to_snake_case); - snake_test("helloWorld", "hello_world"); - snake_test("HelloWorld", "hello_world"); - snake_test("hello world", "hello_world"); - snake_test("HELLO WORLD", "hello_world"); - snake_test("hello-world", "hello_world"); - snake_test("hello world", "hello_world"); - snake_test("hello\tworld", "hello_world"); - snake_test("HELLO WORLD", "hello_world"); - snake_test("HELLO-world", "hello_world"); - snake_test("hello WORLD ", "hello_world"); - snake_test("helloWorld", "hello_world"); - snake_test("helloWORLD123", "hello_world123"); + let tests = [ + ("helloWorld", "hello_world"), + ("HelloWorld", "hello_world"), + ("hello world", "hello_world"), + ("HELLO WORLD", "hello_world"), + ("hello-world", "hello_world"), + ("hello world", "hello_world"), + ("hello\tworld", "hello_world"), + ("HELLO WORLD", "hello_world"), + ("HELLO-world", "hello_world"), + ("hello WORLD ", "hello_world"), + ("helloWorld", "hello_world"), + ("helloWORLD123", "hello_world123"), + ]; + + for (input, expected) in tests { + assert_eq!(to_snake_case(input.chars()), expected) + } } } From 28b77e2ae342a31982c8d45a7745fcda0dfb53c3 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 12:04:48 +0000 Subject: [PATCH 27/55] fix: trim leading whitespace --- helix-core/src/case_conversion.rs | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 320bdbdbc..6e37cded6 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -43,6 +43,8 @@ pub fn complex_case_conversion( } prev = Some(c); } + + *buf = buf.trim_end().into(); } pub fn separator_case_conversion( @@ -264,21 +266,22 @@ mod tests { #[test] fn test_title_case_conversion() { let tests = [ - ("hello world", "Hello World"), - ("Hello World", "Hello World"), - ("hello_world", "Hello World"), - ("HELLO_WORLD", "Hello World"), - ("hello-world", "Hello World"), - ("hello world", "Hello World"), - (" hello world", "Hello World"), - ("hello\tworld", "Hello World"), + // ("hello world", "Hello World"), + // ("Hello World", "Hello World"), + // ("hello_world", "Hello World"), + // ("HELLO_WORLD", "Hello World"), + // ("hello-world", "Hello World"), + // ("hello world", "Hello World"), + // (" hello world", "Hello World"), + // ("hello\tworld", "Hello World"), // ("HELLO WORLD", "Hello World"), - ("HELLO-world", "Hello World"), - // ("hello WORLD ", "Hello World"), + // ("HELLO-world", "Hello World"), + ("hello WORLD ", "Hello World"), // ("helloWorld", "Hello World"), ]; for (input, expected) in tests { + dbg!(input); assert_eq!(to_title_case(input.chars()), expected) } } From d4e4049ab76fa8a6e6f3c7dd68b43bc19d969394 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 12:10:05 +0000 Subject: [PATCH 28/55] fix: add extra separator character if at camelCase boundary --- helix-core/src/case_conversion.rs | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 6e37cded6..3a122ac4e 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -24,6 +24,14 @@ pub fn complex_case_conversion( for c in text.skip_while(|ch| ch.is_whitespace()) { if c.is_alphanumeric() { + if let Some(separator) = separator { + if prev.is_some_and(|p| p != separator) + && prev.is_some_and(|p| p.is_lowercase()) + && c.is_uppercase() + { + buf.push(separator); + } + } if prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase() { capitalize_next = true; } @@ -266,18 +274,18 @@ mod tests { #[test] fn test_title_case_conversion() { let tests = [ - // ("hello world", "Hello World"), - // ("Hello World", "Hello World"), - // ("hello_world", "Hello World"), - // ("HELLO_WORLD", "Hello World"), - // ("hello-world", "Hello World"), - // ("hello world", "Hello World"), - // (" hello world", "Hello World"), - // ("hello\tworld", "Hello World"), - // ("HELLO WORLD", "Hello World"), - // ("HELLO-world", "Hello World"), + ("hello world", "Hello World"), + ("Hello World", "Hello World"), + ("hello_world", "Hello World"), + ("HELLO_WORLD", "Hello World"), + ("hello-world", "Hello World"), + ("hello world", "Hello World"), + (" hello world", "Hello World"), + ("hello\tworld", "Hello World"), + ("HELLO WORLD", "Hello World"), + ("HELLO-world", "Hello World"), ("hello WORLD ", "Hello World"), - // ("helloWorld", "Hello World"), + ("helloWorld", "Hello World"), ]; for (input, expected) in tests { From ef2b035e015bd29a60ebe929a450221738fc800b Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 12:23:53 +0000 Subject: [PATCH 29/55] refactor: increase readability split logic into variables and add comments --- helix-core/src/case_conversion.rs | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 3a122ac4e..7b0426b55 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -63,15 +63,23 @@ pub fn separator_case_conversion( let mut prev: Option = None; for c in text.skip_while(|ch| ch.is_whitespace()) { - if c.is_alphanumeric() { - if prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase() - || !prev.is_some_and(|p| p.is_alphanumeric()) && !buf.is_empty() - { - buf.push(separator); - } - - buf.push(c.to_ascii_lowercase()); + if !c.is_alphanumeric() { + prev = Some(c); + continue; } + + // "camelCase" => transition at 'l' -> 'C' + let has_camel_transition = prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase(); + // "email@somewhere" => transition at 'l' -> '@' + // first character must not be separator, e.g. @emailSomewhere should not become -email-somewhere + let has_alphanum_transition = !prev.is_some_and(|p| p.is_alphanumeric()) && !buf.is_empty(); + + if has_camel_transition || has_alphanum_transition { + buf.push(separator); + } + + buf.push(c.to_ascii_lowercase()); + prev = Some(c); } } From e6da544a71664633f7a0256dfa8c59cab01ac709 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 12:26:05 +0000 Subject: [PATCH 30/55] refactor: variable name --- helix-core/src/case_conversion.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 7b0426b55..99096f8d8 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -19,7 +19,7 @@ pub fn complex_case_conversion( capitalize_first: bool, separator: Option, ) { - let mut capitalize_next = capitalize_first; + let mut should_capitalize_current = capitalize_first; let mut prev: Option = None; for c in text.skip_while(|ch| ch.is_whitespace()) { @@ -33,16 +33,16 @@ pub fn complex_case_conversion( } } if prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase() { - capitalize_next = true; + should_capitalize_current = true; } - if capitalize_next { + if should_capitalize_current { buf.push(c.to_ascii_uppercase()); - capitalize_next = false; + should_capitalize_current = false; } else { buf.extend(c.to_lowercase()); } } else { - capitalize_next = true; + should_capitalize_current = true; if let Some(separator) = separator { if prev.is_some_and(|p| p != separator) { buf.push(separator); From f8b9497dbc779872379e54895988467846236f5d Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 12:31:07 +0000 Subject: [PATCH 31/55] feat: do not introduce breaking changes --- helix-core/src/case_conversion.rs | 16 ++++++++-------- helix-core/src/snippets/elaborate.rs | 8 ++++---- helix-term/src/commands.rs | 20 ++++++++++---------- helix-term/src/keymap/default.rs | 6 +++--- 4 files changed, 25 insertions(+), 25 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 99096f8d8..070b6e821 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -96,11 +96,11 @@ pub fn into_alternate_case(text: impl Iterator, buf: &mut Tendril) }); } -pub fn into_upper_case(text: impl Iterator, buf: &mut Tendril) { +pub fn into_uppercase(text: impl Iterator, buf: &mut Tendril) { simple_case_conversion(text, buf, char::to_ascii_uppercase); } -pub fn into_lower_case(text: impl Iterator, buf: &mut Tendril) { +pub fn into_lowercase(text: impl Iterator, buf: &mut Tendril) { simple_case_conversion(text, buf, char::to_ascii_lowercase); } @@ -137,12 +137,12 @@ pub fn to_camel_case(text: impl Iterator) -> Tendril { to_case(text, into_camel_case) } -pub fn to_lower_case(text: impl Iterator) -> Tendril { - to_case(text, into_lower_case) +pub fn to_lowercase(text: impl Iterator) -> Tendril { + to_case(text, into_lowercase) } -pub fn to_upper_case(text: impl Iterator) -> Tendril { - to_case(text, into_upper_case) +pub fn to_uppercase(text: impl Iterator) -> Tendril { + to_case(text, into_uppercase) } pub fn to_pascal_case(text: impl Iterator) -> Tendril { @@ -209,7 +209,7 @@ mod tests { ]; for (input, expected) in tests { - assert_eq!(to_lower_case(input.chars()), expected) + assert_eq!(to_lowercase(input.chars()), expected) } } @@ -231,7 +231,7 @@ mod tests { ]; for (input, expected) in tests { - assert_eq!(to_upper_case(input.chars()), expected) + assert_eq!(to_uppercase(input.chars()), expected) } } diff --git a/helix-core/src/snippets/elaborate.rs b/helix-core/src/snippets/elaborate.rs index 0ae5e4adf..fae46706f 100644 --- a/helix-core/src/snippets/elaborate.rs +++ b/helix-core/src/snippets/elaborate.rs @@ -10,8 +10,8 @@ use regex_cursor::engines::meta::Regex; use regex_cursor::regex_automata::util::syntax::Config as RegexConfig; use ropey::RopeSlice; -use crate::case_conversion::into_lower_case; -use crate::case_conversion::into_upper_case; +use crate::case_conversion::into_lowercase; +use crate::case_conversion::into_uppercase; use crate::case_conversion::{into_camel_case, into_pascal_case}; use crate::snippets::parser::{self, CaseChange, FormatItem}; use crate::snippets::{TabstopIdx, LAST_TABSTOP_IDX}; @@ -348,8 +348,8 @@ impl Transform { if let Some(cap) = cap.get_group(i).filter(|i| !i.is_empty()) { let mut chars = doc.byte_slice(cap.range()).chars(); match change { - CaseChange::Upcase => into_upper_case(chars, &mut buf), - CaseChange::Downcase => into_lower_case(chars, &mut buf), + CaseChange::Upcase => into_uppercase(chars, &mut buf), + CaseChange::Downcase => into_lowercase(chars, &mut buf), CaseChange::Capitalize => { let first_char = chars.next().unwrap(); buf.extend(first_char.to_uppercase()); diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 4e321a808..6c1075ac7 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -19,8 +19,8 @@ pub use typed::*; use helix_core::{ case_conversion::{ - to_alternate_case, to_camel_case, to_kebab_case, to_lower_case, to_pascal_case, - to_snake_case, to_title_case, to_upper_case, + to_alternate_case, to_camel_case, to_kebab_case, to_lowercase, to_pascal_case, + to_snake_case, to_title_case, to_uppercase, }, char_idx_at_visual_offset, chars::char_is_word, @@ -356,9 +356,9 @@ impl MappableCommand { extend_prev_char, "Extend to previous occurrence of char", repeat_last_motion, "Repeat last motion", replace, "Replace with new char", - switch_to_alternate_case, "Switch to aLTERNATE cASE", - switch_to_upper_case, "Switch to UPPERCASE", - switch_to_lower_case, "Switch to lowercase", + switch_case, "Switch to aLTERNATE cASE", + switch_to_uppercase, "Switch to UPPERCASE", + switch_to_lowercase, "Switch to lowercase", switch_to_pascal_case, "Switch to PascalCase", switch_to_camel_case, "Switch to camelCase", switch_to_title_case, "Switch to Title Case", @@ -1795,15 +1795,15 @@ fn switch_to_camel_case(cx: &mut Context) { switch_case_impl(cx, |chars| to_camel_case(chars)) } -fn switch_to_lower_case(cx: &mut Context) { - switch_case_impl(cx, |chars| to_lower_case(chars)) +fn switch_to_lowercase(cx: &mut Context) { + switch_case_impl(cx, |chars| to_lowercase(chars)) } -fn switch_to_upper_case(cx: &mut Context) { - switch_case_impl(cx, |chars| to_upper_case(chars)) +fn switch_to_uppercase(cx: &mut Context) { + switch_case_impl(cx, |chars| to_uppercase(chars)) } -fn switch_to_alternate_case(cx: &mut Context) { +fn switch_case(cx: &mut Context) { switch_case_impl(cx, |chars| to_alternate_case(chars)) } diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs index 3a21594d2..250e3149a 100644 --- a/helix-term/src/keymap/default.rs +++ b/helix-term/src/keymap/default.rs @@ -19,10 +19,10 @@ pub fn default() -> HashMap { "R" => replace_with_yanked, "A-." => repeat_last_motion, - "~" => switch_to_alternate_case, + "~" => switch_case, "`" => { "Case" - "l" => switch_to_lower_case, - "u" => switch_to_upper_case, + "l" => switch_to_lowercase, + "u" => switch_to_uppercase, "p" => switch_to_pascal_case, "c" => switch_to_camel_case, "t" => switch_to_title_case, From c1c63a0e55fa31b063637f040c967186b874b3e4 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 12:33:58 +0000 Subject: [PATCH 32/55] feat!: remap switch_to_alternate_case from ~ to `a --- helix-term/src/commands.rs | 4 ++-- helix-term/src/keymap/default.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 6c1075ac7..7ccb63f27 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -356,7 +356,7 @@ impl MappableCommand { extend_prev_char, "Extend to previous occurrence of char", repeat_last_motion, "Repeat last motion", replace, "Replace with new char", - switch_case, "Switch to aLTERNATE cASE", + switch_to_alternate_case, "Switch to aLTERNATE cASE", switch_to_uppercase, "Switch to UPPERCASE", switch_to_lowercase, "Switch to lowercase", switch_to_pascal_case, "Switch to PascalCase", @@ -1803,7 +1803,7 @@ fn switch_to_uppercase(cx: &mut Context) { switch_case_impl(cx, |chars| to_uppercase(chars)) } -fn switch_case(cx: &mut Context) { +fn switch_to_alternate_case(cx: &mut Context) { switch_case_impl(cx, |chars| to_alternate_case(chars)) } diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs index 250e3149a..1643ca185 100644 --- a/helix-term/src/keymap/default.rs +++ b/helix-term/src/keymap/default.rs @@ -19,8 +19,8 @@ pub fn default() -> HashMap { "R" => replace_with_yanked, "A-." => repeat_last_motion, - "~" => switch_case, "`" => { "Case" + "a" => switch_to_alternate_case, "l" => switch_to_lowercase, "u" => switch_to_uppercase, "p" => switch_to_pascal_case, From 59d65beeac9c9dd835408a05f672c98bbb03da13 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 12:37:37 +0000 Subject: [PATCH 33/55] docs: document new keymappings --- book/src/generated/static-cmd.md | 6 +++--- book/src/keymap.md | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/book/src/generated/static-cmd.md b/book/src/generated/static-cmd.md index da9117d6b..e80672bd7 100644 --- a/book/src/generated/static-cmd.md +++ b/book/src/generated/static-cmd.md @@ -53,9 +53,9 @@ | `extend_prev_char` | Extend to previous occurrence of char | select: `` F `` | | `repeat_last_motion` | Repeat last motion | normal: `` ``, select: `` `` | | `replace` | Replace with new char | normal: `` r ``, select: `` r `` | -| `switch_to_alternate_case` | Switch to aLTERNATE cASE | normal: `` ~ ``, select: `` ~ `` | -| `switch_to_upper_case` | Switch to UPPERCASE | normal: `` `u ``, select: `` `u `` | -| `switch_to_lower_case` | Switch to lowercase | normal: `` `l ``, select: `` `l `` | +| `switch_to_alternate_case` | Switch to aLTERNATE cASE | normal: `` `a ``, select: `` `a `` | +| `switch_to_uppercase` | Switch to UPPERCASE | normal: `` `u ``, select: `` `u `` | +| `switch_to_lowercase` | Switch to lowercase | normal: `` `l ``, select: `` `l `` | | `switch_to_pascal_case` | Switch to PascalCase | normal: `` `p ``, select: `` `p `` | | `switch_to_camel_case` | Switch to camelCase | normal: `` `c ``, select: `` `c `` | | `switch_to_title_case` | Switch to Title Case | normal: `` `t ``, select: `` `t `` | diff --git a/book/src/keymap.md b/book/src/keymap.md index 6c6ed5b0a..a111f4e7e 100644 --- a/book/src/keymap.md +++ b/book/src/keymap.md @@ -70,7 +70,6 @@ Normal mode is the default mode when you launch helix. You can return to it from | ----- | ----------- | ------- | | `r` | Replace with a character | `replace` | | `R` | Replace with yanked text | `replace_with_yanked` | -| `~` | Switch case of the selected text | `switch_case` | | `i` | Insert before selection | `insert_mode` | | `a` | Insert after selection (append) | `append_mode` | | `I` | Insert at the start of the line | `insert_at_line_start` | @@ -242,13 +241,14 @@ Various commands for changing the case of text in different ways. | Key | Description | Command | | ----- | ----------- | ------- | -| `l` | Switch all text to lowercase | `switch_to_lowercase` | -| `u` | Switch all text to UPPERCASE | `switch_to_uppercase` | +| `l` | Switch text to lowercase | `switch_to_lowercase` | +| `u` | Switch text to UPPERCASE | `switch_to_uppercase` | | `p` | Switch text to Pascal Case | `switch_to_pascal_case` | | `c` | Switch text to camelCase | `switch_to_camel_case` | | `t` | Switch text to Title Case | `switch_to_title_case` | | `s` | Switch text to snake_case | `switch_to_snake_case` | | `k` | Switch text to kebab-case | `switch_to_kebab_case` | +| `a` | Switch text to aLTERNATE cASE | `switch_to_alternate_case` | TODO: Mappings for selecting syntax nodes (a superset of `[`). From 45dd3a6c96a863c1aebe589612c6ac523e400e13 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 13:03:34 +0000 Subject: [PATCH 34/55] docs: remove unneeded comment --- book/src/keymap.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/book/src/keymap.md b/book/src/keymap.md index a111f4e7e..867a6fdf6 100644 --- a/book/src/keymap.md +++ b/book/src/keymap.md @@ -250,8 +250,6 @@ Various commands for changing the case of text in different ways. | `k` | Switch text to kebab-case | `switch_to_kebab_case` | | `a` | Switch text to aLTERNATE cASE | `switch_to_alternate_case` | -TODO: Mappings for selecting syntax nodes (a superset of `[`). - #### Match mode Accessed by typing `m` in [normal mode](#normal-mode). From fe7b74fd060a0f9626e9441f41acca548c987211 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 13:04:03 +0000 Subject: [PATCH 35/55] style: add 2 space --- book/src/keymap.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/book/src/keymap.md b/book/src/keymap.md index 867a6fdf6..3707f828b 100644 --- a/book/src/keymap.md +++ b/book/src/keymap.md @@ -169,7 +169,7 @@ These sub-modes are accessible from normal mode and typically switch back to nor | ----- | ----------- | ------- | | `v` | Enter [select (extend) mode](#select--extend-mode) | `select_mode` | | `g` | Enter [goto mode](#goto-mode) | N/A | -| ` ` ` | Enter [case mode](#case-mode) | N/A | +| ` ` ` | Enter [case mode](#case-mode) | N/A | | `m` | Enter [match mode](#match-mode) | N/A | | `:` | Enter command mode | `command_mode` | | `z` | Enter [view mode](#view-mode) | N/A | From ea920b82eb465b9b841cb24d227b4e3fc4571514 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 20 Dec 2024 13:04:53 +0000 Subject: [PATCH 36/55] docs: remove comment for consistency --- helix-core/src/case_conversion.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 070b6e821..814ea4a9d 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -2,7 +2,6 @@ use crate::Tendril; // todo: should this be grapheme aware? -/// Converts each character into a different one, with zero context about surrounding characters pub fn simple_case_conversion( text: impl Iterator, buf: &mut Tendril, From e073a2eb7b2ba86638f2b1459e5d3ac363afeb1f Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Sat, 11 Jan 2025 17:04:04 +0000 Subject: [PATCH 37/55] refactor: rename variable --- helix-core/src/case_conversion.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 814ea4a9d..5fe5bac1a 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -12,7 +12,7 @@ pub fn simple_case_conversion( } } -pub fn complex_case_conversion( +pub fn smart_case_conversion( text: impl Iterator, buf: &mut Tendril, capitalize_first: bool, @@ -112,15 +112,15 @@ pub fn into_snake_case(text: impl Iterator, buf: &mut Tendril) { } pub fn into_title_case(text: impl Iterator, buf: &mut Tendril) { - complex_case_conversion(text, buf, true, Some(' ')); + smart_case_conversion(text, buf, true, Some(' ')); } pub fn into_camel_case(text: impl Iterator, buf: &mut Tendril) { - complex_case_conversion(text, buf, false, None); + smart_case_conversion(text, buf, false, None); } pub fn into_pascal_case(text: impl Iterator, buf: &mut Tendril) { - complex_case_conversion(text, buf, true, None); + smart_case_conversion(text, buf, true, None); } fn to_case(text: I, to_case_with: fn(I, &mut Tendril)) -> Tendril From d7a3ffa2d80b5a8256490d30666e0b7812543e96 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Sat, 11 Jan 2025 17:43:57 +0000 Subject: [PATCH 38/55] refactor: simplify code --- helix-core/src/case_conversion.rs | 35 +++++++++++++++++-------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 5fe5bac1a..b7ba1d08d 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -13,7 +13,7 @@ pub fn simple_case_conversion( } pub fn smart_case_conversion( - text: impl Iterator, + chars: impl Iterator, buf: &mut Tendril, capitalize_first: bool, separator: Option, @@ -21,34 +21,37 @@ pub fn smart_case_conversion( let mut should_capitalize_current = capitalize_first; let mut prev: Option = None; - for c in text.skip_while(|ch| ch.is_whitespace()) { - if c.is_alphanumeric() { + for current in chars.skip_while(|ch| ch.is_whitespace()) { + let mut maybe_add_separator = || { if let Some(separator) = separator { - if prev.is_some_and(|p| p != separator) - && prev.is_some_and(|p| p.is_lowercase()) - && c.is_uppercase() - { + // We do not want to add a separator when the previous char is not a separator + // For example, snake__case is invalid + if prev.is_some_and(|ch| ch != separator) { buf.push(separator); } } - if prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase() { + }; + + if current.is_alphanumeric() { + // "camelCase" => transition at 'l' -> 'C' + let has_camel_transition = + current.is_uppercase() && prev.is_some_and(|ch| ch.is_lowercase()); + + if has_camel_transition { + maybe_add_separator(); should_capitalize_current = true; } if should_capitalize_current { - buf.push(c.to_ascii_uppercase()); + buf.push(current.to_ascii_uppercase()); should_capitalize_current = false; } else { - buf.extend(c.to_lowercase()); + buf.push(current.to_ascii_lowercase()); } } else { should_capitalize_current = true; - if let Some(separator) = separator { - if prev.is_some_and(|p| p != separator) { - buf.push(separator); - } - } + maybe_add_separator(); } - prev = Some(c); + prev = Some(current); } *buf = buf.trim_end().into(); From 5420ef5f63640c6d5ad6759c40e57be4425d1f39 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Sat, 11 Jan 2025 17:45:50 +0000 Subject: [PATCH 39/55] refactor: remove unneeded loop, replace with map instead --- helix-core/src/case_conversion.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index b7ba1d08d..01e5a70b7 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -7,9 +7,7 @@ pub fn simple_case_conversion( buf: &mut Tendril, transform_char: impl Fn(&char) -> char, ) { - for c in text { - buf.push(transform_char(&c)) - } + *buf = text.map(|ch| transform_char(&ch)).collect(); } pub fn smart_case_conversion( From 2c1af76fb0a82657255da13e3c180603b2a9028f Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Sat, 11 Jan 2025 17:49:01 +0000 Subject: [PATCH 40/55] refactor: do not create new function on each loop --- helix-core/src/case_conversion.rs | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 01e5a70b7..2a67416cc 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -19,24 +19,24 @@ pub fn smart_case_conversion( let mut should_capitalize_current = capitalize_first; let mut prev: Option = None; - for current in chars.skip_while(|ch| ch.is_whitespace()) { - let mut maybe_add_separator = || { - if let Some(separator) = separator { - // We do not want to add a separator when the previous char is not a separator - // For example, snake__case is invalid - if prev.is_some_and(|ch| ch != separator) { - buf.push(separator); - } + let add_separator_if_needed = |prev: Option, buf: &mut Tendril| { + if let Some(separator) = separator { + // We do not want to add a separator when the previous char is not a separator + // For example, snake__case is invalid + if prev.is_some_and(|ch| ch != separator) { + buf.push(separator); } - }; + } + }; + for current in chars.skip_while(|ch| ch.is_whitespace()) { if current.is_alphanumeric() { // "camelCase" => transition at 'l' -> 'C' let has_camel_transition = current.is_uppercase() && prev.is_some_and(|ch| ch.is_lowercase()); if has_camel_transition { - maybe_add_separator(); + add_separator_if_needed(prev, buf); should_capitalize_current = true; } if should_capitalize_current { @@ -47,7 +47,7 @@ pub fn smart_case_conversion( } } else { should_capitalize_current = true; - maybe_add_separator(); + add_separator_if_needed(prev, buf); } prev = Some(current); } From ac3722a74d4a4f55263dcb8dd6f87c0292289f12 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Sat, 11 Jan 2025 17:51:45 +0000 Subject: [PATCH 41/55] refactor: extract has_camel_transition function --- helix-core/src/case_conversion.rs | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 2a67416cc..4403db301 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -10,6 +10,11 @@ pub fn simple_case_conversion( *buf = text.map(|ch| transform_char(&ch)).collect(); } +/// Whether there is a camelCase transition, such as at 'l' -> 'C' +fn has_camel_transition(prev: Option, current: char) -> bool { + current.is_uppercase() && prev.is_some_and(|ch| ch.is_lowercase()) +} + pub fn smart_case_conversion( chars: impl Iterator, buf: &mut Tendril, @@ -31,11 +36,7 @@ pub fn smart_case_conversion( for current in chars.skip_while(|ch| ch.is_whitespace()) { if current.is_alphanumeric() { - // "camelCase" => transition at 'l' -> 'C' - let has_camel_transition = - current.is_uppercase() && prev.is_some_and(|ch| ch.is_lowercase()); - - if has_camel_transition { + if has_camel_transition(prev, current) { add_separator_if_needed(prev, buf); should_capitalize_current = true; } @@ -62,25 +63,23 @@ pub fn separator_case_conversion( ) { let mut prev: Option = None; - for c in text.skip_while(|ch| ch.is_whitespace()) { - if !c.is_alphanumeric() { - prev = Some(c); + for current in text.skip_while(|ch| ch.is_whitespace()) { + if !current.is_alphanumeric() { + prev = Some(current); continue; } - // "camelCase" => transition at 'l' -> 'C' - let has_camel_transition = prev.is_some_and(|p| p.is_lowercase()) && c.is_uppercase(); // "email@somewhere" => transition at 'l' -> '@' // first character must not be separator, e.g. @emailSomewhere should not become -email-somewhere let has_alphanum_transition = !prev.is_some_and(|p| p.is_alphanumeric()) && !buf.is_empty(); - if has_camel_transition || has_alphanum_transition { + if has_camel_transition(prev, current) || has_alphanum_transition { buf.push(separator); } - buf.push(c.to_ascii_lowercase()); + buf.push(current.to_ascii_lowercase()); - prev = Some(c); + prev = Some(current); } } From cec122e1cad1c476003ddc8531c19bffaca415f8 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Sat, 11 Jan 2025 19:25:24 +0000 Subject: [PATCH 42/55] refactor: rename variable --- helix-core/src/case_conversion.rs | 86 +++++++++++++++---------------- 1 file changed, 43 insertions(+), 43 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 4403db301..898398f52 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -3,11 +3,11 @@ use crate::Tendril; // todo: should this be grapheme aware? pub fn simple_case_conversion( - text: impl Iterator, + chars: impl Iterator, buf: &mut Tendril, transform_char: impl Fn(&char) -> char, ) { - *buf = text.map(|ch| transform_char(&ch)).collect(); + *buf = chars.map(|ch| transform_char(&ch)).collect(); } /// Whether there is a camelCase transition, such as at 'l' -> 'C' @@ -57,13 +57,13 @@ pub fn smart_case_conversion( } pub fn separator_case_conversion( - text: impl Iterator, + chars: impl Iterator, buf: &mut Tendril, separator: char, ) { let mut prev: Option = None; - for current in text.skip_while(|ch| ch.is_whitespace()) { + for current in chars.skip_while(|ch| ch.is_whitespace()) { if !current.is_alphanumeric() { prev = Some(current); continue; @@ -83,85 +83,85 @@ pub fn separator_case_conversion( } } -pub fn into_alternate_case(text: impl Iterator, buf: &mut Tendril) { - simple_case_conversion(text, buf, |c| { - if c.is_uppercase() { - c.to_ascii_lowercase() - } else if c.is_lowercase() { - c.to_ascii_uppercase() +pub fn into_alternate_case(chars: impl Iterator, buf: &mut Tendril) { + simple_case_conversion(chars, buf, |ch| { + if ch.is_uppercase() { + ch.to_ascii_lowercase() + } else if ch.is_lowercase() { + ch.to_ascii_uppercase() } else { - *c + *ch } }); } -pub fn into_uppercase(text: impl Iterator, buf: &mut Tendril) { - simple_case_conversion(text, buf, char::to_ascii_uppercase); +pub fn into_uppercase(chars: impl Iterator, buf: &mut Tendril) { + simple_case_conversion(chars, buf, char::to_ascii_uppercase); } -pub fn into_lowercase(text: impl Iterator, buf: &mut Tendril) { - simple_case_conversion(text, buf, char::to_ascii_lowercase); +pub fn into_lowercase(chars: impl Iterator, buf: &mut Tendril) { + simple_case_conversion(chars, buf, char::to_ascii_lowercase); } -pub fn into_kebab_case(text: impl Iterator, buf: &mut Tendril) { - separator_case_conversion(text, buf, '-'); +pub fn into_kebab_case(chars: impl Iterator, buf: &mut Tendril) { + separator_case_conversion(chars, buf, '-'); } -pub fn into_snake_case(text: impl Iterator, buf: &mut Tendril) { - separator_case_conversion(text, buf, '_'); +pub fn into_snake_case(chars: impl Iterator, buf: &mut Tendril) { + separator_case_conversion(chars, buf, '_'); } -pub fn into_title_case(text: impl Iterator, buf: &mut Tendril) { - smart_case_conversion(text, buf, true, Some(' ')); +pub fn into_title_case(chars: impl Iterator, buf: &mut Tendril) { + smart_case_conversion(chars, buf, true, Some(' ')); } -pub fn into_camel_case(text: impl Iterator, buf: &mut Tendril) { - smart_case_conversion(text, buf, false, None); +pub fn into_camel_case(chars: impl Iterator, buf: &mut Tendril) { + smart_case_conversion(chars, buf, false, None); } -pub fn into_pascal_case(text: impl Iterator, buf: &mut Tendril) { - smart_case_conversion(text, buf, true, None); +pub fn into_pascal_case(chars: impl Iterator, buf: &mut Tendril) { + smart_case_conversion(chars, buf, true, None); } -fn to_case(text: I, to_case_with: fn(I, &mut Tendril)) -> Tendril +fn to_case(chars: I, into_case: fn(I, &mut Tendril)) -> Tendril where I: Iterator, { let mut res = Tendril::new(); - to_case_with(text, &mut res); + into_case(chars, &mut res); res } -pub fn to_camel_case(text: impl Iterator) -> Tendril { - to_case(text, into_camel_case) +pub fn to_camel_case(chars: impl Iterator) -> Tendril { + to_case(chars, into_camel_case) } -pub fn to_lowercase(text: impl Iterator) -> Tendril { - to_case(text, into_lowercase) +pub fn to_lowercase(chars: impl Iterator) -> Tendril { + to_case(chars, into_lowercase) } -pub fn to_uppercase(text: impl Iterator) -> Tendril { - to_case(text, into_uppercase) +pub fn to_uppercase(chars: impl Iterator) -> Tendril { + to_case(chars, into_uppercase) } -pub fn to_pascal_case(text: impl Iterator) -> Tendril { - to_case(text, into_pascal_case) +pub fn to_pascal_case(chars: impl Iterator) -> Tendril { + to_case(chars, into_pascal_case) } -pub fn to_alternate_case(text: impl Iterator) -> Tendril { - to_case(text, into_alternate_case) +pub fn to_alternate_case(chars: impl Iterator) -> Tendril { + to_case(chars, into_alternate_case) } -pub fn to_title_case(text: impl Iterator) -> Tendril { - to_case(text, into_title_case) +pub fn to_title_case(chars: impl Iterator) -> Tendril { + to_case(chars, into_title_case) } -pub fn to_kebab_case(text: impl Iterator) -> Tendril { - to_case(text, into_kebab_case) +pub fn to_kebab_case(chars: impl Iterator) -> Tendril { + to_case(chars, into_kebab_case) } -pub fn to_snake_case(text: impl Iterator) -> Tendril { - to_case(text, into_snake_case) +pub fn to_snake_case(chars: impl Iterator) -> Tendril { + to_case(chars, into_snake_case) } #[cfg(test)] From 2a1bff56484c1d4d475505ffc13f644b7163bf9e Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Sat, 11 Jan 2025 19:49:23 +0000 Subject: [PATCH 43/55] refactor: remove unneeded type annotation --- helix-core/src/case_conversion.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 898398f52..ccc9c6465 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -22,7 +22,7 @@ pub fn smart_case_conversion( separator: Option, ) { let mut should_capitalize_current = capitalize_first; - let mut prev: Option = None; + let mut prev = None; let add_separator_if_needed = |prev: Option, buf: &mut Tendril| { if let Some(separator) = separator { @@ -61,7 +61,7 @@ pub fn separator_case_conversion( buf: &mut Tendril, separator: char, ) { - let mut prev: Option = None; + let mut prev = None; for current in chars.skip_while(|ch| ch.is_whitespace()) { if !current.is_alphanumeric() { From fdd1a1c78f43720ffe4ed613cc3d17ef6bf0d7f6 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Sat, 11 Jan 2025 19:56:18 +0000 Subject: [PATCH 44/55] refactor: remove 1 layer of nesting --- helix-core/src/case_conversion.rs | 28 ++++++++++++++++------------ 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index ccc9c6465..0bd0053cc 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -35,21 +35,25 @@ pub fn smart_case_conversion( }; for current in chars.skip_while(|ch| ch.is_whitespace()) { - if current.is_alphanumeric() { - if has_camel_transition(prev, current) { - add_separator_if_needed(prev, buf); - should_capitalize_current = true; - } - if should_capitalize_current { - buf.push(current.to_ascii_uppercase()); - should_capitalize_current = false; - } else { - buf.push(current.to_ascii_lowercase()); - } - } else { + if !current.is_alphanumeric() { should_capitalize_current = true; add_separator_if_needed(prev, buf); + prev = Some(current); + continue; } + + if has_camel_transition(prev, current) { + add_separator_if_needed(prev, buf); + should_capitalize_current = true; + } + + if should_capitalize_current { + buf.push(current.to_ascii_uppercase()); + should_capitalize_current = false; + } else { + buf.push(current.to_ascii_lowercase()); + } + prev = Some(current); } From 54dbc1bd44e304132b5343bf7a8b4fb4e770c286 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Mon, 3 Feb 2025 21:43:32 +0000 Subject: [PATCH 45/55] feat: restore default `~` keymap for switch to alternate text --- book/src/keymap.md | 1 + helix-term/src/keymap/default.rs | 1 + 2 files changed, 2 insertions(+) diff --git a/book/src/keymap.md b/book/src/keymap.md index 3707f828b..82a0fb6e3 100644 --- a/book/src/keymap.md +++ b/book/src/keymap.md @@ -70,6 +70,7 @@ Normal mode is the default mode when you launch helix. You can return to it from | ----- | ----------- | ------- | | `r` | Replace with a character | `replace` | | `R` | Replace with yanked text | `replace_with_yanked` | +| `~` | Switch case of the selected text | `switch_to_alternate_case`| | `i` | Insert before selection | `insert_mode` | | `a` | Insert after selection (append) | `append_mode` | | `I` | Insert at the start of the line | `insert_at_line_start` | diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs index 1643ca185..f801dbbd1 100644 --- a/helix-term/src/keymap/default.rs +++ b/helix-term/src/keymap/default.rs @@ -19,6 +19,7 @@ pub fn default() -> HashMap { "R" => replace_with_yanked, "A-." => repeat_last_motion, + "~" => switch_to_alternate_case, "`" => { "Case" "a" => switch_to_alternate_case, "l" => switch_to_lowercase, From c7cbb4e0c972a99e8624edcef8e4f3ac8e54c917 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Mon, 3 Feb 2025 21:58:15 +0000 Subject: [PATCH 46/55] docs: `~` is assigned to alternate case function --- book/src/generated/static-cmd.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/book/src/generated/static-cmd.md b/book/src/generated/static-cmd.md index e80672bd7..de7763a7c 100644 --- a/book/src/generated/static-cmd.md +++ b/book/src/generated/static-cmd.md @@ -53,7 +53,7 @@ | `extend_prev_char` | Extend to previous occurrence of char | select: `` F `` | | `repeat_last_motion` | Repeat last motion | normal: `` ``, select: `` `` | | `replace` | Replace with new char | normal: `` r ``, select: `` r `` | -| `switch_to_alternate_case` | Switch to aLTERNATE cASE | normal: `` `a ``, select: `` `a `` | +| `switch_to_alternate_case` | Switch to aLTERNATE cASE | normal: `` ~ ``, `` `a ``, select: `` ~ ``, `` `a `` | | `switch_to_uppercase` | Switch to UPPERCASE | normal: `` `u ``, select: `` `u `` | | `switch_to_lowercase` | Switch to lowercase | normal: `` `l ``, select: `` `l `` | | `switch_to_pascal_case` | Switch to PascalCase | normal: `` `p ``, select: `` `p `` | From 917e8057dc60d6bd80b6e6bf2ee3db235885e29a Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 28 Feb 2025 15:16:25 +0000 Subject: [PATCH 47/55] fix: remove extra allocs from alternate case impl --- helix-core/src/case_conversion.rs | 57 +++++++++++++++++++++++++------ helix-term/src/commands.rs | 31 ----------------- 2 files changed, 46 insertions(+), 42 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 0bd0053cc..f0268eed7 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -1,3 +1,5 @@ +use std::char::{ToLowercase, ToUppercase}; + use crate::Tendril; // todo: should this be grapheme aware? @@ -87,24 +89,57 @@ pub fn separator_case_conversion( } } -pub fn into_alternate_case(chars: impl Iterator, buf: &mut Tendril) { - simple_case_conversion(chars, buf, |ch| { - if ch.is_uppercase() { - ch.to_ascii_lowercase() - } else if ch.is_lowercase() { - ch.to_ascii_uppercase() - } else { - *ch +enum AlternateCase { + Upper(ToUppercase), + Lower(ToLowercase), + Keep(Option), +} + +impl Iterator for AlternateCase { + type Item = char; + + fn next(&mut self) -> Option { + match self { + AlternateCase::Upper(upper) => upper.next(), + AlternateCase::Lower(lower) => lower.next(), + AlternateCase::Keep(ch) => ch.take(), } - }); + } + + fn size_hint(&self) -> (usize, Option) { + match self { + AlternateCase::Upper(upper) => upper.size_hint(), + AlternateCase::Lower(lower) => lower.size_hint(), + AlternateCase::Keep(ch) => { + let n = if ch.is_some() { 1 } else { 0 }; + (n, Some(n)) + } + } + } +} + +impl ExactSizeIterator for AlternateCase {} + +pub fn into_alternate_case(chars: impl Iterator, buf: &mut Tendril) { + *buf = chars + .flat_map(|ch| { + if ch.is_lowercase() { + AlternateCase::Upper(ch.to_uppercase()) + } else if ch.is_uppercase() { + AlternateCase::Lower(ch.to_lowercase()) + } else { + AlternateCase::Keep(Some(ch)) + } + }) + .collect(); } pub fn into_uppercase(chars: impl Iterator, buf: &mut Tendril) { - simple_case_conversion(chars, buf, char::to_ascii_uppercase); + *buf = chars.map(|ch| char::to_ascii_uppercase(&ch)).collect(); } pub fn into_lowercase(chars: impl Iterator, buf: &mut Tendril) { - simple_case_conversion(chars, buf, char::to_ascii_lowercase); + *buf = chars.map(|ch| char::to_ascii_lowercase(&ch)).collect(); } pub fn into_kebab_case(chars: impl Iterator, buf: &mut Tendril) { diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 7ccb63f27..adf7b4555 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -1739,37 +1739,6 @@ where exit_select_mode(cx); } -enum CaseSwitcher { - Upper(ToUppercase), - Lower(ToLowercase), - Keep(Option), -} - -impl Iterator for CaseSwitcher { - type Item = char; - - fn next(&mut self) -> Option { - match self { - CaseSwitcher::Upper(upper) => upper.next(), - CaseSwitcher::Lower(lower) => lower.next(), - CaseSwitcher::Keep(ch) => ch.take(), - } - } - - fn size_hint(&self) -> (usize, Option) { - match self { - CaseSwitcher::Upper(upper) => upper.size_hint(), - CaseSwitcher::Lower(lower) => lower.size_hint(), - CaseSwitcher::Keep(ch) => { - let n = if ch.is_some() { 1 } else { 0 }; - (n, Some(n)) - } - } - } -} - -impl ExactSizeIterator for CaseSwitcher {} - fn switch_case(cx: &mut Context) { switch_case_impl(cx, |string| { string From 90884f0588ca096b5195b9cde95a830066ee5304 Mon Sep 17 00:00:00 2001 From: Nikita Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Fri, 28 Feb 2025 15:19:25 +0000 Subject: [PATCH 48/55] fix: use char::to_{lower_uppercase} instead of their ascii variants --- helix-core/src/case_conversion.rs | 4 ++-- helix-term/src/commands.rs | 18 ------------------ 2 files changed, 2 insertions(+), 20 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index f0268eed7..358bdf622 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -135,11 +135,11 @@ pub fn into_alternate_case(chars: impl Iterator, buf: &mut Tendril) } pub fn into_uppercase(chars: impl Iterator, buf: &mut Tendril) { - *buf = chars.map(|ch| char::to_ascii_uppercase(&ch)).collect(); + *buf = chars.flat_map(char::to_uppercase).collect(); } pub fn into_lowercase(chars: impl Iterator, buf: &mut Tendril) { - *buf = chars.map(|ch| char::to_ascii_lowercase(&ch)).collect(); + *buf = chars.flat_map(char::to_lowercase).collect(); } pub fn into_kebab_case(chars: impl Iterator, buf: &mut Tendril) { diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index adf7b4555..07de5adee 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -70,7 +70,6 @@ use crate::{ use crate::job::{self, Jobs}; use std::{ - char::{ToLowercase, ToUppercase}, cmp::Ordering, collections::{HashMap, HashSet}, error::Error, @@ -1739,23 +1738,6 @@ where exit_select_mode(cx); } -fn switch_case(cx: &mut Context) { - switch_case_impl(cx, |string| { - string - .chars() - .flat_map(|ch| { - if ch.is_lowercase() { - CaseSwitcher::Upper(ch.to_uppercase()) - } else if ch.is_uppercase() { - CaseSwitcher::Lower(ch.to_lowercase()) - } else { - CaseSwitcher::Keep(Some(ch)) - } - }) - .collect() - }); -} - fn switch_to_pascal_case(cx: &mut Context) { switch_case_impl(cx, |chars| to_pascal_case(chars)) } From fd83cf7870a27445c0ae231f4e6a4d0c8bcb00c5 Mon Sep 17 00:00:00 2001 From: Nik Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Tue, 25 Mar 2025 15:56:37 +0000 Subject: [PATCH 49/55] refactor: use macro to create functional versions of case converters --- helix-core/src/case_conversion.rs | 57 +++++++++++-------------------- 1 file changed, 20 insertions(+), 37 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 358bdf622..14631b3cc 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -162,45 +162,28 @@ pub fn into_pascal_case(chars: impl Iterator, buf: &mut Tendril) { smart_case_conversion(chars, buf, true, None); } -fn to_case(chars: I, into_case: fn(I, &mut Tendril)) -> Tendril -where - I: Iterator, -{ - let mut res = Tendril::new(); - into_case(chars, &mut res); - res +/// Create functional versions of the "into_*" case functions that take a `&mut Tendril` +macro_rules! to_case { + ($($into_case:ident => $to_case:ident)*) => { + $( + pub fn $to_case(chars: impl Iterator) -> Tendril { + let mut res = Tendril::new(); + $into_case(chars, &mut res); + res + } + )* + }; } -pub fn to_camel_case(chars: impl Iterator) -> Tendril { - to_case(chars, into_camel_case) -} - -pub fn to_lowercase(chars: impl Iterator) -> Tendril { - to_case(chars, into_lowercase) -} - -pub fn to_uppercase(chars: impl Iterator) -> Tendril { - to_case(chars, into_uppercase) -} - -pub fn to_pascal_case(chars: impl Iterator) -> Tendril { - to_case(chars, into_pascal_case) -} - -pub fn to_alternate_case(chars: impl Iterator) -> Tendril { - to_case(chars, into_alternate_case) -} - -pub fn to_title_case(chars: impl Iterator) -> Tendril { - to_case(chars, into_title_case) -} - -pub fn to_kebab_case(chars: impl Iterator) -> Tendril { - to_case(chars, into_kebab_case) -} - -pub fn to_snake_case(chars: impl Iterator) -> Tendril { - to_case(chars, into_snake_case) +to_case! { + into_camel_case => to_camel_case + into_lowercase => to_lowercase + into_uppercase => to_uppercase + into_pascal_case => to_pascal_case + into_alternate_case => to_alternate_case + into_title_case => to_title_case + into_kebab_case => to_kebab_case + into_snake_case => to_snake_case } #[cfg(test)] From bf788f5f00597bcd3f284853b3bbefe8cd481f46 Mon Sep 17 00:00:00 2001 From: Nik Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Tue, 25 Mar 2025 16:04:35 +0000 Subject: [PATCH 50/55] fix: use `to_{uppercase,lowercase}` instead of `to_ascii*`variants --- helix-core/src/case_conversion.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 14631b3cc..9459cd302 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -50,10 +50,10 @@ pub fn smart_case_conversion( } if should_capitalize_current { - buf.push(current.to_ascii_uppercase()); + buf.extend(current.to_uppercase()); should_capitalize_current = false; } else { - buf.push(current.to_ascii_lowercase()); + buf.extend(current.to_lowercase()); } prev = Some(current); @@ -83,7 +83,7 @@ pub fn separator_case_conversion( buf.push(separator); } - buf.push(current.to_ascii_lowercase()); + buf.extend(current.to_lowercase()); prev = Some(current); } From 2cc5222226351df00e64509e43ad856b09fe41c4 Mon Sep 17 00:00:00 2001 From: Nik Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Tue, 25 Mar 2025 16:06:47 +0000 Subject: [PATCH 51/55] refactor: remove unused function --- helix-core/src/case_conversion.rs | 8 -------- 1 file changed, 8 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 9459cd302..e4a4927b3 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -4,14 +4,6 @@ use crate::Tendril; // todo: should this be grapheme aware? -pub fn simple_case_conversion( - chars: impl Iterator, - buf: &mut Tendril, - transform_char: impl Fn(&char) -> char, -) { - *buf = chars.map(|ch| transform_char(&ch)).collect(); -} - /// Whether there is a camelCase transition, such as at 'l' -> 'C' fn has_camel_transition(prev: Option, current: char) -> bool { current.is_uppercase() && prev.is_some_and(|ch| ch.is_lowercase()) From b0251ef7152be5a5d8eeb6b604a7ae827ca38e0e Mon Sep 17 00:00:00 2001 From: Nik Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Tue, 25 Mar 2025 16:21:40 +0000 Subject: [PATCH 52/55] feat: `switch_to_sentence_case` (`` `S ``) _ --- book/src/generated/static-cmd.md | 1 + book/src/keymap.md | 1 + helix-core/src/case_conversion.rs | 55 ++++++++++++++++++++++++++----- helix-term/src/commands.rs | 28 ++++++++-------- helix-term/src/keymap/default.rs | 1 + 5 files changed, 64 insertions(+), 22 deletions(-) diff --git a/book/src/generated/static-cmd.md b/book/src/generated/static-cmd.md index de7763a7c..59da8f839 100644 --- a/book/src/generated/static-cmd.md +++ b/book/src/generated/static-cmd.md @@ -59,6 +59,7 @@ | `switch_to_pascal_case` | Switch to PascalCase | normal: `` `p ``, select: `` `p `` | | `switch_to_camel_case` | Switch to camelCase | normal: `` `c ``, select: `` `c `` | | `switch_to_title_case` | Switch to Title Case | normal: `` `t ``, select: `` `t `` | +| `switch_to_sentence_case` | Switch to Sentence case | normal: `` `S ``, select: `` `S `` | | `switch_to_snake_case` | Switch to snake_case | normal: `` `s ``, select: `` `s `` | | `switch_to_kebab_case` | Switch to kebab-case | normal: `` `k ``, select: `` `k `` | | `page_up` | Move page up | normal: `` ``, `` Z ``, `` z ``, `` ``, `` Z ``, `` z ``, select: `` ``, `` Z ``, `` z ``, `` ``, `` Z ``, `` z ``, insert: `` `` | diff --git a/book/src/keymap.md b/book/src/keymap.md index 82a0fb6e3..f833d19af 100644 --- a/book/src/keymap.md +++ b/book/src/keymap.md @@ -247,6 +247,7 @@ Various commands for changing the case of text in different ways. | `p` | Switch text to Pascal Case | `switch_to_pascal_case` | | `c` | Switch text to camelCase | `switch_to_camel_case` | | `t` | Switch text to Title Case | `switch_to_title_case` | +| `S` | Switch text to Sentence case | `switch_to_sentence_case` | | `s` | Switch text to snake_case | `switch_to_snake_case` | | `k` | Switch text to kebab-case | `switch_to_kebab_case` | | `a` | Switch text to aLTERNATE cASE | `switch_to_alternate_case` | diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index e4a4927b3..f3ea6c73c 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -9,13 +9,20 @@ fn has_camel_transition(prev: Option, current: char) -> bool { current.is_uppercase() && prev.is_some_and(|ch| ch.is_lowercase()) } -pub fn smart_case_conversion( +#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy)] +enum CapitalizeWords { + AllButFirst, + All, + First, +} + +fn smart_case_conversion( chars: impl Iterator, buf: &mut Tendril, - capitalize_first: bool, + capitalize: CapitalizeWords, separator: Option, ) { - let mut should_capitalize_current = capitalize_first; + let mut should_capitalize_current = capitalize != CapitalizeWords::AllButFirst; let mut prev = None; let add_separator_if_needed = |prev: Option, buf: &mut Tendril| { @@ -30,7 +37,7 @@ pub fn smart_case_conversion( for current in chars.skip_while(|ch| ch.is_whitespace()) { if !current.is_alphanumeric() { - should_capitalize_current = true; + should_capitalize_current = capitalize != CapitalizeWords::First; add_separator_if_needed(prev, buf); prev = Some(current); continue; @@ -38,7 +45,7 @@ pub fn smart_case_conversion( if has_camel_transition(prev, current) { add_separator_if_needed(prev, buf); - should_capitalize_current = true; + should_capitalize_current = capitalize != CapitalizeWords::First; } if should_capitalize_current { @@ -54,7 +61,7 @@ pub fn smart_case_conversion( *buf = buf.trim_end().into(); } -pub fn separator_case_conversion( +fn separator_case_conversion( chars: impl Iterator, buf: &mut Tendril, separator: char, @@ -143,15 +150,19 @@ pub fn into_snake_case(chars: impl Iterator, buf: &mut Tendril) { } pub fn into_title_case(chars: impl Iterator, buf: &mut Tendril) { - smart_case_conversion(chars, buf, true, Some(' ')); + smart_case_conversion(chars, buf, CapitalizeWords::All, Some(' ')); +} + +pub fn into_sentence_case(chars: impl Iterator, buf: &mut Tendril) { + smart_case_conversion(chars, buf, CapitalizeWords::First, Some(' ')); } pub fn into_camel_case(chars: impl Iterator, buf: &mut Tendril) { - smart_case_conversion(chars, buf, false, None); + smart_case_conversion(chars, buf, CapitalizeWords::AllButFirst, None); } pub fn into_pascal_case(chars: impl Iterator, buf: &mut Tendril) { - smart_case_conversion(chars, buf, true, None); + smart_case_conversion(chars, buf, CapitalizeWords::All, None); } /// Create functional versions of the "into_*" case functions that take a `&mut Tendril` @@ -176,6 +187,7 @@ to_case! { into_title_case => to_title_case into_kebab_case => to_kebab_case into_snake_case => to_snake_case + into_sentence_case => to_sentence_case } #[cfg(test)] @@ -296,6 +308,7 @@ mod tests { fn test_title_case_conversion() { let tests = [ ("hello world", "Hello World"), + ("hello world again", "Hello World Again"), ("Hello World", "Hello World"), ("hello_world", "Hello World"), ("HELLO_WORLD", "Hello World"), @@ -315,6 +328,30 @@ mod tests { } } + #[test] + fn test_sentence_case_conversion() { + let tests = [ + ("hello world", "Hello world"), + ("hello world again", "Hello world again"), + ("Hello World", "Hello world"), + ("hello_world", "Hello world"), + ("HELLO_WORLD", "Hello world"), + ("hello-world", "Hello world"), + ("hello world", "Hello world"), + (" hello world", "Hello world"), + ("hello\tworld", "Hello world"), + ("HELLO WORLD", "Hello world"), + ("HELLO-world", "Hello world"), + ("hello WORLD ", "Hello world"), + ("helloWorld", "Hello world"), + ]; + + for (input, expected) in tests { + dbg!(input); + assert_eq!(to_sentence_case(input.chars()), expected) + } + } + #[test] fn test_kebab_case_conversion() { let tests = [ diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs index 07de5adee..c209306c7 100644 --- a/helix-term/src/commands.rs +++ b/helix-term/src/commands.rs @@ -18,11 +18,7 @@ use tui::{ pub use typed::*; use helix_core::{ - case_conversion::{ - to_alternate_case, to_camel_case, to_kebab_case, to_lowercase, to_pascal_case, - to_snake_case, to_title_case, to_uppercase, - }, - char_idx_at_visual_offset, + case_conversion, char_idx_at_visual_offset, chars::char_is_word, command_line, comment, doc_formatter::TextFormat, @@ -361,6 +357,7 @@ impl MappableCommand { switch_to_pascal_case, "Switch to PascalCase", switch_to_camel_case, "Switch to camelCase", switch_to_title_case, "Switch to Title Case", + switch_to_sentence_case, "Switch to Sentence case", switch_to_snake_case, "Switch to snake_case", switch_to_kebab_case, "Switch to kebab-case", page_up, "Move page up", @@ -1717,6 +1714,7 @@ fn replace(cx: &mut Context) { }) } +#[inline] fn switch_case_impl(cx: &mut Context, change_fn: F) where F: for<'a> Fn(&mut (dyn Iterator + 'a)) -> Tendril, @@ -1739,35 +1737,39 @@ where } fn switch_to_pascal_case(cx: &mut Context) { - switch_case_impl(cx, |chars| to_pascal_case(chars)) + switch_case_impl(cx, |chars| case_conversion::to_pascal_case(chars)) } fn switch_to_camel_case(cx: &mut Context) { - switch_case_impl(cx, |chars| to_camel_case(chars)) + switch_case_impl(cx, |chars| case_conversion::to_camel_case(chars)) } fn switch_to_lowercase(cx: &mut Context) { - switch_case_impl(cx, |chars| to_lowercase(chars)) + switch_case_impl(cx, |chars| case_conversion::to_lowercase(chars)) } fn switch_to_uppercase(cx: &mut Context) { - switch_case_impl(cx, |chars| to_uppercase(chars)) + switch_case_impl(cx, |chars| case_conversion::to_uppercase(chars)) } fn switch_to_alternate_case(cx: &mut Context) { - switch_case_impl(cx, |chars| to_alternate_case(chars)) + switch_case_impl(cx, |chars| case_conversion::to_alternate_case(chars)) } fn switch_to_title_case(cx: &mut Context) { - switch_case_impl(cx, |chars| to_title_case(chars)) + switch_case_impl(cx, |chars| case_conversion::to_title_case(chars)) +} + +fn switch_to_sentence_case(cx: &mut Context) { + switch_case_impl(cx, |chars| case_conversion::to_sentence_case(chars)) } fn switch_to_snake_case(cx: &mut Context) { - switch_case_impl(cx, |chars| to_snake_case(chars)) + switch_case_impl(cx, |chars| case_conversion::to_snake_case(chars)) } fn switch_to_kebab_case(cx: &mut Context) { - switch_case_impl(cx, |chars| to_kebab_case(chars)) + switch_case_impl(cx, |chars| case_conversion::to_kebab_case(chars)) } pub fn scroll(cx: &mut Context, offset: usize, direction: Direction, sync_cursor: bool) { diff --git a/helix-term/src/keymap/default.rs b/helix-term/src/keymap/default.rs index f801dbbd1..256aa6c2c 100644 --- a/helix-term/src/keymap/default.rs +++ b/helix-term/src/keymap/default.rs @@ -27,6 +27,7 @@ pub fn default() -> HashMap { "p" => switch_to_pascal_case, "c" => switch_to_camel_case, "t" => switch_to_title_case, + "S" => switch_to_sentence_case, "s" => switch_to_snake_case, "k" => switch_to_kebab_case, }, From 13fa57542991c5e2cd493afdd500bc80a575193f Mon Sep 17 00:00:00 2001 From: Nik Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Tue, 25 Mar 2025 17:31:53 +0000 Subject: [PATCH 53/55] test: improved test syntax _ _ _ --- helix-core/src/case_conversion.rs | 321 ++++++++++++------------------ 1 file changed, 130 insertions(+), 191 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index f3ea6c73c..371cefb18 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -192,207 +192,146 @@ to_case! { #[cfg(test)] mod tests { - use super::*; - - #[test] - fn test_camel_case_conversion() { - let tests = [ - ("hello world", "helloWorld"), - ("Hello World", "helloWorld"), - ("hello_world", "helloWorld"), - ("HELLO_WORLD", "helloWorld"), - ("hello-world", "helloWorld"), - ("hello world", "helloWorld"), - (" hello world", "helloWorld"), - ("hello\tworld", "helloWorld"), - ("HELLO WORLD", "helloWorld"), - ("HELLO-world", "helloWorld"), - ("hello WORLD ", "helloWorld"), - ("helloWorld", "helloWorld"), - ]; - - for (input, expected) in tests { - assert_eq!(to_camel_case(input.chars()), expected) + macro_rules! test_case_converters { + ($($case_converter:ident: $($input:literal -> $expected:literal)*)*) => { + $( + #[test] + fn $case_converter() { + for (input, expected) in [ $(($input, $expected),)* ] { + assert_eq!(super::$case_converter(input.chars()), expected, "{input}"); + } + } + )* } } - #[test] - fn test_lower_case_conversion() { - let tests = [ - ("HelloWorld", "helloworld"), - ("HELLO WORLD", "hello world"), - ("hello_world", "hello_world"), - ("Hello-World", "hello-world"), - ("Hello", "hello"), - ("WORLD", "world"), - ("hello world", "hello world"), - ("HELLOworld", "helloworld"), - ("hello-world", "hello-world"), - ("hello_world_here", "hello_world_here"), - ("HELLO_world", "hello_world"), - ("MixEdCaseString", "mixedcasestring"), - ]; + test_case_converters! { + to_camel_case: + "hello world" -> "helloWorld" + "Hello World" -> "helloWorld" + "hello_world" -> "helloWorld" + "HELLO_WORLD" -> "helloWorld" + "hello-world" -> "helloWorld" + "hello world" -> "helloWorld" + " hello world" -> "helloWorld" + "hello\tworld" -> "helloWorld" + "HELLO WORLD" -> "helloWorld" + "HELLO-world" -> "helloWorld" + "hello WORLD " -> "helloWorld" + "helloWorld" -> "helloWorld" - for (input, expected) in tests { - assert_eq!(to_lowercase(input.chars()), expected) - } - } + to_pascal_case: + "hello world" -> "HelloWorld" + "Hello World" -> "HelloWorld" + "hello_world" -> "HelloWorld" + "HELLO_WORLD" -> "HelloWorld" + "hello-world" -> "HelloWorld" + "hello world" -> "HelloWorld" + " hello world" -> "HelloWorld" + "hello\tworld" -> "HelloWorld" + "HELLO WORLD" -> "HelloWorld" + "HELLO-world" -> "HelloWorld" + "hello WORLD " -> "HelloWorld" + "helloWorld" -> "HelloWorld" - #[test] - fn test_upper_case_conversion() { - let tests = [ - ("helloWorld", "HELLOWORLD"), - ("hello world", "HELLO WORLD"), - ("hello_world", "HELLO_WORLD"), - ("Hello-World", "HELLO-WORLD"), - ("Hello", "HELLO"), - ("world", "WORLD"), - ("hello world", "HELLO WORLD"), - ("helloworld", "HELLOWORLD"), - ("hello-world", "HELLO-WORLD"), - ("hello_world_here", "HELLO_WORLD_HERE"), - ("hello_WORLD", "HELLO_WORLD"), - ("mixedCaseString", "MIXEDCASESTRING"), - ]; + to_snake_case: + "helloWorld" -> "hello_world" + "HelloWorld" -> "hello_world" + "hello world" -> "hello_world" + "HELLO WORLD" -> "hello_world" + "hello-world" -> "hello_world" + "hello world" -> "hello_world" + "hello\tworld" -> "hello_world" + "HELLO WORLD" -> "hello_world" + "HELLO-world" -> "hello_world" + "hello WORLD " -> "hello_world" + "helloWorld" -> "hello_world" + "helloWORLD123" -> "hello_world123" - for (input, expected) in tests { - assert_eq!(to_uppercase(input.chars()), expected) - } - } + to_kebab_case: + "helloWorld" -> "hello-world" + "HelloWorld" -> "hello-world" + "hello_world" -> "hello-world" + "HELLO_WORLD" -> "hello-world" + "hello-world" -> "hello-world" + "hello world" -> "hello-world" + "hello\tworld" -> "hello-world" + "HELLO WORLD" -> "hello-world" + "HELLO-world" -> "hello-world" + "hello WORLD " -> "hello-world" + "helloWorld" -> "hello-world" + "HelloWorld123" -> "hello-world123" - #[test] - fn test_pascal_case_conversion() { - let tests = [ - ("hello world", "HelloWorld"), - ("Hello World", "HelloWorld"), - ("hello_world", "HelloWorld"), - ("HELLO_WORLD", "HelloWorld"), - ("hello-world", "HelloWorld"), - ("hello world", "HelloWorld"), - (" hello world", "HelloWorld"), - ("hello\tworld", "HelloWorld"), - ("HELLO WORLD", "HelloWorld"), - ("HELLO-world", "HelloWorld"), - ("hello WORLD ", "HelloWorld"), - ("helloWorld", "HelloWorld"), - ]; + to_title_case: + "hello world" -> "Hello World" + "hello world again" -> "Hello World Again" + "Hello World" -> "Hello World" + "hello_world" -> "Hello World" + "HELLO_WORLD" -> "Hello World" + "hello-world" -> "Hello World" + "hello world" -> "Hello World" + " hello world" -> "Hello World" + "hello\tworld" -> "Hello World" + "HELLO WORLD" -> "Hello World" + "HELLO-world" -> "Hello World" + "hello WORLD " -> "Hello World" + "helloWorld" -> "Hello World" - for (input, expected) in tests { - assert_eq!(to_pascal_case(input.chars()), expected) - } - } + to_sentence_case: + "hello world" -> "Hello world" + "hello world again" -> "Hello world again" + "Hello World" -> "Hello world" + "hello_world" -> "Hello world" + "HELLO_WORLD" -> "Hello world" + "hello-world" -> "Hello world" + "hello world" -> "Hello world" + " hello world" -> "Hello world" + "hello\tworld" -> "Hello world" + "HELLO WORLD" -> "Hello world" + "HELLO-world" -> "Hello world" + "hello WORLD " -> "Hello world" + "helloWorld" -> "Hello world" - #[test] - fn test_alternate_case_conversion() { - let tests = [ - ("hello world", "HELLO WORLD"), - ("Hello World", "hELLO wORLD"), - ("helLo_woRlD", "HELlO_WOrLd"), - ("HELLO_world", "hello_WORLD"), - ("hello-world", "HELLO-WORLD"), - ("Hello-world", "hELLO-WORLD"), - ("hello", "HELLO"), - ("HELLO", "hello"), - ("hello123", "HELLO123"), - ("hello WORLD", "HELLO world"), - ("HELLO123 world", "hello123 WORLD"), - ("world hello", "WORLD HELLO"), - ]; + to_alternate_case: + "hello world" -> "HELLO WORLD" + "Hello World" -> "hELLO wORLD" + "helLo_woRlD" -> "HELlO_WOrLd" + "HELLO_world" -> "hello_WORLD" + "hello-world" -> "HELLO-WORLD" + "Hello-world" -> "hELLO-WORLD" + "hello" -> "HELLO" + "HELLO" -> "hello" + "hello123" -> "HELLO123" + "hello WORLD" -> "HELLO world" + "HELLO123 world" -> "hello123 WORLD" + "world hello" -> "WORLD HELLO" - for (input, expected) in tests { - assert_eq!(to_alternate_case(input.chars()), expected) - } - } + to_uppercase: + "helloWorld" -> "HELLOWORLD" + "hello world" -> "HELLO WORLD" + "hello_world" -> "HELLO_WORLD" + "Hello-World" -> "HELLO-WORLD" + "Hello" -> "HELLO" + "world" -> "WORLD" + "hello world" -> "HELLO WORLD" + "helloworld" -> "HELLOWORLD" + "hello-world" -> "HELLO-WORLD" + "hello_world_here" -> "HELLO_WORLD_HERE" + "hello_WORLD" -> "HELLO_WORLD" + "mixedCaseString" -> "MIXEDCASESTRING" - #[test] - fn test_title_case_conversion() { - let tests = [ - ("hello world", "Hello World"), - ("hello world again", "Hello World Again"), - ("Hello World", "Hello World"), - ("hello_world", "Hello World"), - ("HELLO_WORLD", "Hello World"), - ("hello-world", "Hello World"), - ("hello world", "Hello World"), - (" hello world", "Hello World"), - ("hello\tworld", "Hello World"), - ("HELLO WORLD", "Hello World"), - ("HELLO-world", "Hello World"), - ("hello WORLD ", "Hello World"), - ("helloWorld", "Hello World"), - ]; - - for (input, expected) in tests { - dbg!(input); - assert_eq!(to_title_case(input.chars()), expected) - } - } - - #[test] - fn test_sentence_case_conversion() { - let tests = [ - ("hello world", "Hello world"), - ("hello world again", "Hello world again"), - ("Hello World", "Hello world"), - ("hello_world", "Hello world"), - ("HELLO_WORLD", "Hello world"), - ("hello-world", "Hello world"), - ("hello world", "Hello world"), - (" hello world", "Hello world"), - ("hello\tworld", "Hello world"), - ("HELLO WORLD", "Hello world"), - ("HELLO-world", "Hello world"), - ("hello WORLD ", "Hello world"), - ("helloWorld", "Hello world"), - ]; - - for (input, expected) in tests { - dbg!(input); - assert_eq!(to_sentence_case(input.chars()), expected) - } - } - - #[test] - fn test_kebab_case_conversion() { - let tests = [ - ("helloWorld", "hello-world"), - ("HelloWorld", "hello-world"), - ("hello_world", "hello-world"), - ("HELLO_WORLD", "hello-world"), - ("hello-world", "hello-world"), - ("hello world", "hello-world"), - ("hello\tworld", "hello-world"), - ("HELLO WORLD", "hello-world"), - ("HELLO-world", "hello-world"), - ("hello WORLD ", "hello-world"), - ("helloWorld", "hello-world"), - ("HelloWorld123", "hello-world123"), - ]; - - for (input, expected) in tests { - assert_eq!(to_kebab_case(input.chars()), expected) - } - } - - #[test] - fn test_snake_case_conversion() { - let tests = [ - ("helloWorld", "hello_world"), - ("HelloWorld", "hello_world"), - ("hello world", "hello_world"), - ("HELLO WORLD", "hello_world"), - ("hello-world", "hello_world"), - ("hello world", "hello_world"), - ("hello\tworld", "hello_world"), - ("HELLO WORLD", "hello_world"), - ("HELLO-world", "hello_world"), - ("hello WORLD ", "hello_world"), - ("helloWorld", "hello_world"), - ("helloWORLD123", "hello_world123"), - ]; - - for (input, expected) in tests { - assert_eq!(to_snake_case(input.chars()), expected) - } + to_lowercase: + "HelloWorld" -> "helloworld" + "HELLO WORLD" -> "hello world" + "hello_world" -> "hello_world" + "Hello-World" -> "hello-world" + "Hello" -> "hello" + "WORLD" -> "world" + "hello world" -> "hello world" + "HELLOworld" -> "helloworld" + "hello-world" -> "hello-world" + "hello_world_here" -> "hello_world_here" + "HELLO_world" -> "hello_world" + "MixEdCaseString" -> "mixedcasestring" } } From d6c067106a18b5ef093d68e37965c7cbc743804d Mon Sep 17 00:00:00 2001 From: Nik Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Tue, 25 Mar 2025 17:49:01 +0000 Subject: [PATCH 54/55] docs: add documentation comments --- helix-core/src/case_conversion.rs | 151 +++++++++++++++++++----------- 1 file changed, 94 insertions(+), 57 deletions(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 371cefb18..8891eb616 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -9,14 +9,90 @@ fn has_camel_transition(prev: Option, current: char) -> bool { current.is_uppercase() && prev.is_some_and(|ch| ch.is_lowercase()) } +/// In-place conversion into `UPPERCASE` +pub fn into_uppercase(chars: impl Iterator, buf: &mut Tendril) { + *buf = chars.flat_map(char::to_uppercase).collect(); +} + +/// In-place conversion into `lowercase` +pub fn into_lowercase(chars: impl Iterator, buf: &mut Tendril) { + *buf = chars.flat_map(char::to_lowercase).collect(); +} + +/// Change case of a character iterator and put the result into the `buf`. +/// +/// # Arguments +/// +/// - `separator`: Choose what character to insert between the words +fn case_converter_with_separator( + chars: impl Iterator, + buf: &mut Tendril, + separator: char, +) { + let mut prev = None; + + for current in chars.skip_while(|ch| ch.is_whitespace()) { + if !current.is_alphanumeric() { + prev = Some(current); + continue; + } + + // "email@somewhere" => transition at 'l' -> '@' + // first character must not be separator, e.g. @emailSomewhere should not become -email-somewhere + let has_alphanum_transition = !prev.is_some_and(|p| p.is_alphanumeric()) && !buf.is_empty(); + + if has_camel_transition(prev, current) || has_alphanum_transition { + buf.push(separator); + } + + buf.extend(current.to_lowercase()); + + prev = Some(current); + } +} + +/// In-place conversion into `kebab-case` +pub fn into_kebab_case(chars: impl Iterator, buf: &mut Tendril) { + case_converter_with_separator(chars, buf, '-'); +} + +/// In-place conversion into `PascalCase` +pub fn into_snake_case(chars: impl Iterator, buf: &mut Tendril) { + case_converter_with_separator(chars, buf, '_'); +} + +// todo: should this be grapheme aware? + +/// Choose how words are capitalized #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy)] enum CapitalizeWords { + /// # Examples + /// + /// - oneTwoThree + /// - one-Two-Three + /// - one Two Three AllButFirst, + /// # Examples + /// + /// - OneTwoThree + /// - One-Two-Three + /// - One Two Three All, + /// # Examples + /// + /// - Onetwothree + /// - One-two-three + /// - One two three First, } -fn smart_case_conversion( +/// Change case of a character iterator and put the result into the `buf`. +/// +/// # Arguments +/// +/// - `capitalize`: Choose how to capitalize the output +/// - `separator`: Character to insert between the words +fn case_converter_with_capitalization_and_separator( chars: impl Iterator, buf: &mut Tendril, capitalize: CapitalizeWords, @@ -61,31 +137,24 @@ fn smart_case_conversion( *buf = buf.trim_end().into(); } -fn separator_case_conversion( - chars: impl Iterator, - buf: &mut Tendril, - separator: char, -) { - let mut prev = None; +/// In-place conversion into `Title Case` +pub fn into_title_case(chars: impl Iterator, buf: &mut Tendril) { + case_converter_with_capitalization_and_separator(chars, buf, CapitalizeWords::All, Some(' ')); +} - for current in chars.skip_while(|ch| ch.is_whitespace()) { - if !current.is_alphanumeric() { - prev = Some(current); - continue; - } +/// In-place conversion into `Sentence case` +pub fn into_sentence_case(chars: impl Iterator, buf: &mut Tendril) { + case_converter_with_capitalization_and_separator(chars, buf, CapitalizeWords::First, Some(' ')); +} - // "email@somewhere" => transition at 'l' -> '@' - // first character must not be separator, e.g. @emailSomewhere should not become -email-somewhere - let has_alphanum_transition = !prev.is_some_and(|p| p.is_alphanumeric()) && !buf.is_empty(); +/// In-place conversion into `camelCase` +pub fn into_camel_case(chars: impl Iterator, buf: &mut Tendril) { + case_converter_with_capitalization_and_separator(chars, buf, CapitalizeWords::AllButFirst, None); +} - if has_camel_transition(prev, current) || has_alphanum_transition { - buf.push(separator); - } - - buf.extend(current.to_lowercase()); - - prev = Some(current); - } +/// In-place conversion into `PascalCase` +pub fn into_pascal_case(chars: impl Iterator, buf: &mut Tendril) { + case_converter_with_capitalization_and_separator(chars, buf, CapitalizeWords::All, None); } enum AlternateCase { @@ -110,8 +179,8 @@ impl Iterator for AlternateCase { AlternateCase::Upper(upper) => upper.size_hint(), AlternateCase::Lower(lower) => lower.size_hint(), AlternateCase::Keep(ch) => { - let n = if ch.is_some() { 1 } else { 0 }; - (n, Some(n)) + let size = ch.is_some() as usize; + (size, Some(size)) } } } @@ -133,38 +202,6 @@ pub fn into_alternate_case(chars: impl Iterator, buf: &mut Tendril) .collect(); } -pub fn into_uppercase(chars: impl Iterator, buf: &mut Tendril) { - *buf = chars.flat_map(char::to_uppercase).collect(); -} - -pub fn into_lowercase(chars: impl Iterator, buf: &mut Tendril) { - *buf = chars.flat_map(char::to_lowercase).collect(); -} - -pub fn into_kebab_case(chars: impl Iterator, buf: &mut Tendril) { - separator_case_conversion(chars, buf, '-'); -} - -pub fn into_snake_case(chars: impl Iterator, buf: &mut Tendril) { - separator_case_conversion(chars, buf, '_'); -} - -pub fn into_title_case(chars: impl Iterator, buf: &mut Tendril) { - smart_case_conversion(chars, buf, CapitalizeWords::All, Some(' ')); -} - -pub fn into_sentence_case(chars: impl Iterator, buf: &mut Tendril) { - smart_case_conversion(chars, buf, CapitalizeWords::First, Some(' ')); -} - -pub fn into_camel_case(chars: impl Iterator, buf: &mut Tendril) { - smart_case_conversion(chars, buf, CapitalizeWords::AllButFirst, None); -} - -pub fn into_pascal_case(chars: impl Iterator, buf: &mut Tendril) { - smart_case_conversion(chars, buf, CapitalizeWords::All, None); -} - /// Create functional versions of the "into_*" case functions that take a `&mut Tendril` macro_rules! to_case { ($($into_case:ident => $to_case:ident)*) => { From ed80c33ad1403dd5a0f46b93bd09a1f95000aed8 Mon Sep 17 00:00:00 2001 From: Nik Revenco <154856872+NikitaRevenco@users.noreply.github.com> Date: Tue, 25 Mar 2025 18:41:52 +0000 Subject: [PATCH 55/55] style: fmt --- helix-core/src/case_conversion.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/helix-core/src/case_conversion.rs b/helix-core/src/case_conversion.rs index 8891eb616..e2cbffafe 100644 --- a/helix-core/src/case_conversion.rs +++ b/helix-core/src/case_conversion.rs @@ -149,7 +149,12 @@ pub fn into_sentence_case(chars: impl Iterator, buf: &mut Tendril) /// In-place conversion into `camelCase` pub fn into_camel_case(chars: impl Iterator, buf: &mut Tendril) { - case_converter_with_capitalization_and_separator(chars, buf, CapitalizeWords::AllButFirst, None); + case_converter_with_capitalization_and_separator( + chars, + buf, + CapitalizeWords::AllButFirst, + None, + ); } /// In-place conversion into `PascalCase`