- annotations::diagnostics::{DiagnosticFilter, InlineDiagnosticsConfig},

- clipboard::ClipboardProvider,

- document::{

- DocumentOpenError, DocumentSavedEventFuture, DocumentSavedEventResult, Mode, SavePoint,

- },

- events::{DocumentDidClose, DocumentDidOpen, DocumentFocusLost},

- Document, DocumentId, View, ViewId,

-use helix_event::dispatch;

-use helix_lsp::{Call, LanguageServerId};

- collections::{BTreeMap, HashMap, HashSet},

- fs,

- io::{self, stdin},

- num::{NonZeroU8, NonZeroUsize},

- diagnostic::DiagnosticProvider,

- syntax::{

- self,

- config::{AutoPairConfig, IndentationHeuristic, LanguageServerFeature, SoftWrap},

- },

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

-use helix_dap::{self as dap, registry::DebugAdapterId};

-use helix_stdx::path::canonicalize;

-use arc_swap::{

- access::{DynAccess, DynGuard},

- ArcSwap,

-};

-

-pub const DEFAULT_AUTO_SAVE_DELAY: u64 = 3000;

-pub struct FileExplorerConfig {

- /// IgnoreOptions

- /// Enables ignoring hidden files.

- /// Whether to hide hidden files in file explorer and global search results. Defaults to false.

- pub hidden: bool,

- /// Enables following symlinks.

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

- pub follow_symlinks: bool,

- /// Enables reading ignore files from parent directories. Defaults to false.

- pub parents: bool,

- /// Enables reading `.ignore` files.

- /// Whether to hide files listed in .ignore in file picker and global search results. Defaults to false.

- pub ignore: bool,

- /// Enables reading `.gitignore` files.

- /// Whether to hide files listed in .gitignore in file picker and global search results. Defaults to false.

- pub git_ignore: bool,

- /// Enables reading global .gitignore, whose path is specified in git's config: `core.excludefile` option.

- /// Whether to hide files listed in global .gitignore in file picker and global search results. Defaults to false.

- pub git_global: bool,

- /// Enables reading `.git/info/exclude` files.

- /// Whether to hide files listed in .git/info/exclude in file picker and global search results. Defaults to false.

- pub git_exclude: bool,

- /// Whether to flatten single-child directories in file explorer. Defaults to true.

- pub flatten_dirs: bool,

-}

-

-impl Default for FileExplorerConfig {

- fn default() -> Self {

- Self {

- hidden: false,

- follow_symlinks: false,

- parents: false,

- ignore: false,

- git_ignore: false,

- git_global: false,

- git_exclude: false,

- flatten_dirs: true,

- }

- }

-}

-

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

-where

- S: Serializer,

-{

- let alphabet: String = alphabet.iter().collect();

- serializer.serialize_str(&alphabet)

-}

-

-fn deserialize_alphabet<'de, D>(deserializer: D) -> Result<Vec<char>, D::Error>

-where

- D: Deserializer<'de>,

-{

- use serde::de::Error;

-

- let str = String::deserialize(deserializer)?;

- let chars: Vec<_> = str.chars().collect();

- let unique_chars: HashSet<_> = chars.iter().copied().collect();

- if unique_chars.len() != chars.len() {

- return Err(<D::Error as Error>::custom(

- "jump-label-alphabet must contain unique characters",

- ));

- }

- Ok(chars)

-}

-

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

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

- /// Enable filepath completion.

- /// Show files and directories if an existing path at the cursor was recognized,

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

- /// Configures completion of words from open buffers.

- /// Defaults to enabled with a trigger length of 7.

- pub word_completion: WordCompletion,

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

- pub default_yank_register: char,

- /// Automatic save on focus lost and/or after delay.

- /// Time delay in milliseconds since last edit after which auto save timer triggers.

- /// Time delay defaults to false with 3000ms delay. Focus lost defaults to false.

- #[serde(deserialize_with = "deserialize_auto_save")]

- pub auto_save: AutoSave,

- /// `true` if helix should automatically add a line comment token if you're currently in a comment

- /// and press `enter`.

- pub continue_comments: bool,

- pub file_explorer: FileExplorerConfig,

- /// Whether to use atomic operations to write documents to disk.

- /// This prevents data loss if the editor is interrupted while writing the file, but may

- /// confuse some file watching/hot reloading programs. Defaults to `true`.

- pub atomic_save: 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 automatically remove all whitespace characters preceding line-endings on write.

- /// Defaults to `false`.

- pub trim_trailing_whitespace: bool,

- /// labels characters used in jumpmode

- #[serde(

- serialize_with = "serialize_alphabet",

- deserialize_with = "deserialize_alphabet"

- )]

- pub jump_label_alphabet: Vec<char>,

