mod case;mod change;mod delete;mod increment;pub(crate) mod mark;mod paste;pub(crate) mod repeat;mod scroll;pub(crate) mod search;pub mod substitute;mod toggle_comments;pub(crate) mod yank; use std::collections::HashMap;use std::sync::Arc; use crate::{    indent::IndentDirection,    motion::{self, first_non_whitespace, next_line_end, right, Motion},    object::Object,    state::{Mode, Operator},    surrounds::SurroundsType,    Vim,};use case::CaseTarget;use collections::BTreeSet;use editor::scroll::Autoscroll;use editor::Anchor;use editor::Bias;use editor::Editor;use editor::{display_map::ToDisplayPoint, movement};use gpui::{actions, ViewContext};use language::{Point, SelectionGoal, ToPoint};use log::error;use multi_buffer::MultiBufferRow; actions!(    vim,    [        InsertAfter,        InsertBefore,        InsertFirstNonWhitespace,        InsertEndOfLine,        InsertLineAbove,        InsertLineBelow,        InsertAtPrevious,        JoinLines,        JoinLinesNoWhitespace,        DeleteLeft,        DeleteRight,        ChangeToEndOfLine,        DeleteToEndOfLine,        Yank,        YankLine,        ChangeCase,        ConvertToUpperCase,        ConvertToLowerCase,        ToggleComments,        ShowLocation,        Undo,        Redo,    ]); pub(crate) fn register(editor: &mut Editor, cx: &mut ViewContext<Vim>) {    Vim::action(editor, cx, Vim::insert_after);    Vim::action(editor, cx, Vim::insert_before);    Vim::action(editor, cx, Vim::insert_first_non_whitespace);    Vim::action(editor, cx, Vim::insert_end_of_line);    Vim::action(editor, cx, Vim::insert_line_above);    Vim::action(editor, cx, Vim::insert_line_below);    Vim::action(editor, cx, Vim::insert_at_previous);    Vim::action(editor, cx, Vim::change_case);    Vim::action(editor, cx, Vim::convert_to_upper_case);    Vim::action(editor, cx, Vim::convert_to_lower_case);    Vim::action(editor, cx, Vim::yank_line);    Vim::action(editor, cx, Vim::toggle_comments);    Vim::action(editor, cx, Vim::paste);    Vim::action(editor, cx, Vim::show_location);     Vim::action(editor, cx, |vim, _: &DeleteLeft, cx| {        vim.record_current_action(cx);        let times = Vim::take_count(cx);        vim.delete_motion(Motion::Left, times, cx);    });    Vim::action(editor, cx, |vim, _: &DeleteRight, cx| {        vim.record_current_action(cx);        let times = Vim::take_count(cx);        vim.delete_motion(Motion::Right, times, cx);    });    Vim::action(editor, cx, |vim, _: &ChangeToEndOfLine, cx| {        vim.start_recording(cx);        let times = Vim::take_count(cx);        vim.change_motion(            Motion::EndOfLine {                display_lines: false,            },            times,            cx,        );    });    Vim::action(editor, cx, |vim, _: &DeleteToEndOfLine, cx| {        vim.record_current_action(cx);        let times = Vim::take_count(cx);        vim.delete_motion(            Motion::EndOfLine {                display_lines: false,            },            times,            cx,        );    });    Vim::action(editor, cx, |vim, _: &JoinLines, cx| {        vim.join_lines_impl(true, cx);    });     Vim::action(editor, cx, |vim, _: &JoinLinesNoWhitespace, cx| {        vim.join_lines_impl(false, cx);    });     Vim::action(editor, cx, |vim, _: &Undo, cx| {        let times = Vim::take_count(cx);        vim.update_editor(cx, |_, editor, cx| {            for _ in 0..times.unwrap_or(1) {                editor.undo(&editor::actions::Undo, cx);            }        });    });    Vim::action(editor, cx, |vim, _: &Redo, cx| {        let times = Vim::take_count(cx);        vim.update_editor(cx, |_, editor, cx| {            for _ in 0..times.unwrap_or(1) {                editor.redo(&editor::actions::Redo, cx);            }        });    });     repeat::register(editor, cx);    scroll::register(editor, cx);    search::register(editor, cx);    substitute::register(editor, cx);    increment::register(editor, cx);} impl Vim {    pub fn normal_motion(        &mut self,        motion: Motion,        operator: Option<Operator>,        times: Option<usize>,        cx: &mut ViewContext<Self>,    ) {        match operator {            None => self.move_cursor(motion, times, cx),            Some(Operator::Change) => self.change_motion(motion, times, cx),            Some(Operator::Delete) => self.delete_motion(motion, times, cx),            Some(Operator::Yank) => self.yank_motion(motion, times, cx),            Some(Operator::AddSurrounds { target: None }) => {}            Some(Operator::Indent) => self.indent_motion(motion, times, IndentDirection::In, cx),            Some(Operator::Rewrap) => self.rewrap_motion(motion, times, cx),            Some(Operator::Outdent) => self.indent_motion(motion, times, IndentDirection::Out, cx),            Some(Operator::AutoIndent) => {                self.indent_motion(motion, times, IndentDirection::Auto, cx)            }            Some(Operator::ShellCommand) => self.shell_command_motion(motion, times, cx),            Some(Operator::Lowercase) => {                self.change_case_motion(motion, times, CaseTarget::Lowercase, cx)            }            Some(Operator::Uppercase) => {                self.change_case_motion(motion, times, CaseTarget::Uppercase, cx)            }            Some(Operator::OppositeCase) => {                self.change_case_motion(motion, times, CaseTarget::OppositeCase, cx)            }            Some(Operator::ToggleComments) => self.toggle_comments_motion(motion, times, cx),            Some(operator) => {                // Can't do anything for text objects, Ignoring                error!("Unexpected normal mode motion operator: {:?}", operator)            }        }        // Exit temporary normal mode (if active).        self.exit_temporary_normal(cx);    }     pub fn normal_object(&mut self, object: Object, cx: &mut ViewContext<Self>) {        let mut waiting_operator: Option<Operator> = None;        match self.maybe_pop_operator() {            Some(Operator::Object { around }) => match self.maybe_pop_operator() {                Some(Operator::Change) => self.change_object(object, around, cx),                Some(Operator::Delete) => self.delete_object(object, around, cx),                Some(Operator::Yank) => self.yank_object(object, around, cx),                Some(Operator::Indent) => {                    self.indent_object(object, around, IndentDirection::In, cx)                }                Some(Operator::Outdent) => {                    self.indent_object(object, around, IndentDirection::Out, cx)                }                Some(Operator::AutoIndent) => {                    self.indent_object(object, around, IndentDirection::Auto, cx)                }                Some(Operator::ShellCommand) => {                    self.shell_command_object(object, around, cx);                }                Some(Operator::Rewrap) => self.rewrap_object(object, around, cx),                Some(Operator::Lowercase) => {                    self.change_case_object(object, around, CaseTarget::Lowercase, cx)                }                Some(Operator::Uppercase) => {                    self.change_case_object(object, around, CaseTarget::Uppercase, cx)                }                Some(Operator::OppositeCase) => {                    self.change_case_object(object, around, CaseTarget::OppositeCase, cx)                }                Some(Operator::AddSurrounds { target: None }) => {                    waiting_operator = Some(Operator::AddSurrounds {                        target: Some(SurroundsType::Object(object, around)),                    });                }                Some(Operator::ToggleComments) => self.toggle_comments_object(object, around, cx),                _ => {                    // Can't do anything for namespace operators. Ignoring                }            },            Some(Operator::DeleteSurrounds) => {                waiting_operator = Some(Operator::DeleteSurrounds);            }            Some(Operator::ChangeSurrounds { target: None }) => {                if self.check_and_move_to_valid_bracket_pair(object, cx) {                    waiting_operator = Some(Operator::ChangeSurrounds {                        target: Some(object),                    });                }            }            _ => {                // Can't do anything with change/delete/yank/surrounds and text objects. Ignoring            }        }        self.clear_operator(cx);        if let Some(operator) = waiting_operator {            self.push_operator(operator, cx);        }    }     pub(crate) fn move_cursor(        &mut self,        motion: Motion,        times: Option<usize>,        cx: &mut ViewContext<Self>,    ) {        self.update_editor(cx, |_, editor, cx| {            let text_layout_details = editor.text_layout_details(cx);            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                s.move_cursors_with(|map, cursor, goal| {                    motion                        .move_point(map, cursor, goal, times, &text_layout_details)                        .unwrap_or((cursor, goal))                })            })        });    }     fn insert_after(&mut self, _: &InsertAfter, cx: &mut ViewContext<Self>) {        self.start_recording(cx);        self.switch_mode(Mode::Insert, false, cx);        self.update_editor(cx, |_, editor, cx| {            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                s.move_cursors_with(|map, cursor, _| (right(map, cursor, 1), SelectionGoal::None));            });        });    }     fn insert_before(&mut self, _: &InsertBefore, cx: &mut ViewContext<Self>) {        self.start_recording(cx);        self.switch_mode(Mode::Insert, false, cx);    }     fn insert_first_non_whitespace(        &mut self,        _: &InsertFirstNonWhitespace,        cx: &mut ViewContext<Self>,    ) {        self.start_recording(cx);        self.switch_mode(Mode::Insert, false, cx);        self.update_editor(cx, |_, editor, cx| {            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                s.move_cursors_with(|map, cursor, _| {                    (                        first_non_whitespace(map, false, cursor),                        SelectionGoal::None,                    )                });            });        });    }     fn insert_end_of_line(&mut self, _: &InsertEndOfLine, cx: &mut ViewContext<Self>) {        self.start_recording(cx);        self.switch_mode(Mode::Insert, false, cx);        self.update_editor(cx, |_, editor, cx| {            editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                s.move_cursors_with(|map, cursor, _| {                    (next_line_end(map, cursor, 1), SelectionGoal::None)                });            });        });    }     fn insert_at_previous(&mut self, _: &InsertAtPrevious, cx: &mut ViewContext<Self>) {        self.start_recording(cx);        self.switch_mode(Mode::Insert, false, cx);        self.update_editor(cx, |vim, editor, cx| {            if let Some(marks) = vim.marks.get("^") {                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                    s.select_anchor_ranges(marks.iter().map(|mark| *mark..*mark))                });            }        });    }     fn insert_line_above(&mut self, _: &InsertLineAbove, cx: &mut ViewContext<Self>) {        self.start_recording(cx);        self.switch_mode(Mode::Insert, false, cx);        self.update_editor(cx, |_, editor, cx| {            editor.transact(cx, |editor, cx| {                let selections = editor.selections.all::<Point>(cx);                let snapshot = editor.buffer().read(cx).snapshot(cx);                 let selection_start_rows: BTreeSet<u32> = selections                    .into_iter()                    .map(|selection| selection.start.row)                    .collect();                let edits = selection_start_rows                    .into_iter()                    .map(|row| {                        let indent = snapshot                            .indent_and_comment_for_line(MultiBufferRow(row), cx)                            .chars()                            .collect::<String>();                         let start_of_line = Point::new(row, 0);                        (start_of_line..start_of_line, indent + "\n")                    })                    .collect::<Vec<_>>();                editor.edit_with_autoindent(edits, cx);                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                    s.move_cursors_with(|map, cursor, _| {                        let previous_line = motion::start_of_relative_buffer_row(map, cursor, -1);                        let insert_point = motion::end_of_line(map, false, previous_line, 1);                        (insert_point, SelectionGoal::None)                    });                });            });        });    }     fn insert_line_below(&mut self, _: &InsertLineBelow, cx: &mut ViewContext<Self>) {        self.start_recording(cx);        self.switch_mode(Mode::Insert, false, cx);        self.update_editor(cx, |_, editor, cx| {            let text_layout_details = editor.text_layout_details(cx);            editor.transact(cx, |editor, cx| {                let selections = editor.selections.all::<Point>(cx);                let snapshot = editor.buffer().read(cx).snapshot(cx);                 let selection_end_rows: BTreeSet<u32> = selections                    .into_iter()                    .map(|selection| selection.end.row)                    .collect();                let edits = selection_end_rows                    .into_iter()                    .map(|row| {                        let indent = snapshot                            .indent_and_comment_for_line(MultiBufferRow(row), cx)                            .chars()                            .collect::<String>();                         let end_of_line = Point::new(row, snapshot.line_len(MultiBufferRow(row)));                        (end_of_line..end_of_line, "\n".to_string() + &indent)                    })                    .collect::<Vec<_>>();                editor.change_selections(Some(Autoscroll::fit()), cx, |s| {                    s.maybe_move_cursors_with(|map, cursor, goal| {                        Motion::CurrentLine.move_point(                            map,                            cursor,                            goal,                            None,                            &text_layout_details,                        )                    });                });                editor.edit_with_autoindent(edits, cx);            });        });    }     fn join_lines_impl(&mut self, insert_whitespace: bool, cx: &mut ViewContext<Self>) {        self.record_current_action(cx);        let mut times = Vim::take_count(cx).unwrap_or(1);        if self.mode.is_visual() {            times = 1;        } else if times > 1 {            // 2J joins two lines together (same as J or 1J)            times -= 1;        }         self.update_editor(cx, |_, editor, cx| {            editor.transact(cx, |editor, cx| {                for _ in 0..times {                    editor.join_lines_impl(insert_whitespace, cx)                }            })        });        if self.mode.is_visual() {            self.switch_mode(Mode::Normal, true, cx)        }    }     fn yank_line(&mut self, _: &YankLine, cx: &mut ViewContext<Self>) {        let count = Vim::take_count(cx);        self.yank_motion(motion::Motion::CurrentLine, count, cx)    }     fn show_location(&mut self, _: &ShowLocation, cx: &mut ViewContext<Self>) {        let count = Vim::take_count(cx);        self.update_editor(cx, |vim, editor, cx| {            let selection = editor.selections.newest_anchor();            if let Some((_, buffer, _)) = editor.active_excerpt(cx) {                let filename = if let Some(file) = buffer.read(cx).file() {                    if count.is_some() {                        if let Some(local) = file.as_local() {                            local.abs_path(cx).to_string_lossy().to_string()                        } else {                            file.full_path(cx).to_string_lossy().to_string()                        }                    } else {                        file.path().to_string_lossy().to_string()                    }                } else {                    "[No Name]".into()                };                let buffer = buffer.read(cx);                let snapshot = buffer.snapshot();                let lines = buffer.max_point().row + 1;                let current_line = selection.head().text_anchor.to_point(&snapshot).row;                let percentage = current_line as f32 / lines as f32;                let modified = if buffer.is_dirty() { " [modified]" } else { "" };                vim.status_label = Some(                    format!(                        "{}{} {} lines --{:.0}%--",                        filename,                        modified,                        lines,                        percentage * 100.0,                    )                    .into(),                );                cx.notify();            }        });    }     fn toggle_comments(&mut self, _: &ToggleComments, cx: &mut ViewContext<Self>) {        self.record_current_action(cx);        self.store_visual_marks(cx);        self.update_editor(cx, |vim, editor, cx| {            editor.transact(cx, |editor, cx| {                let original_positions = vim.save_selection_starts(editor, cx);                editor.toggle_comments(&Default::default(), cx);                vim.restore_selection_cursors(editor, cx, original_positions);            });        });        if self.mode.is_visual() {            self.switch_mode(Mode::Normal, true, cx)        }    }     pub(crate) fn normal_replace(&mut self, text: Arc<str>, cx: &mut ViewContext<Self>) {        let count = Vim::take_count(cx).unwrap_or(1);        self.stop_recording(cx);        self.update_editor(cx, |_, editor, cx| {            editor.transact(cx, |editor, cx| {                editor.set_clip_at_line_ends(false, cx);                let (map, display_selections) = editor.selections.all_display(cx);                 let mut edits = Vec::new();                for selection in display_selections {                    let mut range = selection.range();                    for _ in 0..count {                        let new_point = movement::saturating_right(&map, range.end);                        if range.end == new_point {                            return;                        }                        range.end = new_point;                    }                     edits.push((                        range.start.to_offset(&map, Bias::Left)                            ..range.end.to_offset(&map, Bias::Left),                        text.repeat(count),

Lines 1–500 of 1503. Load more