use anyhow::{Result, anyhow};use collections::HashMap;use command_palette_hooks::CommandInterceptResult;use editor::{ Bias, Editor, ToPoint, actions::{SortLinesCaseInsensitive, SortLinesCaseSensitive}, display_map::ToDisplayPoint, scroll::Autoscroll,};use gpui::{Action, App, AppContext as _, Context, Global, Window, actions, impl_internal_actions};use itertools::Itertools;use language::Point;use multi_buffer::MultiBufferRow;use project::ProjectPath;use regex::Regex;use schemars::JsonSchema;use search::{BufferSearchBar, SearchOptions};use serde::Deserialize;use std::{ io::Write, iter::Peekable, ops::{Deref, Range}, path::Path, process::Stdio, str::Chars, sync::{Arc, OnceLock}, time::Instant,};use task::{HideStrategy, RevealStrategy, SpawnInTerminal, TaskId};use ui::ActiveTheme;use util::ResultExt;use workspace::notifications::DetachAndPromptErr;use workspace::{Item, SaveIntent, notifications::NotifyResultExt};use zed_actions::{OpenDocs, RevealTarget}; use crate::{ ToggleMarksView, ToggleRegistersView, Vim, motion::{EndOfDocument, Motion, MotionKind, StartOfDocument}, normal::{ JoinLines, search::{FindCommand, ReplaceCommand, Replacement}, }, object::Object, state::{Mark, Mode}, visual::VisualDeleteLine,}; #[derive(Clone, Debug, PartialEq)]pub struct GoToLine { range: CommandRange,} #[derive(Clone, Debug, PartialEq)]pub struct YankCommand { range: CommandRange,} #[derive(Clone, Debug, PartialEq)]pub struct WithRange { restore_selection: bool, range: CommandRange, action: WrappedAction,} #[derive(Clone, Debug, PartialEq)]pub struct WithCount { count: u32, action: WrappedAction,} #[derive(Clone, Deserialize, JsonSchema, PartialEq)]pub enum VimOption { Wrap(bool), Number(bool), RelativeNumber(bool),} impl VimOption { fn possible_commands(query: &str) -> Vec<CommandInterceptResult> { let mut prefix_of_options = Vec::new(); let mut options = query.split(" ").collect::<Vec<_>>(); let prefix = options.pop().unwrap_or_default(); for option in options { if let Some(opt) = Self::from(option) { prefix_of_options.push(opt) } else { return vec![]; } } Self::possibilities(&prefix) .map(|possible| { let mut options = prefix_of_options.clone(); options.push(possible); CommandInterceptResult { string: format!( ":set {}", options.iter().map(|opt| opt.to_string()).join(" ") ), action: VimSet { options }.boxed_clone(), positions: vec![], } }) .collect() } fn possibilities(query: &str) -> impl Iterator<Item = Self> + '_ { [ (None, VimOption::Wrap(true)), (None, VimOption::Wrap(false)), (None, VimOption::Number(true)), (None, VimOption::Number(false)), (None, VimOption::RelativeNumber(true)), (None, VimOption::RelativeNumber(false)), (Some("rnu"), VimOption::RelativeNumber(true)), (Some("nornu"), VimOption::RelativeNumber(false)), ] .into_iter() .filter(move |(prefix, option)| prefix.unwrap_or(option.to_string()).starts_with(query)) .map(|(_, option)| option) } fn from(option: &str) -> Option<Self> { match option { "wrap" => Some(Self::Wrap(true)), "nowrap" => Some(Self::Wrap(false)), "number" => Some(Self::Number(true)), "nu" => Some(Self::Number(true)), "nonumber" => Some(Self::Number(false)), "nonu" => Some(Self::Number(false)), "relativenumber" => Some(Self::RelativeNumber(true)), "rnu" => Some(Self::RelativeNumber(true)), "norelativenumber" => Some(Self::RelativeNumber(false)), "nornu" => Some(Self::RelativeNumber(false)), _ => None, } } fn to_string(&self) -> &'static str { match self { VimOption::Wrap(true) => "wrap", VimOption::Wrap(false) => "nowrap", VimOption::Number(true) => "number", VimOption::Number(false) => "nonumber", VimOption::RelativeNumber(true) => "relativenumber", VimOption::RelativeNumber(false) => "norelativenumber", } }} #[derive(Clone, Deserialize, JsonSchema, PartialEq)]pub struct VimSet { options: Vec<VimOption>,} #[derive(Debug)]struct WrappedAction(Box<dyn Action>); #[derive(Clone, Deserialize, JsonSchema, PartialEq)]struct VimSave { pub save_intent: Option<SaveIntent>, pub filename: String,} actions!(vim, [VisualCommand, CountCommand, ShellCommand]);impl_internal_actions!( vim, [ GoToLine, YankCommand, WithRange, WithCount, OnMatchingLines, ShellExec, VimSet, VimSave, ]); impl PartialEq for WrappedAction { fn eq(&self, other: &Self) -> bool { self.0.partial_eq(&*other.0) }} impl Clone for WrappedAction { fn clone(&self) -> Self { Self(self.0.boxed_clone()) }} impl Deref for WrappedAction { type Target = dyn Action; fn deref(&self) -> &dyn Action { &*self.0 }} pub fn register(editor: &mut Editor, cx: &mut Context<Vim>) { // Vim::action(editor, cx, |vim, action: &StartOfLine, window, cx| { Vim::action(editor, cx, |vim, action: &VimSet, window, cx| { for option in action.options.iter() { vim.update_editor(window, cx, |_, editor, _, cx| match option { VimOption::Wrap(true) => { editor .set_soft_wrap_mode(language::language_settings::SoftWrap::EditorWidth, cx); } VimOption::Wrap(false) => { editor.set_soft_wrap_mode(language::language_settings::SoftWrap::None, cx); } VimOption::Number(enabled) => { editor.set_show_line_numbers(*enabled, cx); } VimOption::RelativeNumber(enabled) => { editor.set_relative_line_number(Some(*enabled), cx); } }); } }); Vim::action(editor, cx, |vim, _: &VisualCommand, window, cx| { let Some(workspace) = vim.workspace(window) else { return; }; workspace.update(cx, |workspace, cx| { command_palette::CommandPalette::toggle(workspace, "'<,'>", window, cx); }) }); Vim::action(editor, cx, |vim, _: &ShellCommand, window, cx| { let Some(workspace) = vim.workspace(window) else { return; }; workspace.update(cx, |workspace, cx| { command_palette::CommandPalette::toggle(workspace, "'<,'>!", window, cx); }) }); Vim::action(editor, cx, |vim, action: &VimSave, window, cx| { vim.update_editor(window, cx, |_, editor, window, cx| { let Some(project) = editor.project.clone() else { return; }; let Some(worktree) = project.read(cx).visible_worktrees(cx).next() else { return; }; let project_path = ProjectPath { worktree_id: worktree.read(cx).id(), path: Arc::from(Path::new(&action.filename)), }; if project.read(cx).entry_for_path(&project_path, cx).is_some() && action.save_intent != Some(SaveIntent::Overwrite) { let answer = window.prompt( gpui::PromptLevel::Critical, &format!("{} already exists. Do you want to replace it?", project_path.path.to_string_lossy()), Some( "A file or folder with the same name already exists. Replacing it will overwrite its current contents.", ), &["Replace", "Cancel"], cx); cx.spawn_in(window, async move |editor, cx| { if answer.await.ok() != Some(0) { return; } let _ = editor.update_in(cx, |editor, window, cx|{ editor .save_as(project, project_path, window, cx) .detach_and_prompt_err("Failed to :w", window, cx, |_, _, _| None); }); }).detach(); } else { editor .save_as(project, project_path, window, cx) .detach_and_prompt_err("Failed to :w", window, cx, |_, _, _| None); } }); }); Vim::action(editor, cx, |vim, _: &CountCommand, window, cx| { let Some(workspace) = vim.workspace(window) else { return; }; let count = Vim::take_count(cx).unwrap_or(1); Vim::take_forced_motion(cx); let n = if count > 1 { format!(".,.+{}", count.saturating_sub(1)) } else { ".".to_string() }; workspace.update(cx, |workspace, cx| { command_palette::CommandPalette::toggle(workspace, &n, window, cx); }) }); Vim::action(editor, cx, |vim, action: &GoToLine, window, cx| { vim.switch_mode(Mode::Normal, false, window, cx); let result = vim.update_editor(window, cx, |vim, editor, window, cx| { let snapshot = editor.snapshot(window, cx); let buffer_row = action.range.head().buffer_row(vim, editor, window, cx)?; let current = editor.selections.newest::<Point>(cx); let target = snapshot .buffer_snapshot .clip_point(Point::new(buffer_row.0, current.head().column), Bias::Left); editor.change_selections(Some(Autoscroll::fit()), window, cx, |s| { s.select_ranges([target..target]); }); anyhow::Ok(()) }); if let Some(e @ Err(_)) = result { let Some(workspace) = vim.workspace(window) else { return; }; workspace.update(cx, |workspace, cx| { e.notify_err(workspace, cx); }); return; } }); Vim::action(editor, cx, |vim, action: &YankCommand, window, cx| { vim.update_editor(window, cx, |vim, editor, window, cx| { let snapshot = editor.snapshot(window, cx); if let Ok(range) = action.range.buffer_range(vim, editor, window, cx) { let end = if range.end < snapshot.buffer_snapshot.max_row() { Point::new(range.end.0 + 1, 0) } else { snapshot.buffer_snapshot.max_point() }; vim.copy_ranges( editor, MotionKind::Linewise, true, vec![Point::new(range.start.0, 0)..end], window, cx, ) } }); }); Vim::action(editor, cx, |_, action: &WithCount, window, cx| { for _ in 0..action.count { window.dispatch_action(action.action.boxed_clone(), cx) } }); Vim::action(editor, cx, |vim, action: &WithRange, window, cx| { let result = vim.update_editor(window, cx, |vim, editor, window, cx| { action.range.buffer_range(vim, editor, window, cx) }); let range = match result { None => return, Some(e @ Err(_)) => { let Some(workspace) = vim.workspace(window) else { return; }; workspace.update(cx, |workspace, cx| { e.notify_err(workspace, cx); }); return; } Some(Ok(result)) => result, }; let previous_selections = vim .update_editor(window, cx, |_, editor, window, cx| { let selections = action.restore_selection.then(|| { editor .selections .disjoint_anchor_ranges() .collect::<Vec<_>>() }); editor.change_selections(None, window, cx, |s| { let end = Point::new(range.end.0, s.buffer().line_len(range.end)); s.select_ranges([end..Point::new(range.start.0, 0)]); }); selections }) .flatten(); window.dispatch_action(action.action.boxed_clone(), cx); cx.defer_in(window, move |vim, window, cx| { vim.update_editor(window, cx, |_, editor, window, cx| { editor.change_selections(None, window, cx, |s| { if let Some(previous_selections) = previous_selections { s.select_ranges(previous_selections); } else { s.select_ranges([ Point::new(range.start.0, 0)..Point::new(range.start.0, 0) ]); } }) }); }); }); Vim::action(editor, cx, |vim, action: &OnMatchingLines, window, cx| { action.run(vim, window, cx) }); Vim::action(editor, cx, |vim, action: &ShellExec, window, cx| { action.run(vim, window, cx) })} #[derive(Default)]struct VimCommand { prefix: &'static str, suffix: &'static str, action: Option<Box<dyn Action>>, action_name: Option<&'static str>, bang_action: Option<Box<dyn Action>>, args: Option< Box<dyn Fn(Box<dyn Action>, String) -> Option<Box<dyn Action>> + Send + Sync + 'static>, >, range: Option< Box< dyn Fn(Box<dyn Action>, &CommandRange) -> Option<Box<dyn Action>> + Send + Sync + 'static, >, >, has_count: bool,} impl VimCommand { fn new(pattern: (&'static str, &'static str), action: impl Action) -> Self { Self { prefix: pattern.0, suffix: pattern.1, action: Some(action.boxed_clone()), ..Default::default() } } // from_str is used for actions in other crates. fn str(pattern: (&'static str, &'static str), action_name: &'static str) -> Self { Self { prefix: pattern.0, suffix: pattern.1, action_name: Some(action_name), ..Default::default() } } fn bang(mut self, bang_action: impl Action) -> Self { self.bang_action = Some(bang_action.boxed_clone()); self } fn args( mut self, f: impl Fn(Box<dyn Action>, String) -> Option<Box<dyn Action>> + Send + Sync + 'static, ) -> Self { self.args = Some(Box::new(f)); self } fn range( mut self, f: impl Fn(Box<dyn Action>, &CommandRange) -> Option<Box<dyn Action>> + Send + Sync + 'static, ) -> Self { self.range = Some(Box::new(f)); self } fn count(mut self) -> Self { self.has_count = true; self } fn parse( &self, query: &str, range: &Option<CommandRange>, cx: &App, ) -> Option<Box<dyn Action>> { let rest = query .to_string() .strip_prefix(self.prefix)? .to_string() .chars() .zip_longest(self.suffix.to_string().chars()) .skip_while(|e| e.clone().both().map(|(s, q)| s == q).unwrap_or(false)) .filter_map(|e| e.left()) .collect::<String>(); let has_bang = rest.starts_with('!'); let args = if has_bang { rest.strip_prefix('!')?.trim().to_string() } else if rest.is_empty() { "".into() } else { rest.strip_prefix(' ')?.trim().to_string() };Lines 1–500 of 2056. Load more
use anyhow::{Result, anyhow}; use collections::HashMap; use command_palette_hooks::CommandInterceptResult; use editor::{ Bias, Editor, ToPoint, actions::{SortLinesCaseInsensitive, SortLinesCaseSensitive}, display_map::ToDisplayPoint, scroll::Autoscroll, }; use gpui::{Action, App, AppContext as _, Context, Global, Window, actions, impl_internal_actions}; use itertools::Itertools; use language::Point; use multi_buffer::MultiBufferRow; use project::ProjectPath; use regex::Regex; use schemars::JsonSchema; use search::{BufferSearchBar, SearchOptions}; use serde::Deserialize; use std::{ io::Write, iter::Peekable, ops::{Deref, Range}, path::Path, process::Stdio, str::Chars, sync::{Arc, OnceLock}, time::Instant, }; use task::{HideStrategy, RevealStrategy, SpawnInTerminal, TaskId}; use ui::ActiveTheme; use util::ResultExt; use workspace::notifications::DetachAndPromptErr; use workspace::{Item, SaveIntent, notifications::NotifyResultExt}; use zed_actions::{OpenDocs, RevealTarget}; use crate::{ ToggleMarksView, ToggleRegistersView, Vim, motion::{EndOfDocument, Motion, MotionKind, StartOfDocument}, normal::{ JoinLines, search::{FindCommand, ReplaceCommand, Replacement}, }, object::Object, state::{Mark, Mode}, visual::VisualDeleteLine, }; #[derive(Clone, Debug, PartialEq)] pub struct GoToLine { range: CommandRange, } #[derive(Clone, Debug, PartialEq)] pub struct YankCommand { range: CommandRange, } #[derive(Clone, Debug, PartialEq)] pub struct WithRange { restore_selection: bool, range: CommandRange, action: WrappedAction, } #[derive(Clone, Debug, PartialEq)] pub struct WithCount { count: u32, action: WrappedAction, } #[derive(Clone, Deserialize, JsonSchema, PartialEq)] pub enum VimOption { Wrap(bool), Number(bool), RelativeNumber(bool), } impl VimOption { fn possible_commands(query: &str) -> Vec<CommandInterceptResult> { let mut prefix_of_options = Vec::new(); let mut options = query.split(" ").collect::<Vec<_>>(); let prefix = options.pop().unwrap_or_default(); for option in options { if let Some(opt) = Self::from(option) { prefix_of_options.push(opt) } else { return vec![]; } } Self::possibilities(&prefix) .map(|possible| { let mut options = prefix_of_options.clone(); options.push(possible); CommandInterceptResult { string: format!( ":set {}", options.iter().map(|opt| opt.to_string()).join(" ") ), action: VimSet { options }.boxed_clone(), positions: vec![], } }) .collect() } fn possibilities(query: &str) -> impl Iterator<Item = Self> + '_ { [ (None, VimOption::Wrap(true)), (None, VimOption::Wrap(false)), (None, VimOption::Number(true)), (None, VimOption::Number(false)), (None, VimOption::RelativeNumber(true)), (None, VimOption::RelativeNumber(false)), (Some("rnu"), VimOption::RelativeNumber(true)), (Some("nornu"), VimOption::RelativeNumber(false)), ] .into_iter() .filter(move |(prefix, option)| prefix.unwrap_or(option.to_string()).starts_with(query)) .map(|(_, option)| option) } fn from(option: &str) -> Option<Self> { match option { "wrap" => Some(Self::Wrap(true)), "nowrap" => Some(Self::Wrap(false)), "number" => Some(Self::Number(true)), "nu" => Some(Self::Number(true)), "nonumber" => Some(Self::Number(false)), "nonu" => Some(Self::Number(false)), "relativenumber" => Some(Self::RelativeNumber(true)), "rnu" => Some(Self::RelativeNumber(true)), "norelativenumber" => Some(Self::RelativeNumber(false)), "nornu" => Some(Self::RelativeNumber(false)), _ => None, } } fn to_string(&self) -> &'static str { match self { VimOption::Wrap(true) => "wrap", VimOption::Wrap(false) => "nowrap", VimOption::Number(true) => "number", VimOption::Number(false) => "nonumber", VimOption::RelativeNumber(true) => "relativenumber", VimOption::RelativeNumber(false) => "norelativenumber", } } } #[derive(Clone, Deserialize, JsonSchema, PartialEq)] pub struct VimSet { options: Vec<VimOption>, } #[derive(Debug)] struct WrappedAction(Box<dyn Action>); #[derive(Clone, Deserialize, JsonSchema, PartialEq)] struct VimSave { pub save_intent: Option<SaveIntent>, pub filename: String, } actions!(vim, [VisualCommand, CountCommand, ShellCommand]); impl_internal_actions!( vim, [ GoToLine, YankCommand, WithRange, WithCount, OnMatchingLines, ShellExec, VimSet, VimSave, ] ); impl PartialEq for WrappedAction { fn eq(&self, other: &Self) -> bool { self.0.partial_eq(&*other.0) } } impl Clone for WrappedAction { fn clone(&self) -> Self { Self(self.0.boxed_clone()) } } impl Deref for WrappedAction { type Target = dyn Action; fn deref(&self) -> &dyn Action { &*self.0 } } pub fn register(editor: &mut Editor, cx: &mut Context<Vim>) { // Vim::action(editor, cx, |vim, action: &StartOfLine, window, cx| { Vim::action(editor, cx, |vim, action: &VimSet, window, cx| { for option in action.options.iter() { vim.update_editor(window, cx, |_, editor, _, cx| match option { VimOption::Wrap(true) => { editor .set_soft_wrap_mode(language::language_settings::SoftWrap::EditorWidth, cx); } VimOption::Wrap(false) => { editor.set_soft_wrap_mode(language::language_settings::SoftWrap::None, cx); } VimOption::Number(enabled) => { editor.set_show_line_numbers(*enabled, cx); } VimOption::RelativeNumber(enabled) => { editor.set_relative_line_number(Some(*enabled), cx); } }); } }); Vim::action(editor, cx, |vim, _: &VisualCommand, window, cx| { let Some(workspace) = vim.workspace(window) else { return; }; workspace.update(cx, |workspace, cx| { command_palette::CommandPalette::toggle(workspace, "'<,'>", window, cx); }) }); Vim::action(editor, cx, |vim, _: &ShellCommand, window, cx| { let Some(workspace) = vim.workspace(window) else { return; }; workspace.update(cx, |workspace, cx| { command_palette::CommandPalette::toggle(workspace, "'<,'>!", window, cx); }) }); Vim::action(editor, cx, |vim, action: &VimSave, window, cx| { vim.update_editor(window, cx, |_, editor, window, cx| { let Some(project) = editor.project.clone() else { return; }; let Some(worktree) = project.read(cx).visible_worktrees(cx).next() else { return; }; let project_path = ProjectPath { worktree_id: worktree.read(cx).id(), path: Arc::from(Path::new(&action.filename)), }; if project.read(cx).entry_for_path(&project_path, cx).is_some() && action.save_intent != Some(SaveIntent::Overwrite) { let answer = window.prompt( gpui::PromptLevel::Critical, &format!("{} already exists. Do you want to replace it?", project_path.path.to_string_lossy()), Some( "A file or folder with the same name already exists. Replacing it will overwrite its current contents.", ), &["Replace", "Cancel"], cx); cx.spawn_in(window, async move |editor, cx| { if answer.await.ok() != Some(0) { return; } let _ = editor.update_in(cx, |editor, window, cx|{ editor .save_as(project, project_path, window, cx) .detach_and_prompt_err("Failed to :w", window, cx, |_, _, _| None); }); }).detach(); } else { editor .save_as(project, project_path, window, cx) .detach_and_prompt_err("Failed to :w", window, cx, |_, _, _| None); } }); }); Vim::action(editor, cx, |vim, _: &CountCommand, window, cx| { let Some(workspace) = vim.workspace(window) else { return; }; let count = Vim::take_count(cx).unwrap_or(1); Vim::take_forced_motion(cx); let n = if count > 1 { format!(".,.+{}", count.saturating_sub(1)) } else { ".".to_string() }; workspace.update(cx, |workspace, cx| { command_palette::CommandPalette::toggle(workspace, &n, window, cx); }) }); Vim::action(editor, cx, |vim, action: &GoToLine, window, cx| { vim.switch_mode(Mode::Normal, false, window, cx); let result = vim.update_editor(window, cx, |vim, editor, window, cx| { let snapshot = editor.snapshot(window, cx); let buffer_row = action.range.head().buffer_row(vim, editor, window, cx)?; let current = editor.selections.newest::<Point>(cx); let target = snapshot .buffer_snapshot .clip_point(Point::new(buffer_row.0, current.head().column), Bias::Left); editor.change_selections(Some(Autoscroll::fit()), window, cx, |s| { s.select_ranges([target..target]); }); anyhow::Ok(()) }); if let Some(e @ Err(_)) = result { let Some(workspace) = vim.workspace(window) else { return; }; workspace.update(cx, |workspace, cx| { e.notify_err(workspace, cx); }); return; } }); Vim::action(editor, cx, |vim, action: &YankCommand, window, cx| { vim.update_editor(window, cx, |vim, editor, window, cx| { let snapshot = editor.snapshot(window, cx); if let Ok(range) = action.range.buffer_range(vim, editor, window, cx) { let end = if range.end < snapshot.buffer_snapshot.max_row() { Point::new(range.end.0 + 1, 0) } else { snapshot.buffer_snapshot.max_point() }; vim.copy_ranges( editor, MotionKind::Linewise, true, vec![Point::new(range.start.0, 0)..end], window, cx, ) } }); }); Vim::action(editor, cx, |_, action: &WithCount, window, cx| { for _ in 0..action.count { window.dispatch_action(action.action.boxed_clone(), cx) } }); Vim::action(editor, cx, |vim, action: &WithRange, window, cx| { let result = vim.update_editor(window, cx, |vim, editor, window, cx| { action.range.buffer_range(vim, editor, window, cx) }); let range = match result { None => return, Some(e @ Err(_)) => { let Some(workspace) = vim.workspace(window) else { return; }; workspace.update(cx, |workspace, cx| { e.notify_err(workspace, cx); }); return; } Some(Ok(result)) => result, }; let previous_selections = vim .update_editor(window, cx, |_, editor, window, cx| { let selections = action.restore_selection.then(|| { editor .selections .disjoint_anchor_ranges() .collect::<Vec<_>>() }); editor.change_selections(None, window, cx, |s| { let end = Point::new(range.end.0, s.buffer().line_len(range.end)); s.select_ranges([end..Point::new(range.start.0, 0)]); }); selections }) .flatten(); window.dispatch_action(action.action.boxed_clone(), cx); cx.defer_in(window, move |vim, window, cx| { vim.update_editor(window, cx, |_, editor, window, cx| { editor.change_selections(None, window, cx, |s| { if let Some(previous_selections) = previous_selections { s.select_ranges(previous_selections); } else { s.select_ranges([ Point::new(range.start.0, 0)..Point::new(range.start.0, 0) ]); } }) }); }); }); Vim::action(editor, cx, |vim, action: &OnMatchingLines, window, cx| { action.run(vim, window, cx) }); Vim::action(editor, cx, |vim, action: &ShellExec, window, cx| { action.run(vim, window, cx) }) } #[derive(Default)] struct VimCommand { prefix: &'static str, suffix: &'static str, action: Option<Box<dyn Action>>, action_name: Option<&'static str>, bang_action: Option<Box<dyn Action>>, args: Option< Box<dyn Fn(Box<dyn Action>, String) -> Option<Box<dyn Action>> + Send + Sync + 'static>, >, range: Option< Box< dyn Fn(Box<dyn Action>, &CommandRange) -> Option<Box<dyn Action>> + Send + Sync + 'static, >, >, has_count: bool, } impl VimCommand { fn new(pattern: (&'static str, &'static str), action: impl Action) -> Self { Self { prefix: pattern.0, suffix: pattern.1, action: Some(action.boxed_clone()), ..Default::default() } } // from_str is used for actions in other crates. fn str(pattern: (&'static str, &'static str), action_name: &'static str) -> Self { Self { prefix: pattern.0, suffix: pattern.1, action_name: Some(action_name), ..Default::default() } } fn bang(mut self, bang_action: impl Action) -> Self { self.bang_action = Some(bang_action.boxed_clone()); self } fn args( mut self, f: impl Fn(Box<dyn Action>, String) -> Option<Box<dyn Action>> + Send + Sync + 'static, ) -> Self { self.args = Some(Box::new(f)); self } fn range( mut self, f: impl Fn(Box<dyn Action>, &CommandRange) -> Option<Box<dyn Action>> + Send + Sync + 'static, ) -> Self { self.range = Some(Box::new(f)); self } fn count(mut self) -> Self { self.has_count = true; self } fn parse( &self, query: &str, range: &Option<CommandRange>, cx: &App, ) -> Option<Box<dyn Action>> { let rest = query .to_string() .strip_prefix(self.prefix)? .to_string() .chars() .zip_longest(self.suffix.to_string().chars()) .skip_while(|e| e.clone().both().map(|(s, q)| s == q).unwrap_or(false)) .filter_map(|e| e.left()) .collect::<String>(); let has_bang = rest.starts_with('!'); let args = if has_bang { rest.strip_prefix('!')?.trim().to_string() } else if rest.is_empty() { "".into() } else { rest.strip_prefix(' ')?.trim().to_string() };