@@ -0,0 +1,499 @@
1+use std::borrow::Cow;
2+
3+use ropey::RopeSlice;
4+
5+use crate::{
6+ textobject::{textobject_word, TextObject},
7+ Range, Tendril,
8+};
9+
10+#[derive(Debug, PartialEq, Eq)]
11+pub struct NumberIncrementor<'a> {
12+ pub range: Range,
13+ pub value: i64,
14+ pub radix: u32,
15+
16+ text: RopeSlice<'a>,
17+}
18+
19+impl<'a> NumberIncrementor<'a> {
20+ /// Return information about number under rang if there is one.
21+ pub fn from_range(text: RopeSlice, range: Range) -> Option<NumberIncrementor> {
22+ // If the cursor is on the minus sign of a number we want to get the word textobject to the
23+ // right of it.
24+ let range = if range.to() < text.len_chars()
25+ && range.to() - range.from() <= 1
26+ && text.char(range.from()) == '-'
27+ {
28+ Range::new(range.from() + 1, range.to() + 1)
29+ } else {
30+ range
31+ };
32+
33+ let range = textobject_word(text, range, TextObject::Inside, 1, false);
34+
35+ // If there is a minus sign to the left of the word object, we want to include it in the range.
36+ let range = if range.from() > 0 && text.char(range.from() - 1) == '-' {
37+ range.extend(range.from() - 1, range.from())
38+ } else {
39+ range
40+ };
41+
42+ let word: String = text
43+ .slice(range.from()..range.to())
44+ .chars()
45+ .filter(|&c| c != '_')
46+ .collect();
47+ let (radix, prefixed) = if word.starts_with("0x") {
48+ (16, true)
49+ } else if word.starts_with("0o") {
50+ (8, true)
51+ } else if word.starts_with("0b") {
52+ (2, true)
53+ } else {
54+ (10, false)
55+ };
56+
57+ let number = if prefixed { &word[2..] } else { &word };
58+
59+ let value = i128::from_str_radix(number, radix).ok()?;
60+ if (value.is_positive() && value.leading_zeros() < 64)
61+ || (value.is_negative() && value.leading_ones() < 64)
62+ {
63+ return None;
64+ }
65+
66+ let value = value as i64;
67+ Some(NumberIncrementor {
68+ range,
69+ value,
70+ radix,
71+ text,
72+ })
73+ }
74+
75+ /// Add `amount` to the number and return the formatted text.
76+ pub fn incremented_text(&self, amount: i64) -> Tendril {
77+ let old_text: Cow<str> = self.text.slice(self.range.from()..self.range.to()).into();
78+ let old_length = old_text.len();
79+ let new_value = self.value.wrapping_add(amount);
80+
81+ // Get separator indexes from right to left.
82+ let separator_rtl_indexes: Vec<usize> = old_text
83+ .chars()
84+ .rev()
85+ .enumerate()
86+ .filter_map(|(i, c)| if c == '_' { Some(i) } else { None })
87+ .collect();
88+
89+ let format_length = if self.radix == 10 {
90+ match (self.value.is_negative(), new_value.is_negative()) {
91+ (true, false) => old_length - 1,
92+ (false, true) => old_length + 1,
93+ _ => old_text.len(),
94+ }
95+ } else {
96+ old_text.len() - 2
97+ } - separator_rtl_indexes.len();
98+
99+ let mut new_text = match self.radix {
100+ 2 => format!("0b{:01$b}", new_value, format_length),
101+ 8 => format!("0o{:01$o}", new_value, format_length),
102+ 10 if old_text.starts_with('0') || old_text.starts_with("-0") => {
103+ format!("{:01$}", new_value, format_length)
104+ }
105+ 10 => format!("{}", new_value),
106+ 16 => {
107+ let (lower_count, upper_count): (usize, usize) =
108+ old_text.chars().skip(2).fold((0, 0), |(lower, upper), c| {
109+ (
110+ lower + c.is_ascii_lowercase().then(|| 1).unwrap_or(0),
111+ upper + c.is_ascii_uppercase().then(|| 1).unwrap_or(0),
112+ )
113+ });
114+ if upper_count > lower_count {
115+ format!("0x{:01$X}", new_value, format_length)
116+ } else {
117+ format!("0x{:01$x}", new_value, format_length)
118+ }
119+ }
120+ _ => unimplemented!("radix not supported: {}", self.radix),
121+ };
122+
123+ // Add separators from original number.
124+ for &rtl_index in &separator_rtl_indexes {
125+ if rtl_index < new_text.len() {
126+ let new_index = new_text.len() - rtl_index;
127+ new_text.insert(new_index, '_');
128+ }
129+ }
130+
131+ // Add in additional separators if necessary.
132+ if new_text.len() > old_length && !separator_rtl_indexes.is_empty() {
133+ let spacing = match separator_rtl_indexes.as_slice() {
134+ [.., b, a] => a - b - 1,
135+ _ => separator_rtl_indexes[0],
136+ };
137+
138+ let prefix_length = if self.radix == 10 { 0 } else { 2 };
139+ if let Some(mut index) = new_text.find('_') {
140+ while index - prefix_length > spacing {
141+ index -= spacing;
142+ new_text.insert(index, '_');
143+ }
144+ }
145+ }
146+
147+ new_text.into()
148+ }
149+}
150+
151+#[cfg(test)]
152+mod test {
153+ use super::*;
154+ use crate::Rope;
155+
156+ #[test]
157+ fn test_decimal_at_point() {
158+ let rope = Rope::from_str("Test text 12345 more text.");
159+ let range = Range::point(12);
160+ assert_eq!(
161+ NumberIncrementor::from_range(rope.slice(..), range),
162+ Some(NumberIncrementor {
163+ range: Range::new(10, 15),
164+ value: 12345,
165+ radix: 10,
166+ text: rope.slice(..),
167+ })
168+ );
169+ }
170+
171+ #[test]
172+ fn test_uppercase_hexadecimal_at_point() {
173+ let rope = Rope::from_str("Test text 0x123ABCDEF more text.");
174+ let range = Range::point(12);
175+ assert_eq!(
176+ NumberIncrementor::from_range(rope.slice(..), range),
177+ Some(NumberIncrementor {
178+ range: Range::new(10, 21),
179+ value: 0x123ABCDEF,
180+ radix: 16,
181+ text: rope.slice(..),
182+ })
183+ );
184+ }
185+
186+ #[test]
187+ fn test_lowercase_hexadecimal_at_point() {
188+ let rope = Rope::from_str("Test text 0xfa3b4e more text.");
189+ let range = Range::point(12);
190+ assert_eq!(
191+ NumberIncrementor::from_range(rope.slice(..), range),
192+ Some(NumberIncrementor {
193+ range: Range::new(10, 18),
194+ value: 0xfa3b4e,
195+ radix: 16,
196+ text: rope.slice(..),
197+ })
198+ );
199+ }
200+
201+ #[test]
202+ fn test_octal_at_point() {
203+ let rope = Rope::from_str("Test text 0o1074312 more text.");
204+ let range = Range::point(12);
205+ assert_eq!(
206+ NumberIncrementor::from_range(rope.slice(..), range),
207+ Some(NumberIncrementor {
208+ range: Range::new(10, 19),
209+ value: 0o1074312,
210+ radix: 8,
211+ text: rope.slice(..),
212+ })
213+ );
214+ }
215+
216+ #[test]
217+ fn test_binary_at_point() {
218+ let rope = Rope::from_str("Test text 0b10111010010101 more text.");
219+ let range = Range::point(12);
220+ assert_eq!(
221+ NumberIncrementor::from_range(rope.slice(..), range),
222+ Some(NumberIncrementor {
223+ range: Range::new(10, 26),
224+ value: 0b10111010010101,
225+ radix: 2,
226+ text: rope.slice(..),
227+ })
228+ );
229+ }
230+
231+ #[test]
232+ fn test_negative_decimal_at_point() {
233+ let rope = Rope::from_str("Test text -54321 more text.");
234+ let range = Range::point(12);
235+ assert_eq!(
236+ NumberIncrementor::from_range(rope.slice(..), range),
237+ Some(NumberIncrementor {
238+ range: Range::new(10, 16),
239+ value: -54321,
240+ radix: 10,
241+ text: rope.slice(..),
242+ })
243+ );
244+ }
245+
246+ #[test]
247+ fn test_decimal_with_leading_zeroes_at_point() {
248+ let rope = Rope::from_str("Test text 000045326 more text.");
249+ let range = Range::point(12);
250+ assert_eq!(
251+ NumberIncrementor::from_range(rope.slice(..), range),
252+ Some(NumberIncrementor {
253+ range: Range::new(10, 19),
254+ value: 45326,
255+ radix: 10,
256+ text: rope.slice(..),
257+ })
258+ );
259+ }
260+
261+ #[test]
262+ fn test_negative_decimal_cursor_on_minus_sign() {
263+ let rope = Rope::from_str("Test text -54321 more text.");
264+ let range = Range::point(10);
265+ assert_eq!(
266+ NumberIncrementor::from_range(rope.slice(..), range),
267+ Some(NumberIncrementor {
268+ range: Range::new(10, 16),
269+ value: -54321,
270+ radix: 10,
271+ text: rope.slice(..),
272+ })
273+ );
274+ }
275+
276+ #[test]
277+ fn test_number_under_range_start_of_rope() {
278+ let rope = Rope::from_str("100");
279+ let range = Range::point(0);
280+ assert_eq!(
281+ NumberIncrementor::from_range(rope.slice(..), range),
282+ Some(NumberIncrementor {
283+ range: Range::new(0, 3),
284+ value: 100,
285+ radix: 10,
286+ text: rope.slice(..),
287+ })
288+ );
289+ }
290+
291+ #[test]
292+ fn test_number_under_range_end_of_rope() {
293+ let rope = Rope::from_str("100");
294+ let range = Range::point(2);
295+ assert_eq!(
296+ NumberIncrementor::from_range(rope.slice(..), range),
297+ Some(NumberIncrementor {
298+ range: Range::new(0, 3),
299+ value: 100,
300+ radix: 10,
301+ text: rope.slice(..),
302+ })
303+ );
304+ }
305+
306+ #[test]
307+ fn test_number_surrounded_by_punctuation() {
308+ let rope = Rope::from_str(",100;");
309+ let range = Range::point(1);
310+ assert_eq!(
311+ NumberIncrementor::from_range(rope.slice(..), range),
312+ Some(NumberIncrementor {
313+ range: Range::new(1, 4),
314+ value: 100,
315+ radix: 10,
316+ text: rope.slice(..),
317+ })
318+ );
319+ }
320+
321+ #[test]
322+ fn test_not_a_number_point() {
323+ let rope = Rope::from_str("Test text 45326 more text.");
324+ let range = Range::point(6);
325+ assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
326+ }
327+
328+ #[test]
329+ fn test_number_too_large_at_point() {
330+ let rope = Rope::from_str("Test text 0xFFFFFFFFFFFFFFFFF more text.");
331+ let range = Range::point(12);
332+ assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
333+ }
334+
335+ #[test]
336+ fn test_number_cursor_one_right_of_number() {
337+ let rope = Rope::from_str("100 ");
338+ let range = Range::point(3);
339+ assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
340+ }
341+
342+ #[test]
343+ fn test_number_cursor_one_left_of_number() {
344+ let rope = Rope::from_str(" 100");
345+ let range = Range::point(0);
346+ assert_eq!(NumberIncrementor::from_range(rope.slice(..), range), None);
347+ }
348+
349+ #[test]
350+ fn test_increment_basic_decimal_numbers() {
351+ let tests = [
352+ ("100", 1, "101"),
353+ ("100", -1, "99"),
354+ ("99", 1, "100"),
355+ ("100", 1000, "1100"),
356+ ("100", -1000, "-900"),
357+ ("-1", 1, "0"),
358+ ("-1", 2, "1"),
359+ ("1", -1, "0"),
360+ ("1", -2, "-1"),
361+ ];
362+
363+ for (original, amount, expected) in tests {
364+ let rope = Rope::from_str(original);
365+ let range = Range::point(0);
366+ assert_eq!(
367+ NumberIncrementor::from_range(rope.slice(..), range)
368+ .unwrap()
369+ .incremented_text(amount),
370+ expected.into()
371+ );
372+ }
373+ }
374+
375+ #[test]
376+ fn test_increment_basic_hexadedimal_numbers() {
377+ let tests = [
378+ ("0x0100", 1, "0x0101"),
379+ ("0x0100", -1, "0x00ff"),
380+ ("0x0001", -1, "0x0000"),
381+ ("0x0000", -1, "0xffffffffffffffff"),
382+ ("0xffffffffffffffff", 1, "0x0000000000000000"),
383+ ("0xffffffffffffffff", 2, "0x0000000000000001"),
384+ ("0xffffffffffffffff", -1, "0xfffffffffffffffe"),
385+ ("0xABCDEF1234567890", 1, "0xABCDEF1234567891"),
386+ ("0xabcdef1234567890", 1, "0xabcdef1234567891"),
387+ ];
388+
389+ for (original, amount, expected) in tests {
390+ let rope = Rope::from_str(original);
391+ let range = Range::point(0);
392+ assert_eq!(
393+ NumberIncrementor::from_range(rope.slice(..), range)
394+ .unwrap()
395+ .incremented_text(amount),
396+ expected.into()
397+ );
398+ }
399+ }
400+
401+ #[test]
402+ fn test_increment_basic_octal_numbers() {
403+ let tests = [
404+ ("0o0107", 1, "0o0110"),
405+ ("0o0110", -1, "0o0107"),
406+ ("0o0001", -1, "0o0000"),
407+ ("0o7777", 1, "0o10000"),
408+ ("0o1000", -1, "0o0777"),
409+ ("0o0107", 10, "0o0121"),
410+ ("0o0000", -1, "0o1777777777777777777777"),
411+ ("0o1777777777777777777777", 1, "0o0000000000000000000000"),
412+ ("0o1777777777777777777777", 2, "0o0000000000000000000001"),
413+ ("0o1777777777777777777777", -1, "0o1777777777777777777776"),
414+ ];
415+
416+ for (original, amount, expected) in tests {
417+ let rope = Rope::from_str(original);
418+ let range = Range::point(0);
419+ assert_eq!(
420+ NumberIncrementor::from_range(rope.slice(..), range)
421+ .unwrap()
422+ .incremented_text(amount),
423+ expected.into()
424+ );
425+ }
426+ }
427+
428+ #[test]
429+ fn test_increment_basic_binary_numbers() {
430+ let tests = [
431+ ("0b00000100", 1, "0b00000101"),
432+ ("0b00000100", -1, "0b00000011"),
433+ ("0b00000100", 2, "0b00000110"),
434+ ("0b00000100", -2, "0b00000010"),
435+ ("0b00000001", -1, "0b00000000"),
436+ ("0b00111111", 10, "0b01001001"),
437+ ("0b11111111", 1, "0b100000000"),
438+ ("0b10000000", -1, "0b01111111"),
439+ (
440+ "0b0000",
441+ -1,
442+ "0b1111111111111111111111111111111111111111111111111111111111111111",
443+ ),
444+ (
445+ "0b1111111111111111111111111111111111111111111111111111111111111111",
446+ 1,
447+ "0b0000000000000000000000000000000000000000000000000000000000000000",
448+ ),
449+ (
450+ "0b1111111111111111111111111111111111111111111111111111111111111111",
451+ 2,
452+ "0b0000000000000000000000000000000000000000000000000000000000000001",
453+ ),
454+ (
455+ "0b1111111111111111111111111111111111111111111111111111111111111111",
456+ -1,
457+ "0b1111111111111111111111111111111111111111111111111111111111111110",
458+ ),
459+ ];
460+
461+ for (original, amount, expected) in tests {
462+ let rope = Rope::from_str(original);
463+ let range = Range::point(0);
464+ assert_eq!(
465+ NumberIncrementor::from_range(rope.slice(..), range)
466+ .unwrap()
467+ .incremented_text(amount),
468+ expected.into()
469+ );
470+ }
471+ }
472+
473+ #[test]
474+ fn test_increment_with_separators() {
475+ let tests = [
476+ ("999_999", 1, "1_000_000"),
477+ ("1_000_000", -1, "999_999"),
478+ ("-999_999", -1, "-1_000_000"),
479+ ("0x0000_0000_0001", 0x1_ffff_0000, "0x0001_ffff_0001"),
480+ ("0x0000_0000_0001", 0x1_ffff_0000, "0x0001_ffff_0001"),
481+ ("0x0000_0000_0001", 0x1_ffff_0000, "0x0001_ffff_0001"),
482+ ("0x0000_0000", -1, "0xffff_ffff_ffff_ffff"),
483+ ("0x0000_0000_0000", -1, "0xffff_ffff_ffff_ffff"),
484+ ("0b01111111_11111111", 1, "0b10000000_00000000"),
485+ ("0b11111111_11111111", 1, "0b1_00000000_00000000"),
486+ ];
487+
488+ for (original, amount, expected) in tests {
489+ let rope = Rope::from_str(original);
490+ let range = Range::point(0);
491+ assert_eq!(
492+ NumberIncrementor::from_range(rope.slice(..), range)
493+ .unwrap()
494+ .incremented_text(amount),
495+ expected.into()
496+ );
497+ }
498+ }
499+}