-pub(crate) mod syntax;

-use futures_util::FutureExt;

-use helix_event::status;

-use helix_stdx::{

- path::{self, find_paths},

- rope::{self, RopeSliceExt},

-};

-use helix_vcs::{FileChange, Hunk};

-pub use syntax::*;

-use tui::{

- text::{Span, Spans},

- widgets::Cell,

-};

- char_idx_at_visual_offset,

- chars::char_is_word,

- command_line::{self, Args},

- comment,

- encoding, find_workspace,

- graphemes::{self, next_grapheme_boundary},

- increment,

- indent::{self, IndentStyle},

- line_ending::{get_line_ending_of_str, line_end_char_index},

- regex::{self, Regex},

- selection, surround,

- syntax::config::{BlockCommentToken, LanguageServerFeature},

- text_annotations::{Overlay, TextAnnotations},

- visual_offset_from_block, Deletion, LineEnding, Position, Range, Rope, RopeReader, RopeSlice,

- Selection, SmallVec, Syntax, Tendril, Transaction,

- editor::Action,

- expansion,

- theme::Style,

- compositor::{self, Component, Compositor},

- ui::{self, overlay::overlaid, Picker, PickerColumn, Popup, Prompt, PromptEvent},

-use std::{

- char::{ToLowercase, ToUppercase},

- cmp::Ordering,

- collections::{HashMap, HashSet},

- error::Error,

- fmt,

- future::Future,

- io::Read,

- num::NonZeroUsize,

-};

-use url::Url;

-#[derive(PartialEq, Eq, Clone, Copy, Debug)]

-pub enum OnKeyCallbackKind {

- PseudoPending,

- Fallback,

-}

- pub callback: Vec<crate::compositor::Callback>,

- pub on_next_key_callback: Option<(OnKeyCallback, OnKeyCallbackKind)>,

-impl Context<'_> {

- self.callback

- .push(Box::new(|compositor: &mut Compositor, _| {

- compositor.push(component)

- }));

- self.callback

- .push(Box::new(move |compositor: &mut Compositor, _| {

- compositor.replace_or_push(id, component);

- }));

- self.on_next_key_callback = Some((

- Box::new(on_next_key_callback),

- OnKeyCallbackKind::PseudoPending,

- ));

- }

-

- #[inline]

