use anyhow::{anyhow, Result};use collections::HashMap;use command_palette_hooks::CommandInterceptResult;use editor::{    actions::{SortLinesCaseInsensitive, SortLinesCaseSensitive},    display_map::ToDisplayPoint,    scroll::Autoscroll,    Bias, Editor, ToPoint,};use gpui::{actions, impl_internal_actions, Action, App, Context, Global, Window};use language::Point;use multi_buffer::MultiBufferRow;use regex::Regex;use schemars::JsonSchema;use search::{BufferSearchBar, SearchOptions};use serde::Deserialize;use std::{    io::Write,    iter::Peekable,    ops::{Deref, Range},    process::Stdio,    str::Chars,    sync::OnceLock,    time::Instant,};use task::{HideStrategy, RevealStrategy, SpawnInTerminal, TaskId};use ui::ActiveTheme;use util::ResultExt;use workspace::{notifications::NotifyResultExt, SaveIntent};use zed_actions::RevealTarget; use crate::{    motion::{EndOfDocument, Motion, StartOfDocument},    normal::{        search::{FindCommand, ReplaceCommand, Replacement},        JoinLines,    },    object::Object,    state::Mode,    visual::VisualDeleteLine,    Vim,}; #[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(Debug)]struct WrappedAction(Box<dyn Action>); actions!(vim, [VisualCommand, CountCommand, ShellCommand]);impl_internal_actions!(    vim,    [        GoToLine,        YankCommand,        WithRange,        WithCount,        OnMatchingLines,        ShellExec    ]); 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, _: &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, _: &CountCommand, window, cx| {        let Some(workspace) = vim.workspace(window) else {            return;        };        let count = Vim::take_count(cx).unwrap_or(1);        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,                    true,                    true,                    vec![Point::new(range.start.0, 0)..end],                    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>>,    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 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,        mut query: &str,        range: &Option<CommandRange>,        cx: &App,    ) -> Option<Box<dyn Action>> {        let has_bang = query.ends_with('!');        if has_bang {            query = &query[..query.len() - 1];        }         let suffix = query.strip_prefix(self.prefix)?;        if !self.suffix.starts_with(suffix) {            return None;        }         let action = if has_bang && self.bang_action.is_some() {            self.bang_action.as_ref().unwrap().boxed_clone()        } else if let Some(action) = self.action.as_ref() {            action.boxed_clone()        } else if let Some(action_name) = self.action_name {            cx.build_action(action_name, None).log_err()?        } else {            return None;        };         if let Some(range) = range {            self.range.as_ref().and_then(|f| f(action, range))        } else {            Some(action)        }    }     // TODO: ranges with search queries    fn parse_range(query: &str) -> (Option<CommandRange>, String) {        let mut chars = query.chars().peekable();         match chars.peek() {            Some('%') => {                chars.next();                return (                    Some(CommandRange {                        start: Position::Line { row: 1, offset: 0 },                        end: Some(Position::LastLine { offset: 0 }),                    }),                    chars.collect(),                );            }            Some('*') => {                chars.next();                return (                    Some(CommandRange {                        start: Position::Mark {                            name: '<',                            offset: 0,                        },                        end: Some(Position::Mark {                            name: '>',                            offset: 0,                        }),                    }),                    chars.collect(),                );            }            _ => {}        }         let start = Self::parse_position(&mut chars);         match chars.peek() {            Some(',' | ';') => {                chars.next();                (                    Some(CommandRange {                        start: start.unwrap_or(Position::CurrentLine { offset: 0 }),                        end: Self::parse_position(&mut chars),                    }),                    chars.collect(),                )            }            _ => (                start.map(|start| CommandRange { start, end: None }),                chars.collect(),            ),        }    }     fn parse_position(chars: &mut Peekable<Chars>) -> Option<Position> {        match chars.peek()? {            '0'..='9' => {                let row = Self::parse_u32(chars);                Some(Position::Line {                    row,                    offset: Self::parse_offset(chars),                })            }            '\'' => {                chars.next();                let name = chars.next()?;                Some(Position::Mark {                    name,                    offset: Self::parse_offset(chars),                })            }            '.' => {                chars.next();                Some(Position::CurrentLine {                    offset: Self::parse_offset(chars),                })            }            '+' | '-' => Some(Position::CurrentLine {                offset: Self::parse_offset(chars),            }),            '$' => {                chars.next();                Some(Position::LastLine {                    offset: Self::parse_offset(chars),                })            }            _ => None,        }    }     fn parse_offset(chars: &mut Peekable<Chars>) -> i32 {        let mut res: i32 = 0;        while matches!(chars.peek(), Some('+' | '-')) {            let sign = if chars.next().unwrap() == '+' { 1 } else { -1 };            let amount = if matches!(chars.peek(), Some('0'..='9')) {                (Self::parse_u32(chars) as i32).saturating_mul(sign)            } else {                sign            };            res = res.saturating_add(amount)        }        res    }     fn parse_u32(chars: &mut Peekable<Chars>) -> u32 {        let mut res: u32 = 0;        while matches!(chars.peek(), Some('0'..='9')) {            res = res                .saturating_mul(10)                .saturating_add(chars.next().unwrap() as u32 - '0' as u32);        }        res    }} #[derive(Clone, Debug, Deserialize, JsonSchema, PartialEq)]enum Position {    Line { row: u32, offset: i32 },    Mark { name: char, offset: i32 },    LastLine { offset: i32 },    CurrentLine { offset: i32 },} impl Position {    fn buffer_row(        &self,        vim: &Vim,        editor: &mut Editor,        window: &mut Window,        cx: &mut App,    ) -> Result<MultiBufferRow> {        let snapshot = editor.snapshot(window, cx);        let target = match self {            Position::Line { row, offset } => {                if let Some(anchor) = editor.active_excerpt(cx).and_then(|(_, buffer, _)| {                    editor.buffer().read(cx).buffer_point_to_anchor(                        &buffer,                        Point::new(row.saturating_sub(1), 0),                        cx,                    )                }) {                    anchor                        .to_point(&snapshot.buffer_snapshot)                        .row                        .saturating_add_signed(*offset)                } else {                    row.saturating_add_signed(offset.saturating_sub(1))                }            }            Position::Mark { name, offset } => {                let Some(mark) = vim.marks.get(&name.to_string()).and_then(|vec| vec.last()) else {                    return Err(anyhow!("mark {} not set", name));                };                mark.to_point(&snapshot.buffer_snapshot)                    .row                    .saturating_add_signed(*offset)            }            Position::LastLine { offset } => snapshot                .buffer_snapshot                .max_row()                .0                .saturating_add_signed(*offset),            Position::CurrentLine { offset } => editor                .selections                .newest_anchor()

Lines 1–500 of 1771. Load more