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

- clipboard::ClipboardProvider,

- document::{

- DocumentOpenError, DocumentSavedEventFuture, DocumentSavedEventResult, Mode, SavePoint,

- },

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

- handlers::Handlers,

- Document, DocumentId, View, ViewId,

-use helix_event::dispatch;

-use helix_lsp::{Call, LanguageServerId};

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

- fs,

- io::{self, stdin},

- num::{NonZeroU8, NonZeroUsize},

- sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},

- auto_pairs::AutoPairs,

- 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 serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};

-

-use arc_swap::{

- access::{DynAccess, DynGuard},

- ArcSwap,

-};

-

-pub const DEFAULT_AUTO_SAVE_DELAY: u64 = 3000;

-

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

-where

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

-{

- let millis = u64::deserialize(deserializer)?;

- Ok(Duration::from_millis(millis))

-}

-

-fn serialize_duration_millis<S>(duration: &Duration, serializer: S) -> Result<S::Ok, S::Error>

-where

- S: Serializer,

-{

- serializer.serialize_u64(

- duration

- .as_millis()

- .try_into()

- .map_err(|_| serde::ser::Error::custom("duration value overflowed u64"))?,

- )

-}

-

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

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

-pub struct GutterConfig {

- /// Gutter Layout

- pub layout: Vec<GutterType>,

- /// Options specific to the "line-numbers" gutter

- pub line_numbers: GutterLineNumbersConfig,

-}

-

-impl Default for GutterConfig {

- fn default() -> Self {

- Self {

- layout: vec![

- GutterType::Diagnostics,

- GutterType::Spacer,

- GutterType::LineNumbers,

- GutterType::Spacer,

- GutterType::Diff,

- ],

- line_numbers: GutterLineNumbersConfig::default(),

- }

- }

-}

-

-impl From<Vec<GutterType>> for GutterConfig {

- fn from(x: Vec<GutterType>) -> Self {

- GutterConfig {

- layout: x,

- ..Default::default()

- }

- }

-}

-

-fn deserialize_gutter_seq_or_struct<'de, D>(deserializer: D) -> Result<GutterConfig, D::Error>

-where

- D: Deserializer<'de>,

-{

- struct GutterVisitor;

-

- impl<'de> serde::de::Visitor<'de> for GutterVisitor {

- type Value = GutterConfig;

-

- fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {

- write!(

- formatter,

- "an array of gutter names or a detailed gutter configuration"

- )

- }

-

- fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>

- where

- S: serde::de::SeqAccess<'de>,

- {

- let mut gutters = Vec::new();

- while let Some(gutter) = seq.next_element::<String>()? {

- gutters.push(

- gutter

- .parse::<GutterType>()

- .map_err(serde::de::Error::custom)?,

- )

- }

-

- Ok(gutters.into())

- }

-

- fn visit_map<M>(self, map: M) -> Result<Self::Value, M::Error>

- where

- M: serde::de::MapAccess<'de>,

- {

- let deserializer = serde::de::value::MapAccessDeserializer::new(map);

- Deserialize::deserialize(deserializer)

- }

- }

-

- deserializer.deserialize_any(GutterVisitor)

-}

-

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

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

-pub struct GutterLineNumbersConfig {

- /// Minimum number of characters to use for line number gutter. Defaults to 3.

- pub min_width: usize,

-}

-

-impl Default for GutterLineNumbersConfig {

- fn default() -> Self {

- Self { min_width: 3 }

- }

-}

-

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

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

-pub struct FilePickerConfig {

- /// IgnoreOptions

- /// Enables ignoring hidden files.

- /// Whether to hide hidden files in file picker and global search results. Defaults to true.

- pub hidden: bool,

- /// Enables following symlinks.

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

- pub follow_symlinks: bool,

- /// Hides symlinks that point into the current directory. Defaults to true.

- pub deduplicate_links: bool,

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

- pub parents: bool,

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

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

- pub ignore: bool,

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

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

- 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 true.

- 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 true.

- pub git_exclude: bool,

- /// WalkBuilder options

- /// Maximum Depth to recurse directories in file picker and global search. Defaults to `None`.

- pub max_depth: Option<usize>,

-}

-

-impl Default for FilePickerConfig {

- fn default() -> Self {

- Self {

- hidden: true,

- follow_symlinks: true,

- deduplicate_links: true,

- parents: true,

- ignore: true,

- git_ignore: true,

- git_global: true,

- git_exclude: true,

- max_depth: None,

- }

- }

-}

-

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

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

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

