use crate::{

graphics::{CursorKind, Rect},

info::Info,

input::KeyEvent,

theme::{self, Theme},

tree::{self, Tree},

};

use helix_vcs::DiffProviderRegistry;

use futures_util::stream::select_all::SelectAll;

use futures_util::{future, StreamExt};

use tokio_stream::wrappers::UnboundedReceiverStream;

use std::{

borrow::Cow,

path::{Path, PathBuf},

pin::Pin,

sync::Arc,

};

use tokio::{

time::{sleep, Duration, Instant, Sleep},

};

use anyhow::{anyhow, bail, Error};

pub use helix_core::diagnostic::Severity;

use helix_core::{

auto_pairs::AutoPairs,

};

use helix_lsp::lsp;

use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};

fn deserialize_duration_millis<'de, D>(deserializer: D) -> Result<Duration, D::Error>

where

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]

#[serde(rename_all = "kebab-case", default, deny_unknown_fields)]

pub struct FilePickerConfig {

/// IgnoreOptions

/// Enables ignoring hidden files.

/// Enables following symlinks.

/// Whether to follow symbolic links in file picker and file or directory completions. Defaults to true.

pub follow_symlinks: bool,

/// Enables reading ignore files from parent directories. Defaults to true.

pub parents: bool,

/// Enables reading `.ignore` files.

Self {

hidden: true,

follow_symlinks: true,

parents: true,

ignore: true,

git_ignore: true,

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]

#[serde(rename_all = "kebab-case", default, deny_unknown_fields)]

pub struct Config {

/// Padding to keep between the edge of the screen and the cursor when scrolling. Defaults to 5.

pub scrolloff: usize,

pub cursorline: bool,

/// Highlight the columns cursors are currently on. Defaults to false.

pub cursorcolumn: bool,

/// Middle click paste support. Defaults to true.

pub middle_click_paste: bool,

/// Automatic insertion of pairs to parentheses, brackets,

pub auto_pairs: AutoPairConfig,

/// Automatic auto-completion, automatically pop up without user trigger. Defaults to true.

pub auto_completion: bool,

/// Automatic formatting on save. Defaults to true.

pub auto_format: bool,

/// Time in milliseconds since last keypress before idle timers trigger.

#[serde(

serialize_with = "serialize_duration_millis",

deserialize_with = "deserialize_duration_millis"

)]

pub idle_timeout: Duration,

pub completion_trigger_len: u8,

/// Whether to display infoboxes. Defaults to true.

pub auto_info: bool,

pub file_picker: FilePickerConfig,

/// Configuration of the statusline elements

pub statusline: StatusLineConfig,

/// Shape for cursor in each mode

pub cursor_shape: CursorShapeConfig,

/// Set to `true` to override automatic detection of terminal truecolor support in the event of a false negative. Defaults to `false`.

pub true_color: bool,

/// Search configuration.

#[serde(default)]

pub search: SearchConfig,

pub lsp: LspConfig,

pub terminal: Option<TerminalConfig>,

pub rulers: Vec<u16>,

#[serde(default)]

pub whitespace: WhitespaceConfig,

pub indent_guides: IndentGuidesConfig,

/// Whether to color modes with different colors. Defaults to `false`.

pub color_modes: bool,

}

#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]

#[cfg(windows)]

pub fn get_terminal_provider() -> Option<TerminalConfig> {

if binary_exists("wt") {

return Some(TerminalConfig {

});

}

command: "conhost".to_string(),

args: vec!["cmd".to_string(), "/C".to_string()],

}

pub fn get_terminal_provider() -> Option<TerminalConfig> {

if env_var_is_set("TMUX") && binary_exists("tmux") {

return Some(TerminalConfig {

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]

#[serde(default, rename_all = "kebab-case", deny_unknown_fields)]

pub struct LspConfig {

pub display_messages: bool,

/// Enable automatic pop up of signature help (parameter hints)

pub auto_signature_help: bool,

/// Display docs under signature help popup

pub display_signature_help_docs: bool,

}

impl Default for LspConfig {

fn default() -> Self {

Self {

auto_signature_help: true,

display_signature_help_docs: true,

}

}

}

pub right: Vec<StatusLineElement>,

pub separator: String,

pub mode: ModeConfig,

}

impl Default for StatusLineConfig {

use StatusLineElement as E;

Self {

center: vec![],

separator: String::from("│"),

mode: ModeConfig::default(),

}

}

}

/// The LSP activity spinner

Spinner,

FileName,

/// The file encoding

FileEncoding,

/// The file line endings (CRLF or LF)

FileLineEnding,

/// The file type (language ID or "text")

FileType,

/// A single space

Spacer,

}

// Cursor shape is read and used on every rendered frame and so needs

}

/// bufferline render modes

#[serde(rename_all = "kebab-case")]

pub enum BufferLine {

/// Don't render bufferline

Never,

/// Always render

Always,

Multiple,

}

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

#[serde(rename_all = "kebab-case")]

