suimeng
/
helix
mirror of https://github.com/helix-editor/helix
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

file tree with better prompts and callbacks

pull/8675/merge^2
mattwparas 2023-07-02 12:57:44 -07:00
parent e063c58d30
commit 76181da53a
9 changed files with 260 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
helix-core/src/indent.rs
View File

@ -791,7 +791,6 @@ fn call_indent_hook(
let mut cursor = line_before;
let mut depth = 0;
// for line in text_up_to_cursor.lines().reversed() {
loop {
let line = text_up_to_cursor.line(cursor);
@ -864,7 +863,12 @@ fn call_indent_hook(
// return Some(" ".repeat(offset + 1));
// }
if line.slice(offset..offset + end).as_str().map(|x| LISP_WORDS.contains(x)).unwrap_or_default() {
if line
.slice(offset..offset + end)
.as_str()
.map(|x| LISP_WORDS.contains(x))
.unwrap_or_default()
{
return Some(" ".repeat(offset + 1));
}
@ -1021,16 +1025,21 @@ pub fn custom_indent_for_newline(
}
// TODO: Don't unwrap here, we don't want that
if LISP_WORDS.contains(
line.slice(offset..offset + end).as_str().unwrap(),
) {
return Some(" ".repeat(offset + 1));
}
// if line.slice(offset..offset + end).as_str().map(|x| LISP_WORDS.contains(x)).unwrap_or_default() {
// if LISP_WORDS.contains(
// line.slice(offset..offset + end).as_str().unwrap(),
// ) {
// return Some(" ".repeat(offset + 1));
// }
if line
.slice(offset..offset + end)
.as_str()
.map(|x| LISP_WORDS.contains(x))
.unwrap_or_default()
{
return Some(" ".repeat(offset + 1));
}
for _ in char_iter_from_paren
.take_while(|(_, x)| x.is_whitespace())
{

4
helix-term/src/application.rs
View File

@ -343,6 +343,10 @@ impl Application {
self.jobs.handle_callback(&mut self.editor, &mut self.compositor, callback);
self.render().await;
}
Some(callback) = self.jobs.local_futures.next() => {
self.jobs.handle_local_callback(&mut self.editor, &mut self.compositor, callback);
self.render().await;
}
event = self.editor.wait_event() => {
let _idle_handled = self.handle_editor_event(event).await;

164
helix-term/src/commands/engine.rs
View File

@ -1,10 +1,12 @@
use fuzzy_matcher::FuzzyMatcher;
use helix_core::{graphemes, Tendril, Selection};
use helix_view::{document::Mode, Document, DocumentId, Editor, editor::Action, extension::document_id_to_usize};
use helix_core::{graphemes, Selection, Tendril};
use helix_view::{
document::Mode, editor::Action, extension::document_id_to_usize, Document, DocumentId, Editor,
};
use once_cell::sync::Lazy;
use steel::{
gc::unsafe_erased_pointers::CustomReference,
rvals::{FromSteelVal, IntoSteelVal, SteelString},
rvals::{AsRefMutSteelValFromRef, FromSteelVal, IntoSteelVal},
steel_vm::{engine::Engine, register_fn::RegisterFn},
SteelErr, SteelVal,
};
@ -25,7 +27,7 @@ use crate::{
compositor::{self, Component, Compositor},
job::{self, Callback},
keymap::{merge_keys, Keymap},
ui::{self, menu::Item, overlay::overlaid, Popup, PromptEvent},
ui::{self, menu::Item, overlay::overlaid, Popup, Prompt, PromptEvent},
};
use self::components::SteelDynamicComponent;
@ -418,6 +420,11 @@ fn configure_engine() -> std::rc::Rc<std::cell::RefCell<steel::steel_vm::engine:
engine.register_fn("enqueue-callback!", CallbackQueue::enqueue);
// Find the workspace
engine.register_fn("helix-find-workspace", || {
helix_core::find_workspace().0.to_str().unwrap().to_string()
});
// Get the current OS
engine.register_fn("current-os!", || std::env::consts::OS);
engine.register_fn("new-component!", SteelDynamicComponent::new_dyn);
@ -477,6 +484,52 @@ fn configure_engine() -> std::rc::Rc<std::cell::RefCell<steel::steel_vm::engine:
},
);
engine.register_fn(
"Prompt::new",
|prompt: String, callback_fn: SteelVal| -> WrappedDynComponent {
let prompt = Prompt::new(
prompt.into(),
None,
|_, _| Vec::new(),
move |cx, input, prompt_event| {
log::info!("Calling dynamic prompt callback");
if prompt_event != PromptEvent::Validate {
return;
}
let mut ctx = Context {
register: None,
count: None,
editor: cx.editor,
callback: None,
on_next_key_callback: None,
jobs: cx.jobs,
};
let cloned_func = callback_fn.clone();
ENGINE
.with(|x| {
x.borrow_mut()
.with_mut_reference::<Context, Context>(&mut ctx)
.consume(move |engine, mut args| {
// Add the string as an argument to the callback
args.push(input.into_steelval().unwrap());
engine.call_function_with_args(cloned_func.clone(), args)
})
})
.unwrap();
},
);
WrappedDynComponent {
inner: Some(Box::new(prompt)),
}
},
);
engine.register_fn("Picker::new", |values: Vec<String>| todo!());
// engine.register_fn(
@ -562,7 +615,7 @@ fn configure_engine() -> std::rc::Rc<std::cell::RefCell<steel::steel_vm::engine:
engine.register_fn("editor-mode", editor_get_mode);
engine.register_fn("editor-set-mode!", editor_set_mode);
engine.register_fn("editor-doc-in-view?", is_document_in_view);
// engine.register_fn("editor->get-document", get_document);
// TODO: These are some horrendous type annotations, however... they do work?
@ -583,6 +636,8 @@ fn configure_engine() -> std::rc::Rc<std::cell::RefCell<steel::steel_vm::engine:
// Check if the doc exists first
engine.register_fn("editor-doc-exists?", document_exists);
engine.register_fn("Document-path", document_path);
engine.register_fn("helix.context?", is_context);
engine.register_type::<DocumentId>("DocumentId?");
// RegisterFn::<
// _,
@ -618,6 +673,10 @@ fn configure_engine() -> std::rc::Rc<std::cell::RefCell<steel::steel_vm::engine:
"PromptEvent::Validate",
PromptEvent::Validate.into_steelval().unwrap(),
);
module.register_value(
"PromptEvent::Update",
PromptEvent::Update.into_steelval().unwrap(),
);
// Register everything in the typable command list. Now these are all available
for command in TYPABLE_COMMAND_LIST {
@ -718,11 +777,9 @@ fn configure_engine() -> std::rc::Rc<std::cell::RefCell<steel::steel_vm::engine:
module.register_fn("current-highlighted-text!", get_highlighted_text);
module.register_fn("get-current-line-number", current_line_number);
module.register_fn("current-selection-object", current_selection);
module.register_fn("set-current-selection-object!", set_selection);
module.register_fn("run-in-engine!", run_in_engine);
module.register_fn("get-helix-scm-path", get_helix_scm_path);
module.register_fn("get-init-scm-path", get_init_scm_path);
@ -733,6 +790,7 @@ fn configure_engine() -> std::rc::Rc<std::cell::RefCell<steel::steel_vm::engine:
engine.register_module(module);
engine.register_fn("push-component!", push_component);
engine.register_fn("enqueue-thread-local-callback", enqueue_command);
let helix_module_path = helix_loader::helix_module_file();
@ -857,12 +915,12 @@ fn set_selection(cx: &mut Context, selection: Selection) {
fn current_line_number(cx: &mut Context) -> usize {
let (view, doc) = current_ref!(cx.editor);
helix_core::coords_at_pos(
doc.text().slice(..),
doc
.selection(view.id)
doc.text().slice(..),
doc.selection(view.id)
.primary()
.cursor(doc.text().slice(..)),
).row
)
.row
}
fn get_selection(cx: &mut Context) -> String {
@ -970,15 +1028,17 @@ fn get_document_id(editor: &mut Editor, view_id: helix_view::ViewId) -> Document
editor.tree.get(view_id).doc
}
// Get the document from the document id - TODO: Add result type here
fn get_document(editor: &mut Editor, doc_id: DocumentId) -> &Document {
editor.documents.get(&doc_id).unwrap()
}
fn is_document_in_view(editor: &mut Editor, doc_id: DocumentId) -> Option<helix_view::ViewId> {
editor.tree.traverse().find(|(_, v)| v.doc == doc_id).map(|(id, _)| id)
editor
.tree
.traverse()
.find(|(_, v)| v.doc == doc_id)
.map(|(id, _)| id)
}
fn document_exists(editor: &mut Editor, doc_id: DocumentId) -> bool {
@ -1035,45 +1095,59 @@ fn run_shell_command_text(
}
}
// Pin the value to _this_ thread?
fn is_context(value: SteelVal) -> bool {
Context::as_mut_ref_from_ref(&value).is_ok()
}
// Overlay the dynamic component, see what happens?
// Probably need to pin the values to this thread - wrap it in a shim which pins the value
// to this thread? - call methods on the thread local value?
fn push_component(cx: &mut Context, component: &mut WrappedDynComponent) {
// let component = crate::ui::Text::new("Hello world!".to_string());
log::info!("Pushing dynamic component!");
// todo!();
let inner = component.inner.take().unwrap();
// let callback = async move {
// let call: job::Callback = Callback::EditorCompositor(Box::new(
// move |_editor: &mut Editor, compositor: &mut Compositor| {
// compositor.push(Box::new(component));
// },
// ));
// Ok(call)
// };
// cx.jobs.callback(callback);
// Why does this not work? - UPDATE: This does work when called in a static command context, but
// in a typed command context, we do not have access to the real compositor. Thus, we need a callback
// that then requires the values to be moved over threads. We'll need some message passing scheme
// to call values from the typed command context.
cx.push_layer(component.inner.take().unwrap());
// TODO: This _needs_ to go through a callback. Otherwise the new layer is just dropped.
// Set up some sort of callback queue for dynamic components that we can pull from instead, so that
// things stay thread local?
// let root = helix_core::find_workspace().0;
// let picker = ui::file_picker(root, &cx.editor.config());
// cx.push_layer(Box::new(overlaid(picker)));
let callback = async move {
let call: Box<dyn FnOnce(&mut Editor, &mut Compositor, &mut job::Jobs)> = Box::new(
move |_editor: &mut Editor, compositor: &mut Compositor, _| compositor.push(inner),
);
Ok(call)
};
cx.jobs.local_callback(callback);
}
// fn push_component_raw(cx: &mut Context, component: Box<dyn Component>) {
// cx.push_layer(component);
fn enqueue_command(cx: &mut Context, callback_fn: SteelVal) {
let callback = async move {
let call: Box<dyn FnOnce(&mut Editor, &mut Compositor, &mut job::Jobs)> = Box::new(
move |editor: &mut Editor, _compositor: &mut Compositor, jobs: &mut job::Jobs| {
let mut ctx = Context {
register: None,
count: None,
editor,
callback: None,
on_next_key_callback: None,
jobs,
};
let cloned_func = callback_fn.clone();
ENGINE
.with(|x| {
x.borrow_mut()
.with_mut_reference::<Context, Context>(&mut ctx)
.consume(move |engine, args| {
engine.call_function_with_args(cloned_func.clone(), args)
})
})
.unwrap();
},
);
Ok(call)
};
cx.jobs.local_callback(callback);
}
// fn enqueue_callback(cx: &mut Context, thunk: SteelVal) {
// log::info!("Enqueueing callback!");
// }

57
helix-term/src/commands/engine/components.rs
View File

@ -10,7 +10,7 @@ use steel::{
use crate::{
commands::{engine::ENGINE, Context},
compositor::{self, Component},
ui::Popup,
ui::{Popup, Prompt, PromptEvent},
};
pub fn helix_component_module() -> BuiltInModule {
@ -72,6 +72,61 @@ pub fn helix_component_module() -> BuiltInModule {
}
},
);
// prompt: Cow<'static, str>,
// history_register: Option<char>,
// completion_fn: impl FnMut(&Editor, &str) -> Vec<Completion> + 'static,
// callback_fn: impl FnMut(&mut Context, &str, PromptEvent) + 'static,
module.register_fn(
"Prompt::new",
|prompt: String, callback_fn: SteelVal| -> WrappedDynComponent {
let prompt = Prompt::new(
prompt.into(),
None,
|_, _| Vec::new(),
move |cx, input, prompt_event| {
if prompt_event != PromptEvent::Validate {
return;
}
let mut ctx = Context {
register: None,
count: None,
editor: cx.editor,
callback: None,
on_next_key_callback: None,
jobs: cx.jobs,
};
let cloned_func = callback_fn.clone();
// let thunk = move |engine: &mut Engine, cx, input| {
// engine.call_function_with_args(
// cloned_func,
// vec![cx, input],
// )
// };
ENGINE
.with(|x| {
x.borrow_mut()
.with_mut_reference::<Context, Context>(&mut ctx)
.consume(move |engine, mut args| {
// Add the string as an argument to the callback
args.push(input.into_steelval().unwrap());
engine.call_function_with_args(cloned_func.clone(), args)
})
})
.unwrap();
},
);
WrappedDynComponent {
inner: Some(Box::new(prompt)),
}
},
);
module.register_fn("Picker::new", |values: Vec<String>| todo!());

35
helix-term/src/commands/typed.rs
View File

@ -2933,17 +2933,18 @@ pub(super) fn command_mode(cx: &mut Context) {
);
let mut guard = x.borrow_mut();
// let mut maybe_callback = None;
let mut cx = Context {
register: None,
count: std::num::NonZeroUsize::new(1),
editor: cx.editor,
callback: None,
on_next_key_callback: None,
jobs: cx.jobs,
};
let res = {
let mut cx = Context {
register: None,
count: std::num::NonZeroUsize::new(1),
editor: cx.editor,
callback: None,
on_next_key_callback: None,
jobs: cx.jobs,
};
{
guard
.register_value("_helix_args", steel::rvals::SteelVal::ListV(args));
@ -2955,8 +2956,22 @@ pub(super) fn command_mode(cx: &mut Context) {
guard.register_value("_helix_args", steel::rvals::SteelVal::Void);
// if let Some(callback) = cx.callback.take() {
// panic!("Found a callback!");
// maybe_callback = Some(callback);
// }
res
}
};
// TODO: Recursively (or otherwise) keep retrying until we're back
// into the engine context, executing a function. We might need to set up
// some sort of fuel or something
// if let Some(callback) = maybe_callback {
// (callback)(_, cx);
// }
res
}) {
compositor_present_error(cx, e)
};

37
helix-term/src/job.rs
View File

@ -2,12 +2,15 @@ use helix_view::Editor;
use crate::compositor::Compositor;
use futures_util::future::{BoxFuture, Future, FutureExt};
use futures_util::stream::{FuturesUnordered, StreamExt};
use futures_util::future::{BoxFuture, Future, FutureExt, LocalBoxFuture};
use futures_util::stream::{FuturesOrdered, FuturesUnordered, StreamExt};
pub type EditorCompositorCallback = Box<dyn FnOnce(&mut Editor, &mut Compositor) + Send>;
pub type EditorCallback = Box<dyn FnOnce(&mut Editor) + Send>;
pub type ThreadLocalEditorCompositorCallback =
Box<dyn FnOnce(&mut Editor, &mut Compositor, &mut Jobs)>;
pub enum Callback {
EditorCompositor(EditorCompositorCallback),
Editor(EditorCallback),
@ -21,11 +24,16 @@ pub struct Job {
pub wait: bool,
}
pub type ThreadLocalJob =
LocalBoxFuture<'static, anyhow::Result<Option<ThreadLocalEditorCompositorCallback>>>;
#[derive(Default)]
pub struct Jobs {
pub futures: FuturesUnordered<JobFuture>,
/// These are the ones that need to complete before we exit.
pub wait_futures: FuturesUnordered<JobFuture>,
pub local_futures: FuturesUnordered<ThreadLocalJob>,
}
impl Job {
@ -67,6 +75,16 @@ impl Jobs {
self.add(Job::with_callback(f));
}
pub fn local_callback<
F: Future<Output = anyhow::Result<ThreadLocalEditorCompositorCallback>> + 'static,
>(
&mut self,
f: F,
) {
self.local_futures
.push(f.map(|r| r.map(Some)).boxed_local());
}
pub fn handle_callback(
&self,
editor: &mut Editor,
@ -85,6 +103,21 @@ impl Jobs {
}
}
pub fn handle_local_callback(
&mut self,
editor: &mut Editor,
compositor: &mut Compositor,
call: anyhow::Result<Option<ThreadLocalEditorCompositorCallback>>,
) {
match call {
Ok(None) => {}
Ok(Some(call)) => call(editor, compositor, self),
Err(e) => {
editor.set_error(format!("Sync job failed: {}", e));
}
}
}
pub async fn next_job(&mut self) -> Option<anyhow::Result<Option<Callback>>> {
tokio::select! {
event = self.futures.next() => { event }

2
helix-tui/src/extension.rs
View File

@ -4,4 +4,4 @@ use steel::{gc::unsafe_erased_pointers::CustomReference, rvals::Custom};
impl CustomReference for Buffer {}
steel::custom_reference!(Buffer);
steel::custom_reference!(Buffer);

2
helix-view/src/editor.rs
View File

@ -692,7 +692,7 @@ pub struct WhitespaceCharacters {
impl Default for WhitespaceCharacters {
fn default() -> Self {
Self {
space: '·', // U+00B7
space: '·', // U+00B7
nbsp: '⍽', // U+237D
tab: '→', // U+2192
newline: '⏎', // U+23CE

2
helix-view/src/extension.rs
View File

@ -12,4 +12,4 @@ impl CustomReference for Document {}
pub fn document_id_to_usize(doc_id: &DocumentId) -> usize {
doc_id.0.into()
}
}