Implement EditorConfig support

helix-view/Cargo.toml

@@ -39,6 +39,8 @@ log = "~0.4"
 
 which = "4.2"
 
+ec4rs = "1.0.0-rc.1"
+
 [target.'cfg(windows)'.dependencies]
 clipboard-win = { version = "4.4", features = ["std"] }
 

helix-view/src/document.rs

@@ -371,25 +371,54 @@ impl Document {
         encoding: Option<&'static encoding::Encoding>,
         config_loader: Option<Arc<syntax::Loader>>,
     ) -> Result<Self, Error> {
-        // Open the file if it exists, otherwise assume it is a new file (and thus empty).
-        let (rope, encoding) = if path.exists() {
+        Self::open_with_config(path, config_loader, move |_| {
+            Config::from_encoding(encoding)
+        })
+    }
+
+    // TODO: async fn?
+    /// Create a new document from `path`,
+    /// using document settings from a [Config].
+    pub fn open_with_config(
+        path: &Path,
+        lang_config_loader: Option<Arc<syntax::Loader>>,
+        doc_config_fn: impl FnOnce(&Path) -> Config,
+    ) -> Result<Self, Error> {
+        let (rope, config) = if path.exists() {
             let mut file =
                 std::fs::File::open(path).context(format!("unable to open {:?}", path))?;
-            from_reader(&mut file, encoding)?
+            let mut config = doc_config_fn(path);
+            // Not using destructuring assignment here.
+            let (rope, encoding) = from_reader(&mut file, config.encoding)?;
+            config.encoding = Some(encoding);
+            (rope, config)
         } else {
-            let encoding = encoding.unwrap_or(encoding::UTF_8);
-            (Rope::from(DEFAULT_LINE_ENDING.as_str()), encoding)
+            let mut config = doc_config_fn(path);
+            config.encoding = config.encoding.or(Some(encoding::UTF_8));
+            (Rope::from(DEFAULT_LINE_ENDING.as_str()), config)
         };
 
-        let mut doc = Self::from(rope, Some(encoding));
+        let mut doc = Self::from(rope, config.encoding);
 
-        // set the path and try detecting the language
+        // Set the path and try detecting the language.
         doc.set_path(Some(path))?;
-        if let Some(loader) = config_loader {
+        if let Some(loader) = lang_config_loader {
             doc.detect_language(loader);
         }
 
-        doc.detect_indent_and_line_ending();
+        // Set the indent style.
+        if let Some(indent_style) = config.indent_style {
+            doc.indent_style = indent_style;
+        } else {
+            doc.detect_indent_impl();
+        }
+
+        // Set the line ending.
+        if let Some(line_ending) = config.line_ending {
+            doc.line_ending = line_ending;
+        } else {
+            doc.detect_line_ending_impl();
+        }
 
         Ok(doc)
     }
@@ -517,11 +546,19 @@ impl Document {
     /// specified. Line ending is likewise auto-detected, and will fallback to the default OS
     /// line ending.
     pub fn detect_indent_and_line_ending(&mut self) {
+        self.detect_indent_impl();
+        self.detect_line_ending_impl();
+    }
+
+    fn detect_indent_impl(&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))
         });
+    }
+
+    fn detect_line_ending_impl(&mut self) {
         self.line_ending = auto_detect_line_ending(&self.text).unwrap_or(DEFAULT_LINE_ENDING);
     }
 
@@ -978,6 +1015,63 @@ impl Default for Document {
     }
 }
 
+#[derive(Clone, Copy, PartialEq, Debug, Default)]
+pub struct Config {
+    pub encoding: Option<&'static encoding::Encoding>,
+    pub line_ending: Option<LineEnding>,
+    pub indent_style: Option<IndentStyle>,
+}
+
+impl Config {
+    /// Create a version of this config with any `None` fields
+    /// filled in with values from the config passed to `other`.
+    pub fn merged(self, other: Config) -> Config {
+        // Crate `merge` isn't used here, so this will do.
+        Config {
+            encoding: self.encoding.or(other.encoding),
+            line_ending: self.line_ending.or(other.line_ending),
+            indent_style: self.indent_style.or(other.indent_style),
+        }
+    }
+
+    /// Wraps an optional encoding in a `Config`, using default values for everything else.
+    pub fn from_encoding(encoding: Option<&'static encoding::Encoding>) -> Config {
+        Config {
+            encoding,
+            ..Default::default()
+        }
+    }
+
+    /// Tries to parse a config from editorconfig properties.
+    pub fn try_from_editorconfig(for_file_at: &std::path::Path) -> Result<Config, ec4rs::Error> {
+        let mut ecfg = ec4rs::config_for(for_file_at)?;
+        ecfg.use_fallbacks();
+
+        use ec4rs::property::{Charset, EndOfLine, IndentSize, IndentStyle as EcIndentStyle};
+        Ok(Config {
+            encoding: ecfg
+                .get_raw::<Charset>()
+                .filter_unset()
+                .into_result()
+                .ok()
+                .and_then(|string| encoding::Encoding::for_label(string.to_lowercase().as_bytes())),
+            indent_style: match (ecfg.get::<EcIndentStyle>(), ecfg.get::<IndentSize>()) {
+                (Ok(EcIndentStyle::Tabs), _) => Some(IndentStyle::Tabs),
+                (Ok(EcIndentStyle::Spaces), Ok(IndentSize::Value(n))) => {
+                    Some(IndentStyle::Spaces(n.try_into().unwrap_or(u8::MAX)))
+                }
+                _ => None,
+            },
+            line_ending: match ecfg.get::<EndOfLine>() {
+                Ok(EndOfLine::Cr) => Some(LineEnding::CR),
+                Ok(EndOfLine::Lf) => Some(LineEnding::LF),
+                Ok(EndOfLine::CrLf) => Some(LineEnding::Crlf),
+                Err(_) => None,
+            },
+        })
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

helix-view/src/editor.rs

@@ -1,6 +1,6 @@
 use crate::{
     clipboard::{get_clipboard_provider, ClipboardProvider},
-    document::{Mode, SCRATCH_BUFFER_NAME},
+    document::{self, Mode, SCRATCH_BUFFER_NAME},
     graphics::{CursorKind, Rect},
     info::Info,
     input::KeyEvent,
@@ -123,6 +123,9 @@ pub struct Config {
     /// Search configuration.
     #[serde(default)]
     pub search: SearchConfig,
+    /// Whether to use [EditorConfig](https://editorconfig.org/).
+    /// Defaults to `true`.
+    pub editorconfig: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -233,6 +236,7 @@ impl Default for Config {
             cursor_shape: CursorShapeConfig::default(),
             true_color: false,
             search: SearchConfig::default(),
+            editorconfig: true,
         }
     }
 }
@@ -587,7 +591,20 @@ impl Editor {
         let id = if let Some(id) = id {
             id
         } else {
-            let mut doc = Document::open(&path, None, Some(self.syn_loader.clone()))?;
+            let syn_loader = Some(self.syn_loader.clone());
+            let mut doc = if self.config.editorconfig {
+                Document::open_with_config(&path, syn_loader, |path| {
+                    match document::Config::try_from_editorconfig(path) {
+                        Ok(cfg) => cfg,
+                        Err(_) => {
+                            //TODO: Log error.
+                            document::Config::default()
+                        }
+                    }
+                })?
+            } else {
+                Document::open(&path, None, syn_loader)?
+            };
 
             let _ = Self::launch_language_server(&mut self.language_servers, &mut doc);