2f23064 · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

async picker syntax highlighting

2f23064Pascal Kuthe3 years ago

helix-term/src/ui/picker.rs+75−32

compare with master

unifiedsplit

@@ -1,7 +1,9 @@

1use crate::{

2 alt,

3− compositor::{Component, Compositor, Context, Event, EventResult},

3+ compositor::{self, Component, Compositor, Context, Event, EventResult},

4+ ctrl,

5+ job::Callback,

4− ctrl, key, shift,

6+ key, shift,

5 ui::{

7 ui::{

6 self,

8 self,

7 document::{render_document, LineDecoration, LinePos, TextRenderer},

9 document::{render_document, LineDecoration, LinePos, TextRenderer},

@@ -9,7 +11,7 @@ use crate::{

9 EditorView,

11 EditorView,

10 },

12 },

11};

13};

12−use futures_util::future::BoxFuture;

14+use futures_util::{future::BoxFuture, FutureExt};

13use tui::{

15use tui::{

14 buffer::Buffer as Surface,

16 buffer::Buffer as Surface,

15 layout::Constraint,

17 layout::Constraint,

@@ -26,7 +28,7 @@ use std::{collections::HashMap, io::Read, path::PathBuf};

26use crate::ui::{Prompt, PromptEvent};

28use crate::ui::{Prompt, PromptEvent};

27use helix_core::{

29use helix_core::{

28 movement::Direction, text_annotations::TextAnnotations,

30 movement::Direction, text_annotations::TextAnnotations,

29− unicode::segmentation::UnicodeSegmentation, Position,

31+ unicode::segmentation::UnicodeSegmentation, Position, Syntax,

30};

32};

31use helix_view::{

33use helix_view::{

32 editor::Action,

34 editor::Action,

@@ -122,7 +124,7 @@ impl Preview<'_, '_> {

122 }

124 }

123}

125}

124

126

125−impl<T: Item> FilePicker<T> {

127+impl<T: Item + 'static> FilePicker<T> {

126 pub fn new(

128 pub fn new(

127 options: Vec<T>,

129 options: Vec<T>,

128 editor_data: T::Data,

130 editor_data: T::Data,

@@ -208,29 +210,67 @@ impl<T: Item> FilePicker<T> {

208 }

210 }

209

211

210 fn handle_idle_timeout(&mut self, cx: &mut Context) -> EventResult {

212 fn handle_idle_timeout(&mut self, cx: &mut Context) -> EventResult {

213+ let Some((current_file, _)) = self.current_file(cx.editor) else {

214+ return EventResult::Consumed(None)

215+ };

216+

211 // Try to find a document in the cache

217 // Try to find a document in the cache

212− let doc = self

213− .current_file(cx.editor)

218+ let doc = match &current_file {

214− .and_then(|(path, _range)| match path {

215− PathOrId::Id(doc_id) => Some(doc_mut!(cx.editor, &doc_id)),

219+ PathOrId::Id(doc_id) => doc_mut!(cx.editor, doc_id),

216− PathOrId::Path(path) => match self.preview_cache.get_mut(&path) {

220+ PathOrId::Path(path) => match self.preview_cache.get_mut(path) {

217− Some(CachedPreview::Document(doc)) => Some(doc),

221+ Some(CachedPreview::Document(ref mut doc)) => doc,

218− _ => None,

222+ _ => return EventResult::Consumed(None),

219− },

223+ },

220− });

224+ };

225+

226+ let mut callback: Option<compositor::Callback> = None;

221

227

222 // Then attempt to highlight it if it has no language set

228 // Then attempt to highlight it if it has no language set

223− if let Some(doc) = doc {

224− if doc.language_config().is_none() {

229+ if doc.language_config().is_none() {

230+ if let Some(language_config) = doc.detect_language_config(&cx.editor.syn_loader) {

231+ doc.language = Some(language_config.clone());

232+ let text = doc.text().clone();

225 let loader = cx.editor.syn_loader.clone();

233 let loader = cx.editor.syn_loader.clone();

226− doc.detect_language(loader);

234+ let job = tokio::task::spawn_blocking(move || {

235+ let syntax = language_config

236+ .highlight_config(&loader.scopes())

237+ .and_then(|highlight_config| Syntax::new(&text, highlight_config, loader));

238+ let callback = move |editor: &mut Editor, compositor: &mut Compositor| {

239+ let Some(syntax) = syntax else {

240+ log::info!("highlighting picker item failed");

241+ return

242+ };

243+ log::info!("hmm1");

244+ let Some(Overlay { content: picker, .. }) = compositor.find::<Overlay<Self>>() else {

245+ log::info!("picker closed before syntax highlighting finished");

246+ return

247+ };

248+ log::info!("hmm2");

249+ // Try to find a document in the cache

250+ let doc = match current_file {

251+ PathOrId::Id(doc_id) => doc_mut!(editor, &doc_id),

252+ PathOrId::Path(path) => match picker.preview_cache.get_mut(&path) {

253+ Some(CachedPreview::Document(ref mut doc)) => doc,

254+ _ => return,

255+ },

256+ };

257+ log::info!("yay");

258+ doc.syntax = Some(syntax);

259+ };

260+ Callback::EditorCompositor(Box::new(callback))

261+ });

262+ let tmp: compositor::Callback = Box::new(move |_, ctx| {

263+ ctx.jobs

264+ .callback(job.map(|res| res.map_err(anyhow::Error::from)))

265+ });

266+ callback = Some(Box::new(tmp))

227 }

267 }

228−

229− // QUESTION: do we want to compute inlay hints in pickers too ? Probably not for now

230− // but it could be interesting in the future

231 }

268 }

232

269

270+ // QUESTION: do we want to compute inlay hints in pickers too ? Probably not for now

271+ // but it could be interesting in the future

272+

233− EventResult::Consumed(None)

273+ EventResult::Consumed(callback)

234 }

274 }

235}

275}

236

276

@@ -373,6 +413,10 @@ impl<T: Item + 'static> Component for FilePicker<T> {

373 self.picker.required_size((picker_width, height))?;

413 self.picker.required_size((picker_width, height))?;

374 Some((width, height))

414 Some((width, height))

375 }

