1pub mod branch_diff;
2mod conflict_set;
3pub mod git_traversal;
4pub mod pending_op;
5
6use crate::{
7 ProjectEnvironment, ProjectItem, ProjectPath,
8 buffer_store::{BufferStore, BufferStoreEvent},
9 worktree_store::{WorktreeStore, WorktreeStoreEvent},
10};
11use anyhow::{Context as _, Result, anyhow, bail};
12use askpass::{AskPassDelegate, EncryptedPassword, IKnowWhatIAmDoingAndIHaveReadTheDocs};
13use buffer_diff::{BufferDiff, BufferDiffEvent};
14use client::ProjectId;
15use collections::HashMap;
16pub use conflict_set::{ConflictRegion, ConflictSet, ConflictSetSnapshot, ConflictSetUpdate};
17use fs::Fs;
18use futures::{
19 FutureExt, StreamExt,
20 channel::{
21 mpsc,
22 oneshot::{self, Canceled},
23 },
24 future::{self, Shared},
25 stream::FuturesOrdered,
26};
27use git::{
28 BuildPermalinkParams, GitHostingProviderRegistry, Oid, RunHook,
29 blame::Blame,
30 parse_git_remote_url,
31 repository::{
32 Branch, CommitDetails, CommitDiff, CommitFile, CommitOptions, DiffType, FetchOptions,
33 GitRepository, GitRepositoryCheckpoint, PushOptions, Remote, RemoteCommandOutput, RepoPath,
34 ResetMode, UpstreamTrackingStatus, Worktree as GitWorktree,
35 },
36 stash::{GitStash, StashEntry},
37 status::{
38 DiffTreeType, FileStatus, GitSummary, StatusCode, TrackedStatus, TreeDiff, TreeDiffStatus,
39 UnmergedStatus, UnmergedStatusCode,
40 },
41};
42use gpui::{
43 App, AppContext, AsyncApp, Context, Entity, EventEmitter, SharedString, Subscription, Task,
44 WeakEntity,
45};
46use language::{
47 Buffer, BufferEvent, Language, LanguageRegistry,
48 proto::{deserialize_version, serialize_version},
49};
50use parking_lot::Mutex;
51use pending_op::{PendingOp, PendingOpId, PendingOps, PendingOpsSummary};
52use postage::stream::Stream as _;
53use rpc::{
54 AnyProtoClient, TypedEnvelope,
55 proto::{self, git_reset, split_repository_update},
56};
57use serde::Deserialize;
58use settings::WorktreeId;
59use smol::future::yield_now;
60use std::{
61 cmp::Ordering,
62 collections::{BTreeSet, HashSet, VecDeque},
63 future::Future,
64 mem,
65 ops::Range,
66 path::{Path, PathBuf},
67 str::FromStr,
68 sync::{
69 Arc,
70 atomic::{self, AtomicU64},
71 },
72 time::Instant,
73};
74use sum_tree::{Edit, SumTree, TreeSet};
75use task::Shell;
76use text::{Bias, BufferId};
77use util::{
78 ResultExt, debug_panic,
79 paths::{PathStyle, SanitizedPath},
80 post_inc,
81 rel_path::RelPath,
82};
83use worktree::{
84 File, PathChange, PathKey, PathProgress, PathSummary, PathTarget, ProjectEntryId,
85 UpdatedGitRepositoriesSet, UpdatedGitRepository, Worktree,
86};
87use zeroize::Zeroize;
88
89pub struct GitStore {
90 state: GitStoreState,
91 buffer_store: Entity<BufferStore>,
92 worktree_store: Entity<WorktreeStore>,
93 repositories: HashMap<RepositoryId, Entity<Repository>>,
94 worktree_ids: HashMap<RepositoryId, HashSet<WorktreeId>>,
95 active_repo_id: Option<RepositoryId>,
96 #[allow(clippy::type_complexity)]
97 loading_diffs:
98 HashMap<(BufferId, DiffKind), Shared<Task<Result<Entity<BufferDiff>, Arc<anyhow::Error>>>>>,
99 diffs: HashMap<BufferId, Entity<BufferGitState>>,
100 shared_diffs: HashMap<proto::PeerId, HashMap<BufferId, SharedDiffs>>,
101 _subscriptions: Vec<Subscription>,
102}
103
104#[derive(Default)]
105struct SharedDiffs {
106 unstaged: Option<Entity<BufferDiff>>,
107 uncommitted: Option<Entity<BufferDiff>>,
108}
109
110struct BufferGitState {
111 unstaged_diff: Option<WeakEntity<BufferDiff>>,
112 uncommitted_diff: Option<WeakEntity<BufferDiff>>,
113 conflict_set: Option<WeakEntity<ConflictSet>>,
114 recalculate_diff_task: Option<Task<Result<()>>>,
115 reparse_conflict_markers_task: Option<Task<Result<()>>>,
116 language: Option<Arc<Language>>,
117 language_registry: Option<Arc<LanguageRegistry>>,
118 conflict_updated_futures: Vec<oneshot::Sender<()>>,
119 recalculating_tx: postage::watch::Sender<bool>,
120
121 /// These operation counts are used to ensure that head and index text
122 /// values read from the git repository are up-to-date with any hunk staging
123 /// operations that have been performed on the BufferDiff.
124 ///
125 /// The operation count is incremented immediately when the user initiates a
126 /// hunk stage/unstage operation. Then, upon finishing writing the new index
127 /// text do disk, the `operation count as of write` is updated to reflect
128 /// the operation count that prompted the write.
129 hunk_staging_operation_count: usize,
130 hunk_staging_operation_count_as_of_write: usize,
131
132 head_text: Option<Arc<String>>,
133 index_text: Option<Arc<String>>,
134 head_changed: bool,
135 index_changed: bool,
136 language_changed: bool,
137}
138
139#[derive(Clone, Debug)]
140enum DiffBasesChange {
141 SetIndex(Option<String>),
142 SetHead(Option<String>),
143 SetEach {
144 index: Option<String>,
145 head: Option<String>,
146 },
147 SetBoth(Option<String>),
148}
149
150#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
151enum DiffKind {
152 Unstaged,
153 Uncommitted,
154}
155
156enum GitStoreState {
157 Local {
158 next_repository_id: Arc<AtomicU64>,
159 downstream: Option<LocalDownstreamState>,
160 project_environment: Entity<ProjectEnvironment>,
161 fs: Arc<dyn Fs>,
162 },
163 Remote {
164 upstream_client: AnyProtoClient,
165 upstream_project_id: u64,
166 downstream: Option<(AnyProtoClient, ProjectId)>,
167 },
168}
169
170enum DownstreamUpdate {
171 UpdateRepository(RepositorySnapshot),
172 RemoveRepository(RepositoryId),
173}
174
175struct LocalDownstreamState {
176 client: AnyProtoClient,
177 project_id: ProjectId,
178 updates_tx: mpsc::UnboundedSender<DownstreamUpdate>,
179 _task: Task<Result<()>>,
180}
181
182#[derive(Clone, Debug)]
183pub struct GitStoreCheckpoint {
184 checkpoints_by_work_dir_abs_path: HashMap<Arc<Path>, GitRepositoryCheckpoint>,
185}
186
187#[derive(Clone, Debug, PartialEq, Eq)]
188pub struct StatusEntry {
189 pub repo_path: RepoPath,
190 pub status: FileStatus,
191}
192
193impl StatusEntry {
194 fn to_proto(&self) -> proto::StatusEntry {
195 let simple_status = match self.status {
196 FileStatus::Ignored | FileStatus::Untracked => proto::GitStatus::Added as i32,
197 FileStatus::Unmerged { .. } => proto::GitStatus::Conflict as i32,
198 FileStatus::Tracked(TrackedStatus {
199 index_status,
200 worktree_status,
201 }) => tracked_status_to_proto(if worktree_status != StatusCode::Unmodified {
202 worktree_status
203 } else {
204 index_status
205 }),
206 };
207
208 proto::StatusEntry {
209 repo_path: self.repo_path.to_proto(),
210 simple_status,
211 status: Some(status_to_proto(self.status)),
212 }
213 }
214}
215
216impl TryFrom<proto::StatusEntry> for StatusEntry {
217 type Error = anyhow::Error;
218
219 fn try_from(value: proto::StatusEntry) -> Result<Self, Self::Error> {
220 let repo_path = RepoPath::from_proto(&value.repo_path).context("invalid repo path")?;
221 let status = status_from_proto(value.simple_status, value.status)?;
222 Ok(Self { repo_path, status })
223 }
224}
225
226impl sum_tree::Item for StatusEntry {
227 type Summary = PathSummary<GitSummary>;
228
229 fn summary(&self, _: <Self::Summary as sum_tree::Summary>::Context<'_>) -> Self::Summary {
230 PathSummary {
231 max_path: self.repo_path.as_ref().clone(),
232 item_summary: self.status.summary(),
233 }
234 }
235}
236
237impl sum_tree::KeyedItem for StatusEntry {
238 type Key = PathKey;
239
240 fn key(&self) -> Self::Key {
241 PathKey(self.repo_path.as_ref().clone())
242 }
243}
244
245#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
246pub struct RepositoryId(pub u64);
247
248#[derive(Clone, Debug, Default, PartialEq, Eq)]
249pub struct MergeDetails {
250 pub conflicted_paths: TreeSet<RepoPath>,
251 pub message: Option<SharedString>,
252 pub heads: Vec<Option<SharedString>>,
253}
254
255#[derive(Clone, Debug, PartialEq, Eq)]
256pub struct RepositorySnapshot {
257 pub id: RepositoryId,
258 pub statuses_by_path: SumTree<StatusEntry>,
259 pub work_directory_abs_path: Arc<Path>,
260 pub path_style: PathStyle,
261 pub branch: Option<Branch>,
262 pub head_commit: Option<CommitDetails>,
263 pub scan_id: u64,
264 pub merge: MergeDetails,
265 pub remote_origin_url: Option<String>,
266 pub remote_upstream_url: Option<String>,
267 pub stash_entries: GitStash,
268}
269
270type JobId = u64;
271
272#[derive(Clone, Debug, PartialEq, Eq)]
273pub struct JobInfo {
274 pub start: Instant,
275 pub message: SharedString,
276}
277
278pub struct Repository {
279 this: WeakEntity<Self>,
280 snapshot: RepositorySnapshot,
281 commit_message_buffer: Option<Entity<Buffer>>,
282 git_store: WeakEntity<GitStore>,
283 // For a local repository, holds paths that have had worktree events since the last status scan completed,
284 // and that should be examined during the next status scan.
285 paths_needing_status_update: BTreeSet<RepoPath>,
286 job_sender: mpsc::UnboundedSender<GitJob>,
287 active_jobs: HashMap<JobId, JobInfo>,
288 pending_ops: SumTree<PendingOps>,
289 job_id: JobId,
290 askpass_delegates: Arc<Mutex<HashMap<u64, AskPassDelegate>>>,
291 latest_askpass_id: u64,
292 repository_state: Shared<Task<Result<RepositoryState, String>>>,
293}
294
295impl std::ops::Deref for Repository {
296 type Target = RepositorySnapshot;
297
298 fn deref(&self) -> &Self::Target {
299 &self.snapshot
300 }
301}
302
303#[derive(Clone)]
304pub struct LocalRepositoryState {
305 pub fs: Arc<dyn Fs>,
306 pub backend: Arc<dyn GitRepository>,
307 pub environment: Arc<HashMap<String, String>>,
308}
309
310impl LocalRepositoryState {
311 async fn new(
312 work_directory_abs_path: Arc<Path>,
313 dot_git_abs_path: Arc<Path>,
314 project_environment: WeakEntity<ProjectEnvironment>,
315 fs: Arc<dyn Fs>,
316 cx: &mut AsyncApp,
317 ) -> anyhow::Result<Self> {
318 let environment = project_environment
319 .update(cx, |project_environment, cx| {
320 project_environment.local_directory_environment(&Shell::System, work_directory_abs_path.clone(), cx)
321 })?
322 .await
323 .unwrap_or_else(|| {
324 log::error!("failed to get working directory environment for repository {work_directory_abs_path:?}");
325 HashMap::default()
326 });
327 let search_paths = environment.get("PATH").map(|val| val.to_owned());
328 let backend = cx
329 .background_spawn({
330 let fs = fs.clone();
331 async move {
332 let system_git_binary_path = search_paths
333 .and_then(|search_paths| {
334 which::which_in("git", Some(search_paths), &work_directory_abs_path)
335 .ok()
336 })
337 .or_else(|| which::which("git").ok());
338 fs.open_repo(&dot_git_abs_path, system_git_binary_path.as_deref())
339 .with_context(|| format!("opening repository at {dot_git_abs_path:?}"))
340 }
341 })
342 .await?;
343 Ok(LocalRepositoryState {
344 backend,
345 environment: Arc::new(environment),
346 fs,
347 })
348 }
349}
350
351#[derive(Clone)]
352pub struct RemoteRepositoryState {
353 pub project_id: ProjectId,
354 pub client: AnyProtoClient,
355}
356
357#[derive(Clone)]
358pub enum RepositoryState {
359 Local(LocalRepositoryState),
360 Remote(RemoteRepositoryState),
361}
362
363#[derive(Clone, Debug, PartialEq, Eq)]
364pub enum RepositoryEvent {
365 StatusesChanged,
366 MergeHeadsChanged,
367 BranchChanged,
368 StashEntriesChanged,
369 PendingOpsChanged { pending_ops: SumTree<PendingOps> },
370}
371
372#[derive(Clone, Debug)]
373pub struct JobsUpdated;
374
375#[derive(Debug)]
376pub enum GitStoreEvent {
377 ActiveRepositoryChanged(Option<RepositoryId>),
378 RepositoryUpdated(RepositoryId, RepositoryEvent, bool),
379 RepositoryAdded,
380 RepositoryRemoved(RepositoryId),
381 IndexWriteError(anyhow::Error),
382 JobsUpdated,
383 ConflictsUpdated,
384}
385
386impl EventEmitter<RepositoryEvent> for Repository {}
387impl EventEmitter<JobsUpdated> for Repository {}
388impl EventEmitter<GitStoreEvent> for GitStore {}
389
390pub struct GitJob {
391 job: Box<dyn FnOnce(RepositoryState, &mut AsyncApp) -> Task<()>>,
392 key: Option<GitJobKey>,
393}
394
395#[derive(PartialEq, Eq)]
396enum GitJobKey {
397 WriteIndex(Vec<RepoPath>),
398 ReloadBufferDiffBases,
399 RefreshStatuses,
400 ReloadGitState,
401}
402
403impl GitStore {
404 pub fn local(
405 worktree_store: &Entity<WorktreeStore>,
406 buffer_store: Entity<BufferStore>,
407 environment: Entity<ProjectEnvironment>,
408 fs: Arc<dyn Fs>,
409 cx: &mut Context<Self>,
410 ) -> Self {
411 Self::new(
412 worktree_store.clone(),
413 buffer_store,
414 GitStoreState::Local {
415 next_repository_id: Arc::new(AtomicU64::new(1)),
416 downstream: None,
417 project_environment: environment,
418 fs,
419 },
420 cx,
421 )
422 }
423
424 pub fn remote(
425 worktree_store: &Entity<WorktreeStore>,
426 buffer_store: Entity<BufferStore>,
427 upstream_client: AnyProtoClient,
428 project_id: u64,
429 cx: &mut Context<Self>,
430 ) -> Self {
431 Self::new(
432 worktree_store.clone(),
433 buffer_store,
434 GitStoreState::Remote {
435 upstream_client,
436 upstream_project_id: project_id,
437 downstream: None,
438 },
439 cx,
440 )
441 }
442
443 fn new(
444 worktree_store: Entity<WorktreeStore>,
445 buffer_store: Entity<BufferStore>,
446 state: GitStoreState,
447 cx: &mut Context<Self>,
448 ) -> Self {
449 let _subscriptions = vec![
450 cx.subscribe(&worktree_store, Self::on_worktree_store_event),
451 cx.subscribe(&buffer_store, Self::on_buffer_store_event),
452 ];
453
454 GitStore {
455 state,
456 buffer_store,
457 worktree_store,
458 repositories: HashMap::default(),
459 worktree_ids: HashMap::default(),
460 active_repo_id: None,
461 _subscriptions,
462 loading_diffs: HashMap::default(),
463 shared_diffs: HashMap::default(),
464 diffs: HashMap::default(),
465 }
466 }
467
468 pub fn init(client: &AnyProtoClient) {
469 client.add_entity_request_handler(Self::handle_get_remotes);
470 client.add_entity_request_handler(Self::handle_get_branches);
471 client.add_entity_request_handler(Self::handle_get_default_branch);
472 client.add_entity_request_handler(Self::handle_change_branch);
473 client.add_entity_request_handler(Self::handle_create_branch);
474 client.add_entity_request_handler(Self::handle_rename_branch);
475 client.add_entity_request_handler(Self::handle_create_remote);
476 client.add_entity_request_handler(Self::handle_remove_remote);
477 client.add_entity_request_handler(Self::handle_delete_branch);
478 client.add_entity_request_handler(Self::handle_git_init);
479 client.add_entity_request_handler(Self::handle_push);
480 client.add_entity_request_handler(Self::handle_pull);
481 client.add_entity_request_handler(Self::handle_fetch);
482 client.add_entity_request_handler(Self::handle_stage);
483 client.add_entity_request_handler(Self::handle_unstage);
484 client.add_entity_request_handler(Self::handle_stash);
485 client.add_entity_request_handler(Self::handle_stash_pop);
486 client.add_entity_request_handler(Self::handle_stash_apply);
487 client.add_entity_request_handler(Self::handle_stash_drop);
488 client.add_entity_request_handler(Self::handle_commit);
489 client.add_entity_request_handler(Self::handle_run_hook);
490 client.add_entity_request_handler(Self::handle_reset);
491 client.add_entity_request_handler(Self::handle_show);
492 client.add_entity_request_handler(Self::handle_load_commit_diff);
493 client.add_entity_request_handler(Self::handle_file_history);
494 client.add_entity_request_handler(Self::handle_checkout_files);
495 client.add_entity_request_handler(Self::handle_open_commit_message_buffer);
496 client.add_entity_request_handler(Self::handle_set_index_text);
497 client.add_entity_request_handler(Self::handle_askpass);
498 client.add_entity_request_handler(Self::handle_check_for_pushed_commits);
499 client.add_entity_request_handler(Self::handle_git_diff);
500 client.add_entity_request_handler(Self::handle_tree_diff);
501 client.add_entity_request_handler(Self::handle_get_blob_content);
502 client.add_entity_request_handler(Self::handle_open_unstaged_diff);
503 client.add_entity_request_handler(Self::handle_open_uncommitted_diff);
504 client.add_entity_message_handler(Self::handle_update_diff_bases);
505 client.add_entity_request_handler(Self::handle_get_permalink_to_line);
506 client.add_entity_request_handler(Self::handle_blame_buffer);
507 client.add_entity_message_handler(Self::handle_update_repository);
508 client.add_entity_message_handler(Self::handle_remove_repository);
509 client.add_entity_request_handler(Self::handle_git_clone);
510 client.add_entity_request_handler(Self::handle_get_worktrees);
511 client.add_entity_request_handler(Self::handle_create_worktree);
512 }
513
514 pub fn is_local(&self) -> bool {
515 matches!(self.state, GitStoreState::Local { .. })
516 }
517 pub fn set_active_repo_for_path(&mut self, project_path: &ProjectPath, cx: &mut Context<Self>) {
518 if let Some((repo, _)) = self.repository_and_path_for_project_path(project_path, cx) {
519 let id = repo.read(cx).id;
520 if self.active_repo_id != Some(id) {
521 self.active_repo_id = Some(id);
522 cx.emit(GitStoreEvent::ActiveRepositoryChanged(Some(id)));
523 }
524 }
525 }
526
527 pub fn shared(&mut self, project_id: u64, client: AnyProtoClient, cx: &mut Context<Self>) {
528 match &mut self.state {
529 GitStoreState::Remote {
530 downstream: downstream_client,
531 ..
532 } => {
533 for repo in self.repositories.values() {
534 let update = repo.read(cx).snapshot.initial_update(project_id);
535 for update in split_repository_update(update) {
536 client.send(update).log_err();
537 }
538 }
539 *downstream_client = Some((client, ProjectId(project_id)));
540 }
541 GitStoreState::Local {
542 downstream: downstream_client,
543 ..
544 } => {
545 let mut snapshots = HashMap::default();
546 let (updates_tx, mut updates_rx) = mpsc::unbounded();
547 for repo in self.repositories.values() {
548 updates_tx
549 .unbounded_send(DownstreamUpdate::UpdateRepository(
550 repo.read(cx).snapshot.clone(),
551 ))
552 .ok();
553 }
554 *downstream_client = Some(LocalDownstreamState {
555 client: client.clone(),
556 project_id: ProjectId(project_id),
557 updates_tx,
558 _task: cx.spawn(async move |this, cx| {
559 cx.background_spawn(async move {
560 while let Some(update) = updates_rx.next().await {
561 match update {
562 DownstreamUpdate::UpdateRepository(snapshot) => {
563 if let Some(old_snapshot) = snapshots.get_mut(&snapshot.id)
564 {
565 let update =
566 snapshot.build_update(old_snapshot, project_id);
567 *old_snapshot = snapshot;
568 for update in split_repository_update(update) {
569 client.send(update)?;
570 }
571 } else {
572 let update = snapshot.initial_update(project_id);
573 for update in split_repository_update(update) {
574 client.send(update)?;
575 }
576 snapshots.insert(snapshot.id, snapshot);
577 }
578 }
579 DownstreamUpdate::RemoveRepository(id) => {
580 client.send(proto::RemoveRepository {
581 project_id,
582 id: id.to_proto(),
583 })?;
584 }
585 }
586 }
587 anyhow::Ok(())
588 })
589 .await
590 .ok();
591 this.update(cx, |this, _| {
592 if let GitStoreState::Local {
593 downstream: downstream_client,
594 ..
595 } = &mut this.state
596 {
597 downstream_client.take();
598 } else {
599 unreachable!("unshared called on remote store");
600 }
601 })
602 }),
603 });
604 }
605 }
606 }
607
608 pub fn unshared(&mut self, _cx: &mut Context<Self>) {
609 match &mut self.state {
610 GitStoreState::Local {
611 downstream: downstream_client,
612 ..
613 } => {
614 downstream_client.take();
615 }
616 GitStoreState::Remote {
617 downstream: downstream_client,
618 ..
619 } => {
620 downstream_client.take();
621 }
622 }
623 self.shared_diffs.clear();
624 }
625
626 pub(crate) fn forget_shared_diffs_for(&mut self, peer_id: &proto::PeerId) {
627 self.shared_diffs.remove(peer_id);
628 }
629
630 pub fn active_repository(&self) -> Option<Entity<Repository>> {
631 self.active_repo_id
632 .as_ref()
633 .map(|id| self.repositories[id].clone())
634 }
635
636 pub fn open_unstaged_diff(
637 &mut self,
638 buffer: Entity<Buffer>,
639 cx: &mut Context<Self>,
640 ) -> Task<Result<Entity<BufferDiff>>> {
641 let buffer_id = buffer.read(cx).remote_id();
642 if let Some(diff_state) = self.diffs.get(&buffer_id)
643 && let Some(unstaged_diff) = diff_state
644 .read(cx)
645 .unstaged_diff
646 .as_ref()
647 .and_then(|weak| weak.upgrade())
648 {
649 if let Some(task) =
650 diff_state.update(cx, |diff_state, _| diff_state.wait_for_recalculation())
651 {
652 return cx.background_executor().spawn(async move {
653 task.await;
654 Ok(unstaged_diff)
655 });
656 }
657 return Task::ready(Ok(unstaged_diff));
658 }
659
660 let Some((repo, repo_path)) =
661 self.repository_and_path_for_buffer_id(buffer.read(cx).remote_id(), cx)
662 else {
663 return Task::ready(Err(anyhow!("failed to find git repository for buffer")));
664 };
665
666 let task = self
667 .loading_diffs
668 .entry((buffer_id, DiffKind::Unstaged))
669 .or_insert_with(|| {
670 let staged_text = repo.update(cx, |repo, cx| {
671 repo.load_staged_text(buffer_id, repo_path, cx)
672 });
673 cx.spawn(async move |this, cx| {
674 Self::open_diff_internal(
675 this,
676 DiffKind::Unstaged,
677 staged_text.await.map(DiffBasesChange::SetIndex),
678 buffer,
679 cx,
680 )
681 .await
682 .map_err(Arc::new)
683 })
684 .shared()
685 })
686 .clone();
687
688 cx.background_spawn(async move { task.await.map_err(|e| anyhow!("{e}")) })
689 }
690
691 pub fn open_diff_since(
692 &mut self,
693 oid: Option<git::Oid>,
694 buffer: Entity<Buffer>,
695 repo: Entity<Repository>,
696 languages: Arc<LanguageRegistry>,
697 cx: &mut Context<Self>,
698 ) -> Task<Result<Entity<BufferDiff>>> {
699 cx.spawn(async move |this, cx| {
700 let buffer_snapshot = buffer.update(cx, |buffer, _| buffer.snapshot())?;
701 let content = match oid {
702 None => None,
703 Some(oid) => Some(
704 repo.update(cx, |repo, cx| repo.load_blob_content(oid, cx))?
705 .await?,
706 ),
707 };
708 let buffer_diff = cx.new(|cx| BufferDiff::new(&buffer_snapshot, cx))?;
709
710 buffer_diff
711 .update(cx, |buffer_diff, cx| {
712 buffer_diff.set_base_text(
713 content.map(Arc::new),
714 buffer_snapshot.language().cloned(),
715 Some(languages.clone()),
716 buffer_snapshot.text,
717 cx,
718 )
719 })?
720 .await?;
721 let unstaged_diff = this
722 .update(cx, |this, cx| this.open_unstaged_diff(buffer.clone(), cx))?
723 .await?;
724 buffer_diff.update(cx, |buffer_diff, _| {
725 buffer_diff.set_secondary_diff(unstaged_diff);
726 })?;
727
728 this.update(cx, |_, cx| {
729 cx.subscribe(&buffer_diff, Self::on_buffer_diff_event)
730 .detach();
731 })?;
732
733 Ok(buffer_diff)
734 })
735 }
736
737 pub fn open_uncommitted_diff(
738 &mut self,
739 buffer: Entity<Buffer>,
740 cx: &mut Context<Self>,
741 ) -> Task<Result<Entity<BufferDiff>>> {
742 let buffer_id = buffer.read(cx).remote_id();
743
744 if let Some(diff_state) = self.diffs.get(&buffer_id)
745 && let Some(uncommitted_diff) = diff_state
746 .read(cx)
747 .uncommitted_diff
748 .as_ref()
749 .and_then(|weak| weak.upgrade())
750 {
751 if let Some(task) =
752 diff_state.update(cx, |diff_state, _| diff_state.wait_for_recalculation())
753 {
754 return cx.background_executor().spawn(async move {
755 task.await;
756 Ok(uncommitted_diff)
757 });
758 }
759 return Task::ready(Ok(uncommitted_diff));
760 }
761
762 let Some((repo, repo_path)) =
763 self.repository_and_path_for_buffer_id(buffer.read(cx).remote_id(), cx)
764 else {
765 return Task::ready(Err(anyhow!("failed to find git repository for buffer")));
766 };
767
768 let task = self
769 .loading_diffs
770 .entry((buffer_id, DiffKind::Uncommitted))
771 .or_insert_with(|| {
772 let changes = repo.update(cx, |repo, cx| {
773 repo.load_committed_text(buffer_id, repo_path, cx)
774 });
775
776 // todo(lw): hot foreground spawn
777 cx.spawn(async move |this, cx| {
778 Self::open_diff_internal(this, DiffKind::Uncommitted, changes.await, buffer, cx)
779 .await
780 .map_err(Arc::new)
781 })
782 .shared()
783 })
784 .clone();
785
786 cx.background_spawn(async move { task.await.map_err(|e| anyhow!("{e}")) })
787 }
788
789 async fn open_diff_internal(
790 this: WeakEntity<Self>,
791 kind: DiffKind,
792 texts: Result<DiffBasesChange>,
793 buffer_entity: Entity<Buffer>,
794 cx: &mut AsyncApp,
795 ) -> Result<Entity<BufferDiff>> {
796 let diff_bases_change = match texts {
797 Err(e) => {
798 this.update(cx, |this, cx| {
799 let buffer = buffer_entity.read(cx);
800 let buffer_id = buffer.remote_id();
801 this.loading_diffs.remove(&(buffer_id, kind));
802 })?;
803 return Err(e);
804 }
805 Ok(change) => change,
806 };
807
808 this.update(cx, |this, cx| {
809 let buffer = buffer_entity.read(cx);
810 let buffer_id = buffer.remote_id();
811 let language = buffer.language().cloned();
812 let language_registry = buffer.language_registry();
813 let text_snapshot = buffer.text_snapshot();
814 this.loading_diffs.remove(&(buffer_id, kind));
815
816 let git_store = cx.weak_entity();
817 let diff_state = this
818 .diffs
819 .entry(buffer_id)
820 .or_insert_with(|| cx.new(|_| BufferGitState::new(git_store)));
821
822 let diff = cx.new(|cx| BufferDiff::new(&text_snapshot, cx));
823
824 cx.subscribe(&diff, Self::on_buffer_diff_event).detach();
825 diff_state.update(cx, |diff_state, cx| {
826 diff_state.language = language;
827 diff_state.language_registry = language_registry;
828
829 match kind {
830 DiffKind::Unstaged => diff_state.unstaged_diff = Some(diff.downgrade()),
831 DiffKind::Uncommitted => {
832 let unstaged_diff = if let Some(diff) = diff_state.unstaged_diff() {
833 diff
834 } else {
835 let unstaged_diff = cx.new(|cx| BufferDiff::new(&text_snapshot, cx));
836 diff_state.unstaged_diff = Some(unstaged_diff.downgrade());
837 unstaged_diff
838 };
839
840 diff.update(cx, |diff, _| diff.set_secondary_diff(unstaged_diff));
841 diff_state.uncommitted_diff = Some(diff.downgrade())
842 }
843 }
844
845 diff_state.diff_bases_changed(text_snapshot, Some(diff_bases_change), cx);
846 let rx = diff_state.wait_for_recalculation();
847
848 anyhow::Ok(async move {
849 if let Some(rx) = rx {
850 rx.await;
851 }
852 Ok(diff)
853 })
854 })
855 })??
856 .await
857 }
858
859 pub fn get_unstaged_diff(&self, buffer_id: BufferId, cx: &App) -> Option<Entity<BufferDiff>> {
860 let diff_state = self.diffs.get(&buffer_id)?;
861 diff_state.read(cx).unstaged_diff.as_ref()?.upgrade()
862 }
863
864 pub fn get_uncommitted_diff(
865 &self,
866 buffer_id: BufferId,
867 cx: &App,
868 ) -> Option<Entity<BufferDiff>> {
869 let diff_state = self.diffs.get(&buffer_id)?;
870 diff_state.read(cx).uncommitted_diff.as_ref()?.upgrade()
871 }
872
873 pub fn open_conflict_set(
874 &mut self,
875 buffer: Entity<Buffer>,
876 cx: &mut Context<Self>,
877 ) -> Entity<ConflictSet> {
878 log::debug!("open conflict set");
879 let buffer_id = buffer.read(cx).remote_id();
880
881 if let Some(git_state) = self.diffs.get(&buffer_id)
882 && let Some(conflict_set) = git_state
883 .read(cx)
884 .conflict_set
885 .as_ref()
886 .and_then(|weak| weak.upgrade())
887 {
888 let conflict_set = conflict_set;
889 let buffer_snapshot = buffer.read(cx).text_snapshot();
890
891 git_state.update(cx, |state, cx| {
892 let _ = state.reparse_conflict_markers(buffer_snapshot, cx);
893 });
894
895 return conflict_set;
896 }
897
898 let is_unmerged = self
899 .repository_and_path_for_buffer_id(buffer_id, cx)
900 .is_some_and(|(repo, path)| repo.read(cx).snapshot.has_conflict(&path));
901 let git_store = cx.weak_entity();
902 let buffer_git_state = self
903 .diffs
904 .entry(buffer_id)
905 .or_insert_with(|| cx.new(|_| BufferGitState::new(git_store)));
906 let conflict_set = cx.new(|cx| ConflictSet::new(buffer_id, is_unmerged, cx));
907
908 self._subscriptions
909 .push(cx.subscribe(&conflict_set, |_, _, _, cx| {
910 cx.emit(GitStoreEvent::ConflictsUpdated);
911 }));
912
913 buffer_git_state.update(cx, |state, cx| {
914 state.conflict_set = Some(conflict_set.downgrade());
915 let buffer_snapshot = buffer.read(cx).text_snapshot();
916 let _ = state.reparse_conflict_markers(buffer_snapshot, cx);
917 });
918
919 conflict_set
920 }
921
922 pub fn project_path_git_status(
923 &self,
924 project_path: &ProjectPath,
925 cx: &App,
926 ) -> Option<FileStatus> {
927 let (repo, repo_path) = self.repository_and_path_for_project_path(project_path, cx)?;
928 Some(repo.read(cx).status_for_path(&repo_path)?.status)
929 }
930
931 pub fn checkpoint(&self, cx: &mut App) -> Task<Result<GitStoreCheckpoint>> {
932 let mut work_directory_abs_paths = Vec::new();
933 let mut checkpoints = Vec::new();
934 for repository in self.repositories.values() {
935 repository.update(cx, |repository, _| {
936 work_directory_abs_paths.push(repository.snapshot.work_directory_abs_path.clone());
937 checkpoints.push(repository.checkpoint().map(|checkpoint| checkpoint?));
938 });
939 }
940
941 cx.background_executor().spawn(async move {
942 let checkpoints = future::try_join_all(checkpoints).await?;
943 Ok(GitStoreCheckpoint {
944 checkpoints_by_work_dir_abs_path: work_directory_abs_paths
945 .into_iter()
946 .zip(checkpoints)
947 .collect(),
948 })
949 })
950 }
951
952 pub fn restore_checkpoint(
953 &self,
954 checkpoint: GitStoreCheckpoint,
955 cx: &mut App,
956 ) -> Task<Result<()>> {
957 let repositories_by_work_dir_abs_path = self
958 .repositories
959 .values()
960 .map(|repo| (repo.read(cx).snapshot.work_directory_abs_path.clone(), repo))
961 .collect::<HashMap<_, _>>();
962
963 let mut tasks = Vec::new();
964 for (work_dir_abs_path, checkpoint) in checkpoint.checkpoints_by_work_dir_abs_path {
965 if let Some(repository) = repositories_by_work_dir_abs_path.get(&work_dir_abs_path) {
966 let restore = repository.update(cx, |repository, _| {
967 repository.restore_checkpoint(checkpoint)
968 });
969 tasks.push(async move { restore.await? });
970 }
971 }
972 cx.background_spawn(async move {
973 future::try_join_all(tasks).await?;
974 Ok(())
975 })
976 }
977
978 /// Compares two checkpoints, returning true if they are equal.
979 pub fn compare_checkpoints(
980 &self,
981 left: GitStoreCheckpoint,
982 mut right: GitStoreCheckpoint,
983 cx: &mut App,
984 ) -> Task<Result<bool>> {
985 let repositories_by_work_dir_abs_path = self
986 .repositories
987 .values()
988 .map(|repo| (repo.read(cx).snapshot.work_directory_abs_path.clone(), repo))
989 .collect::<HashMap<_, _>>();
990
991 let mut tasks = Vec::new();
992 for (work_dir_abs_path, left_checkpoint) in left.checkpoints_by_work_dir_abs_path {
993 if let Some(right_checkpoint) = right
994 .checkpoints_by_work_dir_abs_path
995 .remove(&work_dir_abs_path)
996 {
997 if let Some(repository) = repositories_by_work_dir_abs_path.get(&work_dir_abs_path)
998 {
999 let compare = repository.update(cx, |repository, _| {
1000 repository.compare_checkpoints(left_checkpoint, right_checkpoint)
1001 });
1002
1003 tasks.push(async move { compare.await? });
1004 }
1005 } else {
1006 return Task::ready(Ok(false));
1007 }
1008 }
1009 cx.background_spawn(async move {
1010 Ok(future::try_join_all(tasks)
1011 .await?
1012 .into_iter()
1013 .all(|result| result))
1014 })
1015 }
1016
1017 /// Blames a buffer.
1018 pub fn blame_buffer(
1019 &self,
1020 buffer: &Entity<Buffer>,
1021 version: Option<clock::Global>,
1022 cx: &mut Context<Self>,
1023 ) -> Task<Result<Option<Blame>>> {
1024 let buffer = buffer.read(cx);
1025 let Some((repo, repo_path)) =
1026 self.repository_and_path_for_buffer_id(buffer.remote_id(), cx)
1027 else {
1028 return Task::ready(Err(anyhow!("failed to find a git repository for buffer")));
1029 };
1030 let content = match &version {
1031 Some(version) => buffer.rope_for_version(version),
1032 None => buffer.as_rope().clone(),
1033 };
1034 let version = version.unwrap_or(buffer.version());
1035 let buffer_id = buffer.remote_id();
1036
1037 let repo = repo.downgrade();
1038 cx.spawn(async move |_, cx| {
1039 let repository_state = repo
1040 .update(cx, |repo, _| repo.repository_state.clone())?
1041 .await
1042 .map_err(|err| anyhow::anyhow!(err))?;
1043 match repository_state {
1044 RepositoryState::Local(LocalRepositoryState { backend, .. }) => backend
1045 .blame(repo_path.clone(), content)
1046 .await
1047 .with_context(|| format!("Failed to blame {:?}", repo_path.as_ref()))
1048 .map(Some),
1049 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
1050 let response = client
1051 .request(proto::BlameBuffer {
1052 project_id: project_id.to_proto(),
1053 buffer_id: buffer_id.into(),
1054 version: serialize_version(&version),
1055 })
1056 .await?;
1057 Ok(deserialize_blame_buffer_response(response))
1058 }
1059 }
1060 })
1061 }
1062
1063 pub fn file_history(
1064 &self,
1065 repo: &Entity<Repository>,
1066 path: RepoPath,
1067 cx: &mut App,
1068 ) -> Task<Result<git::repository::FileHistory>> {
1069 let rx = repo.update(cx, |repo, _| repo.file_history(path));
1070
1071 cx.spawn(|_: &mut AsyncApp| async move { rx.await? })
1072 }
1073
1074 pub fn file_history_paginated(
1075 &self,
1076 repo: &Entity<Repository>,
1077 path: RepoPath,
1078 skip: usize,
1079 limit: Option<usize>,
1080 cx: &mut App,
1081 ) -> Task<Result<git::repository::FileHistory>> {
1082 let rx = repo.update(cx, |repo, _| repo.file_history_paginated(path, skip, limit));
1083
1084 cx.spawn(|_: &mut AsyncApp| async move { rx.await? })
1085 }
1086
1087 pub fn get_permalink_to_line(
1088 &self,
1089 buffer: &Entity<Buffer>,
1090 selection: Range<u32>,
1091 cx: &mut App,
1092 ) -> Task<Result<url::Url>> {
1093 let Some(file) = File::from_dyn(buffer.read(cx).file()) else {
1094 return Task::ready(Err(anyhow!("buffer has no file")));
1095 };
1096
1097 let Some((repo, repo_path)) = self.repository_and_path_for_project_path(
1098 &(file.worktree.read(cx).id(), file.path.clone()).into(),
1099 cx,
1100 ) else {
1101 // If we're not in a Git repo, check whether this is a Rust source
1102 // file in the Cargo registry (presumably opened with go-to-definition
1103 // from a normal Rust file). If so, we can put together a permalink
1104 // using crate metadata.
1105 if buffer
1106 .read(cx)
1107 .language()
1108 .is_none_or(|lang| lang.name() != "Rust".into())
1109 {
1110 return Task::ready(Err(anyhow!("no permalink available")));
1111 }
1112 let file_path = file.worktree.read(cx).absolutize(&file.path);
1113 return cx.spawn(async move |cx| {
1114 let provider_registry = cx.update(GitHostingProviderRegistry::default_global)?;
1115 get_permalink_in_rust_registry_src(provider_registry, file_path, selection)
1116 .context("no permalink available")
1117 });
1118 };
1119
1120 let buffer_id = buffer.read(cx).remote_id();
1121 let branch = repo.read(cx).branch.clone();
1122 let remote = branch
1123 .as_ref()
1124 .and_then(|b| b.upstream.as_ref())
1125 .and_then(|b| b.remote_name())
1126 .unwrap_or("origin")
1127 .to_string();
1128
1129 let rx = repo.update(cx, |repo, _| {
1130 repo.send_job(None, move |state, cx| async move {
1131 match state {
1132 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
1133 let origin_url = backend
1134 .remote_url(&remote)
1135 .await
1136 .with_context(|| format!("remote \"{remote}\" not found"))?;
1137
1138 let sha = backend.head_sha().await.context("reading HEAD SHA")?;
1139
1140 let provider_registry =
1141 cx.update(GitHostingProviderRegistry::default_global)?;
1142
1143 let (provider, remote) =
1144 parse_git_remote_url(provider_registry, &origin_url)
1145 .context("parsing Git remote URL")?;
1146
1147 Ok(provider.build_permalink(
1148 remote,
1149 BuildPermalinkParams::new(&sha, &repo_path, Some(selection)),
1150 ))
1151 }
1152 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
1153 let response = client
1154 .request(proto::GetPermalinkToLine {
1155 project_id: project_id.to_proto(),
1156 buffer_id: buffer_id.into(),
1157 selection: Some(proto::Range {
1158 start: selection.start as u64,
1159 end: selection.end as u64,
1160 }),
1161 })
1162 .await?;
1163
1164 url::Url::parse(&response.permalink).context("failed to parse permalink")
1165 }
1166 }
1167 })
1168 });
1169 cx.spawn(|_: &mut AsyncApp| async move { rx.await? })
1170 }
1171
1172 fn downstream_client(&self) -> Option<(AnyProtoClient, ProjectId)> {
1173 match &self.state {
1174 GitStoreState::Local {
1175 downstream: downstream_client,
1176 ..
1177 } => downstream_client
1178 .as_ref()
1179 .map(|state| (state.client.clone(), state.project_id)),
1180 GitStoreState::Remote {
1181 downstream: downstream_client,
1182 ..
1183 } => downstream_client.clone(),
1184 }
1185 }
1186
1187 fn upstream_client(&self) -> Option<AnyProtoClient> {
1188 match &self.state {
1189 GitStoreState::Local { .. } => None,
1190 GitStoreState::Remote {
1191 upstream_client, ..
1192 } => Some(upstream_client.clone()),
1193 }
1194 }
1195
1196 fn on_worktree_store_event(
1197 &mut self,
1198 worktree_store: Entity<WorktreeStore>,
1199 event: &WorktreeStoreEvent,
1200 cx: &mut Context<Self>,
1201 ) {
1202 let GitStoreState::Local {
1203 project_environment,
1204 downstream,
1205 next_repository_id,
1206 fs,
1207 } = &self.state
1208 else {
1209 return;
1210 };
1211
1212 match event {
1213 WorktreeStoreEvent::WorktreeUpdatedEntries(worktree_id, updated_entries) => {
1214 if let Some(worktree) = self
1215 .worktree_store
1216 .read(cx)
1217 .worktree_for_id(*worktree_id, cx)
1218 {
1219 let paths_by_git_repo =
1220 self.process_updated_entries(&worktree, updated_entries, cx);
1221 let downstream = downstream
1222 .as_ref()
1223 .map(|downstream| downstream.updates_tx.clone());
1224 cx.spawn(async move |_, cx| {
1225 let paths_by_git_repo = paths_by_git_repo.await;
1226 for (repo, paths) in paths_by_git_repo {
1227 repo.update(cx, |repo, cx| {
1228 repo.paths_changed(paths, downstream.clone(), cx);
1229 })
1230 .ok();
1231 }
1232 })
1233 .detach();
1234 }
1235 }
1236 WorktreeStoreEvent::WorktreeUpdatedGitRepositories(worktree_id, changed_repos) => {
1237 let Some(worktree) = worktree_store.read(cx).worktree_for_id(*worktree_id, cx)
1238 else {
1239 return;
1240 };
1241 if !worktree.read(cx).is_visible() {
1242 log::debug!(
1243 "not adding repositories for local worktree {:?} because it's not visible",
1244 worktree.read(cx).abs_path()
1245 );
1246 return;
1247 }
1248 self.update_repositories_from_worktree(
1249 *worktree_id,
1250 project_environment.clone(),
1251 next_repository_id.clone(),
1252 downstream
1253 .as_ref()
1254 .map(|downstream| downstream.updates_tx.clone()),
1255 changed_repos.clone(),
1256 fs.clone(),
1257 cx,
1258 );
1259 self.local_worktree_git_repos_changed(worktree, changed_repos, cx);
1260 }
1261 WorktreeStoreEvent::WorktreeRemoved(_entity_id, worktree_id) => {
1262 let repos_without_worktree: Vec<RepositoryId> = self
1263 .worktree_ids
1264 .iter_mut()
1265 .filter_map(|(repo_id, worktree_ids)| {
1266 worktree_ids.remove(worktree_id);
1267 if worktree_ids.is_empty() {
1268 Some(*repo_id)
1269 } else {
1270 None
1271 }
1272 })
1273 .collect();
1274 let is_active_repo_removed = repos_without_worktree
1275 .iter()
1276 .any(|repo_id| self.active_repo_id == Some(*repo_id));
1277
1278 for repo_id in repos_without_worktree {
1279 self.repositories.remove(&repo_id);
1280 self.worktree_ids.remove(&repo_id);
1281 if let Some(updates_tx) =
1282 downstream.as_ref().map(|downstream| &downstream.updates_tx)
1283 {
1284 updates_tx
1285 .unbounded_send(DownstreamUpdate::RemoveRepository(repo_id))
1286 .ok();
1287 }
1288 }
1289
1290 if is_active_repo_removed {
1291 if let Some((&repo_id, _)) = self.repositories.iter().next() {
1292 self.active_repo_id = Some(repo_id);
1293 cx.emit(GitStoreEvent::ActiveRepositoryChanged(Some(repo_id)));
1294 } else {
1295 self.active_repo_id = None;
1296 cx.emit(GitStoreEvent::ActiveRepositoryChanged(None));
1297 }
1298 }
1299 }
1300 _ => {}
1301 }
1302 }
1303 fn on_repository_event(
1304 &mut self,
1305 repo: Entity<Repository>,
1306 event: &RepositoryEvent,
1307 cx: &mut Context<Self>,
1308 ) {
1309 let id = repo.read(cx).id;
1310 let repo_snapshot = repo.read(cx).snapshot.clone();
1311 for (buffer_id, diff) in self.diffs.iter() {
1312 if let Some((buffer_repo, repo_path)) =
1313 self.repository_and_path_for_buffer_id(*buffer_id, cx)
1314 && buffer_repo == repo
1315 {
1316 diff.update(cx, |diff, cx| {
1317 if let Some(conflict_set) = &diff.conflict_set {
1318 let conflict_status_changed =
1319 conflict_set.update(cx, |conflict_set, cx| {
1320 let has_conflict = repo_snapshot.has_conflict(&repo_path);
1321 conflict_set.set_has_conflict(has_conflict, cx)
1322 })?;
1323 if conflict_status_changed {
1324 let buffer_store = self.buffer_store.read(cx);
1325 if let Some(buffer) = buffer_store.get(*buffer_id) {
1326 let _ = diff
1327 .reparse_conflict_markers(buffer.read(cx).text_snapshot(), cx);
1328 }
1329 }
1330 }
1331 anyhow::Ok(())
1332 })
1333 .ok();
1334 }
1335 }
1336 cx.emit(GitStoreEvent::RepositoryUpdated(
1337 id,
1338 event.clone(),
1339 self.active_repo_id == Some(id),
1340 ))
1341 }
1342
1343 fn on_jobs_updated(&mut self, _: Entity<Repository>, _: &JobsUpdated, cx: &mut Context<Self>) {
1344 cx.emit(GitStoreEvent::JobsUpdated)
1345 }
1346
1347 /// Update our list of repositories and schedule git scans in response to a notification from a worktree,
1348 fn update_repositories_from_worktree(
1349 &mut self,
1350 worktree_id: WorktreeId,
1351 project_environment: Entity<ProjectEnvironment>,
1352 next_repository_id: Arc<AtomicU64>,
1353 updates_tx: Option<mpsc::UnboundedSender<DownstreamUpdate>>,
1354 updated_git_repositories: UpdatedGitRepositoriesSet,
1355 fs: Arc<dyn Fs>,
1356 cx: &mut Context<Self>,
1357 ) {
1358 let mut removed_ids = Vec::new();
1359 for update in updated_git_repositories.iter() {
1360 if let Some((id, existing)) = self.repositories.iter().find(|(_, repo)| {
1361 let existing_work_directory_abs_path =
1362 repo.read(cx).work_directory_abs_path.clone();
1363 Some(&existing_work_directory_abs_path)
1364 == update.old_work_directory_abs_path.as_ref()
1365 || Some(&existing_work_directory_abs_path)
1366 == update.new_work_directory_abs_path.as_ref()
1367 }) {
1368 let repo_id = *id;
1369 if let Some(new_work_directory_abs_path) =
1370 update.new_work_directory_abs_path.clone()
1371 {
1372 self.worktree_ids
1373 .entry(repo_id)
1374 .or_insert_with(HashSet::new)
1375 .insert(worktree_id);
1376 existing.update(cx, |existing, cx| {
1377 existing.snapshot.work_directory_abs_path = new_work_directory_abs_path;
1378 existing.schedule_scan(updates_tx.clone(), cx);
1379 });
1380 } else {
1381 if let Some(worktree_ids) = self.worktree_ids.get_mut(&repo_id) {
1382 worktree_ids.remove(&worktree_id);
1383 if worktree_ids.is_empty() {
1384 removed_ids.push(repo_id);
1385 }
1386 }
1387 }
1388 } else if let UpdatedGitRepository {
1389 new_work_directory_abs_path: Some(work_directory_abs_path),
1390 dot_git_abs_path: Some(dot_git_abs_path),
1391 repository_dir_abs_path: Some(_repository_dir_abs_path),
1392 common_dir_abs_path: Some(_common_dir_abs_path),
1393 ..
1394 } = update
1395 {
1396 let id = RepositoryId(next_repository_id.fetch_add(1, atomic::Ordering::Release));
1397 let git_store = cx.weak_entity();
1398 let repo = cx.new(|cx| {
1399 let mut repo = Repository::local(
1400 id,
1401 work_directory_abs_path.clone(),
1402 dot_git_abs_path.clone(),
1403 project_environment.downgrade(),
1404 fs.clone(),
1405 git_store,
1406 cx,
1407 );
1408 if let Some(updates_tx) = updates_tx.as_ref() {
1409 // trigger an empty `UpdateRepository` to ensure remote active_repo_id is set correctly
1410 updates_tx
1411 .unbounded_send(DownstreamUpdate::UpdateRepository(repo.snapshot()))
1412 .ok();
1413 }
1414 repo.schedule_scan(updates_tx.clone(), cx);
1415 repo
1416 });
1417 self._subscriptions
1418 .push(cx.subscribe(&repo, Self::on_repository_event));
1419 self._subscriptions
1420 .push(cx.subscribe(&repo, Self::on_jobs_updated));
1421 self.repositories.insert(id, repo);
1422 self.worktree_ids.insert(id, HashSet::from([worktree_id]));
1423 cx.emit(GitStoreEvent::RepositoryAdded);
1424 self.active_repo_id.get_or_insert_with(|| {
1425 cx.emit(GitStoreEvent::ActiveRepositoryChanged(Some(id)));
1426 id
1427 });
1428 }
1429 }
1430
1431 for id in removed_ids {
1432 if self.active_repo_id == Some(id) {
1433 self.active_repo_id = None;
1434 cx.emit(GitStoreEvent::ActiveRepositoryChanged(None));
1435 }
1436 self.repositories.remove(&id);
1437 if let Some(updates_tx) = updates_tx.as_ref() {
1438 updates_tx
1439 .unbounded_send(DownstreamUpdate::RemoveRepository(id))
1440 .ok();
1441 }
1442 }
1443 }
1444
1445 fn on_buffer_store_event(
1446 &mut self,
1447 _: Entity<BufferStore>,
1448 event: &BufferStoreEvent,
1449 cx: &mut Context<Self>,
1450 ) {
1451 match event {
1452 BufferStoreEvent::BufferAdded(buffer) => {
1453 cx.subscribe(buffer, |this, buffer, event, cx| {
1454 if let BufferEvent::LanguageChanged = event {
1455 let buffer_id = buffer.read(cx).remote_id();
1456 if let Some(diff_state) = this.diffs.get(&buffer_id) {
1457 diff_state.update(cx, |diff_state, cx| {
1458 diff_state.buffer_language_changed(buffer, cx);
1459 });
1460 }
1461 }
1462 })
1463 .detach();
1464 }
1465 BufferStoreEvent::SharedBufferClosed(peer_id, buffer_id) => {
1466 if let Some(diffs) = self.shared_diffs.get_mut(peer_id) {
1467 diffs.remove(buffer_id);
1468 }
1469 }
1470 BufferStoreEvent::BufferDropped(buffer_id) => {
1471 self.diffs.remove(buffer_id);
1472 for diffs in self.shared_diffs.values_mut() {
1473 diffs.remove(buffer_id);
1474 }
1475 }
1476 BufferStoreEvent::BufferChangedFilePath { buffer, .. } => {
1477 // Whenever a buffer's file path changes, it's possible that the
1478 // new path is actually a path that is being tracked by a git
1479 // repository. In that case, we'll want to update the buffer's
1480 // `BufferDiffState`, in case it already has one.
1481 let buffer_id = buffer.read(cx).remote_id();
1482 let diff_state = self.diffs.get(&buffer_id);
1483 let repo = self.repository_and_path_for_buffer_id(buffer_id, cx);
1484
1485 if let Some(diff_state) = diff_state
1486 && let Some((repo, repo_path)) = repo
1487 {
1488 let buffer = buffer.clone();
1489 let diff_state = diff_state.clone();
1490
1491 cx.spawn(async move |_git_store, cx| {
1492 async {
1493 let diff_bases_change = repo
1494 .update(cx, |repo, cx| {
1495 repo.load_committed_text(buffer_id, repo_path, cx)
1496 })?
1497 .await?;
1498
1499 diff_state.update(cx, |diff_state, cx| {
1500 let buffer_snapshot = buffer.read(cx).text_snapshot();
1501 diff_state.diff_bases_changed(
1502 buffer_snapshot,
1503 Some(diff_bases_change),
1504 cx,
1505 );
1506 })
1507 }
1508 .await
1509 .log_err();
1510 })
1511 .detach();
1512 }
1513 }
1514 _ => {}
1515 }
1516 }
1517
1518 pub fn recalculate_buffer_diffs(
1519 &mut self,
1520 buffers: Vec<Entity<Buffer>>,
1521 cx: &mut Context<Self>,
1522 ) -> impl Future<Output = ()> + use<> {
1523 let mut futures = Vec::new();
1524 for buffer in buffers {
1525 if let Some(diff_state) = self.diffs.get_mut(&buffer.read(cx).remote_id()) {
1526 let buffer = buffer.read(cx).text_snapshot();
1527 diff_state.update(cx, |diff_state, cx| {
1528 diff_state.recalculate_diffs(buffer.clone(), cx);
1529 futures.extend(diff_state.wait_for_recalculation().map(FutureExt::boxed));
1530 });
1531 futures.push(diff_state.update(cx, |diff_state, cx| {
1532 diff_state
1533 .reparse_conflict_markers(buffer, cx)
1534 .map(|_| {})
1535 .boxed()
1536 }));
1537 }
1538 }
1539 async move {
1540 futures::future::join_all(futures).await;
1541 }
1542 }
1543
1544 fn on_buffer_diff_event(
1545 &mut self,
1546 diff: Entity<buffer_diff::BufferDiff>,
1547 event: &BufferDiffEvent,
1548 cx: &mut Context<Self>,
1549 ) {
1550 if let BufferDiffEvent::HunksStagedOrUnstaged(new_index_text) = event {
1551 let buffer_id = diff.read(cx).buffer_id;
1552 if let Some(diff_state) = self.diffs.get(&buffer_id) {
1553 let hunk_staging_operation_count = diff_state.update(cx, |diff_state, _| {
1554 diff_state.hunk_staging_operation_count += 1;
1555 diff_state.hunk_staging_operation_count
1556 });
1557 if let Some((repo, path)) = self.repository_and_path_for_buffer_id(buffer_id, cx) {
1558 let recv = repo.update(cx, |repo, cx| {
1559 log::debug!("hunks changed for {}", path.as_unix_str());
1560 repo.spawn_set_index_text_job(
1561 path,
1562 new_index_text.as_ref().map(|rope| rope.to_string()),
1563 Some(hunk_staging_operation_count),
1564 cx,
1565 )
1566 });
1567 let diff = diff.downgrade();
1568 cx.spawn(async move |this, cx| {
1569 if let Ok(Err(error)) = cx.background_spawn(recv).await {
1570 diff.update(cx, |diff, cx| {
1571 diff.clear_pending_hunks(cx);
1572 })
1573 .ok();
1574 this.update(cx, |_, cx| cx.emit(GitStoreEvent::IndexWriteError(error)))
1575 .ok();
1576 }
1577 })
1578 .detach();
1579 }
1580 }
1581 }
1582 }
1583
1584 fn local_worktree_git_repos_changed(
1585 &mut self,
1586 worktree: Entity<Worktree>,
1587 changed_repos: &UpdatedGitRepositoriesSet,
1588 cx: &mut Context<Self>,
1589 ) {
1590 log::debug!("local worktree repos changed");
1591 debug_assert!(worktree.read(cx).is_local());
1592
1593 for repository in self.repositories.values() {
1594 repository.update(cx, |repository, cx| {
1595 let repo_abs_path = &repository.work_directory_abs_path;
1596 if changed_repos.iter().any(|update| {
1597 update.old_work_directory_abs_path.as_ref() == Some(repo_abs_path)
1598 || update.new_work_directory_abs_path.as_ref() == Some(repo_abs_path)
1599 }) {
1600 repository.reload_buffer_diff_bases(cx);
1601 }
1602 });
1603 }
1604 }
1605
1606 pub fn repositories(&self) -> &HashMap<RepositoryId, Entity<Repository>> {
1607 &self.repositories
1608 }
1609
1610 pub fn status_for_buffer_id(&self, buffer_id: BufferId, cx: &App) -> Option<FileStatus> {
1611 let (repo, path) = self.repository_and_path_for_buffer_id(buffer_id, cx)?;
1612 let status = repo.read(cx).snapshot.status_for_path(&path)?;
1613 Some(status.status)
1614 }
1615
1616 pub fn repository_and_path_for_buffer_id(
1617 &self,
1618 buffer_id: BufferId,
1619 cx: &App,
1620 ) -> Option<(Entity<Repository>, RepoPath)> {
1621 let buffer = self.buffer_store.read(cx).get(buffer_id)?;
1622 let project_path = buffer.read(cx).project_path(cx)?;
1623 self.repository_and_path_for_project_path(&project_path, cx)
1624 }
1625
1626 pub fn repository_and_path_for_project_path(
1627 &self,
1628 path: &ProjectPath,
1629 cx: &App,
1630 ) -> Option<(Entity<Repository>, RepoPath)> {
1631 let abs_path = self.worktree_store.read(cx).absolutize(path, cx)?;
1632 self.repositories
1633 .values()
1634 .filter_map(|repo| {
1635 let repo_path = repo.read(cx).abs_path_to_repo_path(&abs_path)?;
1636 Some((repo.clone(), repo_path))
1637 })
1638 .max_by_key(|(repo, _)| repo.read(cx).work_directory_abs_path.clone())
1639 }
1640
1641 pub fn git_init(
1642 &self,
1643 path: Arc<Path>,
1644 fallback_branch_name: String,
1645 cx: &App,
1646 ) -> Task<Result<()>> {
1647 match &self.state {
1648 GitStoreState::Local { fs, .. } => {
1649 let fs = fs.clone();
1650 cx.background_executor()
1651 .spawn(async move { fs.git_init(&path, fallback_branch_name).await })
1652 }
1653 GitStoreState::Remote {
1654 upstream_client,
1655 upstream_project_id: project_id,
1656 ..
1657 } => {
1658 let client = upstream_client.clone();
1659 let project_id = *project_id;
1660 cx.background_executor().spawn(async move {
1661 client
1662 .request(proto::GitInit {
1663 project_id: project_id,
1664 abs_path: path.to_string_lossy().into_owned(),
1665 fallback_branch_name,
1666 })
1667 .await?;
1668 Ok(())
1669 })
1670 }
1671 }
1672 }
1673
1674 pub fn git_clone(
1675 &self,
1676 repo: String,
1677 path: impl Into<Arc<std::path::Path>>,
1678 cx: &App,
1679 ) -> Task<Result<()>> {
1680 let path = path.into();
1681 match &self.state {
1682 GitStoreState::Local { fs, .. } => {
1683 let fs = fs.clone();
1684 cx.background_executor()
1685 .spawn(async move { fs.git_clone(&repo, &path).await })
1686 }
1687 GitStoreState::Remote {
1688 upstream_client,
1689 upstream_project_id,
1690 ..
1691 } => {
1692 if upstream_client.is_via_collab() {
1693 return Task::ready(Err(anyhow!(
1694 "Git Clone isn't supported for project guests"
1695 )));
1696 }
1697 let request = upstream_client.request(proto::GitClone {
1698 project_id: *upstream_project_id,
1699 abs_path: path.to_string_lossy().into_owned(),
1700 remote_repo: repo,
1701 });
1702
1703 cx.background_spawn(async move {
1704 let result = request.await?;
1705
1706 match result.success {
1707 true => Ok(()),
1708 false => Err(anyhow!("Git Clone failed")),
1709 }
1710 })
1711 }
1712 }
1713 }
1714
1715 async fn handle_update_repository(
1716 this: Entity<Self>,
1717 envelope: TypedEnvelope<proto::UpdateRepository>,
1718 mut cx: AsyncApp,
1719 ) -> Result<()> {
1720 this.update(&mut cx, |this, cx| {
1721 let path_style = this.worktree_store.read(cx).path_style();
1722 let mut update = envelope.payload;
1723
1724 let id = RepositoryId::from_proto(update.id);
1725 let client = this.upstream_client().context("no upstream client")?;
1726
1727 let mut repo_subscription = None;
1728 let repo = this.repositories.entry(id).or_insert_with(|| {
1729 let git_store = cx.weak_entity();
1730 let repo = cx.new(|cx| {
1731 Repository::remote(
1732 id,
1733 Path::new(&update.abs_path).into(),
1734 path_style,
1735 ProjectId(update.project_id),
1736 client,
1737 git_store,
1738 cx,
1739 )
1740 });
1741 repo_subscription = Some(cx.subscribe(&repo, Self::on_repository_event));
1742 cx.emit(GitStoreEvent::RepositoryAdded);
1743 repo
1744 });
1745 this._subscriptions.extend(repo_subscription);
1746
1747 repo.update(cx, {
1748 let update = update.clone();
1749 |repo, cx| repo.apply_remote_update(update, cx)
1750 })?;
1751
1752 this.active_repo_id.get_or_insert_with(|| {
1753 cx.emit(GitStoreEvent::ActiveRepositoryChanged(Some(id)));
1754 id
1755 });
1756
1757 if let Some((client, project_id)) = this.downstream_client() {
1758 update.project_id = project_id.to_proto();
1759 client.send(update).log_err();
1760 }
1761 Ok(())
1762 })?
1763 }
1764
1765 async fn handle_remove_repository(
1766 this: Entity<Self>,
1767 envelope: TypedEnvelope<proto::RemoveRepository>,
1768 mut cx: AsyncApp,
1769 ) -> Result<()> {
1770 this.update(&mut cx, |this, cx| {
1771 let mut update = envelope.payload;
1772 let id = RepositoryId::from_proto(update.id);
1773 this.repositories.remove(&id);
1774 if let Some((client, project_id)) = this.downstream_client() {
1775 update.project_id = project_id.to_proto();
1776 client.send(update).log_err();
1777 }
1778 if this.active_repo_id == Some(id) {
1779 this.active_repo_id = None;
1780 cx.emit(GitStoreEvent::ActiveRepositoryChanged(None));
1781 }
1782 cx.emit(GitStoreEvent::RepositoryRemoved(id));
1783 })
1784 }
1785
1786 async fn handle_git_init(
1787 this: Entity<Self>,
1788 envelope: TypedEnvelope<proto::GitInit>,
1789 cx: AsyncApp,
1790 ) -> Result<proto::Ack> {
1791 let path: Arc<Path> = PathBuf::from(envelope.payload.abs_path).into();
1792 let name = envelope.payload.fallback_branch_name;
1793 cx.update(|cx| this.read(cx).git_init(path, name, cx))?
1794 .await?;
1795
1796 Ok(proto::Ack {})
1797 }
1798
1799 async fn handle_git_clone(
1800 this: Entity<Self>,
1801 envelope: TypedEnvelope<proto::GitClone>,
1802 cx: AsyncApp,
1803 ) -> Result<proto::GitCloneResponse> {
1804 let path: Arc<Path> = PathBuf::from(envelope.payload.abs_path).into();
1805 let repo_name = envelope.payload.remote_repo;
1806 let result = cx
1807 .update(|cx| this.read(cx).git_clone(repo_name, path, cx))?
1808 .await;
1809
1810 Ok(proto::GitCloneResponse {
1811 success: result.is_ok(),
1812 })
1813 }
1814
1815 async fn handle_fetch(
1816 this: Entity<Self>,
1817 envelope: TypedEnvelope<proto::Fetch>,
1818 mut cx: AsyncApp,
1819 ) -> Result<proto::RemoteMessageResponse> {
1820 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
1821 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
1822 let fetch_options = FetchOptions::from_proto(envelope.payload.remote);
1823 let askpass_id = envelope.payload.askpass_id;
1824
1825 let askpass = make_remote_delegate(
1826 this,
1827 envelope.payload.project_id,
1828 repository_id,
1829 askpass_id,
1830 &mut cx,
1831 );
1832
1833 let remote_output = repository_handle
1834 .update(&mut cx, |repository_handle, cx| {
1835 repository_handle.fetch(fetch_options, askpass, cx)
1836 })?
1837 .await??;
1838
1839 Ok(proto::RemoteMessageResponse {
1840 stdout: remote_output.stdout,
1841 stderr: remote_output.stderr,
1842 })
1843 }
1844
1845 async fn handle_push(
1846 this: Entity<Self>,
1847 envelope: TypedEnvelope<proto::Push>,
1848 mut cx: AsyncApp,
1849 ) -> Result<proto::RemoteMessageResponse> {
1850 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
1851 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
1852
1853 let askpass_id = envelope.payload.askpass_id;
1854 let askpass = make_remote_delegate(
1855 this,
1856 envelope.payload.project_id,
1857 repository_id,
1858 askpass_id,
1859 &mut cx,
1860 );
1861
1862 let options = envelope
1863 .payload
1864 .options
1865 .as_ref()
1866 .map(|_| match envelope.payload.options() {
1867 proto::push::PushOptions::SetUpstream => git::repository::PushOptions::SetUpstream,
1868 proto::push::PushOptions::Force => git::repository::PushOptions::Force,
1869 });
1870
1871 let branch_name = envelope.payload.branch_name.into();
1872 let remote_name = envelope.payload.remote_name.into();
1873
1874 let remote_output = repository_handle
1875 .update(&mut cx, |repository_handle, cx| {
1876 repository_handle.push(branch_name, remote_name, options, askpass, cx)
1877 })?
1878 .await??;
1879 Ok(proto::RemoteMessageResponse {
1880 stdout: remote_output.stdout,
1881 stderr: remote_output.stderr,
1882 })
1883 }
1884
1885 async fn handle_pull(
1886 this: Entity<Self>,
1887 envelope: TypedEnvelope<proto::Pull>,
1888 mut cx: AsyncApp,
1889 ) -> Result<proto::RemoteMessageResponse> {
1890 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
1891 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
1892 let askpass_id = envelope.payload.askpass_id;
1893 let askpass = make_remote_delegate(
1894 this,
1895 envelope.payload.project_id,
1896 repository_id,
1897 askpass_id,
1898 &mut cx,
1899 );
1900
1901 let branch_name = envelope.payload.branch_name.map(|name| name.into());
1902 let remote_name = envelope.payload.remote_name.into();
1903 let rebase = envelope.payload.rebase;
1904
1905 let remote_message = repository_handle
1906 .update(&mut cx, |repository_handle, cx| {
1907 repository_handle.pull(branch_name, remote_name, rebase, askpass, cx)
1908 })?
1909 .await??;
1910
1911 Ok(proto::RemoteMessageResponse {
1912 stdout: remote_message.stdout,
1913 stderr: remote_message.stderr,
1914 })
1915 }
1916
1917 async fn handle_stage(
1918 this: Entity<Self>,
1919 envelope: TypedEnvelope<proto::Stage>,
1920 mut cx: AsyncApp,
1921 ) -> Result<proto::Ack> {
1922 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
1923 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
1924
1925 let entries = envelope
1926 .payload
1927 .paths
1928 .into_iter()
1929 .map(|path| RepoPath::new(&path))
1930 .collect::<Result<Vec<_>>>()?;
1931
1932 repository_handle
1933 .update(&mut cx, |repository_handle, cx| {
1934 repository_handle.stage_entries(entries, cx)
1935 })?
1936 .await?;
1937 Ok(proto::Ack {})
1938 }
1939
1940 async fn handle_unstage(
1941 this: Entity<Self>,
1942 envelope: TypedEnvelope<proto::Unstage>,
1943 mut cx: AsyncApp,
1944 ) -> Result<proto::Ack> {
1945 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
1946 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
1947
1948 let entries = envelope
1949 .payload
1950 .paths
1951 .into_iter()
1952 .map(|path| RepoPath::new(&path))
1953 .collect::<Result<Vec<_>>>()?;
1954
1955 repository_handle
1956 .update(&mut cx, |repository_handle, cx| {
1957 repository_handle.unstage_entries(entries, cx)
1958 })?
1959 .await?;
1960
1961 Ok(proto::Ack {})
1962 }
1963
1964 async fn handle_stash(
1965 this: Entity<Self>,
1966 envelope: TypedEnvelope<proto::Stash>,
1967 mut cx: AsyncApp,
1968 ) -> Result<proto::Ack> {
1969 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
1970 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
1971
1972 let entries = envelope
1973 .payload
1974 .paths
1975 .into_iter()
1976 .map(|path| RepoPath::new(&path))
1977 .collect::<Result<Vec<_>>>()?;
1978
1979 repository_handle
1980 .update(&mut cx, |repository_handle, cx| {
1981 repository_handle.stash_entries(entries, cx)
1982 })?
1983 .await?;
1984
1985 Ok(proto::Ack {})
1986 }
1987
1988 async fn handle_stash_pop(
1989 this: Entity<Self>,
1990 envelope: TypedEnvelope<proto::StashPop>,
1991 mut cx: AsyncApp,
1992 ) -> Result<proto::Ack> {
1993 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
1994 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
1995 let stash_index = envelope.payload.stash_index.map(|i| i as usize);
1996
1997 repository_handle
1998 .update(&mut cx, |repository_handle, cx| {
1999 repository_handle.stash_pop(stash_index, cx)
2000 })?
2001 .await?;
2002
2003 Ok(proto::Ack {})
2004 }
2005
2006 async fn handle_stash_apply(
2007 this: Entity<Self>,
2008 envelope: TypedEnvelope<proto::StashApply>,
2009 mut cx: AsyncApp,
2010 ) -> Result<proto::Ack> {
2011 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2012 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2013 let stash_index = envelope.payload.stash_index.map(|i| i as usize);
2014
2015 repository_handle
2016 .update(&mut cx, |repository_handle, cx| {
2017 repository_handle.stash_apply(stash_index, cx)
2018 })?
2019 .await?;
2020
2021 Ok(proto::Ack {})
2022 }
2023
2024 async fn handle_stash_drop(
2025 this: Entity<Self>,
2026 envelope: TypedEnvelope<proto::StashDrop>,
2027 mut cx: AsyncApp,
2028 ) -> Result<proto::Ack> {
2029 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2030 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2031 let stash_index = envelope.payload.stash_index.map(|i| i as usize);
2032
2033 repository_handle
2034 .update(&mut cx, |repository_handle, cx| {
2035 repository_handle.stash_drop(stash_index, cx)
2036 })?
2037 .await??;
2038
2039 Ok(proto::Ack {})
2040 }
2041
2042 async fn handle_set_index_text(
2043 this: Entity<Self>,
2044 envelope: TypedEnvelope<proto::SetIndexText>,
2045 mut cx: AsyncApp,
2046 ) -> Result<proto::Ack> {
2047 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2048 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2049 let repo_path = RepoPath::from_proto(&envelope.payload.path)?;
2050
2051 repository_handle
2052 .update(&mut cx, |repository_handle, cx| {
2053 repository_handle.spawn_set_index_text_job(
2054 repo_path,
2055 envelope.payload.text,
2056 None,
2057 cx,
2058 )
2059 })?
2060 .await??;
2061 Ok(proto::Ack {})
2062 }
2063
2064 async fn handle_run_hook(
2065 this: Entity<Self>,
2066 envelope: TypedEnvelope<proto::RunGitHook>,
2067 mut cx: AsyncApp,
2068 ) -> Result<proto::Ack> {
2069 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2070 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2071 let hook = RunHook::from_proto(envelope.payload.hook).context("invalid hook")?;
2072 repository_handle
2073 .update(&mut cx, |repository_handle, cx| {
2074 repository_handle.run_hook(hook, cx)
2075 })?
2076 .await??;
2077 Ok(proto::Ack {})
2078 }
2079
2080 async fn handle_commit(
2081 this: Entity<Self>,
2082 envelope: TypedEnvelope<proto::Commit>,
2083 mut cx: AsyncApp,
2084 ) -> Result<proto::Ack> {
2085 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2086 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2087 let askpass_id = envelope.payload.askpass_id;
2088
2089 let askpass = make_remote_delegate(
2090 this,
2091 envelope.payload.project_id,
2092 repository_id,
2093 askpass_id,
2094 &mut cx,
2095 );
2096
2097 let message = SharedString::from(envelope.payload.message);
2098 let name = envelope.payload.name.map(SharedString::from);
2099 let email = envelope.payload.email.map(SharedString::from);
2100 let options = envelope.payload.options.unwrap_or_default();
2101
2102 repository_handle
2103 .update(&mut cx, |repository_handle, cx| {
2104 repository_handle.commit(
2105 message,
2106 name.zip(email),
2107 CommitOptions {
2108 amend: options.amend,
2109 signoff: options.signoff,
2110 },
2111 askpass,
2112 cx,
2113 )
2114 })?
2115 .await??;
2116 Ok(proto::Ack {})
2117 }
2118
2119 async fn handle_get_remotes(
2120 this: Entity<Self>,
2121 envelope: TypedEnvelope<proto::GetRemotes>,
2122 mut cx: AsyncApp,
2123 ) -> Result<proto::GetRemotesResponse> {
2124 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2125 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2126
2127 let branch_name = envelope.payload.branch_name;
2128 let is_push = envelope.payload.is_push;
2129
2130 let remotes = repository_handle
2131 .update(&mut cx, |repository_handle, _| {
2132 repository_handle.get_remotes(branch_name, is_push)
2133 })?
2134 .await??;
2135
2136 Ok(proto::GetRemotesResponse {
2137 remotes: remotes
2138 .into_iter()
2139 .map(|remotes| proto::get_remotes_response::Remote {
2140 name: remotes.name.to_string(),
2141 })
2142 .collect::<Vec<_>>(),
2143 })
2144 }
2145
2146 async fn handle_get_worktrees(
2147 this: Entity<Self>,
2148 envelope: TypedEnvelope<proto::GitGetWorktrees>,
2149 mut cx: AsyncApp,
2150 ) -> Result<proto::GitWorktreesResponse> {
2151 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2152 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2153
2154 let worktrees = repository_handle
2155 .update(&mut cx, |repository_handle, _| {
2156 repository_handle.worktrees()
2157 })?
2158 .await??;
2159
2160 Ok(proto::GitWorktreesResponse {
2161 worktrees: worktrees
2162 .into_iter()
2163 .map(|worktree| worktree_to_proto(&worktree))
2164 .collect::<Vec<_>>(),
2165 })
2166 }
2167
2168 async fn handle_create_worktree(
2169 this: Entity<Self>,
2170 envelope: TypedEnvelope<proto::GitCreateWorktree>,
2171 mut cx: AsyncApp,
2172 ) -> Result<proto::Ack> {
2173 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2174 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2175 let directory = PathBuf::from(envelope.payload.directory);
2176 let name = envelope.payload.name;
2177 let commit = envelope.payload.commit;
2178
2179 repository_handle
2180 .update(&mut cx, |repository_handle, _| {
2181 repository_handle.create_worktree(name, directory, commit)
2182 })?
2183 .await??;
2184
2185 Ok(proto::Ack {})
2186 }
2187
2188 async fn handle_get_branches(
2189 this: Entity<Self>,
2190 envelope: TypedEnvelope<proto::GitGetBranches>,
2191 mut cx: AsyncApp,
2192 ) -> Result<proto::GitBranchesResponse> {
2193 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2194 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2195
2196 let branches = repository_handle
2197 .update(&mut cx, |repository_handle, _| repository_handle.branches())?
2198 .await??;
2199
2200 Ok(proto::GitBranchesResponse {
2201 branches: branches
2202 .into_iter()
2203 .map(|branch| branch_to_proto(&branch))
2204 .collect::<Vec<_>>(),
2205 })
2206 }
2207 async fn handle_get_default_branch(
2208 this: Entity<Self>,
2209 envelope: TypedEnvelope<proto::GetDefaultBranch>,
2210 mut cx: AsyncApp,
2211 ) -> Result<proto::GetDefaultBranchResponse> {
2212 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2213 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2214
2215 let branch = repository_handle
2216 .update(&mut cx, |repository_handle, _| {
2217 repository_handle.default_branch()
2218 })?
2219 .await??
2220 .map(Into::into);
2221
2222 Ok(proto::GetDefaultBranchResponse { branch })
2223 }
2224 async fn handle_create_branch(
2225 this: Entity<Self>,
2226 envelope: TypedEnvelope<proto::GitCreateBranch>,
2227 mut cx: AsyncApp,
2228 ) -> Result<proto::Ack> {
2229 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2230 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2231 let branch_name = envelope.payload.branch_name;
2232
2233 repository_handle
2234 .update(&mut cx, |repository_handle, _| {
2235 repository_handle.create_branch(branch_name, None)
2236 })?
2237 .await??;
2238
2239 Ok(proto::Ack {})
2240 }
2241
2242 async fn handle_change_branch(
2243 this: Entity<Self>,
2244 envelope: TypedEnvelope<proto::GitChangeBranch>,
2245 mut cx: AsyncApp,
2246 ) -> Result<proto::Ack> {
2247 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2248 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2249 let branch_name = envelope.payload.branch_name;
2250
2251 repository_handle
2252 .update(&mut cx, |repository_handle, _| {
2253 repository_handle.change_branch(branch_name)
2254 })?
2255 .await??;
2256
2257 Ok(proto::Ack {})
2258 }
2259
2260 async fn handle_rename_branch(
2261 this: Entity<Self>,
2262 envelope: TypedEnvelope<proto::GitRenameBranch>,
2263 mut cx: AsyncApp,
2264 ) -> Result<proto::Ack> {
2265 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2266 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2267 let branch = envelope.payload.branch;
2268 let new_name = envelope.payload.new_name;
2269
2270 repository_handle
2271 .update(&mut cx, |repository_handle, _| {
2272 repository_handle.rename_branch(branch, new_name)
2273 })?
2274 .await??;
2275
2276 Ok(proto::Ack {})
2277 }
2278
2279 async fn handle_create_remote(
2280 this: Entity<Self>,
2281 envelope: TypedEnvelope<proto::GitCreateRemote>,
2282 mut cx: AsyncApp,
2283 ) -> Result<proto::Ack> {
2284 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2285 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2286 let remote_name = envelope.payload.remote_name;
2287 let remote_url = envelope.payload.remote_url;
2288
2289 repository_handle
2290 .update(&mut cx, |repository_handle, _| {
2291 repository_handle.create_remote(remote_name, remote_url)
2292 })?
2293 .await??;
2294
2295 Ok(proto::Ack {})
2296 }
2297
2298 async fn handle_delete_branch(
2299 this: Entity<Self>,
2300 envelope: TypedEnvelope<proto::GitDeleteBranch>,
2301 mut cx: AsyncApp,
2302 ) -> Result<proto::Ack> {
2303 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2304 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2305 let branch_name = envelope.payload.branch_name;
2306
2307 repository_handle
2308 .update(&mut cx, |repository_handle, _| {
2309 repository_handle.delete_branch(branch_name)
2310 })?
2311 .await??;
2312
2313 Ok(proto::Ack {})
2314 }
2315
2316 async fn handle_remove_remote(
2317 this: Entity<Self>,
2318 envelope: TypedEnvelope<proto::GitRemoveRemote>,
2319 mut cx: AsyncApp,
2320 ) -> Result<proto::Ack> {
2321 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2322 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2323 let remote_name = envelope.payload.remote_name;
2324
2325 repository_handle
2326 .update(&mut cx, |repository_handle, _| {
2327 repository_handle.remove_remote(remote_name)
2328 })?
2329 .await??;
2330
2331 Ok(proto::Ack {})
2332 }
2333
2334 async fn handle_show(
2335 this: Entity<Self>,
2336 envelope: TypedEnvelope<proto::GitShow>,
2337 mut cx: AsyncApp,
2338 ) -> Result<proto::GitCommitDetails> {
2339 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2340 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2341
2342 let commit = repository_handle
2343 .update(&mut cx, |repository_handle, _| {
2344 repository_handle.show(envelope.payload.commit)
2345 })?
2346 .await??;
2347 Ok(proto::GitCommitDetails {
2348 sha: commit.sha.into(),
2349 message: commit.message.into(),
2350 commit_timestamp: commit.commit_timestamp,
2351 author_email: commit.author_email.into(),
2352 author_name: commit.author_name.into(),
2353 })
2354 }
2355
2356 async fn handle_load_commit_diff(
2357 this: Entity<Self>,
2358 envelope: TypedEnvelope<proto::LoadCommitDiff>,
2359 mut cx: AsyncApp,
2360 ) -> Result<proto::LoadCommitDiffResponse> {
2361 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2362 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2363
2364 let commit_diff = repository_handle
2365 .update(&mut cx, |repository_handle, _| {
2366 repository_handle.load_commit_diff(envelope.payload.commit)
2367 })?
2368 .await??;
2369 Ok(proto::LoadCommitDiffResponse {
2370 files: commit_diff
2371 .files
2372 .into_iter()
2373 .map(|file| proto::CommitFile {
2374 path: file.path.to_proto(),
2375 old_text: file.old_text,
2376 new_text: file.new_text,
2377 })
2378 .collect(),
2379 })
2380 }
2381
2382 async fn handle_file_history(
2383 this: Entity<Self>,
2384 envelope: TypedEnvelope<proto::GitFileHistory>,
2385 mut cx: AsyncApp,
2386 ) -> Result<proto::GitFileHistoryResponse> {
2387 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2388 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2389 let path = RepoPath::from_proto(&envelope.payload.path)?;
2390 let skip = envelope.payload.skip as usize;
2391 let limit = envelope.payload.limit.map(|l| l as usize);
2392
2393 let file_history = repository_handle
2394 .update(&mut cx, |repository_handle, _| {
2395 repository_handle.file_history_paginated(path, skip, limit)
2396 })?
2397 .await??;
2398
2399 Ok(proto::GitFileHistoryResponse {
2400 entries: file_history
2401 .entries
2402 .into_iter()
2403 .map(|entry| proto::FileHistoryEntry {
2404 sha: entry.sha.to_string(),
2405 subject: entry.subject.to_string(),
2406 message: entry.message.to_string(),
2407 commit_timestamp: entry.commit_timestamp,
2408 author_name: entry.author_name.to_string(),
2409 author_email: entry.author_email.to_string(),
2410 })
2411 .collect(),
2412 path: file_history.path.to_proto(),
2413 })
2414 }
2415
2416 async fn handle_reset(
2417 this: Entity<Self>,
2418 envelope: TypedEnvelope<proto::GitReset>,
2419 mut cx: AsyncApp,
2420 ) -> Result<proto::Ack> {
2421 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2422 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2423
2424 let mode = match envelope.payload.mode() {
2425 git_reset::ResetMode::Soft => ResetMode::Soft,
2426 git_reset::ResetMode::Mixed => ResetMode::Mixed,
2427 };
2428
2429 repository_handle
2430 .update(&mut cx, |repository_handle, cx| {
2431 repository_handle.reset(envelope.payload.commit, mode, cx)
2432 })?
2433 .await??;
2434 Ok(proto::Ack {})
2435 }
2436
2437 async fn handle_checkout_files(
2438 this: Entity<Self>,
2439 envelope: TypedEnvelope<proto::GitCheckoutFiles>,
2440 mut cx: AsyncApp,
2441 ) -> Result<proto::Ack> {
2442 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2443 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2444 let paths = envelope
2445 .payload
2446 .paths
2447 .iter()
2448 .map(|s| RepoPath::from_proto(s))
2449 .collect::<Result<Vec<_>>>()?;
2450
2451 repository_handle
2452 .update(&mut cx, |repository_handle, cx| {
2453 repository_handle.checkout_files(&envelope.payload.commit, paths, cx)
2454 })?
2455 .await?;
2456 Ok(proto::Ack {})
2457 }
2458
2459 async fn handle_open_commit_message_buffer(
2460 this: Entity<Self>,
2461 envelope: TypedEnvelope<proto::OpenCommitMessageBuffer>,
2462 mut cx: AsyncApp,
2463 ) -> Result<proto::OpenBufferResponse> {
2464 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2465 let repository = Self::repository_for_request(&this, repository_id, &mut cx)?;
2466 let buffer = repository
2467 .update(&mut cx, |repository, cx| {
2468 repository.open_commit_buffer(None, this.read(cx).buffer_store.clone(), cx)
2469 })?
2470 .await?;
2471
2472 let buffer_id = buffer.read_with(&cx, |buffer, _| buffer.remote_id())?;
2473 this.update(&mut cx, |this, cx| {
2474 this.buffer_store.update(cx, |buffer_store, cx| {
2475 buffer_store
2476 .create_buffer_for_peer(
2477 &buffer,
2478 envelope.original_sender_id.unwrap_or(envelope.sender_id),
2479 cx,
2480 )
2481 .detach_and_log_err(cx);
2482 })
2483 })?;
2484
2485 Ok(proto::OpenBufferResponse {
2486 buffer_id: buffer_id.to_proto(),
2487 })
2488 }
2489
2490 async fn handle_askpass(
2491 this: Entity<Self>,
2492 envelope: TypedEnvelope<proto::AskPassRequest>,
2493 mut cx: AsyncApp,
2494 ) -> Result<proto::AskPassResponse> {
2495 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2496 let repository = Self::repository_for_request(&this, repository_id, &mut cx)?;
2497
2498 let delegates = cx.update(|cx| repository.read(cx).askpass_delegates.clone())?;
2499 let Some(mut askpass) = delegates.lock().remove(&envelope.payload.askpass_id) else {
2500 debug_panic!("no askpass found");
2501 anyhow::bail!("no askpass found");
2502 };
2503
2504 let response = askpass
2505 .ask_password(envelope.payload.prompt)
2506 .await
2507 .ok_or_else(|| anyhow::anyhow!("askpass cancelled"))?;
2508
2509 delegates
2510 .lock()
2511 .insert(envelope.payload.askpass_id, askpass);
2512
2513 // In fact, we don't quite know what we're doing here, as we're sending askpass password unencrypted, but..
2514 Ok(proto::AskPassResponse {
2515 response: response.decrypt(IKnowWhatIAmDoingAndIHaveReadTheDocs)?,
2516 })
2517 }
2518
2519 async fn handle_check_for_pushed_commits(
2520 this: Entity<Self>,
2521 envelope: TypedEnvelope<proto::CheckForPushedCommits>,
2522 mut cx: AsyncApp,
2523 ) -> Result<proto::CheckForPushedCommitsResponse> {
2524 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2525 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2526
2527 let branches = repository_handle
2528 .update(&mut cx, |repository_handle, _| {
2529 repository_handle.check_for_pushed_commits()
2530 })?
2531 .await??;
2532 Ok(proto::CheckForPushedCommitsResponse {
2533 pushed_to: branches
2534 .into_iter()
2535 .map(|commit| commit.to_string())
2536 .collect(),
2537 })
2538 }
2539
2540 async fn handle_git_diff(
2541 this: Entity<Self>,
2542 envelope: TypedEnvelope<proto::GitDiff>,
2543 mut cx: AsyncApp,
2544 ) -> Result<proto::GitDiffResponse> {
2545 let repository_id = RepositoryId::from_proto(envelope.payload.repository_id);
2546 let repository_handle = Self::repository_for_request(&this, repository_id, &mut cx)?;
2547 let diff_type = match envelope.payload.diff_type() {
2548 proto::git_diff::DiffType::HeadToIndex => DiffType::HeadToIndex,
2549 proto::git_diff::DiffType::HeadToWorktree => DiffType::HeadToWorktree,
2550 };
2551
2552 let mut diff = repository_handle
2553 .update(&mut cx, |repository_handle, cx| {
2554 repository_handle.diff(diff_type, cx)
2555 })?
2556 .await??;
2557 const ONE_MB: usize = 1_000_000;
2558 if diff.len() > ONE_MB {
2559 diff = diff.chars().take(ONE_MB).collect()
2560 }
2561
2562 Ok(proto::GitDiffResponse { diff })
2563 }
2564
2565 async fn handle_tree_diff(
2566 this: Entity<Self>,
2567 request: TypedEnvelope<proto::GetTreeDiff>,
2568 mut cx: AsyncApp,
2569 ) -> Result<proto::GetTreeDiffResponse> {
2570 let repository_id = RepositoryId(request.payload.repository_id);
2571 let diff_type = if request.payload.is_merge {
2572 DiffTreeType::MergeBase {
2573 base: request.payload.base.into(),
2574 head: request.payload.head.into(),
2575 }
2576 } else {
2577 DiffTreeType::Since {
2578 base: request.payload.base.into(),
2579 head: request.payload.head.into(),
2580 }
2581 };
2582
2583 let diff = this
2584 .update(&mut cx, |this, cx| {
2585 let repository = this.repositories().get(&repository_id)?;
2586 Some(repository.update(cx, |repo, cx| repo.diff_tree(diff_type, cx)))
2587 })?
2588 .context("missing repository")?
2589 .await??;
2590
2591 Ok(proto::GetTreeDiffResponse {
2592 entries: diff
2593 .entries
2594 .into_iter()
2595 .map(|(path, status)| proto::TreeDiffStatus {
2596 path: path.as_ref().to_proto(),
2597 status: match status {
2598 TreeDiffStatus::Added {} => proto::tree_diff_status::Status::Added.into(),
2599 TreeDiffStatus::Modified { .. } => {
2600 proto::tree_diff_status::Status::Modified.into()
2601 }
2602 TreeDiffStatus::Deleted { .. } => {
2603 proto::tree_diff_status::Status::Deleted.into()
2604 }
2605 },
2606 oid: match status {
2607 TreeDiffStatus::Deleted { old } | TreeDiffStatus::Modified { old } => {
2608 Some(old.to_string())
2609 }
2610 TreeDiffStatus::Added => None,
2611 },
2612 })
2613 .collect(),
2614 })
2615 }
2616
2617 async fn handle_get_blob_content(
2618 this: Entity<Self>,
2619 request: TypedEnvelope<proto::GetBlobContent>,
2620 mut cx: AsyncApp,
2621 ) -> Result<proto::GetBlobContentResponse> {
2622 let oid = git::Oid::from_str(&request.payload.oid)?;
2623 let repository_id = RepositoryId(request.payload.repository_id);
2624 let content = this
2625 .update(&mut cx, |this, cx| {
2626 let repository = this.repositories().get(&repository_id)?;
2627 Some(repository.update(cx, |repo, cx| repo.load_blob_content(oid, cx)))
2628 })?
2629 .context("missing repository")?
2630 .await?;
2631 Ok(proto::GetBlobContentResponse { content })
2632 }
2633
2634 async fn handle_open_unstaged_diff(
2635 this: Entity<Self>,
2636 request: TypedEnvelope<proto::OpenUnstagedDiff>,
2637 mut cx: AsyncApp,
2638 ) -> Result<proto::OpenUnstagedDiffResponse> {
2639 let buffer_id = BufferId::new(request.payload.buffer_id)?;
2640 let diff = this
2641 .update(&mut cx, |this, cx| {
2642 let buffer = this.buffer_store.read(cx).get(buffer_id)?;
2643 Some(this.open_unstaged_diff(buffer, cx))
2644 })?
2645 .context("missing buffer")?
2646 .await?;
2647 this.update(&mut cx, |this, _| {
2648 let shared_diffs = this
2649 .shared_diffs
2650 .entry(request.original_sender_id.unwrap_or(request.sender_id))
2651 .or_default();
2652 shared_diffs.entry(buffer_id).or_default().unstaged = Some(diff.clone());
2653 })?;
2654 let staged_text = diff.read_with(&cx, |diff, _| diff.base_text_string())?;
2655 Ok(proto::OpenUnstagedDiffResponse { staged_text })
2656 }
2657
2658 async fn handle_open_uncommitted_diff(
2659 this: Entity<Self>,
2660 request: TypedEnvelope<proto::OpenUncommittedDiff>,
2661 mut cx: AsyncApp,
2662 ) -> Result<proto::OpenUncommittedDiffResponse> {
2663 let buffer_id = BufferId::new(request.payload.buffer_id)?;
2664 let diff = this
2665 .update(&mut cx, |this, cx| {
2666 let buffer = this.buffer_store.read(cx).get(buffer_id)?;
2667 Some(this.open_uncommitted_diff(buffer, cx))
2668 })?
2669 .context("missing buffer")?
2670 .await?;
2671 this.update(&mut cx, |this, _| {
2672 let shared_diffs = this
2673 .shared_diffs
2674 .entry(request.original_sender_id.unwrap_or(request.sender_id))
2675 .or_default();
2676 shared_diffs.entry(buffer_id).or_default().uncommitted = Some(diff.clone());
2677 })?;
2678 diff.read_with(&cx, |diff, cx| {
2679 use proto::open_uncommitted_diff_response::Mode;
2680
2681 let unstaged_diff = diff.secondary_diff();
2682 let index_snapshot = unstaged_diff.and_then(|diff| {
2683 let diff = diff.read(cx);
2684 diff.base_text_exists().then(|| diff.base_text())
2685 });
2686
2687 let mode;
2688 let staged_text;
2689 let committed_text;
2690 if diff.base_text_exists() {
2691 let committed_snapshot = diff.base_text();
2692 committed_text = Some(committed_snapshot.text());
2693 if let Some(index_text) = index_snapshot {
2694 if index_text.remote_id() == committed_snapshot.remote_id() {
2695 mode = Mode::IndexMatchesHead;
2696 staged_text = None;
2697 } else {
2698 mode = Mode::IndexAndHead;
2699 staged_text = Some(index_text.text());
2700 }
2701 } else {
2702 mode = Mode::IndexAndHead;
2703 staged_text = None;
2704 }
2705 } else {
2706 mode = Mode::IndexAndHead;
2707 committed_text = None;
2708 staged_text = index_snapshot.as_ref().map(|buffer| buffer.text());
2709 }
2710
2711 proto::OpenUncommittedDiffResponse {
2712 committed_text,
2713 staged_text,
2714 mode: mode.into(),
2715 }
2716 })
2717 }
2718
2719 async fn handle_update_diff_bases(
2720 this: Entity<Self>,
2721 request: TypedEnvelope<proto::UpdateDiffBases>,
2722 mut cx: AsyncApp,
2723 ) -> Result<()> {
2724 let buffer_id = BufferId::new(request.payload.buffer_id)?;
2725 this.update(&mut cx, |this, cx| {
2726 if let Some(diff_state) = this.diffs.get_mut(&buffer_id)
2727 && let Some(buffer) = this.buffer_store.read(cx).get(buffer_id)
2728 {
2729 let buffer = buffer.read(cx).text_snapshot();
2730 diff_state.update(cx, |diff_state, cx| {
2731 diff_state.handle_base_texts_updated(buffer, request.payload, cx);
2732 })
2733 }
2734 })
2735 }
2736
2737 async fn handle_blame_buffer(
2738 this: Entity<Self>,
2739 envelope: TypedEnvelope<proto::BlameBuffer>,
2740 mut cx: AsyncApp,
2741 ) -> Result<proto::BlameBufferResponse> {
2742 let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
2743 let version = deserialize_version(&envelope.payload.version);
2744 let buffer = this.read_with(&cx, |this, cx| {
2745 this.buffer_store.read(cx).get_existing(buffer_id)
2746 })??;
2747 buffer
2748 .update(&mut cx, |buffer, _| {
2749 buffer.wait_for_version(version.clone())
2750 })?
2751 .await?;
2752 let blame = this
2753 .update(&mut cx, |this, cx| {
2754 this.blame_buffer(&buffer, Some(version), cx)
2755 })?
2756 .await?;
2757 Ok(serialize_blame_buffer_response(blame))
2758 }
2759
2760 async fn handle_get_permalink_to_line(
2761 this: Entity<Self>,
2762 envelope: TypedEnvelope<proto::GetPermalinkToLine>,
2763 mut cx: AsyncApp,
2764 ) -> Result<proto::GetPermalinkToLineResponse> {
2765 let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
2766 // let version = deserialize_version(&envelope.payload.version);
2767 let selection = {
2768 let proto_selection = envelope
2769 .payload
2770 .selection
2771 .context("no selection to get permalink for defined")?;
2772 proto_selection.start as u32..proto_selection.end as u32
2773 };
2774 let buffer = this.read_with(&cx, |this, cx| {
2775 this.buffer_store.read(cx).get_existing(buffer_id)
2776 })??;
2777 let permalink = this
2778 .update(&mut cx, |this, cx| {
2779 this.get_permalink_to_line(&buffer, selection, cx)
2780 })?
2781 .await?;
2782 Ok(proto::GetPermalinkToLineResponse {
2783 permalink: permalink.to_string(),
2784 })
2785 }
2786
2787 fn repository_for_request(
2788 this: &Entity<Self>,
2789 id: RepositoryId,
2790 cx: &mut AsyncApp,
2791 ) -> Result<Entity<Repository>> {
2792 this.read_with(cx, |this, _| {
2793 this.repositories
2794 .get(&id)
2795 .context("missing repository handle")
2796 .cloned()
2797 })?
2798 }
2799
2800 pub fn repo_snapshots(&self, cx: &App) -> HashMap<RepositoryId, RepositorySnapshot> {
2801 self.repositories
2802 .iter()
2803 .map(|(id, repo)| (*id, repo.read(cx).snapshot.clone()))
2804 .collect()
2805 }
2806
2807 fn process_updated_entries(
2808 &self,
2809 worktree: &Entity<Worktree>,
2810 updated_entries: &[(Arc<RelPath>, ProjectEntryId, PathChange)],
2811 cx: &mut App,
2812 ) -> Task<HashMap<Entity<Repository>, Vec<RepoPath>>> {
2813 let path_style = worktree.read(cx).path_style();
2814 let mut repo_paths = self
2815 .repositories
2816 .values()
2817 .map(|repo| (repo.read(cx).work_directory_abs_path.clone(), repo.clone()))
2818 .collect::<Vec<_>>();
2819 let mut entries: Vec<_> = updated_entries
2820 .iter()
2821 .map(|(path, _, _)| path.clone())
2822 .collect();
2823 entries.sort();
2824 let worktree = worktree.read(cx);
2825
2826 let entries = entries
2827 .into_iter()
2828 .map(|path| worktree.absolutize(&path))
2829 .collect::<Arc<[_]>>();
2830
2831 let executor = cx.background_executor().clone();
2832 cx.background_executor().spawn(async move {
2833 repo_paths.sort_by(|lhs, rhs| lhs.0.cmp(&rhs.0));
2834 let mut paths_by_git_repo = HashMap::<_, Vec<_>>::default();
2835 let mut tasks = FuturesOrdered::new();
2836 for (repo_path, repo) in repo_paths.into_iter().rev() {
2837 let entries = entries.clone();
2838 let task = executor.spawn(async move {
2839 // Find all repository paths that belong to this repo
2840 let mut ix = entries.partition_point(|path| path < &*repo_path);
2841 if ix == entries.len() {
2842 return None;
2843 };
2844
2845 let mut paths = Vec::new();
2846 // All paths prefixed by a given repo will constitute a continuous range.
2847 while let Some(path) = entries.get(ix)
2848 && let Some(repo_path) = RepositorySnapshot::abs_path_to_repo_path_inner(
2849 &repo_path, path, path_style,
2850 )
2851 {
2852 paths.push((repo_path, ix));
2853 ix += 1;
2854 }
2855 if paths.is_empty() {
2856 None
2857 } else {
2858 Some((repo, paths))
2859 }
2860 });
2861 tasks.push_back(task);
2862 }
2863
2864 // Now, let's filter out the "duplicate" entries that were processed by multiple distinct repos.
2865 let mut path_was_used = vec![false; entries.len()];
2866 let tasks = tasks.collect::<Vec<_>>().await;
2867 // Process tasks from the back: iterating backwards allows us to see more-specific paths first.
2868 // We always want to assign a path to it's innermost repository.
2869 for t in tasks {
2870 let Some((repo, paths)) = t else {
2871 continue;
2872 };
2873 let entry = paths_by_git_repo.entry(repo).or_default();
2874 for (repo_path, ix) in paths {
2875 if path_was_used[ix] {
2876 continue;
2877 }
2878 path_was_used[ix] = true;
2879 entry.push(repo_path);
2880 }
2881 }
2882
2883 paths_by_git_repo
2884 })
2885 }
2886}
2887
2888impl BufferGitState {
2889 fn new(_git_store: WeakEntity<GitStore>) -> Self {
2890 Self {
2891 unstaged_diff: Default::default(),
2892 uncommitted_diff: Default::default(),
2893 recalculate_diff_task: Default::default(),
2894 language: Default::default(),
2895 language_registry: Default::default(),
2896 recalculating_tx: postage::watch::channel_with(false).0,
2897 hunk_staging_operation_count: 0,
2898 hunk_staging_operation_count_as_of_write: 0,
2899 head_text: Default::default(),
2900 index_text: Default::default(),
2901 head_changed: Default::default(),
2902 index_changed: Default::default(),
2903 language_changed: Default::default(),
2904 conflict_updated_futures: Default::default(),
2905 conflict_set: Default::default(),
2906 reparse_conflict_markers_task: Default::default(),
2907 }
2908 }
2909
2910 fn buffer_language_changed(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
2911 self.language = buffer.read(cx).language().cloned();
2912 self.language_changed = true;
2913 let _ = self.recalculate_diffs(buffer.read(cx).text_snapshot(), cx);
2914 }
2915
2916 fn reparse_conflict_markers(
2917 &mut self,
2918 buffer: text::BufferSnapshot,
2919 cx: &mut Context<Self>,
2920 ) -> oneshot::Receiver<()> {
2921 let (tx, rx) = oneshot::channel();
2922
2923 let Some(conflict_set) = self
2924 .conflict_set
2925 .as_ref()
2926 .and_then(|conflict_set| conflict_set.upgrade())
2927 else {
2928 return rx;
2929 };
2930
2931 let old_snapshot = conflict_set.read_with(cx, |conflict_set, _| {
2932 if conflict_set.has_conflict {
2933 Some(conflict_set.snapshot())
2934 } else {
2935 None
2936 }
2937 });
2938
2939 if let Some(old_snapshot) = old_snapshot {
2940 self.conflict_updated_futures.push(tx);
2941 self.reparse_conflict_markers_task = Some(cx.spawn(async move |this, cx| {
2942 let (snapshot, changed_range) = cx
2943 .background_spawn(async move {
2944 let new_snapshot = ConflictSet::parse(&buffer);
2945 let changed_range = old_snapshot.compare(&new_snapshot, &buffer);
2946 (new_snapshot, changed_range)
2947 })
2948 .await;
2949 this.update(cx, |this, cx| {
2950 if let Some(conflict_set) = &this.conflict_set {
2951 conflict_set
2952 .update(cx, |conflict_set, cx| {
2953 conflict_set.set_snapshot(snapshot, changed_range, cx);
2954 })
2955 .ok();
2956 }
2957 let futures = std::mem::take(&mut this.conflict_updated_futures);
2958 for tx in futures {
2959 tx.send(()).ok();
2960 }
2961 })
2962 }))
2963 }
2964
2965 rx
2966 }
2967
2968 fn unstaged_diff(&self) -> Option<Entity<BufferDiff>> {
2969 self.unstaged_diff.as_ref().and_then(|set| set.upgrade())
2970 }
2971
2972 fn uncommitted_diff(&self) -> Option<Entity<BufferDiff>> {
2973 self.uncommitted_diff.as_ref().and_then(|set| set.upgrade())
2974 }
2975
2976 fn handle_base_texts_updated(
2977 &mut self,
2978 buffer: text::BufferSnapshot,
2979 message: proto::UpdateDiffBases,
2980 cx: &mut Context<Self>,
2981 ) {
2982 use proto::update_diff_bases::Mode;
2983
2984 let Some(mode) = Mode::from_i32(message.mode) else {
2985 return;
2986 };
2987
2988 let diff_bases_change = match mode {
2989 Mode::HeadOnly => DiffBasesChange::SetHead(message.committed_text),
2990 Mode::IndexOnly => DiffBasesChange::SetIndex(message.staged_text),
2991 Mode::IndexMatchesHead => DiffBasesChange::SetBoth(message.committed_text),
2992 Mode::IndexAndHead => DiffBasesChange::SetEach {
2993 index: message.staged_text,
2994 head: message.committed_text,
2995 },
2996 };
2997
2998 self.diff_bases_changed(buffer, Some(diff_bases_change), cx);
2999 }
3000
3001 pub fn wait_for_recalculation(&mut self) -> Option<impl Future<Output = ()> + use<>> {
3002 if *self.recalculating_tx.borrow() {
3003 let mut rx = self.recalculating_tx.subscribe();
3004 Some(async move {
3005 loop {
3006 let is_recalculating = rx.recv().await;
3007 if is_recalculating != Some(true) {
3008 break;
3009 }
3010 }
3011 })
3012 } else {
3013 None
3014 }
3015 }
3016
3017 fn diff_bases_changed(
3018 &mut self,
3019 buffer: text::BufferSnapshot,
3020 diff_bases_change: Option<DiffBasesChange>,
3021 cx: &mut Context<Self>,
3022 ) {
3023 match diff_bases_change {
3024 Some(DiffBasesChange::SetIndex(index)) => {
3025 self.index_text = index.map(|mut index| {
3026 text::LineEnding::normalize(&mut index);
3027 Arc::new(index)
3028 });
3029 self.index_changed = true;
3030 }
3031 Some(DiffBasesChange::SetHead(head)) => {
3032 self.head_text = head.map(|mut head| {
3033 text::LineEnding::normalize(&mut head);
3034 Arc::new(head)
3035 });
3036 self.head_changed = true;
3037 }
3038 Some(DiffBasesChange::SetBoth(text)) => {
3039 let text = text.map(|mut text| {
3040 text::LineEnding::normalize(&mut text);
3041 Arc::new(text)
3042 });
3043 self.head_text = text.clone();
3044 self.index_text = text;
3045 self.head_changed = true;
3046 self.index_changed = true;
3047 }
3048 Some(DiffBasesChange::SetEach { index, head }) => {
3049 self.index_text = index.map(|mut index| {
3050 text::LineEnding::normalize(&mut index);
3051 Arc::new(index)
3052 });
3053 self.index_changed = true;
3054 self.head_text = head.map(|mut head| {
3055 text::LineEnding::normalize(&mut head);
3056 Arc::new(head)
3057 });
3058 self.head_changed = true;
3059 }
3060 None => {}
3061 }
3062
3063 self.recalculate_diffs(buffer, cx)
3064 }
3065
3066 fn recalculate_diffs(&mut self, buffer: text::BufferSnapshot, cx: &mut Context<Self>) {
3067 *self.recalculating_tx.borrow_mut() = true;
3068
3069 let language = self.language.clone();
3070 let language_registry = self.language_registry.clone();
3071 let unstaged_diff = self.unstaged_diff();
3072 let uncommitted_diff = self.uncommitted_diff();
3073 let head = self.head_text.clone();
3074 let index = self.index_text.clone();
3075 let index_changed = self.index_changed;
3076 let head_changed = self.head_changed;
3077 let language_changed = self.language_changed;
3078 let prev_hunk_staging_operation_count = self.hunk_staging_operation_count_as_of_write;
3079 let index_matches_head = match (self.index_text.as_ref(), self.head_text.as_ref()) {
3080 (Some(index), Some(head)) => Arc::ptr_eq(index, head),
3081 (None, None) => true,
3082 _ => false,
3083 };
3084 self.recalculate_diff_task = Some(cx.spawn(async move |this, cx| {
3085 log::debug!(
3086 "start recalculating diffs for buffer {}",
3087 buffer.remote_id()
3088 );
3089
3090 let mut new_unstaged_diff = None;
3091 if let Some(unstaged_diff) = &unstaged_diff {
3092 new_unstaged_diff = Some(
3093 BufferDiff::update_diff(
3094 unstaged_diff.clone(),
3095 buffer.clone(),
3096 index,
3097 index_changed,
3098 language_changed,
3099 language.clone(),
3100 language_registry.clone(),
3101 cx,
3102 )
3103 .await?,
3104 );
3105 }
3106
3107 // Dropping BufferDiff can be expensive, so yield back to the event loop
3108 // for a bit
3109 yield_now().await;
3110
3111 let mut new_uncommitted_diff = None;
3112 if let Some(uncommitted_diff) = &uncommitted_diff {
3113 new_uncommitted_diff = if index_matches_head {
3114 new_unstaged_diff.clone()
3115 } else {
3116 Some(
3117 BufferDiff::update_diff(
3118 uncommitted_diff.clone(),
3119 buffer.clone(),
3120 head,
3121 head_changed,
3122 language_changed,
3123 language.clone(),
3124 language_registry.clone(),
3125 cx,
3126 )
3127 .await?,
3128 )
3129 }
3130 }
3131
3132 // Dropping BufferDiff can be expensive, so yield back to the event loop
3133 // for a bit
3134 yield_now().await;
3135
3136 let cancel = this.update(cx, |this, _| {
3137 // This checks whether all pending stage/unstage operations
3138 // have quiesced (i.e. both the corresponding write and the
3139 // read of that write have completed). If not, then we cancel
3140 // this recalculation attempt to avoid invalidating pending
3141 // state too quickly; another recalculation will come along
3142 // later and clear the pending state once the state of the index has settled.
3143 if this.hunk_staging_operation_count > prev_hunk_staging_operation_count {
3144 *this.recalculating_tx.borrow_mut() = false;
3145 true
3146 } else {
3147 false
3148 }
3149 })?;
3150 if cancel {
3151 log::debug!(
3152 concat!(
3153 "aborting recalculating diffs for buffer {}",
3154 "due to subsequent hunk operations",
3155 ),
3156 buffer.remote_id()
3157 );
3158 return Ok(());
3159 }
3160
3161 let unstaged_changed_range = if let Some((unstaged_diff, new_unstaged_diff)) =
3162 unstaged_diff.as_ref().zip(new_unstaged_diff.clone())
3163 {
3164 unstaged_diff.update(cx, |diff, cx| {
3165 if language_changed {
3166 diff.language_changed(cx);
3167 }
3168 diff.set_snapshot(new_unstaged_diff, &buffer, cx)
3169 })?
3170 } else {
3171 None
3172 };
3173
3174 yield_now().await;
3175
3176 if let Some((uncommitted_diff, new_uncommitted_diff)) =
3177 uncommitted_diff.as_ref().zip(new_uncommitted_diff.clone())
3178 {
3179 uncommitted_diff.update(cx, |diff, cx| {
3180 if language_changed {
3181 diff.language_changed(cx);
3182 }
3183 diff.set_snapshot_with_secondary(
3184 new_uncommitted_diff,
3185 &buffer,
3186 unstaged_changed_range,
3187 true,
3188 cx,
3189 );
3190 })?;
3191 }
3192
3193 log::debug!(
3194 "finished recalculating diffs for buffer {}",
3195 buffer.remote_id()
3196 );
3197
3198 if let Some(this) = this.upgrade() {
3199 this.update(cx, |this, _| {
3200 this.index_changed = false;
3201 this.head_changed = false;
3202 this.language_changed = false;
3203 *this.recalculating_tx.borrow_mut() = false;
3204 })?;
3205 }
3206
3207 Ok(())
3208 }));
3209 }
3210}
3211
3212fn make_remote_delegate(
3213 this: Entity<GitStore>,
3214 project_id: u64,
3215 repository_id: RepositoryId,
3216 askpass_id: u64,
3217 cx: &mut AsyncApp,
3218) -> AskPassDelegate {
3219 AskPassDelegate::new(cx, move |prompt, tx, cx| {
3220 this.update(cx, |this, cx| {
3221 let Some((client, _)) = this.downstream_client() else {
3222 return;
3223 };
3224 let response = client.request(proto::AskPassRequest {
3225 project_id,
3226 repository_id: repository_id.to_proto(),
3227 askpass_id,
3228 prompt,
3229 });
3230 cx.spawn(async move |_, _| {
3231 let mut response = response.await?.response;
3232 tx.send(EncryptedPassword::try_from(response.as_ref())?)
3233 .ok();
3234 response.zeroize();
3235 anyhow::Ok(())
3236 })
3237 .detach_and_log_err(cx);
3238 })
3239 .log_err();
3240 })
3241}
3242
3243impl RepositoryId {
3244 pub fn to_proto(self) -> u64 {
3245 self.0
3246 }
3247
3248 pub fn from_proto(id: u64) -> Self {
3249 RepositoryId(id)
3250 }
3251}
3252
3253impl RepositorySnapshot {
3254 fn empty(id: RepositoryId, work_directory_abs_path: Arc<Path>, path_style: PathStyle) -> Self {
3255 Self {
3256 id,
3257 statuses_by_path: Default::default(),
3258 work_directory_abs_path,
3259 branch: None,
3260 head_commit: None,
3261 scan_id: 0,
3262 merge: Default::default(),
3263 remote_origin_url: None,
3264 remote_upstream_url: None,
3265 stash_entries: Default::default(),
3266 path_style,
3267 }
3268 }
3269
3270 fn initial_update(&self, project_id: u64) -> proto::UpdateRepository {
3271 proto::UpdateRepository {
3272 branch_summary: self.branch.as_ref().map(branch_to_proto),
3273 head_commit_details: self.head_commit.as_ref().map(commit_details_to_proto),
3274 updated_statuses: self
3275 .statuses_by_path
3276 .iter()
3277 .map(|entry| entry.to_proto())
3278 .collect(),
3279 removed_statuses: Default::default(),
3280 current_merge_conflicts: self
3281 .merge
3282 .conflicted_paths
3283 .iter()
3284 .map(|repo_path| repo_path.to_proto())
3285 .collect(),
3286 merge_message: self.merge.message.as_ref().map(|msg| msg.to_string()),
3287 project_id,
3288 id: self.id.to_proto(),
3289 abs_path: self.work_directory_abs_path.to_string_lossy().into_owned(),
3290 entry_ids: vec![self.id.to_proto()],
3291 scan_id: self.scan_id,
3292 is_last_update: true,
3293 stash_entries: self
3294 .stash_entries
3295 .entries
3296 .iter()
3297 .map(stash_to_proto)
3298 .collect(),
3299 remote_upstream_url: self.remote_upstream_url.clone(),
3300 remote_origin_url: self.remote_origin_url.clone(),
3301 }
3302 }
3303
3304 fn build_update(&self, old: &Self, project_id: u64) -> proto::UpdateRepository {
3305 let mut updated_statuses: Vec<proto::StatusEntry> = Vec::new();
3306 let mut removed_statuses: Vec<String> = Vec::new();
3307
3308 let mut new_statuses = self.statuses_by_path.iter().peekable();
3309 let mut old_statuses = old.statuses_by_path.iter().peekable();
3310
3311 let mut current_new_entry = new_statuses.next();
3312 let mut current_old_entry = old_statuses.next();
3313 loop {
3314 match (current_new_entry, current_old_entry) {
3315 (Some(new_entry), Some(old_entry)) => {
3316 match new_entry.repo_path.cmp(&old_entry.repo_path) {
3317 Ordering::Less => {
3318 updated_statuses.push(new_entry.to_proto());
3319 current_new_entry = new_statuses.next();
3320 }
3321 Ordering::Equal => {
3322 if new_entry.status != old_entry.status {
3323 updated_statuses.push(new_entry.to_proto());
3324 }
3325 current_old_entry = old_statuses.next();
3326 current_new_entry = new_statuses.next();
3327 }
3328 Ordering::Greater => {
3329 removed_statuses.push(old_entry.repo_path.to_proto());
3330 current_old_entry = old_statuses.next();
3331 }
3332 }
3333 }
3334 (None, Some(old_entry)) => {
3335 removed_statuses.push(old_entry.repo_path.to_proto());
3336 current_old_entry = old_statuses.next();
3337 }
3338 (Some(new_entry), None) => {
3339 updated_statuses.push(new_entry.to_proto());
3340 current_new_entry = new_statuses.next();
3341 }
3342 (None, None) => break,
3343 }
3344 }
3345
3346 proto::UpdateRepository {
3347 branch_summary: self.branch.as_ref().map(branch_to_proto),
3348 head_commit_details: self.head_commit.as_ref().map(commit_details_to_proto),
3349 updated_statuses,
3350 removed_statuses,
3351 current_merge_conflicts: self
3352 .merge
3353 .conflicted_paths
3354 .iter()
3355 .map(|path| path.to_proto())
3356 .collect(),
3357 merge_message: self.merge.message.as_ref().map(|msg| msg.to_string()),
3358 project_id,
3359 id: self.id.to_proto(),
3360 abs_path: self.work_directory_abs_path.to_string_lossy().into_owned(),
3361 entry_ids: vec![],
3362 scan_id: self.scan_id,
3363 is_last_update: true,
3364 stash_entries: self
3365 .stash_entries
3366 .entries
3367 .iter()
3368 .map(stash_to_proto)
3369 .collect(),
3370 remote_upstream_url: self.remote_upstream_url.clone(),
3371 remote_origin_url: self.remote_origin_url.clone(),
3372 }
3373 }
3374
3375 pub fn status(&self) -> impl Iterator<Item = StatusEntry> + '_ {
3376 self.statuses_by_path.iter().cloned()
3377 }
3378
3379 pub fn status_summary(&self) -> GitSummary {
3380 self.statuses_by_path.summary().item_summary
3381 }
3382
3383 pub fn status_for_path(&self, path: &RepoPath) -> Option<StatusEntry> {
3384 self.statuses_by_path
3385 .get(&PathKey(path.as_ref().clone()), ())
3386 .cloned()
3387 }
3388
3389 pub fn abs_path_to_repo_path(&self, abs_path: &Path) -> Option<RepoPath> {
3390 Self::abs_path_to_repo_path_inner(&self.work_directory_abs_path, abs_path, self.path_style)
3391 }
3392
3393 fn repo_path_to_abs_path(&self, repo_path: &RepoPath) -> PathBuf {
3394 self.path_style
3395 .join(&self.work_directory_abs_path, repo_path.as_std_path())
3396 .unwrap()
3397 .into()
3398 }
3399
3400 #[inline]
3401 fn abs_path_to_repo_path_inner(
3402 work_directory_abs_path: &Path,
3403 abs_path: &Path,
3404 path_style: PathStyle,
3405 ) -> Option<RepoPath> {
3406 let rel_path = path_style.strip_prefix(abs_path, work_directory_abs_path)?;
3407 Some(RepoPath::from_rel_path(&rel_path))
3408 }
3409
3410 pub fn had_conflict_on_last_merge_head_change(&self, repo_path: &RepoPath) -> bool {
3411 self.merge.conflicted_paths.contains(repo_path)
3412 }
3413
3414 pub fn has_conflict(&self, repo_path: &RepoPath) -> bool {
3415 let had_conflict_on_last_merge_head_change =
3416 self.merge.conflicted_paths.contains(repo_path);
3417 let has_conflict_currently = self
3418 .status_for_path(repo_path)
3419 .is_some_and(|entry| entry.status.is_conflicted());
3420 had_conflict_on_last_merge_head_change || has_conflict_currently
3421 }
3422
3423 /// This is the name that will be displayed in the repository selector for this repository.
3424 pub fn display_name(&self) -> SharedString {
3425 self.work_directory_abs_path
3426 .file_name()
3427 .unwrap_or_default()
3428 .to_string_lossy()
3429 .to_string()
3430 .into()
3431 }
3432}
3433
3434pub fn stash_to_proto(entry: &StashEntry) -> proto::StashEntry {
3435 proto::StashEntry {
3436 oid: entry.oid.as_bytes().to_vec(),
3437 message: entry.message.clone(),
3438 branch: entry.branch.clone(),
3439 index: entry.index as u64,
3440 timestamp: entry.timestamp,
3441 }
3442}
3443
3444pub fn proto_to_stash(entry: &proto::StashEntry) -> Result<StashEntry> {
3445 Ok(StashEntry {
3446 oid: Oid::from_bytes(&entry.oid)?,
3447 message: entry.message.clone(),
3448 index: entry.index as usize,
3449 branch: entry.branch.clone(),
3450 timestamp: entry.timestamp,
3451 })
3452}
3453
3454impl MergeDetails {
3455 async fn load(
3456 backend: &Arc<dyn GitRepository>,
3457 status: &SumTree<StatusEntry>,
3458 prev_snapshot: &RepositorySnapshot,
3459 ) -> Result<(MergeDetails, bool)> {
3460 log::debug!("load merge details");
3461 let message = backend.merge_message().await;
3462 let heads = backend
3463 .revparse_batch(vec![
3464 "MERGE_HEAD".into(),
3465 "CHERRY_PICK_HEAD".into(),
3466 "REBASE_HEAD".into(),
3467 "REVERT_HEAD".into(),
3468 "APPLY_HEAD".into(),
3469 ])
3470 .await
3471 .log_err()
3472 .unwrap_or_default()
3473 .into_iter()
3474 .map(|opt| opt.map(SharedString::from))
3475 .collect::<Vec<_>>();
3476 let merge_heads_changed = heads != prev_snapshot.merge.heads;
3477 let conflicted_paths = if merge_heads_changed {
3478 let current_conflicted_paths = TreeSet::from_ordered_entries(
3479 status
3480 .iter()
3481 .filter(|entry| entry.status.is_conflicted())
3482 .map(|entry| entry.repo_path.clone()),
3483 );
3484
3485 // It can happen that we run a scan while a lengthy merge is in progress
3486 // that will eventually result in conflicts, but before those conflicts
3487 // are reported by `git status`. Since for the moment we only care about
3488 // the merge heads state for the purposes of tracking conflicts, don't update
3489 // this state until we see some conflicts.
3490 if heads.iter().any(Option::is_some)
3491 && !prev_snapshot.merge.heads.iter().any(Option::is_some)
3492 && current_conflicted_paths.is_empty()
3493 {
3494 log::debug!("not updating merge heads because no conflicts found");
3495 return Ok((
3496 MergeDetails {
3497 message: message.map(SharedString::from),
3498 ..prev_snapshot.merge.clone()
3499 },
3500 false,
3501 ));
3502 }
3503
3504 current_conflicted_paths
3505 } else {
3506 prev_snapshot.merge.conflicted_paths.clone()
3507 };
3508 let details = MergeDetails {
3509 conflicted_paths,
3510 message: message.map(SharedString::from),
3511 heads,
3512 };
3513 Ok((details, merge_heads_changed))
3514 }
3515}
3516
3517impl Repository {
3518 pub fn snapshot(&self) -> RepositorySnapshot {
3519 self.snapshot.clone()
3520 }
3521
3522 pub fn pending_ops(&self) -> impl Iterator<Item = PendingOps> + '_ {
3523 self.pending_ops.iter().cloned()
3524 }
3525
3526 pub fn pending_ops_summary(&self) -> PathSummary<PendingOpsSummary> {
3527 self.pending_ops.summary().clone()
3528 }
3529
3530 pub fn pending_ops_for_path(&self, path: &RepoPath) -> Option<PendingOps> {
3531 self.pending_ops
3532 .get(&PathKey(path.as_ref().clone()), ())
3533 .cloned()
3534 }
3535
3536 fn local(
3537 id: RepositoryId,
3538 work_directory_abs_path: Arc<Path>,
3539 dot_git_abs_path: Arc<Path>,
3540 project_environment: WeakEntity<ProjectEnvironment>,
3541 fs: Arc<dyn Fs>,
3542 git_store: WeakEntity<GitStore>,
3543 cx: &mut Context<Self>,
3544 ) -> Self {
3545 let snapshot =
3546 RepositorySnapshot::empty(id, work_directory_abs_path.clone(), PathStyle::local());
3547 let state = cx
3548 .spawn(async move |_, cx| {
3549 LocalRepositoryState::new(
3550 work_directory_abs_path,
3551 dot_git_abs_path,
3552 project_environment,
3553 fs,
3554 cx,
3555 )
3556 .await
3557 .map_err(|err| err.to_string())
3558 })
3559 .shared();
3560 let job_sender = Repository::spawn_local_git_worker(state.clone(), cx);
3561 let state = cx
3562 .spawn(async move |_, _| {
3563 let state = state.await?;
3564 Ok(RepositoryState::Local(state))
3565 })
3566 .shared();
3567
3568 Repository {
3569 this: cx.weak_entity(),
3570 git_store,
3571 snapshot,
3572 pending_ops: Default::default(),
3573 repository_state: state,
3574 commit_message_buffer: None,
3575 askpass_delegates: Default::default(),
3576 paths_needing_status_update: Default::default(),
3577 latest_askpass_id: 0,
3578 job_sender,
3579 job_id: 0,
3580 active_jobs: Default::default(),
3581 }
3582 }
3583
3584 fn remote(
3585 id: RepositoryId,
3586 work_directory_abs_path: Arc<Path>,
3587 path_style: PathStyle,
3588 project_id: ProjectId,
3589 client: AnyProtoClient,
3590 git_store: WeakEntity<GitStore>,
3591 cx: &mut Context<Self>,
3592 ) -> Self {
3593 let snapshot = RepositorySnapshot::empty(id, work_directory_abs_path, path_style);
3594 let repository_state = RemoteRepositoryState { project_id, client };
3595 let job_sender = Self::spawn_remote_git_worker(repository_state.clone(), cx);
3596 let repository_state = Task::ready(Ok(RepositoryState::Remote(repository_state))).shared();
3597 Self {
3598 this: cx.weak_entity(),
3599 snapshot,
3600 commit_message_buffer: None,
3601 git_store,
3602 pending_ops: Default::default(),
3603 paths_needing_status_update: Default::default(),
3604 job_sender,
3605 repository_state,
3606 askpass_delegates: Default::default(),
3607 latest_askpass_id: 0,
3608 active_jobs: Default::default(),
3609 job_id: 0,
3610 }
3611 }
3612
3613 pub fn git_store(&self) -> Option<Entity<GitStore>> {
3614 self.git_store.upgrade()
3615 }
3616
3617 fn reload_buffer_diff_bases(&mut self, cx: &mut Context<Self>) {
3618 let this = cx.weak_entity();
3619 let git_store = self.git_store.clone();
3620 let _ = self.send_keyed_job(
3621 Some(GitJobKey::ReloadBufferDiffBases),
3622 None,
3623 |state, mut cx| async move {
3624 let RepositoryState::Local(LocalRepositoryState { backend, .. }) = state else {
3625 log::error!("tried to recompute diffs for a non-local repository");
3626 return Ok(());
3627 };
3628
3629 let Some(this) = this.upgrade() else {
3630 return Ok(());
3631 };
3632
3633 let repo_diff_state_updates = this.update(&mut cx, |this, cx| {
3634 git_store.update(cx, |git_store, cx| {
3635 git_store
3636 .diffs
3637 .iter()
3638 .filter_map(|(buffer_id, diff_state)| {
3639 let buffer_store = git_store.buffer_store.read(cx);
3640 let buffer = buffer_store.get(*buffer_id)?;
3641 let file = File::from_dyn(buffer.read(cx).file())?;
3642 let abs_path = file.worktree.read(cx).absolutize(&file.path);
3643 let repo_path = this.abs_path_to_repo_path(&abs_path)?;
3644 log::debug!(
3645 "start reload diff bases for repo path {}",
3646 repo_path.as_unix_str()
3647 );
3648 diff_state.update(cx, |diff_state, _| {
3649 let has_unstaged_diff = diff_state
3650 .unstaged_diff
3651 .as_ref()
3652 .is_some_and(|diff| diff.is_upgradable());
3653 let has_uncommitted_diff = diff_state
3654 .uncommitted_diff
3655 .as_ref()
3656 .is_some_and(|set| set.is_upgradable());
3657
3658 Some((
3659 buffer,
3660 repo_path,
3661 has_unstaged_diff.then(|| diff_state.index_text.clone()),
3662 has_uncommitted_diff.then(|| diff_state.head_text.clone()),
3663 ))
3664 })
3665 })
3666 .collect::<Vec<_>>()
3667 })
3668 })??;
3669
3670 let buffer_diff_base_changes = cx
3671 .background_spawn(async move {
3672 let mut changes = Vec::new();
3673 for (buffer, repo_path, current_index_text, current_head_text) in
3674 &repo_diff_state_updates
3675 {
3676 let index_text = if current_index_text.is_some() {
3677 backend.load_index_text(repo_path.clone()).await
3678 } else {
3679 None
3680 };
3681 let head_text = if current_head_text.is_some() {
3682 backend.load_committed_text(repo_path.clone()).await
3683 } else {
3684 None
3685 };
3686
3687 let change =
3688 match (current_index_text.as_ref(), current_head_text.as_ref()) {
3689 (Some(current_index), Some(current_head)) => {
3690 let index_changed =
3691 index_text.as_ref() != current_index.as_deref();
3692 let head_changed =
3693 head_text.as_ref() != current_head.as_deref();
3694 if index_changed && head_changed {
3695 if index_text == head_text {
3696 Some(DiffBasesChange::SetBoth(head_text))
3697 } else {
3698 Some(DiffBasesChange::SetEach {
3699 index: index_text,
3700 head: head_text,
3701 })
3702 }
3703 } else if index_changed {
3704 Some(DiffBasesChange::SetIndex(index_text))
3705 } else if head_changed {
3706 Some(DiffBasesChange::SetHead(head_text))
3707 } else {
3708 None
3709 }
3710 }
3711 (Some(current_index), None) => {
3712 let index_changed =
3713 index_text.as_ref() != current_index.as_deref();
3714 index_changed
3715 .then_some(DiffBasesChange::SetIndex(index_text))
3716 }
3717 (None, Some(current_head)) => {
3718 let head_changed =
3719 head_text.as_ref() != current_head.as_deref();
3720 head_changed.then_some(DiffBasesChange::SetHead(head_text))
3721 }
3722 (None, None) => None,
3723 };
3724
3725 changes.push((buffer.clone(), change))
3726 }
3727 changes
3728 })
3729 .await;
3730
3731 git_store.update(&mut cx, |git_store, cx| {
3732 for (buffer, diff_bases_change) in buffer_diff_base_changes {
3733 let buffer_snapshot = buffer.read(cx).text_snapshot();
3734 let buffer_id = buffer_snapshot.remote_id();
3735 let Some(diff_state) = git_store.diffs.get(&buffer_id) else {
3736 continue;
3737 };
3738
3739 let downstream_client = git_store.downstream_client();
3740 diff_state.update(cx, |diff_state, cx| {
3741 use proto::update_diff_bases::Mode;
3742
3743 if let Some((diff_bases_change, (client, project_id))) =
3744 diff_bases_change.clone().zip(downstream_client)
3745 {
3746 let (staged_text, committed_text, mode) = match diff_bases_change {
3747 DiffBasesChange::SetIndex(index) => {
3748 (index, None, Mode::IndexOnly)
3749 }
3750 DiffBasesChange::SetHead(head) => (None, head, Mode::HeadOnly),
3751 DiffBasesChange::SetEach { index, head } => {
3752 (index, head, Mode::IndexAndHead)
3753 }
3754 DiffBasesChange::SetBoth(text) => {
3755 (None, text, Mode::IndexMatchesHead)
3756 }
3757 };
3758 client
3759 .send(proto::UpdateDiffBases {
3760 project_id: project_id.to_proto(),
3761 buffer_id: buffer_id.to_proto(),
3762 staged_text,
3763 committed_text,
3764 mode: mode as i32,
3765 })
3766 .log_err();
3767 }
3768
3769 diff_state.diff_bases_changed(buffer_snapshot, diff_bases_change, cx);
3770 });
3771 }
3772 })
3773 },
3774 );
3775 }
3776
3777 pub fn send_job<F, Fut, R>(
3778 &mut self,
3779 status: Option<SharedString>,
3780 job: F,
3781 ) -> oneshot::Receiver<R>
3782 where
3783 F: FnOnce(RepositoryState, AsyncApp) -> Fut + 'static,
3784 Fut: Future<Output = R> + 'static,
3785 R: Send + 'static,
3786 {
3787 self.send_keyed_job(None, status, job)
3788 }
3789
3790 fn send_keyed_job<F, Fut, R>(
3791 &mut self,
3792 key: Option<GitJobKey>,
3793 status: Option<SharedString>,
3794 job: F,
3795 ) -> oneshot::Receiver<R>
3796 where
3797 F: FnOnce(RepositoryState, AsyncApp) -> Fut + 'static,
3798 Fut: Future<Output = R> + 'static,
3799 R: Send + 'static,
3800 {
3801 let (result_tx, result_rx) = futures::channel::oneshot::channel();
3802 let job_id = post_inc(&mut self.job_id);
3803 let this = self.this.clone();
3804 self.job_sender
3805 .unbounded_send(GitJob {
3806 key,
3807 job: Box::new(move |state, cx: &mut AsyncApp| {
3808 let job = job(state, cx.clone());
3809 cx.spawn(async move |cx| {
3810 if let Some(s) = status.clone() {
3811 this.update(cx, |this, cx| {
3812 this.active_jobs.insert(
3813 job_id,
3814 JobInfo {
3815 start: Instant::now(),
3816 message: s.clone(),
3817 },
3818 );
3819
3820 cx.notify();
3821 })
3822 .ok();
3823 }
3824 let result = job.await;
3825
3826 this.update(cx, |this, cx| {
3827 this.active_jobs.remove(&job_id);
3828 cx.notify();
3829 })
3830 .ok();
3831
3832 result_tx.send(result).ok();
3833 })
3834 }),
3835 })
3836 .ok();
3837 result_rx
3838 }
3839
3840 pub fn set_as_active_repository(&self, cx: &mut Context<Self>) {
3841 let Some(git_store) = self.git_store.upgrade() else {
3842 return;
3843 };
3844 let entity = cx.entity();
3845 git_store.update(cx, |git_store, cx| {
3846 let Some((&id, _)) = git_store
3847 .repositories
3848 .iter()
3849 .find(|(_, handle)| *handle == &entity)
3850 else {
3851 return;
3852 };
3853 git_store.active_repo_id = Some(id);
3854 cx.emit(GitStoreEvent::ActiveRepositoryChanged(Some(id)));
3855 });
3856 }
3857
3858 pub fn cached_status(&self) -> impl '_ + Iterator<Item = StatusEntry> {
3859 self.snapshot.status()
3860 }
3861
3862 pub fn cached_stash(&self) -> GitStash {
3863 self.snapshot.stash_entries.clone()
3864 }
3865
3866 pub fn repo_path_to_project_path(&self, path: &RepoPath, cx: &App) -> Option<ProjectPath> {
3867 let git_store = self.git_store.upgrade()?;
3868 let worktree_store = git_store.read(cx).worktree_store.read(cx);
3869 let abs_path = self.snapshot.repo_path_to_abs_path(path);
3870 let abs_path = SanitizedPath::new(&abs_path);
3871 let (worktree, relative_path) = worktree_store.find_worktree(abs_path, cx)?;
3872 Some(ProjectPath {
3873 worktree_id: worktree.read(cx).id(),
3874 path: relative_path,
3875 })
3876 }
3877
3878 pub fn project_path_to_repo_path(&self, path: &ProjectPath, cx: &App) -> Option<RepoPath> {
3879 let git_store = self.git_store.upgrade()?;
3880 let worktree_store = git_store.read(cx).worktree_store.read(cx);
3881 let abs_path = worktree_store.absolutize(path, cx)?;
3882 self.snapshot.abs_path_to_repo_path(&abs_path)
3883 }
3884
3885 pub fn contains_sub_repo(&self, other: &Entity<Self>, cx: &App) -> bool {
3886 other
3887 .read(cx)
3888 .snapshot
3889 .work_directory_abs_path
3890 .starts_with(&self.snapshot.work_directory_abs_path)
3891 }
3892
3893 pub fn open_commit_buffer(
3894 &mut self,
3895 languages: Option<Arc<LanguageRegistry>>,
3896 buffer_store: Entity<BufferStore>,
3897 cx: &mut Context<Self>,
3898 ) -> Task<Result<Entity<Buffer>>> {
3899 let id = self.id;
3900 if let Some(buffer) = self.commit_message_buffer.clone() {
3901 return Task::ready(Ok(buffer));
3902 }
3903 let this = cx.weak_entity();
3904
3905 let rx = self.send_job(None, move |state, mut cx| async move {
3906 let Some(this) = this.upgrade() else {
3907 bail!("git store was dropped");
3908 };
3909 match state {
3910 RepositoryState::Local(..) => {
3911 this.update(&mut cx, |_, cx| {
3912 Self::open_local_commit_buffer(languages, buffer_store, cx)
3913 })?
3914 .await
3915 }
3916 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
3917 let request = client.request(proto::OpenCommitMessageBuffer {
3918 project_id: project_id.0,
3919 repository_id: id.to_proto(),
3920 });
3921 let response = request.await.context("requesting to open commit buffer")?;
3922 let buffer_id = BufferId::new(response.buffer_id)?;
3923 let buffer = buffer_store
3924 .update(&mut cx, |buffer_store, cx| {
3925 buffer_store.wait_for_remote_buffer(buffer_id, cx)
3926 })?
3927 .await?;
3928 if let Some(language_registry) = languages {
3929 let git_commit_language =
3930 language_registry.language_for_name("Git Commit").await?;
3931 buffer.update(&mut cx, |buffer, cx| {
3932 buffer.set_language(Some(git_commit_language), cx);
3933 })?;
3934 }
3935 this.update(&mut cx, |this, _| {
3936 this.commit_message_buffer = Some(buffer.clone());
3937 })?;
3938 Ok(buffer)
3939 }
3940 }
3941 });
3942
3943 cx.spawn(|_, _: &mut AsyncApp| async move { rx.await? })
3944 }
3945
3946 fn open_local_commit_buffer(
3947 language_registry: Option<Arc<LanguageRegistry>>,
3948 buffer_store: Entity<BufferStore>,
3949 cx: &mut Context<Self>,
3950 ) -> Task<Result<Entity<Buffer>>> {
3951 cx.spawn(async move |repository, cx| {
3952 let buffer = buffer_store
3953 .update(cx, |buffer_store, cx| buffer_store.create_buffer(false, cx))?
3954 .await?;
3955
3956 if let Some(language_registry) = language_registry {
3957 let git_commit_language = language_registry.language_for_name("Git Commit").await?;
3958 buffer.update(cx, |buffer, cx| {
3959 buffer.set_language(Some(git_commit_language), cx);
3960 })?;
3961 }
3962
3963 repository.update(cx, |repository, _| {
3964 repository.commit_message_buffer = Some(buffer.clone());
3965 })?;
3966 Ok(buffer)
3967 })
3968 }
3969
3970 pub fn checkout_files(
3971 &mut self,
3972 commit: &str,
3973 paths: Vec<RepoPath>,
3974 cx: &mut Context<Self>,
3975 ) -> Task<Result<()>> {
3976 let commit = commit.to_string();
3977 let id = self.id;
3978
3979 self.spawn_job_with_tracking(
3980 paths.clone(),
3981 pending_op::GitStatus::Reverted,
3982 cx,
3983 async move |this, cx| {
3984 this.update(cx, |this, _cx| {
3985 this.send_job(
3986 Some(format!("git checkout {}", commit).into()),
3987 move |git_repo, _| async move {
3988 match git_repo {
3989 RepositoryState::Local(LocalRepositoryState {
3990 backend,
3991 environment,
3992 ..
3993 }) => {
3994 backend
3995 .checkout_files(commit, paths, environment.clone())
3996 .await
3997 }
3998 RepositoryState::Remote(RemoteRepositoryState {
3999 project_id,
4000 client,
4001 }) => {
4002 client
4003 .request(proto::GitCheckoutFiles {
4004 project_id: project_id.0,
4005 repository_id: id.to_proto(),
4006 commit,
4007 paths: paths
4008 .into_iter()
4009 .map(|p| p.to_proto())
4010 .collect(),
4011 })
4012 .await?;
4013
4014 Ok(())
4015 }
4016 }
4017 },
4018 )
4019 })?
4020 .await?
4021 },
4022 )
4023 }
4024
4025 pub fn reset(
4026 &mut self,
4027 commit: String,
4028 reset_mode: ResetMode,
4029 _cx: &mut App,
4030 ) -> oneshot::Receiver<Result<()>> {
4031 let id = self.id;
4032
4033 self.send_job(None, move |git_repo, _| async move {
4034 match git_repo {
4035 RepositoryState::Local(LocalRepositoryState {
4036 backend,
4037 environment,
4038 ..
4039 }) => backend.reset(commit, reset_mode, environment).await,
4040 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4041 client
4042 .request(proto::GitReset {
4043 project_id: project_id.0,
4044 repository_id: id.to_proto(),
4045 commit,
4046 mode: match reset_mode {
4047 ResetMode::Soft => git_reset::ResetMode::Soft.into(),
4048 ResetMode::Mixed => git_reset::ResetMode::Mixed.into(),
4049 },
4050 })
4051 .await?;
4052
4053 Ok(())
4054 }
4055 }
4056 })
4057 }
4058
4059 pub fn show(&mut self, commit: String) -> oneshot::Receiver<Result<CommitDetails>> {
4060 let id = self.id;
4061 self.send_job(None, move |git_repo, _cx| async move {
4062 match git_repo {
4063 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
4064 backend.show(commit).await
4065 }
4066 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4067 let resp = client
4068 .request(proto::GitShow {
4069 project_id: project_id.0,
4070 repository_id: id.to_proto(),
4071 commit,
4072 })
4073 .await?;
4074
4075 Ok(CommitDetails {
4076 sha: resp.sha.into(),
4077 message: resp.message.into(),
4078 commit_timestamp: resp.commit_timestamp,
4079 author_email: resp.author_email.into(),
4080 author_name: resp.author_name.into(),
4081 })
4082 }
4083 }
4084 })
4085 }
4086
4087 pub fn load_commit_diff(&mut self, commit: String) -> oneshot::Receiver<Result<CommitDiff>> {
4088 let id = self.id;
4089 self.send_job(None, move |git_repo, cx| async move {
4090 match git_repo {
4091 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
4092 backend.load_commit(commit, cx).await
4093 }
4094 RepositoryState::Remote(RemoteRepositoryState {
4095 client, project_id, ..
4096 }) => {
4097 let response = client
4098 .request(proto::LoadCommitDiff {
4099 project_id: project_id.0,
4100 repository_id: id.to_proto(),
4101 commit,
4102 })
4103 .await?;
4104 Ok(CommitDiff {
4105 files: response
4106 .files
4107 .into_iter()
4108 .map(|file| {
4109 Ok(CommitFile {
4110 path: RepoPath::from_proto(&file.path)?,
4111 old_text: file.old_text,
4112 new_text: file.new_text,
4113 })
4114 })
4115 .collect::<Result<Vec<_>>>()?,
4116 })
4117 }
4118 }
4119 })
4120 }
4121
4122 pub fn file_history(
4123 &mut self,
4124 path: RepoPath,
4125 ) -> oneshot::Receiver<Result<git::repository::FileHistory>> {
4126 self.file_history_paginated(path, 0, None)
4127 }
4128
4129 pub fn file_history_paginated(
4130 &mut self,
4131 path: RepoPath,
4132 skip: usize,
4133 limit: Option<usize>,
4134 ) -> oneshot::Receiver<Result<git::repository::FileHistory>> {
4135 let id = self.id;
4136 self.send_job(None, move |git_repo, _cx| async move {
4137 match git_repo {
4138 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
4139 backend.file_history_paginated(path, skip, limit).await
4140 }
4141 RepositoryState::Remote(RemoteRepositoryState { client, project_id }) => {
4142 let response = client
4143 .request(proto::GitFileHistory {
4144 project_id: project_id.0,
4145 repository_id: id.to_proto(),
4146 path: path.to_proto(),
4147 skip: skip as u64,
4148 limit: limit.map(|l| l as u64),
4149 })
4150 .await?;
4151 Ok(git::repository::FileHistory {
4152 entries: response
4153 .entries
4154 .into_iter()
4155 .map(|entry| git::repository::FileHistoryEntry {
4156 sha: entry.sha.into(),
4157 subject: entry.subject.into(),
4158 message: entry.message.into(),
4159 commit_timestamp: entry.commit_timestamp,
4160 author_name: entry.author_name.into(),
4161 author_email: entry.author_email.into(),
4162 })
4163 .collect(),
4164 path: RepoPath::from_proto(&response.path)?,
4165 })
4166 }
4167 }
4168 })
4169 }
4170
4171 fn buffer_store(&self, cx: &App) -> Option<Entity<BufferStore>> {
4172 Some(self.git_store.upgrade()?.read(cx).buffer_store.clone())
4173 }
4174
4175 fn save_buffers<'a>(
4176 &self,
4177 entries: impl IntoIterator<Item = &'a RepoPath>,
4178 cx: &mut Context<Self>,
4179 ) -> Vec<Task<anyhow::Result<()>>> {
4180 let mut save_futures = Vec::new();
4181 if let Some(buffer_store) = self.buffer_store(cx) {
4182 buffer_store.update(cx, |buffer_store, cx| {
4183 for path in entries {
4184 let Some(project_path) = self.repo_path_to_project_path(path, cx) else {
4185 continue;
4186 };
4187 if let Some(buffer) = buffer_store.get_by_path(&project_path)
4188 && buffer
4189 .read(cx)
4190 .file()
4191 .is_some_and(|file| file.disk_state().exists())
4192 && buffer.read(cx).has_unsaved_edits()
4193 {
4194 save_futures.push(buffer_store.save_buffer(buffer, cx));
4195 }
4196 }
4197 })
4198 }
4199 save_futures
4200 }
4201
4202 pub fn stage_entries(
4203 &mut self,
4204 entries: Vec<RepoPath>,
4205 cx: &mut Context<Self>,
4206 ) -> Task<anyhow::Result<()>> {
4207 if entries.is_empty() {
4208 return Task::ready(Ok(()));
4209 }
4210 let id = self.id;
4211 let save_tasks = self.save_buffers(&entries, cx);
4212 let paths = entries
4213 .iter()
4214 .map(|p| p.as_unix_str())
4215 .collect::<Vec<_>>()
4216 .join(" ");
4217 let status = format!("git add {paths}");
4218 let job_key = GitJobKey::WriteIndex(entries.clone());
4219
4220 self.spawn_job_with_tracking(
4221 entries.clone(),
4222 pending_op::GitStatus::Staged,
4223 cx,
4224 async move |this, cx| {
4225 for save_task in save_tasks {
4226 save_task.await?;
4227 }
4228
4229 this.update(cx, |this, _| {
4230 this.send_keyed_job(
4231 Some(job_key),
4232 Some(status.into()),
4233 move |git_repo, _cx| async move {
4234 match git_repo {
4235 RepositoryState::Local(LocalRepositoryState {
4236 backend,
4237 environment,
4238 ..
4239 }) => backend.stage_paths(entries, environment.clone()).await,
4240 RepositoryState::Remote(RemoteRepositoryState {
4241 project_id,
4242 client,
4243 }) => {
4244 client
4245 .request(proto::Stage {
4246 project_id: project_id.0,
4247 repository_id: id.to_proto(),
4248 paths: entries
4249 .into_iter()
4250 .map(|repo_path| repo_path.to_proto())
4251 .collect(),
4252 })
4253 .await
4254 .context("sending stage request")?;
4255
4256 Ok(())
4257 }
4258 }
4259 },
4260 )
4261 })?
4262 .await?
4263 },
4264 )
4265 }
4266
4267 pub fn unstage_entries(
4268 &mut self,
4269 entries: Vec<RepoPath>,
4270 cx: &mut Context<Self>,
4271 ) -> Task<anyhow::Result<()>> {
4272 if entries.is_empty() {
4273 return Task::ready(Ok(()));
4274 }
4275 let id = self.id;
4276 let save_tasks = self.save_buffers(&entries, cx);
4277 let paths = entries
4278 .iter()
4279 .map(|p| p.as_unix_str())
4280 .collect::<Vec<_>>()
4281 .join(" ");
4282 let status = format!("git reset {paths}");
4283 let job_key = GitJobKey::WriteIndex(entries.clone());
4284
4285 self.spawn_job_with_tracking(
4286 entries.clone(),
4287 pending_op::GitStatus::Unstaged,
4288 cx,
4289 async move |this, cx| {
4290 for save_task in save_tasks {
4291 save_task.await?;
4292 }
4293
4294 this.update(cx, |this, _| {
4295 this.send_keyed_job(
4296 Some(job_key),
4297 Some(status.into()),
4298 move |git_repo, _cx| async move {
4299 match git_repo {
4300 RepositoryState::Local(LocalRepositoryState {
4301 backend,
4302 environment,
4303 ..
4304 }) => backend.unstage_paths(entries, environment).await,
4305 RepositoryState::Remote(RemoteRepositoryState {
4306 project_id,
4307 client,
4308 }) => {
4309 client
4310 .request(proto::Unstage {
4311 project_id: project_id.0,
4312 repository_id: id.to_proto(),
4313 paths: entries
4314 .into_iter()
4315 .map(|repo_path| repo_path.to_proto())
4316 .collect(),
4317 })
4318 .await
4319 .context("sending unstage request")?;
4320
4321 Ok(())
4322 }
4323 }
4324 },
4325 )
4326 })?
4327 .await?
4328 },
4329 )
4330 }
4331
4332 pub fn stage_all(&mut self, cx: &mut Context<Self>) -> Task<anyhow::Result<()>> {
4333 let to_stage = self
4334 .cached_status()
4335 .filter_map(|entry| {
4336 if let Some(ops) = self.pending_ops_for_path(&entry.repo_path) {
4337 if ops.staging() || ops.staged() {
4338 None
4339 } else {
4340 Some(entry.repo_path)
4341 }
4342 } else if entry.status.staging().is_fully_staged() {
4343 None
4344 } else {
4345 Some(entry.repo_path)
4346 }
4347 })
4348 .collect();
4349 self.stage_entries(to_stage, cx)
4350 }
4351
4352 pub fn unstage_all(&mut self, cx: &mut Context<Self>) -> Task<anyhow::Result<()>> {
4353 let to_unstage = self
4354 .cached_status()
4355 .filter_map(|entry| {
4356 if let Some(ops) = self.pending_ops_for_path(&entry.repo_path) {
4357 if !ops.staging() && !ops.staged() {
4358 None
4359 } else {
4360 Some(entry.repo_path)
4361 }
4362 } else if entry.status.staging().is_fully_unstaged() {
4363 None
4364 } else {
4365 Some(entry.repo_path)
4366 }
4367 })
4368 .collect();
4369 self.unstage_entries(to_unstage, cx)
4370 }
4371
4372 pub fn stash_all(&mut self, cx: &mut Context<Self>) -> Task<anyhow::Result<()>> {
4373 let to_stash = self.cached_status().map(|entry| entry.repo_path).collect();
4374
4375 self.stash_entries(to_stash, cx)
4376 }
4377
4378 pub fn stash_entries(
4379 &mut self,
4380 entries: Vec<RepoPath>,
4381 cx: &mut Context<Self>,
4382 ) -> Task<anyhow::Result<()>> {
4383 let id = self.id;
4384
4385 cx.spawn(async move |this, cx| {
4386 this.update(cx, |this, _| {
4387 this.send_job(None, move |git_repo, _cx| async move {
4388 match git_repo {
4389 RepositoryState::Local(LocalRepositoryState {
4390 backend,
4391 environment,
4392 ..
4393 }) => backend.stash_paths(entries, environment).await,
4394 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4395 client
4396 .request(proto::Stash {
4397 project_id: project_id.0,
4398 repository_id: id.to_proto(),
4399 paths: entries
4400 .into_iter()
4401 .map(|repo_path| repo_path.to_proto())
4402 .collect(),
4403 })
4404 .await
4405 .context("sending stash request")?;
4406 Ok(())
4407 }
4408 }
4409 })
4410 })?
4411 .await??;
4412 Ok(())
4413 })
4414 }
4415
4416 pub fn stash_pop(
4417 &mut self,
4418 index: Option<usize>,
4419 cx: &mut Context<Self>,
4420 ) -> Task<anyhow::Result<()>> {
4421 let id = self.id;
4422 cx.spawn(async move |this, cx| {
4423 this.update(cx, |this, _| {
4424 this.send_job(None, move |git_repo, _cx| async move {
4425 match git_repo {
4426 RepositoryState::Local(LocalRepositoryState {
4427 backend,
4428 environment,
4429 ..
4430 }) => backend.stash_pop(index, environment).await,
4431 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4432 client
4433 .request(proto::StashPop {
4434 project_id: project_id.0,
4435 repository_id: id.to_proto(),
4436 stash_index: index.map(|i| i as u64),
4437 })
4438 .await
4439 .context("sending stash pop request")?;
4440 Ok(())
4441 }
4442 }
4443 })
4444 })?
4445 .await??;
4446 Ok(())
4447 })
4448 }
4449
4450 pub fn stash_apply(
4451 &mut self,
4452 index: Option<usize>,
4453 cx: &mut Context<Self>,
4454 ) -> Task<anyhow::Result<()>> {
4455 let id = self.id;
4456 cx.spawn(async move |this, cx| {
4457 this.update(cx, |this, _| {
4458 this.send_job(None, move |git_repo, _cx| async move {
4459 match git_repo {
4460 RepositoryState::Local(LocalRepositoryState {
4461 backend,
4462 environment,
4463 ..
4464 }) => backend.stash_apply(index, environment).await,
4465 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4466 client
4467 .request(proto::StashApply {
4468 project_id: project_id.0,
4469 repository_id: id.to_proto(),
4470 stash_index: index.map(|i| i as u64),
4471 })
4472 .await
4473 .context("sending stash apply request")?;
4474 Ok(())
4475 }
4476 }
4477 })
4478 })?
4479 .await??;
4480 Ok(())
4481 })
4482 }
4483
4484 pub fn stash_drop(
4485 &mut self,
4486 index: Option<usize>,
4487 cx: &mut Context<Self>,
4488 ) -> oneshot::Receiver<anyhow::Result<()>> {
4489 let id = self.id;
4490 let updates_tx = self
4491 .git_store()
4492 .and_then(|git_store| match &git_store.read(cx).state {
4493 GitStoreState::Local { downstream, .. } => downstream
4494 .as_ref()
4495 .map(|downstream| downstream.updates_tx.clone()),
4496 _ => None,
4497 });
4498 let this = cx.weak_entity();
4499 self.send_job(None, move |git_repo, mut cx| async move {
4500 match git_repo {
4501 RepositoryState::Local(LocalRepositoryState {
4502 backend,
4503 environment,
4504 ..
4505 }) => {
4506 // TODO would be nice to not have to do this manually
4507 let result = backend.stash_drop(index, environment).await;
4508 if result.is_ok()
4509 && let Ok(stash_entries) = backend.stash_entries().await
4510 {
4511 let snapshot = this.update(&mut cx, |this, cx| {
4512 this.snapshot.stash_entries = stash_entries;
4513 cx.emit(RepositoryEvent::StashEntriesChanged);
4514 this.snapshot.clone()
4515 })?;
4516 if let Some(updates_tx) = updates_tx {
4517 updates_tx
4518 .unbounded_send(DownstreamUpdate::UpdateRepository(snapshot))
4519 .ok();
4520 }
4521 }
4522
4523 result
4524 }
4525 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4526 client
4527 .request(proto::StashDrop {
4528 project_id: project_id.0,
4529 repository_id: id.to_proto(),
4530 stash_index: index.map(|i| i as u64),
4531 })
4532 .await
4533 .context("sending stash pop request")?;
4534 Ok(())
4535 }
4536 }
4537 })
4538 }
4539
4540 pub fn run_hook(&mut self, hook: RunHook, _cx: &mut App) -> oneshot::Receiver<Result<()>> {
4541 let id = self.id;
4542 self.send_job(
4543 Some(format!("git hook {}", hook.as_str()).into()),
4544 move |git_repo, _cx| async move {
4545 match git_repo {
4546 RepositoryState::Local(LocalRepositoryState {
4547 backend,
4548 environment,
4549 ..
4550 }) => backend.run_hook(hook, environment.clone()).await,
4551 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4552 client
4553 .request(proto::RunGitHook {
4554 project_id: project_id.0,
4555 repository_id: id.to_proto(),
4556 hook: hook.to_proto(),
4557 })
4558 .await?;
4559
4560 Ok(())
4561 }
4562 }
4563 },
4564 )
4565 }
4566
4567 pub fn commit(
4568 &mut self,
4569 message: SharedString,
4570 name_and_email: Option<(SharedString, SharedString)>,
4571 options: CommitOptions,
4572 askpass: AskPassDelegate,
4573 cx: &mut App,
4574 ) -> oneshot::Receiver<Result<()>> {
4575 let id = self.id;
4576 let askpass_delegates = self.askpass_delegates.clone();
4577 let askpass_id = util::post_inc(&mut self.latest_askpass_id);
4578
4579 let rx = self.run_hook(RunHook::PreCommit, cx);
4580
4581 self.send_job(Some("git commit".into()), move |git_repo, _cx| async move {
4582 rx.await??;
4583
4584 match git_repo {
4585 RepositoryState::Local(LocalRepositoryState {
4586 backend,
4587 environment,
4588 ..
4589 }) => {
4590 backend
4591 .commit(message, name_and_email, options, askpass, environment)
4592 .await
4593 }
4594 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4595 askpass_delegates.lock().insert(askpass_id, askpass);
4596 let _defer = util::defer(|| {
4597 let askpass_delegate = askpass_delegates.lock().remove(&askpass_id);
4598 debug_assert!(askpass_delegate.is_some());
4599 });
4600 let (name, email) = name_and_email.unzip();
4601 client
4602 .request(proto::Commit {
4603 project_id: project_id.0,
4604 repository_id: id.to_proto(),
4605 message: String::from(message),
4606 name: name.map(String::from),
4607 email: email.map(String::from),
4608 options: Some(proto::commit::CommitOptions {
4609 amend: options.amend,
4610 signoff: options.signoff,
4611 }),
4612 askpass_id,
4613 })
4614 .await
4615 .context("sending commit request")?;
4616
4617 Ok(())
4618 }
4619 }
4620 })
4621 }
4622
4623 pub fn fetch(
4624 &mut self,
4625 fetch_options: FetchOptions,
4626 askpass: AskPassDelegate,
4627 _cx: &mut App,
4628 ) -> oneshot::Receiver<Result<RemoteCommandOutput>> {
4629 let askpass_delegates = self.askpass_delegates.clone();
4630 let askpass_id = util::post_inc(&mut self.latest_askpass_id);
4631 let id = self.id;
4632
4633 self.send_job(Some("git fetch".into()), move |git_repo, cx| async move {
4634 match git_repo {
4635 RepositoryState::Local(LocalRepositoryState {
4636 backend,
4637 environment,
4638 ..
4639 }) => backend.fetch(fetch_options, askpass, environment, cx).await,
4640 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4641 askpass_delegates.lock().insert(askpass_id, askpass);
4642 let _defer = util::defer(|| {
4643 let askpass_delegate = askpass_delegates.lock().remove(&askpass_id);
4644 debug_assert!(askpass_delegate.is_some());
4645 });
4646
4647 let response = client
4648 .request(proto::Fetch {
4649 project_id: project_id.0,
4650 repository_id: id.to_proto(),
4651 askpass_id,
4652 remote: fetch_options.to_proto(),
4653 })
4654 .await
4655 .context("sending fetch request")?;
4656
4657 Ok(RemoteCommandOutput {
4658 stdout: response.stdout,
4659 stderr: response.stderr,
4660 })
4661 }
4662 }
4663 })
4664 }
4665
4666 pub fn push(
4667 &mut self,
4668 branch: SharedString,
4669 remote: SharedString,
4670 options: Option<PushOptions>,
4671 askpass: AskPassDelegate,
4672 cx: &mut Context<Self>,
4673 ) -> oneshot::Receiver<Result<RemoteCommandOutput>> {
4674 let askpass_delegates = self.askpass_delegates.clone();
4675 let askpass_id = util::post_inc(&mut self.latest_askpass_id);
4676 let id = self.id;
4677
4678 let args = options
4679 .map(|option| match option {
4680 PushOptions::SetUpstream => " --set-upstream",
4681 PushOptions::Force => " --force-with-lease",
4682 })
4683 .unwrap_or("");
4684
4685 let updates_tx = self
4686 .git_store()
4687 .and_then(|git_store| match &git_store.read(cx).state {
4688 GitStoreState::Local { downstream, .. } => downstream
4689 .as_ref()
4690 .map(|downstream| downstream.updates_tx.clone()),
4691 _ => None,
4692 });
4693
4694 let this = cx.weak_entity();
4695 let rx = self.run_hook(RunHook::PrePush, cx);
4696 self.send_job(
4697 Some(format!("git push {} {} {}", args, remote, branch).into()),
4698 move |git_repo, mut cx| async move {
4699 rx.await??;
4700 match git_repo {
4701 RepositoryState::Local(LocalRepositoryState {
4702 backend,
4703 environment,
4704 ..
4705 }) => {
4706 let result = backend
4707 .push(
4708 branch.to_string(),
4709 remote.to_string(),
4710 options,
4711 askpass,
4712 environment.clone(),
4713 cx.clone(),
4714 )
4715 .await;
4716 // TODO would be nice to not have to do this manually
4717 if result.is_ok() {
4718 let branches = backend.branches().await?;
4719 let branch = branches.into_iter().find(|branch| branch.is_head);
4720 log::info!("head branch after scan is {branch:?}");
4721 let snapshot = this.update(&mut cx, |this, cx| {
4722 this.snapshot.branch = branch;
4723 cx.emit(RepositoryEvent::BranchChanged);
4724 this.snapshot.clone()
4725 })?;
4726 if let Some(updates_tx) = updates_tx {
4727 updates_tx
4728 .unbounded_send(DownstreamUpdate::UpdateRepository(snapshot))
4729 .ok();
4730 }
4731 }
4732 result
4733 }
4734 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4735 askpass_delegates.lock().insert(askpass_id, askpass);
4736 let _defer = util::defer(|| {
4737 let askpass_delegate = askpass_delegates.lock().remove(&askpass_id);
4738 debug_assert!(askpass_delegate.is_some());
4739 });
4740 let response = client
4741 .request(proto::Push {
4742 project_id: project_id.0,
4743 repository_id: id.to_proto(),
4744 askpass_id,
4745 branch_name: branch.to_string(),
4746 remote_name: remote.to_string(),
4747 options: options.map(|options| match options {
4748 PushOptions::Force => proto::push::PushOptions::Force,
4749 PushOptions::SetUpstream => {
4750 proto::push::PushOptions::SetUpstream
4751 }
4752 }
4753 as i32),
4754 })
4755 .await
4756 .context("sending push request")?;
4757
4758 Ok(RemoteCommandOutput {
4759 stdout: response.stdout,
4760 stderr: response.stderr,
4761 })
4762 }
4763 }
4764 },
4765 )
4766 }
4767
4768 pub fn pull(
4769 &mut self,
4770 branch: Option<SharedString>,
4771 remote: SharedString,
4772 rebase: bool,
4773 askpass: AskPassDelegate,
4774 _cx: &mut App,
4775 ) -> oneshot::Receiver<Result<RemoteCommandOutput>> {
4776 let askpass_delegates = self.askpass_delegates.clone();
4777 let askpass_id = util::post_inc(&mut self.latest_askpass_id);
4778 let id = self.id;
4779
4780 let mut status = "git pull".to_string();
4781 if rebase {
4782 status.push_str(" --rebase");
4783 }
4784 status.push_str(&format!(" {}", remote));
4785 if let Some(b) = &branch {
4786 status.push_str(&format!(" {}", b));
4787 }
4788
4789 self.send_job(Some(status.into()), move |git_repo, cx| async move {
4790 match git_repo {
4791 RepositoryState::Local(LocalRepositoryState {
4792 backend,
4793 environment,
4794 ..
4795 }) => {
4796 backend
4797 .pull(
4798 branch.as_ref().map(|b| b.to_string()),
4799 remote.to_string(),
4800 rebase,
4801 askpass,
4802 environment.clone(),
4803 cx,
4804 )
4805 .await
4806 }
4807 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4808 askpass_delegates.lock().insert(askpass_id, askpass);
4809 let _defer = util::defer(|| {
4810 let askpass_delegate = askpass_delegates.lock().remove(&askpass_id);
4811 debug_assert!(askpass_delegate.is_some());
4812 });
4813 let response = client
4814 .request(proto::Pull {
4815 project_id: project_id.0,
4816 repository_id: id.to_proto(),
4817 askpass_id,
4818 rebase,
4819 branch_name: branch.as_ref().map(|b| b.to_string()),
4820 remote_name: remote.to_string(),
4821 })
4822 .await
4823 .context("sending pull request")?;
4824
4825 Ok(RemoteCommandOutput {
4826 stdout: response.stdout,
4827 stderr: response.stderr,
4828 })
4829 }
4830 }
4831 })
4832 }
4833
4834 fn spawn_set_index_text_job(
4835 &mut self,
4836 path: RepoPath,
4837 content: Option<String>,
4838 hunk_staging_operation_count: Option<usize>,
4839 cx: &mut Context<Self>,
4840 ) -> oneshot::Receiver<anyhow::Result<()>> {
4841 let id = self.id;
4842 let this = cx.weak_entity();
4843 let git_store = self.git_store.clone();
4844 let abs_path = self.snapshot.repo_path_to_abs_path(&path);
4845 self.send_keyed_job(
4846 Some(GitJobKey::WriteIndex(vec![path.clone()])),
4847 None,
4848 move |git_repo, mut cx| async move {
4849 log::debug!(
4850 "start updating index text for buffer {}",
4851 path.as_unix_str()
4852 );
4853
4854 match git_repo {
4855 RepositoryState::Local(LocalRepositoryState {
4856 fs,
4857 backend,
4858 environment,
4859 ..
4860 }) => {
4861 let executable = match fs.metadata(&abs_path).await {
4862 Ok(Some(meta)) => meta.is_executable,
4863 Ok(None) => false,
4864 Err(_err) => false,
4865 };
4866 backend
4867 .set_index_text(path.clone(), content, environment.clone(), executable)
4868 .await?;
4869 }
4870 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4871 client
4872 .request(proto::SetIndexText {
4873 project_id: project_id.0,
4874 repository_id: id.to_proto(),
4875 path: path.to_proto(),
4876 text: content,
4877 })
4878 .await?;
4879 }
4880 }
4881 log::debug!(
4882 "finish updating index text for buffer {}",
4883 path.as_unix_str()
4884 );
4885
4886 if let Some(hunk_staging_operation_count) = hunk_staging_operation_count {
4887 let project_path = this
4888 .read_with(&cx, |this, cx| this.repo_path_to_project_path(&path, cx))
4889 .ok()
4890 .flatten();
4891 git_store.update(&mut cx, |git_store, cx| {
4892 let buffer_id = git_store
4893 .buffer_store
4894 .read(cx)
4895 .get_by_path(&project_path?)?
4896 .read(cx)
4897 .remote_id();
4898 let diff_state = git_store.diffs.get(&buffer_id)?;
4899 diff_state.update(cx, |diff_state, _| {
4900 diff_state.hunk_staging_operation_count_as_of_write =
4901 hunk_staging_operation_count;
4902 });
4903 Some(())
4904 })?;
4905 }
4906 Ok(())
4907 },
4908 )
4909 }
4910
4911 pub fn create_remote(
4912 &mut self,
4913 remote_name: String,
4914 remote_url: String,
4915 ) -> oneshot::Receiver<Result<()>> {
4916 let id = self.id;
4917 self.send_job(
4918 Some(format!("git remote add {remote_name} {remote_url}").into()),
4919 move |repo, _cx| async move {
4920 match repo {
4921 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
4922 backend.create_remote(remote_name, remote_url).await
4923 }
4924 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4925 client
4926 .request(proto::GitCreateRemote {
4927 project_id: project_id.0,
4928 repository_id: id.to_proto(),
4929 remote_name,
4930 remote_url,
4931 })
4932 .await?;
4933
4934 Ok(())
4935 }
4936 }
4937 },
4938 )
4939 }
4940
4941 pub fn remove_remote(&mut self, remote_name: String) -> oneshot::Receiver<Result<()>> {
4942 let id = self.id;
4943 self.send_job(
4944 Some(format!("git remove remote {remote_name}").into()),
4945 move |repo, _cx| async move {
4946 match repo {
4947 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
4948 backend.remove_remote(remote_name).await
4949 }
4950 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4951 client
4952 .request(proto::GitRemoveRemote {
4953 project_id: project_id.0,
4954 repository_id: id.to_proto(),
4955 remote_name,
4956 })
4957 .await?;
4958
4959 Ok(())
4960 }
4961 }
4962 },
4963 )
4964 }
4965
4966 pub fn get_remotes(
4967 &mut self,
4968 branch_name: Option<String>,
4969 is_push: bool,
4970 ) -> oneshot::Receiver<Result<Vec<Remote>>> {
4971 let id = self.id;
4972 self.send_job(None, move |repo, _cx| async move {
4973 match repo {
4974 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
4975 let remote = if let Some(branch_name) = branch_name {
4976 if is_push {
4977 backend.get_push_remote(branch_name).await?
4978 } else {
4979 backend.get_branch_remote(branch_name).await?
4980 }
4981 } else {
4982 None
4983 };
4984
4985 match remote {
4986 Some(remote) => Ok(vec![remote]),
4987 None => backend.get_all_remotes().await,
4988 }
4989 }
4990 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
4991 let response = client
4992 .request(proto::GetRemotes {
4993 project_id: project_id.0,
4994 repository_id: id.to_proto(),
4995 branch_name,
4996 is_push,
4997 })
4998 .await?;
4999
5000 let remotes = response
5001 .remotes
5002 .into_iter()
5003 .map(|remotes| Remote {
5004 name: remotes.name.into(),
5005 })
5006 .collect();
5007
5008 Ok(remotes)
5009 }
5010 }
5011 })
5012 }
5013
5014 pub fn branches(&mut self) -> oneshot::Receiver<Result<Vec<Branch>>> {
5015 let id = self.id;
5016 self.send_job(None, move |repo, _| async move {
5017 match repo {
5018 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5019 backend.branches().await
5020 }
5021 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5022 let response = client
5023 .request(proto::GitGetBranches {
5024 project_id: project_id.0,
5025 repository_id: id.to_proto(),
5026 })
5027 .await?;
5028
5029 let branches = response
5030 .branches
5031 .into_iter()
5032 .map(|branch| proto_to_branch(&branch))
5033 .collect();
5034
5035 Ok(branches)
5036 }
5037 }
5038 })
5039 }
5040
5041 pub fn worktrees(&mut self) -> oneshot::Receiver<Result<Vec<GitWorktree>>> {
5042 let id = self.id;
5043 self.send_job(None, move |repo, _| async move {
5044 match repo {
5045 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5046 backend.worktrees().await
5047 }
5048 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5049 let response = client
5050 .request(proto::GitGetWorktrees {
5051 project_id: project_id.0,
5052 repository_id: id.to_proto(),
5053 })
5054 .await?;
5055
5056 let worktrees = response
5057 .worktrees
5058 .into_iter()
5059 .map(|worktree| proto_to_worktree(&worktree))
5060 .collect();
5061
5062 Ok(worktrees)
5063 }
5064 }
5065 })
5066 }
5067
5068 pub fn create_worktree(
5069 &mut self,
5070 name: String,
5071 path: PathBuf,
5072 commit: Option<String>,
5073 ) -> oneshot::Receiver<Result<()>> {
5074 let id = self.id;
5075 self.send_job(
5076 Some("git worktree add".into()),
5077 move |repo, _cx| async move {
5078 match repo {
5079 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5080 backend.create_worktree(name, path, commit).await
5081 }
5082 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5083 client
5084 .request(proto::GitCreateWorktree {
5085 project_id: project_id.0,
5086 repository_id: id.to_proto(),
5087 name,
5088 directory: path.to_string_lossy().to_string(),
5089 commit,
5090 })
5091 .await?;
5092
5093 Ok(())
5094 }
5095 }
5096 },
5097 )
5098 }
5099
5100 pub fn default_branch(&mut self) -> oneshot::Receiver<Result<Option<SharedString>>> {
5101 let id = self.id;
5102 self.send_job(None, move |repo, _| async move {
5103 match repo {
5104 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5105 backend.default_branch().await
5106 }
5107 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5108 let response = client
5109 .request(proto::GetDefaultBranch {
5110 project_id: project_id.0,
5111 repository_id: id.to_proto(),
5112 })
5113 .await?;
5114
5115 anyhow::Ok(response.branch.map(SharedString::from))
5116 }
5117 }
5118 })
5119 }
5120
5121 pub fn diff_tree(
5122 &mut self,
5123 diff_type: DiffTreeType,
5124 _cx: &App,
5125 ) -> oneshot::Receiver<Result<TreeDiff>> {
5126 let repository_id = self.snapshot.id;
5127 self.send_job(None, move |repo, _cx| async move {
5128 match repo {
5129 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5130 backend.diff_tree(diff_type).await
5131 }
5132 RepositoryState::Remote(RemoteRepositoryState { client, project_id }) => {
5133 let response = client
5134 .request(proto::GetTreeDiff {
5135 project_id: project_id.0,
5136 repository_id: repository_id.0,
5137 is_merge: matches!(diff_type, DiffTreeType::MergeBase { .. }),
5138 base: diff_type.base().to_string(),
5139 head: diff_type.head().to_string(),
5140 })
5141 .await?;
5142
5143 let entries = response
5144 .entries
5145 .into_iter()
5146 .filter_map(|entry| {
5147 let status = match entry.status() {
5148 proto::tree_diff_status::Status::Added => TreeDiffStatus::Added,
5149 proto::tree_diff_status::Status::Modified => {
5150 TreeDiffStatus::Modified {
5151 old: git::Oid::from_str(
5152 &entry.oid.context("missing oid").log_err()?,
5153 )
5154 .log_err()?,
5155 }
5156 }
5157 proto::tree_diff_status::Status::Deleted => {
5158 TreeDiffStatus::Deleted {
5159 old: git::Oid::from_str(
5160 &entry.oid.context("missing oid").log_err()?,
5161 )
5162 .log_err()?,
5163 }
5164 }
5165 };
5166 Some((
5167 RepoPath::from_rel_path(
5168 &RelPath::from_proto(&entry.path).log_err()?,
5169 ),
5170 status,
5171 ))
5172 })
5173 .collect();
5174
5175 Ok(TreeDiff { entries })
5176 }
5177 }
5178 })
5179 }
5180
5181 pub fn diff(&mut self, diff_type: DiffType, _cx: &App) -> oneshot::Receiver<Result<String>> {
5182 let id = self.id;
5183 self.send_job(None, move |repo, _cx| async move {
5184 match repo {
5185 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5186 backend.diff(diff_type).await
5187 }
5188 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5189 let response = client
5190 .request(proto::GitDiff {
5191 project_id: project_id.0,
5192 repository_id: id.to_proto(),
5193 diff_type: match diff_type {
5194 DiffType::HeadToIndex => {
5195 proto::git_diff::DiffType::HeadToIndex.into()
5196 }
5197 DiffType::HeadToWorktree => {
5198 proto::git_diff::DiffType::HeadToWorktree.into()
5199 }
5200 },
5201 })
5202 .await?;
5203
5204 Ok(response.diff)
5205 }
5206 }
5207 })
5208 }
5209
5210 pub fn create_branch(
5211 &mut self,
5212 branch_name: String,
5213 base_branch: Option<String>,
5214 ) -> oneshot::Receiver<Result<()>> {
5215 let id = self.id;
5216 let status_msg = if let Some(ref base) = base_branch {
5217 format!("git switch -c {branch_name} {base}").into()
5218 } else {
5219 format!("git switch -c {branch_name}").into()
5220 };
5221 self.send_job(Some(status_msg), move |repo, _cx| async move {
5222 match repo {
5223 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5224 backend.create_branch(branch_name, base_branch).await
5225 }
5226 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5227 client
5228 .request(proto::GitCreateBranch {
5229 project_id: project_id.0,
5230 repository_id: id.to_proto(),
5231 branch_name,
5232 })
5233 .await?;
5234
5235 Ok(())
5236 }
5237 }
5238 })
5239 }
5240
5241 pub fn change_branch(&mut self, branch_name: String) -> oneshot::Receiver<Result<()>> {
5242 let id = self.id;
5243 self.send_job(
5244 Some(format!("git switch {branch_name}").into()),
5245 move |repo, _cx| async move {
5246 match repo {
5247 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5248 backend.change_branch(branch_name).await
5249 }
5250 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5251 client
5252 .request(proto::GitChangeBranch {
5253 project_id: project_id.0,
5254 repository_id: id.to_proto(),
5255 branch_name,
5256 })
5257 .await?;
5258
5259 Ok(())
5260 }
5261 }
5262 },
5263 )
5264 }
5265
5266 pub fn delete_branch(&mut self, branch_name: String) -> oneshot::Receiver<Result<()>> {
5267 let id = self.id;
5268 self.send_job(
5269 Some(format!("git branch -d {branch_name}").into()),
5270 move |repo, _cx| async move {
5271 match repo {
5272 RepositoryState::Local(state) => state.backend.delete_branch(branch_name).await,
5273 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5274 client
5275 .request(proto::GitDeleteBranch {
5276 project_id: project_id.0,
5277 repository_id: id.to_proto(),
5278 branch_name,
5279 })
5280 .await?;
5281
5282 Ok(())
5283 }
5284 }
5285 },
5286 )
5287 }
5288
5289 pub fn rename_branch(
5290 &mut self,
5291 branch: String,
5292 new_name: String,
5293 ) -> oneshot::Receiver<Result<()>> {
5294 let id = self.id;
5295 self.send_job(
5296 Some(format!("git branch -m {branch} {new_name}").into()),
5297 move |repo, _cx| async move {
5298 match repo {
5299 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5300 backend.rename_branch(branch, new_name).await
5301 }
5302 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5303 client
5304 .request(proto::GitRenameBranch {
5305 project_id: project_id.0,
5306 repository_id: id.to_proto(),
5307 branch,
5308 new_name,
5309 })
5310 .await?;
5311
5312 Ok(())
5313 }
5314 }
5315 },
5316 )
5317 }
5318
5319 pub fn check_for_pushed_commits(&mut self) -> oneshot::Receiver<Result<Vec<SharedString>>> {
5320 let id = self.id;
5321 self.send_job(None, move |repo, _cx| async move {
5322 match repo {
5323 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5324 backend.check_for_pushed_commit().await
5325 }
5326 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5327 let response = client
5328 .request(proto::CheckForPushedCommits {
5329 project_id: project_id.0,
5330 repository_id: id.to_proto(),
5331 })
5332 .await?;
5333
5334 let branches = response.pushed_to.into_iter().map(Into::into).collect();
5335
5336 Ok(branches)
5337 }
5338 }
5339 })
5340 }
5341
5342 pub fn checkpoint(&mut self) -> oneshot::Receiver<Result<GitRepositoryCheckpoint>> {
5343 self.send_job(None, |repo, _cx| async move {
5344 match repo {
5345 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5346 backend.checkpoint().await
5347 }
5348 RepositoryState::Remote(..) => anyhow::bail!("not implemented yet"),
5349 }
5350 })
5351 }
5352
5353 pub fn restore_checkpoint(
5354 &mut self,
5355 checkpoint: GitRepositoryCheckpoint,
5356 ) -> oneshot::Receiver<Result<()>> {
5357 self.send_job(None, move |repo, _cx| async move {
5358 match repo {
5359 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5360 backend.restore_checkpoint(checkpoint).await
5361 }
5362 RepositoryState::Remote { .. } => anyhow::bail!("not implemented yet"),
5363 }
5364 })
5365 }
5366
5367 pub(crate) fn apply_remote_update(
5368 &mut self,
5369 update: proto::UpdateRepository,
5370 cx: &mut Context<Self>,
5371 ) -> Result<()> {
5372 let conflicted_paths = TreeSet::from_ordered_entries(
5373 update
5374 .current_merge_conflicts
5375 .into_iter()
5376 .filter_map(|path| RepoPath::from_proto(&path).log_err()),
5377 );
5378 let new_branch = update.branch_summary.as_ref().map(proto_to_branch);
5379 let new_head_commit = update
5380 .head_commit_details
5381 .as_ref()
5382 .map(proto_to_commit_details);
5383 if self.snapshot.branch != new_branch || self.snapshot.head_commit != new_head_commit {
5384 cx.emit(RepositoryEvent::BranchChanged)
5385 }
5386 self.snapshot.branch = new_branch;
5387 self.snapshot.head_commit = new_head_commit;
5388
5389 self.snapshot.merge.conflicted_paths = conflicted_paths;
5390 self.snapshot.merge.message = update.merge_message.map(SharedString::from);
5391 let new_stash_entries = GitStash {
5392 entries: update
5393 .stash_entries
5394 .iter()
5395 .filter_map(|entry| proto_to_stash(entry).ok())
5396 .collect(),
5397 };
5398 if self.snapshot.stash_entries != new_stash_entries {
5399 cx.emit(RepositoryEvent::StashEntriesChanged)
5400 }
5401 self.snapshot.stash_entries = new_stash_entries;
5402 self.snapshot.remote_upstream_url = update.remote_upstream_url;
5403 self.snapshot.remote_origin_url = update.remote_origin_url;
5404
5405 let edits = update
5406 .removed_statuses
5407 .into_iter()
5408 .filter_map(|path| {
5409 Some(sum_tree::Edit::Remove(PathKey(
5410 RelPath::from_proto(&path).log_err()?,
5411 )))
5412 })
5413 .chain(
5414 update
5415 .updated_statuses
5416 .into_iter()
5417 .filter_map(|updated_status| {
5418 Some(sum_tree::Edit::Insert(updated_status.try_into().log_err()?))
5419 }),
5420 )
5421 .collect::<Vec<_>>();
5422 if !edits.is_empty() {
5423 cx.emit(RepositoryEvent::StatusesChanged);
5424 }
5425 self.snapshot.statuses_by_path.edit(edits, ());
5426 if update.is_last_update {
5427 self.snapshot.scan_id = update.scan_id;
5428 }
5429 self.clear_pending_ops(cx);
5430 Ok(())
5431 }
5432
5433 pub fn compare_checkpoints(
5434 &mut self,
5435 left: GitRepositoryCheckpoint,
5436 right: GitRepositoryCheckpoint,
5437 ) -> oneshot::Receiver<Result<bool>> {
5438 self.send_job(None, move |repo, _cx| async move {
5439 match repo {
5440 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5441 backend.compare_checkpoints(left, right).await
5442 }
5443 RepositoryState::Remote { .. } => anyhow::bail!("not implemented yet"),
5444 }
5445 })
5446 }
5447
5448 pub fn diff_checkpoints(
5449 &mut self,
5450 base_checkpoint: GitRepositoryCheckpoint,
5451 target_checkpoint: GitRepositoryCheckpoint,
5452 ) -> oneshot::Receiver<Result<String>> {
5453 self.send_job(None, move |repo, _cx| async move {
5454 match repo {
5455 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5456 backend
5457 .diff_checkpoints(base_checkpoint, target_checkpoint)
5458 .await
5459 }
5460 RepositoryState::Remote { .. } => anyhow::bail!("not implemented yet"),
5461 }
5462 })
5463 }
5464
5465 fn clear_pending_ops(&mut self, cx: &mut Context<Self>) {
5466 let updated = SumTree::from_iter(
5467 self.pending_ops.iter().filter_map(|ops| {
5468 let inner_ops: Vec<PendingOp> =
5469 ops.ops.iter().filter(|op| op.running()).cloned().collect();
5470 if inner_ops.is_empty() {
5471 None
5472 } else {
5473 Some(PendingOps {
5474 repo_path: ops.repo_path.clone(),
5475 ops: inner_ops,
5476 })
5477 }
5478 }),
5479 (),
5480 );
5481
5482 if updated != self.pending_ops {
5483 cx.emit(RepositoryEvent::PendingOpsChanged {
5484 pending_ops: self.pending_ops.clone(),
5485 })
5486 }
5487
5488 self.pending_ops = updated;
5489 }
5490
5491 fn schedule_scan(
5492 &mut self,
5493 updates_tx: Option<mpsc::UnboundedSender<DownstreamUpdate>>,
5494 cx: &mut Context<Self>,
5495 ) {
5496 let this = cx.weak_entity();
5497 let _ = self.send_keyed_job(
5498 Some(GitJobKey::ReloadGitState),
5499 None,
5500 |state, mut cx| async move {
5501 log::debug!("run scheduled git status scan");
5502
5503 let Some(this) = this.upgrade() else {
5504 return Ok(());
5505 };
5506 let RepositoryState::Local(LocalRepositoryState { backend, .. }) = state else {
5507 bail!("not a local repository")
5508 };
5509 let (snapshot, events) = this
5510 .update(&mut cx, |this, _| {
5511 this.paths_needing_status_update.clear();
5512 compute_snapshot(
5513 this.id,
5514 this.work_directory_abs_path.clone(),
5515 this.snapshot.clone(),
5516 backend.clone(),
5517 )
5518 })?
5519 .await?;
5520 this.update(&mut cx, |this, cx| {
5521 this.snapshot = snapshot.clone();
5522 this.clear_pending_ops(cx);
5523 for event in events {
5524 cx.emit(event);
5525 }
5526 })?;
5527 if let Some(updates_tx) = updates_tx {
5528 updates_tx
5529 .unbounded_send(DownstreamUpdate::UpdateRepository(snapshot))
5530 .ok();
5531 }
5532 Ok(())
5533 },
5534 );
5535 }
5536
5537 fn spawn_local_git_worker(
5538 state: Shared<Task<Result<LocalRepositoryState, String>>>,
5539 cx: &mut Context<Self>,
5540 ) -> mpsc::UnboundedSender<GitJob> {
5541 let (job_tx, mut job_rx) = mpsc::unbounded::<GitJob>();
5542
5543 cx.spawn(async move |_, cx| {
5544 let state = state.await.map_err(|err| anyhow::anyhow!(err))?;
5545 if let Some(git_hosting_provider_registry) =
5546 cx.update(|cx| GitHostingProviderRegistry::try_global(cx))?
5547 {
5548 git_hosting_providers::register_additional_providers(
5549 git_hosting_provider_registry,
5550 state.backend.clone(),
5551 )
5552 .await;
5553 }
5554 let state = RepositoryState::Local(state);
5555 let mut jobs = VecDeque::new();
5556 loop {
5557 while let Ok(Some(next_job)) = job_rx.try_next() {
5558 jobs.push_back(next_job);
5559 }
5560
5561 if let Some(job) = jobs.pop_front() {
5562 if let Some(current_key) = &job.key
5563 && jobs
5564 .iter()
5565 .any(|other_job| other_job.key.as_ref() == Some(current_key))
5566 {
5567 continue;
5568 }
5569 (job.job)(state.clone(), cx).await;
5570 } else if let Some(job) = job_rx.next().await {
5571 jobs.push_back(job);
5572 } else {
5573 break;
5574 }
5575 }
5576 anyhow::Ok(())
5577 })
5578 .detach_and_log_err(cx);
5579
5580 job_tx
5581 }
5582
5583 fn spawn_remote_git_worker(
5584 state: RemoteRepositoryState,
5585 cx: &mut Context<Self>,
5586 ) -> mpsc::UnboundedSender<GitJob> {
5587 let (job_tx, mut job_rx) = mpsc::unbounded::<GitJob>();
5588
5589 cx.spawn(async move |_, cx| {
5590 let state = RepositoryState::Remote(state);
5591 let mut jobs = VecDeque::new();
5592 loop {
5593 while let Ok(Some(next_job)) = job_rx.try_next() {
5594 jobs.push_back(next_job);
5595 }
5596
5597 if let Some(job) = jobs.pop_front() {
5598 if let Some(current_key) = &job.key
5599 && jobs
5600 .iter()
5601 .any(|other_job| other_job.key.as_ref() == Some(current_key))
5602 {
5603 continue;
5604 }
5605 (job.job)(state.clone(), cx).await;
5606 } else if let Some(job) = job_rx.next().await {
5607 jobs.push_back(job);
5608 } else {
5609 break;
5610 }
5611 }
5612 anyhow::Ok(())
5613 })
5614 .detach_and_log_err(cx);
5615
5616 job_tx
5617 }
5618
5619 fn load_staged_text(
5620 &mut self,
5621 buffer_id: BufferId,
5622 repo_path: RepoPath,
5623 cx: &App,
5624 ) -> Task<Result<Option<String>>> {
5625 let rx = self.send_job(None, move |state, _| async move {
5626 match state {
5627 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5628 anyhow::Ok(backend.load_index_text(repo_path).await)
5629 }
5630 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5631 let response = client
5632 .request(proto::OpenUnstagedDiff {
5633 project_id: project_id.to_proto(),
5634 buffer_id: buffer_id.to_proto(),
5635 })
5636 .await?;
5637 Ok(response.staged_text)
5638 }
5639 }
5640 });
5641 cx.spawn(|_: &mut AsyncApp| async move { rx.await? })
5642 }
5643
5644 fn load_committed_text(
5645 &mut self,
5646 buffer_id: BufferId,
5647 repo_path: RepoPath,
5648 cx: &App,
5649 ) -> Task<Result<DiffBasesChange>> {
5650 let rx = self.send_job(None, move |state, _| async move {
5651 match state {
5652 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5653 let committed_text = backend.load_committed_text(repo_path.clone()).await;
5654 let staged_text = backend.load_index_text(repo_path).await;
5655 let diff_bases_change = if committed_text == staged_text {
5656 DiffBasesChange::SetBoth(committed_text)
5657 } else {
5658 DiffBasesChange::SetEach {
5659 index: staged_text,
5660 head: committed_text,
5661 }
5662 };
5663 anyhow::Ok(diff_bases_change)
5664 }
5665 RepositoryState::Remote(RemoteRepositoryState { project_id, client }) => {
5666 use proto::open_uncommitted_diff_response::Mode;
5667
5668 let response = client
5669 .request(proto::OpenUncommittedDiff {
5670 project_id: project_id.to_proto(),
5671 buffer_id: buffer_id.to_proto(),
5672 })
5673 .await?;
5674 let mode = Mode::from_i32(response.mode).context("Invalid mode")?;
5675 let bases = match mode {
5676 Mode::IndexMatchesHead => DiffBasesChange::SetBoth(response.committed_text),
5677 Mode::IndexAndHead => DiffBasesChange::SetEach {
5678 head: response.committed_text,
5679 index: response.staged_text,
5680 },
5681 };
5682 Ok(bases)
5683 }
5684 }
5685 });
5686
5687 cx.spawn(|_: &mut AsyncApp| async move { rx.await? })
5688 }
5689 fn load_blob_content(&mut self, oid: Oid, cx: &App) -> Task<Result<String>> {
5690 let repository_id = self.snapshot.id;
5691 let rx = self.send_job(None, move |state, _| async move {
5692 match state {
5693 RepositoryState::Local(LocalRepositoryState { backend, .. }) => {
5694 backend.load_blob_content(oid).await
5695 }
5696 RepositoryState::Remote(RemoteRepositoryState { client, project_id }) => {
5697 let response = client
5698 .request(proto::GetBlobContent {
5699 project_id: project_id.to_proto(),
5700 repository_id: repository_id.0,
5701 oid: oid.to_string(),
5702 })
5703 .await?;
5704 Ok(response.content)
5705 }
5706 }
5707 });
5708 cx.spawn(|_: &mut AsyncApp| async move { rx.await? })
5709 }
5710
5711 fn paths_changed(
5712 &mut self,
5713 paths: Vec<RepoPath>,
5714 updates_tx: Option<mpsc::UnboundedSender<DownstreamUpdate>>,
5715 cx: &mut Context<Self>,
5716 ) {
5717 self.paths_needing_status_update.extend(paths);
5718
5719 let this = cx.weak_entity();
5720 let _ = self.send_keyed_job(
5721 Some(GitJobKey::RefreshStatuses),
5722 None,
5723 |state, mut cx| async move {
5724 let (prev_snapshot, mut changed_paths) = this.update(&mut cx, |this, _| {
5725 (
5726 this.snapshot.clone(),
5727 mem::take(&mut this.paths_needing_status_update),
5728 )
5729 })?;
5730 let RepositoryState::Local(LocalRepositoryState { backend, .. }) = state else {
5731 bail!("not a local repository")
5732 };
5733
5734 let paths = changed_paths.iter().cloned().collect::<Vec<_>>();
5735 if paths.is_empty() {
5736 return Ok(());
5737 }
5738 let statuses = backend.status(&paths).await?;
5739 let stash_entries = backend.stash_entries().await?;
5740
5741 let changed_path_statuses = cx
5742 .background_spawn(async move {
5743 let mut changed_path_statuses = Vec::new();
5744 let prev_statuses = prev_snapshot.statuses_by_path.clone();
5745 let mut cursor = prev_statuses.cursor::<PathProgress>(());
5746
5747 for (repo_path, status) in &*statuses.entries {
5748 changed_paths.remove(repo_path);
5749 if cursor.seek_forward(&PathTarget::Path(repo_path), Bias::Left)
5750 && cursor.item().is_some_and(|entry| entry.status == *status)
5751 {
5752 continue;
5753 }
5754
5755 changed_path_statuses.push(Edit::Insert(StatusEntry {
5756 repo_path: repo_path.clone(),
5757 status: *status,
5758 }));
5759 }
5760 let mut cursor = prev_statuses.cursor::<PathProgress>(());
5761 for path in changed_paths.into_iter() {
5762 if cursor.seek_forward(&PathTarget::Path(&path), Bias::Left) {
5763 changed_path_statuses
5764 .push(Edit::Remove(PathKey(path.as_ref().clone())));
5765 }
5766 }
5767 changed_path_statuses
5768 })
5769 .await;
5770
5771 this.update(&mut cx, |this, cx| {
5772 if this.snapshot.stash_entries != stash_entries {
5773 cx.emit(RepositoryEvent::StashEntriesChanged);
5774 this.snapshot.stash_entries = stash_entries;
5775 }
5776
5777 if !changed_path_statuses.is_empty() {
5778 cx.emit(RepositoryEvent::StatusesChanged);
5779 this.snapshot
5780 .statuses_by_path
5781 .edit(changed_path_statuses, ());
5782 this.snapshot.scan_id += 1;
5783 }
5784
5785 if let Some(updates_tx) = updates_tx {
5786 updates_tx
5787 .unbounded_send(DownstreamUpdate::UpdateRepository(
5788 this.snapshot.clone(),
5789 ))
5790 .ok();
5791 }
5792 })
5793 },
5794 );
5795 }
5796
5797 /// currently running git command and when it started
5798 pub fn current_job(&self) -> Option<JobInfo> {
5799 self.active_jobs.values().next().cloned()
5800 }
5801
5802 pub fn barrier(&mut self) -> oneshot::Receiver<()> {
5803 self.send_job(None, |_, _| async {})
5804 }
5805
5806 fn spawn_job_with_tracking<AsyncFn>(
5807 &mut self,
5808 paths: Vec<RepoPath>,
5809 git_status: pending_op::GitStatus,
5810 cx: &mut Context<Self>,
5811 f: AsyncFn,
5812 ) -> Task<Result<()>>
5813 where
5814 AsyncFn: AsyncFnOnce(WeakEntity<Repository>, &mut AsyncApp) -> Result<()> + 'static,
5815 {
5816 let ids = self.new_pending_ops_for_paths(paths, git_status);
5817
5818 cx.spawn(async move |this, cx| {
5819 let (job_status, result) = match f(this.clone(), cx).await {
5820 Ok(()) => (pending_op::JobStatus::Finished, Ok(())),
5821 Err(err) if err.is::<Canceled>() => (pending_op::JobStatus::Skipped, Ok(())),
5822 Err(err) => (pending_op::JobStatus::Error, Err(err)),
5823 };
5824
5825 this.update(cx, |this, _| {
5826 let mut edits = Vec::with_capacity(ids.len());
5827 for (id, entry) in ids {
5828 if let Some(mut ops) = this
5829 .pending_ops
5830 .get(&PathKey(entry.as_ref().clone()), ())
5831 .cloned()
5832 {
5833 if let Some(op) = ops.op_by_id_mut(id) {
5834 op.job_status = job_status;
5835 }
5836 edits.push(sum_tree::Edit::Insert(ops));
5837 }
5838 }
5839 this.pending_ops.edit(edits, ());
5840 })?;
5841
5842 result
5843 })
5844 }
5845
5846 fn new_pending_ops_for_paths(
5847 &mut self,
5848 paths: Vec<RepoPath>,
5849 git_status: pending_op::GitStatus,
5850 ) -> Vec<(PendingOpId, RepoPath)> {
5851 let mut edits = Vec::with_capacity(paths.len());
5852 let mut ids = Vec::with_capacity(paths.len());
5853 for path in paths {
5854 let mut ops = self
5855 .pending_ops
5856 .get(&PathKey(path.as_ref().clone()), ())
5857 .cloned()
5858 .unwrap_or_else(|| PendingOps::new(&path));
5859 let id = ops.max_id() + 1;
5860 ops.ops.push(PendingOp {
5861 id,
5862 git_status,
5863 job_status: pending_op::JobStatus::Running,
5864 });
5865 edits.push(sum_tree::Edit::Insert(ops));
5866 ids.push((id, path));
5867 }
5868 self.pending_ops.edit(edits, ());
5869 ids
5870 }
5871}
5872
5873fn get_permalink_in_rust_registry_src(
5874 provider_registry: Arc<GitHostingProviderRegistry>,
5875 path: PathBuf,
5876 selection: Range<u32>,
5877) -> Result<url::Url> {
5878 #[derive(Deserialize)]
5879 struct CargoVcsGit {
5880 sha1: String,
5881 }
5882
5883 #[derive(Deserialize)]
5884 struct CargoVcsInfo {
5885 git: CargoVcsGit,
5886 path_in_vcs: String,
5887 }
5888
5889 #[derive(Deserialize)]
5890 struct CargoPackage {
5891 repository: String,
5892 }
5893
5894 #[derive(Deserialize)]
5895 struct CargoToml {
5896 package: CargoPackage,
5897 }
5898
5899 let Some((dir, cargo_vcs_info_json)) = path.ancestors().skip(1).find_map(|dir| {
5900 let json = std::fs::read_to_string(dir.join(".cargo_vcs_info.json")).ok()?;
5901 Some((dir, json))
5902 }) else {
5903 bail!("No .cargo_vcs_info.json found in parent directories")
5904 };
5905 let cargo_vcs_info = serde_json::from_str::<CargoVcsInfo>(&cargo_vcs_info_json)?;
5906 let cargo_toml = std::fs::read_to_string(dir.join("Cargo.toml"))?;
5907 let manifest = toml::from_str::<CargoToml>(&cargo_toml)?;
5908 let (provider, remote) = parse_git_remote_url(provider_registry, &manifest.package.repository)
5909 .context("parsing package.repository field of manifest")?;
5910 let path = PathBuf::from(cargo_vcs_info.path_in_vcs).join(path.strip_prefix(dir).unwrap());
5911 let permalink = provider.build_permalink(
5912 remote,
5913 BuildPermalinkParams::new(
5914 &cargo_vcs_info.git.sha1,
5915 &RepoPath::from_rel_path(
5916 &RelPath::new(&path, PathStyle::local()).context("invalid path")?,
5917 ),
5918 Some(selection),
5919 ),
5920 );
5921 Ok(permalink)
5922}
5923
5924fn serialize_blame_buffer_response(blame: Option<git::blame::Blame>) -> proto::BlameBufferResponse {
5925 let Some(blame) = blame else {
5926 return proto::BlameBufferResponse {
5927 blame_response: None,
5928 };
5929 };
5930
5931 let entries = blame
5932 .entries
5933 .into_iter()
5934 .map(|entry| proto::BlameEntry {
5935 sha: entry.sha.as_bytes().into(),
5936 start_line: entry.range.start,
5937 end_line: entry.range.end,
5938 original_line_number: entry.original_line_number,
5939 author: entry.author,
5940 author_mail: entry.author_mail,
5941 author_time: entry.author_time,
5942 author_tz: entry.author_tz,
5943 committer: entry.committer_name,
5944 committer_mail: entry.committer_email,
5945 committer_time: entry.committer_time,
5946 committer_tz: entry.committer_tz,
5947 summary: entry.summary,
5948 previous: entry.previous,
5949 filename: entry.filename,
5950 })
5951 .collect::<Vec<_>>();
5952
5953 let messages = blame
5954 .messages
5955 .into_iter()
5956 .map(|(oid, message)| proto::CommitMessage {
5957 oid: oid.as_bytes().into(),
5958 message,
5959 })
5960 .collect::<Vec<_>>();
5961
5962 proto::BlameBufferResponse {
5963 blame_response: Some(proto::blame_buffer_response::BlameResponse { entries, messages }),
5964 }
5965}
5966
5967fn deserialize_blame_buffer_response(
5968 response: proto::BlameBufferResponse,
5969) -> Option<git::blame::Blame> {
5970 let response = response.blame_response?;
5971 let entries = response
5972 .entries
5973 .into_iter()
5974 .filter_map(|entry| {
5975 Some(git::blame::BlameEntry {
5976 sha: git::Oid::from_bytes(&entry.sha).ok()?,
5977 range: entry.start_line..entry.end_line,
5978 original_line_number: entry.original_line_number,
5979 committer_name: entry.committer,
5980 committer_time: entry.committer_time,
5981 committer_tz: entry.committer_tz,
5982 committer_email: entry.committer_mail,
5983 author: entry.author,
5984 author_mail: entry.author_mail,
5985 author_time: entry.author_time,
5986 author_tz: entry.author_tz,
5987 summary: entry.summary,
5988 previous: entry.previous,
5989 filename: entry.filename,
5990 })
5991 })
5992 .collect::<Vec<_>>();
5993
5994 let messages = response
5995 .messages
5996 .into_iter()
5997 .filter_map(|message| Some((git::Oid::from_bytes(&message.oid).ok()?, message.message)))
5998 .collect::<HashMap<_, _>>();
5999
6000 Some(Blame { entries, messages })
6001}
6002
6003fn branch_to_proto(branch: &git::repository::Branch) -> proto::Branch {
6004 proto::Branch {
6005 is_head: branch.is_head,
6006 ref_name: branch.ref_name.to_string(),
6007 unix_timestamp: branch
6008 .most_recent_commit
6009 .as_ref()
6010 .map(|commit| commit.commit_timestamp as u64),
6011 upstream: branch.upstream.as_ref().map(|upstream| proto::GitUpstream {
6012 ref_name: upstream.ref_name.to_string(),
6013 tracking: upstream
6014 .tracking
6015 .status()
6016 .map(|upstream| proto::UpstreamTracking {
6017 ahead: upstream.ahead as u64,
6018 behind: upstream.behind as u64,
6019 }),
6020 }),
6021 most_recent_commit: branch
6022 .most_recent_commit
6023 .as_ref()
6024 .map(|commit| proto::CommitSummary {
6025 sha: commit.sha.to_string(),
6026 subject: commit.subject.to_string(),
6027 commit_timestamp: commit.commit_timestamp,
6028 author_name: commit.author_name.to_string(),
6029 }),
6030 }
6031}
6032
6033fn worktree_to_proto(worktree: &git::repository::Worktree) -> proto::Worktree {
6034 proto::Worktree {
6035 path: worktree.path.to_string_lossy().to_string(),
6036 ref_name: worktree.ref_name.to_string(),
6037 sha: worktree.sha.to_string(),
6038 }
6039}
6040
6041fn proto_to_worktree(proto: &proto::Worktree) -> git::repository::Worktree {
6042 git::repository::Worktree {
6043 path: PathBuf::from(proto.path.clone()),
6044 ref_name: proto.ref_name.clone().into(),
6045 sha: proto.sha.clone().into(),
6046 }
6047}
6048
6049fn proto_to_branch(proto: &proto::Branch) -> git::repository::Branch {
6050 git::repository::Branch {
6051 is_head: proto.is_head,
6052 ref_name: proto.ref_name.clone().into(),
6053 upstream: proto
6054 .upstream
6055 .as_ref()
6056 .map(|upstream| git::repository::Upstream {
6057 ref_name: upstream.ref_name.to_string().into(),
6058 tracking: upstream
6059 .tracking
6060 .as_ref()
6061 .map(|tracking| {
6062 git::repository::UpstreamTracking::Tracked(UpstreamTrackingStatus {
6063 ahead: tracking.ahead as u32,
6064 behind: tracking.behind as u32,
6065 })
6066 })
6067 .unwrap_or(git::repository::UpstreamTracking::Gone),
6068 }),
6069 most_recent_commit: proto.most_recent_commit.as_ref().map(|commit| {
6070 git::repository::CommitSummary {
6071 sha: commit.sha.to_string().into(),
6072 subject: commit.subject.to_string().into(),
6073 commit_timestamp: commit.commit_timestamp,
6074 author_name: commit.author_name.to_string().into(),
6075 has_parent: true,
6076 }
6077 }),
6078 }
6079}
6080
6081fn commit_details_to_proto(commit: &CommitDetails) -> proto::GitCommitDetails {
6082 proto::GitCommitDetails {
6083 sha: commit.sha.to_string(),
6084 message: commit.message.to_string(),
6085 commit_timestamp: commit.commit_timestamp,
6086 author_email: commit.author_email.to_string(),
6087 author_name: commit.author_name.to_string(),
6088 }
6089}
6090
6091fn proto_to_commit_details(proto: &proto::GitCommitDetails) -> CommitDetails {
6092 CommitDetails {
6093 sha: proto.sha.clone().into(),
6094 message: proto.message.clone().into(),
6095 commit_timestamp: proto.commit_timestamp,
6096 author_email: proto.author_email.clone().into(),
6097 author_name: proto.author_name.clone().into(),
6098 }
6099}
6100
6101async fn compute_snapshot(
6102 id: RepositoryId,
6103 work_directory_abs_path: Arc<Path>,
6104 prev_snapshot: RepositorySnapshot,
6105 backend: Arc<dyn GitRepository>,
6106) -> Result<(RepositorySnapshot, Vec<RepositoryEvent>)> {
6107 let mut events = Vec::new();
6108 let branches = backend.branches().await?;
6109 let branch = branches.into_iter().find(|branch| branch.is_head);
6110 let statuses = backend
6111 .status(&[RepoPath::from_rel_path(
6112 &RelPath::new(".".as_ref(), PathStyle::local()).unwrap(),
6113 )])
6114 .await?;
6115 let stash_entries = backend.stash_entries().await?;
6116 let statuses_by_path = SumTree::from_iter(
6117 statuses
6118 .entries
6119 .iter()
6120 .map(|(repo_path, status)| StatusEntry {
6121 repo_path: repo_path.clone(),
6122 status: *status,
6123 }),
6124 (),
6125 );
6126 let (merge_details, merge_heads_changed) =
6127 MergeDetails::load(&backend, &statuses_by_path, &prev_snapshot).await?;
6128 log::debug!("new merge details (changed={merge_heads_changed:?}): {merge_details:?}");
6129
6130 if merge_heads_changed {
6131 events.push(RepositoryEvent::MergeHeadsChanged);
6132 }
6133
6134 if statuses_by_path != prev_snapshot.statuses_by_path {
6135 events.push(RepositoryEvent::StatusesChanged)
6136 }
6137
6138 // Useful when branch is None in detached head state
6139 let head_commit = match backend.head_sha().await {
6140 Some(head_sha) => backend.show(head_sha).await.log_err(),
6141 None => None,
6142 };
6143
6144 if branch != prev_snapshot.branch || head_commit != prev_snapshot.head_commit {
6145 events.push(RepositoryEvent::BranchChanged);
6146 }
6147
6148 let remote_origin_url = backend.remote_url("origin").await;
6149 let remote_upstream_url = backend.remote_url("upstream").await;
6150
6151 let snapshot = RepositorySnapshot {
6152 id,
6153 statuses_by_path,
6154 work_directory_abs_path,
6155 path_style: prev_snapshot.path_style,
6156 scan_id: prev_snapshot.scan_id + 1,
6157 branch,
6158 head_commit,
6159 merge: merge_details,
6160 remote_origin_url,
6161 remote_upstream_url,
6162 stash_entries,
6163 };
6164
6165 Ok((snapshot, events))
6166}
6167
6168fn status_from_proto(
6169 simple_status: i32,
6170 status: Option<proto::GitFileStatus>,
6171) -> anyhow::Result<FileStatus> {
6172 use proto::git_file_status::Variant;
6173
6174 let Some(variant) = status.and_then(|status| status.variant) else {
6175 let code = proto::GitStatus::from_i32(simple_status)
6176 .with_context(|| format!("Invalid git status code: {simple_status}"))?;
6177 let result = match code {
6178 proto::GitStatus::Added => TrackedStatus {
6179 worktree_status: StatusCode::Added,
6180 index_status: StatusCode::Unmodified,
6181 }
6182 .into(),
6183 proto::GitStatus::Modified => TrackedStatus {
6184 worktree_status: StatusCode::Modified,
6185 index_status: StatusCode::Unmodified,
6186 }
6187 .into(),
6188 proto::GitStatus::Conflict => UnmergedStatus {
6189 first_head: UnmergedStatusCode::Updated,
6190 second_head: UnmergedStatusCode::Updated,
6191 }
6192 .into(),
6193 proto::GitStatus::Deleted => TrackedStatus {
6194 worktree_status: StatusCode::Deleted,
6195 index_status: StatusCode::Unmodified,
6196 }
6197 .into(),
6198 _ => anyhow::bail!("Invalid code for simple status: {simple_status}"),
6199 };
6200 return Ok(result);
6201 };
6202
6203 let result = match variant {
6204 Variant::Untracked(_) => FileStatus::Untracked,
6205 Variant::Ignored(_) => FileStatus::Ignored,
6206 Variant::Unmerged(unmerged) => {
6207 let [first_head, second_head] =
6208 [unmerged.first_head, unmerged.second_head].map(|head| {
6209 let code = proto::GitStatus::from_i32(head)
6210 .with_context(|| format!("Invalid git status code: {head}"))?;
6211 let result = match code {
6212 proto::GitStatus::Added => UnmergedStatusCode::Added,
6213 proto::GitStatus::Updated => UnmergedStatusCode::Updated,
6214 proto::GitStatus::Deleted => UnmergedStatusCode::Deleted,
6215 _ => anyhow::bail!("Invalid code for unmerged status: {code:?}"),
6216 };
6217 Ok(result)
6218 });
6219 let [first_head, second_head] = [first_head?, second_head?];
6220 UnmergedStatus {
6221 first_head,
6222 second_head,
6223 }
6224 .into()
6225 }
6226 Variant::Tracked(tracked) => {
6227 let [index_status, worktree_status] = [tracked.index_status, tracked.worktree_status]
6228 .map(|status| {
6229 let code = proto::GitStatus::from_i32(status)
6230 .with_context(|| format!("Invalid git status code: {status}"))?;
6231 let result = match code {
6232 proto::GitStatus::Modified => StatusCode::Modified,
6233 proto::GitStatus::TypeChanged => StatusCode::TypeChanged,
6234 proto::GitStatus::Added => StatusCode::Added,
6235 proto::GitStatus::Deleted => StatusCode::Deleted,
6236 proto::GitStatus::Renamed => StatusCode::Renamed,
6237 proto::GitStatus::Copied => StatusCode::Copied,
6238 proto::GitStatus::Unmodified => StatusCode::Unmodified,
6239 _ => anyhow::bail!("Invalid code for tracked status: {code:?}"),
6240 };
6241 Ok(result)
6242 });
6243 let [index_status, worktree_status] = [index_status?, worktree_status?];
6244 TrackedStatus {
6245 index_status,
6246 worktree_status,
6247 }
6248 .into()
6249 }
6250 };
6251 Ok(result)
6252}
6253
6254fn status_to_proto(status: FileStatus) -> proto::GitFileStatus {
6255 use proto::git_file_status::{Tracked, Unmerged, Variant};
6256
6257 let variant = match status {
6258 FileStatus::Untracked => Variant::Untracked(Default::default()),
6259 FileStatus::Ignored => Variant::Ignored(Default::default()),
6260 FileStatus::Unmerged(UnmergedStatus {
6261 first_head,
6262 second_head,
6263 }) => Variant::Unmerged(Unmerged {
6264 first_head: unmerged_status_to_proto(first_head),
6265 second_head: unmerged_status_to_proto(second_head),
6266 }),
6267 FileStatus::Tracked(TrackedStatus {
6268 index_status,
6269 worktree_status,
6270 }) => Variant::Tracked(Tracked {
6271 index_status: tracked_status_to_proto(index_status),
6272 worktree_status: tracked_status_to_proto(worktree_status),
6273 }),
6274 };
6275 proto::GitFileStatus {
6276 variant: Some(variant),
6277 }
6278}
6279
6280fn unmerged_status_to_proto(code: UnmergedStatusCode) -> i32 {
6281 match code {
6282 UnmergedStatusCode::Added => proto::GitStatus::Added as _,
6283 UnmergedStatusCode::Deleted => proto::GitStatus::Deleted as _,
6284 UnmergedStatusCode::Updated => proto::GitStatus::Updated as _,
6285 }
6286}
6287
6288fn tracked_status_to_proto(code: StatusCode) -> i32 {
6289 match code {
6290 StatusCode::Added => proto::GitStatus::Added as _,
6291 StatusCode::Deleted => proto::GitStatus::Deleted as _,
6292 StatusCode::Modified => proto::GitStatus::Modified as _,
6293 StatusCode::Renamed => proto::GitStatus::Renamed as _,
6294 StatusCode::TypeChanged => proto::GitStatus::TypeChanged as _,
6295 StatusCode::Copied => proto::GitStatus::Copied as _,
6296 StatusCode::Unmodified => proto::GitStatus::Unmodified as _,
6297 }
6298}