document::{

DocumentOpenError, DocumentSavedEventFuture, DocumentSavedEventResult, Mode, SavePoint,

},

graphics::{CursorKind, Rect},

handlers::Handlers,

info::Info,

tree::{self, Tree},

Document, DocumentId, View, ViewId,

};

use helix_event::dispatch;

use helix_vcs::DiffProviderRegistry;

collections::{BTreeMap, HashMap, HashSet},

fs,

io::{self, stdin},

path::{Path, PathBuf},

pin::Pin,

sync::Arc,

pub use helix_core::diagnostic::Severity;

use helix_core::{

auto_pairs::AutoPairs,

Change, LineEnding, Position, Range, Selection, Uri, NATIVE_LINE_ENDING,

};

use helix_lsp::lsp;

use helix_stdx::path::canonicalize;

}

}

fn serialize_alphabet<S>(alphabet: &[char], serializer: S) -> Result<S::Ok, S::Error>

where

S: Serializer,

/// either absolute or relative to the current opened document or current working directory (if the buffer is not yet saved).

/// Defaults to true.

pub path_completion: bool,

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

pub auto_format: bool,

/// Default register used for yank/paste. Defaults to '"'

/// Whether to instruct the LSP to replace the entire word when applying a completion

/// or to only insert new text

pub completion_replace: bool,

/// 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 default_line_ending: LineEndingConfig,

/// Whether to automatically insert a trailing line-ending on write if missing. Defaults to `true`.

pub insert_final_newline: bool,

/// Enables smart tab

pub smart_tab: Option<SmartTabConfig>,

/// Draw border around popups.

pub end_of_line_diagnostics: DiagnosticFilter,

// Set to override the default clipboard provider

pub clipboard_provider: ClipboardProvider,

}

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

pub struct SmartTabConfig {

pub enable: bool,

pub supersede_menu: bool,

pub display_signature_help_docs: bool,

/// Display inlay hints

pub display_inlay_hints: bool,

/// Whether to enable snippet support

pub snippets: bool,

/// Whether to include declaration in the goto reference query

auto_signature_help: true,

display_signature_help_docs: true,

display_inlay_hints: false,

snippets: true,

goto_reference_include_declaration: true,

}

}

}

pub right: Vec<StatusLineElement>,

pub separator: String,

pub mode: ModeConfig,

}

impl Default for StatusLineConfig {

],

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

mode: ModeConfig::default(),

}

}

}

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

FileLineEnding,

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

FileType,

/// Indicator for selected register

Register,

}

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

Menu,

}

impl Default for Config {

fn default() -> Self {

Self {

auto_pairs: AutoPairConfig::default(),

auto_completion: true,

path_completion: true,

auto_format: true,

default_yank_register: '"',

auto_save: AutoSave::default(),

completion_trigger_len: 2,

auto_info: true,

file_picker: FilePickerConfig::default(),

statusline: StatusLineConfig::default(),

cursor_shape: CursorShapeConfig::default(),

true_color: false,

},

text_width: 80,

completion_replace: false,

workspace_lsp_roots: Vec::new(),

default_line_ending: LineEndingConfig::default(),

insert_final_newline: true,

smart_tab: Some(SmartTabConfig::default()),

popup_border: PopupBorderConfig::None,

indent_heuristic: IndentationHeuristic::default(),

jump_label_alphabet: ('a'..='z').collect(),

inline_diagnostics: InlineDiagnosticsConfig::default(),

clipboard_provider: ClipboardProvider::default(),

}

}

}

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 syn_loader: Arc<ArcSwap<syntax::Loader>>,

redraw_timer: Pin<Box<Sleep>>,

last_motion: Option<Motion>,

pub last_completion: Option<CompleteAction>,

pub exit_code: i32,

DocumentSaved(DocumentSavedEventResult),

ConfigEvent(ConfigEvent),

LanguageServerMessage((LanguageServerId, Call)),

IdleTimer,

