7f54935324
This adds a new action to the editor: `editor: toggle git blame`. When used it turns on a sidebar containing `git blame` information for the currently open buffer. The git blame information is updated when the buffer changes. It handles additions, deletions, modifications, changes to the underlying git data (new commits, changed commits, ...), file saves. It also handles folding and wrapping lines correctly. When the user hovers over a commit, a tooltip displays information for the commit that introduced the line. If the repository has a remote with the name `origin` configured, then clicking on a blame entry opens the permalink to the commit on the code host. Users can right-click on a blame entry to get a context menu which allows them to copy the SHA of the commit. The feature also works on shared projects, e.g. when collaborating a peer can request `git blame` data. As of this PR, Zed now comes bundled with a `git` binary so that users don't have to have `git` installed locally to use this feature. ### Screenshots    ### TODOs - [x] Bundling `git` binary ### Release Notes Release Notes: - Added `editor: toggle git blame` command that toggles a sidebar with git blame information for the current buffer. --------- Co-authored-by: Antonio <antonio@zed.dev> Co-authored-by: Piotr <piotr@zed.dev> Co-authored-by: Bennet <bennetbo@gmx.de> Co-authored-by: Mikayla <mikayla@zed.dev>
107 lines
2.5 KiB
Rust
107 lines
2.5 KiB
Rust
use anyhow::{anyhow, Context, Result};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::ffi::OsStr;
|
|
use std::fmt;
|
|
use std::str::FromStr;
|
|
|
|
pub use git2 as libgit;
|
|
pub use lazy_static::lazy_static;
|
|
|
|
pub mod blame;
|
|
pub mod commit;
|
|
pub mod diff;
|
|
pub mod permalink;
|
|
|
|
lazy_static! {
|
|
pub static ref DOT_GIT: &'static OsStr = OsStr::new(".git");
|
|
pub static ref GITIGNORE: &'static OsStr = OsStr::new(".gitignore");
|
|
}
|
|
|
|
#[derive(Clone, Copy, Eq, Hash, PartialEq)]
|
|
pub struct Oid(libgit::Oid);
|
|
|
|
impl Oid {
|
|
pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
|
|
let oid = libgit::Oid::from_bytes(bytes).context("failed to parse bytes into git oid")?;
|
|
Ok(Self(oid))
|
|
}
|
|
|
|
pub fn as_bytes(&self) -> &[u8] {
|
|
self.0.as_bytes()
|
|
}
|
|
|
|
pub(crate) fn is_zero(&self) -> bool {
|
|
self.0.is_zero()
|
|
}
|
|
}
|
|
|
|
impl FromStr for Oid {
|
|
type Err = anyhow::Error;
|
|
|
|
fn from_str(s: &str) -> std::prelude::v1::Result<Self, Self::Err> {
|
|
libgit::Oid::from_str(s)
|
|
.map_err(|error| anyhow!("failed to parse git oid: {}", error))
|
|
.map(|oid| Self(oid))
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for Oid {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
fmt::Display::fmt(self, f)
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for Oid {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
self.0.fmt(f)
|
|
}
|
|
}
|
|
|
|
impl Serialize for Oid {
|
|
fn serialize<S>(&self, serializer: S) -> std::prelude::v1::Result<S::Ok, S::Error>
|
|
where
|
|
S: serde::Serializer,
|
|
{
|
|
serializer.serialize_str(&self.0.to_string())
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for Oid {
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
let s = String::deserialize(deserializer)?;
|
|
s.parse::<Oid>().map_err(serde::de::Error::custom)
|
|
}
|
|
}
|
|
|
|
impl Default for Oid {
|
|
fn default() -> Self {
|
|
Self(libgit::Oid::zero())
|
|
}
|
|
}
|
|
|
|
impl From<Oid> for u32 {
|
|
fn from(oid: Oid) -> Self {
|
|
let bytes = oid.0.as_bytes();
|
|
debug_assert!(bytes.len() > 4);
|
|
|
|
let mut u32_bytes: [u8; 4] = [0; 4];
|
|
u32_bytes.copy_from_slice(&bytes[..4]);
|
|
|
|
u32::from_ne_bytes(u32_bytes)
|
|
}
|
|
}
|
|
|
|
impl From<Oid> for usize {
|
|
fn from(oid: Oid) -> Self {
|
|
let bytes = oid.0.as_bytes();
|
|
debug_assert!(bytes.len() > 8);
|
|
|
|
let mut u64_bytes: [u8; 8] = [0; 8];
|
|
u64_bytes.copy_from_slice(&bytes[..8]);
|
|
|
|
u64::from_ne_bytes(u64_bytes) as usize
|
|
}
|
|
}
|