+ comment, coords_at_pos, find_first_non_whitespace_char, find_root, graphemes, indent,

+ indent::IndentStyle,

+ line_ending::{get_line_ending_of_str, line_end_char_index, str_is_line_ending},

+ movement::{self, Direction},

+ regex::{self, Regex, RegexBuilder},

+ register::Register,

+ search, selection, surround, textobject, LineEnding, Position, Range, Rope, RopeGraphemes,

+ RopeSlice, Selection, SmallVec, Tendril, Transaction,

+

+ clipboard::ClipboardType, document::Mode, editor::Action, input::KeyEvent, keyboard::KeyCode,

+ view::View, Document, DocumentId, Editor, ViewId,

+use anyhow::{anyhow, bail, Context as _};

+use helix_lsp::{

+ lsp,

+ util::{lsp_pos_to_pos, lsp_range_to_range, pos_to_lsp_pos, range_to_lsp_range},

+ OffsetEncoding,

+};

+ ui::{self, FilePicker, Picker, Popup, Prompt, PromptEvent},

+use crate::job::{self, Job, Jobs};

+use futures_util::{FutureExt, StreamExt};

+use std::num::NonZeroUsize;

+use std::{fmt, future::Future};

+use tokio_stream::wrappers::UnboundedReceiverStream;

+ pub callback: Option<crate::compositor::Callback>,

+ pub on_next_key_callback: Option<Box<dyn FnOnce(&mut Context, KeyEvent)>>,

+impl<'a> Context<'a> {

+ self.callback = Some(Box::new(|compositor: &mut Compositor| {

+ compositor.push(component)

+ }));

+ self.on_next_key_callback = Some(Box::new(on_next_key_callback));

+ call: impl Future<Output = helix_lsp::Result<serde_json::Value>> + 'static + Send,

+ T: for<'de> serde::Deserialize<'de> + Send + 'static,

+ let callback = Box::pin(async move {

+ let json = call.await?;

+ let response = serde_json::from_value(json)?;

+ let call: job::Callback =

+ Box::new(move |editor: &mut Editor, compositor: &mut Compositor| {

+ callback(editor, compositor, response)

+ });

+ Ok(call)

+ });

+ self.jobs.callback(callback);

+}