pub enum LineNumber {

"spacer" => Ok(Self::Spacer),

"line-numbers" => Ok(Self::LineNumbers),

"diff" => Ok(Self::Diff),

}

}

}

default: Option<WhitespaceRenderValue>,

space: Option<WhitespaceRenderValue>,

nbsp: Option<WhitespaceRenderValue>,

tab: Option<WhitespaceRenderValue>,

newline: Option<WhitespaceRenderValue>,

},

}

}

}

pub fn tab(&self) -> WhitespaceRenderValue {

match *self {

Self::Basic(val) => val,

}

}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]

#[serde(default)]

pub struct WhitespaceCharacters {

pub space: char,

pub nbsp: char,

pub tab: char,

pub tabpad: char,

pub newline: char,

impl Default for WhitespaceCharacters {

fn default() -> Self {

Self {

nbsp: '⍽', // U+237D

tab: '→', // U+2192

newline: '⏎', // U+23CE

tabpad: ' ',

}

}

impl Default for Config {

fn default() -> Self {

Self {

line_number: LineNumber::Absolute,

cursorline: false,

cursorcolumn: false,

middle_click_paste: true,

auto_pairs: AutoPairConfig::default(),

auto_completion: true,

auto_format: true,

completion_trigger_len: 2,

auto_info: true,

file_picker: FilePickerConfig::default(),

statusline: StatusLineConfig::default(),

cursor_shape: CursorShapeConfig::default(),

true_color: false,

search: SearchConfig::default(),

lsp: LspConfig::default(),

terminal: get_terminal_provider(),

bufferline: BufferLine::default(),

indent_guides: IndentGuidesConfig::default(),

color_modes: false,

}

}

}

}

}

#[derive(Debug, Clone, Default)]

pub struct Breakpoint {

pub id: Option<usize>,

use futures_util::stream::{Flatten, Once};

pub struct Editor {

/// Current editing mode.

pub mode: Mode,

pub macro_recording: Option<(char, Vec<KeyEvent>)>,

pub macro_replaying: Vec<char>,

pub language_servers: helix_lsp::Registry,

pub diff_providers: DiffProviderRegistry,

pub breakpoints: HashMap<PathBuf, Vec<Breakpoint>>,

pub theme_loader: Arc<theme::Loader>,

/// last_theme is used for theme previews. We store the current theme here,

/// and if previewing is cancelled, we can return to it.

/// The currently applied editor theme. While previewing a theme, the previewed theme

/// is set here.

pub theme: Theme,

pub status_msg: Option<(Cow<'static, str>, Severity)>,

pub autoinfo: Option<Info>,

pub auto_pairs: Option<AutoPairs>,

pub idle_timer: Pin<Box<Sleep>>,

pub last_completion: Option<CompleteAction>,

pub exit_code: i32,

pub config_events: (UnboundedSender<ConfigEvent>, UnboundedReceiver<ConfigEvent>),

pub needs_redraw: bool,

}

#[derive(Debug)]

pub enum EditorEvent {

DocumentSaved(DocumentSavedEventResult),

ConfigEvent(ConfigEvent),

IdleTimer,

}

#[derive(Debug, Clone)]

}

#[derive(Debug, Clone)]

}

#[derive(Debug, Copy, Clone)]

VerticalSplit,

}

/// Error thrown on failed document closed

pub enum CloseError {

/// Document doesn't exist

pub fn new(

mut area: Rect,

theme_loader: Arc<theme::Loader>,

) -> Self {

let conf = config.load();

let auto_pairs = (&conf.auto_pairs).into();

macro_recording: None,

macro_replaying: Vec::new(),

theme: theme_loader.default(),

diff_providers: DiffProviderRegistry::default(),

breakpoints: HashMap::new(),

syn_loader,

theme_loader,

last_theme: None,

status_msg: None,

autoinfo: None,

idle_timer: Box::pin(sleep(conf.idle_timeout)),

last_motion: None,

last_completion: None,

config,

auto_pairs,

exit_code: 0,

config_events: unbounded_channel(),

needs_redraw: false,

}

}

/// Current editing mode for the [`Editor`].

pub fn mode(&self) -> Mode {

self.mode

/// Call if the config has changed to let the editor update all

/// relevant members.

let config = self.config();

self.auto_pairs = (&config.auto_pairs).into();

self.reset_idle_timer();

}

pub fn clear_idle_timer(&mut self) {

#[inline]

pub fn set_error<T: Into<Cow<'static, str>>>(&mut self, error: T) {

let error = error.into();

self.status_msg = Some((error, Severity::Error));

}

#[inline]

pub fn get_status(&self) -> Option<(&Cow<'static, str>, &Severity)> {

self.status_msg.as_ref().map(|(status, sev)| (status, sev))

}

fn set_theme_impl(&mut self, theme: Theme, preview: ThemeAction) {

// `ui.selection` is the only scope required to be able to render a theme.

self.set_error("Invalid theme: `ui.selection` required");

return;

}

let scopes = theme.scopes();

match preview {

ThemeAction::Preview => {

self._refresh();

}

/// Refreshes the language server for a given document

}