- /// Display diagnostic below the line they occur.

- pub inline_diagnostics: InlineDiagnosticsConfig,

- pub end_of_line_diagnostics: DiagnosticFilter,

- // Set to override the default clipboard provider

- pub clipboard_provider: ClipboardProvider,

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

- /// `true`.

- pub editor_config: bool,

- /// Whether to render rainbow colors for matching brackets. Defaults to `false`.

- pub rainbow_brackets: bool,

- /// Whether to enable Kitty Keyboard Protocol

- pub kitty_keyboard_protocol: KittyKeyboardProtocolConfig,

-}

-

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

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

-pub enum KittyKeyboardProtocolConfig {

- #[default]

- Auto,

- Disabled,

- Enabled,

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

-#[cfg(not(any(windows, target_arch = "wasm32")))]

- /// Display LSP messagess from $/progress below statusline

- pub display_progress_messages: bool,

- /// Display LSP messages from window/showMessage below statusline

- /// Maximum displayed length of inlay hints (excluding the added trailing `…`).

- /// If it's `None`, there's no limit

- pub inlay_hints_length_limit: Option<NonZeroU8>,

- /// Display document color swatches

- pub display_color_swatches: bool,

- display_progress_messages: false,

- display_messages: true,

- inlay_hints_length_limit: None,

- display_color_swatches: true,

- pub diagnostics: Vec<Severity>,

- pub workspace_diagnostics: Vec<Severity>,

- diagnostics: vec![Severity::Warning, Severity::Error],

- workspace_diagnostics: vec![Severity::Warning, Severity::Error],

- /// The file absolute path

- FileAbsolutePath,

-

- /// The file indentation style

- FileIndentStyle,

-

-

- /// The base of current working directory

- CurrentWorkingDirectory,

- nnbsp: Option<WhitespaceRenderValue>,

- pub fn nnbsp(&self) -> WhitespaceRenderValue {

- match *self {

- Self::Basic(val) => val,

- Self::Specific { default, nnbsp, .. } => {

- nnbsp.or(default).unwrap_or(WhitespaceRenderValue::None)

- }

- }

- }

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

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

-pub struct AutoSave {

- /// Auto save after a delay in milliseconds. Defaults to disabled.

- #[serde(default)]

- pub after_delay: AutoSaveAfterDelay,

- /// Auto save on focus lost. Defaults to false.

- #[serde(default)]

- pub focus_lost: bool,

-}

-

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

-#[serde(deny_unknown_fields)]

-pub struct AutoSaveAfterDelay {

- #[serde(default)]

- /// Enable auto save after delay. Defaults to false.

- pub enable: bool,

- #[serde(default = "default_auto_save_delay")]

- /// Time delay in milliseconds. Defaults to [DEFAULT_AUTO_SAVE_DELAY].

- pub timeout: u64,

-}

-

-impl Default for AutoSaveAfterDelay {

- fn default() -> Self {

- Self {

- enable: false,

- timeout: DEFAULT_AUTO_SAVE_DELAY,

- }

- }

-}

-

-fn default_auto_save_delay() -> u64 {

- DEFAULT_AUTO_SAVE_DELAY

-}

-

-fn deserialize_auto_save<'de, D>(deserializer: D) -> Result<AutoSave, D::Error>

-where

- D: serde::Deserializer<'de>,

-{

- #[derive(Deserialize, Serialize)]

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

- enum AutoSaveToml {

- EnableFocusLost(bool),

- AutoSave(AutoSave),

- }

-

- match AutoSaveToml::deserialize(deserializer)? {

- AutoSaveToml::EnableFocusLost(focus_lost) => Ok(AutoSave {

- focus_lost,

- ..Default::default()

- }),

- AutoSaveToml::AutoSave(auto_save) => Ok(auto_save),

- }

-}

-

- pub nnbsp: char,

- nnbsp: '␣', // U+2423

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

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

-pub struct WordCompletion {

- pub enable: bool,

- pub trigger_length: NonZeroU8,

-}

-

-impl Default for WordCompletion {

- fn default() -> Self {

- Self {

- enable: true,

- trigger_length: NonZeroU8::new(7).unwrap(),

- }

- }

-}

-

- path_completion: true,

- word_completion: WordCompletion::default(),

- default_yank_register: '"',

- auto_save: AutoSave::default(),

- file_explorer: FileExplorerConfig::default(),

- continue_comments: true,

- atomic_save: true,

- trim_final_newlines: false,

- trim_trailing_whitespace: false,

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

- inline_diagnostics: InlineDiagnosticsConfig::default(),

- end_of_line_diagnostics: DiagnosticFilter::Enable(Severity::Hint),

- clipboard_provider: ClipboardProvider::default(),

- editor_config: true,

- rainbow_brackets: false,

- kitty_keyboard_protocol: Default::default(),

-type Diagnostics = BTreeMap<Uri, Vec<(lsp::Diagnostic, DiagnosticProvider)>>;

-

- pub diagnostics: Diagnostics,

- pub debug_adapters: dap::registry::Registry,

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

- last_cwd: Option<PathBuf>,

-

- pub mouse_down_range: Option<Range>,

- pub cursor_cache: CursorCache,

- LanguageServerMessage((LanguageServerId, Call)),

- DebuggerEvent((DebugAdapterId, dap::Payload)),

- placeholder: bool,

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

- diagnostics: Diagnostics::new(),

- debug_adapters: dap::registry::Registry::new(),

- registers: Registers::new(Box::new(arc_swap::access::Map::new(

- Arc::clone(&config),

- |config: &Config| &config.clipboard_provider,

- ))),

- last_cwd: None,

- mouse_down_range: None,

- cursor_cache: CursorCache::default(),

- pub fn refresh_config(&mut self, old_config: &Config) {

- helix_event::dispatch(crate::events::ConfigDidChange {

- editor: self,

- old: old_config,

- new: &config,

- })

- pub fn set_warning<T: Into<Cow<'static, str>>>(&mut self, warning: T) {

- let warning = warning.into();

- log::warn!("editor warning: {}", warning);

- self.status_msg = Some((warning, Severity::Warning));

- }

-

- #[inline]

- if theme.find_highlight_exact("ui.selection").is_none() {

- (*self.syn_loader).load().set_scopes(scopes.to_vec());

- pub fn language_server_by_id(

- &self,

- language_server_id: LanguageServerId,

- ) -> Option<&helix_lsp::Client> {

- self.language_servers

- .get_by_id(language_server_id)

- .map(|client| &**client)

- /// moves/renames a path, invoking any event handlers (currently only lsp)

- /// and calling `set_doc_path` if the file is open in the editor

- pub fn move_path(&mut self, old_path: &Path, new_path: &Path) -> io::Result<()> {

- let new_path = canonicalize(new_path);

- // sanity check

- if old_path == new_path {

- return Ok(());

- }

- let is_dir = old_path.is_dir();

- let language_servers: Vec<_> = self

- .language_servers

- .iter_clients()

- .filter(|client| client.is_initialized())

- .cloned()

- .collect();

- for language_server in language_servers {

- let Some(request) = language_server.will_rename(old_path, &new_path, is_dir) else {

- continue;

- };

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

- Ok(edit) => edit.unwrap_or_default(),

- Err(err) => {

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

- continue;

- }

- };

- if let Err(err) = self.apply_workspace_edit(language_server.offset_encoding(), &edit) {

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

- }

- }

-

- if old_path.exists() {

- fs::rename(old_path, &new_path)?;

- }

-

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

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

- }

- let is_dir = new_path.is_dir();

- for ls in self.language_servers.iter_clients() {

- // A new language server might have been started in `set_doc_path` and won't

- // be initialized yet. Skip the `did_rename` notification for this server.

- if !ls.is_initialized() {

- continue;

- }

- ls.did_rename(old_path, &new_path, is_dir);

- }

- self.language_servers

- .file_event_handler

- .file_changed(old_path.to_owned());

- self.language_servers

- .file_event_handler

- .file_changed(new_path);

- Ok(())

- }

-

- pub fn set_doc_path(&mut self, doc_id: DocumentId, path: &Path) {

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

- let old_path = doc.path();

-

- if let Some(old_path) = old_path {

- // sanity check, should not occur but some callers (like an LSP) may

- // create bogus calls

- if old_path == path {

- return;

- }

- // if we are open in LSPs send did_close notification

- for language_server in doc.language_servers() {

- language_server.text_document_did_close(doc.identifier());

- }

- }

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

- // refresh_doc_language/refresh_language_servers doesn't resend

- // text_document_did_close. Since we called `text_document_did_close`

- // we have fully unregistered this document from its LS

- doc.language_servers.clear();

- doc.set_path(Some(path));

- doc.detect_editor_config();

- self.refresh_doc_language(doc_id)

- }

-

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

- let loader = self.syn_loader.load();

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

- doc.detect_language(&loader);

- doc.detect_editor_config();

- doc.detect_indent_and_line_ending();

- self.refresh_language_servers(doc_id);

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

- let diagnostics = Editor::doc_diagnostics(&self.language_servers, &self.diagnostics, doc);

- doc.replace_diagnostics(diagnostics, &[], None);

- doc.reset_all_inlay_hints();

- }