415 }

416+

417+ fn id(&self) -> Option<&'static str> {

418+ Some("file-picker")

419+ }

376}

420}

377

421

378#[derive(PartialEq, Eq, Debug)]

422#[derive(PartialEq, Eq, Debug)]

@@ -945,17 +989,16 @@ impl<T: Item + Send + 'static> Component for DynamicPicker<T> {

945

989

946 cx.jobs.callback(async move {

990 cx.jobs.callback(async move {

947 let new_options = new_options.await?;

991 let new_options = new_options.await?;

948− let callback =

949− crate::job::Callback::EditorCompositor(Box::new(move |editor, compositor| {

992+ let callback = Callback::EditorCompositor(Box::new(move |editor, compositor| {

950− // Wrapping of pickers in overlay is done outside the picker code,

993+ // Wrapping of pickers in overlay is done outside the picker code,

951− // so this is fragile and will break if wrapped in some other widget.

994+ // so this is fragile and will break if wrapped in some other widget.

952− let picker = match compositor.find_id::<Overlay<DynamicPicker<T>>>(Self::ID) {

995+ let picker = match compositor.find_id::<Overlay<DynamicPicker<T>>>(Self::ID) {

953− Some(overlay) => &mut overlay.content.file_picker.picker,

996+ Some(overlay) => &mut overlay.content.file_picker.picker,

954− None => return,

997+ None => return,

955− };

998+ };

956− picker.set_options(new_options);

999+ picker.set_options(new_options);

957− editor.reset_idle_timer();

1000+ editor.reset_idle_timer();

958− }));

1001+ }));

959 anyhow::Ok(callback)

1002 anyhow::Ok(callback)

960 });

1003 });

961 EventResult::Consumed(None)

1004 EventResult::Consumed(None)

helix-view/src/document.rs+16−8

@@ -154,9 +154,9 @@ pub struct Document {

154 /// The document's default line ending.

155 pub line_ending: LineEnding,

156

157− syntax: Option<Syntax>,

157+ pub syntax: Option<Syntax>,

158 /// Corresponding language scope name. Usually `source.<lang>`.

159− pub(crate) language: Option<Arc<LanguageConfiguration>>,

159+ pub language: Option<Arc<LanguageConfiguration>>,

160

161 /// Pending changes since last history commit.

162 changes: ChangeSet,

@@ -869,12 +869,20 @@ impl Document {

869

870 /// Detect the programming language based on the file type.

871 pub fn detect_language(&mut self, config_loader: Arc<syntax::Loader>) {

872− if let Some(path) = &self.path {

872+ self.set_language(

873+ self.detect_language_config(&config_loader),

874+ Some(config_loader),

875+ );

876+ }

877+

878+ /// Detect the programming language based on the file type.

879+ pub fn detect_language_config(

880+ &self,

881+ config_loader: &syntax::Loader,

882+ ) -> Option<Arc<helix_core::syntax::LanguageConfiguration>> {

873− let language_config = config_loader

883+ config_loader

874− .language_config_for_file_name(path)

884+ .language_config_for_file_name(self.path.as_ref()?)

875− .or_else(|| config_loader.language_config_for_shebang(self.text()));

885+ .or_else(|| config_loader.language_config_for_shebang(self.text()))

876− self.set_language(language_config, Some(config_loader));

877− }

878 }

886 }

879

887

880 /// Detect the indentation used in the file, or otherwise defaults to the language indentation

888 /// Detect the indentation used in the file, or otherwise defaults to the language indentation