gpui-neovim 0.2.0

Embedded Neovim component for GPUI, rendered by libghostty
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

/// Defines `NvimEditor` and `Terminal` against the caller's GPUI path.
///
/// Invoke once per module: `gpui_neovim::bind_gpui!(gpui);`.
/// This includes the terminal binding; do not invoke both macros in one module.
#[macro_export]
macro_rules! bind_gpui {
    ($gpui:path) => {
        pub use self::__gpui_neovim_adapter::{NvimEditor, Terminal};
        use $gpui as __gpui_neovim;
        mod __gpui_neovim_adapter {
            use super::__gpui_neovim as gpui;
            use gpui::{App, Context, Entity, IntoElement, Render, RenderImage, Task, Window};
            use std::{
                path::{Path, PathBuf},
                sync::Arc,
            };
            use $crate::NvimOptions;
            $crate::__private::ghostty::bind_gpui!(self::gpui);
            /// A Neovim process hosted inside a [`Terminal`].
            pub struct NvimEditor {
                session: $crate::NvimSession,
                terminal: Entity<Terminal>,
            }

            impl NvimEditor {
                pub fn spawn<T: 'static>(
                    options: NvimOptions,
                    window: &mut Window,
                    cx: &mut Context<T>,
                ) -> Result<Self, String> {
                    let (session, options) = $crate::NvimSession::new(options);
                    let terminal = Terminal::spawn(options, window, cx)?;
                    Ok(Self { session, terminal })
                }

                pub fn project(&self) -> &Path {
                    &self.session.project
                }

                pub fn path(&self) -> &Path {
                    &self.session.path
                }

                pub fn is_alive(&self, cx: &App) -> bool {
                    self.terminal.read(cx).is_alive()
                }

                pub fn focus<T>(&mut self, window: &mut Window, cx: &mut Context<T>) {
                    self.terminal
                        .update(cx, |terminal, cx| terminal.focus(window, cx));
                }

                pub fn set_visible(&mut self, visible: bool, cx: &mut Context<Self>) {
                    self.terminal
                        .update(cx, |terminal, _| terminal.set_visible(visible));
                }

                /// Captures Neovim's last completed native frame for temporary GPUI compositing.
                pub fn snapshot(
                    &mut self,
                    cx: &mut Context<Self>,
                ) -> Result<Arc<RenderImage>, String> {
                    self.terminal.update(cx, |terminal, _| terminal.snapshot())
                }

                /// Opens `path` in the existing Neovim server without blocking the UI thread.
                pub fn open_file(
                    &mut self,
                    path: PathBuf,
                    cx: &mut Context<Self>,
                ) -> Task<Result<(), String>> {
                    self.open_file_at_line(path, None, cx)
                }

                /// Opens `path`, places the cursor at `line`, and completes when Neovim accepts the request.
                pub fn open_file_at_line(
                    &mut self,
                    path: PathBuf,
                    line: Option<u64>,
                    cx: &mut Context<Self>,
                ) -> Task<Result<(), String>> {
                    if !self.terminal.read(cx).is_alive() {
                        return Task::ready(Err(
                            "the embedded Neovim process has exited".to_owned()
                        ));
                    }

                    let request = self.session.open_request(&path, line);
                    let request = cx.background_executor().spawn(async move { request.run() });

                    cx.spawn(async move |editor, cx| {
                        request.await?;
                        editor
                            .update(cx, |editor, _| editor.session.path = path)
                            .map_err(|_| "the embedded Neovim editor was dropped".to_owned())?;
                        Ok(())
                    })
                }
            }

            impl Render for NvimEditor {
                fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
                    self.terminal.clone()
                }
            }
        }
    };
}