Merge upstream PR helix-editor#13133: feat: Inline Git Blame

Author: mhersson

Cargo.lock

@@ -4,6 +4,7 @@
 - [`[editor.clipboard-provider]` Section](#editorclipboard-provider-section)
 - [`[editor.statusline]` Section](#editorstatusline-section)
 - [`[editor.lsp]` Section](#editorlsp-section)
+- [`[editor.inline-blame]` Section](#editorinlineblame-section)
 - [`[editor.cursor-shape]` Section](#editorcursor-shape-section)
 - [`[editor.file-picker]` Section](#editorfile-picker-section)
 - [`[editor.file-explorer]` Section](#editorfile-explorer-section)
@@ -176,6 +177,39 @@ The following statusline elements can be configured:
 
 [^2]: You may also have to activate them in the language server config for them to appear, not just in Helix. Inlay hints in Helix are still being improved on and may be a little bit laggy/janky under some circumstances. Please report any bugs you see so we can fix them!
 
+### `[editor.inline-blame]` Section
+
+Inline blame is virtual text that appears at the end of a line, displaying information about the most recent commit that affected this line.
+
+| Key     | Description                                | Default |
+| ------- | ------------------------------------------ | ------- |
+| `show` | When to show inline blame | `"never"` |
+| `auto-fetch` | Automatically fetch blame information in the background | `false` |
+| `format` | Inline blame message format | `"{author}, {time-ago} • {title} • {commit}"` |
+
+`show` can be one of the following:
+- `"all-lines"`: Inline blame is on every line.
+- `"cursor-line"`: Inline blame is only on the line of the primary cursor.
+- `"hidden"`: Inline blame is hidden.
+
+With `auto-fetch` set to `false`, blame for the current file is fetched only when explicitly requested, such as when using `space + B` to display the blame for the line of the cursor. There may be a little delay when loading the blame.
+
+When `auto-fetch` is set to `true`, blame for the file is fetched in the background; this will have no effect on performance, but will use a little bit extra resources in the background. Directly requesting the blame with `space + B` will be instant. Inline blame will show as soon as the blame is available when loading new files.
+
+When opening new files, even with `show` set to `"all-lines"` or `"cursor-line"`, the inline blame won't show. It needs to be fetched first in order to become available, which can be triggered manually with `space + B`.
+
+#### `format`
+
+Change the `format` string to customize the blame message displayed. Variables are text placeholders wrapped in curly braces: `{variable}`. The following variables are available:
+
+- `author`: The author of the commit
+- `date`: When the commit was made
+- `time-ago`: How long ago the commit was made
+- `title`: The title of the commit
+- `body`: The body of the commit
+- `commit`: The short hex SHA1 hash of the commit
+- `email`: The email of the author of the commit
+
 ### `[editor.cursor-shape]` Section
 
 Defines the shape of cursor in each mode.

book/src/editor.md

@@ -316,5 +316,6 @@
 | `extend_to_word` | Extend to a two-character label | select: `` gw `` |
 | `goto_next_tabstop` | Goto next snippet placeholder |  |
 | `goto_prev_tabstop` | Goto next snippet placeholder |  |
+| `blame_line` | Show blame for the current line | normal: `` <space>B ``, select: `` <space>B `` |
 | `rotate_selections_first` | Make the first selection your primary one |  |
 | `rotate_selections_last` | Make the last selection your primary one |  |

book/src/generated/static-cmd.md

@@ -314,6 +314,7 @@ This layer is a kludge of mappings, mostly pickers.
 | `R`     | Replace selections by clipboard contents                                | `replace_selections_with_clipboard`        |
 | `/`     | Global search in workspace folder                                       | `global_search`                            |
 | `?`     | Open command palette                                                    | `command_palette`                          |
+| `B`     | Show blame for the current line                                         | `blame_line`                             |
 
 > 💡 Global search displays results in a fuzzy picker, use `Space + '` to bring it back up after opening a file.
 

book/src/keymap.md

@@ -340,6 +340,7 @@ These scopes are used for theming the editor interface:
 | `ui.virtual.inlay-hint.type`      | Style for inlay hints of kind `type` (language servers are not required to set a kind)         |
 | `ui.virtual.wrap`                 | Soft-wrap indicator (see the [`editor.soft-wrap` config][editor-section])                      |
 | `ui.virtual.jump-label`           | Style for virtual jump labels                                                                  |
+| `ui.virtual.inline-blame`         | Inline blame indicator (see the [`editor.inline-blame` config][editor-section])                |
 | `ui.menu`                         | Code and command completion menus                                                              |
 | `ui.menu.selected`                | Selected autocomplete item                                                                     |
 | `ui.menu.scroll`                  | `fg` sets thumb color, `bg` sets track color of scrollbar                                      |

book/src/themes.md

@@ -6,5 +6,6 @@ pub mod faccess;
 pub mod path;
 pub mod range;
 pub mod rope;
+pub mod time;
 
 pub use range::Range;

helix-stdx/src/lib.rs

@@ -0,0 +1,75 @@
+use std::time::{Instant, SystemTime};
+
+use once_cell::sync::Lazy;
+
+const SECOND: i64 = 1;
+const MINUTE: i64 = 60 * SECOND;
+const HOUR: i64 = 60 * MINUTE;
+const DAY: i64 = 24 * HOUR;
+const MONTH: i64 = 30 * DAY;
+const YEAR: i64 = 365 * DAY;
+
+/// Like `std::time::SystemTime::now()` but does not cause a syscall on every invocation.
+///
+/// There is just one syscall at the start of the program, subsequent invocations are
+/// much cheaper and use the monotonic clock instead of trigerring a syscall.
+#[inline]
+fn now() -> SystemTime {
+    static START_INSTANT: Lazy<Instant> = Lazy::new(Instant::now);
+    static START_SYSTEM_TIME: Lazy<SystemTime> = Lazy::new(SystemTime::now);
+
+    *START_SYSTEM_TIME + START_INSTANT.elapsed()
+}
+
+/// Formats a timestamp into a human-readable relative time string.
+///
+/// # Arguments
+///
+/// * `timestamp` - A point in history. Seconds since UNIX epoch (UTC)
+/// * `timezone_offset` - Timezone offset in seconds
+///
+/// # Returns
+///
+/// A String representing the relative time (e.g., "4 years ago", "11 months from now")
+#[inline]
+pub fn format_relative_time(timestamp: i64, timezone_offset: i32) -> String {
+    let timestamp = timestamp + timezone_offset as i64;
+    let now = now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs() as i64
+        + timezone_offset as i64;
+
+    let time_passed = now - timestamp;
+
+    let time_difference = time_passed.abs();
+
+    let (value, unit) = if time_difference >= YEAR {
+        let years = time_difference / YEAR;
+        (years, if years == 1 { "year" } else { "years" })
+    } else if time_difference >= MONTH {
+        let months = time_difference / MONTH;
+        (months, if months == 1 { "month" } else { "months" })
+    } else if time_difference >= DAY {
+        let days = time_difference / DAY;
+        (days, if days == 1 { "day" } else { "days" })
+    } else if time_difference >= HOUR {
+        let hours = time_difference / HOUR;
+        (hours, if hours == 1 { "hour" } else { "hours" })
+    } else if time_difference >= MINUTE {
+        let minutes = time_difference / MINUTE;
+        (minutes, if minutes == 1 { "minute" } else { "minutes" })
+    } else {
+        let seconds = time_difference / SECOND;
+        (seconds, if seconds == 1 { "second" } else { "seconds" })
+    };
+    let value = value.to_string();
+
+    let label = if time_passed.is_positive() {
+        "ago"
+    } else {
+        "from now"
+    };
+
+    format!("{value} {unit} {label}")
+}

helix-stdx/src/time.rs

@@ -11,6 +11,7 @@ use helix_view::{
     align_view,
     document::{DocumentOpenError, DocumentSavedEventResult},
     editor::{ConfigEvent, EditorEvent},
+    events::EditorConfigDidChange,
     graphics::Rect,
     theme,
     tree::Layout,
@@ -389,6 +390,10 @@ impl Application {
             // the Application can apply it.
             ConfigEvent::Update(editor_config) => {
                 let mut app_config = (*self.config.load().clone()).clone();
+                helix_event::dispatch(EditorConfigDidChange {
+                    old_config: &app_config.editor,
+                    editor: &mut self.editor,
+                });
                 app_config.editor = *editor_config;
                 if let Err(err) = self.terminal.reconfigure((&app_config.editor).into()) {
                     self.editor.set_error(err.to_string());

helix-term/src/application.rs

@@ -11,6 +11,7 @@ use helix_stdx::{
     rope::{self, RopeSliceExt},
 };
 use helix_vcs::{FileChange, Hunk};
+use helix_view::document::LineBlameError;
 pub use lsp::*;
 pub use syntax::*;
 use tui::{
@@ -619,6 +620,7 @@ impl MappableCommand {
         extend_to_word, "Extend to a two-character label",
         goto_next_tabstop, "Goto next snippet placeholder",
         goto_prev_tabstop, "Goto next snippet placeholder",
+        blame_line, "Show blame for the current line",
         rotate_selections_first, "Make the first selection your primary one",
         rotate_selections_last, "Make the last selection your primary one",
     );
@@ -3533,6 +3535,55 @@ fn insert_at_line_start(cx: &mut Context) {
     insert_with_indent(cx, IndentFallbackPos::LineStart);
 }
 
+pub(crate) fn blame_line_impl(editor: &mut Editor, doc_id: DocumentId, cursor_line: u32) {
+    let inline_blame_config = &editor.config().inline_blame;
+    let Some(doc) = editor.document(doc_id) else {
+        return;
+    };
+    let line_blame = match doc.line_blame(cursor_line, &inline_blame_config.format) {
+        result
+            if (result.is_ok() && doc.is_blame_potentially_out_of_date)
+                || matches!(result, Err(LineBlameError::NotReadyYet) if !inline_blame_config.auto_fetch) =>
+        {
+            if let Some(path) = doc.path() {
+                let tx = editor.handlers.blame.clone();
+                helix_event::send_blocking(
+                    &tx,
+                    helix_view::handlers::BlameEvent {
+                        path: path.to_path_buf(),
+                        doc_id: doc.id(),
+                        line: Some(cursor_line),
+                    },
+                );
+                editor.set_status(format!("Requested blame for {}...", path.display()));
+                let doc = editor
+                    .document_mut(doc_id)
+                    .expect("exists since we return from the function earlier if it does not");
+                doc.is_blame_potentially_out_of_date = false;
+            } else {
+                editor.set_error("Could not get path of document");
+            };
+            return;
+        }
+        Ok(line_blame) => line_blame,
+        Err(err @ (LineBlameError::NotCommittedYet | LineBlameError::NotReadyYet)) => {
+            editor.set_status(err.to_string());
+            return;
+        }
+        Err(err @ LineBlameError::NoFileBlame(_, _)) => {
+            editor.set_error(err.to_string());
+            return;
+        }
+    };
+
+    editor.set_status(line_blame);
+}
+
+fn blame_line(cx: &mut Context) {
+    let (view, doc) = current_ref!(cx.editor);
+    blame_line_impl(cx.editor, doc.id(), doc.cursor_line(view.id) as u32);
+}
+
 // `A` inserts at the end of each line with a selection.
 // If the line is empty, automatically indent.
 fn insert_at_line_end(cx: &mut Context) {

helix-term/src/commands.rs

@@ -14,6 +14,7 @@ use helix_stdx::path::home_dir;
 use helix_view::document::{read_to_string, DEFAULT_LANGUAGE_NAME};
 use helix_view::editor::{CloseError, ConfigEvent};
 use helix_view::expansion;
+use helix_view::handlers::BlameEvent;
 use serde_json::Value;
 use ui::completers::{self, Completer};
 
@@ -1434,16 +1435,33 @@ fn reload(cx: &mut compositor::Context, _args: Args, event: PromptEvent) -> anyh
     }
 
     let scrolloff = cx.editor.config().scrolloff;
+    let auto_fetch = cx.editor.config().inline_blame.auto_fetch;
     let (view, doc) = current!(cx.editor);
     doc.reload(view, &cx.editor.diff_providers).map(|_| {
         view.ensure_cursor_in_view(doc, scrolloff);
     })?;
+    let doc_id = doc.id();
     if let Some(path) = doc.path() {
         cx.editor
             .language_servers
             .file_event_handler
             .file_changed(path.clone());
     }
+
+    if doc.should_request_full_file_blame(auto_fetch) {
+        if let Some(path) = doc.path() {
+            helix_event::send_blocking(
+                &cx.editor.handlers.blame,
+                BlameEvent {
+                    path: path.to_path_buf(),
+                    doc_id,
+                    line: None,
+                },
+            );
+        }
+    }
+    doc.is_blame_potentially_out_of_date = true;
+
     Ok(())
 }
 
@@ -1470,6 +1488,8 @@ fn reload_all(cx: &mut compositor::Context, _args: Args, event: PromptEvent) ->
         })
         .collect();
 
+    let blame_compute = cx.editor.config().inline_blame.auto_fetch;
+
     for (doc_id, view_ids) in docs_view_ids {
         let doc = doc_mut!(cx.editor, &doc_id);
 
@@ -1497,6 +1517,20 @@ fn reload_all(cx: &mut compositor::Context, _args: Args, event: PromptEvent) ->
                 view.ensure_cursor_in_view(doc, scrolloff);
             }
         }
+
+        if doc.should_request_full_file_blame(blame_compute) {
+            if let Some(path) = doc.path() {
+                helix_event::send_blocking(
+                    &cx.editor.handlers.blame,
+                    BlameEvent {
+                        path: path.to_path_buf(),
+                        doc_id,
+                        line: None,
+                    },
+                );
+            }
+        }
+        doc.is_blame_potentially_out_of_date = true;
     }
 
     Ok(())