Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
git: Further extract gitlib2 dependencies (#58280)
Anthony Eide07d9a438b37
diff --git a/Cargo.lock b/Cargo.lockindex 334815a59a5..03720dca110 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -14313,7 +14313,6 @@ dependencies = ["fuzzy","fuzzy_nucleo","git",- "git2","git_hosting_providers","globset","gpui",@@ -15527,7 +15526,6 @@ dependencies = ["fs","futures 0.3.32","git",- "git2","git_hosting_providers","gpui","gpui_platform",@@ -20387,7 +20385,6 @@ dependencies = ["dunce","futures 0.3.32","futures-lite 1.13.0",- "git2","globset","gpui_util","itertools 0.14.0",diff --git a/crates/collab/tests/integration/editor_tests.rs b/crates/collab/tests/integration/editor_tests.rsindex 71040766db0..e4e8fbfae01 100644--- a/crates/collab/tests/integration/editor_tests.rs+++ b/crates/collab/tests/integration/editor_tests.rs@@ -6235,6 +6235,17 @@ fn blame_entry(sha: &str, range: Range<u32>) -> git::blame::BlameEntry {git::blame::BlameEntry {sha: sha.parse().unwrap(),range,- ..Default::default()+ original_line_number: 0,+ author: None,+ author_mail: None,+ author_time: None,+ author_tz: None,+ committer_name: None,+ committer_email: None,+ committer_time: None,+ committer_tz: None,+ summary: None,+ previous: None,+ filename: String::new(),}}diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rsindex e7d23db81b4..e7f06bcacf5 100644--- a/crates/editor/src/editor_tests.rs+++ b/crates/editor/src/editor_tests.rs@@ -30142,7 +30142,18 @@ async fn test_hide_pending_blame_popover_when_modal_opens(cx: &mut TestAppContex&::git::blame::BlameEntry {sha: "1b1b1b".parse().unwrap(),range: 0..1,- ..Default::default()+ original_line_number: 0,+ author: None,+ author_mail: None,+ author_time: None,+ author_tz: None,+ committer_name: None,+ committer_email: None,+ committer_time: None,+ committer_tz: None,+ summary: None,+ previous: None,+ filename: String::new(),},gpui::point(gpui::px(0.), gpui::px(0.)),false,diff --git a/crates/editor/src/git/blame.rs b/crates/editor/src/git/blame.rsindex a78c37e66d1..0e6ad1cb0ea 100644--- a/crates/editor/src/git/blame.rs+++ b/crates/editor/src/git/blame.rs@@ -1281,7 +1281,18 @@ mod tests {BlameEntry {sha: sha.parse().unwrap(),range,- ..Default::default()+ original_line_number: 0,+ author: None,+ author_mail: None,+ author_time: None,+ author_tz: None,+ committer_name: None,+ committer_email: None,+ committer_time: None,+ committer_tz: None,+ summary: None,+ previous: None,+ filename: String::new(),}}}diff --git a/crates/fs/src/fake_git_repo.rs b/crates/fs/src/fake_git_repo.rsindex 7635317aed1..3a2c0980983 100644--- a/crates/fs/src/fake_git_repo.rs+++ b/crates/fs/src/fake_git_repo.rs@@ -161,8 +161,6 @@ impl FakeGitRepository {}impl GitRepository for FakeGitRepository {- fn reload_index(&self) {}-fn load_index_text(&self, path: RepoPath) -> BoxFuture<'_, Option<String>> {let fut = self.with_state_async(false, move |state| {statediff --git a/crates/git/src/blame.rs b/crates/git/src/blame.rsindex 2261f52f878..b10a50942b8 100644--- a/crates/git/src/blame.rs+++ b/crates/git/src/blame.rs@@ -12,8 +12,6 @@ use time::UtcOffset;use time::macros::format_description;use util::command::Stdio;-pub use git2 as libgit;-#[derive(Debug, Clone, Default)]pub struct Blame {pub entries: Vec<BlameEntry>,@@ -92,7 +90,7 @@ async fn run_git_blame(Ok(String::from_utf8(output.stdout)?)}-#[derive(Serialize, Deserialize, Default, Debug, Clone, PartialEq, Eq)]+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]pub struct BlameEntry {pub sha: Oid,@@ -151,7 +149,17 @@ impl BlameEntry {sha,range,original_line_number,- ..Default::default()+ author: None,+ author_mail: None,+ author_time: None,+ author_tz: None,+ committer_name: None,+ committer_email: None,+ committer_time: None,+ committer_tz: None,+ summary: None,+ previous: None,+ filename: String::new(),})}diff --git a/crates/git/src/git.rs b/crates/git/src/git.rsindex 73ba6275756..e826e5c0c3c 100644--- a/crates/git/src/git.rs+++ b/crates/git/src/git.rs@@ -8,13 +8,12 @@ pub mod status;pub use crate::hosting_provider::*;pub use crate::remote::*;-use anyhow::{Context as _, Result};-pub use git2 as libgit;+use anyhow::Result;use gpui::{Action, actions};pub use repository::RemoteCommandOutput;use schemars::JsonSchema;use serde::{Deserialize, Serialize};-use std::fmt;+use std::fmt::{self, Write as _};use std::str::FromStr;pub const DOT_GIT: &str = ".git";@@ -137,40 +136,115 @@ pub struct RestoreFile {/// The length of a Git short SHA.pub const SHORT_SHA_LENGTH: usize = 7;+const SHA1_BYTE_LENGTH: usize = 20;+const SHA256_BYTE_LENGTH: usize = 32;+const SHA1_HEX_LENGTH: usize = SHA1_BYTE_LENGTH * 2;+const SHA256_HEX_LENGTH: usize = SHA256_BYTE_LENGTH * 2;+const HEX_DIGITS: &[u8; 16] = b"0123456789abcdef";+#[derive(Clone, Copy, Eq, Hash, PartialEq)]-pub struct Oid(libgit::Oid);+pub struct Oid {+ bytes: [u8; SHA256_BYTE_LENGTH],+ format: OidFormat,+}++#[derive(Clone, Copy, Eq, Hash, PartialEq)]+enum OidFormat {+ Sha1,+ Sha256,+}++impl OidFormat {+ fn byte_len(self) -> usize {+ match self {+ Self::Sha1 => SHA1_BYTE_LENGTH,+ Self::Sha256 => SHA256_BYTE_LENGTH,+ }+ }++ fn hex_len(self) -> usize {+ match self {+ Self::Sha1 => SHA1_HEX_LENGTH,+ Self::Sha256 => SHA256_HEX_LENGTH,+ }+ }+}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))+ let format = match bytes.len() {+ SHA1_BYTE_LENGTH => OidFormat::Sha1,+ SHA256_BYTE_LENGTH => OidFormat::Sha256,+ len => {+ anyhow::bail!(+ "invalid git oid byte length: expected {SHA1_BYTE_LENGTH} for SHA-1 or {SHA256_BYTE_LENGTH} for SHA-256, got {len}"+ );+ }+ };++ let mut oid_bytes = [0u8; SHA256_BYTE_LENGTH];+ oid_bytes[..bytes.len()].copy_from_slice(bytes);+ Ok(Self {+ bytes: oid_bytes,+ format,+ })}#[cfg(any(test, feature = "test-support"))]pub fn random(rng: &mut impl rand::Rng) -> Self {- let mut bytes = [0; 20];- rng.fill(&mut bytes);- Self::from_bytes(&bytes).unwrap()+ let mut bytes = [0u8; SHA256_BYTE_LENGTH];+ rng.fill(&mut bytes[..SHA1_BYTE_LENGTH]);+ Self {+ bytes,+ format: OidFormat::Sha1,+ }}pub fn as_bytes(&self) -> &[u8] {- self.0.as_bytes()+ &self.bytes[..self.format.byte_len()]}pub(crate) fn is_zero(&self) -> bool {- self.0.is_zero()+ self.as_bytes().iter().all(|byte| *byte == 0)}/// Returns this [`Oid`] as a short SHA.pub fn display_short(&self) -> String {- self.to_string().chars().take(SHORT_SHA_LENGTH).collect()+ self.hex_string(SHORT_SHA_LENGTH)+ }++ fn hex_string(&self, len: usize) -> String {+ let mut string = String::with_capacity(len);+ for index in 0..len {+ string.push(self.hex_digit(index));+ }+ string+ }++ fn write_hex(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ for index in 0..self.format.hex_len() {+ f.write_char(self.hex_digit(index))?;+ }+ Ok(())+ }++ #[inline(always)]+ fn hex_digit(&self, index: usize) -> char {+ debug_assert!(index < self.format.hex_len());+ let byte = self.as_bytes()[index / 2];+ let nibble = if index & 1 == 0 {+ byte >> 4+ } else {+ byte & 0x0f+ };+ char::from(HEX_DIGITS[nibble as usize])}}impl TryFrom<&str> for Oid {type Error = anyhow::Error;- fn try_from(value: &str) -> std::prelude::v1::Result<Self, Self::Error> {+ fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {Oid::from_str(value)}}@@ -178,13 +252,38 @@ impl TryFrom<&str> for Oid {impl FromStr for Oid {type Err = anyhow::Error;- fn from_str(s: &str) -> std::prelude::v1::Result<Self, Self::Err> {- let oid = if s.len() == 64 {- libgit::Oid::from_str_ext(s, libgit::ObjectFormat::Sha256)- } else {- libgit::Oid::from_str_ext(s, libgit::ObjectFormat::Sha1)+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {+ let format = match s.len() {+ 1..=SHA1_HEX_LENGTH => OidFormat::Sha1,+ SHA256_HEX_LENGTH => OidFormat::Sha256,+ len => {+ anyhow::bail!(+ "invalid git oid hex length: expected 1..={SHA1_HEX_LENGTH} for SHA-1 or {SHA256_HEX_LENGTH} for SHA-256, got {len}"+ );+ }};- oid.context("parsing git oid").map(Self)++ let mut bytes = [0u8; SHA256_BYTE_LENGTH];+ for (index, byte) in s.bytes().enumerate() {+ let digit = decode_hex_digit(byte)+ .ok_or_else(|| anyhow::anyhow!("invalid hex digit at byte {index} for git oid"))?;+ if index % 2 == 0 {+ bytes[index / 2] = digit << 4;+ } else {+ bytes[index / 2] |= digit;+ }+ }++ Ok(Self { bytes, format })+ }+}++fn decode_hex_digit(byte: u8) -> Option<u8> {+ match byte {+ b'0'..=b'9' => Some(byte - b'0'),+ b'a'..=b'f' => Some(byte - b'a' + 10),+ b'A'..=b'F' => Some(byte - b'A' + 10),+ _ => None,}}@@ -196,21 +295,21 @@ impl fmt::Debug for Oid {impl fmt::Display for Oid {fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {- self.0.fmt(f)+ self.write_hex(f)}}impl Serialize for Oid {- fn serialize<S>(&self, serializer: S) -> std::prelude::v1::Result<S::Ok, S::Error>+ fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>whereS: serde::Serializer,{- serializer.serialize_str(&self.0.to_string())+ serializer.serialize_str(&self.hex_string(self.format.hex_len()))}}impl<'de> Deserialize<'de> for Oid {- fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>+ fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>whereD: serde::Deserializer<'de>,{@@ -219,33 +318,49 @@ impl<'de> Deserialize<'de> for Oid {}}-impl Default for Oid {- fn default() -> Self {- Self(libgit::Oid::ZERO_SHA1)- }-}-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]);-+ let mut u32_bytes = [0u8; 4];+ u32_bytes.copy_from_slice(&oid.as_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 = [0u8; 8];+ u64_bytes.copy_from_slice(&oid.as_bytes()[..8]);+ u64::from_ne_bytes(u64_bytes) as usize+ }+}- let mut u64_bytes: [u8; 8] = [0; 8];- u64_bytes.copy_from_slice(&bytes[..8]);+#[cfg(test)]+mod tests {+ use super::*;- u64::from_ne_bytes(u64_bytes) as usize+ #[test]+ fn parses_short_sha1_oid_by_padding_trailing_nibbles() {+ let oid = "abc1234".parse::<Oid>().expect("failed to parse oid");++ assert_eq!(oid.as_bytes().len(), SHA1_BYTE_LENGTH);+ assert_eq!(oid.display_short(), "abc1234");+ assert_eq!(oid.to_string(), "abc1234000000000000000000000000000000000");+ }++ #[test]+ fn parses_full_sha256_oid() {+ let sha = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";+ let oid = sha.parse::<Oid>().expect("failed to parse oid");++ assert_eq!(oid.as_bytes().len(), SHA256_BYTE_LENGTH);+ assert_eq!(oid.to_string(), sha);+ }++ #[test]+ fn rejects_invalid_oid_lengths() {+ assert!("".parse::<Oid>().is_err());+ assert!("a".repeat(SHA1_HEX_LENGTH + 1).parse::<Oid>().is_err());+ assert!("a".repeat(SHA256_HEX_LENGTH - 1).parse::<Oid>().is_err());}}diff --git a/crates/git/src/repository.rs b/crates/git/src/repository.rsindex 7da5ae44904..b58758cff11 100644--- a/crates/git/src/repository.rs+++ b/crates/git/src/repository.rs@@ -774,8 +774,6 @@ pub fn delete_branch_flag(is_remote_tracking_ref: bool, force: bool) -> &'static}pub trait GitRepository: Send + Sync {- fn reload_index(&self);-/// Returns the contents of an entry in the repository's index, or None if there is no entry for the given path.////// Also returns `None` for symlinks.@@ -1262,12 +1260,6 @@ pub async fn get_git_committer(cx: &AsyncApp) -> GitCommitter {}impl GitRepository for RealGitRepository {- fn reload_index(&self) {- if let Ok(mut index) = self.repository.lock().index() {- _ = index.read(false);- }- }-fn path(&self) -> PathBuf {let repo = self.repository.lock();repo.path().into()@@ -1564,7 +1556,8 @@ impl GitRepository for RealGitRepository {self.executor.spawn(async move {let repo = repo.lock();- let content = repo.find_blob(oid.0)?.content().to_owned();+ let oid = git2::Oid::from_bytes(oid.as_bytes())?;+ let content = repo.find_blob(oid)?.content().to_owned();Ok(String::from_utf8(content)?)}).boxed()diff --git a/crates/project/Cargo.toml b/crates/project/Cargo.tomlindex 3a27bf4de61..df57a8fdf5e 100644--- a/crates/project/Cargo.toml+++ b/crates/project/Cargo.toml@@ -114,7 +114,6 @@ context_server = { workspace = true, features = ["test-support"] }buffer_diff = { workspace = true, features = ["test-support"] }dap = { workspace = true, features = ["test-support"] }fs = { workspace = true, features = ["test-support"] }-git2.workspace = truegpui = { workspace = true, features = ["test-support"] }language = { workspace = true, features = ["test-support"] }lsp = { workspace = true, features = ["test-support"] }diff --git a/crates/project/tests/integration/project_tests.rs b/crates/project/tests/integration/project_tests.rsindex daaaa0bd2c6..9ad334ece6b 100644--- a/crates/project/tests/integration/project_tests.rs+++ b/crates/project/tests/integration/project_tests.rs@@ -33,7 +33,6 @@ use git::{repository::{RepoPath, repo_path},status::{DiffStat, FileStatus, StatusCode, TrackedStatus},};-use git2::RepositoryInitOptions;use gpui::{App, AppContext, BackgroundExecutor, BorrowAppContext, Entity, FutureExt, SharedString, Task,TestAppContext, UpdateGlobal,@@ -77,6 +76,7 @@ use std::{num::NonZeroU32,ops::Range,path::{Path, PathBuf},+ process::Command,rc::Rc,str::FromStr,sync::{Arc, OnceLock, atomic},@@ -11101,7 +11101,8 @@ async fn test_conflicted_cherry_pick(cx: &mut gpui::TestAppContext) {}));let root_path = root.path();- let repo = git_init(&root_path.join("project"));+ let work_dir = &root_path.join("project");+ let repo = git_init(work_dir);git_add("a.txt", &repo);git_commit("init", &repo);@@ -11119,25 +11120,21 @@ async fn test_conflicted_cherry_pick(cx: &mut gpui::TestAppContext) {});git_branch("other-branch", &repo);- git_checkout("refs/heads/other-branch", &repo);+ git_checkout("other-branch", &repo);std::fs::write(root_path.join("project/a.txt"), "A").unwrap();git_add("a.txt", &repo);git_commit("capitalize", &repo);- let commit = repo- .head()- .expect("Failed to get HEAD")- .peel_to_commit()- .expect("HEAD is not a commit");- git_checkout("refs/heads/main", &repo);+ let commit = git_rev_parse("HEAD", &repo);+ git_checkout("main", &repo);std::fs::write(root_path.join("project/a.txt"), "b").unwrap();git_add("a.txt", &repo);git_commit("improve letter", &repo);- git_cherry_pick(&commit, &repo);+ git_cherry_pick_expect_conflict(&commit, &repo);std::fs::read_to_string(root_path.join("project/.git/CHERRY_PICK_HEAD")).expect("No CHERRY_PICK_HEAD");pretty_assertions::assert_eq!(git_status(&repo),- collections::HashMap::from_iter([("a.txt".to_owned(), git2::Status::CONFLICTED)])+ collections::HashMap::from_iter([("a.txt".to_owned(), GIT_STATUS_CONFLICTED.to_owned())]));tree.flush_fs_events(cx).await;project@@ -11364,8 +11361,7 @@ async fn test_file_status(cx: &mut gpui::TestAppContext) {// Set up git repository before creating the worktree.let work_dir = root.path().join("project");- let mut repo = git_init(work_dir.as_path());- repo.add_ignore_rule(IGNORE_RULE).unwrap();+ let repo = git_init(work_dir.as_path());git_add(A_TXT, &repo);git_add(E_TXT, &repo);git_add(DOTGITIGNORE, &repo);@@ -11452,7 +11448,7 @@ async fn test_file_status(cx: &mut gpui::TestAppContext) {// Modify files in the working copy and perform git operations on other files.git_reset(0, &repo);git_remove_index(Path::new(B_TXT), &repo);- git_stash(&mut repo);+ git_stash(&repo);std::fs::write(work_dir.join(E_TXT), "eeee").unwrap();std::fs::write(work_dir.join(BUILD_FILE), "this should be ignored").unwrap();tree.flush_fs_events(cx).await;@@ -11576,7 +11572,6 @@ async fn test_ignored_dirs_events(cx: &mut gpui::TestAppContext) {// Set up git repository before creating the worktree.let work_dir = root.path().join("project");let repo = git_init(work_dir.as_path());- repo.add_ignore_rule(IGNORE_RULE).unwrap();git_add("src/main.rs", &repo);git_add(".gitignore", &repo);git_commit("Initial commit", &repo);@@ -12740,111 +12735,192 @@ fn assert_entry_git_state();}+#[cfg(any())]+const GIT_STATUS_CONFLICTED: &str = "UU";++#[allow(clippy::disallowed_methods)]+fn git_cmd(work_dir: &Path) -> Command {+ let mut cmd = Command::new("git");+ cmd.current_dir(work_dir)+ .env("GIT_CONFIG_GLOBAL", "")+ .env("GIT_CONFIG_SYSTEM", "")+ .env("GIT_AUTHOR_NAME", "test")+ .env("GIT_AUTHOR_EMAIL", "[email protected]")+ .env("GIT_COMMITTER_NAME", "test")+ .env("GIT_COMMITTER_EMAIL", "[email protected]");+ cmd+}++#[allow(clippy::disallowed_methods)]#[track_caller]-fn git_init(path: &Path) -> git2::Repository {- let mut init_opts = RepositoryInitOptions::new();- init_opts.initial_head("main");- git2::Repository::init_opts(path, &init_opts).expect("Failed to initialize git repository")+fn git_init(path: &Path) -> PathBuf {+ let output = git_cmd(path)+ .args(["init", "-b", "main"])+ .output()+ .expect("Failed to run git init");+ assert!(+ output.status.success(),+ "git init failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );+ path.to_path_buf()}+#[allow(clippy::disallowed_methods)]#[track_caller]-fn git_add<P: AsRef<Path>>(path: P, repo: &git2::Repository) {- let path = path.as_ref();- let mut index = repo.index().expect("Failed to get index");- index.add_path(path).expect("Failed to add file");- index.write().expect("Failed to write index");+fn git_add<P: AsRef<Path>>(path: P, work_dir: &Path) {+ let output = git_cmd(work_dir)+ .args(["add"])+ .arg(path.as_ref())+ .output()+ .expect("Failed to run git add");+ assert!(+ output.status.success(),+ "git add failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );}+#[allow(clippy::disallowed_methods)]#[track_caller]-fn git_remove_index(path: &Path, repo: &git2::Repository) {- let mut index = repo.index().expect("Failed to get index");- index.remove_path(path).expect("Failed to add file");- index.write().expect("Failed to write index");+fn git_remove_index(path: &Path, work_dir: &Path) {+ let output = git_cmd(work_dir)+ .args(["rm", "--cached"])+ .arg(path)+ .output()+ .expect("Failed to run git rm");+ assert!(+ output.status.success(),+ "git rm --cached failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );}+#[allow(clippy::disallowed_methods)]#[track_caller]-fn git_commit(msg: &'static str, repo: &git2::Repository) {- use git2::Signature;-- let signature = Signature::now("test", "[email protected]").unwrap();- let oid = repo.index().unwrap().write_tree().unwrap();- let tree = repo.find_tree(oid).unwrap();- if let Ok(head) = repo.head() {- let parent_obj = head.peel(git2::ObjectType::Commit).unwrap();-- let parent_commit = parent_obj.as_commit().unwrap();-- repo.commit(- Some("HEAD"),- &signature,- &signature,- msg,- &tree,- &[parent_commit],- )- .expect("Failed to commit with parent");- } else {- repo.commit(Some("HEAD"), &signature, &signature, msg, &tree, &[])- .expect("Failed to commit");- }+fn git_commit(msg: &str, work_dir: &Path) {+ let output = git_cmd(work_dir)+ .args(["commit", "-m", msg])+ .output()+ .expect("Failed to run git commit");+ assert!(+ output.status.success(),+ "git commit failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );}-#[cfg(any())]+#[allow(clippy::disallowed_methods)]#[track_caller]-fn git_cherry_pick(commit: &git2::Commit<'_>, repo: &git2::Repository) {- repo.cherrypick(commit, None).expect("Failed to cherrypick");+fn git_stash(work_dir: &Path) {+ let output = git_cmd(work_dir)+ .args(["stash"])+ .output()+ .expect("Failed to run git stash");+ assert!(+ output.status.success(),+ "git stash failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );}+#[allow(clippy::disallowed_methods)]#[track_caller]-fn git_stash(repo: &mut git2::Repository) {- use git2::Signature;+fn git_reset(offset: usize, work_dir: &Path) {+ let target = format!("HEAD~{}", offset + 1);+ let output = git_cmd(work_dir)+ .args(["reset", "--soft", &target])+ .output()+ .expect("Failed to run git reset");+ assert!(+ output.status.success(),+ "git reset failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );+}- let signature = Signature::now("test", "[email protected]").unwrap();- repo.stash_save(&signature, "N/A", None)- .expect("Failed to stash");+#[cfg(any())]+#[allow(clippy::disallowed_methods)]+#[track_caller]+fn git_branch(name: &str, work_dir: &Path) {+ let output = git_cmd(work_dir)+ .args(["branch", name])+ .output()+ .expect("Failed to run git branch");+ assert!(+ output.status.success(),+ "git branch failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );}+#[cfg(any())]+#[allow(clippy::disallowed_methods)]#[track_caller]-fn git_reset(offset: usize, repo: &git2::Repository) {- let head = repo.head().expect("Couldn't get repo head");- let object = head.peel(git2::ObjectType::Commit).unwrap();- let commit = object.as_commit().unwrap();- let new_head = commit- .parents()- .inspect(|parnet| {- let _ = parnet.message();- })- .nth(offset)- .expect("Not enough history");- repo.reset(new_head.as_object(), git2::ResetType::Soft, None)- .expect("Could not reset");+fn git_checkout(name: &str, work_dir: &Path) {+ let output = git_cmd(work_dir)+ .args(["checkout", name])+ .output()+ .expect("Failed to run git checkout");+ assert!(+ output.status.success(),+ "git checkout failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );}#[cfg(any())]+#[allow(clippy::disallowed_methods)]#[track_caller]-fn git_branch(name: &str, repo: &git2::Repository) {- let head = repo- .head()- .expect("Couldn't get repo head")- .peel_to_commit()- .expect("HEAD is not a commit");- repo.branch(name, &head, false).expect("Failed to commit");+fn git_rev_parse(rev: &str, work_dir: &Path) -> String {+ let output = git_cmd(work_dir)+ .args(["rev-parse", rev])+ .output()+ .expect("Failed to run git rev-parse");+ assert!(+ output.status.success(),+ "git rev-parse failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );+ String::from_utf8(output.stdout).unwrap().trim().to_string()}#[cfg(any())]+#[allow(clippy::disallowed_methods)]#[track_caller]-fn git_checkout(name: &str, repo: &git2::Repository) {- repo.set_head(name).expect("Failed to set head");- repo.checkout_head(None).expect("Failed to check out head");+fn git_cherry_pick_expect_conflict(commit: &str, work_dir: &Path) {+ let output = git_cmd(work_dir)+ .args(["cherry-pick", "--no-commit", commit])+ .output()+ .expect("Failed to run git cherry-pick");+ assert!(+ !output.status.success(),+ "git cherry-pick unexpectedly succeeded"+ );}#[cfg(any())]+#[allow(clippy::disallowed_methods)]#[track_caller]-fn git_status(repo: &git2::Repository) -> collections::HashMap<String, git2::Status> {- repo.statuses(None)- .unwrap()- .iter()- .map(|status| (status.path().unwrap().to_string(), status.status()))+fn git_status(work_dir: &Path) -> collections::HashMap<String, String> {+ let output = git_cmd(work_dir)+ .args(["status", "--porcelain=v1"])+ .output()+ .expect("Failed to run git status");+ assert!(+ output.status.success(),+ "git status failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );+ let stdout = String::from_utf8(output.stdout).unwrap();+ stdout+ .lines()+ .filter(|line| !line.is_empty())+ .map(|line| {+ let status = line[..2].to_string();+ let path = line[3..].to_string();+ (path, status)+ }).collect()}diff --git a/crates/remote_server/Cargo.toml b/crates/remote_server/Cargo.tomlindex db879f1ddf5..05bebd25fd0 100644--- a/crates/remote_server/Cargo.toml+++ b/crates/remote_server/Cargo.toml@@ -39,7 +39,6 @@ fs.workspace = truefutures.workspace = truegit.workspace = truegit_hosting_providers.workspace = true-git2 = { workspace = true, features = ["vendored-libgit2"] }gpui.workspace = truegpui_platform.workspace = truegpui_tokio.workspace = true@@ -115,4 +114,4 @@ cargo_toml.workspace = truetoml.workspace = true[package.metadata.cargo-machete]-ignored = ["git2", "rust-embed", "paths"]+ignored = ["rust-embed", "paths"]diff --git a/crates/util/Cargo.toml b/crates/util/Cargo.tomlindex 4f317e79e0c..13f40811225 100644--- a/crates/util/Cargo.toml+++ b/crates/util/Cargo.toml@@ -15,7 +15,7 @@ path = "src/util.rs"doctest = true[features]-test-support = ["git2", "rand", "util_macros"]+test-support = ["rand", "util_macros"][dependencies]anyhow.workspace = true@@ -46,7 +46,6 @@ gpui_util.workspace = true[target.'cfg(not(target_family = "wasm"))'.dependencies]smol.workspace = truewhich.workspace = true-git2 = { workspace = true, optional = true }async-fs.workspace = truewalkdir.workspace = truedirs.workspace = true@@ -63,7 +62,6 @@ mach2.workspace = truetendril = "0.4.3"[dev-dependencies]-git2.workspace = truerand.workspace = trueutil_macros.workspace = truepretty_assertions.workspace = truediff --git a/crates/util/src/test.rs b/crates/util/src/test.rsindex 717754e3337..68688ee2e28 100644--- a/crates/util/src/test.rs+++ b/crates/util/src/test.rs@@ -4,7 +4,6 @@ mod marked_text;pub use assertions::*;pub use marked_text::*;-use git2;use std::ffi::OsStr;use std::path::{Path, PathBuf};use tempfile::TempDir;@@ -44,8 +43,20 @@ fn write_tree(path: &Path, tree: serde_json::Value) {fs::create_dir(&path).unwrap();#[cfg(not(target_family = "wasm"))]+ #[allow(clippy::disallowed_methods)]if path.file_name() == Some(OsStr::new(".git")) {- git2::Repository::init(path.parent().unwrap()).unwrap();+ let output = std::process::Command::new("git")+ .args(["init", "-b", "main"])+ .current_dir(path.parent().unwrap())+ .env("GIT_CONFIG_GLOBAL", "")+ .env("GIT_CONFIG_SYSTEM", "")+ .output()+ .expect("failed to init git repo");+ assert!(+ output.status.success(),+ "git init failed: {}",+ String::from_utf8_lossy(&output.stderr)+ );}write_tree(&path, contents);