Merge remote-tracking branch 'nikitarevenco/gix-blame'
This commit is contained in:
commit
f3f4ae5fdd
19 changed files with 938 additions and 15 deletions
16
Cargo.lock
generated
16
Cargo.lock
generated
|
|
@ -509,6 +509,7 @@ checksum = "736f14636705f3a56ea52b553e67282519418d9a35bb1e90b3a9637a00296b68"
|
|||
dependencies = [
|
||||
"gix-actor",
|
||||
"gix-attributes",
|
||||
"gix-blame",
|
||||
"gix-command",
|
||||
"gix-commitgraph",
|
||||
"gix-config",
|
||||
|
|
@ -591,6 +592,21 @@ dependencies = [
|
|||
"thiserror 2.0.12",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "gix-blame"
|
||||
version = "0.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "adc795e239a2347eb50ed18b8c529382dd8b62439c57277f79af3d8f8928a986"
|
||||
dependencies = [
|
||||
"gix-diff",
|
||||
"gix-hash",
|
||||
"gix-object",
|
||||
"gix-trace",
|
||||
"gix-traverse",
|
||||
"gix-worktree",
|
||||
"thiserror 2.0.12",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "gix-chunk"
|
||||
version = "0.4.11"
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@
|
|||
- [`[editor.clipboard-provider]` Section](#editorclipboard-provider-section)
|
||||
- [`[editor.statusline]` Section](#editorstatusline-section)
|
||||
- [`[editor.lsp]` Section](#editorlsp-section)
|
||||
- [`[editor.version-control]` Section](#editorversioncontrol-section)
|
||||
- [`[editor.cursor-shape]` Section](#editorcursor-shape-section)
|
||||
- [`[editor.file-picker]` Section](#editorfile-picker-section)
|
||||
- [`[editor.auto-pairs]` Section](#editorauto-pairs-section)
|
||||
|
|
@ -160,6 +161,37 @@ 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.version-control]` Section
|
||||
|
||||
| Key | Description | Default |
|
||||
| ------- | ------------------------------------------ | ------- |
|
||||
| `inline-blame` | Show git blame output for the current line | `false` |
|
||||
| `inline-blame-format` | The format in which to show the inline blame | `"{author}, {date} • {message} • {commit}"` |
|
||||
|
||||
For `inline-blame-format`, you can use specific variables like so: `{variable}`.
|
||||
|
||||
These are the available variables:
|
||||
|
||||
- `author`: The author of the commit
|
||||
- `date`: When the commit was made
|
||||
- `message`: The message of the commit, excluding the body
|
||||
- `body`: The body of the commit
|
||||
- `commit`: The short hex SHA1 hash of the commit
|
||||
- `email`: The email of the author of the commit
|
||||
|
||||
Any of the variables can potentially be empty.
|
||||
In this case, the content before the variable will not be included in the string.
|
||||
If the variable is at the beginning of the string, the content after the variable will not be included.
|
||||
|
||||
Some examples, using the default value `inline-blame-format` value:
|
||||
|
||||
- If `author` is empty: `"{date} • {message} • {commit}"`
|
||||
- If `date` is empty: `"{author} • {message} • {commit}"`
|
||||
- If `message` is empty: `"{author}, {date} • {commit}"`
|
||||
- If `commit` is empty: `"{author}, {date} • {message}"`
|
||||
- If `date` and `message` is empty: `"{author} • {commit}"`
|
||||
- If `author` and `message` is empty: `"{date} • {commit}"`
|
||||
|
||||
### `[editor.cursor-shape]` Section
|
||||
|
||||
Defines the shape of cursor in each mode.
|
||||
|
|
|
|||
|
|
@ -173,6 +173,7 @@
|
|||
| `redo` | Redo change | normal: `` U ``, select: `` U `` |
|
||||
| `earlier` | Move backward in history | normal: `` <A-u> ``, select: `` <A-u> `` |
|
||||
| `later` | Move forward in history | normal: `` <A-U> ``, select: `` <A-U> `` |
|
||||
| `line_blame` | Blame for the current line | normal: `` <space>B ``, select: `` <space>B `` |
|
||||
| `commit_undo_checkpoint` | Commit changes to new checkpoint | insert: `` <C-s> `` |
|
||||
| `yank` | Yank selection | normal: `` y ``, select: `` y `` |
|
||||
| `yank_to_clipboard` | Yank selections to clipboard | normal: `` <space>y ``, select: `` <space>y `` |
|
||||
|
|
|
|||
|
|
@ -472,6 +472,7 @@ impl MappableCommand {
|
|||
redo, "Redo change",
|
||||
earlier, "Move backward in history",
|
||||
later, "Move forward in history",
|
||||
line_blame, "Blame for the current line",
|
||||
commit_undo_checkpoint, "Commit changes to new checkpoint",
|
||||
yank, "Yank selection",
|
||||
yank_to_clipboard, "Yank selections to clipboard",
|
||||
|
|
@ -6563,6 +6564,42 @@ fn goto_word(cx: &mut Context) {
|
|||
jump_to_word(cx, Movement::Move)
|
||||
}
|
||||
|
||||
fn line_blame(cx: &mut Context) {
|
||||
let (view, doc) = current!(cx.editor);
|
||||
const BLAME_ERROR: &str = "No blame available for the current file";
|
||||
let Some(diff) = doc.diff_handle() else {
|
||||
cx.editor.set_error(BLAME_ERROR);
|
||||
return;
|
||||
};
|
||||
|
||||
let Some(path) = doc.path() else {
|
||||
cx.editor.set_error(BLAME_ERROR);
|
||||
return;
|
||||
};
|
||||
|
||||
let cursor_line = doc.cursor_line(view.id);
|
||||
let (inserted_lines_count, deleted_lines_count) =
|
||||
diff.load().inserted_and_deleted_before_line(cursor_line);
|
||||
|
||||
let Ok(cursor_line) = u32::try_from(doc.cursor_line(view.id)) else {
|
||||
cx.editor.set_error(BLAME_ERROR);
|
||||
return;
|
||||
};
|
||||
|
||||
let Ok(output) = cx.editor.diff_providers.blame_line(
|
||||
path,
|
||||
cursor_line,
|
||||
inserted_lines_count,
|
||||
deleted_lines_count,
|
||||
) else {
|
||||
cx.editor.set_error(BLAME_ERROR);
|
||||
return;
|
||||
};
|
||||
|
||||
cx.editor
|
||||
.set_status(output.parse_format(&cx.editor.config().version_control.inline_blame_format));
|
||||
}
|
||||
|
||||
fn extend_to_word(cx: &mut Context) {
|
||||
jump_to_word(cx, Movement::Extend)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ use crate::handlers::signature_help::SignatureHelpHandler;
|
|||
pub use helix_view::handlers::Handlers;
|
||||
|
||||
mod auto_save;
|
||||
mod blame;
|
||||
pub mod completion;
|
||||
pub mod diagnostics;
|
||||
mod signature_help;
|
||||
|
|
@ -24,12 +25,14 @@ pub fn setup(config: Arc<ArcSwap<Config>>) -> Handlers {
|
|||
let signature_hints = SignatureHelpHandler::new().spawn();
|
||||
let auto_save = AutoSaveHandler::new().spawn();
|
||||
let pull_diagnostics = PullDiagnosticsHandler::new().spawn();
|
||||
let blame = blame::BlameHandler::default().spawn();
|
||||
|
||||
let handlers = Handlers {
|
||||
completions: helix_view::handlers::completion::CompletionHandler::new(event_tx),
|
||||
signature_hints,
|
||||
auto_save,
|
||||
pull_diagnostics,
|
||||
blame,
|
||||
};
|
||||
|
||||
completion::register_hooks(&handlers);
|
||||
|
|
@ -37,5 +40,6 @@ pub fn setup(config: Arc<ArcSwap<Config>>) -> Handlers {
|
|||
auto_save::register_hooks(&handlers);
|
||||
diagnostics::register_hooks(&handlers);
|
||||
snippet::register_hooks(&handlers);
|
||||
blame::register_hooks(&handlers);
|
||||
handlers
|
||||
}
|
||||
|
|
|
|||
117
helix-term/src/handlers/blame.rs
Normal file
117
helix-term/src/handlers/blame.rs
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
use std::time::Duration;
|
||||
|
||||
use helix_event::{register_hook, send_blocking};
|
||||
use helix_view::handlers::{BlameEvent, Handlers};
|
||||
use tokio::{task::JoinHandle, time::Instant};
|
||||
|
||||
use crate::{events::PostCommand, job};
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct BlameHandler {
|
||||
worker: Option<JoinHandle<anyhow::Result<String>>>,
|
||||
cursor_line: u32,
|
||||
}
|
||||
|
||||
impl helix_event::AsyncHook for BlameHandler {
|
||||
type Event = BlameEvent;
|
||||
|
||||
fn handle_event(
|
||||
&mut self,
|
||||
event: Self::Event,
|
||||
_timeout: Option<tokio::time::Instant>,
|
||||
) -> Option<tokio::time::Instant> {
|
||||
if let Some(worker) = &self.worker {
|
||||
if worker.is_finished() {
|
||||
self.finish_debounce();
|
||||
return None;
|
||||
}
|
||||
return Some(Instant::now() + Duration::from_millis(50));
|
||||
}
|
||||
|
||||
let BlameEvent::PostCommand {
|
||||
file,
|
||||
cursor_line,
|
||||
diff_providers,
|
||||
deleted_lines_count: removed_lines_count,
|
||||
inserted_lines_count: added_lines_count,
|
||||
blame_format,
|
||||
} = event;
|
||||
|
||||
self.cursor_line = cursor_line;
|
||||
|
||||
let worker = tokio::spawn(async move {
|
||||
diff_providers
|
||||
.blame_line(&file, cursor_line, added_lines_count, removed_lines_count)
|
||||
.map(|s| s.parse_format(&blame_format))
|
||||
});
|
||||
self.worker = Some(worker);
|
||||
Some(Instant::now() + Duration::from_millis(50))
|
||||
}
|
||||
|
||||
fn finish_debounce(&mut self) {
|
||||
let cursor_line = self.cursor_line;
|
||||
if let Some(worker) = &self.worker {
|
||||
if worker.is_finished() {
|
||||
let worker = self.worker.take().unwrap();
|
||||
tokio::spawn(async move {
|
||||
let Ok(Ok(outcome)) = worker.await else {
|
||||
return;
|
||||
};
|
||||
job::dispatch(move |editor, _| {
|
||||
let doc = doc_mut!(editor);
|
||||
// if we're on a line that hasn't been commited yet, just show nothing at all
|
||||
// in order to reduce visual noise.
|
||||
// Because the git hunks already imply this information
|
||||
let blame_text = doc
|
||||
.diff_handle()
|
||||
.is_some_and(|diff| diff.load().hunk_at(cursor_line, false).is_none())
|
||||
.then_some(outcome);
|
||||
doc.blame = blame_text;
|
||||
})
|
||||
.await;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn register_hooks(handlers: &Handlers) {
|
||||
let tx = handlers.blame.clone();
|
||||
register_hook!(move |event: &mut PostCommand<'_, '_>| {
|
||||
let version_control_config = &event.cx.editor.config().version_control;
|
||||
if !version_control_config.inline_blame {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let (view, doc) = current!(event.cx.editor);
|
||||
let Some(file) = doc.path() else {
|
||||
return Ok(());
|
||||
};
|
||||
let file = file.to_path_buf();
|
||||
|
||||
let Ok(cursor_line) = u32::try_from(doc.cursor_line(view.id)) else {
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
let hunks = doc.diff_handle().unwrap().load();
|
||||
|
||||
let (inserted_lines_count, deleted_lines_count) =
|
||||
hunks.inserted_and_deleted_before_line(cursor_line as usize);
|
||||
|
||||
send_blocking(
|
||||
&tx,
|
||||
BlameEvent::PostCommand {
|
||||
file,
|
||||
cursor_line,
|
||||
deleted_lines_count,
|
||||
inserted_lines_count,
|
||||
// ok to clone because diff_providers is very small
|
||||
diff_providers: event.cx.editor.diff_providers.clone(),
|
||||
// ok to clone because blame_format is likely to be about 30 characters or less
|
||||
blame_format: version_control_config.inline_blame_format.clone(),
|
||||
},
|
||||
);
|
||||
|
||||
Ok(())
|
||||
});
|
||||
}
|
||||
|
|
@ -232,6 +232,7 @@ pub fn default() -> HashMap<Mode, KeyTrie> {
|
|||
"D" => workspace_diagnostics_picker,
|
||||
"g" => changed_file_picker,
|
||||
"a" => code_action,
|
||||
"B" => line_blame,
|
||||
"'" => last_picker,
|
||||
"G" => { "Debug (experimental)" sticky=true
|
||||
"l" => dap_launch,
|
||||
|
|
|
|||
|
|
@ -203,6 +203,16 @@ impl EditorView {
|
|||
inline_diagnostic_config,
|
||||
config.end_of_line_diagnostics,
|
||||
));
|
||||
if config.version_control.inline_blame {
|
||||
if let Some(blame) = &doc.blame {
|
||||
decorations.add_decoration(text_decorations::blame::EolBlame::new(
|
||||
doc,
|
||||
theme,
|
||||
doc.text().char_to_line(primary_cursor),
|
||||
blame,
|
||||
));
|
||||
}
|
||||
}
|
||||
render_document(
|
||||
surface,
|
||||
inner,
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ use crate::ui::document::{LinePos, TextRenderer};
|
|||
|
||||
pub use diagnostics::InlineDiagnostics;
|
||||
|
||||
pub mod blame;
|
||||
mod diagnostics;
|
||||
|
||||
/// Decorations are the primary mechanism for extending the text rendering.
|
||||
|
|
|
|||
68
helix-term/src/ui/text_decorations/blame.rs
Normal file
68
helix-term/src/ui/text_decorations/blame.rs
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
#![allow(dead_code, unused_variables, unused_mut)]
|
||||
|
||||
use helix_core::Position;
|
||||
|
||||
use helix_view::theme::Style;
|
||||
use helix_view::{Document, Theme};
|
||||
|
||||
use crate::ui::document::{LinePos, TextRenderer};
|
||||
use crate::ui::text_decorations::Decoration;
|
||||
|
||||
pub struct EolBlame<'a> {
|
||||
message: &'a str,
|
||||
doc: &'a Document,
|
||||
cursor: usize,
|
||||
style: Style,
|
||||
}
|
||||
|
||||
impl<'a> EolBlame<'a> {
|
||||
pub fn new(doc: &'a Document, theme: &Theme, cursor: usize, message: &'a str) -> Self {
|
||||
EolBlame {
|
||||
style: theme.get("ui.virtual.blame"),
|
||||
message,
|
||||
doc,
|
||||
cursor,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Decoration for EolBlame<'_> {
|
||||
fn render_virt_lines(
|
||||
&mut self,
|
||||
renderer: &mut TextRenderer,
|
||||
pos: LinePos,
|
||||
virt_off: Position,
|
||||
) -> Position {
|
||||
if self.cursor != pos.doc_line {
|
||||
return Position::new(0, 0);
|
||||
}
|
||||
let row = pos.visual_line;
|
||||
let col = virt_off.col as u16;
|
||||
let style = self.style;
|
||||
let width = renderer.viewport.width;
|
||||
let start_col = col - renderer.offset.col as u16;
|
||||
// start drawing the git blame 6 spaces after the end of the line
|
||||
let draw_col = col + 6;
|
||||
|
||||
let end_col = renderer
|
||||
.column_in_bounds(draw_col as usize, 1)
|
||||
.then(|| {
|
||||
renderer
|
||||
.set_string_truncated(
|
||||
renderer.viewport.x + draw_col,
|
||||
row,
|
||||
self.message,
|
||||
width.saturating_sub(draw_col) as usize,
|
||||
|_| self.style,
|
||||
true,
|
||||
false,
|
||||
)
|
||||
.0
|
||||
})
|
||||
.unwrap_or(start_col);
|
||||
|
||||
let col_off = end_col - start_col;
|
||||
|
||||
Position::new(0, col_off as usize)
|
||||
}
|
||||
}
|
||||
|
|
@ -19,7 +19,7 @@ tokio = { version = "1", features = ["rt", "rt-multi-thread", "time", "sync", "p
|
|||
parking_lot.workspace = true
|
||||
arc-swap = { version = "1.7.1" }
|
||||
|
||||
gix = { version = "0.70.0", features = ["attributes", "status"], default-features = false, optional = true }
|
||||
gix = { version = "0.70.0", features = ["attributes", "status", "blame"], default-features = false, optional = true }
|
||||
imara-diff = "0.1.8"
|
||||
anyhow = "1"
|
||||
|
||||
|
|
|
|||
|
|
@ -177,6 +177,20 @@ impl Diff<'_> {
|
|||
}
|
||||
}
|
||||
|
||||
/// Get the amount of lines inserted and deleted before a given line
|
||||
pub fn inserted_and_deleted_before_line(&self, cursor_line: usize) -> (u32, u32) {
|
||||
let mut inserted_lines_count: u32 = 0;
|
||||
let mut deleted_lines_count: u32 = 0;
|
||||
for hunk in self.hunks_intersecting_line_ranges(std::iter::once((0, cursor_line))) {
|
||||
let lines_inserted = hunk.after.end - hunk.after.start;
|
||||
let lines_removed = hunk.before.end - hunk.before.start;
|
||||
inserted_lines_count += lines_inserted;
|
||||
deleted_lines_count += lines_removed;
|
||||
}
|
||||
|
||||
(inserted_lines_count, deleted_lines_count)
|
||||
}
|
||||
|
||||
pub fn doc(&self) -> &Rope {
|
||||
if self.inverted {
|
||||
&self.diff.diff_base
|
||||
|
|
|
|||
|
|
@ -1,11 +1,11 @@
|
|||
use anyhow::{bail, Context, Result};
|
||||
use arc_swap::ArcSwap;
|
||||
use gix::bstr::ByteSlice as _;
|
||||
use gix::filter::plumbing::driver::apply::Delay;
|
||||
use std::io::Read;
|
||||
use std::path::Path;
|
||||
use std::sync::Arc;
|
||||
|
||||
use gix::bstr::ByteSlice;
|
||||
use gix::diff::Rewrites;
|
||||
use gix::dir::entry::Status;
|
||||
use gix::objs::tree::EntryKind;
|
||||
|
|
@ -22,6 +22,9 @@ use crate::FileChange;
|
|||
#[cfg(test)]
|
||||
mod test;
|
||||
|
||||
mod blame;
|
||||
pub use blame::*;
|
||||
|
||||
#[inline]
|
||||
fn get_repo_dir(file: &Path) -> Result<&Path> {
|
||||
file.parent().context("file has no parent directory")
|
||||
|
|
|
|||
537
helix-vcs/src/git/blame.rs
Normal file
537
helix-vcs/src/git/blame.rs
Normal file
|
|
@ -0,0 +1,537 @@
|
|||
use anyhow::Context as _;
|
||||
use gix::bstr::BStr;
|
||||
use helix_core::hashmap;
|
||||
use std::path::Path;
|
||||
|
||||
use super::{get_repo_dir, open_repo};
|
||||
|
||||
#[derive(Clone, PartialEq, PartialOrd, Ord, Eq, Debug)]
|
||||
pub struct BlameInformation {
|
||||
pub commit_hash: Option<String>,
|
||||
pub author_name: Option<String>,
|
||||
pub author_email: Option<String>,
|
||||
pub commit_date: Option<String>,
|
||||
pub commit_message: Option<String>,
|
||||
pub commit_body: Option<String>,
|
||||
}
|
||||
|
||||
impl BlameInformation {
|
||||
/// Parse the user's blame format
|
||||
pub fn parse_format(&self, format: &str) -> String {
|
||||
let mut formatted = String::new();
|
||||
let mut content_before_variable = String::new();
|
||||
|
||||
let variables = hashmap! {
|
||||
"commit" => &self.commit_hash,
|
||||
"author" => &self.author_name,
|
||||
"date" => &self.commit_date,
|
||||
"message" => &self.commit_message,
|
||||
"email" => &self.author_email,
|
||||
"body" => &self.commit_body,
|
||||
};
|
||||
|
||||
let mut chars = format.chars().peekable();
|
||||
// in all cases, when any of the variables is empty we exclude the content before the variable
|
||||
// However, if the variable is the first and it is empty - then exclude the content after the variable
|
||||
let mut exclude_content_after_variable = false;
|
||||
while let Some(ch) = chars.next() {
|
||||
// "{{" => '{'
|
||||
if ch == '{' && chars.next_if_eq(&'{').is_some() {
|
||||
content_before_variable.push('{');
|
||||
}
|
||||
// "}}" => '}'
|
||||
else if ch == '}' && chars.next_if_eq(&'}').is_some() {
|
||||
content_before_variable.push('}');
|
||||
} else if ch == '{' {
|
||||
let mut variable = String::new();
|
||||
// eat all characters until the end
|
||||
while let Some(ch) = chars.next_if(|ch| *ch != '}') {
|
||||
variable.push(ch);
|
||||
}
|
||||
// eat the '}' if it was found
|
||||
let has_closing = chars.next().is_some();
|
||||
|
||||
#[derive(PartialEq, Eq, PartialOrd, Ord)]
|
||||
enum Variable {
|
||||
Valid(String),
|
||||
Invalid(String),
|
||||
Empty,
|
||||
}
|
||||
|
||||
let variable_value = variables.get(variable.as_str()).map_or_else(
|
||||
|| {
|
||||
// Invalid variable. So just add whatever we parsed before
|
||||
let mut result = String::with_capacity(variable.len() + 2);
|
||||
result.push('{');
|
||||
result.push_str(variable.as_str());
|
||||
if has_closing {
|
||||
result.push('}');
|
||||
}
|
||||
Variable::Invalid(result)
|
||||
},
|
||||
|s| {
|
||||
s.as_ref()
|
||||
.map(|s| Variable::Valid(s.to_string()))
|
||||
.unwrap_or(Variable::Empty)
|
||||
},
|
||||
);
|
||||
|
||||
match variable_value {
|
||||
Variable::Valid(value) | Variable::Invalid(value) => {
|
||||
if exclude_content_after_variable {
|
||||
// don't push anything.
|
||||
exclude_content_after_variable = false;
|
||||
} else {
|
||||
formatted.push_str(&content_before_variable);
|
||||
}
|
||||
formatted.push_str(&value);
|
||||
}
|
||||
Variable::Empty => {
|
||||
if formatted.is_empty() {
|
||||
// exclude content AFTER this variable (at next iteration of the loop,
|
||||
// we'll exclude the content before a valid variable)
|
||||
exclude_content_after_variable = true;
|
||||
} else {
|
||||
// exclude content BEFORE this variable
|
||||
// also just don't add anything.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
content_before_variable.drain(..);
|
||||
} else {
|
||||
content_before_variable.push(ch);
|
||||
}
|
||||
}
|
||||
|
||||
formatted
|
||||
}
|
||||
}
|
||||
|
||||
/// `git blame` a single line in a file
|
||||
pub fn blame_line(
|
||||
file: &Path,
|
||||
line: u32,
|
||||
added_lines_count: u32,
|
||||
removed_lines_count: u32,
|
||||
) -> anyhow::Result<BlameInformation> {
|
||||
// Because gix_blame doesn't care about stuff that is not commited, we have to "normalize" the
|
||||
// line number to account for uncommited code.
|
||||
//
|
||||
// You'll notice that blame_line can be 0 when, for instance we have:
|
||||
// - removed 0 lines
|
||||
// - added 10 lines
|
||||
// - cursor_line is 8
|
||||
//
|
||||
// So when our cursor is on the 10th added line or earlier, blame_line will be 0. This means
|
||||
// the blame will be incorrect. But that's fine, because when the cursor_line is on some hunk,
|
||||
// we can show to the user nothing at all. This is detected in the editor
|
||||
//
|
||||
// Add 1 to convert 0-based line numbers into 1-based
|
||||
let blame_line = line.saturating_sub(added_lines_count) + removed_lines_count + 1;
|
||||
|
||||
let repo_dir = get_repo_dir(file)?;
|
||||
let repo = open_repo(repo_dir)
|
||||
.context("failed to open git repo")?
|
||||
.to_thread_local();
|
||||
|
||||
let suspect = repo.head()?.peel_to_commit_in_place()?;
|
||||
|
||||
let relative_path = file
|
||||
.strip_prefix(
|
||||
repo.path()
|
||||
.parent()
|
||||
.context("Could not get parent path of repository")?,
|
||||
)
|
||||
.unwrap_or(file)
|
||||
.to_str()
|
||||
.context("Could not convert path to string")?;
|
||||
|
||||
let traverse_all_commits = gix::traverse::commit::topo::Builder::from_iters(
|
||||
&repo.objects,
|
||||
[suspect.id],
|
||||
None::<Vec<gix::ObjectId>>,
|
||||
)
|
||||
.build()?;
|
||||
|
||||
let mut resource_cache = repo.diff_resource_cache_for_tree_diff()?;
|
||||
let latest_commit_id = gix::blame::file(
|
||||
&repo.objects,
|
||||
traverse_all_commits,
|
||||
&mut resource_cache,
|
||||
BStr::new(relative_path),
|
||||
Some(blame_line..blame_line),
|
||||
)?
|
||||
.entries
|
||||
.first()
|
||||
.context("No commits found")?
|
||||
.commit_id;
|
||||
|
||||
let commit = repo.find_commit(latest_commit_id).ok();
|
||||
let message = commit.as_ref().and_then(|c| c.message().ok());
|
||||
let author = commit.as_ref().and_then(|c| c.author().ok());
|
||||
|
||||
Ok(BlameInformation {
|
||||
commit_hash: commit
|
||||
.as_ref()
|
||||
.and_then(|c| c.short_id().map(|id| id.to_string()).ok()),
|
||||
author_name: author.map(|a| a.name.to_string()),
|
||||
author_email: author.map(|a| a.email.to_string()),
|
||||
commit_date: author.map(|a| a.time.format(gix::date::time::format::SHORT)),
|
||||
commit_message: message.as_ref().map(|msg| msg.title.to_string()),
|
||||
commit_body: message
|
||||
.as_ref()
|
||||
.and_then(|msg| msg.body.map(|body| body.to_string())),
|
||||
})
|
||||
}
|
||||
|
||||
// attributes on expressions are not allowed
|
||||
// however, in our macro its possible that sometimes the
|
||||
// assignment to the mutable variable will not be read.
|
||||
//
|
||||
// when the last line has no expected blame commit
|
||||
#[allow(unused_assignments)]
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use std::fs::File;
|
||||
|
||||
use crate::git::test::{create_commit_with_message, empty_git_repo};
|
||||
|
||||
use super::*;
|
||||
|
||||
/// describes how a line was modified
|
||||
#[derive(PartialEq, PartialOrd, Ord, Eq)]
|
||||
enum LineDiff {
|
||||
/// this line is added
|
||||
Insert,
|
||||
/// this line is deleted
|
||||
Delete,
|
||||
/// no changes for this line
|
||||
None,
|
||||
}
|
||||
|
||||
/// checks if the first argument is `no_commit` or not
|
||||
macro_rules! no_commit_flag {
|
||||
(no_commit, $commit_msg:literal) => {
|
||||
false
|
||||
};
|
||||
(, $commit_msg:literal) => {
|
||||
true
|
||||
};
|
||||
($any:tt, $commit_msg:literal) => {
|
||||
compile_error!(concat!(
|
||||
"expected `no_commit` or nothing for commit ",
|
||||
$commit_msg
|
||||
))
|
||||
};
|
||||
}
|
||||
|
||||
/// checks if the first argument is `insert` or `delete`
|
||||
macro_rules! line_diff_flag {
|
||||
(insert, $commit_msg:literal, $line:expr) => {
|
||||
LineDiff::Insert
|
||||
};
|
||||
(delete, $commit_msg:literal, $line:expr) => {
|
||||
LineDiff::Delete
|
||||
};
|
||||
(, $commit_msg:literal, $line:expr) => {
|
||||
LineDiff::None
|
||||
};
|
||||
($any:tt, $commit_msg:literal, $line:expr) => {
|
||||
compile_error!(concat!(
|
||||
"expected `insert`, `delete` or nothing for commit ",
|
||||
$commit_msg,
|
||||
" line ",
|
||||
$line
|
||||
))
|
||||
};
|
||||
}
|
||||
|
||||
/// This macro exists because we can't pass a `match` statement into `concat!`
|
||||
/// we would like to exclude any lines that are `delete`
|
||||
macro_rules! line_diff_flag_str {
|
||||
(insert, $commit_msg:literal, $line:expr) => {
|
||||
concat!($line, newline_literal!())
|
||||
};
|
||||
(delete, $commit_msg:literal, $line:expr) => {
|
||||
""
|
||||
};
|
||||
(, $commit_msg:literal, $line:expr) => {
|
||||
concat!($line, newline_literal!())
|
||||
};
|
||||
($any:tt, $commit_msg:literal, $line:expr) => {
|
||||
compile_error!(concat!(
|
||||
"expected `insert`, `delete` or nothing for commit ",
|
||||
$commit_msg,
|
||||
" line ",
|
||||
$line
|
||||
))
|
||||
};
|
||||
}
|
||||
|
||||
/// Attributes on expressions are experimental so we have to use a whole macro for this
|
||||
#[cfg(windows)]
|
||||
macro_rules! newline_literal {
|
||||
() => {
|
||||
"\r\n"
|
||||
};
|
||||
}
|
||||
#[cfg(not(windows))]
|
||||
macro_rules! newline_literal {
|
||||
() => {
|
||||
"\n"
|
||||
};
|
||||
}
|
||||
|
||||
/// Helper macro to create a history of the same file being modified.
|
||||
macro_rules! assert_line_blame_progress {
|
||||
(
|
||||
$(
|
||||
// a unique identifier for the commit, other commits must not use this
|
||||
// If `no_commit` option is used, use the identifier of the previous commit
|
||||
$commit_msg:literal
|
||||
// must be `no_commit` if exists.
|
||||
// If exists, this block won't be committed
|
||||
$($no_commit:ident)? =>
|
||||
$(
|
||||
// contents of a line in the file
|
||||
$line:literal
|
||||
// what commit identifier we are expecting for this line
|
||||
$($expected:literal)?
|
||||
// must be `insert` or `delete` if exists
|
||||
// if exists, must be used with `no_commit`
|
||||
// - `insert`: this line is added
|
||||
// - `delete`: this line is deleted
|
||||
$($line_diff:ident)?
|
||||
),+
|
||||
);+
|
||||
$(;)?
|
||||
) => {{
|
||||
use std::fs::OpenOptions;
|
||||
use std::io::Write;
|
||||
|
||||
let repo = empty_git_repo();
|
||||
let file = repo.path().join("file.txt");
|
||||
File::create(&file).expect("could not create file");
|
||||
|
||||
$(
|
||||
let file_content = concat!(
|
||||
$(
|
||||
line_diff_flag_str!($($line_diff)?, $commit_msg, $line),
|
||||
)*
|
||||
);
|
||||
eprintln!("at commit {}:\n\n{file_content}", stringify!($commit_msg));
|
||||
|
||||
let mut f = OpenOptions::new()
|
||||
.write(true)
|
||||
.truncate(true)
|
||||
.open(&file)
|
||||
.unwrap();
|
||||
|
||||
f.write_all(file_content.as_bytes()).unwrap();
|
||||
|
||||
let should_commit = no_commit_flag!($($no_commit)?, $commit_msg);
|
||||
if should_commit {
|
||||
create_commit_with_message(repo.path(), true, stringify!($commit_msg));
|
||||
}
|
||||
|
||||
let mut line_number = 0;
|
||||
let mut added_lines = 0;
|
||||
let mut removed_lines = 0;
|
||||
|
||||
$(
|
||||
let line_diff_flag = line_diff_flag!($($line_diff)?, $commit_msg, $line);
|
||||
match line_diff_flag {
|
||||
LineDiff::Insert => added_lines += 1,
|
||||
LineDiff::Delete => removed_lines += 1,
|
||||
LineDiff::None => ()
|
||||
}
|
||||
// completely skip lines that are marked as `delete`
|
||||
if line_diff_flag != LineDiff::Delete {
|
||||
// if there is no $expected, then we don't care what blame_line returns
|
||||
// because we won't show it to the user.
|
||||
$(
|
||||
|
||||
let blame_result =
|
||||
blame_line(&file, line_number, added_lines, removed_lines)
|
||||
.unwrap()
|
||||
.commit_message;
|
||||
assert_eq!(
|
||||
blame_result,
|
||||
Some(concat!(stringify!($expected), newline_literal!()).to_owned()),
|
||||
"Blame mismatch\nat commit: {}\nat line: {}\nline contents: {}\nexpected commit: {}\nbut got commit: {}",
|
||||
$commit_msg,
|
||||
line_number,
|
||||
file_content
|
||||
.lines()
|
||||
.nth(line_number.try_into().unwrap())
|
||||
.unwrap(),
|
||||
stringify!($expected),
|
||||
blame_result
|
||||
.as_ref()
|
||||
.map(|blame| blame.trim_end())
|
||||
.unwrap_or("<no commit>")
|
||||
);
|
||||
)?
|
||||
line_number += 1;
|
||||
}
|
||||
)*
|
||||
)*
|
||||
}};
|
||||
}
|
||||
|
||||
#[test]
|
||||
pub fn blamed_lines() {
|
||||
assert_line_blame_progress! {
|
||||
// initialize
|
||||
1 =>
|
||||
"fn main() {" 1,
|
||||
"" 1,
|
||||
"}" 1;
|
||||
// modifying a line works
|
||||
2 =>
|
||||
"fn main() {" 1,
|
||||
" one" 2,
|
||||
"}" 1;
|
||||
// inserting a line works
|
||||
3 =>
|
||||
"fn main() {" 1,
|
||||
" one" 2,
|
||||
" two" 3,
|
||||
"}" 1;
|
||||
// deleting a line works
|
||||
4 =>
|
||||
"fn main() {" 1,
|
||||
" two" 3,
|
||||
"}" 1;
|
||||
// when a line is inserted in-between the blame order is preserved
|
||||
4 no_commit =>
|
||||
"fn main() {" 1,
|
||||
" hello world" insert,
|
||||
" two" 3,
|
||||
"}" 1;
|
||||
// Having a bunch of random lines interspersed should not change which lines
|
||||
// have blame for which commits
|
||||
4 no_commit =>
|
||||
" six" insert,
|
||||
" three" insert,
|
||||
"fn main() {" 1,
|
||||
" five" insert,
|
||||
" four" insert,
|
||||
" two" 3,
|
||||
" five" insert,
|
||||
" four" insert,
|
||||
"}" 1,
|
||||
" five" insert,
|
||||
" four" insert;
|
||||
// committing all of those insertions should recognize that they are
|
||||
// from the current commit, while still keeping the information about
|
||||
// previous commits
|
||||
5 =>
|
||||
" six" 5,
|
||||
" three" 5,
|
||||
"fn main() {" 1,
|
||||
" five" 5,
|
||||
" four" 5,
|
||||
" two" 3,
|
||||
" five" 5,
|
||||
" four" 5,
|
||||
"}" 1,
|
||||
" five" 5,
|
||||
" four" 5;
|
||||
// several lines deleted
|
||||
5 no_commit =>
|
||||
" six" 5,
|
||||
" three" 5,
|
||||
"fn main() {" delete,
|
||||
" five" delete,
|
||||
" four" delete,
|
||||
" two" delete,
|
||||
" five" delete,
|
||||
" four",
|
||||
"}" 1,
|
||||
" five" 5,
|
||||
" four" 5;
|
||||
// committing the deleted changes
|
||||
6 =>
|
||||
" six" 5,
|
||||
" three" 5,
|
||||
" four" 5,
|
||||
"}" 1,
|
||||
" five" 5,
|
||||
" four" 5;
|
||||
};
|
||||
}
|
||||
|
||||
fn bob() -> BlameInformation {
|
||||
BlameInformation {
|
||||
commit_hash: Some("f14ab1cf".to_owned()),
|
||||
author_name: Some("Bob TheBuilder".to_owned()),
|
||||
author_email: Some("bob@bob.com".to_owned()),
|
||||
commit_date: Some("2028-01-10".to_owned()),
|
||||
commit_message: Some("feat!: extend house".to_owned()),
|
||||
commit_body: Some("BREAKING CHANGE: Removed door".to_owned()),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
pub fn inline_blame_format_parser() {
|
||||
let default_values = "{author}, {date} • {message} • {commit}";
|
||||
|
||||
assert_eq!(
|
||||
bob().parse_format(default_values),
|
||||
"Bob TheBuilder, 2028-01-10 • feat!: extend house • f14ab1cf".to_owned()
|
||||
);
|
||||
assert_eq!(
|
||||
BlameInformation {
|
||||
author_name: None,
|
||||
..bob()
|
||||
}
|
||||
.parse_format(default_values),
|
||||
"2028-01-10 • feat!: extend house • f14ab1cf".to_owned()
|
||||
);
|
||||
assert_eq!(
|
||||
BlameInformation {
|
||||
commit_date: None,
|
||||
..bob()
|
||||
}
|
||||
.parse_format(default_values),
|
||||
"Bob TheBuilder • feat!: extend house • f14ab1cf".to_owned()
|
||||
);
|
||||
assert_eq!(
|
||||
BlameInformation {
|
||||
commit_message: None,
|
||||
author_email: None,
|
||||
..bob()
|
||||
}
|
||||
.parse_format(default_values),
|
||||
"Bob TheBuilder, 2028-01-10 • f14ab1cf".to_owned()
|
||||
);
|
||||
assert_eq!(
|
||||
BlameInformation {
|
||||
commit_hash: None,
|
||||
..bob()
|
||||
}
|
||||
.parse_format(default_values),
|
||||
"Bob TheBuilder, 2028-01-10 • feat!: extend house".to_owned()
|
||||
);
|
||||
assert_eq!(
|
||||
BlameInformation {
|
||||
commit_date: None,
|
||||
author_name: None,
|
||||
..bob()
|
||||
}
|
||||
.parse_format(default_values),
|
||||
"feat!: extend house • f14ab1cf".to_owned()
|
||||
);
|
||||
assert_eq!(
|
||||
BlameInformation {
|
||||
author_name: None,
|
||||
commit_message: None,
|
||||
..bob()
|
||||
}
|
||||
.parse_format(default_values),
|
||||
"2028-01-10 • f14ab1cf".to_owned()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -4,11 +4,11 @@ use tempfile::TempDir;
|
|||
|
||||
use crate::git;
|
||||
|
||||
fn exec_git_cmd(args: &str, git_dir: &Path) {
|
||||
pub fn exec_git_cmd(args: &[&str], git_dir: &Path) {
|
||||
let res = Command::new("git")
|
||||
.arg("-C")
|
||||
.arg(git_dir) // execute the git command in this directory
|
||||
.args(args.split_whitespace())
|
||||
.args(args)
|
||||
.env_remove("GIT_DIR")
|
||||
.env_remove("GIT_ASKPASS")
|
||||
.env_remove("SSH_ASKPASS")
|
||||
|
|
@ -25,26 +25,30 @@ fn exec_git_cmd(args: &str, git_dir: &Path) {
|
|||
.env("GIT_CONFIG_KEY_1", "init.defaultBranch")
|
||||
.env("GIT_CONFIG_VALUE_1", "main")
|
||||
.output()
|
||||
.unwrap_or_else(|_| panic!("`git {args}` failed"));
|
||||
.unwrap_or_else(|_| panic!("`git {args:?}` failed"));
|
||||
if !res.status.success() {
|
||||
println!("{}", String::from_utf8_lossy(&res.stdout));
|
||||
eprintln!("{}", String::from_utf8_lossy(&res.stderr));
|
||||
panic!("`git {args}` failed (see output above)")
|
||||
panic!("`git {args:?}` failed (see output above)")
|
||||
}
|
||||
}
|
||||
|
||||
fn create_commit(repo: &Path, add_modified: bool) {
|
||||
pub fn create_commit(repo: &Path, add_modified: bool) {
|
||||
create_commit_with_message(repo, add_modified, "commit")
|
||||
}
|
||||
|
||||
pub fn create_commit_with_message(repo: &Path, add_modified: bool, message: &str) {
|
||||
if add_modified {
|
||||
exec_git_cmd("add -A", repo);
|
||||
exec_git_cmd(&["add", "-A"], repo);
|
||||
}
|
||||
exec_git_cmd("commit -m message", repo);
|
||||
exec_git_cmd(&["commit", "-m", message], repo);
|
||||
}
|
||||
|
||||
fn empty_git_repo() -> TempDir {
|
||||
pub fn empty_git_repo() -> TempDir {
|
||||
let tmp = tempfile::tempdir().expect("create temp dir for git testing");
|
||||
exec_git_cmd("init", tmp.path());
|
||||
exec_git_cmd("config user.email test@helix.org", tmp.path());
|
||||
exec_git_cmd("config user.name helix-test", tmp.path());
|
||||
exec_git_cmd(&["init"], tmp.path());
|
||||
exec_git_cmd(&["config", "user.email", "test@helix.org"], tmp.path());
|
||||
exec_git_cmd(&["config", "user.name", "helix-test"], tmp.path());
|
||||
tmp
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,7 @@
|
|||
use anyhow::Context as _;
|
||||
use anyhow::{anyhow, bail, Result};
|
||||
use arc_swap::ArcSwap;
|
||||
use git::BlameInformation;
|
||||
use std::{
|
||||
path::{Path, PathBuf},
|
||||
sync::Arc,
|
||||
|
|
@ -16,7 +18,7 @@ mod status;
|
|||
|
||||
pub use status::FileChange;
|
||||
|
||||
#[derive(Clone)]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct DiffProviderRegistry {
|
||||
providers: Vec<DiffProvider>,
|
||||
}
|
||||
|
|
@ -48,6 +50,21 @@ impl DiffProviderRegistry {
|
|||
})
|
||||
}
|
||||
|
||||
/// Blame a line in a file
|
||||
pub fn blame_line(
|
||||
&self,
|
||||
file: &Path,
|
||||
line: u32,
|
||||
added_lines_count: u32,
|
||||
removed_lines_count: u32,
|
||||
) -> anyhow::Result<BlameInformation> {
|
||||
self.providers
|
||||
.iter()
|
||||
.map(|provider| provider.blame_line(file, line, added_lines_count, removed_lines_count))
|
||||
.next()
|
||||
.context("No provider found")?
|
||||
}
|
||||
|
||||
/// Fire-and-forget changed file iteration. Runs everything in a background task. Keeps
|
||||
/// iteration until `on_change` returns `false`.
|
||||
pub fn for_each_changed_file(
|
||||
|
|
@ -84,7 +101,7 @@ impl Default for DiffProviderRegistry {
|
|||
/// cloning [DiffProviderRegistry] as `Clone` cannot be used in trait objects.
|
||||
///
|
||||
/// `Copy` is simply to ensure the `clone()` call is the simplest it can be.
|
||||
#[derive(Copy, Clone)]
|
||||
#[derive(Copy, Clone, Debug)]
|
||||
pub enum DiffProvider {
|
||||
#[cfg(feature = "git")]
|
||||
Git,
|
||||
|
|
@ -108,6 +125,20 @@ impl DiffProvider {
|
|||
}
|
||||
}
|
||||
|
||||
fn blame_line(
|
||||
&self,
|
||||
file: &Path,
|
||||
line: u32,
|
||||
added_lines_count: u32,
|
||||
removed_lines_count: u32,
|
||||
) -> Result<BlameInformation> {
|
||||
match self {
|
||||
#[cfg(feature = "git")]
|
||||
Self::Git => git::blame_line(file, line, added_lines_count, removed_lines_count),
|
||||
Self::None => bail!("No blame support compiled in"),
|
||||
}
|
||||
}
|
||||
|
||||
fn for_each_changed_file(
|
||||
&self,
|
||||
cwd: &Path,
|
||||
|
|
|
|||
|
|
@ -144,6 +144,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<String>,
|
||||
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
|
||||
|
|
@ -702,6 +703,7 @@ impl Document {
|
|||
readonly: false,
|
||||
jump_labels: HashMap::new(),
|
||||
previous_diagnostic_id: None,
|
||||
blame: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1264,6 +1266,13 @@ impl Document {
|
|||
Range::new(0, 1).grapheme_aligned(self.text().slice(..))
|
||||
}
|
||||
|
||||
/// Get the line of cursor for the primary selection
|
||||
pub fn cursor_line(&self, view_id: ViewId) -> usize {
|
||||
let text = self.text();
|
||||
let selection = self.selection(view_id);
|
||||
text.char_to_line(selection.primary().cursor(text.slice(..)))
|
||||
}
|
||||
|
||||
/// Reset the view's selection on this document to the
|
||||
/// [origin](Document::origin) cursor.
|
||||
pub fn reset_selection(&mut self, view_id: ViewId) {
|
||||
|
|
|
|||
|
|
@ -174,6 +174,23 @@ impl Default for GutterLineNumbersConfig {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "kebab-case", default, deny_unknown_fields)]
|
||||
pub struct VersionControlConfig {
|
||||
/// Whether to enable git blame
|
||||
pub inline_blame: bool,
|
||||
pub inline_blame_format: String,
|
||||
}
|
||||
|
||||
impl Default for VersionControlConfig {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
inline_blame: false,
|
||||
inline_blame_format: "{author}, {date} • {message} • {commit}".to_owned(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "kebab-case", default, deny_unknown_fields)]
|
||||
pub struct FilePickerConfig {
|
||||
|
|
@ -371,6 +388,7 @@ pub struct Config {
|
|||
pub clipboard_provider: ClipboardProvider,
|
||||
/// Centralized location for icons that can be used throughout the UI
|
||||
pub icons: Icons,
|
||||
pub version_control: VersionControlConfig,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, Eq, PartialOrd, Ord)]
|
||||
|
|
@ -1017,6 +1035,7 @@ impl Default for Config {
|
|||
end_of_line_diagnostics: DiagnosticFilter::Disable,
|
||||
clipboard_provider: ClipboardProvider::default(),
|
||||
icons: Icons::default(),
|
||||
version_control: VersionControlConfig::default(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,8 @@
|
|||
use std::path::PathBuf;
|
||||
|
||||
use completion::{CompletionEvent, CompletionHandler};
|
||||
use helix_event::send_blocking;
|
||||
use helix_vcs::DiffProviderRegistry;
|
||||
use tokio::sync::mpsc::Sender;
|
||||
|
||||
use crate::handlers::lsp::SignatureHelpInvoked;
|
||||
|
|
@ -16,12 +19,28 @@ pub enum AutoSaveEvent {
|
|||
LeftInsertMode,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum BlameEvent {
|
||||
PostCommand {
|
||||
file: PathBuf,
|
||||
cursor_line: u32,
|
||||
/// How many lines were removed before cursor_line
|
||||
deleted_lines_count: u32,
|
||||
/// How many lines were added before cursor_line
|
||||
inserted_lines_count: u32,
|
||||
diff_providers: DiffProviderRegistry,
|
||||
/// Format of the blame
|
||||
blame_format: String,
|
||||
},
|
||||
}
|
||||
|
||||
pub struct Handlers {
|
||||
// only public because most of the actual implementation is in helix-term right now :/
|
||||
pub completions: CompletionHandler,
|
||||
pub signature_hints: Sender<lsp::SignatureHelpEvent>,
|
||||
pub auto_save: Sender<AutoSaveEvent>,
|
||||
pub pull_diagnostics: Sender<lsp::PullDiagnosticsEvent>,
|
||||
pub blame: Sender<BlameEvent>,
|
||||
}
|
||||
|
||||
impl Handlers {
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue