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,

use helix_core::{

auto_pairs::AutoPairs,

diagnostic::DiagnosticProvider,

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

/// Whether to automatically remove all trailing line-endings after the final one on write.

/// Defaults to `false`.

pub trim_final_newlines: bool,

/// Whether to read settings from [EditorConfig](https://editorconfig.org) files. Defaults to

/// `true`.

pub editor_config: bool,

}

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

pub display_signature_help_docs: bool,

/// Display inlay hints

pub display_inlay_hints: bool,

/// Display document color swatches

pub display_color_swatches: bool,

/// Whether to enable snippet support

auto_signature_help: true,

display_signature_help_docs: true,

display_inlay_hints: false,

snippets: true,

goto_reference_include_declaration: true,

display_color_swatches: 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,

workspace_lsp_roots: Vec::new(),

default_line_ending: LineEndingConfig::default(),

insert_final_newline: true,

trim_final_newlines: false,

trim_trailing_whitespace: false,

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

indent_heuristic: IndentationHeuristic::default(),

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

inline_diagnostics: InlineDiagnosticsConfig::default(),

clipboard_provider: ClipboardProvider::default(),

editor_config: true,

}

}

}

pub diagnostics: Diagnostics,

pub diff_providers: DiffProviderRegistry,

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

pub syn_loader: Arc<ArcSwap<syntax::Loader>>,

DocumentSaved(DocumentSavedEventResult),

ConfigEvent(ConfigEvent),

LanguageServerMessage((LanguageServerId, Call)),

IdleTimer,

Redraw,

}

language_servers,

diagnostics: Diagnostics::new(),

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;

}

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

}

}

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

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

doc.detect_editor_config();

doc.detect_indent_and_line_ending();

self.refresh_language_servers(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 {

}

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

let mut doc = Document::open(

&path,

None,

self.config.clone(),

)?;

let diagnostics =

if !force && doc.is_modified() {

return Err(CloseError::BufferModified(doc.display_name().into_owned()));

}

// This will also disallow any follow-up writes

self.saves.remove(&doc_id);

}

}

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

// containing either an existing document, or a brand new document.

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

}

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

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

}

}

pub fn focus_next(&mut self) {

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,

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