-pub struct Config {

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

- pub scrolloff: usize,

- /// Number of lines to scroll at once. Defaults to 3

- pub scroll_lines: isize,

- /// Mouse support. Defaults to true.

- pub mouse: bool,

- /// Shell to use for shell commands. Defaults to ["cmd", "/C"] on Windows and ["sh", "-c"] otherwise.

- pub shell: Vec<String>,

- /// Line number mode.

- pub line_number: LineNumber,

- /// Highlight the lines cursors are currently on. Defaults to false.

- pub cursorline: bool,

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

- pub cursorcolumn: bool,

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

- pub gutters: GutterConfig,

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

- pub middle_click_paste: bool,

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

- /// etc. Optionally, this can be a list of 2-tuples to specify a

- /// global list of characters to pair. Defaults to true.

- pub auto_pairs: AutoPairConfig,

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

- pub auto_completion: bool,

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

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

- pub auto_format: bool,

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

- /// Set a global text_width

- pub text_width: usize,

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

- /// Used for various UI timeouts. Defaults to 250ms.

- #[serde(

- serialize_with = "serialize_duration_millis",

- deserialize_with = "deserialize_duration_millis"

- )]

- pub idle_timeout: Duration,

- /// Time in milliseconds after typing a word character before auto completions

- /// are shown, set to 5 for instant. Defaults to 250ms.

- #[serde(

- serialize_with = "serialize_duration_millis",

- deserialize_with = "deserialize_duration_millis"

- )]

- pub completion_timeout: Duration,

- /// Whether to insert the completion suggestion on hover. Defaults to true.

- pub preview_completion_insert: bool,

- pub completion_trigger_len: u8,

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

- /// or to only insert new text

- pub completion_replace: bool,

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

- /// and press `enter`.

- pub continue_comments: bool,

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

- pub auto_info: bool,

- pub file_picker: FilePickerConfig,

- pub file_explorer: FileExplorerConfig,

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

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

- pub undercurl: bool,

- /// Search configuration.

- #[serde(default)]

- pub search: SearchConfig,

- pub lsp: LspConfig,

- pub terminal: Option<TerminalConfig>,

- /// Column numbers at which to draw the rulers. Defaults to `[]`, meaning no rulers.

- pub rulers: Vec<u16>,

- #[serde(default)]

- pub whitespace: WhitespaceConfig,

- /// Persistently display open buffers along the top

- pub bufferline: BufferLine,

- /// Vertical indent width guides.

- pub indent_guides: IndentGuidesConfig,

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

- pub color_modes: bool,

- pub soft_wrap: SoftWrap,

- /// Workspace specific lsp ceiling dirs

- pub workspace_lsp_roots: Vec<PathBuf>,

- /// Which line ending to choose for new documents. Defaults to `native`. i.e. `crlf` on Windows, otherwise `lf`.

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

- /// Enables smart tab

- pub smart_tab: Option<SmartTabConfig>,

- /// Draw border around popups.

- pub popup_border: PopupBorderConfig,

- /// Which indent heuristic to use when a new line is inserted

- #[serde(default)]

- pub indent_heuristic: IndentationHeuristic,

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

-}

-

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

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

-pub struct SmartTabConfig {

- pub enable: bool,

- pub supersede_menu: bool,

-}

-

-impl Default for SmartTabConfig {

- fn default() -> Self {

- SmartTabConfig {

- enable: true,

- supersede_menu: false,

- }

- }

-}

-

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

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

-pub struct TerminalConfig {

- pub command: String,

- #[serde(default)]

- #[serde(skip_serializing_if = "Vec::is_empty")]

- pub args: Vec<String>,

-}

-

-#[cfg(windows)]

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

- use helix_stdx::env::binary_exists;

-

- if binary_exists("wt") {

- return Some(TerminalConfig {

- command: "wt".to_string(),

- args: vec![

- "new-tab".to_string(),

- "--title".to_string(),

- "DEBUG".to_string(),

- "cmd".to_string(),

- "/C".to_string(),

- ],

- });

- }

-

- Some(TerminalConfig {

- command: "conhost".to_string(),

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

- })

-}

-

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

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

- use helix_stdx::env::{binary_exists, env_var_is_set};

-

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

- return Some(TerminalConfig {

- command: "tmux".to_string(),

- args: vec!["split-window".to_string()],

- });

- }

-

- if env_var_is_set("WEZTERM_UNIX_SOCKET") && binary_exists("wezterm") {

- return Some(TerminalConfig {

- command: "wezterm".to_string(),

- args: vec!["cli".to_string(), "split-pane".to_string()],

- });

- }

