1use command_palette::CommandInterceptResult;
  2use editor::actions::{SortLinesCaseInsensitive, SortLinesCaseSensitive};
  3use gpui::{impl_actions, Action, AppContext, ViewContext};
  4use serde_derive::Deserialize;
  5use workspace::{SaveIntent, Workspace};
  6
  7use crate::{
  8    motion::{EndOfDocument, Motion, StartOfDocument},
  9    normal::{
 10        move_cursor,
 11        search::{FindCommand, ReplaceCommand},
 12        JoinLines,
 13    },
 14    state::Mode,
 15    Vim,
 16};
 17
 18#[derive(Debug, Clone, PartialEq, Deserialize)]
 19pub struct GoToLine {
 20    pub line: u32,
 21}
 22
 23impl_actions!(vim, [GoToLine]);
 24
 25pub fn register(workspace: &mut Workspace, _: &mut ViewContext<Workspace>) {
 26    workspace.register_action(|_: &mut Workspace, action: &GoToLine, cx| {
 27        Vim::update(cx, |vim, cx| {
 28            vim.switch_mode(Mode::Normal, false, cx);
 29            move_cursor(vim, Motion::StartOfDocument, Some(action.line as usize), cx);
 30        });
 31    });
 32}
 33
 34pub fn command_interceptor(mut query: &str, _: &AppContext) -> Option<CommandInterceptResult> {
 35    // Note: this is a very poor simulation of vim's command palette.
 36    // In the future we should adjust it to handle parsing range syntax,
 37    // and then calling the appropriate commands with/without ranges.
 38    //
 39    // We also need to support passing arguments to commands like :w
 40    // (ideally with filename autocompletion).
 41    //
 42    // For now, you can only do a replace on the % range, and you can
 43    // only use a specific line number range to "go to line"
 44    while query.starts_with(":") {
 45        query = &query[1..];
 46    }
 47
 48    let (name, action) = match query {
 49        // save and quit
 50        "w" | "wr" | "wri" | "writ" | "write" => (
 51            "write",
 52            workspace::Save {
 53                save_intent: Some(SaveIntent::Save),
 54            }
 55            .boxed_clone(),
 56        ),
 57        "w!" | "wr!" | "wri!" | "writ!" | "write!" => (
 58            "write!",
 59            workspace::Save {
 60                save_intent: Some(SaveIntent::Overwrite),
 61            }
 62            .boxed_clone(),
 63        ),
 64        "q" | "qu" | "qui" | "quit" => (
 65            "quit",
 66            workspace::CloseActiveItem {
 67                save_intent: Some(SaveIntent::Close),
 68            }
 69            .boxed_clone(),
 70        ),
 71        "q!" | "qu!" | "qui!" | "quit!" => (
 72            "quit!",
 73            workspace::CloseActiveItem {
 74                save_intent: Some(SaveIntent::Skip),
 75            }
 76            .boxed_clone(),
 77        ),
 78        "wq" => (
 79            "wq",
 80            workspace::CloseActiveItem {
 81                save_intent: Some(SaveIntent::Save),
 82            }
 83            .boxed_clone(),
 84        ),
 85        "wq!" => (
 86            "wq!",
 87            workspace::CloseActiveItem {
 88                save_intent: Some(SaveIntent::Overwrite),
 89            }
 90            .boxed_clone(),
 91        ),
 92        "x" | "xi" | "xit" | "exi" | "exit" => (
 93            "exit",
 94            workspace::CloseActiveItem {
 95                save_intent: Some(SaveIntent::SaveAll),
 96            }
 97            .boxed_clone(),
 98        ),
 99        "x!" | "xi!" | "xit!" | "exi!" | "exit!" => (
100            "exit!",
101            workspace::CloseActiveItem {
102                save_intent: Some(SaveIntent::Overwrite),
103            }
104            .boxed_clone(),
105        ),
106        "up" | "upd" | "upda" | "updat" | "update" => (
107            "update",
108            workspace::Save {
109                save_intent: Some(SaveIntent::SaveAll),
110            }
111            .boxed_clone(),
112        ),
113        "wa" | "wal" | "wall" => (
114            "wall",
115            workspace::SaveAll {
116                save_intent: Some(SaveIntent::SaveAll),
117            }
118            .boxed_clone(),
119        ),
120        "wa!" | "wal!" | "wall!" => (
121            "wall!",
122            workspace::SaveAll {
123                save_intent: Some(SaveIntent::Overwrite),
124            }
125            .boxed_clone(),
126        ),
127        "qa" | "qal" | "qall" | "quita" | "quital" | "quitall" => (
128            "quitall",
129            workspace::CloseAllItemsAndPanes {
130                save_intent: Some(SaveIntent::Close),
131            }
132            .boxed_clone(),
133        ),
134        "qa!" | "qal!" | "qall!" | "quita!" | "quital!" | "quitall!" => (
135            "quitall!",
136            workspace::CloseAllItemsAndPanes {
137                save_intent: Some(SaveIntent::Skip),
138            }
139            .boxed_clone(),
140        ),
141        "xa" | "xal" | "xall" => (
142            "xall",
143            workspace::CloseAllItemsAndPanes {
144                save_intent: Some(SaveIntent::SaveAll),
145            }
146            .boxed_clone(),
147        ),
148        "xa!" | "xal!" | "xall!" => (
149            "xall!",
150            workspace::CloseAllItemsAndPanes {
151                save_intent: Some(SaveIntent::Overwrite),
152            }
153            .boxed_clone(),
154        ),
155        "wqa" | "wqal" | "wqall" => (
156            "wqall",
157            workspace::CloseAllItemsAndPanes {
158                save_intent: Some(SaveIntent::SaveAll),
159            }
160            .boxed_clone(),
161        ),
162        "wqa!" | "wqal!" | "wqall!" => (
163            "wqall!",
164            workspace::CloseAllItemsAndPanes {
165                save_intent: Some(SaveIntent::Overwrite),
166            }
167            .boxed_clone(),
168        ),
169        "cq" | "cqu" | "cqui" | "cquit" | "cq!" | "cqu!" | "cqui!" | "cquit!" => {
170            ("cquit!", zed_actions::Quit.boxed_clone())
171        }
172
173        // pane management
174        "sp" | "spl" | "spli" | "split" => ("split", workspace::SplitUp.boxed_clone()),
175        "vs" | "vsp" | "vspl" | "vspli" | "vsplit" => {
176            ("vsplit", workspace::SplitLeft.boxed_clone())
177        }
178        "new" => (
179            "new",
180            workspace::NewFileInDirection(workspace::SplitDirection::Up).boxed_clone(),
181        ),
182        "vne" | "vnew" => (
183            "vnew",
184            workspace::NewFileInDirection(workspace::SplitDirection::Left).boxed_clone(),
185        ),
186        "tabe" | "tabed" | "tabedi" | "tabedit" => ("tabedit", workspace::NewFile.boxed_clone()),
187        "tabnew" => ("tabnew", workspace::NewFile.boxed_clone()),
188
189        "tabn" | "tabne" | "tabnex" | "tabnext" => {
190            ("tabnext", workspace::ActivateNextItem.boxed_clone())
191        }
192        "tabp" | "tabpr" | "tabpre" | "tabprev" | "tabprevi" | "tabprevio" | "tabpreviou"
193        | "tabprevious" => ("tabprevious", workspace::ActivatePrevItem.boxed_clone()),
194        "tabN" | "tabNe" | "tabNex" | "tabNext" => {
195            ("tabNext", workspace::ActivatePrevItem.boxed_clone())
196        }
197        "tabc" | "tabcl" | "tabclo" | "tabclos" | "tabclose" => (
198            "tabclose",
199            workspace::CloseActiveItem {
200                save_intent: Some(SaveIntent::Close),
201            }
202            .boxed_clone(),
203        ),
204
205        // quickfix / loclist (merged together for now)
206        "cl" | "cli" | "clis" | "clist" => ("clist", diagnostics::Deploy.boxed_clone()),
207        "cc" => ("cc", editor::actions::Hover.boxed_clone()),
208        "ll" => ("ll", editor::actions::Hover.boxed_clone()),
209        "cn" | "cne" | "cnex" | "cnext" => ("cnext", editor::actions::GoToDiagnostic.boxed_clone()),
210        "lne" | "lnex" | "lnext" => ("cnext", editor::actions::GoToDiagnostic.boxed_clone()),
211
212        "cpr" | "cpre" | "cprev" | "cprevi" | "cprevio" | "cpreviou" | "cprevious" => (
213            "cprevious",
214            editor::actions::GoToPrevDiagnostic.boxed_clone(),
215        ),
216        "cN" | "cNe" | "cNex" | "cNext" => {
217            ("cNext", editor::actions::GoToPrevDiagnostic.boxed_clone())
218        }
219        "lp" | "lpr" | "lpre" | "lprev" | "lprevi" | "lprevio" | "lpreviou" | "lprevious" => (
220            "lprevious",
221            editor::actions::GoToPrevDiagnostic.boxed_clone(),
222        ),
223        "lN" | "lNe" | "lNex" | "lNext" => {
224            ("lNext", editor::actions::GoToPrevDiagnostic.boxed_clone())
225        }
226
227        // modify the buffer (should accept [range])
228        "j" | "jo" | "joi" | "join" => ("join", JoinLines.boxed_clone()),
229        "d" | "de" | "del" | "dele" | "delet" | "delete" | "dl" | "dell" | "delel" | "deletl"
230        | "deletel" | "dp" | "dep" | "delp" | "delep" | "deletp" | "deletep" => {
231            ("delete", editor::actions::DeleteLine.boxed_clone())
232        }
233        "sor" | "sor " | "sort" | "sort " => ("sort", SortLinesCaseSensitive.boxed_clone()),
234        "sor i" | "sort i" => ("sort i", SortLinesCaseInsensitive.boxed_clone()),
235
236        // goto (other ranges handled under _ => )
237        "$" => ("$", EndOfDocument.boxed_clone()),
238        "%" => ("%", EndOfDocument.boxed_clone()),
239        "0" => ("0", StartOfDocument.boxed_clone()),
240
241        _ => {
242            if query.starts_with("/") || query.starts_with("?") {
243                (
244                    query,
245                    FindCommand {
246                        query: query[1..].to_string(),
247                        backwards: query.starts_with("?"),
248                    }
249                    .boxed_clone(),
250                )
251            } else if query.starts_with("%") {
252                (
253                    query,
254                    ReplaceCommand {
255                        query: query.to_string(),
256                    }
257                    .boxed_clone(),
258                )
259            } else if let Ok(line) = query.parse::<u32>() {
260                (query, GoToLine { line }.boxed_clone())
261            } else {
262                return None;
263            }
264        }
265    };
266
267    let string = ":".to_owned() + name;
268    let positions = generate_positions(&string, query);
269
270    Some(CommandInterceptResult {
271        action,
272        string,
273        positions,
274    })
275}
276
277fn generate_positions(string: &str, query: &str) -> Vec<usize> {
278    let mut positions = Vec::new();
279    let mut chars = query.chars().into_iter();
280
281    let Some(mut current) = chars.next() else {
282        return positions;
283    };
284
285    for (i, c) in string.char_indices() {
286        if c == current {
287            positions.push(i);
288            if let Some(c) = chars.next() {
289                current = c;
290            } else {
291                break;
292            }
293        }
294    }
295
296    positions
297}
298
299#[cfg(test)]
300mod test {
301    use std::path::Path;
302
303    use crate::test::{NeovimBackedTestContext, VimTestContext};
304    use gpui::TestAppContext;
305    use indoc::indoc;
306
307    #[gpui::test]
308    async fn test_command_basics(cx: &mut TestAppContext) {
309        let mut cx = NeovimBackedTestContext::new(cx).await;
310
311        cx.set_shared_state(indoc! {"
312            ˇa
313            b
314            c"})
315            .await;
316
317        cx.simulate_shared_keystrokes([":", "j", "enter"]).await;
318
319        // hack: our cursor positionining after a join command is wrong
320        cx.simulate_shared_keystrokes(["^"]).await;
321        cx.assert_shared_state(indoc! {
322            "ˇa b
323            c"
324        })
325        .await;
326    }
327
328    #[gpui::test]
329    async fn test_command_goto(cx: &mut TestAppContext) {
330        let mut cx = NeovimBackedTestContext::new(cx).await;
331
332        cx.set_shared_state(indoc! {"
333            ˇa
334            b
335            c"})
336            .await;
337        cx.simulate_shared_keystrokes([":", "3", "enter"]).await;
338        cx.assert_shared_state(indoc! {"
339            a
340            b
341            ˇc"})
342            .await;
343    }
344
345    #[gpui::test]
346    async fn test_command_replace(cx: &mut TestAppContext) {
347        let mut cx = NeovimBackedTestContext::new(cx).await;
348
349        cx.set_shared_state(indoc! {"
350            ˇa
351            b
352            c"})
353            .await;
354        cx.simulate_shared_keystrokes([":", "%", "s", "/", "b", "/", "d", "enter"])
355            .await;
356        cx.assert_shared_state(indoc! {"
357            a
358            ˇd
359            c"})
360            .await;
361        cx.simulate_shared_keystrokes([
362            ":", "%", "s", ":", ".", ":", "\\", "0", "\\", "0", "enter",
363        ])
364        .await;
365        cx.assert_shared_state(indoc! {"
366            aa
367            dd
368            ˇcc"})
369            .await;
370    }
371
372    #[gpui::test]
373    async fn test_command_search(cx: &mut TestAppContext) {
374        let mut cx = NeovimBackedTestContext::new(cx).await;
375
376        cx.set_shared_state(indoc! {"
377                ˇa
378                b
379                a
380                c"})
381            .await;
382        cx.simulate_shared_keystrokes([":", "/", "b", "enter"])
383            .await;
384        cx.assert_shared_state(indoc! {"
385                a
386                ˇb
387                a
388                c"})
389            .await;
390        cx.simulate_shared_keystrokes([":", "?", "a", "enter"])
391            .await;
392        cx.assert_shared_state(indoc! {"
393                ˇa
394                b
395                a
396                c"})
397            .await;
398    }
399
400    #[gpui::test]
401    async fn test_command_write(cx: &mut TestAppContext) {
402        let mut cx = VimTestContext::new(cx, true).await;
403        let path = Path::new("/root/dir/file.rs");
404        let fs = cx.workspace(|workspace, cx| workspace.project().read(cx).fs().clone());
405
406        cx.simulate_keystrokes(["i", "@", "escape"]);
407        cx.simulate_keystrokes([":", "w", "enter"]);
408
409        assert_eq!(fs.load(&path).await.unwrap(), "@\n");
410
411        fs.as_fake()
412            .write_file_internal(path, "oops\n".to_string())
413            .unwrap();
414
415        // conflict!
416        cx.simulate_keystrokes(["i", "@", "escape"]);
417        cx.simulate_keystrokes([":", "w", "enter"]);
418        assert!(cx.has_pending_prompt());
419        // "Cancel"
420        cx.simulate_prompt_answer(0);
421        assert_eq!(fs.load(&path).await.unwrap(), "oops\n");
422        assert!(!cx.has_pending_prompt());
423        // force overwrite
424        cx.simulate_keystrokes([":", "w", "!", "enter"]);
425        assert!(!cx.has_pending_prompt());
426        assert_eq!(fs.load(&path).await.unwrap(), "@@\n");
427    }
428
429    #[gpui::test]
430    async fn test_command_quit(cx: &mut TestAppContext) {
431        let mut cx = VimTestContext::new(cx, true).await;
432
433        cx.simulate_keystrokes([":", "n", "e", "w", "enter"]);
434        cx.workspace(|workspace, cx| assert_eq!(workspace.items(cx).count(), 2));
435        cx.simulate_keystrokes([":", "q", "enter"]);
436        cx.workspace(|workspace, cx| assert_eq!(workspace.items(cx).count(), 1));
437        cx.simulate_keystrokes([":", "n", "e", "w", "enter"]);
438        cx.workspace(|workspace, cx| assert_eq!(workspace.items(cx).count(), 2));
439        cx.simulate_keystrokes([":", "q", "a", "enter"]);
440        cx.workspace(|workspace, cx| assert_eq!(workspace.items(cx).count(), 0));
441    }
442}