@@ -12,11 +12,63 @@ use helix_core::{Position, Transaction};
1212use helix_view::Editor;
1313
1414use crate::commands;
15−use crate::ui::{Markdown, Menu, Popup, PromptEvent};
15+use crate::ui::{menu, Markdown, Menu, Popup, PromptEvent};
1616
1717use helix_lsp::lsp;
1818use lsp::CompletionItem;
1919
20+impl menu::Item for CompletionItem {
21+ fn filter_text(&self) -> &str {
22+ self.filter_text
23+ .as_ref()
24+ .unwrap_or_else(|| &self.label)
25+ .as_str()
26+ }
27+
28+ fn label(&self) -> &str {
29+ self.label.as_str()
30+ }
31+
32+ fn row(&self) -> menu::Row {
33+ menu::Row::new(vec![
34+ menu::Cell::from(self.label.as_str()),
35+ menu::Cell::from(match self.kind {
36+ Some(lsp::CompletionItemKind::Text) => "text",
37+ Some(lsp::CompletionItemKind::Method) => "method",
38+ Some(lsp::CompletionItemKind::Function) => "function",
39+ Some(lsp::CompletionItemKind::Constructor) => "constructor",
40+ Some(lsp::CompletionItemKind::Field) => "field",
41+ Some(lsp::CompletionItemKind::Variable) => "variable",
42+ Some(lsp::CompletionItemKind::Class) => "class",
43+ Some(lsp::CompletionItemKind::Interface) => "interface",
44+ Some(lsp::CompletionItemKind::Module) => "module",
45+ Some(lsp::CompletionItemKind::Property) => "property",
46+ Some(lsp::CompletionItemKind::Unit) => "unit",
47+ Some(lsp::CompletionItemKind::Value) => "value",
48+ Some(lsp::CompletionItemKind::Enum) => "enum",
49+ Some(lsp::CompletionItemKind::Keyword) => "keyword",
50+ Some(lsp::CompletionItemKind::Snippet) => "snippet",
51+ Some(lsp::CompletionItemKind::Color) => "color",
52+ Some(lsp::CompletionItemKind::File) => "file",
53+ Some(lsp::CompletionItemKind::Reference) => "reference",
54+ Some(lsp::CompletionItemKind::Folder) => "folder",
55+ Some(lsp::CompletionItemKind::EnumMember) => "enum_member",
56+ Some(lsp::CompletionItemKind::Constant) => "constant",
57+ Some(lsp::CompletionItemKind::Struct) => "struct",
58+ Some(lsp::CompletionItemKind::Event) => "event",
59+ Some(lsp::CompletionItemKind::Operator) => "operator",
60+ Some(lsp::CompletionItemKind::TypeParameter) => "type_param",
61+ None => "",
62+ }),
63+ // self.detail.as_deref().unwrap_or("")
64+ // self.label_details
65+ // .as_ref()
66+ // .or(self.detail())
67+ // .as_str(),
68+ ])
69+ }
70+}
71+
2072/// Wraps a Menu.
2173pub struct Completion {
2274 popup: Popup<Menu<CompletionItem>>, // TODO: Popup<Menu> need to be able to access contents.
@@ -31,92 +83,83 @@ impl Completion {
3183 trigger_offset: usize,
3284 ) -> Self {
3385 // let items: Vec<CompletionItem> = Vec::new();
34− let mut menu = Menu::new(
35− items,
36− |item| {
37− // format_fn
38− item.label.as_str().into()
39−
40− // TODO: use item.filter_text for filtering
41− },
42− move |editor: &mut Editor, item, event| {
43− match event {
44− PromptEvent::Abort => {
45− // revert state
46− // let id = editor.view().doc;
47− // let doc = &mut editor.documents[id];
48− // doc.state = snapshot.clone();
49− }
50− PromptEvent::Validate => {
51− let (view, doc) = editor.current();
52−
53− // revert state to what it was before the last update
54− // doc.state = snapshot.clone();
55−
56− // extract as fn(doc, item):
57−
58− // TODO: need to apply without composing state...
59− // TODO: need to update lsp on accept/cancel by diffing the snapshot with
60− // the final state?
61− // -> on update simply update the snapshot, then on accept redo the call,
62− // finally updating doc.changes + notifying lsp.
63− //
64− // or we could simply use doc.undo + apply when changing between options
65−
66− // always present here
67− let item = item.unwrap();
68−
69− use helix_lsp::{lsp, util};
70− // determine what to insert: text_edit | insert_text | label
71− let edit = if let Some(edit) = &item.text_edit {
72− match edit {
73− lsp::CompletionTextEdit::Edit(edit) => edit.clone(),
74− lsp::CompletionTextEdit::InsertAndReplace(item) => {
75− unimplemented!("completion: insert_and_replace {:?}", item)
76− }
86+ let mut menu = Menu::new(items, move |editor: &mut Editor, item, event| {
87+ match event {
88+ PromptEvent::Abort => {
89+ // revert state
90+ // let id = editor.view().doc;
91+ // let doc = &mut editor.documents[id];
92+ // doc.state = snapshot.clone();
93+ }
94+ PromptEvent::Validate => {
95+ let (view, doc) = editor.current();
96+
97+ // revert state to what it was before the last update
98+ // doc.state = snapshot.clone();
99+
100+ // extract as fn(doc, item):
101+
102+ // TODO: need to apply without composing state...
103+ // TODO: need to update lsp on accept/cancel by diffing the snapshot with
104+ // the final state?
105+ // -> on update simply update the snapshot, then on accept redo the call,
106+ // finally updating doc.changes + notifying lsp.
107+ //
108+ // or we could simply use doc.undo + apply when changing between options
109+
110+ // always present here
111+ let item = item.unwrap();
112+
113+ use helix_lsp::{lsp, util};
114+ // determine what to insert: text_edit | insert_text | label
115+ let edit = if let Some(edit) = &item.text_edit {
116+ match edit {
117+ lsp::CompletionTextEdit::Edit(edit) => edit.clone(),
118+ lsp::CompletionTextEdit::InsertAndReplace(item) => {
119+ unimplemented!("completion: insert_and_replace {:?}", item)
77120 }
78− } else {
79− item.insert_text.as_ref().unwrap_or(&item.label);
80− unimplemented!();
81− // lsp::TextEdit::new(); TODO: calculate a TextEdit from insert_text
82− // and we insert at position.
83− };
84−
85− // if more text was entered, remove it
86− let cursor = doc.selection(view.id).cursor();
87− if trigger_offset < cursor {
88− let remove = Transaction::change(
89− doc.text(),
90− vec![(trigger_offset, cursor, None)].into_iter(),
91− );
92− doc.apply(&remove, view.id);
93121 }
122+ } else {
123+ item.insert_text.as_ref().unwrap_or(&item.label);
124+ unimplemented!();
125+ // lsp::TextEdit::new(); TODO: calculate a TextEdit from insert_text
126+ // and we insert at position.
127+ };
94128
95− use helix_lsp::OffsetEncoding;
96− let transaction = util::generate_transaction_from_edits(
129+ // if more text was entered, remove it
130+ let cursor = doc.selection(view.id).cursor();
131+ if trigger_offset < cursor {
132+ let remove = Transaction::change(
97133 doc.text(),
98− vec![edit],
99− offset_encoding, // TODO: should probably transcode in Client
134+ vec![(trigger_offset, cursor, None)].into_iter(),
100135 );
101− doc.apply(&transaction, view.id);
102−
103− // TODO: merge edit with additional_text_edits
104− if let Some(additional_edits) = &item.additional_text_edits {
105− // gopls uses this to add extra imports
106− if !additional_edits.is_empty() {
107− let transaction = util::generate_transaction_from_edits(
108− doc.text(),
109− additional_edits.clone(),
110− offset_encoding, // TODO: should probably transcode in Client
111− );
112− doc.apply(&transaction, view.id);
113− }
136+ doc.apply(&remove, view.id);
137+ }
138+
139+ use helix_lsp::OffsetEncoding;
140+ let transaction = util::generate_transaction_from_edits(
141+ doc.text(),
142+ vec![edit],
143+ offset_encoding, // TODO: should probably transcode in Client
144+ );
145+ doc.apply(&transaction, view.id);
146+
147+ // TODO: merge edit with additional_text_edits
148+ if let Some(additional_edits) = &item.additional_text_edits {
149+ // gopls uses this to add extra imports
150+ if !additional_edits.is_empty() {
151+ let transaction = util::generate_transaction_from_edits(
152+ doc.text(),
153+ additional_edits.clone(),
154+ offset_encoding, // TODO: should probably transcode in Client
155+ );
156+ doc.apply(&transaction, view.id);
114157 }
115158 }
116− _ => (),
117− };
118− },
119− );
159+ }
160+ _ => (),
161+ };
162+ });
120163 let popup = Popup::new(menu);
121164 Self {
122165 popup,