+enum Align {

+ Top,

+ Center,

+ Bottom,

+fn align_view(doc: &Document, view: &mut View, align: Align) {

+ let pos = doc

+ .selection(view.id)

+ .primary()

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

+ let line = doc.text().char_to_line(pos);

+

+ let height = view.inner_area().height as usize;

+

+ let relative = match align {

+ Align::Center => height / 2,

+ Align::Top => 0,

+ Align::Bottom => height,

+ };

+

+ view.offset.row = line.saturating_sub(relative);

+}

+

+/// A command is composed of a static name, and a function that takes the current state plus a count,

+/// and does a side-effect on the state (usually by creating and applying a transaction).

+#[derive(Copy, Clone)]

+pub struct Command {

+ name: &'static str,

+ fun: fn(cx: &mut Context),

+ doc: &'static str,

+macro_rules! commands {

+ pub const $name: Self = Self {

+ pub const COMMAND_LIST: &'static [Self] = &[

+impl Command {

+ (self.fun)(cx);

+ pub fn name(&self) -> &'static str {

+ self.name

+ pub fn doc(&self) -> &'static str {

+ self.doc

+ commands!(

+ move_next_word_start, "Move to beginning of next word",

+ move_prev_word_start, "Move to beginning of previous word",

+ move_next_long_word_start, "Move to beginning of next long word",

+ move_prev_long_word_start, "Move to beginning of previous long word",

+ extend_next_word_start, "Extend to beginning of next word",

+ extend_prev_word_start, "Extend to beginning of previous word",

+ extend_next_long_word_start, "Extend to beginning of next long word",

+ extend_prev_long_word_start, "Extend to beginning of previous long word",

+ extend_next_word_end, "Extend to end of next word",

+ find_till_char, "Move till next occurance of char",

+ find_next_char, "Move to next occurance of char",

+ extend_till_char, "Extend till next occurance of char",

+ extend_next_char, "Extend to next occurance of char",

+ till_prev_char, "Move till previous occurance of char",

+ find_prev_char, "Move to previous occurance of char",

+ extend_till_prev_char, "Extend till previous occurance of char",

+ extend_prev_char, "Extend to previous occurance of char",

+ split_selection, "Split selection into subselections on regex matches",

+ global_search, "Global Search in workspace folder",

+ extend_line, "Select current line, if already selected, extend to next line",

+ extend_to_line_bounds, "Extend selection to line bounds (line-wise selection)",

+ change_selection, "Change selection (delete and enter insert mode)",

+ collapse_selection, "Collapse selection onto a single cursor",

+ append_mode, "Insert after selection (append)",

+ prepend_to_line, "Insert at start of line",

+ append_to_line, "Insert at end of line",

+ goto_file_start, "Goto file start/line",

+ goto_window_middle, "Goto window middle",

+ // TODO: different description ?

+ goto_line_end_newline, "Goto line end",

+ replace_selections_with_primary_clipboard, "Replace selections by primary clipboard content",

+ shell_pipe_to, "Pipe selections into shell command, ignoring command output",

+ shell_insert_output, "Insert output of shell command before each selection",

+ shell_append_output, "Append output of shell command after each selection",

+ suspend, "Suspend",

+impl fmt::Debug for Command {

+ let Command { name, .. } = self;

+ f.debug_tuple("Command").field(name).finish()

+impl fmt::Display for Command {

+ let Command { name, .. } = self;

+ f.write_str(name)

+impl std::str::FromStr for Command {

+ Command::COMMAND_LIST

+ .iter()

+ .copied()

+ .find(|cmd| cmd.name == s)

+ .ok_or_else(|| anyhow!("No command named '{}'", s))

+impl<'de> Deserialize<'de> for Command {

+impl PartialEq for Command {

+ self.name() == other.name()

+fn move_impl<F>(cx: &mut Context, move_fn: F, dir: Direction, behaviour: Movement)

+where

+ F: Fn(RopeSlice, Range, Direction, usize, Movement) -> Range,

+{

+ let selection = doc

+ .selection(view.id)

+ .clone()

+ .transform(|range| move_fn(text, range, dir, count, behaviour));

+ if doc.mode == Mode::Select {

+ if doc.mode == Mode::Select {

+ if doc.mode == Mode::Select {

+ if let Some(pos) = find_first_non_whitespace_char(text.line(line)) {

+ range.put_cursor(text, pos, doc.mode == Mode::Select)

+ let height = view.inner_area().height as usize;

+ let scrolloff = cx.editor.config.scrolloff.min(height.saturating_sub(1) / 2);

+ let last_line = view.last_line(doc);

+ let line = match align {

+ Align::Top => (view.offset.row + scrolloff),

+ Align::Center => (view.offset.row + (height / 2)),

+ Align::Bottom => last_line.saturating_sub(scrolloff),

+ }

+ .min(last_line.saturating_sub(scrolloff));

+ let pos = doc.text().line_to_char(line);

+ doc.set_selection(view.id, Selection::point(pos));

+fn goto_window_middle(cx: &mut Context) {

+ goto_line(cx);

+ push_jump(cx.editor);

+ doc.set_selection(view.id, Selection::point(0));

+ push_jump(cx.editor);

+ doc.set_selection(view.id, Selection::point(doc.text().len_chars()));

+#[inline]

+fn find_char_impl<F>(cx: &mut Context, search_fn: F, inclusive: bool, extend: bool)

+where

+ F: Fn(RopeSlice, char, usize, usize, bool) -> Option<usize> + 'static,

+{

+ } =>

+ // TODO: this isn't quite correct when CRLF is involved.

+ // This hack will work in most cases, since documents don't

+ // usually mix line endings. But we should fix it eventually

+ // anyway.

+ {

+ current!(cx.editor)

+ .1

+ .line_ending

+ .as_str()

+ .chars()

+ .next()

+ .unwrap()

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

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

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

+ // TODO: use `Range::cursor()` here instead. However, that works in terms of

+ // graphemes, whereas this function doesn't yet. So we're doing the same logic

+ // here, but just in terms of chars instead.

+ let search_start_pos = if range.anchor < range.head {

+ range.head - 1

+ range.head

+ };

+

+ search_fn(text, ch, search_start_pos, count, inclusive).map_or(range, |pos| {

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

+ })

+ find_char_impl(

+ cx,

+ find_next_char_impl,

+ false, /* inclusive */

+ false, /* extend */

+ )

+ find_char_impl(

+ cx,

+ find_next_char_impl,

+ true, /* inclusive */

+ false, /* extend */

+ )

+ find_char_impl(

+ cx,

+ find_next_char_impl,

+ false, /* inclusive */

+ true, /* extend */

+ )

+ find_char_impl(

+ cx,

+ find_next_char_impl,

+ true, /* inclusive */

+ true, /* extend */

+ )

+ find_char_impl(

+ cx,

+ find_prev_char_impl,

+ false, /* inclusive */

+ false, /* extend */

+ )

+ find_char_impl(

+ cx,

+ find_prev_char_impl,

+ true, /* inclusive */

+ false, /* extend */

+ )

+ find_char_impl(

+ cx,

+ find_prev_char_impl,

+ false, /* inclusive */

+ true, /* extend */

+ )

+ find_char_impl(

+ cx,

+ find_prev_char_impl,

+ true, /* inclusive */

+ true, /* extend */

+ )

+ let ch = match event {

+ } => Some(&ch.encode_utf8(&mut buf[..])[..]),

+ let text: String =

+ RopeGraphemes::new(doc.text().slice(range.from()..range.to()))

+ .map(|g| {

+ let cow: Cow<str> = g.into();

+ if str_is_line_ending(&cow) {

+ cow

+ } else {

+ ch.into()

+ }

+ })

+ .collect();

+

+ (range.from(), range.to(), Some(text.into()))

+ doc.append_changes_to_history(view.id);

+ F: Fn(Cow<str>) -> Tendril,

+ let text: Tendril = change_fn(range.fragment(doc.text().slice(..)));

+ doc.append_changes_to_history(view.id);

+ ch.to_uppercase().collect()

+ ch.to_lowercase().collect()

+ vec![ch]

+ switch_case_impl(cx, |string| string.to_uppercase().into());

+ switch_case_impl(cx, |string| string.to_lowercase().into());

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

+ let cursor = coords_at_pos(text, range.cursor(text));

+ let doc_last_line = doc.text().len_lines().saturating_sub(1);

+ let last_line = view.last_line(doc);

+ if direction == Backward && view.offset.row == 0

+ || direction == Forward && last_line == doc_last_line

+ {

+ let height = view.inner_area().height;

+

+ let scrolloff = cx.editor.config.scrolloff.min(height as usize / 2);

+

+ view.offset.row = match direction {

+ Forward => view.offset.row + offset,

+ Backward => view.offset.row.saturating_sub(offset),

+ .min(doc_last_line);

+

+ // recalculate last line

+ let last_line = view.last_line(doc);

+

+ // clamp into viewport

+ let line = cursor

+ .row

+ .max(view.offset.row + scrolloff)

+ .min(last_line.saturating_sub(scrolloff));

+ let head = pos_at_coords(text, Position::new(line, cursor.col), true); // this func will properly truncate to line end

+

+ let anchor = if doc.mode == Mode::Select {

+ // TODO: only manipulate main selection

+ doc.set_selection(view.id, Selection::single(anchor, head));

+ let offset = view.inner_area().height as usize;

+ scroll(cx, offset, Direction::Backward);

+ let offset = view.inner_area().height as usize;

+ scroll(cx, offset, Direction::Forward);

+ let offset = view.inner_area().height as usize / 2;

+ scroll(cx, offset, Direction::Backward);

+ let offset = view.inner_area().height as usize / 2;

+ scroll(cx, offset, Direction::Forward);

+ let head_pos = coords_at_pos(text, range.head);

+ let anchor_pos = coords_at_pos(text, range.anchor);

+ let anchor = pos_at_coords(text, Position::new(anchor_row, anchor_pos.col), true);

+ let head = pos_at_coords(text, Position::new(head_row, head_pos.col), true);

+ if coords_at_pos(text, anchor).col == anchor_pos.col

+ && coords_at_pos(text, head).col == head_pos.col

+ ranges.push(Range::new(anchor, head));

+ let prompt = ui::regex_prompt(

+ move |view, doc, regex, event| {

+ if event != PromptEvent::Update {

+

+ cx.push_layer(Box::new(prompt));

+ let prompt = ui::regex_prompt(

+ move |view, doc, regex, event| {

+ if event != PromptEvent::Update {

+

+ cx.push_layer(Box::new(prompt));

+ // only compile the regex once

+ #[allow(clippy::trivial_regex)]

+ static REGEX: Lazy<Regex> =

+ Lazy::new(|| Regex::new(r"\r\n|[\n\r\u{000B}\u{000C}\u{0085}\u{2028}\u{2029}]").unwrap());

+ let selection = selection::split_on_matches(text, doc.selection(view.id), &REGEX);

+fn search_impl(doc: &mut Document, view: &mut View, contents: &str, regex: &Regex, extend: bool) {

+ // Get the right side of the primary block cursor.

+ let start = text.char_to_byte(graphemes::next_grapheme_boundary(

+ text,

+ selection.primary().cursor(text),

+ ));

+ let mat = regex

+ .find_at(contents, start)

+ .or_else(|| regex.find(contents));

+ // TODO: message on wraparound

+ let selection = if extend {

+ selection.clone().push(Range::new(start, end))

+ } else {

+ Selection::single(start, end)

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

+// TODO: use one function for search vs extend

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

+ // HAXX: sadly we can't avoid allocating a single string for the whole buffer since we can't

+ // feed chunks into the regex yet

+ let contents = doc.text().slice(..).to_string();

+

+ let prompt = ui::regex_prompt(

+ move |view, doc, regex, event| {

+ if event != PromptEvent::Update {

+ search_impl(doc, view, &contents, &regex, false);

+

+ cx.push_layer(Box::new(prompt));

+fn search_next_impl(cx: &mut Context, extend: bool) {

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

+ let registers = &cx.editor.registers;

+ if let Some(query) = registers.read('/') {

+ let query = query.last().unwrap();

+ let contents = doc.text().slice(..).to_string();

+ let case_insensitive = if cx.editor.config.smart_case {

+ if let Ok(regex) = RegexBuilder::new(query)

+ .case_insensitive(case_insensitive)

+ .build()

+ search_impl(doc, view, &contents, &regex, extend);

+ // get around warning `mutable_borrow_reservation_conflict`

+ // which will be a hard error in the future

+ // see: https://github.com/rust-lang/rust/issues/59159

+ let query = query.clone();

+ cx.editor.set_error(format!("Invalid regex: {}", query));

+ search_next_impl(cx, false);

+ search_next_impl(cx, true);

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

+ let query = doc.selection(view.id).primary().fragment(contents);

+ let regex = regex::escape(&query);

+ cx.editor.registers.get_mut('/').push(regex);

+ let msg = format!("register '{}' set to '{}'", '\\', query);

+ cx.editor.set_status(msg);

+ let (all_matches_sx, all_matches_rx) =

+ tokio::sync::mpsc::unbounded_channel::<(usize, PathBuf)>();

+ let smart_case = cx.editor.config.smart_case;

+ let prompt = ui::regex_prompt(

+ cx,

+ "global search:".into(),

+ None,

+ move |_view, _doc, regex, event| {

+ if event != PromptEvent::Validate {

+ return;

+ if let Ok(matcher) = RegexMatcherBuilder::new()

+ .case_smart(smart_case)

+ .build(regex.as_str())

+ {

+ let searcher = SearcherBuilder::new()

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

+ .build();

+

+ let search_root = std::env::current_dir()

+ .expect("Global search error: Failed to get current dir");

+ WalkBuilder::new(search_root).build_parallel().run(|| {

+ let mut searcher_cl = searcher.clone();

+ let matcher_cl = matcher.clone();

+ let all_matches_sx_cl = all_matches_sx.clone();

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

+ let dent = match dent {

+ Ok(dent) => dent,

+ match dent.file_type() {

+ Some(fi) => {

+ if !fi.is_file() {

+ return WalkState::Continue;

+ }

+ }

+ None => return WalkState::Continue,

+ }

+ let result_sink = sinks::UTF8(|line_num, _| {

+ match all_matches_sx_cl

+ .send((line_num as usize - 1, dent.path().to_path_buf()))

+ {

+ Ok(_) => Ok(true),

+ Err(_) => Ok(false),

+ });

+ let result = searcher_cl.search_path(&matcher_cl, dent.path(), result_sink);

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

+ WalkState::Continue

+ } else {

+ // Otherwise do nothing

+ // log::warn!("Global Search Invalid Pattern")

+ }

+ },

+ );

+ cx.push_layer(Box::new(prompt));

+ let current_path = doc_mut!(cx.editor).path().cloned();

+ let show_picker = async move {

+ let all_matches: Vec<(usize, PathBuf)> =

+ UnboundedReceiverStream::new(all_matches_rx).collect().await;

+ let call: job::Callback =

+ Box::new(move |editor: &mut Editor, compositor: &mut Compositor| {

+ if all_matches.is_empty() {

+ editor.set_status("No matches found".to_string());

+ return;

+ }

+ let picker = FilePicker::new(

+ all_matches,

+ move |(_line_num, path)| {

+ let relative_path = helix_core::path::get_relative_path(path)

+ .to_str()

+ .unwrap()

+ .to_owned();

+ if current_path.as_ref().map(|p| p == path).unwrap_or(false) {

+ format!("{} (*)", relative_path).into()

+ } else {

+ relative_path.into()

+ }

+ },

+ move |editor: &mut Editor, (line_num, path), action| {

+ match editor.open(path.into(), action) {

+ Ok(_) => {}

+ Err(e) => {

+ editor.set_error(format!(

+ "Failed to open file '{}': {}",

+ path.display(),

+ e

+ ));

+ return;

+ }

+ }

+ let line_num = *line_num;

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

+ let text = doc.text();

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

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

+ },

+ |_editor, (line_num, path)| Some((path.clone(), Some((*line_num, *line_num)))),

+ );

+ compositor.push(Box::new(picker));

+ });

+ Ok(call)

+ cx.jobs.callback(show_picker);

+fn extend_line(cx: &mut Context) {

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

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

+ let start = text.line_to_char(start_line);

+ let mut end = text.line_to_char((end_line + count).min(text.len_lines()));

+ if range.from() == start && range.to() == end {

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

+ }

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

+ if range.anchor <= range.head {

+ Range::new(start, end)

+ } else {

+ Range::new(end, start)

+fn delete_selection_impl(reg: &mut Register, doc: &mut Document, view_id: ViewId) {

+ let selection = doc.selection(view_id);

+ // first yank the selection

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

+ reg.write(values);

+ // then delete

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

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

+ });

+ doc.apply(&transaction, view_id);

+ let reg_name = cx.register.unwrap_or('"');

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

+ let registers = &mut cx.editor.registers;

+ let reg = registers.get_mut(reg_name);

+ delete_selection_impl(reg, doc, view.id);

+ doc.append_changes_to_history(view.id);

+ // exit select mode, if currently in select mode

+ exit_select_mode(cx);

+fn change_selection(cx: &mut Context) {

+ let reg_name = cx.register.unwrap_or('"');

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

+ let registers = &mut cx.editor.registers;

+ let reg = registers.get_mut(reg_name);

+ delete_selection_impl(reg, doc, view.id);

+ enter_insert_mode(doc);

+ .transform(|range| Range::new(range.head, range.anchor));

+fn enter_insert_mode(doc: &mut Document) {

+ doc.mode = Mode::Insert;

+ enter_insert_mode(doc);

+ enter_insert_mode(doc);

+ let last_range = doc.selection(view.id).iter().last().unwrap();

+ if !last_range.is_empty() && last_range.head == end {

+ std::array::IntoIter::new([(end, end, Some(doc.line_ending.as_str().into()))]),

+mod cmd {

+ use super::*;

+ use std::collections::HashMap;

+

+ use helix_view::editor::Action;

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

+

+ #[derive(Clone)]

+ pub struct TypableCommand {

+ pub name: &'static str,

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

+ pub doc: &'static str,

+ // params, flags, helper, completer

+ pub fun: fn(&mut compositor::Context, &[&str], PromptEvent) -> anyhow::Result<()>,

+ pub completer: Option<Completer>,

+ fn quit(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ // last view and we have unsaved changes

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

+ buffers_remaining_impl(cx.editor)?

+ .close(view!(cx.editor).id, /* close_buffer */ false);

+

+ Ok(())

+ fn force_quit(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ cx.editor

+ .close(view!(cx.editor).id, /* close_buffer */ false);

+

+ Ok(())

+ fn open(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

+ use helix_core::path::expand_tilde;

+ let path = args.get(0).context("wrong argument count")?;

+ let _ = cx

+ .editor

+ .open(expand_tilde(Path::new(path)), Action::Replace)?;

+ Ok(())

+ fn write_impl<P: AsRef<Path>>(

+ cx: &mut compositor::Context,

+ path: Option<P>,

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

+ let jobs = &mut cx.jobs;

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

+ if let Some(path) = path {

+ doc.set_path(path.as_ref()).context("invalid filepath")?;

+ }

+ if doc.path().is_none() {

+ bail!("cannot write a buffer without a filename");

+ }

+ let fmt = doc.auto_format().map(|fmt| {

+ let shared = fmt.shared();

+ let callback = make_format_callback(

+ doc.id(),

+ doc.version(),

+ Modified::SetUnmodified,

+ shared.clone(),

+ jobs.callback(callback);

+ shared

+ });

+ let future = doc.format_and_save(fmt);

+ cx.jobs.add(Job::new(future).wait_before_exiting());

+ Ok(())

+ }

+

+ fn write(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

+ write_impl(cx, args.first())

+ }

+

+ fn new_file(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ cx.editor.new_file(Action::Replace);

+

+ Ok(())

+ }

+

+ fn format(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

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

+

+ if let Some(format) = doc.format() {

+ let callback =

+ make_format_callback(doc.id(), doc.version(), Modified::LeaveModified, format);

+ cx.jobs.callback(callback);

+ Ok(())

+ fn set_indent_style(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

+ use IndentStyle::*;

+

+ // If no argument, report current indent style.

+ if args.is_empty() {

+ let style = current!(cx.editor).1.indent_style;

+ cx.editor.set_status(match style {

+ Tabs => "tabs".into(),

+ Spaces(1) => "1 space".into(),

+ Spaces(n) if (2..=8).contains(&n) => format!("{} spaces", n),

+ _ => "error".into(), // Shouldn't happen.

+ });

+ return Ok(());

+ }

+ // Attempt to parse argument as an indent style.

+ let style = match args.get(0) {

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

+ Some(&"0") => Some(Tabs),

+ Some(arg) => arg

+ .parse::<u8>()

+ .ok()

+ .filter(|n| (1..=8).contains(n))

+ .map(Spaces),

+ _ => None,

+ };

+

+ let style = style.context("invalid indent style")?;

+ let doc = doc_mut!(cx.editor);

+ doc.indent_style = style;

+

+ Ok(())

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

+ fn set_line_ending(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

+ use LineEnding::*;

+

+ // If no argument, report current line ending setting.

+ if args.is_empty() {

+ let line_ending = current!(cx.editor).1.line_ending;

+ cx.editor.set_status(match line_ending {

+ Crlf => "crlf".into(),

+ LF => "line feed".into(),

+ FF => "form feed".into(),

+ CR => "carriage return".into(),

+ Nel => "next line".into(),

+

+ // These should never be a document's default line ending.

+ VT | LS | PS => "error".into(),

+ });

+

+ return Ok(());

+ }

+

+ let arg = args

+ .get(0)

+ .context("argument missing")?

+ .to_ascii_lowercase();

+

+ // Attempt to parse argument as a line ending.

+ let line_ending = match arg {

+ // We check for CR first because it shares a common prefix with CRLF.

+ arg if arg.starts_with("cr") => CR,

+ arg if arg.starts_with("crlf") => Crlf,

+ arg if arg.starts_with("lf") => LF,

+ arg if arg.starts_with("ff") => FF,

+ arg if arg.starts_with("nel") => Nel,

+ _ => bail!("invalid line ending"),

+ };

+

+ doc_mut!(cx.editor).line_ending = line_ending;

+ Ok(())

+ fn earlier(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

+ let uk = args

+ .join(" ")

+ .parse::<helix_core::history::UndoKind>()

+ .map_err(|s| anyhow!(s))?;

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

+ doc.earlier(view.id, uk);

+

+ Ok(())

+ fn later(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

+ let uk = args

+ .join(" ")

+ .parse::<helix_core::history::UndoKind>()

+ .map_err(|s| anyhow!(s))?;

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

+ doc.later(view.id, uk);

+ Ok(())

+ }

+ fn write_quit(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ event: PromptEvent,

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

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

+ quit(cx, &[], event)

+ fn force_write_quit(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ event: PromptEvent,

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

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

+ force_quit(cx, &[], event)

+ }

+

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

+ /// otherwise returns `Ok(())`

+ pub(super) fn buffers_remaining_impl(editor: &mut Editor) -> anyhow::Result<()> {

+ let modified: Vec<_> = editor

+ .documents()

+ .filter(|doc| doc.is_modified())

+ .map(|doc| {

+ doc.relative_path()

+ .map(|path| path.to_string_lossy().to_string())

+ .unwrap_or_else(|| "[scratch]".into())

+ })

+ .collect();

+ if !modified.is_empty() {

+ bail!(

+ "{} unsaved buffer(s) remaining: {:?}",

+ modified.len(),

+ modified

+ );

+ Ok(())

+ fn write_all_impl(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

+ quit: bool,

+ force: bool,

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

+ let mut errors = String::new();

+

+ // save all documents

+ for (_, doc) in &mut cx.editor.documents {

+ if doc.path().is_none() {

+ errors.push_str("cannot write a buffer without a filename\n");

+ continue;

+ }

+ // TODO: handle error.

+ let handle = doc.save();

+ cx.jobs.add(Job::new(handle).wait_before_exiting());

+ if quit {

+ if !force {

+ buffers_remaining_impl(cx.editor)?;

+ // close all views

+ let views: Vec<_> = cx.editor.tree.views().map(|(view, _)| view.id).collect();

+ for view_id in views {

+ cx.editor.close(view_id, false);

+ }

+ bail!(errors)

+ }

+

+ fn write_all(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ event: PromptEvent,

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

+ write_all_impl(cx, args, event, false, false)

+ }

+

+ fn write_all_quit(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ event: PromptEvent,

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

+ write_all_impl(cx, args, event, true, false)

+ }

+

+ fn force_write_all_quit(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ event: PromptEvent,

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

+ write_all_impl(cx, args, event, true, true)

+ }

+

+ fn quit_all_impl(

+ editor: &mut Editor,

+ _args: &[&str],

+ _event: PromptEvent,

+ force: bool,

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

+ if !force {

+ buffers_remaining_impl(editor)?;

+ }

+

+ // close all views

+ let views: Vec<_> = editor.tree.views().map(|(view, _)| view.id).collect();

+ for view_id in views {

+ editor.close(view_id, false);

+ }

+

+ Ok(())

+ }

+

+ fn quit_all(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ event: PromptEvent,

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

+ quit_all_impl(&mut cx.editor, args, event, false)

+ }

+

+ fn force_quit_all(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ event: PromptEvent,

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

+ quit_all_impl(&mut cx.editor, args, event, true)

+ }

+

+ fn theme(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

+ let theme = args.first().context("theme not provided")?;

+ cx.editor.set_theme_from_name(theme)

+ }

+

+ fn yank_main_selection_to_clipboard(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ yank_main_selection_to_clipboard_impl(&mut cx.editor, ClipboardType::Clipboard)

+ }

+

+ fn yank_joined_to_clipboard(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

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

+ let separator = args

+ .first()

+ .copied()

+ .unwrap_or_else(|| doc.line_ending.as_str());

+ yank_joined_to_clipboard_impl(&mut cx.editor, separator, ClipboardType::Clipboard)

+ }

+

+ fn yank_main_selection_to_primary_clipboard(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ yank_main_selection_to_clipboard_impl(&mut cx.editor, ClipboardType::Selection)

+ }

+

+ fn yank_joined_to_primary_clipboard(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

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

+ let separator = args

+ .first()

+ .copied()

+ .unwrap_or_else(|| doc.line_ending.as_str());

+ yank_joined_to_clipboard_impl(&mut cx.editor, separator, ClipboardType::Selection)

+ }

+

+ fn paste_clipboard_after(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ paste_clipboard_impl(&mut cx.editor, Paste::After, ClipboardType::Clipboard)

+ }

+

+ fn paste_clipboard_before(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ paste_clipboard_impl(&mut cx.editor, Paste::After, ClipboardType::Clipboard)

+ }

+

+ fn paste_primary_clipboard_after(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ paste_clipboard_impl(&mut cx.editor, Paste::After, ClipboardType::Selection)

+ }

+

+ fn paste_primary_clipboard_before(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ paste_clipboard_impl(&mut cx.editor, Paste::After, ClipboardType::Selection)

+ }

+

+ fn replace_selections_with_clipboard_impl(

+ cx: &mut compositor::Context,

+ clipboard_type: ClipboardType,

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

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

+

+ match cx.editor.clipboard_provider.get_contents(clipboard_type) {

+ Ok(contents) => {

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

+ let transaction =

+ Transaction::change_by_selection(doc.text(), selection, |range| {

+ (range.from(), range.to(), Some(contents.as_str().into()))

+ });

+

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

+ doc.append_changes_to_history(view.id);

+ Ok(())

+ Err(e) => Err(e.context("Couldn't get system clipboard contents")),

+ }

+ }

+

+ fn replace_selections_with_clipboard(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ replace_selections_with_clipboard_impl(cx, ClipboardType::Clipboard)

+ }

+ fn replace_selections_with_primary_clipboard(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ replace_selections_with_clipboard_impl(cx, ClipboardType::Selection)

+ fn show_clipboard_provider(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ .set_status(cx.editor.clipboard_provider.name().to_string());

+ Ok(())

+ fn change_current_directory(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

+ let dir = helix_core::path::expand_tilde(

+ args.first()

+ .context("target directory not provided")?

+ .as_ref(),

+ );

+

+ if let Err(e) = std::env::set_current_dir(dir) {

+ bail!("Couldn't change the current working directory: {}", e);

+ }

+

+ let cwd = std::env::current_dir().context("Couldn't get the new working directory")?;

+ cx.editor.set_status(format!(

+ "Current working directory is now {}",

+ cwd.display()

+ ));

+ Ok(())

+ }

+

+ fn show_current_directory(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

+ let cwd = std::env::current_dir().context("Couldn't get the new working directory")?;

+ cx.editor

+ .set_status(format!("Current working directory is {}", cwd.display()));

+ Ok(())

+ }

+

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

+ fn set_encoding(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

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

+ if let Some(label) = args.first() {

+ doc.set_encoding(label)

+ } else {

+ let encoding = doc.encoding().name().to_string();

+ cx.editor.set_status(encoding);

+ Ok(())

+ }

+ }

+

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

+ fn reload(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

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

+ doc.reload(view.id)

+ }

+

+ fn tree_sitter_scopes(

+ cx: &mut compositor::Context,

+ _args: &[&str],

+ _event: PromptEvent,

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

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

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

+

+ let pos = doc.selection(view.id).primary().cursor(text);

+ let scopes = indent::get_scopes(doc.syntax(), text, pos);

+ cx.editor.set_status(format!("scopes: {:?}", &scopes));

+ Ok(())

+ }

+

+ fn vsplit(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

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

+ let id = doc.id();

+

+ if let Some(path) = args.get(0) {

+ cx.editor.open(path.into(), Action::VerticalSplit)?;

+ } else {

+ cx.editor.switch(id, Action::VerticalSplit);

+ }

+

+ Ok(())

+ }

+ fn hsplit(

+ cx: &mut compositor::Context,

+ args: &[&str],

+ _event: PromptEvent,

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

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

+ let id = doc.id();

+

+ if let Some(path) = args.get(0) {

+ cx.editor.open(path.into(), Action::HorizontalSplit)?;

+ } else {

+ cx.editor.switch(id, Action::HorizontalSplit);

+ }

+

+ Ok(())

+ }

+

+ pub const TYPABLE_COMMAND_LIST: &[TypableCommand] = &[

+ TypableCommand {

+ name: "quit",

+ aliases: &["q"],

+ doc: "Close the current view.",

+ fun: quit,

+ completer: None,

+ TypableCommand {

+ name: "quit!",

+ aliases: &["q!"],

+ doc: "Close the current view.",

+ fun: force_quit,

+ completer: None,

+ TypableCommand {

+ name: "open",

+ aliases: &["o"],

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

+ fun: open,

+ completer: Some(completers::filename),

+ },

+ TypableCommand {

+ name: "write",

+ aliases: &["w"],

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

+ fun: write,

+ completer: Some(completers::filename),

+ },

+ TypableCommand {

+ name: "new",

+ aliases: &["n"],

+ doc: "Create a new scratch buffer.",

+ fun: new_file,

+ completer: Some(completers::filename),

+ },

+ TypableCommand {

+ name: "format",

+ aliases: &["fmt"],

+ doc: "Format the file using a formatter.",

+ fun: format,

+ completer: None,

+ },

+ TypableCommand {

+ name: "indent-style",

+ aliases: &[],

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

+ fun: set_indent_style,

+ completer: None,

+ },

+ TypableCommand {

+ name: "line-ending",

+ aliases: &[],

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

+ fun: set_line_ending,

+ completer: None,

+ },

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

+ completer: None,

+ },

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

+ completer: None,

+ },

+ TypableCommand {

+ name: "write-quit",

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

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

+ fun: write_quit,

+ completer: Some(completers::filename),

+ },

+ TypableCommand {

+ name: "write-quit!",

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

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

+ fun: force_write_quit,

+ completer: Some(completers::filename),

+ },

+ TypableCommand {

+ name: "write-all",

+ aliases: &["wa"],

+ doc: "Writes changes from all views to disk.",

+ fun: write_all,

+ completer: None,

+ },

+ TypableCommand {

+ name: "write-quit-all",

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

+ doc: "Writes changes from all views to disk and close all views.",

+ fun: write_all_quit,

+ completer: None,

+ },

+ TypableCommand {

+ name: "write-quit-all!",

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

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

+ fun: force_write_all_quit,

+ completer: None,

+ },

+ TypableCommand {

+ name: "quit-all",

+ aliases: &["qa"],

+ doc: "Close all views.",

+ fun: quit_all,

+ completer: None,

+ },

+ TypableCommand {

+ name: "quit-all!",

+ aliases: &["qa!"],

+ doc: "Close all views forcefully (ignoring unsaved changes).",

+ fun: force_quit_all,

+ completer: None,

+ },

+ TypableCommand {

+ name: "theme",

+ aliases: &[],

+ doc: "Change the theme of current view. Requires theme name as argument (:theme <name>)",

+ fun: theme,

+ completer: Some(completers::theme),

+ },

+ TypableCommand {

+ name: "clipboard-yank",

+ aliases: &[],

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

+ fun: yank_main_selection_to_clipboard,

+ completer: None,

+ },

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

+ completer: None,

+ },

+ TypableCommand {

+ name: "primary-clipboard-yank",

+ aliases: &[],

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

+ fun: yank_main_selection_to_primary_clipboard,

+ completer: None,

+ },

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

+ completer: None,

+ },

+ TypableCommand {

+ name: "clipboard-paste-after",

+ aliases: &[],

+ doc: "Paste system clipboard after selections.",

+ fun: paste_clipboard_after,

+ completer: None,

+ },

+ TypableCommand {

+ name: "clipboard-paste-before",

+ aliases: &[],

+ doc: "Paste system clipboard before selections.",

+ fun: paste_clipboard_before,

+ completer: None,

+ },

+ TypableCommand {

+ name: "clipboard-paste-replace",

+ aliases: &[],

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

+ fun: replace_selections_with_clipboard,

+ completer: None,

+ },

+ TypableCommand {

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

+ aliases: &[],

+ doc: "Paste primary clipboard after selections.",

+ fun: paste_primary_clipboard_after,

+ completer: None,

+ },

+ TypableCommand {

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

+ aliases: &[],

+ doc: "Paste primary clipboard before selections.",

+ fun: paste_primary_clipboard_before,

+ completer: None,

+ },

+ TypableCommand {

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

+ aliases: &[],

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

+ fun: replace_selections_with_primary_clipboard,

+ completer: None,

+ },

+ TypableCommand {

+ name: "show-clipboard-provider",

+ aliases: &[],

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

+ fun: show_clipboard_provider,

+ completer: None,

+ },

+ TypableCommand {

+ name: "change-current-directory",

+ aliases: &["cd"],

+ doc: "Change the current working directory (:cd <dir>).",

+ fun: change_current_directory,

+ completer: Some(completers::directory),

+ },

+ TypableCommand {

+ name: "show-directory",

+ aliases: &["pwd"],

+ doc: "Show the current working directory.",

+ fun: show_current_directory,

+ completer: None,

+ },

+ TypableCommand {

+ name: "encoding",

+ aliases: &[],

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

+ fun: set_encoding,

+ completer: None,

+ },

+ TypableCommand {

+ name: "reload",

+ aliases: &[],

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

+ fun: reload,

+ completer: None,

+ },

+ TypableCommand {

+ name: "tree-sitter-scopes",

+ aliases: &[],

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

+ fun: tree_sitter_scopes,

+ completer: None,

+ },

+ TypableCommand {

+ name: "vsplit",

+ aliases: &["vs"],

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

+ fun: vsplit,

+ completer: Some(completers::filename),

+ },

+ TypableCommand {

+ name: "hsplit",

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

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

+ fun: hsplit,

+ completer: Some(completers::filename),

+ }

+ ];

+ pub static COMMANDS: Lazy<HashMap<&'static str, &'static TypableCommand>> = Lazy::new(|| {

+ TYPABLE_COMMAND_LIST

+ .iter()

+ .flat_map(|cmd| {

+ std::iter::once((cmd.name, cmd))

+ .chain(cmd.aliases.iter().map(move |&alias| (alias, cmd)))

+ })

+ .collect()

+ });

+fn command_mode(cx: &mut Context) {

+ let mut prompt = Prompt::new(

+ ":".into(),

+ Some(':'),

+ |input: &str| {

+ // we use .this over split_whitespace() because we care about empty segments

+ let parts = input.split(' ').collect::<Vec<&str>>();

+ // simple heuristic: if there's no just one part, complete command name.

+ // if there's a space, per command completion kicks in.

+ if parts.len() <= 1 {

+ let end = 0..;

+ cmd::TYPABLE_COMMAND_LIST

+ .filter(|command| command.name.contains(input))

+ .map(|command| (end.clone(), Cow::Borrowed(command.name)))

+ .collect()

+ } else {

+ let part = parts.last().unwrap();

+ if let Some(cmd::TypableCommand {

+ completer: Some(completer),

+ ..

+ }) = cmd::COMMANDS.get(parts[0])

+ {

+ completer(part)

+ .into_iter()

+ .map(|(range, file)| {

+ // offset ranges to input

+ let offset = input.len() - part.len();

+ let range = (range.start + offset)..;

+ (range, file)

+ })

+ .collect()

+ } else {

+ Vec::new()

+ }

+ }

+ }, // completion

+ move |cx: &mut compositor::Context, input: &str, event: PromptEvent| {

+ if event != PromptEvent::Validate {

+ return;

+ }

+ let parts = input.split_whitespace().collect::<Vec<&str>>();

+ if parts.is_empty() {

+ return;

+ }

+

+ if let Some(cmd) = cmd::COMMANDS.get(parts[0]) {

+ if let Err(e) = (cmd.fun)(cx, &parts[1..], event) {

+ cx.editor.set_error(format!("{}", e));

+ }

+ } else {

+ cx.editor

+ .set_error(format!("no such command: '{}'", parts[0]));

+ };

+ },

+ );

+ prompt.doc_fn = Box::new(|input: &str| {

+ let part = input.split(' ').next().unwrap_or_default();

+ if let Some(cmd::TypableCommand { doc, .. }) = cmd::COMMANDS.get(part) {

+ return Some(doc);

+ }

+ None

+ });

+ cx.push_layer(Box::new(prompt));

+}

+fn file_picker(cx: &mut Context) {

+ let root = find_root(None).unwrap_or_else(|| PathBuf::from("./"));

+ let picker = ui::file_picker(root);

+ cx.push_layer(Box::new(picker));

+}

+

+fn buffer_picker(cx: &mut Context) {

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

+

+ let picker = FilePicker::new(

+ cx.editor

+ .documents

+ .iter()

+ .map(|(id, doc)| (id, doc.path().cloned()))

+ .collect(),

+ move |(id, path): &(DocumentId, Option<PathBuf>)| {

+ let path = path.as_deref().map(helix_core::path::get_relative_path);

+ match path.as_ref().and_then(|path| path.to_str()) {

+ Some(path) => {

+ if *id == current {

+ format!("{} (*)", &path).into()

+ } else {

+ path.to_owned().into()

+ None => "[scratch buffer]".into(),

+ }

+ |editor: &mut Editor, (id, _path): &(DocumentId, Option<PathBuf>), _action| {

+ editor.switch(*id, Action::Replace);

+ },

+ |editor, (id, path)| {

+ let doc = &editor.documents.get(*id)?;

+ let &view_id = doc.selections().keys().next()?;

+ let line = doc

+ .selection(view_id)

+ .primary()

+ .cursor_line(doc.text().slice(..));

+ Some((path.clone()?, Some((line, line))))

+ },

+ );

+ cx.push_layer(Box::new(picker));

+fn symbol_picker(cx: &mut Context) {

+ fn nested_to_flat(

+ list: &mut Vec<lsp::SymbolInformation>,

+ file: &lsp::TextDocumentIdentifier,

+ symbol: lsp::DocumentSymbol,

+ ) {

+ #[allow(deprecated)]

+ list.push(lsp::SymbolInformation {

+ name: symbol.name,

+ kind: symbol.kind,

+ tags: symbol.tags,

+ deprecated: symbol.deprecated,

+ location: lsp::Location::new(file.uri.clone(), symbol.selection_range),

+ container_name: None,

+ });

+ for child in symbol.children.into_iter().flatten() {

+ nested_to_flat(list, file, child);

+ }

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

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ };

+ let offset_encoding = language_server.offset_encoding();

+ let future = language_server.document_symbols(doc.identifier());

+

+ cx.callback(

+ future,

+ move |editor: &mut Editor,

+ compositor: &mut Compositor,

+ response: Option<lsp::DocumentSymbolResponse>| {

+ if let Some(symbols) = response {

+ // lsp has two ways to represent symbols (flat/nested)

+ // convert the nested variant to flat, so that we have a homogeneous list

+ let symbols = match symbols {

+ lsp::DocumentSymbolResponse::Flat(symbols) => symbols,

+ lsp::DocumentSymbolResponse::Nested(symbols) => {

+ let (_view, doc) = current!(editor);

+ let mut flat_symbols = Vec::new();

+ for symbol in symbols {

+ nested_to_flat(&mut flat_symbols, &doc.identifier(), symbol)

+ }

+ flat_symbols

+ }

+ };

+ let picker = FilePicker::new(

+ symbols,

+ |symbol| (&symbol.name).into(),

+ move |editor: &mut Editor, symbol, _action| {

+ push_jump(editor);

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

+ if let Some(range) =

+ lsp_range_to_range(doc.text(), symbol.location.range, offset_encoding)

+ {

+ // we flip the range so that the cursor sits on the start of the symbol

+ // (for example start of the function).

+ doc.set_selection(view.id, Selection::single(range.head, range.anchor));

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

+ }

+ },

+ move |_editor, symbol| {

+ let path = symbol.location.uri.to_file_path().unwrap();

+ let line = Some((

+ symbol.location.range.start.line as usize,

+ symbol.location.range.end.line as usize,

+ ));

+ Some((path, line))

+ },

+ );

+ compositor.push(Box::new(picker))

+ }

+ },

+ )

+}

+pub fn code_action(cx: &mut Context) {

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ };

+ let range = range_to_lsp_range(

+ doc.text(),

+ doc.selection(view.id).primary(),

+ language_server.offset_encoding(),

+ );

+ let future = language_server.code_actions(doc.identifier(), range);

+ let offset_encoding = language_server.offset_encoding();

+ cx.callback(

+ future,

+ move |_editor: &mut Editor,

+ compositor: &mut Compositor,

+ response: Option<lsp::CodeActionResponse>| {

+ if let Some(actions) = response {

+ let picker = Picker::new(

+ true,

+ actions,

+ |action| match action {

+ lsp::CodeActionOrCommand::CodeAction(action) => {

+ action.title.as_str().into()

+ }

+ lsp::CodeActionOrCommand::Command(command) => command.title.as_str().into(),

+ },

+ move |editor, code_action, _action| match code_action {

+ lsp::CodeActionOrCommand::Command(command) => {

+ log::debug!("code action command: {:?}", command);

+ editor.set_error(String::from("Handling code action command is not implemented yet, see https://github.com/helix-editor/helix/issues/183"));

+ }

+ lsp::CodeActionOrCommand::CodeAction(code_action) => {

+ log::debug!("code action: {:?}", code_action);

+ if let Some(ref workspace_edit) = code_action.edit {

+ apply_workspace_edit(editor, offset_encoding, workspace_edit)

+ }

+ }

+ },

+ );

+ compositor.push(Box::new(picker))

+ }

+ },

+ )

+}

+fn apply_workspace_edit(

+ editor: &mut Editor,

+ offset_encoding: OffsetEncoding,

+ workspace_edit: &lsp::WorkspaceEdit,

+) {

+ if let Some(ref changes) = workspace_edit.changes {

+ log::debug!("workspace changes: {:?}", changes);

+ editor.set_error(String::from("Handling workspace_edit.changes is not implemented yet, see https://github.com/helix-editor/helix/issues/183"));

+ return;

+ // Not sure if it works properly, it'll be safer to just panic here to avoid breaking some parts of code on which code actions will be used

+ // TODO: find some example that uses workspace changes, and test it

+ // for (url, edits) in changes.iter() {

+ // let file_path = url.origin().ascii_serialization();

+ // let file_path = std::path::PathBuf::from(file_path);

+ // let file = std::fs::File::open(file_path).unwrap();

+ // let mut text = Rope::from_reader(file).unwrap();

+ // let transaction = edits_to_changes(&text, edits);

+ // transaction.apply(&mut text);

+ // }

+ }

+ if let Some(ref document_changes) = workspace_edit.document_changes {

+ match document_changes {

+ lsp::DocumentChanges::Edits(document_edits) => {

+ for document_edit in document_edits {

+ let path = document_edit

+ .text_document

+ .uri

+ .to_file_path()

+ .expect("unable to convert URI to filepath");

+ let current_view_id = view!(editor).id;

+ let doc = editor

+ .document_by_path_mut(path)

+ .expect("Document for document_changes not found");

+

+ // Need to determine a view for apply/append_changes_to_history

+ let selections = doc.selections();

+ let view_id = if selections.contains_key(&current_view_id) {

+ // use current if possible

+ current_view_id

+ } else {

+ // Hack: we take the first available view_id

+ selections

+ .keys()

+ .next()

+ .copied()

+ .expect("No view_id available")

+ };

+ let edits = document_edit

+ .edits

+ .iter()

+ .map(|edit| match edit {

+ lsp::OneOf::Left(text_edit) => text_edit,

+ lsp::OneOf::Right(annotated_text_edit) => {

+ &annotated_text_edit.text_edit

+ }

+ })

+ .cloned()

+ .collect();

+ let transaction = helix_lsp::util::generate_transaction_from_edits(

+ doc.text(),

+ edits,

+ offset_encoding,

+ );

+ doc.apply(&transaction, view_id);

+ doc.append_changes_to_history(view_id);

+ }

+ }

+ lsp::DocumentChanges::Operations(operations) => {

+ log::debug!("document changes - operations: {:?}", operations);

+ editor.set_error(String::from("Handling document operations is not implemented yet, see https://github.com/helix-editor/helix/issues/183"));

+ }

+ }

+}

+

+fn last_picker(cx: &mut Context) {

+ // TODO: last picker does not seem to work well with buffer_picker

+ cx.callback = Some(Box::new(|compositor: &mut Compositor| {

+ if let Some(picker) = compositor.last_picker.take() {

+ compositor.push(picker);

+ }

+ // XXX: figure out how to show error when no last picker lifetime

+ // cx.editor.set_error("no last picker".to_owned())

+ }));

+}

+

+// I inserts at the first nonwhitespace character of each line with a selection

+fn prepend_to_line(cx: &mut Context) {

+ goto_first_nonwhitespace(cx);

+ let doc = doc_mut!(cx.editor);

+ enter_insert_mode(doc);

+}

+

+// A inserts at the end of each line with a selection

+fn append_to_line(cx: &mut Context) {

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

+ enter_insert_mode(doc);

+

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

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

+ let line = range.cursor_line(text);

+ let pos = line_end_char_index(&text, line);

+ Range::new(pos, pos)

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

+}

+/// Sometimes when applying formatting changes we want to mark the buffer as unmodified, for

+/// example because we just applied the same changes while saving.

+enum Modified {

+ SetUnmodified,

+ LeaveModified,

+ modified: Modified,

+ format: impl Future<Output = helix_lsp::util::LspFormatting> + Send + 'static,

+ let call: job::Callback = Box::new(move |editor: &mut Editor, _compositor: &mut Compositor| {

+ let view_id = view!(editor).id;

+ if let Some(doc) = editor.document_mut(doc_id) {

+ if doc.version() == doc_version {

+ doc.apply(&Transaction::from(format), view_id);

+ doc.append_changes_to_history(view_id);

+ if let Modified::SetUnmodified = modified {

+ doc.reset_modified();

+ } else {

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

+ });

+enum Open {

+fn open(cx: &mut Context, open: Open) {

+ enter_insert_mode(doc);

+ let mut offs = 0;

+ let line = range.cursor_line(text);

+ let line = match open {

+ // adjust position to the end of the line (next line - 1)

+ Open::Below => line + 1,

+ // adjust position to the end of the previous line (current line - 1)

+ Open::Above => line,

+ let (line_end_index, line_end_offset_width) = if line == 0 {

+ line_end_char_index(&doc.text().slice(..), line.saturating_sub(1)),

+ // TODO: share logic with insert_newline for indentation

+ let indent_level = indent::suggested_indent_for_pos(

+ doc.language_config(),

+ doc.syntax(),

+ text,

+ line_end_index,

+ true,

+ );

+ let indent = doc.indent_unit().repeat(indent_level);

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

+ text.push_str(&indent);

+ let pos = offs + line_end_index + line_end_offset_width;

+ // pos -> beginning of reference line,

+ // + (i * (1+indent_len)) -> beginning of i'th line from pos

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

+ ranges.push(Range::point(pos + (i * (1 + indent_len)) + indent_len));

+ (line_end_index, line_end_index, Some(text.into()))

+ open(cx, Open::Below)

+ open(cx, Open::Above)

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

+

+ if doc.mode == Mode::Normal {

+ return;

+ }

+

+ doc.mode = Mode::Normal;

+

+ doc.append_changes_to_history(view.id);

+

+ // if leaving append mode, move cursor back by 1

+ if doc.restore_cursor {

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

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

+ Range::new(

+ range.from(),

+ graphemes::prev_grapheme_boundary(text, range.to()),

+ )

+ });

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

+

+ doc.restore_cursor = false;

+ }

+fn push_jump(editor: &mut Editor) {

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

+ if let Some(count) = cx.count {

+ push_jump(cx.editor);

+ let max_line = if doc.text().line(doc.text().len_lines() - 1).len_chars() == 0 {

+ doc.text().len_lines().saturating_sub(2)

+ doc.text().len_lines() - 1

+ let pos = doc.text().line_to_char(line_idx);

+ doc.set_selection(view.id, Selection::point(pos));

+ push_jump(cx.editor);

+ let line_idx = if doc.text().line(doc.text().len_lines() - 1).len_chars() == 0 {

+ doc.text().len_lines().saturating_sub(2)

+ doc.text().len_lines() - 1

+ let pos = doc.text().line_to_char(line_idx);

+ doc.set_selection(view.id, Selection::point(pos));

+ let alternate_file = view!(cx.editor).last_accessed_doc;

+ cx.editor.set_error("no last accessed buffer".to_owned())

+ doc_mut!(cx.editor).mode = Mode::Select;

+ let doc = doc_mut!(cx.editor);

+ if doc.mode == Mode::Select {

+ doc.mode = Mode::Normal;

+fn goto_impl(

+ editor: &mut Editor,

+ compositor: &mut Compositor,

+ locations: Vec<lsp::Location>,

+ offset_encoding: OffsetEncoding,

+) {

+ push_jump(editor);

+

+ fn jump_to(

+ editor: &mut Editor,

+ location: &lsp::Location,

+ offset_encoding: OffsetEncoding,

+ action: Action,

+ ) {

+ let path = location

+ .uri

+ .to_file_path()

+ .expect("unable to convert URI to filepath");

+ let _id = editor.open(path, action).expect("editor.open failed");

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

+ let definition_pos = location.range.start;

+ // TODO: convert inside server

+ let new_pos =

+ if let Some(new_pos) = lsp_pos_to_pos(doc.text(), definition_pos, offset_encoding) {

+ new_pos

+ } else {

+ return;

+ };

+ doc.set_selection(view.id, Selection::point(new_pos));

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

+ }

+

+ let cwdir = std::env::current_dir().expect("couldn't determine current directory");

+

+ match locations.as_slice() {

+ [location] => {

+ jump_to(editor, location, offset_encoding, Action::Replace);

+ }

+ [] => {

+ editor.set_error("No definition found.".to_string());

+ }

+ _locations => {

+ let picker = FilePicker::new(

+ locations,

+ move |location| {

+ let file: Cow<'_, str> = (location.uri.scheme() == "file")

+ .then(|| {

+ location

+ .uri

+ .to_file_path()

+ .map(|path| {

+ // strip root prefix

+ path.strip_prefix(&cwdir)

+ .map(|path| path.to_path_buf())

+ .unwrap_or(path)

+ })

+ .ok()

+ .and_then(|path| path.to_str().map(|path| path.to_owned().into()))

+ })

+ .flatten()

+ .unwrap_or_else(|| location.uri.as_str().into());

+ let line = location.range.start.line;

+ format!("{}:{}", file, line).into()

+ },

+ move |editor: &mut Editor, location, action| {

+ jump_to(editor, location, offset_encoding, action)

+ },

+ |_editor, location| {

+ let path = location.uri.to_file_path().unwrap();

+ let line = Some((

+ location.range.start.line as usize,

+ location.range.end.line as usize,

+ ));

+ Some((path, line))

+ },

+ );

+ compositor.push(Box::new(picker));

+ }

+ }

+}

+

+fn goto_definition(cx: &mut Context) {

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+

+ let offset_encoding = language_server.offset_encoding();

+

+ let pos = pos_to_lsp_pos(

+ doc.text(),

+ doc.selection(view.id)

+ .primary()

+ .cursor(doc.text().slice(..)),

+ offset_encoding,

+ );

+

+ let future = language_server.goto_definition(doc.identifier(), pos, None);

+

+ cx.callback(

+ future,

+ move |editor: &mut Editor,

+ compositor: &mut Compositor,

+ response: Option<lsp::GotoDefinitionResponse>| {

+ let items = match response {

+ Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],

+ Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,

+ Some(lsp::GotoDefinitionResponse::Link(locations)) => locations

+ .into_iter()

+ .map(|location_link| lsp::Location {

+ uri: location_link.target_uri,

+ range: location_link.target_range,

+ })

+ .collect(),

+ None => Vec::new(),

+ };

+

+ goto_impl(editor, compositor, items, offset_encoding);

+ },

+ );

+fn goto_type_definition(cx: &mut Context) {

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ let offset_encoding = language_server.offset_encoding();

+ let pos = pos_to_lsp_pos(

+ doc.text(),

+ doc.selection(view.id)

+ .cursor(doc.text().slice(..)),

+ offset_encoding,

+ );

+ let future = language_server.goto_type_definition(doc.identifier(), pos, None);

+

+ cx.callback(

+ future,

+ move |editor: &mut Editor,

+ compositor: &mut Compositor,

+ response: Option<lsp::GotoDefinitionResponse>| {

+ let items = match response {

+ Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],

+ Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,

+ Some(lsp::GotoDefinitionResponse::Link(locations)) => locations

+ .into_iter()

+ .map(|location_link| lsp::Location {

+ uri: location_link.target_uri,

+ range: location_link.target_range,

+ })

+ .collect(),

+ None => Vec::new(),

+ };

+ goto_impl(editor, compositor, items, offset_encoding);

+ },

+ );

+fn goto_implementation(cx: &mut Context) {

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

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ };

+ let offset_encoding = language_server.offset_encoding();

+

+ let pos = pos_to_lsp_pos(

+ doc.text(),

+ doc.selection(view.id)

+ .cursor(doc.text().slice(..)),

+ offset_encoding,

+ );

+ let future = language_server.goto_implementation(doc.identifier(), pos, None);

+

+ cx.callback(

+ future,

+ move |editor: &mut Editor,

+ compositor: &mut Compositor,

+ response: Option<lsp::GotoDefinitionResponse>| {

+ let items = match response {

+ Some(lsp::GotoDefinitionResponse::Scalar(location)) => vec![location],

+ Some(lsp::GotoDefinitionResponse::Array(locations)) => locations,

+ Some(lsp::GotoDefinitionResponse::Link(locations)) => locations

+ .into_iter()

+ .map(|location_link| lsp::Location {

+ uri: location_link.target_uri,

+ range: location_link.target_range,

+ })

+ .collect(),

+ None => Vec::new(),

+ };

+ goto_impl(editor, compositor, items, offset_encoding);

+ },

+ );

+fn goto_reference(cx: &mut Context) {

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

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ };

+

+ let offset_encoding = language_server.offset_encoding();

+

+ let pos = pos_to_lsp_pos(

+ doc.text(),

+ doc.selection(view.id)

+ .primary()

+ .cursor(doc.text().slice(..)),

+ offset_encoding,

+ );

+ let future = language_server.goto_reference(doc.identifier(), pos, None);

+

+ cx.callback(

+ future,

+ move |editor: &mut Editor,

+ compositor: &mut Compositor,

+ items: Option<Vec<lsp::Location>>| {

+ goto_impl(

+ editor,

+ compositor,

+ items.unwrap_or_default(),

+ offset_encoding,

+ );

+ },

+ );

+fn goto_pos(editor: &mut Editor, pos: usize) {

+ push_jump(editor);

+

+ doc.set_selection(view.id, Selection::point(pos));

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

+fn goto_first_diag(cx: &mut Context) {

+ let editor = &mut cx.editor;

+ let (_, doc) = current!(editor);

+

+ let diag = if let Some(diag) = doc.diagnostics().first() {

+ diag.range.start

+ } else {

+ return;

+ };

+

+ goto_pos(editor, diag);

+fn goto_last_diag(cx: &mut Context) {

+ let editor = &mut cx.editor;

+ let (_, doc) = current!(editor);

+ let diag = if let Some(diag) = doc.diagnostics().last() {

+ diag.range.start

+ } else {

+ return;

+ };

+ goto_pos(editor, diag);

+}

+

+fn goto_next_diag(cx: &mut Context) {

+ let editor = &mut cx.editor;

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

+ let cursor_pos = doc

+ .selection(view.id)

+ .primary()

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

+ let diag = if let Some(diag) = doc

+ .diagnostics()

+ .iter()

+ .map(|diag| diag.range.start)

+ .find(|&pos| pos > cursor_pos)

+ {

+ diag

+ } else if let Some(diag) = doc.diagnostics().first() {

+ diag.range.start

+ } else {

+ return;

+

+ goto_pos(editor, diag);

+fn goto_prev_diag(cx: &mut Context) {

+ let editor = &mut cx.editor;

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

+

+ let cursor_pos = doc

+ .selection(view.id)

+ .primary()

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

+ let diag = if let Some(diag) = doc

+ .diagnostics()

+ .iter()

+ .rev()

+ .map(|diag| diag.range.start)

+ .find(|&pos| pos < cursor_pos)

+ {

+ diag

+ } else if let Some(diag) = doc.diagnostics().last() {

+ diag.range.start

+ return;

+ goto_pos(editor, diag);

+fn signature_help(cx: &mut Context) {

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

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ };

+

+ let pos = pos_to_lsp_pos(

+ doc.text(),

+ doc.selection(view.id)

+ .primary()

+ .cursor(doc.text().slice(..)),

+ language_server.offset_encoding(),

+ );

+

+ let future = language_server.text_document_signature_help(doc.identifier(), pos, None);

+

+ cx.callback(

+ future,

+ move |_editor: &mut Editor,

+ _compositor: &mut Compositor,

+ response: Option<lsp::SignatureHelp>| {

+ if let Some(signature_help) = response {

+ log::info!("{:?}", signature_help);

+ // signatures

+ // active_signature

+ // active_parameter

+ // render as:

+

+ // signature

+ // ----------

+ // doc

+

+ // with active param highlighted

+ }

+ },

+ );

+}

+

+// NOTE: Transactions in this module get appended to history when we switch back to normal mode.

+pub mod insert {

+ pub type PostHook = fn(&mut Context, char);

+ // It trigger completion when idle timer reaches deadline

+ // Only trigger completion if the word under cursor is longer than n characters

+ pub fn idle_completion(cx: &mut Context) {

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

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

+ let cursor = doc.selection(view.id).primary().cursor(text);

+

+ use helix_core::chars::char_is_word;

+ let mut iter = text.chars_at(cursor);

+ iter.reverse();

+ for _ in 0..cx.editor.config.completion_trigger_len {

+ match iter.next() {

+ Some(c) if char_is_word(c) => {}

+ _ => return,

+ }

+ super::completion(cx);

+ }

+

+ fn language_server_completion(cx: &mut Context, ch: char) {

+ // if ch matches completion char, trigger completion

+ let doc = doc_mut!(cx.editor);

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ };

+

+ let capabilities = language_server.capabilities();

+

+ if let Some(lsp::CompletionOptions {

+ trigger_characters: Some(triggers),

+ ..

+ }) = &capabilities.completion_provider

+ {

+ // TODO: what if trigger is multiple chars long

+ if triggers.iter().any(|trigger| trigger.contains(ch)) {

+ cx.editor.clear_idle_timer();

+ super::completion(cx);

+ }

+ }

+ }

+

+ fn signature_help(cx: &mut Context, ch: char) {

+ // if ch matches signature_help char, trigger

+ let doc = doc_mut!(cx.editor);

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ };

+

+ let capabilities = language_server.capabilities();

+

+ if let lsp::ServerCapabilities {

+ signature_help_provider:

+ Some(lsp::SignatureHelpOptions {

+ trigger_characters: Some(triggers),

+ // TODO: retrigger_characters

+ ..

+ }),

+ ..

+ } = capabilities

+ {

+ // TODO: what if trigger is multiple chars long

+ let is_trigger = triggers.iter().any(|trigger| trigger.contains(ch));

+

+ if is_trigger {

+ super::signature_help(cx);

+ }

+ }

+

+ // SignatureHelp {

+ // signatures: [

+ // SignatureInformation {

+ // label: "fn open(&mut self, path: PathBuf, action: Action) -> Result<DocumentId, Error>",

+ // documentation: None,

+ // parameters: Some(

+ // [ParameterInformation { label: Simple("path: PathBuf"), documentation: None },

+ // ParameterInformation { label: Simple("action: Action"), documentation: None }]

+ // ),

+ // active_parameter: Some(0)

+ // }

+ // ],

+ // active_signature: None, active_parameter: Some(0)

+ // }

+ let t = Tendril::from_char(ch);

+ let transaction = Transaction::insert(doc, selection, t);

+ let hooks: &[Hook] = match cx.editor.config.auto_pairs {

+ true => &[auto_pairs::hook, insert],

+ false => &[insert],

+ };

+ let text = doc.text();

+ let selection = doc.selection(view.id).clone().cursors(text.slice(..));

+ // run through insert hooks, stopping on the first one that returns Some(t)

+ for hook in hooks {

+ if let Some(transaction) = hook(text, &selection, c) {

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

+ break;

+ // TODO: need a post insert hook too for certain triggers (autocomplete, signature help, etc)

+ // this could also generically look at Transaction, but it's a bit annoying to look at

+ // Operation instead of Change.

+ for hook in &[language_server_completion, signature_help] {

+ // for hook in &[signature_help] {

+ hook(cx, c);

+ }

+ let indent = Tendril::from(doc.indent_unit());

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

+ let selection = doc.selection(view.id).clone().cursors(text);

+ let mut offs = 0;

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

+ let pos = range.head;

+ // TODO: offset range.head by 1? when calculating?

+ let indent_level = indent::suggested_indent_for_pos(

+ doc.language_config(),

+ doc.syntax(),

+ text,

+ pos.saturating_sub(1),

+ true,

+ );

+ let indent = doc.indent_unit().repeat(indent_level);

+ let mut text = String::with_capacity(1 + indent.len());

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

+ text.push_str(&indent);

+ let head = pos + offs + text.chars().count();

+ ranges.push(Range::new(

+ if range.is_empty() {

+ head

+ } else {

+ range.anchor + offs

+ },

+ head,

+ ));

+

+ // if between a bracket pair

+ if helix_core::auto_pairs::PAIRS.contains(&(prev, curr)) {

+ // another newline, indent the end bracket one level less

+ let indent = doc.indent_unit().repeat(indent_level.saturating_sub(1));

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

+ text.push_str(&indent);

+ }

+ offs += text.chars().count();

+

+ (pos, pos, Some(text.into()))

+ //

+ // TODO: handle indent-aware delete

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

+ Transaction::change_by_selection(doc.text(), doc.selection(view.id), |range| {

+ (

+ graphemes::nth_prev_grapheme_boundary(text, pos, count),

+ pos,

+ None,

+ )

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

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

+ let transaction =

+ Transaction::change_by_selection(doc.text(), doc.selection(view.id), |range| {

+ (

+ pos,

+ graphemes::nth_next_grapheme_boundary(text, pos, count),

+ None,

+ )

+ });

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

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

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

+ let selection = doc

+ .selection(view.id)

+ .clone()

+ .transform(|range| movement::move_prev_word_start(text, range, count));

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

+ delete_selection(cx)

+// TODO: each command could simply return a Option<transaction>, then the higher level handles

+// storing it?

+

+ let view_id = view.id;

+ doc.undo(view_id);

+ let view_id = view.id;

+ doc.redo(view_id);

+// Yank / Paste

+fn yank(cx: &mut Context) {

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

+ let values: Vec<String> = doc

+ .selection(view.id)

+ .fragments(text)

+ .map(Cow::into_owned)

+ .collect();

+ let msg = format!(

+ "yanked {} selection(s) to register {}",

+ values.len(),

+ cx.register.unwrap_or('"')

+ cx.editor

+ .registers

+ .write(cx.register.unwrap_or('"'), values);

+ cx.editor.set_status(msg);

+fn yank_joined_to_clipboard_impl(

+ editor: &mut Editor,

+ separator: &str,

+ clipboard_type: ClipboardType,

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

+ let msg = format!(

+ "joined and yanked {} selection(s) to system clipboard",

+ values.len(),

+ );

+ let joined = values.join(separator);

+ editor

+ .clipboard_provider

+ .set_contents(joined, clipboard_type)

+ .context("Couldn't set system clipboard content")?;

+ editor.set_status(msg);

+ Ok(())

+fn yank_joined_to_clipboard(cx: &mut Context) {

+ let line_ending = current!(cx.editor).1.line_ending;

+ let _ = yank_joined_to_clipboard_impl(

+ &mut cx.editor,

+ line_ending.as_str(),

+ ClipboardType::Clipboard,

+ );

+fn yank_main_selection_to_clipboard_impl(

+ editor: &mut Editor,

+ clipboard_type: ClipboardType,

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

+ let value = doc.selection(view.id).primary().fragment(text);

+ if let Err(e) = editor

+ .clipboard_provider

+ .set_contents(value.into_owned(), clipboard_type)

+ {

+ bail!("Couldn't set system clipboard content: {}", e);

+

+ editor.set_status("yanked main selection to system clipboard".to_owned());

+ Ok(())

+ let _ = yank_main_selection_to_clipboard_impl(&mut cx.editor, ClipboardType::Clipboard);

+}

+

+fn yank_joined_to_primary_clipboard(cx: &mut Context) {

+ let line_ending = current!(cx.editor).1.line_ending;

+ let _ = yank_joined_to_clipboard_impl(

+ &mut cx.editor,

+ line_ending.as_str(),

+ ClipboardType::Selection,

+ );

+ let _ = yank_main_selection_to_clipboard_impl(&mut cx.editor, ClipboardType::Selection);

+ view: &View,

+) -> Option<Transaction> {

+ let repeat = std::iter::repeat(

+ values

+ .last()

+ .map(|value| Tendril::from_slice(value))

+ .unwrap(),

+ );

+ // Only compiled once.

+ #[allow(clippy::trivial_regex)]

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

+ let mut values = values

+ .iter()

+ .map(|value| REGEX.replace_all(value, doc.line_ending.as_str()))

+ .map(|value| Tendril::from(value.as_ref()))

+ .chain(repeat);

+ let transaction = Transaction::change_by_selection(text, selection, |range| {

+ (pos, pos, Some(values.next().unwrap()))

+ Some(transaction)

+fn paste_clipboard_impl(

+ editor: &mut Editor,

+ action: Paste,

+ clipboard_type: ClipboardType,

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

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

+

+ match editor

+ .clipboard_provider

+ .get_contents(clipboard_type)

+ .map(|contents| paste_impl(&[contents], doc, view, action))

+ {

+ Ok(Some(transaction)) => {

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

+ doc.append_changes_to_history(view.id);

+ Ok(())

+ }

+ Ok(None) => Ok(()),

+ Err(e) => Err(e.context("Couldn't get system clipboard contents")),

+ }

+ let _ = paste_clipboard_impl(&mut cx.editor, Paste::After, ClipboardType::Clipboard);

+ let _ = paste_clipboard_impl(&mut cx.editor, Paste::Before, ClipboardType::Clipboard);

+ let _ = paste_clipboard_impl(&mut cx.editor, Paste::After, ClipboardType::Selection);

+ let _ = paste_clipboard_impl(&mut cx.editor, Paste::Before, ClipboardType::Selection);

+ let reg_name = cx.register.unwrap_or('"');

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

+ let registers = &mut cx.editor.registers;

+

+ if let Some(values) = registers.read(reg_name) {

+ if !values.is_empty() {

+ let repeat = std::iter::repeat(

+ values

+ .last()

+ .map(|value| Tendril::from_slice(value))

+ .unwrap(),

+ );

+ let mut values = values

+ .iter()

+ .map(|value| Tendril::from_slice(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)

+ }

+ });

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

+ doc.append_changes_to_history(view.id);

+ }

+}

+fn replace_selections_with_clipboard_impl(

+ editor: &mut Editor,

+ clipboard_type: ClipboardType,

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

+

+ match editor.clipboard_provider.get_contents(clipboard_type) {

+ Ok(contents) => {

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

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

+ (range.from(), range.to(), Some(contents.as_str().into()))

+ });

+

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

+ doc.append_changes_to_history(view.id);

+ Ok(())

+ }

+ Err(e) => Err(e.context("Couldn't get system clipboard contents")),

+ }

+ let _ = replace_selections_with_clipboard_impl(&mut cx.editor, ClipboardType::Clipboard);

+ let _ = replace_selections_with_clipboard_impl(&mut cx.editor, ClipboardType::Selection);

+ let reg_name = cx.register.unwrap_or('"');

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

+ let registers = &mut cx.editor.registers;

+

+ if let Some(transaction) = registers

+ .read(reg_name)

+ .and_then(|values| paste_impl(values, doc, view, Paste::After))

+ {

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

+ doc.append_changes_to_history(view.id);

+ }

+ let reg_name = cx.register.unwrap_or('"');

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

+ let registers = &mut cx.editor.registers;

+

+ if let Some(transaction) = registers

+ .read(reg_name)

+ .and_then(|values| paste_impl(values, doc, view, Paste::Before))

+ {

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

+ doc.append_changes_to_history(view.id);

+ }

+ let indent = Tendril::from(doc.indent_unit().repeat(count));

+ lines.into_iter().map(|line| {

+ (pos, pos, Some(indent.clone()))

+ doc.append_changes_to_history(view.id);

+ let indent_width = count * tab_width;

+ doc.append_changes_to_history(view.id);

+ // else via tree-sitter indentation calculations

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ .selection(view.id)

+ .map(|range| range_to_lsp_range(doc.text(), *range, language_server.offset_encoding()))

+ // TODO: all of the TODO's and commented code inside the loop,

+ // to make this actually work.

+ for _range in ranges {

+ let _language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ };

+ // TODO: handle fails

+ // TODO: concurrent map

+ // TODO: need to block to get the formatting

+ // let edits = block_on(language_server.text_document_range_formatting(

+ // doc.identifier(),

+ // range,

+ // lsp::FormattingOptions::default(),

+ // ))

+ // .unwrap_or_default();

+ // let transaction = helix_lsp::util::generate_transaction_from_edits(

+ // doc.text(),

+ // edits,

+ // language_server.offset_encoding(),

+ // );

+

+ // doc.apply(&transaction, view.id);

+ }

+

+ doc.append_changes_to_history(view.id);

+fn join_selections(cx: &mut Context) {

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

+ let fragment = Tendril::from(" ");

+ // need to skip from start, not end

+ let change = (start, end, Some(fragment.clone()));

+ changes.push(change);

+ // TODO: joining multiple empty lines should be replaced by a single space.

+ // need to merge change ranges that touch

+

+ let transaction = Transaction::change(doc.text(), changes.into_iter());

+ // TODO: select inserted spaces

+ // .with_selection(selection);

+ doc.append_changes_to_history(view.id);

+fn keep_selections(cx: &mut Context) {

+ // keep selections matching regex

+ let prompt = ui::regex_prompt(

+ "keep:".into(),

+ move |view, doc, regex, event| {

+ if event != PromptEvent::Update {

+ if let Some(selection) = selection::keep_matches(text, doc.selection(view.id), &regex) {

+ );

+ cx.push_layer(Box::new(prompt));

+ cx.editor.set_error("no selections remaining".to_owned());

+ // trigger on trigger char, or if user calls it

+ // (or on word char typing??)

+ // after it's triggered, if response marked is_incomplete, update on every subsequent keypress

+ //

+ // lsp calls are done via a callback: it sends a request and doesn't block.

+ // when we get the response similarly to notification, trigger a call to the completion popup

+ //

+ // language_server.completion(params, |cx: &mut Context, _meta, response| {

+ // // called at response time

+ // // compositor, lookup completion layer

+ // // downcast dyn Component to Completion component

+ // // emit response to completion (completion.complete/handle(response))

+ // })

+ //

+ // typing after prompt opens: usually start offset is tracked and everything between

+ // start_offset..cursor is replaced. For our purposes we could keep the start state (doc,

+ // selection) and revert to them before applying. This needs to properly reset changes/history

+ // though...

+ //

+ // company-mode does this by matching the prefix of the completion and removing it.

+

+ // ignore isIncomplete for now

+ // keep state while typing

+ // the behavior should be, filter the menu based on input

+ // if items returns empty at any point, remove the popup

+ // if backspace past initial offset point, remove the popup

+ //

+ // debounce requests!

+ //

+ // need an idle timeout thing.

+ // https://github.com/company-mode/company-mode/blob/master/company.el#L620-L622

+ //

+ // "The idle delay in seconds until completion starts automatically.

+ // The prefix still has to satisfy `company-minimum-prefix-length' before that

+ // happens. The value of nil means no idle completion."

+

+

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ };

+

+ let offset_encoding = language_server.offset_encoding();

+ let cursor = doc.selection(view.id).primary().cursor(text);

+ let pos = pos_to_lsp_pos(doc.text(), cursor, offset_encoding);

+ let future = language_server.completion(doc.identifier(), pos, None);

+ let trigger_offset = cursor;

+ // TODO: trigger_offset should be the cursor offset but we also need a starting offset from where we want to apply

+ // completion filtering. For example logger.te| should filter the initial suggestion list with "te".

+ use helix_core::chars;

+ let mut iter = text.chars_at(cursor);

+ iter.reverse();

+ let offset = iter.take_while(|ch| chars::char_is_word(*ch)).count();

+ let start_offset = cursor.saturating_sub(offset);

+ cx.callback(

+ future,

+ move |editor: &mut Editor,

+ compositor: &mut Compositor,

+ response: Option<lsp::CompletionResponse>| {

+ let (_, doc) = current!(editor);

+ if doc.mode() != Mode::Insert {

+ // we're not in insert mode anymore

+ return;

+ }

+ let items = match response {

+ Some(lsp::CompletionResponse::Array(items)) => items,

+ // TODO: do something with is_incomplete

+ Some(lsp::CompletionResponse::List(lsp::CompletionList {

+ is_incomplete: _is_incomplete,

+ items,

+ })) => items,

+ None => Vec::new(),

+ };

+ if items.is_empty() {

+ // editor.set_error("No completion available".to_string());

+ return;

+ }

+ let size = compositor.size();

+ let ui = compositor

+ .find(std::any::type_name::<ui::EditorView>())

+ .unwrap();

+ if let Some(ui) = ui.as_any_mut().downcast_mut::<ui::EditorView>() {

+ ui.set_completion(

+ editor,

+ items,

+ offset_encoding,

+ start_offset,

+ trigger_offset,

+ size,

+ );

+ };

+ },

+ );

+}

+fn hover(cx: &mut Context) {

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

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => return,

+ };

+ // TODO: factor out a doc.position_identifier() that returns lsp::TextDocumentPositionIdentifier

+ let pos = pos_to_lsp_pos(

+ doc.text(),

+ doc.selection(view.id)

+ .primary()

+ .cursor(doc.text().slice(..)),

+ language_server.offset_encoding(),

+ );

+ let future = language_server.text_document_hover(doc.identifier(), pos, None);

+

+ cx.callback(

+ future,

+ move |editor: &mut Editor, compositor: &mut Compositor, response: Option<lsp::Hover>| {

+ if let Some(hover) = response {

+ // hover.contents / .range <- used for visualizing

+ let contents = match hover.contents {

+ lsp::HoverContents::Scalar(contents) => {

+ // markedstring(string/languagestring to be highlighted)

+ // TODO

+ log::error!("hover contents {:?}", contents);

+ return;

+ }

+ lsp::HoverContents::Array(contents) => {

+ log::error!("hover contents {:?}", contents);

+ return;

+ }

+ // TODO: render markdown

+ lsp::HoverContents::Markup(contents) => contents.value,

+ };

+ // skip if contents empty

+ let contents = ui::Markdown::new(contents, editor.syn_loader.clone());

+ let popup = Popup::new(contents);

+ compositor.push(Box::new(popup));

+ }

+ },

+ );

+// comments

+fn toggle_comments(cx: &mut Context) {

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

+ let token = doc

+ .language_config()

+ .and_then(|lc| lc.comment_token.as_ref())

+ .map(|tc| tc.as_ref());

+ let transaction = comment::toggle_line_comments(doc.text(), doc.selection(view.id), token);

+

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

+ doc.append_changes_to_history(view.id);

+ exit_select_mode(cx);

+fn rotate_selection_contents(cx: &mut Context, direction: Direction) {

+ let mut fragments: Vec<_> = selection

+ .fragments(text)

+ .map(|fragment| Tendril::from_slice(&fragment))

+ let group = count

+ .map(|count| count.get())

+ .unwrap_or(fragments.len()) // default to rotating everything as one group

+ .min(fragments.len());

+ for chunk in fragments.chunks_mut(group) {

+ // TODO: also modify main index

+ match direction {

+ Direction::Forward => chunk.rotate_right(1),

+ Direction::Backward => chunk.rotate_left(1),

+ };

+ }

+ .zip(fragments)

+ doc.append_changes_to_history(view.id);

+ rotate_selection_contents(cx, Direction::Forward)

+ rotate_selection_contents(cx, Direction::Backward)

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

+ let selection = object::expand_selection(syntax, text, doc.selection(view.id));

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

+ let pos = doc

+ .selection(view.id)

+ .primary()

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

+ if let Some(pos) = match_brackets::find(syntax, doc.text(), pos) {