-pub(crate) mod syntax;

- path::{self, find_paths},

-pub use syntax::*;

-use tui::{

- text::{Span, Spans},

- widgets::Cell,

-};

- command_line::{self, Args},

- graphemes::{self, next_grapheme_boundary},

- increment,

- indent::{self, IndentStyle},

- selection, surround,

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

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

- Selection, SmallVec, Syntax, Tendril, Transaction,

- expansion,

- char::{ToLowercase, ToUppercase},

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

-pub enum OnKeyCallbackKind {

- PseudoPending,

- Fallback,

-}

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

-impl Context<'_> {

- 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,

- 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",

- 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",

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

- 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",

- 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",

- extend_to_last_line, "Extend to last line",

- goto_column, "Goto column",

- extend_to_column, "Extend to column",

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

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

- 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_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,

- })

- 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)

-}

-

- 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(..);

- // 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()]

- .fragments(text)

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

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

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

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

-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)

-}

-

- let text: Tendril = doc

- .text()

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

- .graphemes()

- .map(|_g| ch)

- .collect();

-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))

- 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);

- 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,

- } else {

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

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

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

- 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 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 regex = match cx.editor.registers.first(register, cx.editor) {

- directory_style: Style,

- number_style: Style,

- colon_style: Style,

- 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"),

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

-

- 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),

- ]))

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

- // in this case a continuous buffer is required

- let values: Vec<String> = selection.fragments(text).map(Cow::into_owned).collect();

- let reg_name = cx

- .register

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

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

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

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

- 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)));

- }

-}

-

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

- .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))

- args: String::new(),

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

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

- }

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

- &loader,

- 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);

- push_jump(view, doc);

- push_jump(view, doc);

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

- push_jump(view, doc);

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

- push_jump(view, doc);

- push_jump(view, doc);

- push_jump(view, doc);

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

- if doc.active_snippet.is_some() {

- goto_next_tabstop(cx);

- } else {

- move_parent_node_end(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)

- (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),

- );

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

- yank_joined_impl(

- cx.editor,

- separator,

- cx.register

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

- );

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

-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);

- replace_with_yanked_impl(

- cx.editor,

- cx.register

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

- cx.count(),

- );

- 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))

- drop(values);

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

- cx.register

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

- cx.register

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

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

- .ok()

- .flatten()

- .unwrap_or_default();

- 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);

- }

- }

- } else {

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

-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),

- );

- // 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);

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

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

- 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;

- cx.register

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

-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);

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

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

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

- push_jump(view, doc);

-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)

-}

-

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

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

- return range;

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

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

- ("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;

- });

-

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

- "Surround selections with",

- &SURROUND_HELP_TEXT[1..],

- ));

- cx.editor.autoinfo = None;

- cx.editor.autoinfo = None;

-

- 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;

- });

-

- 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));

- });

- 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 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

-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)

- })

-}

-

-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);

- }

- })

- }

-}

-

- let s = keys

- .into_iter()

- .map(|key| {

- let s = key.to_string();

- if s.chars().count() == 1 {

- s

- } else {

- format!("<{}>", s)

- }

- })

- .collect::<String>();

- match cx.editor.registers.write(reg, vec![s]) {

- .filter(|_| event.modifiers.is_empty())

- .filter(|_| event.modifiers.is_empty())

- if alphabet.is_empty() {

- return;

- }

-

- let start = text.line_to_char(text.char_to_line(doc.view_offset(view.id).anchor));

- // single grapheme words need a special case

- let add_label = text

- .slice(..cursor_fwd.head)

- .graphemes_rev()

- let add_label = text

- .slice(cursor_rev.head..)

- .graphemes()

-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);

- }