vorto 0.10.0

A terminal text editor with tree-sitter syntax highlighting and LSP support
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

//! Inline completion suggestion (ghost text) state.
//!
//! Phase-0 plumbing: holds the lifecycle of a single suggestion so the
//! UI can paint ghost text and the input layer can route the accept /
//! dismiss key. The actual provider (Copilot, Claude, …) lives behind
//! a later abstraction — this module only models what the editor needs
//! to render and confirm.
//!
//! Anchor semantics: a suggestion is only valid while the cursor is
//! exactly at the position the request was issued from. Any cursor
//! movement or buffer edit must drop back to [`SuggestionState::Idle`]
//! so we never paint stale text against a shifted cursor.

use super::Cursor;

/// Monotonic id for an in-flight suggestion request. Lets a late
/// provider response be discarded when a newer request has already
/// superseded it (debounce / cancellation race).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct RequestId(pub u64);

/// A completion the provider would insert at [`Suggestion::anchor`].
/// `text` is the full insertion verbatim — may contain `\n` for
/// multi-line completions. The renderer splits on `\n` to paint
/// continuation rows below the cursor row.
#[derive(Debug, Clone)]
pub struct Suggestion {
    pub text: String,
    pub anchor: Cursor,
}

impl Suggestion {
    /// True when this suggestion is currently anchored at `cursor`.
    /// Callers use this before painting / accepting to confirm the
    /// cursor hasn't drifted since the request fired.
    pub fn is_anchored_at(&self, cursor: Cursor) -> bool {
        self.anchor == cursor
    }
}

#[derive(Debug, Default)]
pub enum SuggestionState {
    #[default]
    Idle,
    Pending {
        id: RequestId,
        anchor: Cursor,
    },
    Showing {
        /// Request id of the response that produced this suggestion.
        /// Currently unread but kept so future telemetry
        /// (`didShowCompletion` / `didPartiallyAccept`) can identify
        /// the originating request without an extra lookup.
        #[allow(dead_code)]
        id: RequestId,
        suggestion: Suggestion,
    },
}

impl SuggestionState {
    pub fn showing(&self) -> Option<&Suggestion> {
        match self {
            SuggestionState::Showing { suggestion, .. } => Some(suggestion),
            _ => None,
        }
    }

    pub fn dismiss(&mut self) {
        *self = SuggestionState::Idle;
    }
}

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

    fn cur(row: usize, col: usize) -> Cursor {
        Cursor { row, col }
    }

    #[test]
    fn default_is_idle() {
        let s = SuggestionState::default();
        assert!(matches!(s, SuggestionState::Idle));
        assert!(s.showing().is_none());
    }

    #[test]
    fn showing_returns_suggestion_only_in_showing_state() {
        let mut s = SuggestionState::Pending {
            id: RequestId(1),
            anchor: cur(0, 0),
        };
        assert!(s.showing().is_none());

        s = SuggestionState::Showing {
            id: RequestId(1),
            suggestion: Suggestion {
                text: "abc".into(),
                anchor: cur(2, 4),
            },
        };
        let got = s.showing().expect("should be showing");
        assert_eq!(got.text, "abc");
        assert_eq!(got.anchor, cur(2, 4));
    }

    #[test]
    fn dismiss_resets_to_idle() {
        let mut s = SuggestionState::Showing {
            id: RequestId(7),
            suggestion: Suggestion {
                text: "x".into(),
                anchor: cur(0, 0),
            },
        };
        s.dismiss();
        assert!(matches!(s, SuggestionState::Idle));
    }

    #[test]
    fn anchor_check_distinguishes_positions() {
        let s = Suggestion {
            text: "y".into(),
            anchor: cur(3, 5),
        };
        assert!(s.is_anchored_at(cur(3, 5)));
        assert!(!s.is_anchored_at(cur(3, 6)));
        assert!(!s.is_anchored_at(cur(4, 5)));
    }
}