-

- None

-}

-

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

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

-pub struct LspConfig {

- /// Enables LSP

- pub enable: bool,

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

- pub display_progress_messages: bool,

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

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

- /// Display inlay hints

- pub display_inlay_hints: bool,

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

- /// Whether to enable snippet support

- pub snippets: bool,

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

- pub goto_reference_include_declaration: bool,

-}

-

-impl Default for LspConfig {

- fn default() -> Self {

- Self {

- enable: true,

- display_progress_messages: false,

- display_messages: true,

- auto_signature_help: true,

- display_signature_help_docs: true,

- display_inlay_hints: false,

- inlay_hints_length_limit: None,

- snippets: true,

- goto_reference_include_declaration: true,

- display_color_swatches: true,

- }

- }

-}

-

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

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

-pub struct SearchConfig {

- /// Smart case: Case insensitive searching unless pattern contains upper case characters. Defaults to true.

- pub smart_case: bool,

- /// Whether the search should wrap after depleting the matches. Default to true.

- pub wrap_around: bool,

-}

-

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

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

-pub struct StatusLineConfig {

- pub left: Vec<StatusLineElement>,

- pub center: Vec<StatusLineElement>,

- pub right: Vec<StatusLineElement>,

- pub separator: String,

- pub mode: ModeConfig,

- pub diagnostics: Vec<Severity>,

- pub workspace_diagnostics: Vec<Severity>,

-}

-

-impl Default for StatusLineConfig {

- fn default() -> Self {

- use StatusLineElement as E;

-

- Self {

- left: vec![

- E::Mode,

- E::Spinner,

- E::FileName,

- E::ReadOnlyIndicator,

- E::FileModificationIndicator,

- ],

- center: vec![],

- right: vec![

- E::Diagnostics,

- E::Selections,

- E::Register,

- E::Position,

- E::FileEncoding,

- ],

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

- mode: ModeConfig::default(),

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

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

- }

- }

-}

-

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

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

-pub struct ModeConfig {

- pub normal: String,

- pub insert: String,

- pub select: String,

-}

-

-impl Default for ModeConfig {

- fn default() -> Self {

- Self {

- normal: String::from("NOR"),

- insert: String::from("INS"),

- select: String::from("SEL"),

- }

- }

-}

-

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

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

-pub enum StatusLineElement {

- /// The editor mode (Normal, Insert, Visual/Selection)

- Mode,

-

- /// The LSP activity spinner

- Spinner,

-

- /// The file basename (the leaf of the open file's path)

- FileBaseName,

-

- /// The relative file path

- FileName,

-

- /// The file absolute path

- FileAbsolutePath,

-

- // The file modification indicator

- FileModificationIndicator,

-

- /// An indicator that shows `"[readonly]"` when a file cannot be written

- ReadOnlyIndicator,

-

- /// The file encoding

- FileEncoding,

-

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

- FileLineEnding,

-

- /// The file indentation style

- FileIndentStyle,

-

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

- FileType,

-

- /// A summary of the number of errors and warnings

- Diagnostics,

-

- /// A summary of the number of errors and warnings on file and workspace

- WorkspaceDiagnostics,

-

- /// The number of selections (cursors)

- Selections,

-

- /// The number of characters currently in primary selection

- PrimarySelectionLength,

-

- /// The cursor position

- Position,

-

- /// The separator string

- Separator,

-

- /// The cursor position as a percent of the total file

- PositionPercentage,

-

- /// The total line numbers of the current file

- TotalLineNumbers,

-

- /// A single space

- Spacer,

-

- /// Current version control information

- VersionControl,

-

- /// Indicator for selected register

- Register,

-

- /// The base of current working directory

- CurrentWorkingDirectory,

-}

-

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

-// to be fast. Therefore we avoid a hashmap and use an enum indexed array.

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

-pub struct CursorShapeConfig([CursorKind; 3]);

-

-impl CursorShapeConfig {

- pub fn from_mode(&self, mode: Mode) -> CursorKind {

- self.get(mode as usize).copied().unwrap_or_default()

- }

-}

-

-impl<'de> Deserialize<'de> for CursorShapeConfig {

- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

- where

- D: Deserializer<'de>,

- {

- let m = HashMap::<Mode, CursorKind>::deserialize(deserializer)?;

- let into_cursor = |mode: Mode| m.get(&mode).copied().unwrap_or_default();

- Ok(CursorShapeConfig([

- into_cursor(Mode::Normal),

- into_cursor(Mode::Select),

- into_cursor(Mode::Insert),

- ]))

- }

-}

