feat: implement basic virtual text (end of line blame)

helix-term/src/handlers/blame.rs

@@ -1,4 +1,4 @@
-#![allow(dead_code, unused_variables)]
+use helix_core::text_annotations::InlineAnnotation;
 use helix_event::{register_hook, send_blocking};
 use helix_view::{
     handlers::{BlameEvent, Handlers},
@@ -14,14 +14,15 @@ impl helix_event::AsyncHook for BlameHandler {
 
     fn handle_event(
         &mut self,
-        event: Self::Event,
+        _event: Self::Event,
-        timeout: Option<tokio::time::Instant>,
+        _timeout: Option<tokio::time::Instant>,
     ) -> Option<tokio::time::Instant> {
         self.finish_debounce();
         None
     }
 
     fn finish_debounce(&mut self) {
+        // TODO: this blocks on the main thread. Figure out how not to do that
         job::dispatch_blocking(move |editor, _| {
             request_git_blame(editor);
         })
@@ -40,22 +41,33 @@ pub(super) fn register_hooks(handlers: &Handlers) {
 }
 
 fn request_git_blame(editor: &mut Editor) {
-    let (view, doc) = current_ref!(editor);
+    let blame_enabled = editor.config().vcs.blame;
+    let (view, doc) = current!(editor);
     let text = doc.text();
     let selection = doc.selection(view.id);
     let Some(file) = doc.path() else {
         return;
     };
-    let Ok(cursor_line) = TryInto::<u32>::try_into(
+    if !blame_enabled {
-        text.char_to_line(selection.primary().cursor(doc.text().slice(..))),
+        return;
-    ) else {
+    }
+
+    let cursor_lin = text.char_to_line(selection.primary().cursor(doc.text().slice(..)));
+    let Ok(cursor_line) = TryInto::<u32>::try_into(cursor_lin) else {
         return;
     };
 
-    let output = editor.diff_providers.blame_line(file, cursor_line);
+    // gix-blame expects a 1-based line
+    let Ok(output) = editor.diff_providers.blame_line(file, cursor_line + 1) else {
+        return;
+    };
 
-    match output {
+    doc.blame = Some(vec![InlineAnnotation::new(
-        Ok(blame) => editor.set_status(blame.to_string()),
+        text.try_line_to_char(cursor_lin + 1)
-        Err(err) => editor.set_error(err.to_string()),
+            .unwrap_or(text.len_chars())
-    }
+        // to get the last position in the current line
+        - 1,
+        output.to_string(),
+    )]);
+    log::error!("{:?}", doc.blame);
 }

helix-vcs/src/git.rs

@@ -137,7 +137,7 @@ impl fmt::Display for BlameInformation {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
-            "{} - {} - {} - {}",
+            "    {} - {} - {} - {}",
             self.author_name, self.commit_date, self.commit_message, self.commit_hash
         )
     }

helix-view/src/document.rs

@@ -143,6 +143,7 @@ pub struct Document {
     ///
     /// To know if they're up-to-date, check the `id` field in `DocumentInlayHints`.
     pub(crate) inlay_hints: HashMap<ViewId, DocumentInlayHints>,
+    pub blame: Option<Vec<InlineAnnotation>>,
     pub(crate) jump_labels: HashMap<ViewId, Vec<Overlay>>,
     /// Set to `true` when the document is updated, reset to `false` on the next inlay hints
     /// update from the LSP
@@ -698,6 +699,7 @@ impl Document {
             focused_at: std::time::Instant::now(),
             readonly: false,
             jump_labels: HashMap::new(),
+            blame: None,
         }
     }
 

helix-view/src/view.rs

@@ -452,6 +452,14 @@ impl View {
             text_annotations.add_overlay(labels, style);
         }
 
+        if let Some(blame_annotation) = &doc.blame {
+            let annotation_style = theme
+                .and_then(|t| t.find_scope_index("ui.virtual.inlay-hint.type"))
+                .map(Highlight);
+
+            text_annotations.add_inline_annotations(blame_annotation, annotation_style);
+        }
+
         if let Some(DocumentInlayHints {
             id: _,
             type_inlay_hints,