use std::fmt::Write;

use std::io::BufReader;

use crate::job::Job;

use super::*;

use helix_core::fuzzy::fuzzy_match;

use helix_core::indent::MAX_INDENT;

use helix_stdx::path::home_dir;

use helix_view::document::{read_to_string, DEFAULT_LANGUAGE_NAME};

use helix_view::editor::{CloseError, ConfigEvent};

use serde_json::Value;

use ui::completers::{self, Completer};

pub aliases: &'static [&'static str],

pub doc: &'static str,

// params, flags, helper, completer

/// What completion methods, if any, does this command have?

}

impl TypableCommand {

fn completer_for_argument_number(&self, n: usize) -> &Completer {

Some(completer) => completer,

}

}

}

#[derive(Clone)]

// Arguments with specific completion methods based on their position.

positional_args: &'static [Completer],

var_args: Completer,

}

const fn none() -> Self {

Self {

positional_args: &[],

}

}

log::debug!("quitting...");

if event != PromptEvent::Validate {

return Ok(());

}

// last view and we have unsaved changes

if cx.editor.tree.views().count() == 1 {

buffers_remaining_impl(cx.editor)?

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

cx.block_try_flush_writes()?;

cx.editor.close(view!(cx.editor).id);

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

for arg in args {

let path = helix_stdx::path::expand_tilde(path);

// If the path is a directory, open a file picker on that directory and update the status

// message

Ok(())

}

// No arguments implies current document

if args.is_empty() {

let doc_id = view!(editor).doc;

fn buffer_close(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn force_buffer_close(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn buffer_close_others(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn force_buffer_close_others(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn buffer_close_all(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn force_buffer_close_all(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn buffer_next(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn buffer_previous(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

Ok(())

}

let config = cx.editor.config();

let jobs = &mut cx.jobs;

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

if config.insert_final_newline {

insert_final_newline(doc, view.id);

}

}

if event != PromptEvent::Validate {

return Ok(());

}

write_impl(cx, args.first(), false)

}

if event != PromptEvent::Validate {

return Ok(());

}

fn write_buffer_close(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn force_write_buffer_close(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

buffer_close_by_ids_impl(cx, &document_ids, false)

}

if event != PromptEvent::Validate {

return Ok(());

}

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

fn set_indent_style(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

// Attempt to parse argument as an indent style.

let style = match args.first() {

Some(arg) if "tabs".starts_with(&arg.to_lowercase()) => Some(Tabs),

Some(arg) => arg

.parse::<u8>()

.ok()

/// Sets or reports the current document's line ending setting.

fn set_line_ending(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

write_impl(cx, args.first(), false)?;

cx.block_try_flush_writes()?;

}

fn force_write_quit(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

write_impl(cx, args.first(), true)?;

cx.block_try_flush_writes()?;

}

/// Results in an error if there are modified buffers remaining and sets editor

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

fn force_write_all(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn write_all_quit(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn force_write_all_quit(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

fn force_quit_all(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

quit_all_impl(cx, true)

}

if event != PromptEvent::Validate {

return Ok(());

}

quit_all_impl(cx, false)

}

if event != PromptEvent::Validate {

return Ok(());

}

quit_all_impl(cx, true)

}

let true_color = cx.editor.config.load().true_color || crate::true_color();

match event {

PromptEvent::Abort => {

fn yank_main_selection_to_clipboard(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

let doc = doc!(cx.editor);

let default_sep = Cow::Borrowed(doc.line_ending.as_str());

let separator = args.first().unwrap_or(&default_sep);

fn yank_joined_to_clipboard(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn yank_main_selection_to_primary_clipboard(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn yank_joined_to_primary_clipboard(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn paste_clipboard_after(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn paste_clipboard_before(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn paste_primary_clipboard_after(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn paste_primary_clipboard_before(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn replace_selections_with_clipboard(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn replace_selections_with_primary_clipboard(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn show_clipboard_provider(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn change_current_directory(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn show_current_directory(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

/// Sets the [`Document`]'s encoding..

fn set_encoding(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

/// Shows info about the character under the primary cursor.

fn get_character_info(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

}

/// Reload the [`Document`] from its source file.

if event != PromptEvent::Validate {

return Ok(());

}

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

}

/// Update the [`Document`] if it has been modified.

if event != PromptEvent::Validate {

return Ok(());

}

fn lsp_workspace_command(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

};

cx.jobs.callback(callback);

} else {

let matches: Vec<_> = ls_id_commands

.filter(|(_ls_id, c)| *c == &command)

.collect();

match matches.as_slice() {

[(ls_id, _command)] => {

execute_lsp_command(

cx.editor,

*ls_id,

helix_lsp::lsp::Command {

title: command.clone(),

command,

},

);

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

}

}

if event != PromptEvent::Validate {

return Ok(());

}

fn tree_sitter_scopes(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn tree_sitter_highlight_name(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

fn find_highlight_at_cursor(

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

let name = match args.len() {

0 => None,

_ => Some(args.remove(0)),

fn debug_remote(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

return Ok(());

}

let address = match args.len() {

0 => None,

_ => Some(args.remove(0).parse()?),

dap_start_impl(cx, name.as_deref(), address, Some(args))

}

if event != PromptEvent::Validate {

return Ok(());

}

}

}

cx.editor.last_selection.get_or_insert_with(|| {

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

doc.selection(view.id).clone()

pub(super) fn goto_line_number(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

match event {

PromptEvent::Abort => abort_goto_line_number_preview(cx),

PromptEvent::Validate => {

// If we are invoked directly via a keybinding, Validate is

// sent without any prior Update events. Ensure the cursor

// is moved to the appropriate location.

}

// Fetch the current value of a config option and output as status.

if event != PromptEvent::Validate {

return Ok(());

}

let key = &args[0].to_lowercase();

let key_error = || anyhow::anyhow!("Unknown key `{}`", key);

/// Change config at runtime. Access nested values by dot syntax, for

/// example to disable smart case search, use `:set search.smart-case false`.

if event != PromptEvent::Validate {

return Ok(());

}

let key_error = || anyhow::anyhow!("Unknown key `{}`", key);

let field_error = |_| anyhow::anyhow!("Could not parse field `{}`", arg);

/// case`.

fn toggle_option(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

return Ok(());

}

let key = &args[0].to_lowercase();

let key_error = || anyhow::anyhow!("Unknown key `{}`", key);

Value::Bool(ref value) => {

ensure!(

args.len() == 1,

);

Value::Bool(!value)

}

Value::String(ref value) => {

ensure!(

);

Value::String(

.iter()

.skip_while(|e| *e != value)

.nth(1)

.to_string(),

)

}

ensure!(

);

}

};

let status = format!("'{key}' is now set to {value}");

let config = serde_json::from_value(config)

cx.editor

.config_events

}

/// Change the language of the current buffer at runtime.

if event != PromptEvent::Validate {

return Ok(());

}

return Ok(());

}

let doc = doc_mut!(cx.editor);

doc.set_language(None, None)

} else {

doc.set_language_by_language_id(&args[0], cx.editor.syn_loader.clone())?;

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

}

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

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

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

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

fn tree_sitter_subtree(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn open_config(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn open_workspace_config(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

fn refresh_config(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn append_output(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

return Ok(());

}

shell(cx, &args.join(" "), &ShellBehavior::Append);

Ok(())

}

fn insert_output(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

return Ok(());

}

shell(cx, &args.join(" "), &ShellBehavior::Insert);

Ok(())

}

pipe_impl(cx, args, event, &ShellBehavior::Ignore)

}

pipe_impl(cx, args, event, &ShellBehavior::Replace)

}

fn pipe_impl(

cx: &mut compositor::Context,

event: PromptEvent,

behavior: &ShellBehavior,

) -> anyhow::Result<()> {

return Ok(());

}

shell(cx, &args.join(" "), behavior);

Ok(())

}

fn run_shell_command(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

fn reset_diff_change(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

return Ok(());

}

let editor = &mut cx.editor;

let scrolloff = editor.config().scrolloff;

fn clear_register(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

return Ok(());

}

if args.is_empty() {

cx.editor.registers.clear();

cx.editor.set_status("All registers cleared");

ensure!(

args[0].chars().count() == 1,

);

let register = args[0].chars().next().unwrap_or_default();

if cx.editor.registers.remove(register) {

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

let doc = doc!(cx.editor);

let old_path = doc

.path()

fn yank_diagnostic(

cx: &mut compositor::Context,

event: PromptEvent,

) -> anyhow::Result<()> {

if event != PromptEvent::Validate {

Ok(())

}

if event != PromptEvent::Validate {

return Ok(());

}

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

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

let filename = args.first().unwrap();

let path = helix_stdx::path::expand_tilde(PathBuf::from(filename.to_string()));

Ok(())

}

pub const TYPABLE_COMMAND_LIST: &[TypableCommand] = &[

TypableCommand {

name: "quit",

aliases: &["q"],

doc: "Close the current view.",

fun: quit,

},

TypableCommand {

name: "quit!",

aliases: &["q!"],

doc: "Force close the current view, ignoring unsaved changes.",

fun: force_quit,

},

TypableCommand {

name: "open",

aliases: &["o", "edit", "e"],

doc: "Open a file from disk into the current view.",

fun: open,

},

TypableCommand {

name: "buffer-close",

aliases: &["bc", "bclose"],

doc: "Close the current buffer.",

fun: buffer_close,

},

TypableCommand {

name: "buffer-close!",

aliases: &["bc!", "bclose!"],

doc: "Close the current buffer forcefully, ignoring unsaved changes.",

fun: force_buffer_close,

},

TypableCommand {

name: "buffer-close-others",

aliases: &["bco", "bcloseother"],

doc: "Close all buffers but the currently focused one.",

fun: buffer_close_others,

},

TypableCommand {

name: "buffer-close-others!",

aliases: &["bco!", "bcloseother!"],

doc: "Force close all buffers but the currently focused one.",

fun: force_buffer_close_others,

},

TypableCommand {

name: "buffer-close-all",

aliases: &["bca", "bcloseall"],

doc: "Close all buffers without quitting.",

fun: buffer_close_all,

},

TypableCommand {

name: "buffer-close-all!",

aliases: &["bca!", "bcloseall!"],

doc: "Force close all buffers ignoring unsaved changes without quitting.",

fun: force_buffer_close_all,

},

TypableCommand {

name: "buffer-next",

aliases: &["bn", "bnext"],

doc: "Goto next buffer.",

fun: buffer_next,

},

TypableCommand {

name: "buffer-previous",

aliases: &["bp", "bprev"],

doc: "Goto previous buffer.",

fun: buffer_previous,

},

TypableCommand {

name: "write",

aliases: &["w"],

doc: "Write changes to disk. Accepts an optional path (:write some/path.txt)",

fun: write,

},

TypableCommand {

name: "write!",

aliases: &["w!"],

doc: "Force write changes to disk creating necessary subdirectories. Accepts an optional path (:write! some/path.txt)",

fun: force_write,

},

TypableCommand {

name: "write-buffer-close",

aliases: &["wbc"],

doc: "Write changes to disk and closes the buffer. Accepts an optional path (:write-buffer-close some/path.txt)",

fun: write_buffer_close,

},

TypableCommand {

name: "write-buffer-close!",

aliases: &["wbc!"],

doc: "Force write changes to disk creating necessary subdirectories and closes the buffer. Accepts an optional path (:write-buffer-close! some/path.txt)",

fun: force_write_buffer_close,

},

TypableCommand {

name: "new",

aliases: &["n"],

doc: "Create a new scratch buffer.",

fun: new_file,

},

TypableCommand {

name: "format",

aliases: &["fmt"],

doc: "Format the file using an external formatter or language server.",

fun: format,

},

TypableCommand {

name: "indent-style",

aliases: &[],

doc: "Set the indentation style for editing. ('t' for tabs or 1-16 for number of spaces.)",

fun: set_indent_style,

},

TypableCommand {

name: "line-ending",

#[cfg(feature = "unicode-lines")]

doc: "Set the document's default line ending. Options: crlf, lf, cr, ff, nel.",

fun: set_line_ending,

},

TypableCommand {

name: "earlier",

aliases: &["ear"],

doc: "Jump back to an earlier point in edit history. Accepts a number of steps or a time span.",

fun: earlier,

},

TypableCommand {

name: "later",

aliases: &["lat"],

doc: "Jump to a later point in edit history. Accepts a number of steps or a time span.",

fun: later,

},

TypableCommand {

name: "write-quit",

aliases: &["wq", "x"],

doc: "Write changes to disk and close the current view. Accepts an optional path (:wq some/path.txt)",

fun: write_quit,

},

TypableCommand {

name: "write-quit!",

aliases: &["wq!", "x!"],

doc: "Write changes to disk and close the current view forcefully. Accepts an optional path (:wq! some/path.txt)",

fun: force_write_quit,

},

TypableCommand {

name: "write-all",

aliases: &["wa"],

doc: "Write changes from all buffers to disk.",

fun: write_all,

},

TypableCommand {

name: "write-all!",

aliases: &["wa!"],

doc: "Forcefully write changes from all buffers to disk creating necessary subdirectories.",

fun: force_write_all,

},

TypableCommand {

name: "write-quit-all",

aliases: &["wqa", "xa"],

doc: "Write changes from all buffers to disk and close all views.",

fun: write_all_quit,

},

TypableCommand {

name: "write-quit-all!",

aliases: &["wqa!", "xa!"],

doc: "Write changes from all buffers to disk and close all views forcefully (ignoring unsaved changes).",

fun: force_write_all_quit,

},

TypableCommand {

name: "quit-all",

aliases: &["qa"],

doc: "Close all views.",

fun: quit_all,

},

TypableCommand {

name: "quit-all!",

aliases: &["qa!"],

doc: "Force close all views ignoring unsaved changes.",

fun: force_quit_all,

},

TypableCommand {

name: "cquit",

aliases: &["cq"],

doc: "Quit with exit code (default 1). Accepts an optional integer exit code (:cq 2).",

fun: cquit,

},

TypableCommand {

name: "cquit!",

aliases: &["cq!"],

doc: "Force quit with exit code (default 1) ignoring unsaved changes. Accepts an optional integer exit code (:cq! 2).",

fun: force_cquit,

},

TypableCommand {

name: "theme",

aliases: &[],

doc: "Change the editor theme (show current theme if no name specified).",

fun: theme,

},

TypableCommand {

name: "yank-join",

aliases: &[],

doc: "Yank joined selections. A separator can be provided as first argument. Default value is newline.",

fun: yank_joined,

},

TypableCommand {

name: "clipboard-yank",

aliases: &[],

doc: "Yank main selection into system clipboard.",

fun: yank_main_selection_to_clipboard,

},

TypableCommand {

name: "clipboard-yank-join",

aliases: &[],

doc: "Yank joined selections into system clipboard. A separator can be provided as first argument. Default value is newline.", // FIXME: current UI can't display long doc.

fun: yank_joined_to_clipboard,

},

TypableCommand {

name: "primary-clipboard-yank",

aliases: &[],

doc: "Yank main selection into system primary clipboard.",

fun: yank_main_selection_to_primary_clipboard,

},

TypableCommand {

name: "primary-clipboard-yank-join",

aliases: &[],

doc: "Yank joined selections into system primary clipboard. A separator can be provided as first argument. Default value is newline.", // FIXME: current UI can't display long doc.

fun: yank_joined_to_primary_clipboard,

},

TypableCommand {

name: "clipboard-paste-after",

aliases: &[],

doc: "Paste system clipboard after selections.",

fun: paste_clipboard_after,

},

TypableCommand {

name: "clipboard-paste-before",

aliases: &[],

doc: "Paste system clipboard before selections.",

fun: paste_clipboard_before,

},

TypableCommand {

name: "clipboard-paste-replace",

aliases: &[],

doc: "Replace selections with content of system clipboard.",

fun: replace_selections_with_clipboard,

},

TypableCommand {

name: "primary-clipboard-paste-after",

aliases: &[],

doc: "Paste primary clipboard after selections.",

fun: paste_primary_clipboard_after,

},

TypableCommand {

name: "primary-clipboard-paste-before",

aliases: &[],

doc: "Paste primary clipboard before selections.",

fun: paste_primary_clipboard_before,

},

TypableCommand {

name: "primary-clipboard-paste-replace",

aliases: &[],

doc: "Replace selections with content of system primary clipboard.",

fun: replace_selections_with_primary_clipboard,

},

TypableCommand {

name: "show-clipboard-provider",

aliases: &[],

doc: "Show clipboard provider name in status bar.",

fun: show_clipboard_provider,

},

TypableCommand {

name: "change-current-directory",

aliases: &["cd"],

doc: "Change the current working directory.",

fun: change_current_directory,

},

TypableCommand {

name: "show-directory",

aliases: &["pwd"],

doc: "Show the current working directory.",

fun: show_current_directory,

},

TypableCommand {

name: "encoding",

aliases: &[],

doc: "Set encoding. Based on `https://encoding.spec.whatwg.org`.",

fun: set_encoding,

},

TypableCommand {

name: "character-info",

aliases: &["char"],

doc: "Get info about the character under the primary cursor.",

fun: get_character_info,

},

TypableCommand {

name: "reload",

aliases: &["rl"],

doc: "Discard changes and reload from the source file.",

fun: reload,

},

TypableCommand {

name: "reload-all",

aliases: &["rla"],

doc: "Discard changes and reload all documents from the source files.",

fun: reload_all,

},

TypableCommand {

name: "update",

aliases: &["u"],

doc: "Write changes only if the file has been modified.",

fun: update,

},

TypableCommand {

name: "lsp-workspace-command",

aliases: &[],

doc: "Open workspace command picker",

fun: lsp_workspace_command,

},

TypableCommand {

name: "lsp-restart",

aliases: &[],

doc: "Restarts the given language servers, or all language servers that are used by the current file if no arguments are supplied",

fun: lsp_restart,

},

TypableCommand {

name: "lsp-stop",

aliases: &[],

doc: "Stops the given language servers, or all language servers that are used by the current file if no arguments are supplied",

fun: lsp_stop,

},

TypableCommand {

name: "tree-sitter-scopes",

aliases: &[],

doc: "Display tree sitter scopes, primarily for theming and development.",

fun: tree_sitter_scopes,

},

TypableCommand {

name: "tree-sitter-highlight-name",

aliases: &[],

doc: "Display name of tree-sitter highlight scope under the cursor.",

fun: tree_sitter_highlight_name,

},

TypableCommand {

name: "debug-start",

aliases: &["dbg"],

doc: "Start a debug session from a given template with given parameters.",

fun: debug_start,

},

TypableCommand {

name: "debug-remote",

aliases: &["dbg-tcp"],

doc: "Connect to a debug adapter by TCP address and start a debugging session from a given template with given parameters.",

fun: debug_remote,

},

TypableCommand {

name: "debug-eval",

aliases: &[],

doc: "Evaluate expression in current debug context.",

fun: debug_eval,

},

TypableCommand {

name: "vsplit",

aliases: &["vs"],

doc: "Open the file in a vertical split.",

fun: vsplit,

},

TypableCommand {

name: "vsplit-new",

aliases: &["vnew"],

doc: "Open a scratch buffer in a vertical split.",

fun: vsplit_new,

},

TypableCommand {

name: "hsplit",

aliases: &["hs", "sp"],

doc: "Open the file in a horizontal split.",

fun: hsplit,

},

TypableCommand {

name: "hsplit-new",

aliases: &["hnew"],

doc: "Open a scratch buffer in a horizontal split.",

fun: hsplit_new,

},

TypableCommand {

name: "tutor",

aliases: &[],

doc: "Open the tutorial.",

fun: tutor,

},

TypableCommand {

name: "goto",

aliases: &["g"],

doc: "Goto line number.",

fun: goto_line_number,

},

TypableCommand {

name: "set-language",

aliases: &["lang"],

doc: "Set the language of current buffer (show current language if no value specified).",

fun: language,

},

TypableCommand {

name: "set-option",

doc: "Set a config option at runtime.\nFor example to disable smart case search, use `:set search.smart-case false`.",

fun: set_option,

// TODO: Add support for completion of the options value(s), when appropriate.

},

TypableCommand {

name: "toggle-option",

aliases: &["toggle"],

fun: toggle_option,

},

TypableCommand {

name: "get-option",

aliases: &["get"],

doc: "Get the current value of a config option.",

fun: get_option,

},

TypableCommand {

name: "sort",

aliases: &[],

doc: "Sort ranges in selection.",

fun: sort,

},

TypableCommand {

name: "reflow",

aliases: &[],

doc: "Hard-wrap the current selection of lines to a given width.",

fun: reflow,

},

TypableCommand {

name: "tree-sitter-subtree",

aliases: &["ts-subtree"],

doc: "Display the smallest tree-sitter subtree that spans the primary selection, primarily for debugging queries.",

fun: tree_sitter_subtree,

},

TypableCommand {

name: "config-reload",

aliases: &[],

doc: "Refresh user config.",

fun: refresh_config,

},

TypableCommand {

name: "config-open",

aliases: &[],

doc: "Open the user config.toml file.",

fun: open_config,

},

TypableCommand {

name: "config-open-workspace",

aliases: &[],

doc: "Open the workspace config.toml file.",

fun: open_workspace_config,

},

TypableCommand {

name: "log-open",

aliases: &[],

doc: "Open the helix log file.",

fun: open_log,

},

TypableCommand {

name: "insert-output",

aliases: &[],

doc: "Run shell command, inserting output before each selection.",

fun: insert_output,

},

TypableCommand {

name: "append-output",

aliases: &[],

doc: "Run shell command, appending output after each selection.",

fun: append_output,

},

TypableCommand {

name: "pipe",

aliases: &[],

doc: "Pipe each selection to the shell command.",

fun: pipe,

},

TypableCommand {

name: "pipe-to",

aliases: &[],

doc: "Pipe each selection to the shell command, ignoring output.",

fun: pipe_to,

},

TypableCommand {

name: "run-shell-command",

aliases: &["sh"],

doc: "Run a shell command",

fun: run_shell_command,

},

TypableCommand {

name: "reset-diff-change",

aliases: &["diffget", "diffg"],

doc: "Reset the diff change at the cursor position.",

fun: reset_diff_change,

},

TypableCommand {

name: "clear-register",

aliases: &[],

doc: "Clear given register. If no argument is provided, clear all registers.",

fun: clear_register,

},

TypableCommand {

name: "redraw",

aliases: &[],

doc: "Clear and re-render the whole UI",

fun: redraw,

},

TypableCommand {

name: "move",

aliases: &["mv"],

doc: "Move the current buffer and its corresponding file to a different path",

fun: move_buffer,

},

TypableCommand {

name: "yank-diagnostic",

aliases: &[],

doc: "Yank diagnostic(s) under primary cursor to register, or clipboard by default",

fun: yank_diagnostic,

},

TypableCommand {

name: "read",

aliases: &["r"],

doc: "Load a file into buffer",

fun: read,

},

];

.collect()

});

#[allow(clippy::unnecessary_unwrap)]

pub(super) fn command_mode(cx: &mut Context) {

let mut prompt = Prompt::new(

":".into(),

Some(':'),

} else {

.into_iter()

.collect()

}

}

}

}

}

}

}