- pub fn on_next_key_fallback(

- &mut self,

- on_next_key_callback: impl FnOnce(&mut Context, KeyEvent) + 'static,

- ) {

- self.on_next_key_callback =

- Some((Box::new(on_next_key_callback), OnKeyCallbackKind::Fallback));

- call: impl Future<Output = helix_lsp::Result<T>> + 'static + Send,

- T: Send + 'static,

-

- /// Waits on all pending jobs, and then tries to flush all pending write

- /// operations for all documents.

- pub fn block_try_flush_writes(&mut self) -> anyhow::Result<()> {

- compositor::Context {

- editor: self.editor,

- jobs: self.jobs,

- scroll: None,

- }

- .block_try_flush_writes()

- }

- call: impl Future<Output = helix_lsp::Result<T>> + 'static + Send,

- T: Send + 'static,

- let response = call.await?;

-/// MappableCommands are commands that can be bound to keys, executable in

-/// normal, insert or select mode.

-///

-/// There are three kinds:

-///

-/// * Static: commands usually bound to keys and used for editing, movement,

-/// etc., for example `move_char_left`.

-/// * Typable: commands executable from command mode, prefixed with a `:`,

-/// for example `:write!`.

-/// * Macro: a sequence of keys to execute, for example `@miw`.

- args: String,

- Macro {

- name: String,

- keys: Vec<KeyEvent>,

- if let Err(e) =

- typed::execute_command(&mut cx, command, args, PromptEvent::Validate)

- {

- } else {

- cx.editor.set_error(format!("no such command: '{name}'"));

- Self::Macro { keys, .. } => {

- // Protect against recursive macros.

- if cx.editor.macro_replaying.contains(&'@') {

- cx.editor.set_error(

- "Cannot execute macro because the [@] register is already playing a macro",

- );

- return;

- }

- cx.editor.macro_replaying.push('@');

- let keys = keys.clone();

- cx.callback.push(Box::new(move |compositor, cx| {

- for key in keys.into_iter() {

- compositor.handle_event(&compositor::Event::Key(key), cx);

- }

- cx.editor.macro_replaying.pop();

- }));

- }

- Self::Macro { name, .. } => name,

- Self::Macro { name, .. } => name,

- move_next_sub_word_start, "Move to start of next sub word",

- move_prev_sub_word_start, "Move to start of previous sub word",

- move_next_sub_word_end, "Move to end of next sub word",

- move_prev_sub_word_end, "Move to end of previous sub word",

- move_parent_node_end, "Move to end of the parent node",

- move_parent_node_start, "Move to beginning of the parent node",

- extend_next_sub_word_start, "Extend to start of next sub word",

- extend_prev_sub_word_start, "Extend to start of previous sub word",

- extend_next_sub_word_end, "Extend to end of next sub word",

- extend_prev_sub_word_end, "Extend to end of prev sub word",

- extend_parent_node_end, "Extend to end of the parent node",

- extend_parent_node_start, "Extend to beginning of the parent node",

- page_cursor_up, "Move page and cursor up",

- page_cursor_down, "Move page and cursor down",

- page_cursor_half_up, "Move page and cursor half up",

- page_cursor_half_down, "Move page and cursor half down",

- search_selection_detect_word_boundaries, "Use current selection as the search pattern, automatically wrapping with `\\b` on word boundaries",

- select_line_above, "Select current line, if already selected, extend or shrink line above based on the anchor",

- select_line_below, "Select current line, if already selected, extend or shrink line below based on the anchor",

- file_picker_in_current_buffer_directory, "Open file picker at current buffer's directory",

- file_explorer, "Open file explorer in workspace root",

- file_explorer_in_current_buffer_directory, "Open file explorer at current buffer's directory",

- file_explorer_in_current_directory, "Open file explorer at current working directory",

- syntax_symbol_picker, "Open symbol picker from syntax information",

- lsp_or_syntax_symbol_picker, "Open symbol picker from LSP or syntax information",

- changed_file_picker, "Open changed file picker",

- syntax_workspace_symbol_picker, "Open workspace symbol picker from syntax information",

- lsp_or_syntax_workspace_symbol_picker, "Open workspace symbol picker from LSP or syntax information",

- extend_to_file_start, "Extend to line number<n> else file start",

- extend_to_file_end, "Extend to file end",

- goto_file, "Goto files/URLs in selections",

- goto_file_hsplit, "Goto files in selections (hsplit)",

- goto_file_vsplit, "Goto files in selections (vsplit)",

- extend_to_last_line, "Extend to last line",

- goto_column, "Goto column",

- extend_to_column, "Extend to column",

- smart_tab, "Insert tab if all cursors have all whitespace to their left; otherwise, run a separate command.",

- insert_char_interactive, "Insert an interactively-chosen char",

- append_char_interactive, "Append an interactively-chosen char",

- yank_to_clipboard, "Yank selections to clipboard",

- yank_to_primary_clipboard, "Yank selections to primary clipboard",

- toggle_line_comments, "Line comment/uncomment selections",

- toggle_block_comments, "Block comment/uncomment selections",

- select_next_sibling, "Select next sibling in the syntax tree",

- select_prev_sibling, "Select previous sibling the in syntax tree",

- select_all_siblings, "Select all siblings of the current node",

- select_all_children, "Select all children of the current node",

- copy_between_registers, "Copy between two registers",

- goto_next_xml_element, "Goto next (X)HTML element",

- goto_prev_xml_element, "Goto previous (X)HTML element",

- goto_next_entry, "Goto next pairing",

- goto_prev_entry, "Goto previous pairing",

- goto_word, "Jump to a two-character label",

- extend_to_word, "Extend to a two-character label",

- goto_next_tabstop, "Goto next snippet placeholder",

- goto_prev_tabstop, "Goto next snippet placeholder",

- rotate_selections_first, "Make the first selection your primary one",

- rotate_selections_last, "Make the last selection your primary one",

- MappableCommand::Macro { name, keys, .. } => f

- .debug_tuple("MappableCommand")

- .field(name)

- .field(keys)

- .finish(),

- let (name, args, _) = command_line::split(suffix);

- ensure!(!name.is_empty(), "Expected typable command name");

- .map(|cmd| {

- let doc = if args.is_empty() {

- cmd.doc.to_string()

- } else {

- format!(":{} {:?}", cmd.name, args)

- };

- MappableCommand::Typable {

- name: cmd.name.to_owned(),

- doc,

- args: args.to_string(),

- }

- } else if let Some(suffix) = s.strip_prefix('@') {

- helix_view::input::parse_macro(suffix).map(|keys| Self::Macro {

- name: s.to_string(),

- keys,

- })

- drop(annotations);

- goto_buffer(cx.editor, Direction::Forward, cx.count());

- goto_buffer(cx.editor, Direction::Backward, cx.count());

-fn goto_buffer(editor: &mut Editor, direction: Direction, count: usize) {

- // skip 'count' times past current buffer

- iter.cycle().skip_while(|id| *id != &current).nth(count)

- // skip 'count' times past current buffer

- iter.rev()

- .cycle()

- .skip_while(|id| *id != &current)

- .nth(count)

- } else if let Some(pos) = text.line(line).first_non_whitespace_char() {

- if let Some(pos) = text.line(line).first_non_whitespace_char() {

- exit_select_mode(cx);

- let view_offset = doc.view_offset(view.id);

- Align::Top => view_offset.vertical_offset + scrolloff + count,

- Align::Center => view_offset.vertical_offset + (last_visual_line / 2),

- view_offset.vertical_offset + last_visual_line.saturating_sub(scrolloff + count)

- .max(view_offset.vertical_offset + scrolloff)

- .min(view_offset.vertical_offset + last_visual_line.saturating_sub(scrolloff));

-fn move_next_sub_word_start(cx: &mut Context) {

- move_word_impl(cx, movement::move_next_sub_word_start)

-}

-

-fn move_prev_sub_word_start(cx: &mut Context) {

- move_word_impl(cx, movement::move_prev_sub_word_start)

-}

-

-fn move_prev_sub_word_end(cx: &mut Context) {

- move_word_impl(cx, movement::move_prev_sub_word_end)

-}

-

-fn move_next_sub_word_end(cx: &mut Context) {

- move_word_impl(cx, movement::move_next_sub_word_end)

-}

-

- cx.editor.apply_motion(motion)

- goto_file_start_impl(cx, Movement::Move);

-}

-

-fn extend_to_file_start(cx: &mut Context) {

- goto_file_start_impl(cx, Movement::Extend);

-}

-

-fn goto_file_start_impl(cx: &mut Context, movement: Movement) {

- goto_line_impl(cx, movement);

- .transform(|range| range.put_cursor(text, 0, movement == Movement::Extend));

- goto_file_end_impl(cx, Movement::Move);

-}

-

-fn extend_to_file_end(cx: &mut Context) {

- goto_file_end_impl(cx, Movement::Extend)

-}

-

-fn goto_file_end_impl(cx: &mut Context, movement: Movement) {

- .transform(|range| range.put_cursor(text, pos, movement == Movement::Extend));

- let text = doc.text().slice(..);

- let rel_path = doc

- .relative_path()

- .map(|path| path.parent().unwrap().to_path_buf())

- .unwrap_or_default();

-

- let paths: Vec<_> = if selections.len() == 1 && primary.len() == 1 {

- // Cap the search at roughly 1k bytes around the cursor.

- let lookaround = 1000;

- let pos = text.char_to_byte(primary.cursor(text));

- let search_start = text

- .line_to_byte(text.byte_to_line(pos))

- .max(text.floor_char_boundary(pos.saturating_sub(lookaround)));

- let search_end = text

- .line_to_byte(text.byte_to_line(pos) + 1)

- .min(text.ceil_char_boundary(pos + lookaround));

- let search_range = text.byte_slice(search_start..search_end);

- // we also allow paths that are next to the cursor (can be ambiguous but

- // rarely so in practice) so that gf on quoted/braced path works (not sure about this

- // but apparently that is how gf has worked historically in helix)

- let path = find_paths(search_range, true)

- .take_while(|range| search_start + range.start <= pos + 1)

- .find(|range| pos <= search_start + range.end)

- .map(|range| Cow::from(search_range.byte_slice(range)));

- log::debug!("goto_file auto-detected path: {path:?}");

- let path = path.unwrap_or_else(|| primary.fragment(text));

- vec![path.into_owned()]

- } else {

- // Otherwise use each selection, trimmed.

- selections

- .fragments(text)

- .map(|sel| sel.trim().to_owned())

- .filter(|sel| !sel.is_empty())

- .collect()

- };

-

- for sel in paths {

- if let Ok(url) = Url::parse(&sel) {

- open_url(cx, url, action);

- continue;

- }

-

- let path = path::expand(&sel);

- let path = &rel_path.join(path);

- if path.is_dir() {

- let picker = ui::file_picker(cx.editor, path.into());

- cx.push_layer(Box::new(overlaid(picker)));

- } else if let Err(e) = cx.editor.open(path, action) {

- cx.editor.set_error(format!("Open file failed: {:?}", e));

- }

- }

-}

-

-/// Opens the given url. If the URL points to a valid textual file it is open in helix.

-// Otherwise, the file is open using external program.

-fn open_url(cx: &mut Context, url: Url, action: Action) {

- let doc = doc!(cx.editor);

- let rel_path = doc

- .relative_path()

- .map(|path| path.parent().unwrap().to_path_buf())

- .unwrap_or_default();

-

- if url.scheme() != "file" {

- return cx.jobs.callback(crate::open_external_url_callback(url));

-

- let content_type = std::fs::File::open(url.path()).and_then(|file| {

- // Read up to 1kb to detect the content type

- let mut read_buffer = Vec::new();

- let n = file.take(1024).read_to_end(&mut read_buffer)?;

- Ok(content_inspector::inspect(&read_buffer[..n]))

- });

-

- // we attempt to open binary files - files that can't be open in helix - using external

- // program as well, e.g. pdf files or images

- match content_type {

- Ok(content_inspector::ContentType::BINARY) => {

- cx.jobs.callback(crate::open_external_url_callback(url))

- }

- Ok(_) | Err(_) => {

- let path = &rel_path.join(url.path());

- if path.is_dir() {

- let picker = ui::file_picker(cx.editor, path.into());

- cx.push_layer(Box::new(overlaid(picker)));

- } else if let Err(e) = cx.editor.open(path, action) {

-fn extend_next_sub_word_start(cx: &mut Context) {

- extend_word_impl(cx, movement::move_next_sub_word_start)

-}

-

-fn extend_prev_sub_word_start(cx: &mut Context) {

- extend_word_impl(cx, movement::move_prev_sub_word_start)

-}

-

-fn extend_prev_sub_word_end(cx: &mut Context) {

- extend_word_impl(cx, movement::move_prev_sub_word_end)

-}

-

-fn extend_next_sub_word_end(cx: &mut Context) {

- extend_word_impl(cx, movement::move_next_sub_word_end)

-}

-

-/// Separate branch to find_char designed only for `<ret>` char.

-//

-// This is necessary because the one document can have different line endings inside. And we

-// cannot predict what character to find when <ret> is pressed. On the current line it can be `lf`

-// but on the next line it can be `crlf`. That's why [`find_char_impl`] cannot be applied here.

-fn find_char_line_ending(

- cx: &mut Context,

- count: usize,

- direction: Direction,

- inclusive: bool,

- extend: bool,

-) {

- let (view, doc) = current!(cx.editor);

- let text = doc.text().slice(..);

-

- let selection = doc.selection(view.id).clone().transform(|range| {

- let cursor = range.cursor(text);

- let cursor_line = range.cursor_line(text);

-

- // Finding the line where we're going to find <ret>. Depends mostly on

- // `count`, but also takes into account edge cases where we're already at the end

- // of a line or the beginning of a line

- let find_on_line = match direction {

- Direction::Forward => {

- let on_edge = line_end_char_index(&text, cursor_line) == cursor;

- let line = cursor_line + count - 1 + (on_edge as usize);

- if line >= text.len_lines() - 1 {

- return range;

- } else {

- line

- }

- }

- Direction::Backward => {

- let on_edge = text.line_to_char(cursor_line) == cursor && !inclusive;

- let line = cursor_line as isize - (count as isize - 1 + on_edge as isize);

- if line <= 0 {

- return range;

- } else {

- line as usize

- }

- }

- };

-

- let pos = match (direction, inclusive) {

- (Direction::Forward, true) => line_end_char_index(&text, find_on_line),

- (Direction::Forward, false) => line_end_char_index(&text, find_on_line) - 1,

- (Direction::Backward, true) => line_end_char_index(&text, find_on_line - 1),

- (Direction::Backward, false) => text.line_to_char(find_on_line),

- };

-

- if extend {

- range.put_cursor(text, pos, true)

- } else {

- Range::point(range.cursor(text)).put_cursor(text, pos, true)

- }

- });

- doc.set_selection(view.id, selection);

-}

-

-fn find_char(cx: &mut Context, direction: Direction, inclusive: bool, extend: bool) {

- } => {

- find_char_line_ending(cx, count, direction, inclusive, extend);

- return;

- let motion = move |editor: &mut Editor| {

- match direction {

- Direction::Forward => {

- find_char_impl(editor, &find_next_char_impl, inclusive, extend, ch, count)

- }

- Direction::Backward => {

- find_char_impl(editor, &find_prev_char_impl, inclusive, extend, ch, count)

- }

- };

- };

- cx.editor.apply_motion(motion);

- find_char(cx, Direction::Forward, false, false);

- find_char(cx, Direction::Forward, true, false)

- find_char(cx, Direction::Forward, false, true)

- find_char(cx, Direction::Forward, true, true)

- find_char(cx, Direction::Backward, false, false)

- find_char(cx, Direction::Backward, true, false)

- find_char(cx, Direction::Backward, false, true)

- find_char(cx, Direction::Backward, true, true)

- cx.editor.repeat_last_motion(cx.count())

- let text: Tendril = doc

- .text()

- .slice(range.from()..range.to())

- .graphemes()

- .map(|_g| ch)

- .collect();

- (range.from(), range.to(), Some(text))

- exit_select_mode(cx);

-}

-

-enum CaseSwitcher {

- Upper(ToUppercase),

- Lower(ToLowercase),

- Keep(Option<char>),

-impl Iterator for CaseSwitcher {

- type Item = char;

-

- fn next(&mut self) -> Option<Self::Item> {

- match self {

- CaseSwitcher::Upper(upper) => upper.next(),

- CaseSwitcher::Lower(lower) => lower.next(),

- CaseSwitcher::Keep(ch) => ch.take(),

- }

- }

-

- fn size_hint(&self) -> (usize, Option<usize>) {

- match self {

- CaseSwitcher::Upper(upper) => upper.size_hint(),

- CaseSwitcher::Lower(lower) => lower.size_hint(),

- CaseSwitcher::Keep(ch) => {

- let n = if ch.is_some() { 1 } else { 0 };

- (n, Some(n))

- }

- }

- }

-}

-

-impl ExactSizeIterator for CaseSwitcher {}

-

- CaseSwitcher::Upper(ch.to_uppercase())

- CaseSwitcher::Lower(ch.to_lowercase())

- CaseSwitcher::Keep(Some(ch))

-pub fn scroll(cx: &mut Context, offset: usize, direction: Direction, sync_cursor: bool) {

- let mut view_offset = doc.view_offset(view.id);

- (view_offset.anchor, view_offset.vertical_offset) = char_idx_at_visual_offset(

- view_offset.anchor,

- view_offset.vertical_offset as isize + offset,

- // &annotations,

- &view.text_annotations(&*doc, None),

- doc.set_view_offset(view.id, view_offset);

-

- let doc_text = doc.text().slice(..);

- let mut annotations = view.text_annotations(&*doc, None);

-

- if sync_cursor {

- let movement = match cx.editor.mode {

- Mode::Select => Movement::Extend,

- _ => Movement::Move,

- };

- // TODO: When inline diagnostics gets merged- 1. move_vertically_visual removes

- // line annotations/diagnostics so the cursor may jump further than the view.

- // 2. If the cursor lands on a complete line of virtual text, the cursor will

- // jump a different distance than the view.

- let selection = doc.selection(view.id).clone().transform(|range| {

- move_vertically_visual(

- doc_text,

- range,

- direction,

- offset.unsigned_abs(),

- movement,

- &text_fmt,

- &mut annotations,

- )

- });

- drop(annotations);

- doc.set_selection(view.id, selection);

- return;

- }

-

- let view_offset = doc.view_offset(view.id);

- view_offset.anchor,

- (view_offset.vertical_offset + scrolloff) as isize,

- view_offset.anchor,

- (view_offset.vertical_offset + height - scrolloff - 1) as isize,

- drop(annotations);

- scroll(cx, offset, Direction::Backward, false);

- scroll(cx, offset, Direction::Forward, false);

- scroll(cx, offset, Direction::Backward, false);

- scroll(cx, offset, Direction::Forward, false);

-}

-

-fn page_cursor_up(cx: &mut Context) {

- let view = view!(cx.editor);

- let offset = view.inner_height();

- scroll(cx, offset, Direction::Backward, true);

-}

-

-fn page_cursor_down(cx: &mut Context) {

- let view = view!(cx.editor);

- let offset = view.inner_height();

- scroll(cx, offset, Direction::Forward, true);

-}

-

-fn page_cursor_half_up(cx: &mut Context) {

- let view = view!(cx.editor);

- let offset = view.inner_height() / 2;

- scroll(cx, offset, Direction::Backward, true);

-}

-

-fn page_cursor_half_down(cx: &mut Context) {

- let view = view!(cx.editor);

- let offset = view.inner_height() / 2;

- scroll(cx, offset, Direction::Forward, true);

- move |cx, regex, event| {

- let (view, doc) = current!(cx.editor);

- } else {

- cx.editor.set_error("nothing selected");

- move |cx, regex, event| {

- let (view, doc) = current!(cx.editor);

- let selection = selection::split_on_newline(text, doc.selection(view.id));

- regex: &rope::Regex,

- let doc = doc!(editor).text().slice(..);

- Direction::Forward => regex.find(doc.regex_input_at_bytes(start..)),

- Direction::Backward => regex.find_iter(doc.regex_input_at_bytes(..start)).last(),

- Direction::Forward => regex.find(doc.regex_input()),

- Direction::Backward => regex.find_iter(doc.regex_input_at_bytes(start..)).last(),

- let start = text.byte_to_char(mat.start());

- let end = text.byte_to_char(mat.end());

- .and_then(|reg| cx.editor.registers.read(reg, cx.editor))

- .map_or(Vec::new(), |reg| reg.take(200).collect());

- items.into_iter().map(|value| value.to_string()).collect()

- let movement = if cx.editor.mode() == Mode::Select {

- Movement::Extend

- } else {

- Movement::Move

- };

- .map(|comp| (0.., comp.clone().into()))

- move |cx, regex, event| {

- if event == PromptEvent::Validate {

- cx.editor.registers.last_search_register = reg;

- } else if event != PromptEvent::Update {

- cx.editor,

- movement,

- let register = cx

- .register

- .unwrap_or(cx.editor.registers.last_search_register);

- if let Some(query) = cx.editor.registers.first(register, cx.editor) {

- if let Ok(regex) = rope::RegexBuilder::new()

- .syntax(

- rope::Config::new()

- .case_insensitive(case_insensitive)

- .multi_line(true),

- )

- .build(&query)

- search_selection_impl(cx, false)

-}

-

-fn search_selection_detect_word_boundaries(cx: &mut Context) {

- search_selection_impl(cx, true)

-}

-

-fn search_selection_impl(cx: &mut Context, detect_word_boundaries: bool) {

- fn is_at_word_start(text: RopeSlice, index: usize) -> bool {

- // This can happen when the cursor is at the last character in

- // the document +1 (ge + j), in this case text.char(index) will panic as

- // it will index out of bounds. See https://github.com/helix-editor/helix/issues/12609

- if index == text.len_chars() {

- return false;

- }

- let ch = text.char(index);

- if index == 0 {

- return char_is_word(ch);

- }

- let prev_ch = text.char(index - 1);

-

- !char_is_word(prev_ch) && char_is_word(ch)

- }

-

- fn is_at_word_end(text: RopeSlice, index: usize) -> bool {

- if index == 0 || index == text.len_chars() {

- return false;

- }

- let ch = text.char(index);

- let prev_ch = text.char(index - 1);

-

- char_is_word(prev_ch) && !char_is_word(ch)

- }

-

- let register = cx.register.unwrap_or('/');

- let text = doc.text().slice(..);

- .map(|selection| {

- let add_boundary_prefix =

- detect_word_boundaries && is_at_word_start(text, selection.from());

- let add_boundary_suffix =

- detect_word_boundaries && is_at_word_end(text, selection.to());

-

- let prefix = if add_boundary_prefix { "\\b" } else { "" };

- let suffix = if add_boundary_suffix { "\\b" } else { "" };

-

- let word = regex::escape(&selection.fragment(text));

- format!("{}{}{}", prefix, word, suffix)

- })

- let msg = format!("register '{}' set to '{}'", register, &regex);

- match cx.editor.registers.push(register, regex) {

- Ok(_) => {

- cx.editor.registers.last_search_register = register;

- cx.editor.set_status(msg)

- }

- Err(err) => cx.editor.set_error(err.to_string()),

- }

- // Defaults to the active search register instead `/` to be more ergonomic assuming most people

- // would use this command following `search_selection`. This avoids selecting the register

- // twice.

- let register = cx

- .register

- .unwrap_or(cx.editor.registers.last_search_register);

- let regex = match cx.editor.registers.first(register, cx.editor) {

- new_regex.push_str(&regex);

- let msg = format!("register '{}' set to '{}'", register, &new_regex);

- match cx.editor.registers.push(register, new_regex) {

- Ok(_) => {

- cx.editor.registers.last_search_register = register;

- cx.editor.set_status(msg)

- }

- Err(err) => cx.editor.set_error(err.to_string()),

- }

- struct GlobalSearchConfig {

- smart_case: bool,

- file_picker_config: helix_view::editor::FilePickerConfig,

- directory_style: Style,

- number_style: Style,

- colon_style: Style,

- let config = GlobalSearchConfig {

- smart_case: config.search.smart_case,

- file_picker_config: config.file_picker.clone(),

- directory_style: cx.editor.theme.get("ui.text.directory"),

- number_style: cx.editor.theme.get("constant.numeric.integer"),

- colon_style: cx.editor.theme.get("punctuation"),

- };

-

- let columns = [

- PickerColumn::new("path", |item: &FileResult, config: &GlobalSearchConfig| {

- let path = helix_stdx::path::get_relative_path(&item.path);

-

- let directories = path

- .parent()

- .filter(|p| !p.as_os_str().is_empty())

- .map(|p| format!("{}{}", p.display(), std::path::MAIN_SEPARATOR))

- .unwrap_or_default();

- let filename = item

- .path

- .file_name()

- .expect("global search paths are normalized (can't end in `..`)")

- .to_string_lossy();

-

- Cell::from(Spans::from(vec![

- Span::styled(directories, config.directory_style),

- Span::raw(filename),

- Span::styled(":", config.colon_style),

- Span::styled((item.line_num + 1).to_string(), config.number_style),

- ]))

- }),

- PickerColumn::hidden("contents"),

- ];

-

- let get_files = |query: &str,

- editor: &mut Editor,

- config: std::sync::Arc<GlobalSearchConfig>,

- injector: &ui::picker::Injector<_, _>| {

- if query.is_empty() {

- return async { Ok(()) }.boxed();

- }

-

- let search_root = helix_stdx::env::current_working_dir();

- if !search_root.exists() {

- return async { Err(anyhow::anyhow!("Current working directory does not exist")) }

- .boxed();

- }

-

- let documents: Vec<_> = editor

- .documents()

- .map(|doc| (doc.path().cloned(), doc.text().to_owned()))

- .collect();

- let matcher = match RegexMatcherBuilder::new()

- .case_smart(config.smart_case)

- .build(query)

- {

- Ok(matcher) => {

- // Clear any "Failed to compile regex" errors out of the statusline.

- editor.clear_status();

- matcher

- }

- Err(err) => {

- log::info!("Failed to compile search pattern in global search: {}", err);

- return async { Err(anyhow::anyhow!("Failed to compile regex")) }.boxed();

- };

- let dedup_symlinks = config.file_picker_config.deduplicate_links;

- let absolute_root = search_root

- .canonicalize()

- .unwrap_or_else(|_| search_root.clone());

-

- let injector = injector.clone();

- async move {

- let searcher = SearcherBuilder::new()

- .binary_detection(BinaryDetection::quit(b'\x00'))

- .build();

- WalkBuilder::new(search_root)

- .hidden(config.file_picker_config.hidden)

- .parents(config.file_picker_config.parents)

- .ignore(config.file_picker_config.ignore)

- .follow_links(config.file_picker_config.follow_symlinks)

- .git_ignore(config.file_picker_config.git_ignore)

- .git_global(config.file_picker_config.git_global)

- .git_exclude(config.file_picker_config.git_exclude)

- .max_depth(config.file_picker_config.max_depth)

- .filter_entry(move |entry| {

- filter_picker_entry(entry, &absolute_root, dedup_symlinks)

- })

- .add_custom_ignore_filename(helix_loader::config_dir().join("ignore"))

- .add_custom_ignore_filename(".helix/ignore")

- .build_parallel()

- .run(|| {

- let mut searcher = searcher.clone();

- let matcher = matcher.clone();

- let injector = injector.clone();

- let documents = &documents;

- Box::new(move |entry: Result<DirEntry, ignore::Error>| -> WalkState {

- let entry = match entry {

- Ok(entry) => entry,

- Err(_) => return WalkState::Continue,

- };

-

- match entry.file_type() {

- Some(entry) if entry.is_file() => {}

- // skip everything else

- _ => return WalkState::Continue,

- };

-

- let mut stop = false;

- let sink = sinks::UTF8(|line_num, _line_content| {

- stop = injector

- .push(FileResult::new(entry.path(), line_num as usize - 1))

- .is_err();

-

- Ok(!stop)

- });

- let doc = documents.iter().find(|&(doc_path, _)| {

- doc_path

- .as_ref()

- .is_some_and(|doc_path| doc_path == entry.path())

- });

-

- let result = if let Some((_, doc)) = doc {

- // there is already a buffer for this file

- // search the buffer instead of the file because it's faster

- // and captures new edits without requiring a save

- if searcher.multi_line_with_matcher(&matcher) {

- // in this case a continuous buffer is required

- // convert the rope to a string

- let text = doc.to_string();

- searcher.search_slice(&matcher, text.as_bytes(), sink)

- } else {

- searcher.search_reader(

- &matcher,

- RopeReader::new(doc.slice(..)),

- sink,

- )

- } else {

- searcher.search_path(&matcher, entry.path(), sink)

- };

-

- if let Err(err) = result {

- log::error!("Global search error: {}, {}", entry.path().display(), err);

- }

- if stop {

- WalkState::Quit

- } else {

- }

- })

- });

- Ok(())

- }

- .boxed()

- };

- let reg = cx.register.unwrap_or('/');

- cx.editor.registers.last_search_register = reg;

- let picker = Picker::new(

- columns,

- 1, // contents

- [],

- config,

- move |cx, FileResult { path, line_num, .. }, action| {

- let doc = match cx.editor.open(path, action) {

- Ok(id) => doc_mut!(cx.editor, &id),

- Err(e) => {

- cx.editor

- .set_error(format!("Failed to open file '{}': {}", path.display(), e));

- };

-

- let line_num = *line_num;

- let view = view_mut!(cx.editor);

- let text = doc.text();

- if line_num >= text.len_lines() {

- cx.editor.set_error(

- "The line you jumped to does not exist anymore because the file has changed.",

- );

- return;

- }

- let start = text.line_to_char(line_num);

- let end = text.line_to_char((line_num + 1).min(text.len_lines()));

- doc.set_selection(view.id, Selection::single(start, end));

- if action.align_view(view, doc.id()) {

- align_view(doc, view, Align::Center);

- }

- },

- )

- .with_preview(|_editor, FileResult { path, line_num, .. }| {

- Some((path.as_path().into(), Some((*line_num, *line_num))))

- })

- .with_history_register(Some(reg))

- .with_dynamic_query(get_files, Some(275));

- cx.push_layer(Box::new(overlaid(picker)));

-fn select_line_below(cx: &mut Context) {

- select_line_impl(cx, Extend::Below);

-}

-fn select_line_above(cx: &mut Context) {

- select_line_impl(cx, Extend::Above);

-}

-fn select_line_impl(cx: &mut Context, extend: Extend) {

- let mut count = cx.count();

- let (view, doc) = current!(cx.editor);

- let text = doc.text();

- let saturating_add = |a: usize, b: usize| (a + b).min(text.len_lines());

- let selection = doc.selection(view.id).clone().transform(|range| {

- let (start_line, end_line) = range.line_range(text.slice(..));

- let start = text.line_to_char(start_line);

- let end = text.line_to_char(saturating_add(end_line, 1));

- let direction = range.direction();

-

- // Extending to line bounds is counted as one step

- if range.from() != start || range.to() != end {

- count = count.saturating_sub(1)

- }

- let (anchor_line, head_line) = match (&extend, direction) {

- (Extend::Above, Direction::Forward) => (start_line, end_line.saturating_sub(count)),

- (Extend::Above, Direction::Backward) => (end_line, start_line.saturating_sub(count)),

- (Extend::Below, Direction::Forward) => (start_line, saturating_add(end_line, count)),

- (Extend::Below, Direction::Backward) => (end_line, saturating_add(start_line, count)),

- };

- let (anchor, head) = match anchor_line.cmp(&head_line) {

- Ordering::Less => (

- text.line_to_char(anchor_line),

- text.line_to_char(saturating_add(head_line, 1)),

- ),

- Ordering::Equal => match extend {

- Extend::Above => (

- text.line_to_char(saturating_add(anchor_line, 1)),

- text.line_to_char(head_line),

- ),

- Extend::Below => (

- text.line_to_char(head_line),

- text.line_to_char(saturating_add(anchor_line, 1)),

- ),

- },

-

- Ordering::Greater => (

- text.line_to_char(saturating_add(anchor_line, 1)),

- text.line_to_char(head_line),

- ),

- };

- Range::new(anchor, head)

- });

-

- doc.set_selection(view.id, selection);

-}

-fn selection_is_linewise(selection: &Selection, text: &Rope) -> bool {

- selection.ranges().iter().all(|range| {

- let text = text.slice(..);

- if range.slice(text).len_lines() < 2 {

- return false;

- }

- // If the start of the selection is at the start of a line and the end at the end of a line.

- let (start_line, end_line) = range.line_range(text);

- let start = text.line_to_char(start_line);

- let end = text.line_to_char((end_line + 1).min(text.len_lines()));

- start == range.from() && end == range.to()

- })

-}

-

-enum YankAction {

- Yank,

- NoYank,

-}

-

-fn delete_selection_impl(cx: &mut Context, op: Operation, yank: YankAction) {

- let only_whole_lines = selection_is_linewise(selection, doc.text());

- if cx.register != Some('_') && matches!(yank, YankAction::Yank) {

- // yank the selection

- let reg_name = cx

- .register

- .unwrap_or_else(|| cx.editor.config.load().default_yank_register);

- if let Err(err) = cx.editor.registers.write(reg_name, values) {

- cx.editor.set_error(err.to_string());

- return;

- }

- }

- // delete the selection

- if only_whole_lines {

- open(cx, Open::Above, CommentContinuation::Disabled);

- } else {

- enter_insert_mode(cx);

- }

- delete_selection_impl(cx, Operation::Delete, YankAction::Yank);

- delete_selection_impl(cx, Operation::Delete, YankAction::NoYank);

- delete_selection_impl(cx, Operation::Change, YankAction::Yank);

- delete_selection_impl(cx, Operation::Change, YankAction::NoYank);

- if !root.exists() {

- cx.editor.set_error("Workspace directory does not exist");

- return;

- }

- let picker = ui::file_picker(cx.editor, root);

- let picker = ui::file_picker(cx.editor, path);

-

- let cwd = helix_stdx::env::current_working_dir();

- if !cwd.exists() {

- cx.editor

- .set_error("Current working directory does not exist");

- return;

- }

- let picker = ui::file_picker(cx.editor, cwd);

-fn file_explorer(cx: &mut Context) {

- let root = find_workspace().0;

- if !root.exists() {

- cx.editor.set_error("Workspace directory does not exist");

- return;

- }

-

- if let Ok(picker) = ui::file_explorer(root, cx.editor) {

- cx.push_layer(Box::new(overlaid(picker)));

- }

-fn file_explorer_in_current_buffer_directory(cx: &mut Context) {

- let doc_dir = doc!(cx.editor)

- .path()

- .and_then(|path| path.parent().map(|path| path.to_path_buf()));

-

- let path = match doc_dir {

- Some(path) => path,

- None => {

- let cwd = helix_stdx::env::current_working_dir();

- if !cwd.exists() {

- cx.editor.set_error(

- "Current buffer has no parent and current working directory does not exist",

- );

- return;

- }

- cx.editor.set_error(

- "Current buffer has no parent, opening file explorer in current working directory",

- );

- cwd

- }

- };

- if let Ok(picker) = ui::file_explorer(path, cx.editor) {

- cx.push_layer(Box::new(overlaid(picker)));

- }

-}

-fn file_explorer_in_current_directory(cx: &mut Context) {

- let cwd = helix_stdx::env::current_working_dir();

- if !cwd.exists() {

- cx.editor

- .set_error("Current working directory does not exist");

- return;

- }

- if let Ok(picker) = ui::file_explorer(cwd, cx.editor) {

- cx.push_layer(Box::new(overlaid(picker)));

- }

-}

-fn buffer_picker(cx: &mut Context) {

- let current = view!(cx.editor).doc;

- struct BufferMeta {

- id: DocumentId,

- path: Option<PathBuf>,

- is_modified: bool,

- is_current: bool,

- focused_at: std::time::Instant,

- .map(new_meta)

- let columns = [

- PickerColumn::new("id", |meta: &BufferMeta, _| meta.id.to_string().into()),

- PickerColumn::new("flags", |meta: &BufferMeta, _| {

- let mut flags = String::new();

- if meta.is_modified {

- flags.push('+');

- }

- if meta.is_current {

- flags.push('*');

- }

- flags.into()

- }),

- PickerColumn::new("path", |meta: &BufferMeta, _| {

- let path = meta

- .path

- .as_deref()

- .map(helix_stdx::path::get_relative_path);

- path.as_deref()

- .and_then(Path::to_str)

- .unwrap_or(SCRATCH_BUFFER_NAME)

- .to_string()

- .into()

- }),

- ];

- let initial_cursor = if items.len() <= 1 { 0 } else { 1 };

- let picker = Picker::new(columns, 2, items, (), |cx, meta, action| {

- .with_initial_cursor(initial_cursor)

- let lines = doc.selections().values().next().map(|selection| {

- let cursor_line = selection.primary().cursor_line(doc.text().slice(..));

- (cursor_line, cursor_line)

- });

- Some((meta.id.into(), lines))

- });

- let columns = [

- ui::PickerColumn::new("id", |item: &JumpMeta, _| item.id.to_string().into()),

- ui::PickerColumn::new("path", |item: &JumpMeta, _| {

- let path = item

- .path

- .as_deref()

- .map(helix_stdx::path::get_relative_path);

- path.as_deref()

- .and_then(Path::to_str)

- .unwrap_or(SCRATCH_BUFFER_NAME)

- .to_string()

- .into()

- }),

- ui::PickerColumn::new("flags", |item: &JumpMeta, _| {

- let mut flags = Vec::new();

- if item.is_current {

- flags.push("*");

- }

-

- if flags.is_empty() {

- "".into()

- } else {

- format!(" ({})", flags.join("")).into()

- }

- }),

- ui::PickerColumn::new("contents", |item: &JumpMeta, _| item.text.as_str().into()),

- ];

-

- columns,

- 1, // path

- cx.editor.tree.views().flat_map(|(view, _)| {

- view.jumps

- .iter()

- .rev()

- .map(|(doc_id, selection)| new_meta(view, *doc_id, selection.clone()))

- }),

- let (view, doc) = (view_mut!(cx.editor), doc_mut!(cx.editor, &meta.id));

- if action.align_view(view, doc.id()) {

- view.ensure_cursor_in_view_center(doc, config.scrolloff);

- }

-fn changed_file_picker(cx: &mut Context) {

- pub struct FileChangeData {

- cwd: PathBuf,

- style_untracked: Style,

- style_modified: Style,

- style_conflict: Style,

- style_deleted: Style,

- style_renamed: Style,

- }

-

- let cwd = helix_stdx::env::current_working_dir();

- if !cwd.exists() {

- cx.editor

- .set_error("Current working directory does not exist");

- return;

- }

- let added = cx.editor.theme.get("diff.plus");

- let modified = cx.editor.theme.get("diff.delta");

- let conflict = cx.editor.theme.get("diff.delta.conflict");

- let deleted = cx.editor.theme.get("diff.minus");

- let renamed = cx.editor.theme.get("diff.delta.moved");

-

- let columns = [

- PickerColumn::new("change", |change: &FileChange, data: &FileChangeData| {

- match change {

- FileChange::Untracked { .. } => Span::styled("+ untracked", data.style_untracked),

- FileChange::Modified { .. } => Span::styled("~ modified", data.style_modified),

- FileChange::Conflict { .. } => Span::styled("x conflict", data.style_conflict),

- FileChange::Deleted { .. } => Span::styled("- deleted", data.style_deleted),

- FileChange::Renamed { .. } => Span::styled("> renamed", data.style_renamed),

- }

- .into()

- }),

- PickerColumn::new("path", |change: &FileChange, data: &FileChangeData| {

- let display_path = |path: &PathBuf| {

- path.strip_prefix(&data.cwd)

- .unwrap_or(path)

- .display()

- .to_string()

- };

- match change {

- FileChange::Untracked { path } => display_path(path),

- FileChange::Modified { path } => display_path(path),

- FileChange::Conflict { path } => display_path(path),

- FileChange::Deleted { path } => display_path(path),

- FileChange::Renamed { from_path, to_path } => {

- format!("{} -> {}", display_path(from_path), display_path(to_path))

- }

- .into()

- }),

- ];

-

- let picker = Picker::new(

- columns,

- 1, // path

- [],

- FileChangeData {

- cwd: cwd.clone(),

- style_untracked: added,

- style_modified: modified,

- style_conflict: conflict,

- style_deleted: deleted,

- style_renamed: renamed,

- },

- |cx, meta: &FileChange, action| {

- let path_to_open = meta.path();

- if let Err(e) = cx.editor.open(path_to_open, action) {

- let err = if let Some(err) = e.source() {

- format!("{}", err)

- } else {

- format!("unable to open \"{}\"", path_to_open.display())

- };

- cx.editor.set_error(err);

- }

- },

- )

- .with_preview(|_editor, meta| Some((meta.path().into(), None)));

- let injector = picker.injector();

- cx.editor

- .diff_providers

- .clone()

- .for_each_changed_file(cwd, move |change| match change {

- Ok(change) => injector.push(change).is_ok(),

- Err(err) => {

- status::report_blocking(err);

- true

- }

- });

- cx.push_layer(Box::new(overlaid(picker)));

- cx.callback.push(Box::new(

- let keymap = compositor.find::<ui::EditorView>().unwrap().keymaps.map()

- [&cx.editor.mode]

- .reverse_map();

-

- let commands = MappableCommand::STATIC_COMMAND_LIST.iter().cloned().chain(

- typed::TYPABLE_COMMAND_LIST

- .iter()

- .map(|cmd| MappableCommand::Typable {

- name: cmd.name.to_owned(),

- args: String::new(),

- doc: cmd.doc.to_owned(),

- }),

- );

- let columns = [

- ui::PickerColumn::new("name", |item, _| match item {

- MappableCommand::Typable { name, .. } => format!(":{name}").into(),

- MappableCommand::Static { name, .. } => (*name).into(),

- MappableCommand::Macro { .. } => {

- unreachable!("macros aren't included in the command palette")

- }

- }),

- ui::PickerColumn::new(

- "bindings",

- |item: &MappableCommand, keymap: &crate::keymap::ReverseKeymap| {

- keymap

- .get(item.name())

- .map(|bindings| {

- bindings.iter().fold(String::new(), |mut acc, bind| {

- if !acc.is_empty() {

- acc.push(' ');

- }

- for key in bind {

- acc.push_str(&key.key_sequence_format());

- }

- acc

- })

- })

- .unwrap_or_default()

- .into()

- },

- ),

- ui::PickerColumn::new("doc", |item: &MappableCommand, _| item.doc().into()),

- ];

- let picker = Picker::new(columns, 0, commands, keymap, move |cx, command, _action| {

- callback: Vec::new(),

- cx.callback.push(Box::new(|compositor, cx| {

- let loader = cx.editor.syn_loader.load();

- &loader,

- &doc.config.load().indent_heuristic,

- IndentFallbackPos::LineStart => text

- .line(cursor_line)

- .first_non_whitespace_char()

- .map(|ws_offset| ws_offset + cursor_line_start)

- .unwrap_or(cursor_line_start),

- match format {

- Ok(format) => {

- if doc.version() == doc_version {

- doc.apply(&format, view.id);

- doc.append_changes_to_history(view);

- doc.detect_indent_and_line_ending();

- view.ensure_cursor_in_view(doc, scrolloff);

- } else {

- log::info!("discarded formatting changes because the document changed");

- }

- }

- Err(err) => {

- if write.is_none() {

- editor.set_error(err.to_string());

- return;

- }

- log::info!("failed to format '{}': {err}", doc.display_name());

-#[derive(PartialEq)]

-pub enum CommentContinuation {

- Enabled,

- Disabled,

-}

-

-fn open(cx: &mut Context, open: Open, comment_continuation: CommentContinuation) {

- let config = cx.editor.config();

- let loader = cx.editor.syn_loader.load();

- let mut offs = 0;

-

- let continue_comment_tokens =

- if comment_continuation == CommentContinuation::Enabled && config.continue_comments {

- doc.language_config()

- .and_then(|config| config.comment_tokens.as_ref())

- } else {

- None

- };

- // the line number, where the cursor is currently

- let curr_line_num = text.char_to_line(match open {

-

- // the next line number, where the cursor will be, after finishing the transaction

- let next_new_line_num = match open {

- Open::Below => curr_line_num + 1,

- Open::Above => curr_line_num,

- let above_next_new_line_num = next_new_line_num.saturating_sub(1);

-

- let continue_comment_token = continue_comment_tokens

- .and_then(|tokens| comment::get_comment_token(text, tokens, curr_line_num));

-

- let (above_next_line_end_index, above_next_line_end_width) = if next_new_line_num == 0 {

- line_end_char_index(&text, above_next_new_line_num),

- let line = text.line(curr_line_num);

- let indent = match line.first_non_whitespace_char() {

- Some(pos) if continue_comment_token.is_some() => line.slice(..pos).to_string(),

- _ => indent::indent_for_newline(

- &loader,

- doc.syntax(),

- &config.indent_heuristic,

- &doc.indent_style,

- doc.tab_width(),

- text,

- above_next_new_line_num,

- above_next_line_end_index,

- curr_line_num,

- ),

- };

-

-

- if open == Open::Above && next_new_line_num == 0 {

- text.push_str(&indent);

- if let Some(token) = continue_comment_token {

- text.push_str(token);

- text.push(' ');

- }

- text.push_str(doc.line_ending.as_str());

- } else {

- text.push_str(doc.line_ending.as_str());

- text.push_str(&indent);

-

- if let Some(token) = continue_comment_token {

- text.push_str(token);

- text.push(' ');

- }

- }

-

- let pos = offs + above_next_line_end_index + above_next_line_end_width;

- let comment_len = continue_comment_token

- .map(|token| token.len() + 1) // `+ 1` for the extra space added

- .unwrap_or_default();

- // pos -> beginning of reference line,

- // + (i * (line_ending_len + indent_len + comment_len)) -> beginning of i'th line from pos (possibly including comment token)

- // + indent_len + comment_len -> -> indent for i'th line

- ranges.push(Range::point(

- pos + (i * (doc.line_ending.len_chars() + indent_len + comment_len))

- + indent_len

- + comment_len,

- ));

- // update the offset for the next range

- (

- above_next_line_end_index,

- above_next_line_end_index,

- Some(text.into()),

- )

- open(cx, Open::Below, CommentContinuation::Enabled)

- open(cx, Open::Above, CommentContinuation::Enabled)

-fn push_jump(view: &mut View, doc: &mut Document) {

- doc.append_changes_to_history(view);

- goto_line_impl(cx, Movement::Move);

-}

-

-fn goto_line_impl(cx: &mut Context, movement: Movement) {

- goto_line_without_jumplist(cx.editor, cx.count, movement);

-fn goto_line_without_jumplist(

- editor: &mut Editor,

- count: Option<NonZeroUsize>,

- movement: Movement,

-) {

- .transform(|range| range.put_cursor(text, pos, movement == Movement::Extend));

- goto_last_line_impl(cx, Movement::Move)

-}

-

-fn extend_to_last_line(cx: &mut Context) {

- goto_last_line_impl(cx, Movement::Extend)

-}

-

-fn goto_last_line_impl(cx: &mut Context, movement: Movement) {

- .transform(|range| range.put_cursor(text, pos, movement == Movement::Extend));

-

- push_jump(view, doc);

- doc.set_selection(view.id, selection);

-}

-

-fn goto_column(cx: &mut Context) {

- goto_column_impl(cx, Movement::Move);

-}

-

-fn extend_to_column(cx: &mut Context) {

- goto_column_impl(cx, Movement::Extend);

-}

-fn goto_column_impl(cx: &mut Context, movement: Movement) {

- let count = cx.count();

- let (view, doc) = current!(cx.editor);

- let text = doc.text().slice(..);

- let selection = doc.selection(view.id).clone().transform(|range| {

- let line = range.cursor_line(text);

- let line_start = text.line_to_char(line);

- let line_end = line_end_char_index(&text, line);

- let pos = graphemes::nth_next_grapheme_boundary(text, line_start, count - 1).min(line_end);

- range.put_cursor(text, pos, movement == Movement::Extend)

- });

- push_jump(view, doc);

- let selection = match doc.diagnostics().first() {

- push_jump(view, doc);

- view.diagnostics_handler

- .immediately_show_diagnostic(doc, view.id);

- let selection = match doc.diagnostics().last() {

- push_jump(view, doc);

- view.diagnostics_handler

- .immediately_show_diagnostic(doc, view.id);

- let motion = move |editor: &mut Editor| {

- let (view, doc) = current!(editor);

- let cursor_pos = doc

- .selection(view.id)

- .primary()

- .cursor(doc.text().slice(..));

- let diag = doc

- .diagnostics()

- .iter()

- .find(|diag| diag.range.start > cursor_pos);

- let selection = match diag {

- Some(diag) => Selection::single(diag.range.start, diag.range.end),

- None => return,

- };

- push_jump(view, doc);

- doc.set_selection(view.id, selection);

- view.diagnostics_handler

- .immediately_show_diagnostic(doc, view.id);

-

- cx.editor.apply_motion(motion);

- let motion = move |editor: &mut Editor| {

- let (view, doc) = current!(editor);

- let cursor_pos = doc

- .selection(view.id)

- .primary()

- .cursor(doc.text().slice(..));

- let diag = doc

- .diagnostics()

- .iter()

- .rev()

- .find(|diag| diag.range.start < cursor_pos);

- let selection = match diag {

- // NOTE: the selection is reversed because we're jumping to the

- // previous diagnostic.

- Some(diag) => Selection::single(diag.range.end, diag.range.start),

- None => return,

- };

- push_jump(view, doc);

- doc.set_selection(view.id, selection);

- view.diagnostics_handler

- .immediately_show_diagnostic(doc, view.id);

- cx.editor.apply_motion(motion)

- push_jump(view, doc);

- push_jump(view, doc);

- cx.editor.apply_motion(motion);

- use crate::{events::PostInsertChar, key};

-

- use helix_view::editor::SmartTabConfig;

- helix_event::dispatch(PostInsertChar { c, cx });

- }

-

- pub fn smart_tab(cx: &mut Context) {

- let (view, doc) = current_ref!(cx.editor);

- let view_id = view.id;

-

- if matches!(

- cx.editor.config().smart_tab,

- Some(SmartTabConfig { enable: true, .. })

- ) {

- let cursors_after_whitespace = doc.selection(view_id).ranges().iter().all(|range| {

- let cursor = range.cursor(doc.text().slice(..));

- let current_line_num = doc.text().char_to_line(cursor);

- let current_line_start = doc.text().line_to_char(current_line_num);

- let left = doc.text().slice(current_line_start..cursor);

- left.chars().all(|c| c.is_whitespace())

- });

-

- if !cursors_after_whitespace {

- if doc.active_snippet.is_some() {

- goto_next_tabstop(cx);

- } else {

- move_parent_node_end(cx);

- }

- return;

- }

-

- insert_tab(cx);

- insert_tab_impl(cx, 1)

- }

-

- fn insert_tab_impl(cx: &mut Context, count: usize) {

- let indent = Tendril::from(doc.indent_style.as_str().repeat(count));

- pub fn append_char_interactive(cx: &mut Context) {

- // Save the current mode, so we can restore it later.

- let mode = cx.editor.mode;

- append_mode(cx);

- insert_selection_interactive(cx, mode);

- }

-

- pub fn insert_char_interactive(cx: &mut Context) {

- let mode = cx.editor.mode;

- insert_mode(cx);

- insert_selection_interactive(cx, mode);

- }

-

- fn insert_selection_interactive(cx: &mut Context, old_mode: Mode) {

- let count = cx.count();

-

- // need to wait for next key

- cx.on_next_key(move |cx, event| {

- match event {

- KeyEvent {

- code: KeyCode::Char(ch),

- ..

- } => {

- for _ in 0..count {

- insert::insert_char(cx, ch)

- }

- }

- key!(Enter) => {

- if count != 1 {

- cx.editor

- .set_error("inserting multiple newlines not yet supported");

- return;

- }

- insert_newline(cx)

- }

- key!(Tab) => insert_tab_impl(cx, count),

- _ => (),

- };

- // Restore the old mode.

- cx.editor.mode = old_mode;

- });

- }

-

- let config = cx.editor.config();

- let loader = cx.editor.syn_loader.load();

- let line_ending = doc.line_ending.as_str();

- let selection = doc.selection(view.id);

- let mut new_text = String::new();

- let continue_comment_tokens = if config.continue_comments {

- doc.language_config()

- .and_then(|config| config.comment_tokens.as_ref())

- } else {

- None

- };

-

- let mut last_pos = 0;

- let mut transaction = Transaction::change_by_selection(contents, selection, |range| {

- // Tracks the number of trailing whitespace characters deleted by this selection.

- let mut chars_deleted = 0;

- let line_start = text.line_to_char(current_line);

- let continue_comment_token = continue_comment_tokens

- .and_then(|tokens| comment::get_comment_token(text, tokens, current_line));

- let (from, to, local_offs) = if let Some(idx) =

- text.slice(line_start..pos).last_non_whitespace_char()

- {

- let first_trailing_whitespace_char = (line_start + idx + 1).clamp(last_pos, pos);

- last_pos = pos;

- let line = text.line(current_line);

-

- let indent = match line.first_non_whitespace_char() {

- Some(pos) if continue_comment_token.is_some() => line.slice(..pos).to_string(),

- _ => indent::indent_for_newline(

- &loader,

- doc.syntax(),

- &config.indent_heuristic,

- &doc.indent_style,

- doc.tab_width(),

- text,

- current_line,

- pos,

- current_line,

- ),

- };

- .is_some_and(|pair| pair.open == prev && pair.close == curr);

- let local_offs = if let Some(token) = continue_comment_token {

- new_text.reserve_exact(line_ending.len() + indent.len() + token.len() + 1);

- new_text.push_str(line_ending);

- new_text.push_str(&indent);

- new_text.push_str(token);

- new_text.push(' ');

- new_text.chars().count()

- } else if on_auto_pair {

- // line where the cursor will be

- new_text

- .reserve_exact(line_ending.len() * 2 + indent.len() + inner_indent.len());

- new_text.push_str(line_ending);

-

- // line where the matching pair will be

- new_text.push_str(line_ending);

-

- new_text.reserve_exact(line_ending.len() + indent.len());

- new_text.push_str(line_ending);

-

- // Note that `first_trailing_whitespace_char` is at least `pos` so this unsigned

- // subtraction cannot underflow.

- chars_deleted = pos - first_trailing_whitespace_char;

-

- (

- first_trailing_whitespace_char,

- pos,

- local_offs as isize - chars_deleted as isize,

- )

- } else {

- // If the current line is all whitespace, insert a line ending at the beginning of

- // the current line. This makes the current line empty and the new line contain the

- // indentation of the old line.

- new_text.push_str(line_ending);

-

- (line_start, line_start, new_text.chars().count() as isize)

- let new_range = if range.cursor(text) > range.anchor {

- (range.anchor as isize + global_offs) as usize,

- (range.head as isize + local_offs + global_offs) as usize,

- (range.anchor as isize + local_offs + global_offs) as usize,

- (range.head as isize + local_offs + global_offs) as usize,

- global_offs += new_text.chars().count() as isize - chars_deleted as isize;

- let tendril = Tendril::from(&new_text);

- new_text.clear();

- (from, to, Some(tendril))

- yank_impl(

- cx.editor,

- cx.register

- .unwrap_or(cx.editor.config().default_yank_register),

- );

- exit_select_mode(cx);

-}

-

-fn yank_to_clipboard(cx: &mut Context) {

- yank_impl(cx.editor, '+');

- exit_select_mode(cx);

-}

-

-fn yank_to_primary_clipboard(cx: &mut Context) {

- yank_impl(cx.editor, '*');

- exit_select_mode(cx);

-}

-

-fn yank_impl(editor: &mut Editor, register: char) {

- let (view, doc) = current!(editor);

- let selections = values.len();

- match editor.registers.write(register, values) {

- Ok(_) => editor.set_status(format!(

- "yanked {selections} selection{} to register {register}",

- if selections == 1 { "" } else { "s" }

- )),

- Err(err) => editor.set_error(err.to_string()),

- }

- let selections = selection.len();

- match editor.registers.write(register, vec![joined]) {

- Ok(_) => editor.set_status(format!(

- "joined and yanked {selections} selection{} to register {register}",

- if selections == 1 { "" } else { "s" }

- )),

- Err(err) => editor.set_error(err.to_string()),

- }

- let separator = doc!(cx.editor).line_ending.as_str();

- yank_joined_impl(

- cx.editor,

- separator,

- cx.register

- .unwrap_or(cx.editor.config().default_yank_register),

- );

-fn yank_joined_to_clipboard(cx: &mut Context) {

- let line_ending = doc!(cx.editor).line_ending;

- yank_joined_impl(cx.editor, line_ending.as_str(), '+');

- exit_select_mode(cx);

-fn yank_joined_to_primary_clipboard(cx: &mut Context) {

- yank_joined_impl(cx.editor, line_ending.as_str(), '*');

-fn yank_primary_selection_impl(editor: &mut Editor, register: char) {

- let selection = doc.selection(view.id).primary().fragment(text).to_string();

- match editor.registers.write(register, vec![selection]) {

- Ok(_) => editor.set_status(format!("yanked primary selection to register {register}",)),

- Err(err) => editor.set_error(err.to_string()),

- yank_primary_selection_impl(cx.editor, '+');

- exit_select_mode(cx);

- yank_primary_selection_impl(cx.editor, '*');

-static LINE_ENDING_REGEX: Lazy<Regex> = Lazy::new(|| Regex::new(r"\r\n|\r|\n").unwrap());

-

- if mode == Mode::Insert {

- doc.append_changes_to_history(view);

- }

- let map_value = |value| {

- let value = LINE_ENDING_REGEX.replace_all(value, doc.line_ending.as_str());

- let mut out = Tendril::from(value.as_ref());

- for _ in 1..count {

- out.push_str(&value);

- }

- out

- };

-

- let repeat = std::iter::repeat(

- // `values` is asserted to have at least one entry above.

- map_value(values.last().unwrap()),

- );

-

- let mut values = values.iter().map(|value| map_value(value)).chain(repeat);

- exit_select_mode(cx);

- paste(cx.editor, '+', Paste::After, cx.count());

- exit_select_mode(cx);

- paste(cx.editor, '+', Paste::Before, cx.count());

- exit_select_mode(cx);

- paste(cx.editor, '*', Paste::After, cx.count());

- exit_select_mode(cx);

- paste(cx.editor, '*', Paste::Before, cx.count());

- exit_select_mode(cx);

-}

-

-fn replace_with_yanked(cx: &mut Context) {

- replace_with_yanked_impl(

- cx.register

- .unwrap_or(cx.editor.config().default_yank_register),

- exit_select_mode(cx);

-fn replace_with_yanked_impl(editor: &mut Editor, register: char, count: usize) {

- let Some(values) = editor

- .registers

- .read(register, editor)

- .filter(|values| values.len() > 0)

- else {

- return;

- };

- let scrolloff = editor.config().scrolloff;

- let (view, doc) = current_ref!(editor);

-

- let map_value = |value: &Cow<str>| {

- let value = LINE_ENDING_REGEX.replace_all(value, doc.line_ending.as_str());

- let mut out = Tendril::from(value.as_ref());

- for _ in 1..count {

- out.push_str(&value);

- out

- };

- let mut values_rev = values.rev().peekable();

- // `values` is asserted to have at least one entry above.

- let last = values_rev.peek().unwrap();

- let repeat = std::iter::repeat(map_value(last));

- let mut values = values_rev

- .rev()

- .map(|value| map_value(&value))

- .chain(repeat);

- let selection = doc.selection(view.id);

- let transaction = Transaction::change_by_selection(doc.text(), selection, |range| {

- if !range.is_empty() {

- (range.from(), range.to(), Some(values.next().unwrap()))

- } else {

- (range.from(), range.to(), None)

- });

- drop(values);

- let (view, doc) = current!(editor);

- doc.apply(&transaction, view.id);

- doc.append_changes_to_history(view);

- view.ensure_cursor_in_view(doc, scrolloff);

- replace_with_yanked_impl(cx.editor, '+', cx.count());

- exit_select_mode(cx);

- replace_with_yanked_impl(cx.editor, '*', cx.count());

- exit_select_mode(cx);

-fn paste(editor: &mut Editor, register: char, pos: Paste, count: usize) {

- let Some(values) = editor.registers.read(register, editor) else {

- return;

- };

- let values: Vec<_> = values.map(|value| value.to_string()).collect();

- let (view, doc) = current!(editor);

- paste_impl(&values, doc, view, pos, count, editor.mode);

- paste(

- cx.editor,

- cx.register

- .unwrap_or(cx.editor.config().default_yank_register),

- Paste::After,

- cx.count(),

- );

- exit_select_mode(cx);

- paste(

- cx.editor,

- cx.register

- .unwrap_or(cx.editor.config().default_yank_register),

- Paste::Before,

- cx.count(),

- );

- exit_select_mode(cx);

- exit_select_mode(cx);

- exit_select_mode(cx);

- .set_error("No configured language server supports range formatting");

- lsp::FormattingOptions {

- tab_size: doc.tab_width() as u32,

- insert_spaces: matches!(doc.indent_style, IndentStyle::Spaces(_)),

- ..Default::default()

- },

- let edits = tokio::task::block_in_place(|| helix_lsp::block_on(future))

- .ok()

- .flatten()

- .unwrap_or_default();

- let slice = text.slice(..);

-

- let comment_tokens = doc

- .language_config()

- .and_then(|config| config.comment_tokens.as_deref())

- .unwrap_or(&[]);

- // Sort by length to handle Rust's /// vs //

- let mut comment_tokens: Vec<&str> = comment_tokens.iter().map(|x| x.as_str()).collect();

- comment_tokens.sort_unstable_by_key(|x| std::cmp::Reverse(x.len()));

- let first_line_idx = slice.line_to_char(start);

- let first_line_idx = skip_while(slice, first_line_idx, |ch| matches!(ch, ' ' | '\t'))

- .unwrap_or(first_line_idx);

- let first_line = slice.slice(first_line_idx..);

- let mut current_comment_token = comment_tokens

- .iter()

- .find(|token| first_line.starts_with(token));

-

- let slice_from_end = slice.slice(end..);

- if let Some(token) = comment_tokens

- .iter()

- .find(|token| slice_from_end.starts_with(token))

- {

- if Some(token) == current_comment_token {

- end += token.chars().count();

- end = skip_while(slice, end, |ch| matches!(ch, ' ' | '\t')).unwrap_or(end);

- } else {

- // update current token, but don't delete this one.

- current_comment_token = Some(token);

- }

- }

- let separator = if end == line_end_char_index(&slice, line + 1) {

- // the joining line contains only space-characters => don't include a whitespace when joining

- None

- } else {

- Some(Tendril::from(" "))

- };

- changes.push((start, end, separator));

- let mut offset: usize = 0;

- .filter_map(|change| {

- if change.2.is_some() {

- let range = Range::point(change.0 - offset);

- offset += change.1 - change.0 - 1; // -1 adjusts for the replacement of the range by a space

- Some(range)

- } else {

- offset += change.1 - change.0;

- None

- }

- let t = Transaction::change(text, changes.into_iter());

- if ranges.is_empty() {

- t

- } else {

- let selection = Selection::new(ranges, 0);

- t.with_selection(selection)

- }

- Transaction::change(text, changes.into_iter())

- move |cx, regex, event| {

- let (view, doc) = current!(cx.editor);

- } else {

- cx.editor.set_error("no selections remaining");

- let (view, doc) = current!(cx.editor);

- let range = doc.selection(view.id).primary();

- let text = doc.text().slice(..);

- let cursor = range.cursor(text);

-

- cx.editor

- .handlers

- .trigger_completions(cursor, doc.id(), view.id);

-}

-// comments

-type CommentTransactionFn = fn(

- line_token: Option<&str>,

- block_tokens: Option<&[BlockCommentToken]>,

- doc: &Rope,

- selection: &Selection,

-) -> Transaction;

-

-fn toggle_comments_impl(cx: &mut Context, comment_transaction: CommentTransactionFn) {

- let line_token: Option<&str> = doc

- .language_config()

- .and_then(|lc| lc.comment_tokens.as_ref())

- .and_then(|tc| tc.first())

- .map(|tc| tc.as_str());

- let block_tokens: Option<&[BlockCommentToken]> = doc

- .language_config()

- .and_then(|lc| lc.block_comment_tokens.as_ref())

- .map(|tc| &tc[..]);

-

- let transaction =

- comment_transaction(line_token, block_tokens, doc.text(), doc.selection(view.id));

- doc.apply(&transaction, view.id);

- exit_select_mode(cx);

-}

-

-/// commenting behavior:

-/// 1. only line comment tokens -> line comment

-/// 2. each line block commented -> uncomment all lines

-/// 3. whole selection block commented -> uncomment selection

-/// 4. all lines not commented and block tokens -> comment uncommented lines

-/// 5. no comment tokens and not block commented -> line comment

-fn toggle_comments(cx: &mut Context) {

- toggle_comments_impl(cx, |line_token, block_tokens, doc, selection| {

- let text = doc.slice(..);

-

- // only have line comment tokens

- if line_token.is_some() && block_tokens.is_none() {

- return comment::toggle_line_comments(doc, selection, line_token);

- }

-

- let split_lines = comment::split_lines_of_selection(text, selection);

-

- let default_block_tokens = &[BlockCommentToken::default()];

- let block_comment_tokens = block_tokens.unwrap_or(default_block_tokens);

-

- let (line_commented, line_comment_changes) =

- comment::find_block_comments(block_comment_tokens, text, &split_lines);

- // block commented by line would also be block commented so check this first

- if line_commented {

- return comment::create_block_comment_transaction(

- doc,

- &split_lines,

- line_commented,

- line_comment_changes,

- )

- .0;

- }

- let (block_commented, comment_changes) =

- comment::find_block_comments(block_comment_tokens, text, selection);

- // check if selection has block comments

- if block_commented {

- return comment::create_block_comment_transaction(

- doc,

- selection,

- block_commented,

- comment_changes,

- )

- .0;

- // not commented and only have block comment tokens

- if line_token.is_none() && block_tokens.is_some() {

- return comment::create_block_comment_transaction(

- doc,

- &split_lines,

- line_commented,

- line_comment_changes,

- )

- .0;

- }

- // not block commented at all and don't have any tokens

- comment::toggle_line_comments(doc, selection, line_token)

- })

-}

-fn toggle_line_comments(cx: &mut Context) {

- toggle_comments_impl(cx, |line_token, block_tokens, doc, selection| {

- if line_token.is_none() && block_tokens.is_some() {

- let default_block_tokens = &[BlockCommentToken::default()];

- let block_comment_tokens = block_tokens.unwrap_or(default_block_tokens);

- comment::toggle_block_comments(

- doc,

- &comment::split_lines_of_selection(doc.slice(..), selection),

- block_comment_tokens,

- )

- } else {

- comment::toggle_line_comments(doc, selection, line_token)

- }

-fn toggle_block_comments(cx: &mut Context) {

- toggle_comments_impl(cx, |line_token, block_tokens, doc, selection| {

- if line_token.is_some() && block_tokens.is_none() {

- comment::toggle_line_comments(doc, selection, line_token)

- } else {

- let default_block_tokens = &[BlockCommentToken::default()];

- let block_comment_tokens = block_tokens.unwrap_or(default_block_tokens);

- comment::toggle_block_comments(doc, selection, block_comment_tokens)

- }

- });

-fn rotate_selections_first(cx: &mut Context) {

- let (view, doc) = current!(cx.editor);

- let mut selection = doc.selection(view.id).clone();

- selection.set_primary_index(0);

- doc.set_selection(view.id, selection);

-}

-

-fn rotate_selections_last(cx: &mut Context) {

- let (view, doc) = current!(cx.editor);

- let mut selection = doc.selection(view.id).clone();

- let len = selection.len();

- selection.set_primary_index(len - 1);

- doc.set_selection(view.id, selection);

-}

-

-#[derive(Debug)]

-

- let mut ranges: Vec<_> = selection

- let rotate_by = count.map_or(1, |count| count.get().min(ranges.len()));

-

- let primary_index = match strategy {

- ReorderStrategy::RotateForward => {

- ranges.rotate_right(rotate_by);

- // Like `usize::wrapping_add`, but provide a custom range from `0` to `ranges.len()`

- (selection.primary_index() + ranges.len() + rotate_by) % ranges.len()

- }

- ReorderStrategy::RotateBackward => {

- ranges.rotate_left(rotate_by);

- // Like `usize::wrapping_sub`, but provide a custom range from `0` to `ranges.len()`

- (selection.primary_index() + ranges.len() - rotate_by) % ranges.len()

- }

- ReorderStrategy::Reverse => {

- if rotate_by % 2 == 0 {

- // nothing changed, if we reverse something an even

- // amount of times, the output will be the same

- return;

- }

- ranges.reverse();

- // -1 to turn 1-based len into 0-based index

- (ranges.len() - 1) - selection.primary_index()

- }

- };

- .zip(ranges)

- doc.set_selection(

- view.id,

- Selection::new(selection.ranges().into(), primary_index),

- );

- cx.editor.apply_motion(motion);

- cx.editor.apply_motion(motion);

-fn select_sibling_impl<F>(cx: &mut Context, sibling_fn: F)

- F: Fn(&helix_core::Syntax, RopeSlice, Selection) -> Selection + 'static,

- let motion = move |editor: &mut Editor| {

- let selection = sibling_fn(syntax, text, current_selection.clone());

- cx.editor.apply_motion(motion);

- select_sibling_impl(cx, object::select_next_sibling)

- select_sibling_impl(cx, object::select_prev_sibling)

-}

-

-fn move_node_bound_impl(cx: &mut Context, dir: Direction, movement: Movement) {

- let motion = move |editor: &mut Editor| {

- let (view, doc) = current!(editor);

-

- if let Some(syntax) = doc.syntax() {

- let text = doc.text().slice(..);

- let current_selection = doc.selection(view.id);

-

- let selection = movement::move_parent_node_end(

- syntax,

- text,

- current_selection.clone(),

- dir,

- movement,

- );

-

- doc.set_selection(view.id, selection);

- }

- };

-

- cx.editor.apply_motion(motion);

-}

-

-pub fn move_parent_node_end(cx: &mut Context) {

- move_node_bound_impl(cx, Direction::Forward, Movement::Move)

-}

-

-pub fn move_parent_node_start(cx: &mut Context) {

- move_node_bound_impl(cx, Direction::Backward, Movement::Move)

-}

-

-pub fn extend_parent_node_end(cx: &mut Context) {

- move_node_bound_impl(cx, Direction::Forward, Movement::Extend)

-}

-

-pub fn extend_parent_node_start(cx: &mut Context) {

- move_node_bound_impl(cx, Direction::Backward, Movement::Extend)

-}

-

-fn select_all_impl<F>(editor: &mut Editor, select_fn: F)

-where

- F: Fn(&Syntax, RopeSlice, Selection) -> Selection,

-{

- let (view, doc) = current!(editor);

-

- if let Some(syntax) = doc.syntax() {

- let text = doc.text().slice(..);

- let current_selection = doc.selection(view.id);

- let selection = select_fn(syntax, text, current_selection.clone());

- doc.set_selection(view.id, selection);

- }

-}

-

-fn select_all_siblings(cx: &mut Context) {

- let motion = |editor: &mut Editor| {

- select_all_impl(editor, object::select_all_siblings);

- };

-

- cx.editor.apply_motion(motion);

-}

-

-fn select_all_children(cx: &mut Context) {

- let motion = |editor: &mut Editor| {

- select_all_impl(editor, object::select_all_children);

- };

-

- cx.editor.apply_motion(motion);

- // Document we switch to might not have been opened in the view before

- doc.ensure_view_init(view.id);

- // Document we switch to might not have been opened in the view before

- doc.ensure_view_init(view.id);

-/// Open a new split in the given direction specified by the action.

-///

-/// Maintain the current view (both the cursor's position and view in document).

-fn split(editor: &mut Editor, action: Action) {

- let (view, doc) = current!(editor);

- let offset = doc.view_offset(view.id);

- editor.switch(id, action);

- let (view, doc) = current!(editor);

- doc.set_view_offset(view.id, offset);

- split(cx.editor, Action::HorizontalSplit);

- split(cx.editor, Action::VerticalSplit);

- cx.editor.autoinfo = Some(Info::from_registers(

- "Select register",

- &cx.editor.registers,

- ));

- cx.editor.autoinfo = None;

- cx.editor.autoinfo = Some(Info::from_registers(

- "Insert register",

- &cx.editor.registers,

- ));

- cx.editor.autoinfo = None;

- paste(

- cx.editor,

- cx.register

- .unwrap_or(cx.editor.config().default_yank_register),

- Paste::Cursor,

- cx.count(),

- );

-fn copy_between_registers(cx: &mut Context) {

- cx.editor.autoinfo = Some(Info::from_registers(

- "Copy from register",

- &cx.editor.registers,

- ));

- cx.on_next_key(move |cx, event| {

- cx.editor.autoinfo = None;

-

- let Some(source) = event.char() else {

- return;

- };

-

- let Some(values) = cx.editor.registers.read(source, cx.editor) else {

- cx.editor.set_error(format!("register {source} is empty"));

- return;

- };

- let values: Vec<_> = values.map(|value| value.to_string()).collect();

-

- cx.editor.autoinfo = Some(Info::from_registers(

- "Copy into register",

- &cx.editor.registers,

- ));

- cx.on_next_key(move |cx, event| {

- cx.editor.autoinfo = None;

-

- let Some(dest) = event.char() else {

- return;

- };

-

- let n_values = values.len();

- match cx.editor.registers.write(dest, values) {

- Ok(_) => cx.editor.set_status(format!(

- "yanked {n_values} value{} from register {source} to {dest}",

- if n_values == 1 { "" } else { "s" }

- )),

- Err(err) => cx.editor.set_error(err.to_string()),

- }

- });

- });

-}

-

- let pos = visual_offset_from_block(

- doc_text,

- doc.view_offset(view.id).anchor,

- pos,

- &text_fmt,

- &view.text_annotations(doc, None),

- )

- .0;

- let mut offset = doc.view_offset(view.id);

- offset.horizontal_offset = pos

- doc.set_view_offset(view.id, offset);

- scroll(cx, cx.count(), Direction::Backward, false);

- scroll(cx, cx.count(), Direction::Forward, false);

- let loader = editor.syn_loader.load();

- if let Some(syntax) = doc.syntax() {

- text, range, object, direction, &root, syntax, &loader, count,

- push_jump(view, doc);

- cx.editor.apply_motion(motion);

-fn goto_next_xml_element(cx: &mut Context) {

- goto_ts_object_impl(cx, "xml-element", Direction::Forward)

-}

-

-fn goto_prev_xml_element(cx: &mut Context) {

- goto_ts_object_impl(cx, "xml-element", Direction::Backward)

-}

-

-fn goto_next_entry(cx: &mut Context) {

- goto_ts_object_impl(cx, "entry", Direction::Forward)

-}

-

-fn goto_prev_entry(cx: &mut Context) {

- goto_ts_object_impl(cx, "entry", Direction::Backward)

-}

-

- let loader = editor.syn_loader.load();

- let Some(syntax) = doc.syntax() else {

- return range;

- text, range, objtype, obj_name, syntax, &loader, count,

- 'e' => textobject_treesitter("entry", range),

- 'x' => textobject_treesitter("xml-element", range),

- doc.syntax(),

- text,

- range,

- objtype,

- count,

- ch if !ch.is_ascii_alphanumeric() => textobject::textobject_pair_surround(

- doc.syntax(),

- text,

- range,

- objtype,

- ch,

- count,

- ),

- cx.editor.apply_motion(textobject);

- ("e", "Data structure entry (tree-sitter)"),

- ("m", "Closest surrounding pair (tree-sitter)"),

- ("g", "Change"),

- ("x", "(X)HTML element (tree-sitter)"),

-static SURROUND_HELP_TEXT: [(&str, &str); 6] = [

- ("m", "Nearest matching pair"),

- ("( or )", "Parentheses"),

- ("{ or }", "Curly braces"),

- ("< or >", "Angled brackets"),

- ("[ or ]", "Square brackets"),

- (" ", "... or any character"),

-];

-

- cx.editor.autoinfo = None;

- let (o, c) = match_brackets::get_pair(ch);

- });

-

- cx.editor.autoinfo = Some(Info::new(

- "Surround selections with",

- &SURROUND_HELP_TEXT[1..],

- ));

- cx.editor.autoinfo = None;

- let change_pos =

- match surround::get_surround_pos(doc.syntax(), text, selection, surround_ch, count) {

- Ok(c) => c,

- Err(err) => {

- cx.editor.set_error(err.to_string());

- return;

- }

- };

-

- let selection = selection.clone();

- let ranges: SmallVec<[Range; 1]> = change_pos.iter().map(|&p| Range::point(p)).collect();

- doc.set_selection(

- view.id,

- Selection::new(ranges, selection.primary_index() * 2),

- );

- cx.editor.autoinfo = None;

- None => return doc.set_selection(view.id, selection),

- let (open, close) = match_brackets::get_pair(to);

-

- // the changeset has to be sorted to allow nested surrounds

- let mut sorted_pos: Vec<(usize, char)> = Vec::new();

- for p in change_pos.chunks(2) {

- sorted_pos.push((p[0], open));

- sorted_pos.push((p[1], close));

- }

- sorted_pos.sort_unstable();

-

- sorted_pos.iter().map(|&pos| {

- t.push(pos.1);

- (pos.0, pos.0 + 1, Some(t))

- doc.set_selection(view.id, selection);

-

- cx.editor.autoinfo = Some(Info::new(

- "Replace with a pair of",

- &SURROUND_HELP_TEXT[1..],

- ));

- });

-

- cx.editor.autoinfo = Some(Info::new(

- "Replace surrounding pair of",

- &SURROUND_HELP_TEXT,

- ));

- cx.editor.autoinfo = None;

- let mut change_pos =

- match surround::get_surround_pos(doc.syntax(), text, selection, surround_ch, count) {

- Ok(c) => c,

- Err(err) => {

- cx.editor.set_error(err.to_string());

- return;

- }

- };

- change_pos.sort_unstable(); // the changeset has to be sorted to allow nested surrounds

- });

-

- cx.editor.autoinfo = Some(Info::new("Delete surrounding pair of", &SURROUND_HELP_TEXT));

- shell_prompt_for_behavior(cx, "pipe:".into(), ShellBehavior::Replace);

- shell_prompt_for_behavior(cx, "pipe-to:".into(), ShellBehavior::Ignore);

- shell_prompt_for_behavior(cx, "insert-output:".into(), ShellBehavior::Insert);

- shell_prompt_for_behavior(cx, "append-output:".into(), ShellBehavior::Append);

- shell_prompt(cx, "keep-pipe:".into(), |cx, args| {

- let shell = &cx.editor.config().shell;

- let (view, doc) = current!(cx.editor);

- let selection = doc.selection(view.id);

- let mut ranges = SmallVec::with_capacity(selection.len());

- let old_index = selection.primary_index();

- let mut index: Option<usize> = None;

- let text = doc.text().slice(..);

- for (i, range) in selection.ranges().iter().enumerate() {

- let fragment = range.slice(text);

- if let Err(err) = shell_impl(shell, args.join(" ").as_str(), Some(fragment.into())) {

- log::debug!("Shell command failed: {}", err);

- } else {

- ranges.push(*range);

- if i >= old_index && index.is_none() {

- index = Some(ranges.len() - 1);

- }

- if ranges.is_empty() {

- cx.editor.set_error("No selections remaining");

- return;

- }

- let index = index.unwrap_or_else(|| ranges.len() - 1);

- doc.set_selection(view.id, Selection::new(ranges, index));

- });

-fn shell_impl(shell: &[String], cmd: &str, input: Option<Rope>) -> anyhow::Result<Tendril> {

-) -> anyhow::Result<Tendril> {

- let output = if !output.status.success() {

- if output.stderr.is_empty() {

- match output.status.code() {

- Some(exit_code) => bail!("Shell command failed: status {}", exit_code),

- None => bail!("Shell command failed"),

- }

- String::from_utf8_lossy(&output.stderr)

- // Prioritize `stderr` output over `stdout`

- let stderr = String::from_utf8_lossy(&output.stderr);

- log::debug!("Command printed to stderr: {stderr}");

- stderr

- } else {

- String::from_utf8_lossy(&output.stdout)

- };

- Ok(Tendril::from(output))

- let output = if let Some(output) = shell_output.as_ref() {

- output.clone()

- let input = range.slice(text);

- match shell_impl(shell, cmd, pipe.then(|| input.into())) {

- Ok(mut output) => {

- if !input.ends_with("\n") && output.ends_with('\n') {

- output.pop();

- if output.ends_with('\r') {

- output.pop();

- }

- }

-

- shell_output = Some(output.clone());

- output

- let anchor = to

- .checked_add_signed(offset)

- .expect("Selection ranges cannot overlap")

- .checked_sub(deleted_len)

- .expect("Selection ranges cannot overlap");

- offset = offset

- .checked_add_unsigned(output_len)

- .expect("Selection ranges cannot overlap")

- .checked_sub_unsigned(deleted_len)

- .expect("Selection ranges cannot overlap");

-fn shell_prompt<F>(cx: &mut Context, prompt: Cow<'static, str>, mut callback_fn: F)

-where

- F: FnMut(&mut compositor::Context, Args) + 'static,

-{

- |editor, input| complete_command_args(editor, SHELL_SIGNATURE, &SHELL_COMPLETER, input, 0),

- move |cx, input, event| {

- if event != PromptEvent::Validate || input.is_empty() {

- match Args::parse(input, SHELL_SIGNATURE, true, |token| {

- expansion::expand(cx.editor, token).map_err(|err| err.into())

- }) {

- Ok(args) => callback_fn(cx, args),

- Err(err) => cx.editor.set_error(err.to_string()),

-fn shell_prompt_for_behavior(cx: &mut Context, prompt: Cow<'static, str>, behavior: ShellBehavior) {

- shell_prompt(cx, prompt, move |cx, args| {

- shell(cx, args.join(" ").as_str(), &behavior)

- })

-}

-

- {

- _cx.block_try_flush_writes().ok();

- signal_hook::low_level::raise(signal_hook::consts::signal::SIGTSTP).unwrap();

- }

- exit_select_mode(cx);

- }

-}

-

-fn goto_next_tabstop(cx: &mut Context) {

- goto_next_tabstop_impl(cx, Direction::Forward)

-}

-

-fn goto_prev_tabstop(cx: &mut Context) {

- goto_next_tabstop_impl(cx, Direction::Backward)

-}

-

-fn goto_next_tabstop_impl(cx: &mut Context, direction: Direction) {

- let (view, doc) = current!(cx.editor);

- let view_id = view.id;

- let Some(mut snippet) = doc.active_snippet.take() else {

- cx.editor.set_error("no snippet is currently active");

- return;

- };

- let tabstop = match direction {

- Direction::Forward => Some(snippet.next_tabstop(doc.selection(view_id))),

- Direction::Backward => snippet

- .prev_tabstop(doc.selection(view_id))

- .map(|selection| (selection, false)),

- };

- let Some((selection, last_tabstop)) = tabstop else {

- return;

- };

- doc.set_selection(view_id, selection);

- if !last_tabstop {

- doc.active_snippet = Some(snippet)

- }

- if cx.editor.mode() == Mode::Insert {

- cx.on_next_key_fallback(|cx, key| {

- if let Some(c) = key.char() {

- let (view, doc) = current!(cx.editor);

- if let Some(snippet) = &doc.active_snippet {

- doc.apply(&snippet.delete_placeholder(doc.text()), view.id);

- }

- insert_char(cx, c);

- }

- })

- match cx.editor.registers.write(reg, vec![s]) {

- Ok(_) => cx

- .editor

- .set_status(format!("Recorded to register [{}]", reg)),

- Err(err) => cx.editor.set_error(err.to_string()),

- }

- let keys: Vec<KeyEvent> = if let Some(keys) = cx

- .editor

- .registers

- .read(reg, cx.editor)

- .filter(|values| values.len() == 1)

- .map(|mut values| values.next().unwrap())

- {

- match helix_view::input::parse_macro(&keys) {

- cx.callback.push(Box::new(move |compositor, cx| {

-

-fn goto_word(cx: &mut Context) {

- jump_to_word(cx, Movement::Move)

-}

-

-fn extend_to_word(cx: &mut Context) {

- jump_to_word(cx, Movement::Extend)

-}

-

-fn jump_to_label(cx: &mut Context, labels: Vec<Range>, behaviour: Movement) {

- let doc = doc!(cx.editor);

- let alphabet = &cx.editor.config().jump_label_alphabet;

- if labels.is_empty() {

- return;

- }

- let alphabet_char = |i| {

- let mut res = Tendril::new();

- res.push(alphabet[i]);

- res

- };

-

- // Add label for each jump candidate to the View as virtual text.

- let text = doc.text().slice(..);

- let mut overlays: Vec<_> = labels

- .iter()

- .enumerate()

- .flat_map(|(i, range)| {

- [

- Overlay::new(range.from(), alphabet_char(i / alphabet.len())),

- Overlay::new(

- graphemes::next_grapheme_boundary(text, range.from()),

- alphabet_char(i % alphabet.len()),

- ),

- ]

- })

- .collect();

- overlays.sort_unstable_by_key(|overlay| overlay.char_idx);

- let (view, doc) = current!(cx.editor);

- doc.set_jump_labels(view.id, overlays);

-

- // Accept two characters matching a visible label. Jump to the candidate

- // for that label if it exists.

- let primary_selection = doc.selection(view.id).primary();

- let view = view.id;

- let doc = doc.id();

- cx.on_next_key(move |cx, event| {

- let alphabet = &cx.editor.config().jump_label_alphabet;

- let Some(i) = event

- .char()

- .filter(|_| event.modifiers.is_empty())

- .and_then(|ch| alphabet.iter().position(|&it| it == ch))

- else {

- doc_mut!(cx.editor, &doc).remove_jump_labels(view);

- return;

- };

- let outer = i * alphabet.len();

- // Bail if the given character cannot be a jump label.

- if outer > labels.len() {

- doc_mut!(cx.editor, &doc).remove_jump_labels(view);

- return;

- }

- cx.on_next_key(move |cx, event| {

- doc_mut!(cx.editor, &doc).remove_jump_labels(view);

- let alphabet = &cx.editor.config().jump_label_alphabet;

- let Some(inner) = event

- .char()

- .filter(|_| event.modifiers.is_empty())

- .and_then(|ch| alphabet.iter().position(|&it| it == ch))

- else {

- return;

- };

- if let Some(mut range) = labels.get(outer + inner).copied() {

- range = if behaviour == Movement::Extend {

- let anchor = if range.anchor < range.head {

- let from = primary_selection.from();

- if range.anchor < from {

- range.anchor

- } else {

- from

- }

- } else {

- let to = primary_selection.to();

- if range.anchor > to {

- range.anchor

- } else {

- to

- }

- };

- Range::new(anchor, range.head)

- } else {

- range.with_direction(Direction::Forward)

- };

- doc_mut!(cx.editor, &doc).set_selection(view, range.into());

- }

- });

- });

-}

-

-fn jump_to_word(cx: &mut Context, behaviour: Movement) {

- // Calculate the jump candidates: ranges for any visible words with two or

- // more characters.

- let alphabet = &cx.editor.config().jump_label_alphabet;

- if alphabet.is_empty() {

- return;

- }

-

- let jump_label_limit = alphabet.len() * alphabet.len();

- let mut words = Vec::with_capacity(jump_label_limit);

- let (view, doc) = current_ref!(cx.editor);

- let text = doc.text().slice(..);

-

- // This is not necessarily exact if there is virtual text like soft wrap.

- // It's ok though because the extra jump labels will not be rendered.

- let start = text.line_to_char(text.char_to_line(doc.view_offset(view.id).anchor));

- let end = text.line_to_char(view.estimate_last_doc_line(doc) + 1);

-

- let primary_selection = doc.selection(view.id).primary();

- let cursor = primary_selection.cursor(text);

- let mut cursor_fwd = Range::point(cursor);

- let mut cursor_rev = Range::point(cursor);

- if text.get_char(cursor).is_some_and(|c| !c.is_whitespace()) {

- let cursor_word_end = movement::move_next_word_end(text, cursor_fwd, 1);

- // single grapheme words need a special case

- if cursor_word_end.anchor == cursor {

- cursor_fwd = cursor_word_end;

- }

- let cursor_word_start = movement::move_prev_word_start(text, cursor_rev, 1);

- if cursor_word_start.anchor == next_grapheme_boundary(text, cursor) {

- cursor_rev = cursor_word_start;

- }

- }

- 'outer: loop {

- let mut changed = false;

- while cursor_fwd.head < end {

- cursor_fwd = movement::move_next_word_end(text, cursor_fwd, 1);

- // The cursor is on a word that is atleast two graphemes long and

- // madeup of word characters. The latter condition is needed because

- // move_next_word_end simply treats a sequence of characters from

- // the same char class as a word so `=<` would also count as a word.

- let add_label = text

- .slice(..cursor_fwd.head)

- .graphemes_rev()

- .take(2)

- .take_while(|g| g.chars().all(char_is_word))

- .count()

- == 2;

- if !add_label {

- continue;

- }

- changed = true;

- // skip any leading whitespace

- cursor_fwd.anchor += text

- .chars_at(cursor_fwd.anchor)

- .take_while(|&c| !char_is_word(c))

- .count();

- words.push(cursor_fwd);

- if words.len() == jump_label_limit {

- break 'outer;

- }

- break;

- }

- while cursor_rev.head > start {

- cursor_rev = movement::move_prev_word_start(text, cursor_rev, 1);

- // The cursor is on a word that is atleast two graphemes long and

- // madeup of word characters. The latter condition is needed because

- // move_prev_word_start simply treats a sequence of characters from

- // the same char class as a word so `=<` would also count as a word.

- let add_label = text

- .slice(cursor_rev.head..)

- .graphemes()

- .take(2)

- .take_while(|g| g.chars().all(char_is_word))

- .count()

- == 2;

- if !add_label {

- continue;

- }

- changed = true;

- cursor_rev.anchor -= text

- .chars_at(cursor_rev.anchor)

- .reversed()

- .take_while(|&c| !char_is_word(c))

- .count();

- words.push(cursor_rev);

- if words.len() == jump_label_limit {

- break 'outer;

- }

- break;

- }

- if !changed {

- break;

- }

- }

- jump_to_label(cx, words, behaviour)

-}

-

-fn lsp_or_syntax_symbol_picker(cx: &mut Context) {

- let doc = doc!(cx.editor);

-

- if doc

- .language_servers_with_feature(LanguageServerFeature::DocumentSymbols)

- .next()

- .is_some()

- {

- lsp::symbol_picker(cx);

- } else if doc.syntax().is_some() {

- syntax_symbol_picker(cx);

- } else {

- cx.editor

- .set_error("No language server supporting document symbols or syntax info available");

- }

-}

-

-fn lsp_or_syntax_workspace_symbol_picker(cx: &mut Context) {

- let doc = doc!(cx.editor);

-

- if doc

- .language_servers_with_feature(LanguageServerFeature::WorkspaceSymbols)

- .next()

- .is_some()

- {

- lsp::workspace_symbol_picker(cx);

- } else {

- syntax_workspace_symbol_picker(cx);

- }

-}