Render spell diagnostics when command is executed

Author: connorlay

helix-spell/src/client.rs

@@ -8,20 +8,19 @@ pub struct Client {
 
 impl Client {
     pub fn new() -> Self {
+        // TODO: accept lang as an argument, configurable by the user
         let lang = "en_US";
         let checker = SpellLauncher::new()
             .aspell()
             .dictionary(lang)
             .launch()
+            // TODO: instead of unwrap (which panics), figure out proper error handling
             .unwrap();
-        // TODO: instead of unwrap (which panics), figure out proper error handling
         Self { checker, lang }
     }
     pub fn check(&mut self, string: &str) -> Vec<IspellError> {
         self.checker.check(string).unwrap_or(Vec::new())
     }
 }
 
-// TODO: use helix_core::Diagnostic to represent a mispelling
-// note: Range start is the location of total characters, regardless of "lines"
-// thus, we can probably send the entire string to aspell and things should work alright
+// TODO: expose the ability to add words to a user's dictionary, which the ispell crate supports

helix-spell/src/lib.rs

@@ -18,8 +18,8 @@ mod tests {
         let word = "This sentence contains a misssspelled word";
         let errors = client.check(word);
         let error = errors.first().unwrap();
-        assert_eq!(error.word, "misssspelled");
-        assert_eq!(error.pos, 25);
+        assert_eq!(error.misspelled, "misssspelled");
+        assert_eq!(error.position, 25);
     }
 
     #[test]

helix-term/src/application.rs

@@ -326,6 +326,9 @@ impl Application {
                     // idle timeout
                     self.editor.clear_idle_timer();
                     self.handle_idle_timeout();
+                    // HACK: force rendering until I can figure out how
+                    // async jobs work
+                    self.render();
 
                     #[cfg(feature = "integration")]
                     {

helix-term/src/commands/typed.rs

@@ -341,8 +341,8 @@ fn spell_check(
         return Ok(());
     }
     let doc = doc_mut!(cx.editor);
-    // TODO: make this async via a Job?
-    doc.spell_check();
+    let mut diagnostics = doc.spell_check();
+    doc.add_diagnostics(diagnostics.as_mut());
     Ok(())
 }
 

helix-view/src/document.rs

@@ -119,6 +119,7 @@ pub struct Document {
     version: i32, // should be usize?
     pub(crate) modified_since_accessed: bool,
 
+    // TODO: add a seperate spell diagnostics list decoupled from the language server?
     diagnostics: Vec<Diagnostic>,
     language_server: Option<Arc<helix_lsp::Client>>,
 }
@@ -393,7 +394,7 @@ impl Document {
         Ok(doc)
     }
 
-    pub fn spell_check(&mut self) {
+    pub fn spell_check(&mut self) -> Vec<Diagnostic> {
         let mut diagnostics = Vec::new();
         if let Some(node) = self.syntax() {
             let mut spell_checker = helix_spell::Client::new();
@@ -418,17 +419,19 @@ impl Document {
                                     end: position + error.position + word_count,
                                 },
                                 message: error.suggestions.join("\n"),
-                                severity: Some(diagnostic::Severity::Hint),
+                                severity: Some(diagnostic::Severity::Warning),
                                 code: None,
                             };
                             diagnostics.push(diagnostic);
+                            // TODO: don't set doc diagnostics here, simply return the Vec<Diagnostic> instead
+                            // and have the caller decide how to handle it
                         }
                         position += line.len_chars();
                     }
                 }
             };
         };
-        self.add_diagnostics(diagnostics.as_mut());
+        diagnostics
     }
 
     pub fn auto_format(&self) -> Option<BoxFuture<'static, Result<Transaction, FormatterError>>> {