1use std::ops::{Deref, DerefMut};
  2
  3use editor::test::editor_test_context::EditorTestContext;
  4use gpui::{json::json, AppContext, ContextHandle, ViewHandle};
  5use project::Project;
  6use search::{BufferSearchBar, ProjectSearchBar};
  7use workspace::{pane, AppState, WorkspaceHandle};
  8
  9use crate::{state::Operator, *};
 10
 11use super::VimBindingTestContext;
 12
 13pub struct VimTestContext<'a> {
 14    cx: EditorTestContext<'a>,
 15    workspace: ViewHandle<Workspace>,
 16}
 17
 18impl<'a> VimTestContext<'a> {
 19    pub async fn new(cx: &'a mut gpui::TestAppContext, enabled: bool) -> VimTestContext<'a> {
 20        cx.update(|cx| {
 21            editor::init(cx);
 22            pane::init(cx);
 23            search::init(cx);
 24            crate::init(cx);
 25
 26            settings::KeymapFileContent::load("keymaps/vim.json", cx).unwrap();
 27        });
 28
 29        let params = cx.update(AppState::test);
 30        let project = Project::test(params.fs.clone(), [], cx).await;
 31
 32        cx.update(|cx| {
 33            cx.update_global(|settings: &mut Settings, _| {
 34                settings.vim_mode = enabled;
 35            });
 36        });
 37
 38        params
 39            .fs
 40            .as_fake()
 41            .insert_tree("/root", json!({ "dir": { "test.txt": "" } }))
 42            .await;
 43
 44        let (window_id, workspace) = cx.add_window(|cx| {
 45            Workspace::new(
 46                Default::default(),
 47                project.clone(),
 48                |_, _| unimplemented!(),
 49                cx,
 50            )
 51        });
 52
 53        // Setup search toolbars
 54        workspace.update(cx, |workspace, cx| {
 55            workspace.active_pane().update(cx, |pane, cx| {
 56                pane.toolbar().update(cx, |toolbar, cx| {
 57                    let buffer_search_bar = cx.add_view(BufferSearchBar::new);
 58                    toolbar.add_item(buffer_search_bar, cx);
 59                    let project_search_bar = cx.add_view(|_| ProjectSearchBar::new());
 60                    toolbar.add_item(project_search_bar, cx);
 61                })
 62            });
 63        });
 64
 65        project
 66            .update(cx, |project, cx| {
 67                project.find_or_create_local_worktree("/root", true, cx)
 68            })
 69            .await
 70            .unwrap();
 71        cx.read(|cx| workspace.read(cx).worktree_scans_complete(cx))
 72            .await;
 73
 74        let file = cx.read(|cx| workspace.file_project_paths(cx)[0].clone());
 75        let item = workspace
 76            .update(cx, |workspace, cx| {
 77                workspace.open_path(file, None, true, cx)
 78            })
 79            .await
 80            .expect("Could not open test file");
 81
 82        let editor = cx.update(|cx| {
 83            item.act_as::<Editor>(cx)
 84                .expect("Opened test file wasn't an editor")
 85        });
 86        editor.update(cx, |_, cx| cx.focus_self());
 87
 88        Self {
 89            cx: EditorTestContext {
 90                cx,
 91                window_id,
 92                editor,
 93            },
 94            workspace,
 95        }
 96    }
 97
 98    pub fn workspace<F, T>(&mut self, read: F) -> T
 99    where
100        F: FnOnce(&Workspace, &AppContext) -> T,
101    {
102        self.workspace.read_with(self.cx.cx, read)
103    }
104
105    pub fn enable_vim(&mut self) {
106        self.cx.update(|cx| {
107            cx.update_global(|settings: &mut Settings, _| {
108                settings.vim_mode = true;
109            });
110        })
111    }
112
113    pub fn disable_vim(&mut self) {
114        self.cx.update(|cx| {
115            cx.update_global(|settings: &mut Settings, _| {
116                settings.vim_mode = false;
117            });
118        })
119    }
120
121    pub fn mode(&mut self) -> Mode {
122        self.cx.read(|cx| cx.global::<Vim>().state.mode)
123    }
124
125    pub fn active_operator(&mut self) -> Option<Operator> {
126        self.cx
127            .read(|cx| cx.global::<Vim>().state.operator_stack.last().copied())
128    }
129
130    pub fn set_state(&mut self, text: &str, mode: Mode) -> ContextHandle {
131        self.cx.update(|cx| {
132            Vim::update(cx, |vim, cx| {
133                vim.switch_mode(mode, false, cx);
134            })
135        });
136        self.cx.set_state(text)
137    }
138
139    pub fn assert_state(&mut self, text: &str, mode: Mode) {
140        self.assert_editor_state(text);
141        assert_eq!(self.mode(), mode, "{}", self.assertion_context());
142    }
143
144    pub fn assert_binding<const COUNT: usize>(
145        &mut self,
146        keystrokes: [&str; COUNT],
147        initial_state: &str,
148        initial_mode: Mode,
149        state_after: &str,
150        mode_after: Mode,
151    ) {
152        self.set_state(initial_state, initial_mode);
153        self.cx.simulate_keystrokes(keystrokes);
154        self.cx.assert_editor_state(state_after);
155        assert_eq!(self.mode(), mode_after, "{}", self.assertion_context());
156        assert_eq!(self.active_operator(), None, "{}", self.assertion_context());
157    }
158
159    pub fn binding<const COUNT: usize>(
160        mut self,
161        keystrokes: [&'static str; COUNT],
162    ) -> VimBindingTestContext<'a, COUNT> {
163        let mode = self.mode();
164        VimBindingTestContext::new(keystrokes, mode, mode, self)
165    }
166}
167
168impl<'a> Deref for VimTestContext<'a> {
169    type Target = EditorTestContext<'a>;
170
171    fn deref(&self) -> &Self::Target {
172        &self.cx
173    }
174}
175
176impl<'a> DerefMut for VimTestContext<'a> {
177    fn deref_mut(&mut self) -> &mut Self::Target {
178        &mut self.cx
179    }
180}