alma 0.1.0

A Bevy-native modal text editor with Vim-style navigation.
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Paragraph-wise motion helpers.

use super::clamp_to_cursor_position;

/// Moves to the start of the next blank-line-delimited paragraph.
pub(super) fn next_paragraph_start(text: &str, index: usize) -> usize {
    let current_line_start = line_start_at_or_before(text, index);
    let Some(current_paragraph_start) =
        paragraph_start_containing_or_after(text, current_line_start)
    else {
        return clamp_to_cursor_position(text, index);
    };

    for line in lines(text) {
        if line.start <= current_paragraph_start {
            continue;
        }

        if !line.is_blank && starts_paragraph(text, line.start) {
            return line.start;
        }
    }

    clamp_to_cursor_position(text, text.len())
}

/// Moves to the start of the previous blank-line-delimited paragraph.
pub(super) fn previous_paragraph_start(text: &str, index: usize) -> usize {
    let current_line_start = line_start_at_or_before(text, index);
    let current_paragraph_start = paragraph_start_containing_or_before(text, current_line_start)
        .unwrap_or(current_line_start);

    lines(text)
        .filter(|line| line.start < current_paragraph_start)
        .filter(|line| !line.is_blank && starts_paragraph(text, line.start))
        .map(|line| line.start)
        .last()
        .unwrap_or_else(|| clamp_to_cursor_position(text, index))
}

/// Returns the line start at or before `index`.
fn line_start_at_or_before(text: &str, index: usize) -> usize {
    let index = super::clamp_to_boundary(text, index);

    text[..index]
        .rfind('\n')
        .map_or(0, |newline_index| newline_index + '\n'.len_utf8())
}

/// Returns the paragraph start containing `line_start`, or the next paragraph start.
fn paragraph_start_containing_or_after(text: &str, line_start: usize) -> Option<usize> {
    let mut previous_start = None;

    for line in lines(text) {
        if !line.is_blank && starts_paragraph(text, line.start) {
            previous_start = Some(line.start);
        }

        if line.start >= line_start {
            return if line.is_blank {
                lines(text)
                    .filter(|candidate| candidate.start > line.start)
                    .find(|candidate| {
                        !candidate.is_blank && starts_paragraph(text, candidate.start)
                    })
                    .map(|candidate| candidate.start)
            } else {
                previous_start
            };
        }
    }

    previous_start
}

/// Returns the paragraph start containing `line_start`, or the previous paragraph start.
fn paragraph_start_containing_or_before(text: &str, line_start: usize) -> Option<usize> {
    let mut previous_start = None;

    for line in lines(text) {
        if line.start > line_start {
            break;
        }

        if !line.is_blank && starts_paragraph(text, line.start) {
            previous_start = Some(line.start);
        }
    }

    previous_start
}

/// Returns whether the line at `line_start` begins a paragraph.
fn starts_paragraph(text: &str, line_start: usize) -> bool {
    if line_start == 0 {
        return true;
    }

    let previous_line_end = line_start - '\n'.len_utf8();
    let previous_line_start = text[..previous_line_end]
        .rfind('\n')
        .map_or(0, |newline_index| newline_index + '\n'.len_utf8());

    text[previous_line_start..previous_line_end]
        .trim()
        .is_empty()
}

/// Iterates over physical lines without including newline bytes in content ranges.
fn lines(text: &str) -> impl Iterator<Item = ParagraphLine> + '_ {
    let mut start = 0;

    std::iter::from_fn(move || {
        if start > text.len() {
            return None;
        }

        let line_start = start;
        let line_end = text[start..]
            .find('\n')
            .map_or(text.len(), |newline_offset| start + newline_offset);
        start = line_end
            .checked_add('\n'.len_utf8())
            .filter(|next_start| *next_start <= text.len())
            .unwrap_or(text.len() + 1);

        Some(ParagraphLine {
            start: line_start,
            is_blank: text[line_start..line_end].trim().is_empty(),
        })
    })
}

/// Minimal line metadata needed for paragraph scanning.
#[derive(Clone, Copy, Debug)]
struct ParagraphLine {
    /// Byte index at the start of the line.
    start: usize,
    /// Whether line content is empty after trimming Unicode whitespace.
    is_blank: bool,
}