-

- "Language server not found for `{}` {} {}", language.scope, lang, err,

- language.scope,

- if language_servers.is_empty() && doc.language_servers.is_empty() {

- .is_none_or(|ls| ls.id() != doc_ls.id())

- language_server.text_document_did_close(doc.identifier());

- .is_none_or(|doc_ls| ls.id() != doc_ls.id())

- language_server.text_document_did_open(

- );

- let scrolloff = self.config().scrolloff;

-

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

- view.ensure_cursor_in_view(doc, scrolloff)

- if !matches!(action, Action::Load) {

- self.enter_normal_mode();

- }

- let focust_lost = match action {

- dispatch(DocumentFocusLost {

- editor: self,

- doc: id,

- });

- let focus_lost = self.tree.try_get(self.tree.focus).map(|view| view.doc);

- focus_lost

- };

- if let Some(focus_lost) = focust_lost {

- dispatch(DocumentFocusLost {

- editor: self,

- doc: focus_lost,

- });

- }

- self.new_file_from_document(

- action,

- Document::default(self.config.clone(), self.syn_loader.clone()),

- )

- self.syn_loader.clone(),

- pub fn document_id_by_path(&self, path: &Path) -> Option<DocumentId> {

- self.document_by_path(path).map(|doc| doc.id)

- }

-

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

- let id = self.document_id_by_path(&path);

- true,

- self.syn_loader.clone(),

- helix_event::dispatch(DocumentDidOpen {

- editor: self,

- doc: id,

- });

-

-

- let doc = match self.documents.get(&doc_id) {

- let doc = self.documents.remove(&doc_id).unwrap();

- .unwrap_or_else(|| {

- self.new_document(Document::default(

- self.config.clone(),

- self.syn_loader.clone(),

- ))

- });

- helix_event::dispatch(DocumentDidClose { editor: self, doc });

-

- if self.tree.focus == view_id {

- return;

- }

- // Reset mode to normal and ensure any pending changes are committed in the old document.

- self.enter_normal_mode();

- let (view, doc) = current!(self);

- doc.append_changes_to_history(view);

- self.ensure_cursor_in_view(view_id);

- // Update jumplist selections with new document changes.

- for (view, _focused) in self.tree.views_mut() {

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

- view.sync_changes(doc);

- }

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

- doc_mut!(self).mark_as_focused();

- let focus_lost = self.tree.get(prev_id).doc;

- dispatch(DocumentFocusLost {

- editor: self,

- doc: focus_lost,

- });

- let view = self.tree.get(id);

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

- diagnostics: &'a Diagnostics,

- diagnostics: &'a Diagnostics,

- filter: impl Fn(&lsp::Diagnostic, &DiagnosticProvider) -> bool + 'a,

- .uri()

- diags.iter().filter_map(move |(diagnostic, provider)| {

- let server_id = provider.language_server_id()?;

- let ls = language_servers.get_by_id(server_id)?;

- if filter(diagnostic, provider) {

- provider.clone(),

- if let Some(mut pos) = self.cursor_cache.get(view, doc) {

- Some(event) = self.debug_adapters.incoming.next() => {

- doc.set_last_saved_revision(save_event.revision, save_event.save_time);

- use helix_core::graphemes;

- let mut head = range.to();

- if range.head > range.anchor {

- head = graphemes::prev_grapheme_boundary(text, head);

- }

-

- Range::new(range.from(), head)

- pub fn current_stack_frame(&self) -> Option<&dap::StackFrame> {

- self.debug_adapters.current_stack_frame()

-

- pub fn set_cwd(&mut self, path: &Path) -> std::io::Result<()> {

- self.last_cwd = helix_stdx::env::set_current_working_dir(path)?;

- self.clear_doc_relative_paths();

- Ok(())

- }

-

- pub fn get_last_cwd(&mut self) -> Option<&Path> {

- self.last_cwd.as_deref()

- }

- chars::char_is_whitespace,

- line_ending::{line_end_char_index, str_is_line_ending},

- unicode::segmentation::UnicodeSegmentation,

- Operation, Transaction,

- let mut graphemes = inserted_str.graphemes(true);

- && graphemes.next().is_some_and(str_is_line_ending)

- && graphemes.all(|g| g.chars().all(char_is_whitespace))

-

-#[derive(Default)]

-pub struct CursorCache(Cell<Option<Option<Position>>>);

-

-impl CursorCache {

- pub fn get(&self, view: &View, doc: &Document) -> Option<Position> {

- if let Some(pos) = self.0.get() {

- return pos;

- }

-

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

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

- let res = view.screen_coords_at_pos(doc, text, cursor);

- self.set(res);

- res

- }

-

- pub fn set(&self, cursor_pos: Option<Position>) {

- self.0.set(Some(cursor_pos))

- }

-

- pub fn reset(&self) {

- self.0.set(None)

- }

-}