Redraw,

}

macro_replaying: Vec::new(),

theme: theme_loader.default(),

language_servers,

diff_providers: DiffProviderRegistry::default(),

breakpoints: HashMap::new(),

syn_loader,

theme_loader,

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

self._refresh();

}

pub fn clear_idle_timer(&mut self) {

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;

}

continue;

};

let edit = match helix_lsp::block_on(request) {

Err(err) => {

log::error!("invalid willRename response: {err:?}");

continue;

log::error!("failed to apply workspace edit: {err:?}")

}

}

if let Some(doc) = self.document_by_path(old_path) {

self.set_doc_path(doc.id(), &new_path);

}

if !ls.is_initialized() {

continue;

}

}

self.language_servers

.file_event_handler

}

// if we are open in LSPs send did_close notification

for language_server in doc.language_servers() {

}

}

// we need to clear the list of language servers here so that

// we have fully unregistered this document from its LS

doc.language_servers.clear();

doc.set_path(Some(path));

self.refresh_doc_language(doc_id)

}

pub fn refresh_doc_language(&mut self, doc_id: DocumentId) {

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

doc.detect_indent_and_line_ending();

self.refresh_language_servers(doc_id);

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

if let helix_lsp::Error::ExecutableNotFound(err) = err {

// Silence by default since some language servers might just not be installed

log::debug!(

);

} else {

log::error!(

"Failed to initialize the language servers for `{}` - `{}` {{ {} }}",

lang,

err

);

doc.language_servers.iter().filter(|(name, doc_ls)| {

language_servers

.get(*name)

});

for (_, language_server) in doc_language_servers_not_in_registry {

}

let language_servers_not_in_doc = language_servers.iter().filter(|(name, ls)| {

doc.language_servers

.get(*name)

});

for (_, language_server) in language_servers_not_in_doc {

// TODO: this now races with on_init code if the init happens too quickly

doc_url.clone(),

doc.version(),

doc.text(),

language_id.clone(),

}

doc.language_servers = language_servers;

}

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

}

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

helix_core::Rope::default(),

Some((encoding, has_bom)),

self.config.clone(),

);

let doc_id = self.new_file_from_document(action, doc);

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

Ok(doc_id)

}

// ??? possible use for integration tests

pub fn open(&mut self, path: &Path, action: Action) -> Result<DocumentId, DocumentOpenError> {

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

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

id

let mut doc = Document::open(

&path,

None,

self.config.clone(),

)?;

let diagnostics =

let id = self.new_document(doc);

self.launch_language_servers(id);

id

};

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

self._refresh();

Ok(())

}

}

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

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

}

}

pub fn focus_next(&mut self) {

/// Returns all supported diagnostics for the document

pub fn doc_diagnostics<'a>(

language_servers: &'a helix_lsp::Registry,

document: &Document,

) -> impl Iterator<Item = helix_core::Diagnostic> + 'a {

Editor::doc_diagnostics_with_filter(language_servers, diagnostics, document, |_, _| true)

/// filtered by `filter` which is invocated with the raw `lsp::Diagnostic` and the language server id it came from

pub fn doc_diagnostics_with_filter<'a>(

language_servers: &'a helix_lsp::Registry,

document: &Document,

) -> impl Iterator<Item = helix_core::Diagnostic> + 'a {

let text = document.text().clone();

let language_config = document.language.clone();

.uri()

.and_then(|uri| diagnostics.get(&uri))

.map(|diags| {

language_config

.as_ref()

.and_then(|c| {

})

})

.and_then(|_| {

Document::lsp_diagnostic_to_diagnostic(

&text,

language_config.as_deref(),

diagnostic,

ls.offset_encoding(),

)

} else {

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

return EditorEvent::LanguageServerMessage(message)

}

return EditorEvent::DebuggerEvent(event)

}

}

}

}

/// Returns the id of a view that this doc contains a selection for,

current_view.id

}

}

}

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