Unnamed repository; edit this file 'description' to name the repository.
Support EditorConfig (#13056)
| -rw-r--r-- | book/src/editor.md | 1 | ||||
| -rw-r--r-- | helix-core/src/editor_config.rs | 333 | ||||
| -rw-r--r-- | helix-core/src/lib.rs | 1 | ||||
| -rw-r--r-- | helix-term/src/commands/typed.rs | 12 | ||||
| -rw-r--r-- | helix-view/src/document.rs | 84 | ||||
| -rw-r--r-- | helix-view/src/editor.rs | 6 |
6 files changed, 415 insertions, 22 deletions
diff --git a/book/src/editor.md b/book/src/editor.md index 79f7284c..3fe650e0 100644 --- a/book/src/editor.md +++ b/book/src/editor.md @@ -60,6 +60,7 @@ | `jump-label-alphabet` | The characters that are used to generate two character jump labels. Characters at the start of the alphabet are used first. | `"abcdefghijklmnopqrstuvwxyz"` | `end-of-line-diagnostics` | Minimum severity of diagnostics to render at the end of the line. Set to `disable` to disable entirely. Refer to the setting about `inline-diagnostics` for more details | "disable" | `clipboard-provider` | Which API to use for clipboard interaction. One of `pasteboard` (MacOS), `wayland`, `x-clip`, `x-sel`, `win-32-yank`, `termux`, `tmux`, `windows`, `termcode`, `none`, or a custom command set. | Platform and environment specific. | +| `editor-config` | Whether to read settings from [EditorConfig](https://editorconfig.org) files | `true` | ### `[editor.clipboard-provider]` Section diff --git a/helix-core/src/editor_config.rs b/helix-core/src/editor_config.rs new file mode 100644 index 00000000..714f577c --- /dev/null +++ b/helix-core/src/editor_config.rs @@ -0,0 +1,333 @@ +//! Support for [EditorConfig](https://EditorConfig.org) configuration loading. +//! +//! EditorConfig is an editor-agnostic format for specifying configuration in an INI-like, human +//! friendly syntax in `.editorconfig` files (which are intended to be checked into VCS). This +//! module provides functions to search for all `.editorconfig` files that apply to a given path +//! and returns an `EditorConfig` type containing any specified configuration options. +//! +//! At time of writing, this module follows the [spec](https://spec.editorconfig.org/) at +//! version 0.17.2. + +use std::{ + collections::HashMap, + fs, + num::{NonZeroU16, NonZeroU8}, + path::Path, + str::FromStr, +}; + +use encoding_rs::Encoding; +use globset::{GlobBuilder, GlobMatcher}; + +use crate::{ + indent::{IndentStyle, MAX_INDENT}, + LineEnding, +}; + +/// Configuration declared for a path in `.editorconfig` files. +#[derive(Debug, Default, PartialEq, Eq)] +pub struct EditorConfig { + pub indent_style: Option<IndentStyle>, + pub tab_width: Option<NonZeroU8>, + pub line_ending: Option<LineEnding>, + pub encoding: Option<&'static Encoding>, + // pub spelling_language: Option<SpellingLanguage>, + pub trim_trailing_whitespace: Option<bool>, + pub insert_final_newline: Option<bool>, + pub max_line_length: Option<NonZeroU16>, +} + +impl EditorConfig { + /// Finds any configuration in `.editorconfig` files which applies to the given path. + /// + /// If no configuration applies then `EditorConfig::default()` is returned. + pub fn find(path: &Path) -> Self { + let mut configs = Vec::new(); + // <https://spec.editorconfig.org/#file-processing> + for ancestor in path.ancestors() { + let editor_config_file = ancestor.join(".editorconfig"); + let Ok(contents) = fs::read_to_string(&editor_config_file) else { + continue; + }; + let ini = match contents.parse::<Ini>() { + Ok(ini) => ini, + Err(err) => { + log::warn!("Ignoring EditorConfig file at '{editor_config_file:?}' because a glob failed to compile: {err}"); + continue; + } + }; + let is_root = ini.pairs.get("root").map(AsRef::as_ref) == Some("true"); + configs.push((ini, ancestor)); + // > The search shall stop if an EditorConfig file is found with the `root` key set to + // > `true` in the preamble or when reaching the root filesystem directory. + if is_root { + break; + } + } + + let mut pairs = Pairs::new(); + // Reverse the configuration stack so that the `.editorconfig` files closest to `path` + // are applied last and overwrite settings in files closer to the search ceiling. + // + // > If multiple EditorConfig files have matching sections, the pairs from the closer + // > EditorConfig file are read last, so pairs in closer files take precedence. + for (config, dir) in configs.into_iter().rev() { + let relative_path = path.strip_prefix(dir).expect("dir is an ancestor of path"); + + for section in config.sections { + if section.glob.is_match(relative_path) { + log::info!( + "applying EditorConfig from section '{}' in file {:?}", + section.glob.glob(), + dir.join(".editorconfig") + ); + pairs.extend(section.pairs); + } + } + } + + Self::from_pairs(pairs) + } + + fn from_pairs(pairs: Pairs) -> Self { + enum IndentSize { + Tab, + Spaces(NonZeroU8), + } + + // <https://spec.editorconfig.org/#supported-pairs> + let indent_size = pairs.get("indent_size").and_then(|value| { + if value.as_ref() == "tab" { + Some(IndentSize::Tab) + } else if let Ok(spaces) = value.parse::<NonZeroU8>() { + Some(IndentSize::Spaces(spaces)) + } else { + None + } + }); + let tab_width = pairs + .get("tab_width") + .and_then(|value| value.parse::<NonZeroU8>().ok()) + .or(match indent_size { + Some(IndentSize::Spaces(spaces)) => Some(spaces), + _ => None, + }); + let indent_style = pairs + .get("indent_style") + .and_then(|value| match value.as_ref() { + "tab" => Some(IndentStyle::Tabs), + "space" => { + let spaces = match indent_size { + Some(IndentSize::Spaces(spaces)) => spaces.get(), + Some(IndentSize::Tab) => tab_width.map(|n| n.get()).unwrap_or(4), + None => 4, + }; + Some(IndentStyle::Spaces(spaces.clamp(1, MAX_INDENT))) + } + _ => None, + }); + let line_ending = pairs + .get("end_of_line") + .and_then(|value| match value.as_ref() { + "lf" => Some(LineEnding::LF), + "crlf" => Some(LineEnding::Crlf), + #[cfg(feature = "unicode-lines")] + "cr" => Some(LineEnding::CR), + _ => None, + }); + let encoding = pairs.get("charset").and_then(|value| match value.as_ref() { + "latin1" => Some(encoding_rs::WINDOWS_1252), + "utf-8" => Some(encoding_rs::UTF_8), + // `utf-8-bom` is intentionally ignored. + // > `utf-8-bom` is discouraged. + "utf-16le" => Some(encoding_rs::UTF_16LE), + "utf-16be" => Some(encoding_rs::UTF_16BE), + _ => None, + }); + let trim_trailing_whitespace = + pairs + .get("trim_trailing_whitespace") + .and_then(|value| match value.as_ref() { + "true" => Some(true), + "false" => Some(false), + _ => None, + }); + let insert_final_newline = pairs + .get("insert_final_newline") + .and_then(|value| match value.as_ref() { + "true" => Some(true), + "false" => Some(false), + _ => None, + }); + // This option is not in the spec but is supported by some editors. + // <https://github.com/editorconfig/editorconfig/wiki/EditorConfig-Properties#max_line_length> + let max_line_length = pairs + .get("max_line_length") + .and_then(|value| value.parse::<NonZeroU16>().ok()); + + Self { + indent_style, + tab_width, + line_ending, + encoding, + trim_trailing_whitespace, + insert_final_newline, + max_line_length, + } + } +} + +type Pairs = HashMap<Box<str>, Box<str>>; + +#[derive(Debug)] +struct Section { + glob: GlobMatcher, + pairs: Pairs, +} + +#[derive(Debug, Default)] +struct Ini { + pairs: Pairs, + sections: Vec<Section>, +} + +impl FromStr for Ini { + type Err = globset::Error; + + fn from_str(source: &str) -> Result<Self, Self::Err> { + // <https://spec.editorconfig.org/#file-format> + let mut ini = Ini::default(); + // > EditorConfig files are in an INI-like file format. To read an EditorConfig file, take + // > one line at a time, from beginning to end. For each line: + for full_line in source.lines() { + // > 1. Remove all leading and trailing whitespace. + let line = full_line.trim(); + // > 2. Process the remaining text as specified for its type below. + // > The types of lines are: + // > * Blank: contains nothing. Blank lines are ignored. + if line.is_empty() { + continue; + } + // > * Comment: starts with a ';' or '#'. Comment lines are ignored. + if line.starts_with([';', '#']) { + continue; + } + if let Some(section) = line.strip_prefix('[').and_then(|s| s.strip_suffix(']')) { + // > * Section Header: starts with a `[` and ends with a `]`. These lines define + // > globs... + + // <https://spec.editorconfig.org/#glob-expressions> + // We need to modify the glob string slightly since EditorConfig's glob flavor + // doesn't match `globset`'s exactly. `globset` only allows '**' at the beginning + // or end of a glob or between two '/'s. (This replacement is not very fancy but + // should cover most practical cases.) + let mut glob_str = section.replace("**.", "**/*."); + if !is_glob_relative(section) { + glob_str.insert_str(0, "**/"); + } + let glob = GlobBuilder::new(&glob_str) + .literal_separator(true) + .backslash_escape(true) + .build()?; + ini.sections.push(Section { + glob: glob.compile_matcher(), + pairs: Pairs::new(), + }); + } else if let Some((key, value)) = line.split_once('=') { + // > * Key-Value Pair (or Pair): contains a key and a value, separated by an `=`. + // > * Key: The part before the first `=` on the line. + // > * Value: The part, if any, after the first `=` on the line. + // > * Keys and values are trimmed of leading and trailing whitespace, but + // > include any whitespace that is between non-whitespace characters. + // > * If a value is not provided, then the value is an empty string. + let key = key.trim().to_lowercase().into_boxed_str(); + let value = value.trim().to_lowercase().into_boxed_str(); + if let Some(section) = ini.sections.last_mut() { + section.pairs.insert(key, value); + } else { + ini.pairs.insert(key, value); + } + } + } + Ok(ini) + } +} + +/// Determines whether a glob is relative to the directory of the config file. +fn is_glob_relative(source: &str) -> bool { + // > If the glob contains a path separator (a `/` not inside square brackets), then the + // > glob is relative to the directory level of the particular `.editorconfig` file itself. + let mut idx = 0; + while let Some(open) = source[idx..].find('[').map(|open| idx + open) { + if source[..open].contains('/') { + return true; + } + idx = source[open..] + .find(']') + .map_or(source.len(), |close| idx + close); + } + source[idx..].contains('/') +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn is_glob_relative_test() { + assert!(is_glob_relative("subdir/*.c")); + assert!(!is_glob_relative("*.txt")); + assert!(!is_glob_relative("[a/b].c")); + } + + fn editor_config(path: impl AsRef<Path>, source: &str) -> EditorConfig { + let path = path.as_ref(); + let ini = source.parse::<Ini>().unwrap(); + let pairs = ini + .sections + .into_iter() + .filter(|section| section.glob.is_match(path)) + .fold(Pairs::new(), |mut acc, section| { + acc.extend(section.pairs); + acc + }); + EditorConfig::from_pairs(pairs) + } + + #[test] + fn parse_test() { + let source = r#" + [*] + indent_style = space + + [Makefile] + indent_style = tab + + [docs/**.txt] + insert_final_newline = true + "#; + + assert_eq!( + editor_config("a.txt", source), + EditorConfig { + indent_style: Some(IndentStyle::Spaces(4)), + ..Default::default() + } + ); + assert_eq!( + editor_config("pkg/Makefile", source), + EditorConfig { + indent_style: Some(IndentStyle::Tabs), + ..Default::default() + } + ); + assert_eq!( + editor_config("docs/config/editor.txt", source), + EditorConfig { + indent_style: Some(IndentStyle::Spaces(4)), + insert_final_newline: Some(true), + ..Default::default() + } + ); + } +} diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs index 02107b33..3fcddfcd 100644 --- a/helix-core/src/lib.rs +++ b/helix-core/src/lib.rs @@ -10,6 +10,7 @@ pub mod config; pub mod diagnostic; pub mod diff; pub mod doc_formatter; +pub mod editor_config; pub mod fuzzy; pub mod graphemes; pub mod history; diff --git a/helix-term/src/commands/typed.rs b/helix-term/src/commands/typed.rs index fd741bf9..b570e50b 100644 --- a/helix-term/src/commands/typed.rs +++ b/helix-term/src/commands/typed.rs @@ -326,13 +326,13 @@ fn write_impl(cx: &mut compositor::Context, path: Option<&str>, force: bool) -> let jobs = &mut cx.jobs; let (view, doc) = current!(cx.editor); - if config.trim_trailing_whitespace { + if doc.trim_trailing_whitespace() { trim_trailing_whitespace(doc, view.id); } if config.trim_final_newlines { trim_final_newlines(doc, view.id); } - if config.insert_final_newline { + if doc.insert_final_newline() { insert_final_newline(doc, view.id); } @@ -738,13 +738,13 @@ pub fn write_all_impl( let doc = doc_mut!(cx.editor, &doc_id); let view = view_mut!(cx.editor, target_view); - if config.trim_trailing_whitespace { + if doc.trim_trailing_whitespace() { trim_trailing_whitespace(doc, target_view); } if config.trim_final_newlines { trim_final_newlines(doc, target_view); } - if config.insert_final_newline { + if doc.insert_final_newline() { insert_final_newline(doc, target_view); } @@ -2146,7 +2146,6 @@ fn reflow(cx: &mut compositor::Context, args: Args, event: PromptEvent) -> anyho } let scrolloff = cx.editor.config().scrolloff; - let cfg_text_width: usize = cx.editor.config().text_width; let (view, doc) = current!(cx.editor); // Find the text_width by checking the following sources in order: @@ -2157,8 +2156,7 @@ fn reflow(cx: &mut compositor::Context, args: Args, event: PromptEvent) -> anyho .first() .map(|num| num.parse::<usize>()) .transpose()? - .or_else(|| doc.language_config().and_then(|config| config.text_width)) - .unwrap_or(cfg_text_width); + .unwrap_or_else(|| doc.text_width()); let rope = doc.text(); diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index 1c58eda2..ee5cb468 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -31,6 +31,7 @@ use std::sync::{Arc, Weak}; use std::time::SystemTime; use helix_core::{ + editor_config::EditorConfig, encoding, history::{History, State, UndoKind}, indent::{auto_detect_indent_style, IndentStyle}, @@ -50,6 +51,7 @@ use crate::{ const BUF_SIZE: usize = 8192; const DEFAULT_INDENT: IndentStyle = IndentStyle::Tabs; +const DEFAULT_TAB_WIDTH: usize = 4; pub const DEFAULT_LANGUAGE_NAME: &str = "text"; @@ -157,6 +159,7 @@ pub struct Document { /// Current indent style. pub indent_style: IndentStyle, + editor_config: EditorConfig, /// The document's default line ending. pub line_ending: LineEnding, @@ -678,6 +681,7 @@ impl Document { inlay_hints_oudated: false, view_data: Default::default(), indent_style: DEFAULT_INDENT, + editor_config: EditorConfig::default(), line_ending, restore_cursor: false, syntax: None, @@ -712,7 +716,7 @@ impl Document { /// overwritten with the `encoding` parameter. pub fn open( path: &Path, - encoding: Option<&'static Encoding>, + mut encoding: Option<&'static Encoding>, config_loader: Option<Arc<ArcSwap<syntax::Loader>>>, config: Arc<dyn DynAccess<Config>>, ) -> Result<Self, DocumentOpenError> { @@ -721,12 +725,21 @@ impl Document { return Err(DocumentOpenError::IrregularFile); } + let editor_config = if config.load().editor_config { + EditorConfig::find(path) + } else { + EditorConfig::default() + }; + encoding = encoding.or(editor_config.encoding); + // Open the file if it exists, otherwise assume it is a new file (and thus empty). let (rope, encoding, has_bom) = if path.exists() { let mut file = std::fs::File::open(path)?; from_reader(&mut file, encoding)? } else { - let line_ending: LineEnding = config.load().default_line_ending.into(); + let line_ending = editor_config + .line_ending + .unwrap_or_else(|| config.load().default_line_ending.into()); let encoding = encoding.unwrap_or(encoding::UTF_8); (Rope::from(line_ending.as_str()), encoding, false) }; @@ -739,6 +752,7 @@ impl Document { doc.detect_language(loader); } + doc.editor_config = editor_config; doc.detect_indent_and_line_ending(); Ok(doc) @@ -1090,16 +1104,32 @@ impl Document { /// configured in `languages.toml`, with a fallback to tabs if it isn't specified. Line ending /// is likewise auto-detected, and will remain unchanged if no line endings were detected. pub fn detect_indent_and_line_ending(&mut self) { - self.indent_style = auto_detect_indent_style(&self.text).unwrap_or_else(|| { - self.language_config() - .and_then(|config| config.indent.as_ref()) - .map_or(DEFAULT_INDENT, |config| IndentStyle::from_str(&config.unit)) - }); - if let Some(line_ending) = auto_detect_line_ending(&self.text) { + self.indent_style = if let Some(indent_style) = self.editor_config.indent_style { + indent_style + } else { + auto_detect_indent_style(&self.text).unwrap_or_else(|| { + self.language_config() + .and_then(|config| config.indent.as_ref()) + .map_or(DEFAULT_INDENT, |config| IndentStyle::from_str(&config.unit)) + }) + }; + if let Some(line_ending) = self + .editor_config + .line_ending + .or_else(|| auto_detect_line_ending(&self.text)) + { self.line_ending = line_ending; } } + pub(crate) fn detect_editor_config(&mut self) { + if self.config.load().editor_config { + if let Some(path) = self.path.as_ref() { + self.editor_config = EditorConfig::find(path); + } + } + } + pub fn pickup_last_saved_time(&mut self) { self.last_saved_time = match self.path() { Some(path) => match path.metadata() { @@ -1819,9 +1849,14 @@ impl Document { /// The width that the tab character is rendered at pub fn tab_width(&self) -> usize { - self.language_config() - .and_then(|config| config.indent.as_ref()) - .map_or(4, |config| config.tab_width) // fallback to 4 columns + self.editor_config + .tab_width + .map(|n| n.get() as usize) + .unwrap_or_else(|| { + self.language_config() + .and_then(|config| config.indent.as_ref()) + .map_or(DEFAULT_TAB_WIDTH, |config| config.tab_width) + }) } // The width (in spaces) of a level of indentation. @@ -1829,6 +1864,20 @@ impl Document { self.indent_style.indent_width(self.tab_width()) } + /// Whether the document should have a trailing line ending appended on save. + pub fn insert_final_newline(&self) -> bool { + self.editor_config + .insert_final_newline + .unwrap_or_else(|| self.config.load().insert_final_newline) + } + + /// Whether the document should trim whitespace preceding line endings on save. + pub fn trim_trailing_whitespace(&self) -> bool { + self.editor_config + .trim_trailing_whitespace + .unwrap_or_else(|| self.config.load().trim_trailing_whitespace) + } + pub fn changes(&self) -> &ChangeSet { &self.changes } @@ -2087,12 +2136,17 @@ impl Document { } } + pub fn text_width(&self) -> usize { + self.editor_config + .max_line_length + .map(|n| n.get() as usize) + .or_else(|| self.language_config().and_then(|config| config.text_width)) + .unwrap_or_else(|| self.config.load().text_width) + } + pub fn text_format(&self, mut viewport_width: u16, theme: Option<&Theme>) -> TextFormat { let config = self.config.load(); - let text_width = self - .language_config() - .and_then(|config| config.text_width) - .unwrap_or(config.text_width); + let text_width = self.text_width(); let mut soft_wrap_at_text_width = self .language_config() .and_then(|config| { diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index cdc48a54..e6a585d6 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -366,6 +366,9 @@ pub struct Config { 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, } #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, Eq, PartialOrd, Ord)] @@ -1009,6 +1012,7 @@ impl Default for Config { inline_diagnostics: InlineDiagnosticsConfig::default(), end_of_line_diagnostics: DiagnosticFilter::Disable, clipboard_provider: ClipboardProvider::default(), + editor_config: true, } } } @@ -1456,6 +1460,7 @@ impl Editor { // 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) } @@ -1463,6 +1468,7 @@ impl Editor { let loader = self.syn_loader.clone(); 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); |