-

-impl Serialize for CursorShapeConfig {

- fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

- where

- S: serde::Serializer,

- {

- let mut map = serializer.serialize_map(Some(self.len()))?;

- let modes = [Mode::Normal, Mode::Select, Mode::Insert];

- for mode in modes {

- map.serialize_entry(&mode, &self.from_mode(mode))?;

- }

- map.end()

- }

-}

-

-impl std::ops::Deref for CursorShapeConfig {

- type Target = [CursorKind; 3];

-

- fn deref(&self) -> &Self::Target {

- &self.0

- }

-}

-

-impl Default for CursorShapeConfig {

- fn default() -> Self {

- Self([CursorKind::Block; 3])

- }

-}

-

-/// bufferline render modes

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

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

-pub enum BufferLine {

- /// Don't render bufferline

- #[default]

- Never,

- /// Always render

- Always,

- /// Only if multiple buffers are open

- Multiple,

-}

-

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

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

-pub enum LineNumber {

- /// Show absolute line number

- Absolute,

-

- /// If focused and in normal/select mode, show relative line number to the primary cursor.

- /// If unfocused or in insert mode, show absolute line number.

- Relative,

-}

-

-impl std::str::FromStr for LineNumber {

- type Err = anyhow::Error;

-

- fn from_str(s: &str) -> Result<Self, Self::Err> {

- match s.to_lowercase().as_str() {

- "absolute" | "abs" => Ok(Self::Absolute),

- "relative" | "rel" => Ok(Self::Relative),

- _ => anyhow::bail!("Line number can only be `absolute` or `relative`."),

- }

- }

-}

-

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

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

-pub enum GutterType {

- /// Show diagnostics and other features like breakpoints

- Diagnostics,

- /// Show line numbers

- LineNumbers,

- /// Show one blank space

- Spacer,

- /// Highlight local changes

- Diff,

-}

-

-impl std::str::FromStr for GutterType {

- type Err = anyhow::Error;

-

- fn from_str(s: &str) -> Result<Self, Self::Err> {

- match s.to_lowercase().as_str() {

- "diagnostics" => Ok(Self::Diagnostics),

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

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

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

- _ => anyhow::bail!(

- "Gutter type can only be `diagnostics`, `spacer`, `line-numbers` or `diff`."

- ),

- }

- }

-}

-

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

-#[serde(default)]

-pub struct WhitespaceConfig {

- pub render: WhitespaceRender,

- pub characters: WhitespaceCharacters,

-}

-

-impl Default for WhitespaceConfig {

- fn default() -> Self {

- Self {

- render: WhitespaceRender::Basic(WhitespaceRenderValue::None),

- characters: WhitespaceCharacters::default(),

- }

- }

-}

-

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

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

-pub enum WhitespaceRender {

- Basic(WhitespaceRenderValue),

- Specific {

- default: Option<WhitespaceRenderValue>,

- space: Option<WhitespaceRenderValue>,

- nbsp: Option<WhitespaceRenderValue>,

- nnbsp: Option<WhitespaceRenderValue>,

- tab: Option<WhitespaceRenderValue>,

- newline: Option<WhitespaceRenderValue>,

- },

-}

-

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

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

-pub enum WhitespaceRenderValue {

- None,

- // TODO

- // Selection,

- All,

-}

-

-impl WhitespaceRender {

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

- match *self {

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

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

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

- }

- }

- }

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

- match *self {

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

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

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

- }

- }

- }

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

- match *self {

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

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

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

- }

- }

- }

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

- match *self {

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

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

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

- }

- }

- }

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

- match *self {

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

- Self::Specific {

- default, newline, ..

- } => newline.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),

- }

-}

-

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

-#[serde(default)]

-pub struct WhitespaceCharacters {

- pub space: char,

- pub nbsp: char,

- pub nnbsp: char,

- pub tab: char,

- pub tabpad: char,

- pub newline: char,

-}

-

-impl Default for WhitespaceCharacters {

- fn default() -> Self {

- Self {

- space: '·', // U+00B7

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

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

- tab: '→', // U+2192

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

- tabpad: ' ',

- }

- }

-}

-

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

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

-pub struct IndentGuidesConfig {

- pub render: bool,

- pub character: char,

- pub skip_levels: u8,

-}

-

