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) =
 45            cx.add_window(|cx| Workspace::new(project.clone(), |_, _| unimplemented!(), cx));
 46
 47        // Setup search toolbars
 48        workspace.update(cx, |workspace, cx| {
 49            workspace.active_pane().update(cx, |pane, cx| {
 50                pane.toolbar().update(cx, |toolbar, cx| {
 51                    let buffer_search_bar = cx.add_view(BufferSearchBar::new);
 52                    toolbar.add_item(buffer_search_bar, cx);
 53                    let project_search_bar = cx.add_view(|_| ProjectSearchBar::new());
 54                    toolbar.add_item(project_search_bar, cx);
 55                })
 56            });
 57        });
 58
 59        project
 60            .update(cx, |project, cx| {
 61                project.find_or_create_local_worktree("/root", true, cx)
 62            })
 63            .await
 64            .unwrap();
 65        cx.read(|cx| workspace.read(cx).worktree_scans_complete(cx))
 66            .await;
 67
 68        let file = cx.read(|cx| workspace.file_project_paths(cx)[0].clone());
 69        let item = workspace
 70            .update(cx, |workspace, cx| {
 71                workspace.open_path(file, None, true, cx)
 72            })
 73            .await
 74            .expect("Could not open test file");
 75
 76        let editor = cx.update(|cx| {
 77            item.act_as::<Editor>(cx)
 78                .expect("Opened test file wasn't an editor")
 79        });
 80        editor.update(cx, |_, cx| cx.focus_self());
 81
 82        Self {
 83            cx: EditorTestContext {
 84                cx,
 85                window_id,
 86                editor,
 87            },
 88            workspace,
 89        }
 90    }
 91
 92    pub fn workspace<F, T>(&mut self, read: F) -> T
 93    where
 94        F: FnOnce(&Workspace, &AppContext) -> T,
 95    {
 96        self.workspace.read_with(self.cx.cx, read)
 97    }
 98
 99    pub fn enable_vim(&mut self) {
100        self.cx.update(|cx| {
101            cx.update_global(|settings: &mut Settings, _| {
102                settings.vim_mode = true;
103            });
104        })
105    }
106
107    pub fn disable_vim(&mut self) {
108        self.cx.update(|cx| {
109            cx.update_global(|settings: &mut Settings, _| {
110                settings.vim_mode = false;
111            });
112        })
113    }
114
115    pub fn mode(&mut self) -> Mode {
116        self.cx.read(|cx| cx.global::<Vim>().state.mode)
117    }
118
119    pub fn active_operator(&mut self) -> Option<Operator> {
120        self.cx
121            .read(|cx| cx.global::<Vim>().state.operator_stack.last().copied())
122    }
123
124    pub fn set_state(&mut self, text: &str, mode: Mode) -> ContextHandle {
125        self.cx.update(|cx| {
126            Vim::update(cx, |vim, cx| {
127                vim.switch_mode(mode, false, cx);
128            })
129        });
130        self.cx.set_state(text)
131    }
132
133    pub fn assert_state(&mut self, text: &str, mode: Mode) {
134        self.assert_editor_state(text);
135        assert_eq!(self.mode(), mode, "{}", self.assertion_context());
136    }
137
138    pub fn assert_binding<const COUNT: usize>(
139        &mut self,
140        keystrokes: [&str; COUNT],
141        initial_state: &str,
142        initial_mode: Mode,
143        state_after: &str,
144        mode_after: Mode,
145    ) {
146        self.set_state(initial_state, initial_mode);
147        self.cx.simulate_keystrokes(keystrokes);
148        self.cx.assert_editor_state(state_after);
149        assert_eq!(self.mode(), mode_after, "{}", self.assertion_context());
150        assert_eq!(self.active_operator(), None, "{}", self.assertion_context());
151    }
152
153    pub fn binding<const COUNT: usize>(
154        mut self,
155        keystrokes: [&'static str; COUNT],
156    ) -> VimBindingTestContext<'a, COUNT> {
157        let mode = self.mode();
158        VimBindingTestContext::new(keystrokes, mode, mode, self)
159    }
160}
161
162impl<'a> Deref for VimTestContext<'a> {
163    type Target = EditorTestContext<'a>;
164
165    fn deref(&self) -> &Self::Target {
166        &self.cx
167    }
168}
169
170impl<'a> DerefMut for VimTestContext<'a> {
171    fn deref_mut(&mut self) -> &mut Self::Target {
172        &mut self.cx
173    }
174}