tenant.openagents/omega

1use std::ops::{Deref, DerefMut};
2
3use editor::test::editor_lsp_test_context::EditorLspTestContext;
4use gpui::{Context, Entity, UpdateGlobal};
5use search::{BufferSearchBar, project_search::ProjectSearchBar};
6use semver::Version;
7
8use crate::{state::Operator, *};
9
10pub struct VimTestContext {
11    cx: EditorLspTestContext,
12}
13
14impl VimTestContext {
15    pub fn init(cx: &mut gpui::TestAppContext) {
16        if cx.has_global::<VimGlobals>() {
17            return;
18        }
19        env_logger::try_init().ok();
20        cx.update(|cx| {
21            let settings = SettingsStore::test(cx);
22            cx.set_global(settings);
23            release_channel::init(Version::new(0, 0, 0), cx);
24            command_palette::init(cx);
25            project_panel::init(cx);
26            outline_panel::init(cx);
27            git_ui::init(cx);
28            crate::init(cx);
29            search::init(cx);
30            theme_settings::init(theme::LoadThemes::JustBase, cx);
31            settings_ui::init(cx);
32            markdown_preview::init(cx);
33            zed_actions::init();
34        });
35    }
36
37    pub async fn new(cx: &mut gpui::TestAppContext, enabled: bool) -> VimTestContext {
38        Self::init(cx);
39        let lsp = EditorLspTestContext::new_rust(Default::default(), cx).await;
40        Self::new_with_lsp(lsp, enabled)
41    }
42
43    pub async fn new_html(cx: &mut gpui::TestAppContext) -> VimTestContext {
44        Self::init(cx);
45        Self::new_with_lsp(EditorLspTestContext::new_html(cx).await, true)
46    }
47
48    pub async fn new_markdown_with_rust(cx: &mut gpui::TestAppContext) -> VimTestContext {
49        Self::init(cx);
50        Self::new_with_lsp(EditorLspTestContext::new_markdown_with_rust(cx).await, true)
51    }
52
53    pub async fn new_typescript(cx: &mut gpui::TestAppContext) -> VimTestContext {
54        Self::init(cx);
55        Self::new_with_lsp(
56            EditorLspTestContext::new_typescript(
57                lsp::ServerCapabilities {
58                    completion_provider: Some(lsp::CompletionOptions {
59                        trigger_characters: Some(vec![".".to_string()]),
60                        ..Default::default()
61                    }),
62                    rename_provider: Some(lsp::OneOf::Right(lsp::RenameOptions {
63                        prepare_provider: Some(true),
64                        work_done_progress_options: Default::default(),
65                    })),
66                    definition_provider: Some(lsp::OneOf::Left(true)),
67                    ..Default::default()
68                },
69                cx,
70            )
71            .await,
72            true,
73        )
74    }
75
76    pub async fn new_tsx(cx: &mut gpui::TestAppContext) -> VimTestContext {
77        Self::init(cx);
78        Self::new_with_lsp(
79            EditorLspTestContext::new_tsx(
80                lsp::ServerCapabilities {
81                    completion_provider: Some(lsp::CompletionOptions {
82                        trigger_characters: Some(vec![".".to_string()]),
83                        ..Default::default()
84                    }),
85                    rename_provider: Some(lsp::OneOf::Right(lsp::RenameOptions {
86                        prepare_provider: Some(true),
87                        work_done_progress_options: Default::default(),
88                    })),
89                    ..Default::default()
90                },
91                cx,
92            )
93            .await,
94            true,
95        )
96    }
97
98    pub fn init_keybindings(enabled: bool, cx: &mut App) {
99        SettingsStore::update_global(cx, |store, cx| {
100            store.update_user_settings(cx, |s| s.vim_mode = Some(enabled));
101        });
102        let mut default_key_bindings = settings::KeymapFile::load_asset_allow_partial_failure(
103            "keymaps/default-macos.json",
104            cx,
105        )
106        .unwrap();
107        for key_binding in &mut default_key_bindings {
108            key_binding.set_meta(settings::KeybindSource::Default.meta());
109        }
110        cx.bind_keys(default_key_bindings);
111        if enabled {
112            let mut vim_key_bindings =
113                settings::KeymapFile::load_asset_allow_partial_failure("keymaps/vim.json", cx)
114                    .unwrap();
115            for key_binding in &mut vim_key_bindings {
116                key_binding.set_meta(settings::KeybindSource::Vim.meta());
117            }
118            cx.bind_keys(vim_key_bindings);
119        }
120    }
121
122    pub fn new_with_lsp(mut cx: EditorLspTestContext, enabled: bool) -> VimTestContext {
123        cx.update(|_, cx| {
124            Self::init_keybindings(enabled, cx);
125        });
126
127        // Setup search toolbars and keypress hook
128        cx.update_workspace(|workspace, window, cx| {
129            workspace.active_pane().update(cx, |pane, cx| {
130                pane.toolbar().update(cx, |toolbar, cx| {
131                    let buffer_search_bar = cx.new(|cx| BufferSearchBar::new(None, window, cx));
132                    toolbar.add_item(buffer_search_bar, window, cx);
133
134                    let project_search_bar = cx.new(|_| ProjectSearchBar::new());
135                    toolbar.add_item(project_search_bar, window, cx);
136                })
137            });
138            workspace.status_bar().update(cx, |status_bar, cx| {
139                let vim_mode_indicator = cx.new(|cx| ModeIndicator::new(window, cx));
140                status_bar.add_right_item(vim_mode_indicator, window, cx);
141            });
142        });
143
144        Self { cx }
145    }
146
147    pub fn update_entity<F, T, R>(&mut self, entity: Entity<T>, update: F) -> R
148    where
149        T: 'static,
150        F: FnOnce(&mut T, &mut Window, &mut Context<T>) -> R + 'static,
151    {
152        let window = self.window;
153        self.update_window(window, move |_, window, cx| {
154            entity.update(cx, |t, cx| update(t, window, cx))
155        })
156        .unwrap()
157    }
158
159    pub fn workspace<F, T>(&mut self, update: F) -> T
160    where
161        F: FnOnce(&mut Workspace, &mut Window, &mut Context<Workspace>) -> T,
162    {
163        self.cx.update_workspace(update)
164    }
165
166    pub fn enable_vim(&mut self) {
167        self.cx.update(|_, cx| {
168            SettingsStore::update_global(cx, |store, cx| {
169                store.update_user_settings(cx, |s| s.vim_mode = Some(true));
170            });
171        })
172    }
173
174    pub fn disable_vim(&mut self) {
175        self.cx.update(|_, cx| {
176            SettingsStore::update_global(cx, |store, cx| {
177                store.update_user_settings(cx, |s| s.vim_mode = Some(false));
178            });
179        })
180    }
181
182    pub fn enable_helix(&mut self) {
183        self.cx.update(|_, cx| {
184            SettingsStore::update_global(cx, |store, cx| {
185                store.update_user_settings(cx, |s| s.helix_mode = Some(true));
186            });
187        })
188    }
189
190    pub fn mode(&mut self) -> Mode {
191        self.update_editor(|editor, _, cx| editor.addon::<VimAddon>().unwrap().entity.read(cx).mode)
192    }
193
194    pub fn forced_motion(&mut self) -> bool {
195        self.update_editor(|_, _, cx| cx.global::<VimGlobals>().forced_motion)
196    }
197
198    pub fn active_operator(&mut self) -> Option<Operator> {
199        self.update_editor(|editor, _, cx| {
200            editor
201                .addon::<VimAddon>()
202                .unwrap()
203                .entity
204                .read(cx)
205                .operator_stack
206                .last()
207                .cloned()
208        })
209    }
210
211    pub fn set_state(&mut self, text: &str, mode: Mode) {
212        self.cx.set_state(text);
213        let vim =
214            self.update_editor(|editor, _window, _cx| editor.addon::<VimAddon>().cloned().unwrap());
215
216        self.update(|window, cx| {
217            vim.entity.update(cx, |vim, cx| {
218                vim.switch_mode(mode, true, window, cx);
219            });
220        });
221        self.cx.cx.cx.run_until_parked();
222    }
223
224    #[track_caller]
225    pub fn assert_state(&mut self, text: &str, mode: Mode) {
226        self.assert_editor_state(text);
227        assert_eq!(self.mode(), mode, "{}", self.assertion_context());
228    }
229
230    pub fn assert_binding(
231        &mut self,
232        keystrokes: &str,
233        initial_state: &str,
234        initial_mode: Mode,
235        state_after: &str,
236        mode_after: Mode,
237    ) {
238        self.set_state(initial_state, initial_mode);
239        self.cx.simulate_keystrokes(keystrokes);
240        self.cx.assert_editor_state(state_after);
241        assert_eq!(self.mode(), mode_after, "{}", self.assertion_context());
242        assert_eq!(self.active_operator(), None, "{}", self.assertion_context());
243    }
244
245    pub fn assert_binding_normal(
246        &mut self,
247        keystrokes: &str,
248        initial_state: &str,
249        state_after: &str,
250    ) {
251        self.set_state(initial_state, Mode::Normal);
252        self.cx.simulate_keystrokes(keystrokes);
253        self.cx.assert_editor_state(state_after);
254        assert_eq!(self.mode(), Mode::Normal, "{}", self.assertion_context());
255        assert_eq!(self.active_operator(), None, "{}", self.assertion_context());
256    }
257
258    pub fn shared_clipboard(&mut self) -> VimClipboard {
259        VimClipboard {
260            editor: self
261                .read_from_clipboard()
262                .map(|item| item.text().unwrap())
263                .unwrap_or_default(),
264        }
265    }
266}
267
268pub struct VimClipboard {
269    editor: String,
270}
271
272impl VimClipboard {
273    #[track_caller]
274    pub fn assert_eq(&self, expected: &str) {
275        assert_eq!(self.editor, expected);
276    }
277}
278
279impl Deref for VimTestContext {
280    type Target = EditorLspTestContext;
281
282    fn deref(&self) -> &Self::Target {
283        &self.cx
284    }
285}
286
287impl DerefMut for VimTestContext {
288    fn deref_mut(&mut self) -> &mut Self::Target {
289        &mut self.cx
290    }
291}
292