/// Launch a language server for a given document

// if doc doesn't have a URL it's a scratch buffer, ignore it

})

});

}

}

fn _refresh(&mut self) {

let config = self.config();

for (view, _) in self.tree.views_mut() {

let doc = doc_mut!(self, &view.doc);

view.sync_changes(doc);

view.ensure_cursor_in_view(doc, config.scrolloff)

}

}

fn replace_document_in_view(&mut self, current_view: ViewId, doc_id: DocumentId) {

let view = self.tree.get_mut(current_view);

view.doc = doc_id;

doc.ensure_view_init(view.id);

view.sync_changes(doc);

}

pub fn switch(&mut self, id: DocumentId, action: Action) {

return;

}

Action::Replace => {

let (view, doc) = current_ref!(self);

// If the current view is an empty scratch buffer and is not displayed in any other views, delete it.

self.replace_document_in_view(view_id, id);

return;

}

Action::Load => {

let view_id = view!(self).id;

let doc = doc_mut!(self, &id);

doc.ensure_view_init(view_id);

return;

}

Action::HorizontalSplit | Action::VerticalSplit => {

// copy the current view, unless there is no view yet

let view = self

.tree

// initialize selection for view

let doc = doc_mut!(self, &id);

doc.ensure_view_init(view_id);

}

self._refresh();

}

/// Generate an id for a new document and register it.

}

pub fn new_file(&mut self, action: Action) -> DocumentId {

}

pub fn new_file_from_stdin(&mut self, action: Action) -> Result<DocumentId, Error> {

}

// ??? possible use for integration tests

let id = if let Some(id) = id {

id

} else {

if let Some(diff_base) = self.diff_providers.get_diff_base(&path) {

}

};

self.switch(id, action);

Ok(id)

}

}

pub fn close_document(&mut self, doc_id: DocumentId, force: bool) -> Result<(), CloseError> {

Some(doc) => doc,

None => return Err(CloseError::DoesNotExist),

};

// This will also disallow any follow-up writes

self.saves.remove(&doc_id);

enum Action {

Close(ViewId),

ReplaceDoc(ViewId, DocumentId),

}

}

// If the document we removed was visible in all views, we will have no more views. We don't

// want to close the editor just for a simple buffer close, so we need to create a new view

.iter()

.map(|(&doc_id, _)| doc_id)

.next()

let view = View::new(doc_id, self.config().gutters.clone());

let view_id = self.tree.insert(view);

let doc = doc_mut!(self, &doc_id);

doc.ensure_view_init(view_id);

}

self._refresh();

Ok(())

}

let path = path.map(|path| path.into());

let doc = doc_mut!(self, &doc_id);

use futures_util::stream;

}

pub fn focus(&mut self, view_id: ViewId) {

let prev_id = std::mem::replace(&mut self.tree.focus, view_id);

}

pub fn focus_next(&mut self) {

self.focus(self.tree.next());

}

pub fn focus_direction(&mut self, direction: tree::Direction) {

let current_view = self.tree.focus;

if let Some(id) = self.tree.find_split_in_direction(current_view, direction) {

pub fn ensure_cursor_in_view(&mut self, id: ViewId) {

let config = self.config();

view.ensure_cursor_in_view(doc, config.scrolloff)

}

.find(|doc| doc.path().map(|p| p == path.as_ref()).unwrap_or(false))

}

pub fn cursor(&self) -> (Option<Position>, CursorKind) {

let config = self.config();

let (view, doc) = current_ref!(self);

let inner = view.inner_area(doc);

pos.col += inner.x as usize;

pos.row += inner.y as usize;

&self,

timeout: Option<u64>,

) -> Result<(), tokio::time::error::Elapsed> {

tokio::time::timeout(

Duration::from_millis(timeout.unwrap_or(3000)),

future::join_all(

Some(message) = self.language_servers.incoming.next() => {

return EditorEvent::LanguageServerMessage(message)

}

return EditorEvent::DebuggerEvent(event)

}

if !self.needs_redraw{

self.needs_redraw = true;

}

}

}

_ = &mut self.idle_timer => {

return EditorEvent::IdleTimer

}

};

let doc = doc_mut!(self, &save_event.doc_id);

}

}

/// Switches the editor into normal mode.

pub fn enter_normal_mode(&mut self) {

if self.mode == Mode::Normal {

return;

if doc.restore_cursor {

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

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

});

doc.set_selection(view.id, selection);

doc.restore_cursor = false;

}

}

}

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

use helix_core::{

};

fn inserted_a_new_blank_line(changes: &[Operation], pos: usize, line_end_pos: usize) -> bool {

if let [Operation::Retain(move_pos), Operation::Insert(ref inserted_str), Operation::Retain(_)] =

changes

{

move_pos + inserted_str.len() == pos

&& pos == line_end_pos // ensure no characters exists after current position

} else {

false

let line_start_pos = text.line_to_char(range.cursor_line(text));

(line_start_pos, pos, None)

});

}

}