zsh 0.8.12

Zsh interpreter and parser in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! ZLE delete-to-char / zap-to-char widgets
//!
//! Port from zsh/Src/Zle/deltochar.c (141 lines)
//!
//! Implements Emacs-style zap-to-char (M-z) and delete-to-char widgets.

/// Delete from cursor to next occurrence of character (from deltochar.c deltochar)
///
/// If `inclusive` is true (zap-to-char), the target character is also deleted.
/// If `inclusive` is false (delete-to-char), stop before the target character.
/// If `direction` is positive, search forward; negative, search backward.
pub fn deltochar(
    buffer: &str,
    cursor: usize,
    target: char,
    direction: i32,
    inclusive: bool,
) -> Option<(usize, usize)> {
    if direction >= 0 {
        // Search forward
        let search_area = &buffer[cursor..];
        if let Some(pos) = search_area.find(target) {
            let end = cursor + pos + if inclusive { target.len_utf8() } else { 0 };
            Some((cursor, end))
        } else {
            None
        }
    } else {
        // Search backward
        let search_area = &buffer[..cursor];
        if let Some(pos) = search_area.rfind(target) {
            let start = if inclusive {
                pos
            } else {
                pos + target.len_utf8()
            };
            Some((start, cursor))
        } else {
            None
        }
    }
}

/// Apply delete-to-char: returns the new buffer with the range removed
pub fn apply_deltochar(
    buffer: &str,
    cursor: usize,
    target: char,
    direction: i32,
    inclusive: bool,
) -> Option<(String, usize)> {
    let (start, end) = deltochar(buffer, cursor, target, direction, inclusive)?;
    let mut result = String::with_capacity(buffer.len());
    result.push_str(&buffer[..start]);
    result.push_str(&buffer[end..]);
    Some((result, start))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_deltochar_forward() {
        // "hello world" with cursor at 0, delete to 'o' (inclusive)
        let (start, end) = deltochar("hello world", 0, 'o', 1, true).unwrap();
        assert_eq!(start, 0);
        assert_eq!(end, 5); // includes 'o'
    }

    #[test]
    fn test_deltochar_forward_exclusive() {
        let (start, end) = deltochar("hello world", 0, 'o', 1, false).unwrap();
        assert_eq!(start, 0);
        assert_eq!(end, 4); // stops before 'o'
    }

    #[test]
    fn test_deltochar_backward() {
        let (start, end) = deltochar("hello world", 11, 'o', -1, true).unwrap();
        assert_eq!(start, 7); // includes 'o'
        assert_eq!(end, 11);
    }

    #[test]
    fn test_deltochar_not_found() {
        assert!(deltochar("hello", 0, 'z', 1, true).is_none());
    }

    #[test]
    fn test_apply_deltochar() {
        let (result, cursor) = apply_deltochar("hello world", 0, 'o', 1, true).unwrap();
        assert_eq!(result, " world");
        assert_eq!(cursor, 0);
    }
}