-impl Default for IndentGuidesConfig {

- fn default() -> Self {

- Self {

- skip_levels: 0,

- render: false,

- character: '│',

- }

- }

-}

-

-/// Line ending configuration.

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

-#[serde(rename_all = "lowercase")]

-pub enum LineEndingConfig {

- /// The platform's native line ending.

- ///

- /// `crlf` on Windows, otherwise `lf`.

- #[default]

- Native,

- /// Line feed.

- LF,

- /// Carriage return followed by line feed.

- Crlf,

- /// Form feed.

- #[cfg(feature = "unicode-lines")]

- FF,

- /// Carriage return.

- #[cfg(feature = "unicode-lines")]

- CR,

- /// Next line.

- #[cfg(feature = "unicode-lines")]

- Nel,

-}

-

-impl From<LineEndingConfig> for LineEnding {

- fn from(line_ending: LineEndingConfig) -> Self {

- match line_ending {

- LineEndingConfig::Native => NATIVE_LINE_ENDING,

- LineEndingConfig::LF => LineEnding::LF,

- LineEndingConfig::Crlf => LineEnding::Crlf,

- #[cfg(feature = "unicode-lines")]

- LineEndingConfig::FF => LineEnding::FF,

- #[cfg(feature = "unicode-lines")]

- LineEndingConfig::CR => LineEnding::CR,

- #[cfg(feature = "unicode-lines")]

- LineEndingConfig::Nel => LineEnding::Nel,

- }

- }

-}

-

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

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

-pub enum PopupBorderConfig {

- None,

- All,

- Popup,

- Menu,

-}

-

-#[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(),

- }

- }

-}

-

-impl Default for Config {

- fn default() -> Self {

- Self {

- scrolloff: 5,

- scroll_lines: 3,

- mouse: true,

- shell: if cfg!(windows) {

- vec!["cmd".to_owned(), "/C".to_owned()]

- } else {

- vec!["sh".to_owned(), "-c".to_owned()]

- },

- line_number: LineNumber::Absolute,

- cursorline: false,

- cursorcolumn: false,

- gutters: GutterConfig::default(),

- middle_click_paste: true,

- auto_pairs: AutoPairConfig::default(),

- auto_completion: true,

- path_completion: true,

- word_completion: WordCompletion::default(),

- auto_format: true,

- default_yank_register: '"',

- auto_save: AutoSave::default(),

- idle_timeout: Duration::from_millis(250),

- completion_timeout: Duration::from_millis(250),

- preview_completion_insert: true,

- completion_trigger_len: 2,

- auto_info: true,

- file_picker: FilePickerConfig::default(),

- file_explorer: FileExplorerConfig::default(),

- statusline: StatusLineConfig::default(),

- cursor_shape: CursorShapeConfig::default(),

- true_color: false,

- undercurl: false,

- search: SearchConfig::default(),

- lsp: LspConfig::default(),

- terminal: get_terminal_provider(),

- rulers: Vec::new(),

- whitespace: WhitespaceConfig::default(),

- bufferline: BufferLine::default(),

- indent_guides: IndentGuidesConfig::default(),

- color_modes: false,

- soft_wrap: SoftWrap {

- enable: Some(false),

- ..SoftWrap::default()

- },

- text_width: 80,

- completion_replace: false,

- continue_comments: true,

- workspace_lsp_roots: Vec::new(),

- default_line_ending: LineEndingConfig::default(),

- insert_final_newline: true,

- atomic_save: true,

- trim_final_newlines: false,

- trim_trailing_whitespace: false,

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

- popup_border: PopupBorderConfig::None,

- indent_heuristic: IndentationHeuristic::default(),

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

- }

- }

-}

-

-impl Default for SearchConfig {

- fn default() -> Self {

- Self {

- wrap_around: true,

- smart_case: true,

- }

- }

-}

-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 handlers: Handlers,

-

- pub mouse_down_range: Option<Range>,

- pub cursor_cache: CursorCache,

- LanguageServerMessage((LanguageServerId, Call)),

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

- Triggered,

- /// A savepoint of the currently selected completion. The savepoint

- /// MUST be restored before sending any event to the LSP

- Selected {

- savepoint: Arc<SavePoint>,

- },

- placeholder: bool,

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

- handlers: Handlers,

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

- handlers,

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

- })

- log::debug!("editor error: {}", error);

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

- }

-

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

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

- log::debug!(

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

- );

- } else {

- log::error!(

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

- language.scope,

- lang,

- err

- );

- }

- 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 path = helix_stdx::path::canonicalize(path);

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

- }

-}