-pub(crate) mod syntax;

-pub use syntax::*;

-use tui::{

- text::{Span, Spans},

- widgets::Cell,

-};

- command_line::{self, Args},

- graphemes::{self, next_grapheme_boundary},

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

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

- args: String,

- if let Err(e) =

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

- {

- } else {

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

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

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

- }

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

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

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

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

- .fragments(text)

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

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

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

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

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

- }

- 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

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

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

- &loader,

- &config.indent_heuristic,

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

- // pos -> beginning of reference line,

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

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

- 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 continue_comment_token = continue_comment_tokens

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

- last_pos = pos;

- &loader,

- &config.indent_heuristic,

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

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

- new_text.push_str(line_ending);

- new_text

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

- new_text.push_str(line_ending);

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

-

- local_offs as isize - chars_deleted as isize,

- new_text.push_str(line_ending);

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

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

-

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

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

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

- .ok()

- .flatten()

- .unwrap_or_default();

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

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

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

- });

- if !input.ends_with("\n") && output.ends_with('\n') {

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

- })

-}

-

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

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

- if alphabet.is_empty() {

- return;

- }

-

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

- }

-}