Naive spellbook integration

Author: the-mikedavis

Cargo.lock

@@ -42,6 +42,7 @@ tree-sitter = { version = "0.22" }
 nucleo = "0.5.0"
 slotmap = "1.0.7"
 thiserror = "1.0"
+spellbook = { git = "https://github.com/helix-editor/spellbook.git" }
 
 [workspace.package]
 version = "24.7.0"

Cargo.toml

@@ -107,7 +107,8 @@ fn find_runtime_file(rel_path: &Path) -> Option<PathBuf> {
 /// The valid runtime directories are searched in priority order and the first
 /// file found to exist is returned, otherwise the path to the final attempt
 /// that failed.
-pub fn runtime_file(rel_path: &Path) -> PathBuf {
+pub fn runtime_file<P: AsRef<Path>>(rel_path: P) -> PathBuf {
+    let rel_path = rel_path.as_ref();
     find_runtime_file(rel_path).unwrap_or_else(|| {
         RUNTIME_DIRS
             .last()

helix-loader/src/lib.rs

@@ -20,14 +20,15 @@ use helix_core::{
     unicode::width::UnicodeWidthStr,
     visual_offset_from_block, Change, Position, Range, Selection, Transaction,
 };
+use helix_stdx::rope::RopeSliceExt;
 use helix_view::{
     annotations::diagnostics::DiagnosticFilter,
     document::{Mode, SavePoint, SCRATCH_BUFFER_NAME},
     editor::{CompleteAction, CursorShapeConfig},
     graphics::{Color, CursorKind, Modifier, Rect, Style},
     input::{KeyEvent, MouseButton, MouseEvent, MouseEventKind},
     keyboard::{KeyCode, KeyModifiers},
-    Document, Editor, Theme, View,
+    Dictionary, Document, Editor, Theme, View,
 };
 use std::{mem::take, num::NonZeroUsize, path::PathBuf, rc::Rc, sync::Arc};
 
@@ -154,6 +155,10 @@ impl EditorView {
             }
             overlay_highlights = Box::new(syntax::merge(overlay_highlights, diagnostic));
         }
+        let spell = Self::doc_spell_highlights(&editor.dictionary, doc, view, theme);
+        if !spell.is_empty() {
+            overlay_highlights = Box::new(syntax::merge(overlay_highlights, spell));
+        }
 
         if is_focused {
             let mut highlights = syntax::merge(
@@ -506,6 +511,55 @@ impl EditorView {
         ]
     }
 
+    pub fn doc_spell_highlights(
+        dict: &Dictionary,
+        doc: &Document,
+        view: &View,
+        theme: &Theme,
+    ) -> Vec<(usize, std::ops::Range<usize>)> {
+        // This is **very** ***very*** naive and not at all reflective of what the actual
+        // integration will look like. Doing this per-render is very needlessly expensive.
+        // Instead it should be done in the background and possibly incrementally (only
+        // re-checking ranges that are affected by document changes). However regex-cursor
+        // is very fast and so is spellbook (degenerate cases max out at 1μs in a release
+        // build on my machine, i.e. a worst case throughput of 2 million words / second) so
+        // this is suitable for my testing. I mostly want to find cases where spellbook's
+        // results are surprising.
+        // Also we want to use tree-sitter to mark nodes as ones that should be spellchecked
+        // and maybe specify strategies for doing tokenization (try to tokenize prose vs.
+        // programming languages).
+        // Plus these should really be proper diagnostics so that we can pull them up in the
+        // diagnostics picker and jump to them.
+        use helix_stdx::rope::Regex;
+        use once_cell::sync::Lazy;
+        use std::borrow::Cow;
+        static WORDS: Lazy<Regex> = Lazy::new(|| Regex::new(r#"[0-9A-Z]*(['-]?[a-z]+)*"#).unwrap());
+
+        let mut spans = Vec::new();
+        let error = theme.find_scope_index("diagnostic.error").unwrap();
+
+        let text = doc.text().slice(..);
+        let start = text.line_to_char(text.char_to_line(doc.view_offset(view.id).anchor));
+        let end = text.line_to_char(view.estimate_last_doc_line(doc) + 1);
+
+        for match_ in WORDS.find_iter(text.regex_input_at(start..end)) {
+            let range = text.byte_to_char(match_.start())..text.byte_to_char(match_.end());
+            // TODO: consider how to allow passing the RopeSlice to spellbook:
+            // * Use an Input trait like regex-cursor?
+            // * Accept `impl Iterator<Item = char>`?
+            // * Maybe spellbook should have an internal `String` buffer and it should try to copy
+            //   the word into that? Only in the best case do you not have to allocate at all.
+            //   Maybe we should use a single string buffer and perform all changes to the string
+            //   in-place instead of using `replace` from the stdlib and Cows.
+            let word = Cow::from(text.slice(range.clone()));
+            if !dict.check(&word) {
+                spans.push((error, range))
+            }
+        }
+
+        spans
+    }
+
     /// Get highlight spans for selections in a document view.
     pub fn doc_selection_highlights(
         mode: Mode,

helix-term/src/ui/editor.rs

@@ -52,6 +52,8 @@ log = "~0.4"
 parking_lot = "0.12.3"
 thiserror.workspace = true
 
+spellbook.workspace = true
+
 [target.'cfg(windows)'.dependencies]
 clipboard-win = { version = "5.4", features = ["std"] }
 

helix-view/Cargo.toml

@@ -11,7 +11,7 @@ use crate::{
     register::Registers,
     theme::{self, Theme},
     tree::{self, Tree},
-    Document, DocumentId, View, ViewId,
+    Dictionary, Document, DocumentId, View, ViewId,
 };
 use dap::StackFrame;
 use helix_event::dispatch;
@@ -1087,6 +1087,9 @@ pub struct Editor {
 
     pub mouse_down_range: Option<Range>,
     pub cursor_cache: CursorCache,
+
+    /// HACK:
+    pub dictionary: Dictionary,
 }
 
 pub type Motion = Box<dyn Fn(&mut Editor)>;
@@ -1167,6 +1170,16 @@ impl Editor {
         // HAXX: offset the render area height by 1 to account for prompt/commandline
         area.height -= 1;
 
+        // HACK:
+        let aff =
+            std::fs::read_to_string(helix_loader::runtime_file("dictionaries/en_US/en_US.aff"))
+                .unwrap();
+        let dic =
+            std::fs::read_to_string(helix_loader::runtime_file("dictionaries/en_US/en_US.dic"))
+                .unwrap();
+        let mut dictionary = Dictionary::new(&aff, &dic).unwrap();
+        dictionary.add("khepri").unwrap();
+
         Self {
             mode: Mode::Normal,
             tree: Tree::new(area),
@@ -1205,6 +1218,7 @@ impl Editor {
             handlers,
             mouse_down_range: None,
             cursor_cache: CursorCache::default(),
+            dictionary,
         }
     }
 

helix-view/src/editor.rs

@@ -75,5 +75,6 @@ pub fn align_view(doc: &mut Document, view: &View, align: Align) {
 pub use document::Document;
 pub use editor::Editor;
 use helix_core::char_idx_at_visual_offset;
+pub use spellbook::Dictionary;
 pub use theme::Theme;
 pub use view::View;