diff --git a/book/src/keymap.md b/book/src/keymap.md
index 7a896035..335e393b 100644
--- a/book/src/keymap.md
+++ b/book/src/keymap.md
@@ -72,6 +72,8 @@
| `=` | Format selection (**LSP**) | `format_selections` |
| `d` | Delete selection | `delete_selection` |
| `c` | Change selection (delete and enter insert mode) | `change_selection` |
+| `Ctrl-a` | Increment object (number) under cursor | `increment` |
+| `Ctrl-x` | Decrement object (number) under cursor | `decrement` |
#### Shell
diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs
index d1720df0..de7e95c1 100644
--- a/helix-core/src/lib.rs
+++ b/helix-core/src/lib.rs
@@ -10,6 +10,7 @@ pub mod line_ending;
pub mod macros;
pub mod match_brackets;
pub mod movement;
+pub mod numbers;
pub mod object;
pub mod path;
mod position;
diff --git a/helix-core/src/numbers.rs b/helix-core/src/numbers.rs
new file mode 100644
index 00000000..e9f3c898
--- /dev/null
+++ b/helix-core/src/numbers.rs
@@ -0,0 +1,499 @@
+use std::borrow::Cow;
+
+use ropey::RopeSlice;
+
+use crate::{
+ textobject::{textobject_word, TextObject},
+ Range, Tendril,
+};
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct NumberIncrementor<'a> {
+ pub range: Range,
+ pub value: i64,
+ pub radix: u32,
+
+ text: RopeSlice<'a>,
+}
+
+impl<'a> NumberIncrementor<'a> {
+ /// Return information about number under rang if there is one.
+ pub fn from_range(text: RopeSlice, range: Range) -> Option<NumberIncrementor> {
+ // If the cursor is on the minus sign of a number we want to get the word textobject to the
+ // right of it.
+ let range = if range.to() < text.len_chars()
+ && range.to() - range.from() <= 1
+ && text.char(range.from()) == '-'
+ {
+ Range::new(range.from() + 1, range.to() + 1)
+ } else {
+ range
+ };
+
+ let range = textobject_word(text, range, TextObject::Inside, 1, false);
+
+ // If there is a minus sign to the left of the word object, we want to include it in the range.
+ let range = if range.from() > 0 && text.char(range.from() - 1) == '-' {
+ range.extend(range.from() - 1, range.from())
+ } else {
+ range
+ };
+
+ let word: String = text
+ .slice(range.from()..range.to())
+ .chars()
+ .filter(|&c| c != '_')
+ .collect();
+ let (radix, prefixed) = if word.starts_with("0x") {
+ (16, true)
+ } else if word.starts_with("0o") {
+ (8, true)
+ } else if word.starts_with("0b") {
+ (2, true)
+ } else {
+ (10, false)
+ };
+
+ let number = if prefixed { &word[2..] } else { &word };
+
+ let value = i128::from_str_radix(number, radix).ok()?;
+ if (value.is_positive() && value.leading_zeros() < 64)
+ || (value.is_negative() && value.leading_ones() < 64)
+ {
+ return None;
+ }
+
+ let value = value as i64;
+ Some(NumberIncrementor {
+ range,
+ value,
+ radix,
+ text,
+ })
+ }
+
+ /// Add `amount` to the number and return the formatted text.
+ pub fn incremented_text(&self, amount: i64) -> Tendril {
+ let old_text: Cow<str> = self.text.slice(self.range.from()..self.range.to()).into();
+ let old_length = old_text.len();
+ let new_value = self.value.wrapping_add(amount);
+
+ // Get separator indexes from right to left.
+ let separator_rtl_indexes: Vec<usize> = old_text
+ .chars()
+ .rev()
+ .enumerate()
+ .filter_map(|(i, c)| if c == '_' { Some(i) } else { None })
+ .collect();
+
+ let format_length = if self.radix == 10 {
+ match (self.value.is_negative(), new_value.is_negative()) {
+ (true, false) => old_length - 1,
+ (false, true) => old_length + 1,
+ _ => old_text.len(),
+ }
+ } else {
+ old_text.len() - 2
+ } - separator_rtl_indexes.len();
+
+ let mut new_text = match self.radix {
+ 2 => format!("0b{:01$b}", new_value, format_length),
+ 8 => format!("0o{:01$o}", new_value, format_length),
+ 10 if old_text.starts_with('0') || old_text.starts_with("-0") => {
+ format!("{:01$}", new_value, format_length)
+ }
+ 10 => format!("{}", new_value),
+ 16 => {
+ let (lower_count, upper_count): (usize, usize) =
+ old_text.chars().skip(2).fold((0, 0), |(lower, upper), c| {
+ (
+ lower + c.is_ascii_lowercase().then(|| 1).unwrap_or(0),
+ upper + c.is_ascii_uppercase().then(|| 1).unwrap_or(0),
+ )
+ });
+ if upper_count > lower_count {
+ format!("0x{:01$X}", new_value, format_length)
+ } else {
+ format!("0x{:01$x}", new_value, format_length)
+ }
+ }
+ _ => unimplemented!("radix not supported: {}", self.radix),
+ };
+
+ // Add separators from original number.
+ for &rtl_index in &separator_rtl_indexes {
+ if rtl_index < new_text.len() {
+ let new_index = new_text.len() - rtl_index;
+ new_text.insert(new_index, '_');
+ }
+ }
+
+ // Add in additional separators if necessary.
+ if new_text.len() > old_length && !separator_rtl_indexes.is_empty() {
+ let spacing = match separator_rtl_indexes.as_slice() {
+ [.., b, a] => a - b - 1,
+ _ => separator_rtl_indexes[0],
+ };
+
+ let prefix_length = if self.radix == 10 { 0 } else { 2 };
+ if let Some(mut index) = new_text.find('_') {
+ while index - prefix_length > spacing {
+ index -= spacing;
+ new_text.insert(index, '_');
+ }
+ }
+ }
+
+ new_text.into()
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::Rope;
+
+ #[test]
+ fn test_decimal_at_point() {
+ let rope = Rope::from_str("Test text 12345 more text.");
+ let range = Range::point(12);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(10, 15),
+ value: 12345,
+ radix: 10,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_uppercase_hexadecimal_at_point() {
+ let rope = Rope::from_str("Test text 0x123ABCDEF more text.");
+ let range = Range::point(12);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(10, 21),
+ value: 0x123ABCDEF,
+ radix: 16,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_lowercase_hexadecimal_at_point() {
+ let rope = Rope::from_str("Test text 0xfa3b4e more text.");
+ let range = Range::point(12);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(10, 18),
+ value: 0xfa3b4e,
+ radix: 16,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_octal_at_point() {
+ let rope = Rope::from_str("Test text 0o1074312 more text.");
+ let range = Range::point(12);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(10, 19),
+ value: 0o1074312,
+ radix: 8,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_binary_at_point() {
+ let rope = Rope::from_str("Test text 0b10111010010101 more text.");
+ let range = Range::point(12);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(10, 26),
+ value: 0b10111010010101,
+ radix: 2,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_negative_decimal_at_point() {
+ let rope = Rope::from_str("Test text -54321 more text.");
+ let range = Range::point(12);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(10, 16),
+ value: -54321,
+ radix: 10,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_decimal_with_leading_zeroes_at_point() {
+ let rope = Rope::from_str("Test text 000045326 more text.");
+ let range = Range::point(12);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(10, 19),
+ value: 45326,
+ radix: 10,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_negative_decimal_cursor_on_minus_sign() {
+ let rope = Rope::from_str("Test text -54321 more text.");
+ let range = Range::point(10);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(10, 16),
+ value: -54321,
+ radix: 10,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_number_under_range_start_of_rope() {
+ let rope = Rope::from_str("100");
+ let range = Range::point(0);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(0, 3),
+ value: 100,
+ radix: 10,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_number_under_range_end_of_rope() {
+ let rope = Rope::from_str("100");
+ let range = Range::point(2);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(0, 3),
+ value: 100,
+ radix: 10,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_number_surrounded_by_punctuation() {
+ let rope = Rope::from_str(",100;");
+ let range = Range::point(1);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range),
+ Some(NumberIncrementor {
+ range: Range::new(1, 4),
+ value: 100,
+ radix: 10,
+ text: rope.slice(..),
+ })
+ );
+ }
+
+ #[test]
+ fn test_not_a_number_point() {
+ let rope = Rope::from_str("Test text 45326 more text.");
+ let range = Range::point(6);
+ assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
+ }
+
+ #[test]
+ fn test_number_too_large_at_point() {
+ let rope = Rope::from_str("Test text 0xFFFFFFFFFFFFFFFFF more text.");
+ let range = Range::point(12);
+ assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
+ }
+
+ #[test]
+ fn test_number_cursor_one_right_of_number() {
+ let rope = Rope::from_str("100 ");
+ let range = Range::point(3);
+ assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
+ }
+
+ #[test]
+ fn test_number_cursor_one_left_of_number() {
+ let rope = Rope::from_str(" 100");
+ let range = Range::point(0);
+ assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
+ }
+
+ #[test]
+ fn test_increment_basic_decimal_numbers() {
+ let tests = [
+ ("100", 1, "101"),
+ ("100", -1, "99"),
+ ("99", 1, "100"),
+ ("100", 1000, "1100"),
+ ("100", -1000, "-900"),
+ ("-1", 1, "0"),
+ ("-1", 2, "1"),
+ ("1", -1, "0"),
+ ("1", -2, "-1"),
+ ];
+
+ for (original, amount, expected) in tests {
+ let rope = Rope::from_str(original);
+ let range = Range::point(0);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range)
+ .unwrap()
+ .incremented_text(amount),
+ expected.into()
+ );
+ }
+ }
+
+ #[test]
+ fn test_increment_basic_hexadedimal_numbers() {
+ let tests = [
+ ("0x0100", 1, "0x0101"),
+ ("0x0100", -1, "0x00ff"),
+ ("0x0001", -1, "0x0000"),
+ ("0x0000", -1, "0xffffffffffffffff"),
+ ("0xffffffffffffffff", 1, "0x0000000000000000"),
+ ("0xffffffffffffffff", 2, "0x0000000000000001"),
+ ("0xffffffffffffffff", -1, "0xfffffffffffffffe"),
+ ("0xABCDEF1234567890", 1, "0xABCDEF1234567891"),
+ ("0xabcdef1234567890", 1, "0xabcdef1234567891"),
+ ];
+
+ for (original, amount, expected) in tests {
+ let rope = Rope::from_str(original);
+ let range = Range::point(0);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range)
+ .unwrap()
+ .incremented_text(amount),
+ expected.into()
+ );
+ }
+ }
+
+ #[test]
+ fn test_increment_basic_octal_numbers() {
+ let tests = [
+ ("0o0107", 1, "0o0110"),
+ ("0o0110", -1, "0o0107"),
+ ("0o0001", -1, "0o0000"),
+ ("0o7777", 1, "0o10000"),
+ ("0o1000", -1, "0o0777"),
+ ("0o0107", 10, "0o0121"),
+ ("0o0000", -1, "0o1777777777777777777777"),
+ ("0o1777777777777777777777", 1, "0o0000000000000000000000"),
+ ("0o1777777777777777777777", 2, "0o0000000000000000000001"),
+ ("0o1777777777777777777777", -1, "0o1777777777777777777776"),
+ ];
+
+ for (original, amount, expected) in tests {
+ let rope = Rope::from_str(original);
+ let range = Range::point(0);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range)
+ .unwrap()
+ .incremented_text(amount),
+ expected.into()
+ );
+ }
+ }
+
+ #[test]
+ fn test_increment_basic_binary_numbers() {
+ let tests = [
+ ("0b00000100", 1, "0b00000101"),
+ ("0b00000100", -1, "0b00000011"),
+ ("0b00000100", 2, "0b00000110"),
+ ("0b00000100", -2, "0b00000010"),
+ ("0b00000001", -1, "0b00000000"),
+ ("0b00111111", 10, "0b01001001"),
+ ("0b11111111", 1, "0b100000000"),
+ ("0b10000000", -1, "0b01111111"),
+ (
+ "0b0000",
+ -1,
+ "0b1111111111111111111111111111111111111111111111111111111111111111",
+ ),
+ (
+ "0b1111111111111111111111111111111111111111111111111111111111111111",
+ 1,
+ "0b0000000000000000000000000000000000000000000000000000000000000000",
+ ),
+ (
+ "0b1111111111111111111111111111111111111111111111111111111111111111",
+ 2,
+ "0b0000000000000000000000000000000000000000000000000000000000000001",
+ ),
+ (
+ "0b1111111111111111111111111111111111111111111111111111111111111111",
+ -1,
+ "0b1111111111111111111111111111111111111111111111111111111111111110",
+ ),
+ ];
+
+ for (original, amount, expected) in tests {
+ let rope = Rope::from_str(original);
+ let range = Range::point(0);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range)
+ .unwrap()
+ .incremented_text(amount),
+ expected.into()
+ );
+ }
+ }
+
+ #[test]
+ fn test_increment_with_separators() {
+ let tests = [
+ ("999_999", 1, "1_000_000"),
+ ("1_000_000", -1, "999_999"),
+ ("-999_999", -1, "-1_000_000"),
+ ("0x0000_0000_0001", 0x1_ffff_0000, "0x0001_ffff_0001"),
+ ("0x0000_0000_0001", 0x1_ffff_0000, "0x0001_ffff_0001"),
+ ("0x0000_0000_0001", 0x1_ffff_0000, "0x0001_ffff_0001"),
+ ("0x0000_0000", -1, "0xffff_ffff_ffff_ffff"),
+ ("0x0000_0000_0000", -1, "0xffff_ffff_ffff_ffff"),
+ ("0b01111111_11111111", 1, "0b10000000_00000000"),
+ ("0b11111111_11111111", 1, "0b1_00000000_00000000"),
+ ];
+
+ for (original, amount, expected) in tests {
+ let rope = Rope::from_str(original);
+ let range = Range::point(0);
+ assert_eq!(
+ NumberIncrementor::from_range(rope.slice(..), range)
+ .unwrap()
+ .incremented_text(amount),
+ expected.into()
+ );
+ }
+ }
+}
diff --git a/helix-term/src/commands.rs b/helix-term/src/commands.rs
index 74bc52fd..7ef8f56c 100644
--- a/helix-term/src/commands.rs
+++ b/helix-term/src/commands.rs
@@ -6,6 +6,7 @@ use helix_core::{
line_ending::{get_line_ending_of_str, line_end_char_index, str_is_line_ending},
match_brackets,
movement::{self, Direction},
+ numbers::NumberIncrementor,
object, pos_at_coords,
regex::{self, Regex, RegexBuilder},
register::Register,
@@ -354,6 +355,8 @@ impl Command {
shell_keep_pipe, "Filter selections with shell predicate",
suspend, "Suspend",
rename_symbol, "Rename symbol",
+ increment, "Increment",
+ decrement, "Decrement",
);
}
@@ -5459,3 +5462,38 @@ fn rename_symbol(cx: &mut Context) {
);
cx.push_layer(Box::new(prompt));
}
+
+/// Increment object under cursor by count.
+fn increment(cx: &mut Context) {
+ increment_impl(cx, cx.count() as i64);
+}
+
+/// Decrement object under cursor by count.
+fn decrement(cx: &mut Context) {
+ increment_impl(cx, -(cx.count() as i64));
+}
+
+/// Decrement object under cursor by `amount`.
+fn increment_impl(cx: &mut Context, amount: i64) {
+ let (view, doc) = current!(cx.editor);
+ let selection = doc.selection(view.id);
+ let text = doc.text();
+
+ let changes = selection.ranges().iter().filter_map(|range| {
+ let incrementor = NumberIncrementor::from_range(text.slice(..), *range)?;
+ let new_text = incrementor.incremented_text(amount);
+ Some((
+ incrementor.range.from(),
+ incrementor.range.to(),
+ Some(new_text),
+ ))
+ });
+
+ if changes.clone().count() > 0 {
+ let transaction = Transaction::change(doc.text(), changes);
+ let transaction = transaction.with_selection(selection.clone());
+
+ doc.apply(&transaction, view.id);
+ doc.append_changes_to_history(view.id);
+ }
+}
diff --git a/helix-term/src/keymap.rs b/helix-term/src/keymap.rs
index fdf43d87..bf3b594e 100644
--- a/helix-term/src/keymap.rs
+++ b/helix-term/src/keymap.rs
@@ -698,6 +698,9 @@ impl Default for Keymaps {
"A-!" => shell_append_output,
"$" => shell_keep_pipe,
"C-z" => suspend,
+
+ "C-a" => increment,
+ "C-x" => decrement,
});
let mut select = normal.clone();
select.merge_nodes(keymap!({ "Select mode"