1use crate::askpass_modal::AskPassModal;
   2use crate::commit_modal::CommitModal;
   3use crate::git_panel_settings::StatusStyle;
   4use crate::project_diff::Diff;
   5use crate::remote_output::{self, RemoteAction, SuccessMessage};
   6use crate::repository_selector::filtered_repository_entries;
   7use crate::{branch_picker, render_remote_button};
   8use crate::{
   9    git_panel_settings::GitPanelSettings, git_status_icon, repository_selector::RepositorySelector,
  10};
  11use crate::{picker_prompt, project_diff, ProjectDiff};
  12use anyhow::Result;
  13use askpass::AskPassDelegate;
  14use assistant_settings::AssistantSettings;
  15use db::kvp::KEY_VALUE_STORE;
  16use editor::commit_tooltip::CommitTooltip;
  17
  18use editor::{
  19    scroll::ScrollbarAutoHide, Editor, EditorElement, EditorMode, EditorSettings, MultiBuffer,
  20    ShowScrollbar,
  21};
  22use futures::StreamExt as _;
  23use git::repository::{
  24    Branch, CommitDetails, CommitSummary, DiffType, PushOptions, Remote, RemoteCommandOutput,
  25    ResetMode, Upstream, UpstreamTracking, UpstreamTrackingStatus,
  26};
  27use git::status::StageStatus;
  28use git::{repository::RepoPath, status::FileStatus, Commit, ToggleStaged};
  29use git::{ExpandCommitEditor, RestoreTrackedFiles, StageAll, TrashUntrackedFiles, UnstageAll};
  30use gpui::{
  31    actions, anchored, deferred, percentage, uniform_list, Action, Animation, AnimationExt as _,
  32    Axis, ClickEvent, Corner, DismissEvent, Entity, EventEmitter, FocusHandle, Focusable,
  33    KeyContext, ListHorizontalSizingBehavior, ListSizingBehavior, Modifiers, ModifiersChangedEvent,
  34    MouseButton, MouseDownEvent, Point, PromptLevel, ScrollStrategy, Subscription, Task,
  35    Transformation, UniformListScrollHandle, WeakEntity,
  36};
  37use itertools::Itertools;
  38use language::{Buffer, File};
  39use language_model::{
  40    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
  41};
  42use menu::{Confirm, SecondaryConfirm, SelectFirst, SelectLast, SelectNext, SelectPrevious};
  43use multi_buffer::ExcerptInfo;
  44use panel::{
  45    panel_button, panel_editor_container, panel_editor_style, panel_filled_button,
  46    panel_icon_button, PanelHeader,
  47};
  48use project::{
  49    git::{GitEvent, Repository},
  50    Fs, Project, ProjectPath,
  51};
  52use serde::{Deserialize, Serialize};
  53use settings::{Settings as _, SettingsStore};
  54use std::cell::RefCell;
  55use std::future::Future;
  56use std::path::{Path, PathBuf};
  57use std::rc::Rc;
  58use std::{collections::HashSet, sync::Arc, time::Duration, usize};
  59use strum::{IntoEnumIterator, VariantNames};
  60use time::OffsetDateTime;
  61use ui::{
  62    prelude::*, Checkbox, ContextMenu, ElevationIndex, PopoverMenu, Scrollbar, ScrollbarState,
  63    Tooltip,
  64};
  65use util::{maybe, post_inc, ResultExt, TryFutureExt};
  66use workspace::{AppState, OpenOptions, OpenVisible};
  67
  68use notifications::status_toast::{StatusToast, ToastIcon};
  69use workspace::{
  70    dock::{DockPosition, Panel, PanelEvent},
  71    notifications::DetachAndPromptErr,
  72    Workspace,
  73};
  74
  75actions!(
  76    git_panel,
  77    [
  78        Close,
  79        ToggleFocus,
  80        OpenMenu,
  81        FocusEditor,
  82        FocusChanges,
  83        ToggleFillCoAuthors,
  84        GenerateCommitMessage
  85    ]
  86);
  87
  88fn prompt<T>(
  89    msg: &str,
  90    detail: Option<&str>,
  91    window: &mut Window,
  92    cx: &mut App,
  93) -> Task<anyhow::Result<T>>
  94where
  95    T: IntoEnumIterator + VariantNames + 'static,
  96{
  97    let rx = window.prompt(PromptLevel::Info, msg, detail, &T::VARIANTS, cx);
  98    cx.spawn(|_| async move { Ok(T::iter().nth(rx.await?).unwrap()) })
  99}
 100
 101#[derive(strum::EnumIter, strum::VariantNames)]
 102#[strum(serialize_all = "title_case")]
 103enum TrashCancel {
 104    Trash,
 105    Cancel,
 106}
 107
 108fn git_panel_context_menu(
 109    focus_handle: FocusHandle,
 110    window: &mut Window,
 111    cx: &mut App,
 112) -> Entity<ContextMenu> {
 113    ContextMenu::build(window, cx, |context_menu, _, _| {
 114        context_menu
 115            .context(focus_handle)
 116            .action("Stage All", StageAll.boxed_clone())
 117            .action("Unstage All", UnstageAll.boxed_clone())
 118            .separator()
 119            .action("Open Diff", project_diff::Diff.boxed_clone())
 120            .separator()
 121            .action("Discard Tracked Changes", RestoreTrackedFiles.boxed_clone())
 122            .action("Trash Untracked Files", TrashUntrackedFiles.boxed_clone())
 123    })
 124}
 125
 126const GIT_PANEL_KEY: &str = "GitPanel";
 127
 128const UPDATE_DEBOUNCE: Duration = Duration::from_millis(50);
 129
 130pub fn init(cx: &mut App) {
 131    cx.observe_new(
 132        |workspace: &mut Workspace, _window, _: &mut Context<Workspace>| {
 133            workspace.register_action(|workspace, _: &ToggleFocus, window, cx| {
 134                workspace.toggle_panel_focus::<GitPanel>(window, cx);
 135            });
 136            workspace.register_action(|workspace, _: &ExpandCommitEditor, window, cx| {
 137                CommitModal::toggle(workspace, window, cx)
 138            });
 139        },
 140    )
 141    .detach();
 142}
 143
 144#[derive(Debug, Clone)]
 145pub enum Event {
 146    Focus,
 147}
 148
 149#[derive(Serialize, Deserialize)]
 150struct SerializedGitPanel {
 151    width: Option<Pixels>,
 152}
 153
 154#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 155enum Section {
 156    Conflict,
 157    Tracked,
 158    New,
 159}
 160
 161#[derive(Debug, PartialEq, Eq, Clone)]
 162struct GitHeaderEntry {
 163    header: Section,
 164}
 165
 166impl GitHeaderEntry {
 167    pub fn contains(&self, status_entry: &GitStatusEntry, repo: &Repository) -> bool {
 168        let this = &self.header;
 169        let status = status_entry.status;
 170        match this {
 171            Section::Conflict => repo.has_conflict(&status_entry.repo_path),
 172            Section::Tracked => !status.is_created(),
 173            Section::New => status.is_created(),
 174        }
 175    }
 176    pub fn title(&self) -> &'static str {
 177        match self.header {
 178            Section::Conflict => "Conflicts",
 179            Section::Tracked => "Tracked",
 180            Section::New => "Untracked",
 181        }
 182    }
 183}
 184
 185#[derive(Debug, PartialEq, Eq, Clone)]
 186enum GitListEntry {
 187    GitStatusEntry(GitStatusEntry),
 188    Header(GitHeaderEntry),
 189}
 190
 191impl GitListEntry {
 192    fn status_entry(&self) -> Option<&GitStatusEntry> {
 193        match self {
 194            GitListEntry::GitStatusEntry(entry) => Some(entry),
 195            _ => None,
 196        }
 197    }
 198}
 199
 200#[derive(Debug, PartialEq, Eq, Clone)]
 201pub struct GitStatusEntry {
 202    pub(crate) repo_path: RepoPath,
 203    pub(crate) worktree_path: Arc<Path>,
 204    pub(crate) abs_path: PathBuf,
 205    pub(crate) status: FileStatus,
 206    pub(crate) staging: StageStatus,
 207}
 208
 209impl GitStatusEntry {
 210    fn display_name(&self) -> String {
 211        self.worktree_path
 212            .file_name()
 213            .map(|name| name.to_string_lossy().into_owned())
 214            .unwrap_or_else(|| self.worktree_path.to_string_lossy().into_owned())
 215    }
 216
 217    fn parent_dir(&self) -> Option<String> {
 218        self.worktree_path
 219            .parent()
 220            .map(|parent| parent.to_string_lossy().into_owned())
 221    }
 222}
 223
 224#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 225enum TargetStatus {
 226    Staged,
 227    Unstaged,
 228    Reverted,
 229    Unchanged,
 230}
 231
 232struct PendingOperation {
 233    finished: bool,
 234    target_status: TargetStatus,
 235    entries: Vec<GitStatusEntry>,
 236    op_id: usize,
 237}
 238
 239type RemoteOperations = Rc<RefCell<HashSet<u32>>>;
 240
 241// computed state related to how to render scrollbars
 242// one per axis
 243// on render we just read this off the panel
 244// we update it when
 245// - settings change
 246// - on focus in, on focus out, on hover, etc.
 247#[derive(Debug)]
 248struct ScrollbarProperties {
 249    axis: Axis,
 250    show_scrollbar: bool,
 251    show_track: bool,
 252    auto_hide: bool,
 253    hide_task: Option<Task<()>>,
 254    state: ScrollbarState,
 255}
 256
 257impl ScrollbarProperties {
 258    // Shows the scrollbar and cancels any pending hide task
 259    fn show(&mut self, cx: &mut Context<GitPanel>) {
 260        if !self.auto_hide {
 261            return;
 262        }
 263        self.show_scrollbar = true;
 264        self.hide_task.take();
 265        cx.notify();
 266    }
 267
 268    fn hide(&mut self, window: &mut Window, cx: &mut Context<GitPanel>) {
 269        const SCROLLBAR_SHOW_INTERVAL: Duration = Duration::from_secs(1);
 270
 271        if !self.auto_hide {
 272            return;
 273        }
 274
 275        let axis = self.axis;
 276        self.hide_task = Some(cx.spawn_in(window, |panel, mut cx| async move {
 277            cx.background_executor()
 278                .timer(SCROLLBAR_SHOW_INTERVAL)
 279                .await;
 280
 281            if let Some(panel) = panel.upgrade() {
 282                panel
 283                    .update(&mut cx, |panel, cx| {
 284                        match axis {
 285                            Axis::Vertical => panel.vertical_scrollbar.show_scrollbar = false,
 286                            Axis::Horizontal => panel.horizontal_scrollbar.show_scrollbar = false,
 287                        }
 288                        cx.notify();
 289                    })
 290                    .log_err();
 291            }
 292        }));
 293    }
 294}
 295
 296pub struct GitPanel {
 297    remote_operation_id: u32,
 298    pending_remote_operations: RemoteOperations,
 299    pub(crate) active_repository: Option<Entity<Repository>>,
 300    pub(crate) commit_editor: Entity<Editor>,
 301    conflicted_count: usize,
 302    conflicted_staged_count: usize,
 303    current_modifiers: Modifiers,
 304    add_coauthors: bool,
 305    generate_commit_message_task: Option<Task<Option<()>>>,
 306    entries: Vec<GitListEntry>,
 307    single_staged_entry: Option<GitStatusEntry>,
 308    single_tracked_entry: Option<GitStatusEntry>,
 309    focus_handle: FocusHandle,
 310    fs: Arc<dyn Fs>,
 311    horizontal_scrollbar: ScrollbarProperties,
 312    vertical_scrollbar: ScrollbarProperties,
 313    new_count: usize,
 314    entry_count: usize,
 315    new_staged_count: usize,
 316    pending: Vec<PendingOperation>,
 317    pending_commit: Option<Task<()>>,
 318    pending_serialization: Task<Option<()>>,
 319    pub(crate) project: Entity<Project>,
 320    scroll_handle: UniformListScrollHandle,
 321    max_width_item_index: Option<usize>,
 322    selected_entry: Option<usize>,
 323    marked_entries: Vec<usize>,
 324    tracked_count: usize,
 325    tracked_staged_count: usize,
 326    update_visible_entries_task: Task<()>,
 327    width: Option<Pixels>,
 328    workspace: WeakEntity<Workspace>,
 329    context_menu: Option<(Entity<ContextMenu>, Point<Pixels>, Subscription)>,
 330    modal_open: bool,
 331    _settings_subscription: Subscription,
 332}
 333
 334struct RemoteOperationGuard {
 335    id: u32,
 336    pending_remote_operations: RemoteOperations,
 337}
 338
 339impl Drop for RemoteOperationGuard {
 340    fn drop(&mut self) {
 341        self.pending_remote_operations.borrow_mut().remove(&self.id);
 342    }
 343}
 344
 345const MAX_PANEL_EDITOR_LINES: usize = 6;
 346
 347pub(crate) fn commit_message_editor(
 348    commit_message_buffer: Entity<Buffer>,
 349    placeholder: Option<&str>,
 350    project: Entity<Project>,
 351    in_panel: bool,
 352    window: &mut Window,
 353    cx: &mut Context<'_, Editor>,
 354) -> Editor {
 355    let buffer = cx.new(|cx| MultiBuffer::singleton(commit_message_buffer, cx));
 356    let max_lines = if in_panel { MAX_PANEL_EDITOR_LINES } else { 18 };
 357    let mut commit_editor = Editor::new(
 358        EditorMode::AutoHeight { max_lines },
 359        buffer,
 360        None,
 361        false,
 362        window,
 363        cx,
 364    );
 365    commit_editor.set_collaboration_hub(Box::new(project));
 366    commit_editor.set_use_autoclose(false);
 367    commit_editor.set_show_gutter(false, cx);
 368    commit_editor.set_show_wrap_guides(false, cx);
 369    commit_editor.set_show_indent_guides(false, cx);
 370    let placeholder = placeholder.unwrap_or("Enter commit message");
 371    commit_editor.set_placeholder_text(placeholder, cx);
 372    commit_editor
 373}
 374
 375impl GitPanel {
 376    pub fn new(
 377        workspace: Entity<Workspace>,
 378        project: Entity<Project>,
 379        app_state: Arc<AppState>,
 380        window: &mut Window,
 381        cx: &mut Context<Self>,
 382    ) -> Self {
 383        let fs = app_state.fs.clone();
 384        let git_store = project.read(cx).git_store().clone();
 385        let active_repository = project.read(cx).active_repository(cx);
 386        let workspace = workspace.downgrade();
 387
 388        let focus_handle = cx.focus_handle();
 389        cx.on_focus(&focus_handle, window, Self::focus_in).detach();
 390        cx.on_focus_out(&focus_handle, window, |this, _, window, cx| {
 391            this.hide_scrollbars(window, cx);
 392        })
 393        .detach();
 394
 395        // just to let us render a placeholder editor.
 396        // Once the active git repo is set, this buffer will be replaced.
 397        let temporary_buffer = cx.new(|cx| Buffer::local("", cx));
 398        let commit_editor = cx.new(|cx| {
 399            commit_message_editor(temporary_buffer, None, project.clone(), true, window, cx)
 400        });
 401
 402        commit_editor.update(cx, |editor, cx| {
 403            editor.clear(window, cx);
 404        });
 405
 406        let scroll_handle = UniformListScrollHandle::new();
 407
 408        cx.subscribe_in(
 409            &git_store,
 410            window,
 411            move |this, git_store, event, window, cx| match event {
 412                GitEvent::FileSystemUpdated => {
 413                    this.schedule_update(false, window, cx);
 414                }
 415                GitEvent::ActiveRepositoryChanged | GitEvent::GitStateUpdated => {
 416                    this.active_repository = git_store.read(cx).active_repository();
 417                    this.schedule_update(true, window, cx);
 418                }
 419                GitEvent::IndexWriteError(error) => {
 420                    this.workspace
 421                        .update(cx, |workspace, cx| {
 422                            workspace.show_error(error, cx);
 423                        })
 424                        .ok();
 425                }
 426            },
 427        )
 428        .detach();
 429
 430        let vertical_scrollbar = ScrollbarProperties {
 431            axis: Axis::Vertical,
 432            state: ScrollbarState::new(scroll_handle.clone()).parent_entity(&cx.entity()),
 433            show_scrollbar: false,
 434            show_track: false,
 435            auto_hide: false,
 436            hide_task: None,
 437        };
 438
 439        let horizontal_scrollbar = ScrollbarProperties {
 440            axis: Axis::Horizontal,
 441            state: ScrollbarState::new(scroll_handle.clone()).parent_entity(&cx.entity()),
 442            show_scrollbar: false,
 443            show_track: false,
 444            auto_hide: false,
 445            hide_task: None,
 446        };
 447
 448        let mut assistant_enabled = AssistantSettings::get_global(cx).enabled;
 449        let _settings_subscription = cx.observe_global::<SettingsStore>(move |_, cx| {
 450            if assistant_enabled != AssistantSettings::get_global(cx).enabled {
 451                assistant_enabled = AssistantSettings::get_global(cx).enabled;
 452                cx.notify();
 453            }
 454        });
 455
 456        let mut git_panel = Self {
 457            pending_remote_operations: Default::default(),
 458            remote_operation_id: 0,
 459            active_repository,
 460            commit_editor,
 461            conflicted_count: 0,
 462            conflicted_staged_count: 0,
 463            current_modifiers: window.modifiers(),
 464            add_coauthors: true,
 465            generate_commit_message_task: None,
 466            entries: Vec::new(),
 467            focus_handle: cx.focus_handle(),
 468            fs,
 469            new_count: 0,
 470            new_staged_count: 0,
 471            pending: Vec::new(),
 472            pending_commit: None,
 473            pending_serialization: Task::ready(None),
 474            single_staged_entry: None,
 475            single_tracked_entry: None,
 476            project,
 477            scroll_handle,
 478            max_width_item_index: None,
 479            selected_entry: None,
 480            marked_entries: Vec::new(),
 481            tracked_count: 0,
 482            tracked_staged_count: 0,
 483            update_visible_entries_task: Task::ready(()),
 484            width: None,
 485            context_menu: None,
 486            workspace,
 487            modal_open: false,
 488            entry_count: 0,
 489            horizontal_scrollbar,
 490            vertical_scrollbar,
 491            _settings_subscription,
 492        };
 493        git_panel.schedule_update(false, window, cx);
 494        git_panel
 495    }
 496
 497    fn hide_scrollbars(&mut self, window: &mut Window, cx: &mut Context<Self>) {
 498        self.horizontal_scrollbar.hide(window, cx);
 499        self.vertical_scrollbar.hide(window, cx);
 500    }
 501
 502    fn update_scrollbar_properties(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
 503        // TODO: This PR should have defined Editor's `scrollbar.axis`
 504        // as an Option<ScrollbarAxis>, not a ScrollbarAxes as it would allow you to
 505        // `.unwrap_or(EditorSettings::get_global(cx).scrollbar.show)`.
 506        //
 507        // Once this is fixed we can extend the GitPanelSettings with a `scrollbar.axis`
 508        // so we can show each axis based on the settings.
 509        //
 510        // We should fix this. PR: https://github.com/zed-industries/zed/pull/19495
 511
 512        let show_setting = GitPanelSettings::get_global(cx)
 513            .scrollbar
 514            .show
 515            .unwrap_or(EditorSettings::get_global(cx).scrollbar.show);
 516
 517        let scroll_handle = self.scroll_handle.0.borrow();
 518
 519        let autohide = |show: ShowScrollbar, cx: &mut Context<Self>| match show {
 520            ShowScrollbar::Auto => true,
 521            ShowScrollbar::System => cx
 522                .try_global::<ScrollbarAutoHide>()
 523                .map_or_else(|| cx.should_auto_hide_scrollbars(), |autohide| autohide.0),
 524            ShowScrollbar::Always => false,
 525            ShowScrollbar::Never => false,
 526        };
 527
 528        let longest_item_width = scroll_handle.last_item_size.and_then(|size| {
 529            (size.contents.width > size.item.width).then_some(size.contents.width)
 530        });
 531
 532        // is there an item long enough that we should show a horizontal scrollbar?
 533        let item_wider_than_container = if let Some(longest_item_width) = longest_item_width {
 534            longest_item_width > px(scroll_handle.base_handle.bounds().size.width.0)
 535        } else {
 536            true
 537        };
 538
 539        let show_horizontal = match (show_setting, item_wider_than_container) {
 540            (_, false) => false,
 541            (ShowScrollbar::Auto | ShowScrollbar::System | ShowScrollbar::Always, true) => true,
 542            (ShowScrollbar::Never, true) => false,
 543        };
 544
 545        let show_vertical = match show_setting {
 546            ShowScrollbar::Auto | ShowScrollbar::System | ShowScrollbar::Always => true,
 547            ShowScrollbar::Never => false,
 548        };
 549
 550        let show_horizontal_track =
 551            show_horizontal && matches!(show_setting, ShowScrollbar::Always);
 552
 553        // TODO: we probably should hide the scroll track when the list doesn't need to scroll
 554        let show_vertical_track = show_vertical && matches!(show_setting, ShowScrollbar::Always);
 555
 556        self.vertical_scrollbar = ScrollbarProperties {
 557            axis: self.vertical_scrollbar.axis,
 558            state: self.vertical_scrollbar.state.clone(),
 559            show_scrollbar: show_vertical,
 560            show_track: show_vertical_track,
 561            auto_hide: autohide(show_setting, cx),
 562            hide_task: None,
 563        };
 564
 565        self.horizontal_scrollbar = ScrollbarProperties {
 566            axis: self.horizontal_scrollbar.axis,
 567            state: self.horizontal_scrollbar.state.clone(),
 568            show_scrollbar: show_horizontal,
 569            show_track: show_horizontal_track,
 570            auto_hide: autohide(show_setting, cx),
 571            hide_task: None,
 572        };
 573
 574        cx.notify();
 575    }
 576
 577    pub fn entry_by_path(&self, path: &RepoPath) -> Option<usize> {
 578        fn binary_search<F>(mut low: usize, mut high: usize, is_target: F) -> Option<usize>
 579        where
 580            F: Fn(usize) -> std::cmp::Ordering,
 581        {
 582            while low < high {
 583                let mid = low + (high - low) / 2;
 584                match is_target(mid) {
 585                    std::cmp::Ordering::Equal => return Some(mid),
 586                    std::cmp::Ordering::Less => low = mid + 1,
 587                    std::cmp::Ordering::Greater => high = mid,
 588                }
 589            }
 590            None
 591        }
 592        if self.conflicted_count > 0 {
 593            let conflicted_start = 1;
 594            if let Some(ix) = binary_search(
 595                conflicted_start,
 596                conflicted_start + self.conflicted_count,
 597                |ix| {
 598                    self.entries[ix]
 599                        .status_entry()
 600                        .unwrap()
 601                        .repo_path
 602                        .cmp(&path)
 603                },
 604            ) {
 605                return Some(ix);
 606            }
 607        }
 608        if self.tracked_count > 0 {
 609            let tracked_start = if self.conflicted_count > 0 {
 610                1 + self.conflicted_count
 611            } else {
 612                0
 613            } + 1;
 614            if let Some(ix) =
 615                binary_search(tracked_start, tracked_start + self.tracked_count, |ix| {
 616                    self.entries[ix]
 617                        .status_entry()
 618                        .unwrap()
 619                        .repo_path
 620                        .cmp(&path)
 621                })
 622            {
 623                return Some(ix);
 624            }
 625        }
 626        if self.new_count > 0 {
 627            let untracked_start = if self.conflicted_count > 0 {
 628                1 + self.conflicted_count
 629            } else {
 630                0
 631            } + if self.tracked_count > 0 {
 632                1 + self.tracked_count
 633            } else {
 634                0
 635            } + 1;
 636            if let Some(ix) =
 637                binary_search(untracked_start, untracked_start + self.new_count, |ix| {
 638                    self.entries[ix]
 639                        .status_entry()
 640                        .unwrap()
 641                        .repo_path
 642                        .cmp(&path)
 643                })
 644            {
 645                return Some(ix);
 646            }
 647        }
 648        None
 649    }
 650
 651    pub fn select_entry_by_path(
 652        &mut self,
 653        path: ProjectPath,
 654        _: &mut Window,
 655        cx: &mut Context<Self>,
 656    ) {
 657        let Some(git_repo) = self.active_repository.as_ref() else {
 658            return;
 659        };
 660        let Some(repo_path) = git_repo.read(cx).project_path_to_repo_path(&path) else {
 661            return;
 662        };
 663        let Some(ix) = self.entry_by_path(&repo_path) else {
 664            return;
 665        };
 666        self.selected_entry = Some(ix);
 667        cx.notify();
 668    }
 669
 670    fn start_remote_operation(&mut self) -> RemoteOperationGuard {
 671        let id = post_inc(&mut self.remote_operation_id);
 672        self.pending_remote_operations.borrow_mut().insert(id);
 673
 674        RemoteOperationGuard {
 675            id,
 676            pending_remote_operations: self.pending_remote_operations.clone(),
 677        }
 678    }
 679
 680    fn serialize(&mut self, cx: &mut Context<Self>) {
 681        let width = self.width;
 682        self.pending_serialization = cx.background_spawn(
 683            async move {
 684                KEY_VALUE_STORE
 685                    .write_kvp(
 686                        GIT_PANEL_KEY.into(),
 687                        serde_json::to_string(&SerializedGitPanel { width })?,
 688                    )
 689                    .await?;
 690                anyhow::Ok(())
 691            }
 692            .log_err(),
 693        );
 694    }
 695
 696    pub(crate) fn set_modal_open(&mut self, open: bool, cx: &mut Context<Self>) {
 697        self.modal_open = open;
 698        cx.notify();
 699    }
 700
 701    fn dispatch_context(&self, window: &mut Window, cx: &Context<Self>) -> KeyContext {
 702        let mut dispatch_context = KeyContext::new_with_defaults();
 703        dispatch_context.add("GitPanel");
 704
 705        if self.is_focused(window, cx) {
 706            dispatch_context.add("menu");
 707            dispatch_context.add("ChangesList");
 708        }
 709
 710        if self.commit_editor.read(cx).is_focused(window) {
 711            dispatch_context.add("CommitEditor");
 712        }
 713
 714        dispatch_context
 715    }
 716
 717    fn is_focused(&self, window: &Window, cx: &Context<Self>) -> bool {
 718        window
 719            .focused(cx)
 720            .map_or(false, |focused| self.focus_handle == focused)
 721    }
 722
 723    fn close_panel(&mut self, _: &Close, _window: &mut Window, cx: &mut Context<Self>) {
 724        cx.emit(PanelEvent::Close);
 725    }
 726
 727    fn focus_in(&mut self, window: &mut Window, cx: &mut Context<Self>) {
 728        if !self.focus_handle.contains_focused(window, cx) {
 729            cx.emit(Event::Focus);
 730        }
 731    }
 732
 733    fn handle_modifiers_changed(
 734        &mut self,
 735        event: &ModifiersChangedEvent,
 736        _: &mut Window,
 737        cx: &mut Context<Self>,
 738    ) {
 739        self.current_modifiers = event.modifiers;
 740        cx.notify();
 741    }
 742
 743    fn scroll_to_selected_entry(&mut self, cx: &mut Context<Self>) {
 744        if let Some(selected_entry) = self.selected_entry {
 745            self.scroll_handle
 746                .scroll_to_item(selected_entry, ScrollStrategy::Center);
 747        }
 748
 749        cx.notify();
 750    }
 751
 752    fn select_first(&mut self, _: &SelectFirst, _window: &mut Window, cx: &mut Context<Self>) {
 753        if !self.entries.is_empty() {
 754            self.selected_entry = Some(1);
 755            self.scroll_to_selected_entry(cx);
 756        }
 757    }
 758
 759    fn select_previous(
 760        &mut self,
 761        _: &SelectPrevious,
 762        _window: &mut Window,
 763        cx: &mut Context<Self>,
 764    ) {
 765        let item_count = self.entries.len();
 766        if item_count == 0 {
 767            return;
 768        }
 769
 770        if let Some(selected_entry) = self.selected_entry {
 771            let new_selected_entry = if selected_entry > 0 {
 772                selected_entry - 1
 773            } else {
 774                selected_entry
 775            };
 776
 777            if matches!(
 778                self.entries.get(new_selected_entry),
 779                Some(GitListEntry::Header(..))
 780            ) {
 781                if new_selected_entry > 0 {
 782                    self.selected_entry = Some(new_selected_entry - 1)
 783                }
 784            } else {
 785                self.selected_entry = Some(new_selected_entry);
 786            }
 787
 788            self.scroll_to_selected_entry(cx);
 789        }
 790
 791        cx.notify();
 792    }
 793
 794    fn select_next(&mut self, _: &SelectNext, _window: &mut Window, cx: &mut Context<Self>) {
 795        let item_count = self.entries.len();
 796        if item_count == 0 {
 797            return;
 798        }
 799
 800        if let Some(selected_entry) = self.selected_entry {
 801            let new_selected_entry = if selected_entry < item_count - 1 {
 802                selected_entry + 1
 803            } else {
 804                selected_entry
 805            };
 806            if matches!(
 807                self.entries.get(new_selected_entry),
 808                Some(GitListEntry::Header(..))
 809            ) {
 810                self.selected_entry = Some(new_selected_entry + 1);
 811            } else {
 812                self.selected_entry = Some(new_selected_entry);
 813            }
 814
 815            self.scroll_to_selected_entry(cx);
 816        }
 817
 818        cx.notify();
 819    }
 820
 821    fn select_last(&mut self, _: &SelectLast, _window: &mut Window, cx: &mut Context<Self>) {
 822        if self.entries.last().is_some() {
 823            self.selected_entry = Some(self.entries.len() - 1);
 824            self.scroll_to_selected_entry(cx);
 825        }
 826    }
 827
 828    fn focus_editor(&mut self, _: &FocusEditor, window: &mut Window, cx: &mut Context<Self>) {
 829        self.commit_editor.update(cx, |editor, cx| {
 830            window.focus(&editor.focus_handle(cx));
 831        });
 832        cx.notify();
 833    }
 834
 835    fn select_first_entry_if_none(&mut self, cx: &mut Context<Self>) {
 836        let have_entries = self
 837            .active_repository
 838            .as_ref()
 839            .map_or(false, |active_repository| {
 840                active_repository.read(cx).entry_count() > 0
 841            });
 842        if have_entries && self.selected_entry.is_none() {
 843            self.selected_entry = Some(1);
 844            self.scroll_to_selected_entry(cx);
 845            cx.notify();
 846        }
 847    }
 848
 849    fn focus_changes_list(
 850        &mut self,
 851        _: &FocusChanges,
 852        window: &mut Window,
 853        cx: &mut Context<Self>,
 854    ) {
 855        self.select_first_entry_if_none(cx);
 856
 857        cx.focus_self(window);
 858        cx.notify();
 859    }
 860
 861    fn get_selected_entry(&self) -> Option<&GitListEntry> {
 862        self.selected_entry.and_then(|i| self.entries.get(i))
 863    }
 864
 865    fn open_diff(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
 866        maybe!({
 867            let entry = self.entries.get(self.selected_entry?)?.status_entry()?;
 868            let workspace = self.workspace.upgrade()?;
 869            let git_repo = self.active_repository.as_ref()?;
 870
 871            if let Some(project_diff) = workspace.read(cx).active_item_as::<ProjectDiff>(cx) {
 872                if let Some(project_path) = project_diff.read(cx).active_path(cx) {
 873                    if Some(&entry.repo_path)
 874                        == git_repo
 875                            .read(cx)
 876                            .project_path_to_repo_path(&project_path)
 877                            .as_ref()
 878                    {
 879                        project_diff.focus_handle(cx).focus(window);
 880                        project_diff.update(cx, |project_diff, cx| project_diff.autoscroll(cx));
 881                        return None;
 882                    }
 883                }
 884            };
 885
 886            if entry.worktree_path.starts_with("..") {
 887                self.workspace
 888                    .update(cx, |workspace, cx| {
 889                        workspace
 890                            .open_abs_path(
 891                                entry.abs_path.clone(),
 892                                OpenOptions {
 893                                    visible: Some(OpenVisible::All),
 894                                    focus: Some(false),
 895                                    ..Default::default()
 896                                },
 897                                window,
 898                                cx,
 899                            )
 900                            .detach_and_log_err(cx);
 901                    })
 902                    .ok();
 903            } else {
 904                self.workspace
 905                    .update(cx, |workspace, cx| {
 906                        ProjectDiff::deploy_at(workspace, Some(entry.clone()), window, cx);
 907                    })
 908                    .ok();
 909                self.focus_handle.focus(window);
 910            }
 911
 912            Some(())
 913        });
 914    }
 915
 916    fn open_file(
 917        &mut self,
 918        _: &menu::SecondaryConfirm,
 919        window: &mut Window,
 920        cx: &mut Context<Self>,
 921    ) {
 922        maybe!({
 923            let entry = self.entries.get(self.selected_entry?)?.status_entry()?;
 924            let active_repo = self.active_repository.as_ref()?;
 925            let path = active_repo
 926                .read(cx)
 927                .repo_path_to_project_path(&entry.repo_path)?;
 928            if entry.status.is_deleted() {
 929                return None;
 930            }
 931
 932            self.workspace
 933                .update(cx, |workspace, cx| {
 934                    workspace
 935                        .open_path_preview(path, None, false, false, true, window, cx)
 936                        .detach_and_prompt_err("Failed to open file", window, cx, |e, _, _| {
 937                            Some(format!("{e}"))
 938                        });
 939                })
 940                .ok()
 941        });
 942    }
 943
 944    fn revert_selected(
 945        &mut self,
 946        _: &git::RestoreFile,
 947        window: &mut Window,
 948        cx: &mut Context<Self>,
 949    ) {
 950        maybe!({
 951            let list_entry = self.entries.get(self.selected_entry?)?.clone();
 952            let entry = list_entry.status_entry()?;
 953            self.revert_entry(&entry, window, cx);
 954            Some(())
 955        });
 956    }
 957
 958    fn revert_entry(
 959        &mut self,
 960        entry: &GitStatusEntry,
 961        window: &mut Window,
 962        cx: &mut Context<Self>,
 963    ) {
 964        maybe!({
 965            let active_repo = self.active_repository.clone()?;
 966            let path = active_repo
 967                .read(cx)
 968                .repo_path_to_project_path(&entry.repo_path)?;
 969            let workspace = self.workspace.clone();
 970
 971            if entry.status.staging().has_staged() {
 972                self.change_file_stage(false, vec![entry.clone()], cx);
 973            }
 974            let filename = path.path.file_name()?.to_string_lossy();
 975
 976            if !entry.status.is_created() {
 977                self.perform_checkout(vec![entry.clone()], cx);
 978            } else {
 979                let prompt = prompt(&format!("Trash {}?", filename), None, window, cx);
 980                cx.spawn_in(window, |_, mut cx| async move {
 981                    match prompt.await? {
 982                        TrashCancel::Trash => {}
 983                        TrashCancel::Cancel => return Ok(()),
 984                    }
 985                    let task = workspace.update(&mut cx, |workspace, cx| {
 986                        workspace
 987                            .project()
 988                            .update(cx, |project, cx| project.delete_file(path, true, cx))
 989                    })?;
 990                    if let Some(task) = task {
 991                        task.await?;
 992                    }
 993                    Ok(())
 994                })
 995                .detach_and_prompt_err(
 996                    "Failed to trash file",
 997                    window,
 998                    cx,
 999                    |e, _, _| Some(format!("{e}")),
1000                );
1001            }
1002            Some(())
1003        });
1004    }
1005
1006    fn perform_checkout(&mut self, entries: Vec<GitStatusEntry>, cx: &mut Context<Self>) {
1007        let workspace = self.workspace.clone();
1008        let Some(active_repository) = self.active_repository.clone() else {
1009            return;
1010        };
1011
1012        let op_id = self.pending.iter().map(|p| p.op_id).max().unwrap_or(0) + 1;
1013        self.pending.push(PendingOperation {
1014            op_id,
1015            target_status: TargetStatus::Reverted,
1016            entries: entries.clone(),
1017            finished: false,
1018        });
1019        self.update_visible_entries(cx);
1020        let task = cx.spawn(|_, mut cx| async move {
1021            let tasks: Vec<_> = workspace.update(&mut cx, |workspace, cx| {
1022                workspace.project().update(cx, |project, cx| {
1023                    entries
1024                        .iter()
1025                        .filter_map(|entry| {
1026                            let path = active_repository
1027                                .read(cx)
1028                                .repo_path_to_project_path(&entry.repo_path)?;
1029                            Some(project.open_buffer(path, cx))
1030                        })
1031                        .collect()
1032                })
1033            })?;
1034
1035            let buffers = futures::future::join_all(tasks).await;
1036
1037            active_repository
1038                .update(&mut cx, |repo, cx| {
1039                    repo.checkout_files(
1040                        "HEAD",
1041                        entries
1042                            .iter()
1043                            .map(|entries| entries.repo_path.clone())
1044                            .collect(),
1045                        cx,
1046                    )
1047                })?
1048                .await??;
1049
1050            let tasks: Vec<_> = cx.update(|cx| {
1051                buffers
1052                    .iter()
1053                    .filter_map(|buffer| {
1054                        buffer.as_ref().ok()?.update(cx, |buffer, cx| {
1055                            buffer.is_dirty().then(|| buffer.reload(cx))
1056                        })
1057                    })
1058                    .collect()
1059            })?;
1060
1061            futures::future::join_all(tasks).await;
1062
1063            Ok(())
1064        });
1065
1066        cx.spawn(|this, mut cx| async move {
1067            let result = task.await;
1068
1069            this.update(&mut cx, |this, cx| {
1070                for pending in this.pending.iter_mut() {
1071                    if pending.op_id == op_id {
1072                        pending.finished = true;
1073                        if result.is_err() {
1074                            pending.target_status = TargetStatus::Unchanged;
1075                            this.update_visible_entries(cx);
1076                        }
1077                        break;
1078                    }
1079                }
1080                result
1081                    .map_err(|e| {
1082                        this.show_error_toast("checkout", e, cx);
1083                    })
1084                    .ok();
1085            })
1086            .ok();
1087        })
1088        .detach();
1089    }
1090
1091    fn restore_tracked_files(
1092        &mut self,
1093        _: &RestoreTrackedFiles,
1094        window: &mut Window,
1095        cx: &mut Context<Self>,
1096    ) {
1097        let entries = self
1098            .entries
1099            .iter()
1100            .filter_map(|entry| entry.status_entry().cloned())
1101            .filter(|status_entry| !status_entry.status.is_created())
1102            .collect::<Vec<_>>();
1103
1104        match entries.len() {
1105            0 => return,
1106            1 => return self.revert_entry(&entries[0], window, cx),
1107            _ => {}
1108        }
1109        let mut details = entries
1110            .iter()
1111            .filter_map(|entry| entry.repo_path.0.file_name())
1112            .map(|filename| filename.to_string_lossy())
1113            .take(5)
1114            .join("\n");
1115        if entries.len() > 5 {
1116            details.push_str(&format!("\nand {} more…", entries.len() - 5))
1117        }
1118
1119        #[derive(strum::EnumIter, strum::VariantNames)]
1120        #[strum(serialize_all = "title_case")]
1121        enum RestoreCancel {
1122            RestoreTrackedFiles,
1123            Cancel,
1124        }
1125        let prompt = prompt(
1126            "Discard changes to these files?",
1127            Some(&details),
1128            window,
1129            cx,
1130        );
1131        cx.spawn(|this, mut cx| async move {
1132            match prompt.await {
1133                Ok(RestoreCancel::RestoreTrackedFiles) => {
1134                    this.update(&mut cx, |this, cx| {
1135                        this.perform_checkout(entries, cx);
1136                    })
1137                    .ok();
1138                }
1139                _ => {
1140                    return;
1141                }
1142            }
1143        })
1144        .detach();
1145    }
1146
1147    fn clean_all(&mut self, _: &TrashUntrackedFiles, window: &mut Window, cx: &mut Context<Self>) {
1148        let workspace = self.workspace.clone();
1149        let Some(active_repo) = self.active_repository.clone() else {
1150            return;
1151        };
1152        let to_delete = self
1153            .entries
1154            .iter()
1155            .filter_map(|entry| entry.status_entry())
1156            .filter(|status_entry| status_entry.status.is_created())
1157            .cloned()
1158            .collect::<Vec<_>>();
1159
1160        match to_delete.len() {
1161            0 => return,
1162            1 => return self.revert_entry(&to_delete[0], window, cx),
1163            _ => {}
1164        };
1165
1166        let mut details = to_delete
1167            .iter()
1168            .map(|entry| {
1169                entry
1170                    .repo_path
1171                    .0
1172                    .file_name()
1173                    .map(|f| f.to_string_lossy())
1174                    .unwrap_or_default()
1175            })
1176            .take(5)
1177            .join("\n");
1178
1179        if to_delete.len() > 5 {
1180            details.push_str(&format!("\nand {} more…", to_delete.len() - 5))
1181        }
1182
1183        let prompt = prompt("Trash these files?", Some(&details), window, cx);
1184        cx.spawn_in(window, |this, mut cx| async move {
1185            match prompt.await? {
1186                TrashCancel::Trash => {}
1187                TrashCancel::Cancel => return Ok(()),
1188            }
1189            let tasks = workspace.update(&mut cx, |workspace, cx| {
1190                to_delete
1191                    .iter()
1192                    .filter_map(|entry| {
1193                        workspace.project().update(cx, |project, cx| {
1194                            let project_path = active_repo
1195                                .read(cx)
1196                                .repo_path_to_project_path(&entry.repo_path)?;
1197                            project.delete_file(project_path, true, cx)
1198                        })
1199                    })
1200                    .collect::<Vec<_>>()
1201            })?;
1202            let to_unstage = to_delete
1203                .into_iter()
1204                .filter(|entry| !entry.status.staging().is_fully_unstaged())
1205                .collect();
1206            this.update(&mut cx, |this, cx| {
1207                this.change_file_stage(false, to_unstage, cx)
1208            })?;
1209            for task in tasks {
1210                task.await?;
1211            }
1212            Ok(())
1213        })
1214        .detach_and_prompt_err("Failed to trash files", window, cx, |e, _, _| {
1215            Some(format!("{e}"))
1216        });
1217    }
1218
1219    pub fn stage_all(&mut self, _: &StageAll, _window: &mut Window, cx: &mut Context<Self>) {
1220        let entries = self
1221            .entries
1222            .iter()
1223            .filter_map(|entry| entry.status_entry())
1224            .filter(|status_entry| status_entry.staging.has_unstaged())
1225            .cloned()
1226            .collect::<Vec<_>>();
1227        self.change_file_stage(true, entries, cx);
1228    }
1229
1230    pub fn unstage_all(&mut self, _: &UnstageAll, _window: &mut Window, cx: &mut Context<Self>) {
1231        let entries = self
1232            .entries
1233            .iter()
1234            .filter_map(|entry| entry.status_entry())
1235            .filter(|status_entry| status_entry.staging.has_staged())
1236            .cloned()
1237            .collect::<Vec<_>>();
1238        self.change_file_stage(false, entries, cx);
1239    }
1240
1241    fn toggle_staged_for_entry(
1242        &mut self,
1243        entry: &GitListEntry,
1244        _window: &mut Window,
1245        cx: &mut Context<Self>,
1246    ) {
1247        let Some(active_repository) = self.active_repository.as_ref() else {
1248            return;
1249        };
1250        let (stage, repo_paths) = match entry {
1251            GitListEntry::GitStatusEntry(status_entry) => {
1252                if status_entry.status.staging().is_fully_staged() {
1253                    (false, vec![status_entry.clone()])
1254                } else {
1255                    (true, vec![status_entry.clone()])
1256                }
1257            }
1258            GitListEntry::Header(section) => {
1259                let goal_staged_state = !self.header_state(section.header).selected();
1260                let repository = active_repository.read(cx);
1261                let entries = self
1262                    .entries
1263                    .iter()
1264                    .filter_map(|entry| entry.status_entry())
1265                    .filter(|status_entry| {
1266                        section.contains(&status_entry, repository)
1267                            && status_entry.staging.as_bool() != Some(goal_staged_state)
1268                    })
1269                    .map(|status_entry| status_entry.clone())
1270                    .collect::<Vec<_>>();
1271
1272                (goal_staged_state, entries)
1273            }
1274        };
1275        self.change_file_stage(stage, repo_paths, cx);
1276    }
1277
1278    fn change_file_stage(
1279        &mut self,
1280        stage: bool,
1281        entries: Vec<GitStatusEntry>,
1282        cx: &mut Context<Self>,
1283    ) {
1284        let Some(active_repository) = self.active_repository.clone() else {
1285            return;
1286        };
1287        let op_id = self.pending.iter().map(|p| p.op_id).max().unwrap_or(0) + 1;
1288        self.pending.push(PendingOperation {
1289            op_id,
1290            target_status: if stage {
1291                TargetStatus::Staged
1292            } else {
1293                TargetStatus::Unstaged
1294            },
1295            entries: entries.clone(),
1296            finished: false,
1297        });
1298        let repository = active_repository.read(cx);
1299        self.update_counts(repository);
1300        cx.notify();
1301
1302        cx.spawn({
1303            |this, mut cx| async move {
1304                let result = cx
1305                    .update(|cx| {
1306                        if stage {
1307                            active_repository.update(cx, |repo, cx| {
1308                                let repo_paths = entries
1309                                    .iter()
1310                                    .map(|entry| entry.repo_path.clone())
1311                                    .collect();
1312                                repo.stage_entries(repo_paths, cx)
1313                            })
1314                        } else {
1315                            active_repository.update(cx, |repo, cx| {
1316                                let repo_paths = entries
1317                                    .iter()
1318                                    .map(|entry| entry.repo_path.clone())
1319                                    .collect();
1320                                repo.unstage_entries(repo_paths, cx)
1321                            })
1322                        }
1323                    })?
1324                    .await;
1325
1326                this.update(&mut cx, |this, cx| {
1327                    for pending in this.pending.iter_mut() {
1328                        if pending.op_id == op_id {
1329                            pending.finished = true
1330                        }
1331                    }
1332                    result
1333                        .map_err(|e| {
1334                            this.show_error_toast(if stage { "add" } else { "reset" }, e, cx);
1335                        })
1336                        .ok();
1337                    cx.notify();
1338                })
1339            }
1340        })
1341        .detach();
1342    }
1343
1344    pub fn total_staged_count(&self) -> usize {
1345        self.tracked_staged_count + self.new_staged_count + self.conflicted_staged_count
1346    }
1347
1348    pub fn commit_message_buffer(&self, cx: &App) -> Entity<Buffer> {
1349        self.commit_editor
1350            .read(cx)
1351            .buffer()
1352            .read(cx)
1353            .as_singleton()
1354            .unwrap()
1355            .clone()
1356    }
1357
1358    fn toggle_staged_for_selected(
1359        &mut self,
1360        _: &git::ToggleStaged,
1361        window: &mut Window,
1362        cx: &mut Context<Self>,
1363    ) {
1364        if let Some(selected_entry) = self.get_selected_entry().cloned() {
1365            self.toggle_staged_for_entry(&selected_entry, window, cx);
1366        }
1367    }
1368
1369    fn stage_selected(&mut self, _: &git::StageFile, _window: &mut Window, cx: &mut Context<Self>) {
1370        let Some(selected_entry) = self.get_selected_entry() else {
1371            return;
1372        };
1373        let Some(status_entry) = selected_entry.status_entry() else {
1374            return;
1375        };
1376        if status_entry.staging != StageStatus::Staged {
1377            self.change_file_stage(true, vec![status_entry.clone()], cx);
1378        }
1379    }
1380
1381    fn unstage_selected(
1382        &mut self,
1383        _: &git::UnstageFile,
1384        _window: &mut Window,
1385        cx: &mut Context<Self>,
1386    ) {
1387        let Some(selected_entry) = self.get_selected_entry() else {
1388            return;
1389        };
1390        let Some(status_entry) = selected_entry.status_entry() else {
1391            return;
1392        };
1393        if status_entry.staging != StageStatus::Unstaged {
1394            self.change_file_stage(false, vec![status_entry.clone()], cx);
1395        }
1396    }
1397
1398    fn commit(&mut self, _: &git::Commit, window: &mut Window, cx: &mut Context<Self>) {
1399        if self
1400            .commit_editor
1401            .focus_handle(cx)
1402            .contains_focused(window, cx)
1403        {
1404            telemetry::event!("Git Committed", source = "Git Panel");
1405            self.commit_changes(window, cx)
1406        } else {
1407            cx.propagate();
1408        }
1409    }
1410
1411    fn custom_or_suggested_commit_message(&self, cx: &mut Context<Self>) -> Option<String> {
1412        let message = self.commit_editor.read(cx).text(cx);
1413
1414        if !message.trim().is_empty() {
1415            return Some(message.to_string());
1416        }
1417
1418        self.suggest_commit_message()
1419            .filter(|message| !message.trim().is_empty())
1420    }
1421
1422    pub(crate) fn commit_changes(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1423        let Some(active_repository) = self.active_repository.clone() else {
1424            return;
1425        };
1426        let error_spawn = |message, window: &mut Window, cx: &mut App| {
1427            let prompt = window.prompt(PromptLevel::Warning, message, None, &["Ok"], cx);
1428            cx.spawn(|_| async move {
1429                prompt.await.ok();
1430            })
1431            .detach();
1432        };
1433
1434        if self.has_unstaged_conflicts() {
1435            error_spawn(
1436                "There are still conflicts. You must stage these before committing",
1437                window,
1438                cx,
1439            );
1440            return;
1441        }
1442
1443        let commit_message = self.custom_or_suggested_commit_message(cx);
1444
1445        let Some(mut message) = commit_message else {
1446            self.commit_editor.read(cx).focus_handle(cx).focus(window);
1447            return;
1448        };
1449
1450        if self.add_coauthors {
1451            self.fill_co_authors(&mut message, cx);
1452        }
1453
1454        let task = if self.has_staged_changes() {
1455            // Repository serializes all git operations, so we can just send a commit immediately
1456            let commit_task =
1457                active_repository.update(cx, |repo, cx| repo.commit(message.into(), None, cx));
1458            cx.background_spawn(async move { commit_task.await? })
1459        } else {
1460            let changed_files = self
1461                .entries
1462                .iter()
1463                .filter_map(|entry| entry.status_entry())
1464                .filter(|status_entry| !status_entry.status.is_created())
1465                .map(|status_entry| status_entry.repo_path.clone())
1466                .collect::<Vec<_>>();
1467
1468            if changed_files.is_empty() {
1469                error_spawn("No changes to commit", window, cx);
1470                return;
1471            }
1472
1473            let stage_task =
1474                active_repository.update(cx, |repo, cx| repo.stage_entries(changed_files, cx));
1475            cx.spawn(|_, mut cx| async move {
1476                stage_task.await?;
1477                let commit_task = active_repository
1478                    .update(&mut cx, |repo, cx| repo.commit(message.into(), None, cx))?;
1479                commit_task.await?
1480            })
1481        };
1482        let task = cx.spawn_in(window, |this, mut cx| async move {
1483            let result = task.await;
1484            this.update_in(&mut cx, |this, window, cx| {
1485                this.pending_commit.take();
1486                match result {
1487                    Ok(()) => {
1488                        this.commit_editor
1489                            .update(cx, |editor, cx| editor.clear(window, cx));
1490                    }
1491                    Err(e) => this.show_error_toast("commit", e, cx),
1492                }
1493            })
1494            .ok();
1495        });
1496
1497        self.pending_commit = Some(task);
1498    }
1499
1500    fn uncommit(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1501        let Some(repo) = self.active_repository.clone() else {
1502            return;
1503        };
1504        telemetry::event!("Git Uncommitted");
1505
1506        let confirmation = self.check_for_pushed_commits(window, cx);
1507        let prior_head = self.load_commit_details("HEAD", cx);
1508
1509        let task = cx.spawn_in(window, |this, mut cx| async move {
1510            let result = maybe!(async {
1511                if let Ok(true) = confirmation.await {
1512                    let prior_head = prior_head.await?;
1513
1514                    repo.update(&mut cx, |repo, cx| repo.reset("HEAD^", ResetMode::Soft, cx))?
1515                        .await??;
1516
1517                    Ok(Some(prior_head))
1518                } else {
1519                    Ok(None)
1520                }
1521            })
1522            .await;
1523
1524            this.update_in(&mut cx, |this, window, cx| {
1525                this.pending_commit.take();
1526                match result {
1527                    Ok(None) => {}
1528                    Ok(Some(prior_commit)) => {
1529                        this.commit_editor.update(cx, |editor, cx| {
1530                            editor.set_text(prior_commit.message, window, cx)
1531                        });
1532                    }
1533                    Err(e) => this.show_error_toast("reset", e, cx),
1534                }
1535            })
1536            .ok();
1537        });
1538
1539        self.pending_commit = Some(task);
1540    }
1541
1542    fn check_for_pushed_commits(
1543        &mut self,
1544        window: &mut Window,
1545        cx: &mut Context<Self>,
1546    ) -> impl Future<Output = Result<bool, anyhow::Error>> {
1547        let repo = self.active_repository.clone();
1548        let mut cx = window.to_async(cx);
1549
1550        async move {
1551            let Some(repo) = repo else {
1552                return Err(anyhow::anyhow!("No active repository"));
1553            };
1554
1555            let pushed_to: Vec<SharedString> = repo
1556                .update(&mut cx, |repo, _| repo.check_for_pushed_commits())?
1557                .await??;
1558
1559            if pushed_to.is_empty() {
1560                Ok(true)
1561            } else {
1562                #[derive(strum::EnumIter, strum::VariantNames)]
1563                #[strum(serialize_all = "title_case")]
1564                enum CancelUncommit {
1565                    Uncommit,
1566                    Cancel,
1567                }
1568                let detail = format!(
1569                    "This commit was already pushed to {}.",
1570                    pushed_to.into_iter().join(", ")
1571                );
1572                let result = cx
1573                    .update(|window, cx| prompt("Are you sure?", Some(&detail), window, cx))?
1574                    .await?;
1575
1576                match result {
1577                    CancelUncommit::Cancel => Ok(false),
1578                    CancelUncommit::Uncommit => Ok(true),
1579                }
1580            }
1581        }
1582    }
1583
1584    /// Suggests a commit message based on the changed files and their statuses
1585    pub fn suggest_commit_message(&self) -> Option<String> {
1586        let git_status_entry = if let Some(staged_entry) = &self.single_staged_entry {
1587            Some(staged_entry)
1588        } else if let Some(single_tracked_entry) = &self.single_tracked_entry {
1589            Some(single_tracked_entry)
1590        } else {
1591            None
1592        }?;
1593
1594        let action_text = if git_status_entry.status.is_deleted() {
1595            Some("Delete")
1596        } else if git_status_entry.status.is_created() {
1597            Some("Create")
1598        } else if git_status_entry.status.is_modified() {
1599            Some("Update")
1600        } else {
1601            None
1602        }?;
1603
1604        let file_name = git_status_entry
1605            .repo_path
1606            .file_name()
1607            .unwrap_or_default()
1608            .to_string_lossy();
1609
1610        Some(format!("{} {}", action_text, file_name))
1611    }
1612
1613    fn generate_commit_message_action(
1614        &mut self,
1615        _: &git::GenerateCommitMessage,
1616        _window: &mut Window,
1617        cx: &mut Context<Self>,
1618    ) {
1619        self.generate_commit_message(cx);
1620    }
1621
1622    /// Generates a commit message using an LLM.
1623    pub fn generate_commit_message(&mut self, cx: &mut Context<Self>) {
1624        if !self.can_commit() {
1625            return;
1626        }
1627
1628        let model = match current_language_model(cx) {
1629            Some(value) => value,
1630            None => return,
1631        };
1632
1633        let Some(repo) = self.active_repository.as_ref() else {
1634            return;
1635        };
1636
1637        telemetry::event!("Git Commit Message Generated");
1638
1639        let diff = repo.update(cx, |repo, cx| {
1640            if self.has_staged_changes() {
1641                repo.diff(DiffType::HeadToIndex, cx)
1642            } else {
1643                repo.diff(DiffType::HeadToWorktree, cx)
1644            }
1645        });
1646
1647        self.generate_commit_message_task = Some(cx.spawn(|this, mut cx| {
1648            async move {
1649                let _defer = util::defer({
1650                    let mut cx = cx.clone();
1651                    let this = this.clone();
1652                    move || {
1653                        this.update(&mut cx, |this, _cx| {
1654                            this.generate_commit_message_task.take();
1655                        })
1656                        .ok();
1657                    }
1658                });
1659
1660                let mut diff_text = diff.await??;
1661
1662                const ONE_MB: usize = 1_000_000;
1663                if diff_text.len() > ONE_MB {
1664                    diff_text = diff_text.chars().take(ONE_MB).collect()
1665                }
1666
1667                let subject = this.update(&mut cx, |this, cx| {
1668                    this.commit_editor.read(cx).text(cx).lines().next().map(ToOwned::to_owned).unwrap_or_default()
1669                })?;
1670
1671                let text_empty = subject.trim().is_empty();
1672
1673                let content = if text_empty {
1674                    format!("{PROMPT}\nHere are the changes in this commit:\n{diff_text}")
1675                } else {
1676                    format!("{PROMPT}\nHere is the user's subject line:\n{subject}\nHere are the changes in this commit:\n{diff_text}\n")
1677                };
1678
1679                const PROMPT: &str = include_str!("commit_message_prompt.txt");
1680
1681                let request = LanguageModelRequest {
1682                    messages: vec![LanguageModelRequestMessage {
1683                        role: Role::User,
1684                        content: vec![content.into()],
1685                        cache: false,
1686                    }],
1687                    tools: Vec::new(),
1688                    stop: Vec::new(),
1689                    temperature: None,
1690                };
1691
1692                let stream = model.stream_completion_text(request, &cx);
1693                let mut messages = stream.await?;
1694
1695                if !text_empty {
1696                    this.update(&mut cx, |this, cx| {
1697                        this.commit_message_buffer(cx).update(cx, |buffer, cx| {
1698                            let insert_position = buffer.anchor_before(buffer.len());
1699                            buffer.edit([(insert_position..insert_position, "\n")], None, cx)
1700                        });
1701                    })?;
1702                }
1703
1704                while let Some(message) = messages.stream.next().await {
1705                    let text = message?;
1706
1707                    this.update(&mut cx, |this, cx| {
1708                        this.commit_message_buffer(cx).update(cx, |buffer, cx| {
1709                            let insert_position = buffer.anchor_before(buffer.len());
1710                            buffer.edit([(insert_position..insert_position, text)], None, cx);
1711                        });
1712                    })?;
1713                }
1714
1715                anyhow::Ok(())
1716            }
1717            .log_err()
1718        }));
1719    }
1720
1721    fn update_editor_placeholder(&mut self, cx: &mut Context<Self>) {
1722        let suggested_commit_message = self.suggest_commit_message();
1723        let placeholder_text = suggested_commit_message
1724            .as_deref()
1725            .unwrap_or("Enter commit message");
1726
1727        self.commit_editor.update(cx, |editor, cx| {
1728            editor.set_placeholder_text(Arc::from(placeholder_text), cx)
1729        });
1730
1731        cx.notify();
1732    }
1733
1734    pub(crate) fn fetch(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1735        if !self.can_push_and_pull(cx) {
1736            return;
1737        }
1738
1739        let Some(repo) = self.active_repository.clone() else {
1740            return;
1741        };
1742        telemetry::event!("Git Fetched");
1743        let guard = self.start_remote_operation();
1744        let askpass = self.askpass_delegate("git fetch", window, cx);
1745        let this = cx.weak_entity();
1746        window
1747            .spawn(cx, |mut cx| async move {
1748                let fetch = repo.update(&mut cx, |repo, cx| repo.fetch(askpass, cx))?;
1749
1750                let remote_message = fetch.await?;
1751                drop(guard);
1752                this.update(&mut cx, |this, cx| {
1753                    let action = RemoteAction::Fetch;
1754                    match remote_message {
1755                        Ok(remote_message) => this.show_remote_output(action, remote_message, cx),
1756                        Err(e) => {
1757                            log::error!("Error while fetching {:?}", e);
1758                            this.show_error_toast(action.name(), e, cx)
1759                        }
1760                    }
1761
1762                    anyhow::Ok(())
1763                })
1764                .ok();
1765                anyhow::Ok(())
1766            })
1767            .detach_and_log_err(cx);
1768    }
1769
1770    pub(crate) fn git_init(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1771        let worktrees = self
1772            .project
1773            .read(cx)
1774            .visible_worktrees(cx)
1775            .collect::<Vec<_>>();
1776
1777        let worktree = if worktrees.len() == 1 {
1778            Task::ready(Some(worktrees.first().unwrap().clone()))
1779        } else if worktrees.len() == 0 {
1780            let result = window.prompt(
1781                PromptLevel::Warning,
1782                "Unable to initialize a git repository",
1783                Some("Open a directory first"),
1784                &["Ok"],
1785                cx,
1786            );
1787            cx.background_executor()
1788                .spawn(async move {
1789                    result.await.ok();
1790                })
1791                .detach();
1792            return;
1793        } else {
1794            let worktree_directories = worktrees
1795                .iter()
1796                .map(|worktree| worktree.read(cx).abs_path())
1797                .map(|worktree_abs_path| {
1798                    if let Ok(path) = worktree_abs_path.strip_prefix(util::paths::home_dir()) {
1799                        Path::new("~")
1800                            .join(path)
1801                            .to_string_lossy()
1802                            .to_string()
1803                            .into()
1804                    } else {
1805                        worktree_abs_path.to_string_lossy().to_string().into()
1806                    }
1807                })
1808                .collect_vec();
1809            let prompt = picker_prompt::prompt(
1810                "Where would you like to initialize this git repository?",
1811                worktree_directories,
1812                self.workspace.clone(),
1813                window,
1814                cx,
1815            );
1816
1817            cx.spawn(|_, _| async move { prompt.await.map(|ix| worktrees[ix].clone()) })
1818        };
1819
1820        cx.spawn_in(window, |this, mut cx| async move {
1821            let worktree = match worktree.await {
1822                Some(worktree) => worktree,
1823                None => {
1824                    return;
1825                }
1826            };
1827
1828            let Ok(result) = this.update(&mut cx, |this, cx| {
1829                let fallback_branch_name = GitPanelSettings::get_global(cx)
1830                    .fallback_branch_name
1831                    .clone();
1832                this.project.read(cx).git_init(
1833                    worktree.read(cx).abs_path(),
1834                    fallback_branch_name,
1835                    cx,
1836                )
1837            }) else {
1838                return;
1839            };
1840
1841            let result = result.await;
1842
1843            this.update_in(&mut cx, |this, _, cx| match result {
1844                Ok(()) => {}
1845                Err(e) => this.show_error_toast("init", e, cx),
1846            })
1847            .ok();
1848        })
1849        .detach();
1850    }
1851
1852    pub(crate) fn pull(&mut self, window: &mut Window, cx: &mut Context<Self>) {
1853        if !self.can_push_and_pull(cx) {
1854            return;
1855        }
1856        let Some(repo) = self.active_repository.clone() else {
1857            return;
1858        };
1859        let Some(branch) = repo.read(cx).current_branch() else {
1860            return;
1861        };
1862        telemetry::event!("Git Pulled");
1863        let branch = branch.clone();
1864        let remote = self.get_current_remote(window, cx);
1865        cx.spawn_in(window, move |this, mut cx| async move {
1866            let remote = match remote.await {
1867                Ok(Some(remote)) => remote,
1868                Ok(None) => {
1869                    return Ok(());
1870                }
1871                Err(e) => {
1872                    log::error!("Failed to get current remote: {}", e);
1873                    this.update(&mut cx, |this, cx| this.show_error_toast("pull", e, cx))
1874                        .ok();
1875                    return Ok(());
1876                }
1877            };
1878
1879            let askpass = this.update_in(&mut cx, |this, window, cx| {
1880                this.askpass_delegate(format!("git pull {}", remote.name), window, cx)
1881            })?;
1882
1883            let guard = this
1884                .update(&mut cx, |this, _| this.start_remote_operation())
1885                .ok();
1886
1887            let pull = repo.update(&mut cx, |repo, cx| {
1888                repo.pull(branch.name.clone(), remote.name.clone(), askpass, cx)
1889            })?;
1890
1891            let remote_message = pull.await?;
1892            drop(guard);
1893
1894            let action = RemoteAction::Pull(remote);
1895            this.update(&mut cx, |this, cx| match remote_message {
1896                Ok(remote_message) => this.show_remote_output(action, remote_message, cx),
1897                Err(e) => {
1898                    log::error!("Error while pulling {:?}", e);
1899                    this.show_error_toast(action.name(), e, cx)
1900                }
1901            })
1902            .ok();
1903
1904            anyhow::Ok(())
1905        })
1906        .detach_and_log_err(cx);
1907    }
1908
1909    pub(crate) fn push(&mut self, force_push: bool, window: &mut Window, cx: &mut Context<Self>) {
1910        if !self.can_push_and_pull(cx) {
1911            return;
1912        }
1913        let Some(repo) = self.active_repository.clone() else {
1914            return;
1915        };
1916        let Some(branch) = repo.read(cx).current_branch() else {
1917            return;
1918        };
1919        telemetry::event!("Git Pushed");
1920        let branch = branch.clone();
1921
1922        let options = if force_push {
1923            Some(PushOptions::Force)
1924        } else {
1925            match branch.upstream {
1926                Some(Upstream {
1927                    tracking: UpstreamTracking::Gone,
1928                    ..
1929                })
1930                | None => Some(PushOptions::SetUpstream),
1931                _ => None,
1932            }
1933        };
1934        let remote = self.get_current_remote(window, cx);
1935
1936        cx.spawn_in(window, move |this, mut cx| async move {
1937            let remote = match remote.await {
1938                Ok(Some(remote)) => remote,
1939                Ok(None) => {
1940                    return Ok(());
1941                }
1942                Err(e) => {
1943                    log::error!("Failed to get current remote: {}", e);
1944                    this.update(&mut cx, |this, cx| this.show_error_toast("push", e, cx))
1945                        .ok();
1946                    return Ok(());
1947                }
1948            };
1949
1950            let askpass_delegate = this.update_in(&mut cx, |this, window, cx| {
1951                this.askpass_delegate(format!("git push {}", remote.name), window, cx)
1952            })?;
1953
1954            let guard = this
1955                .update(&mut cx, |this, _| this.start_remote_operation())
1956                .ok();
1957
1958            let push = repo.update(&mut cx, |repo, cx| {
1959                repo.push(
1960                    branch.name.clone(),
1961                    remote.name.clone(),
1962                    options,
1963                    askpass_delegate,
1964                    cx,
1965                )
1966            })?;
1967
1968            let remote_output = push.await?;
1969            drop(guard);
1970
1971            let action = RemoteAction::Push(branch.name, remote);
1972            this.update(&mut cx, |this, cx| match remote_output {
1973                Ok(remote_message) => this.show_remote_output(action, remote_message, cx),
1974                Err(e) => {
1975                    log::error!("Error while pushing {:?}", e);
1976                    this.show_error_toast(action.name(), e, cx)
1977                }
1978            })?;
1979
1980            anyhow::Ok(())
1981        })
1982        .detach_and_log_err(cx);
1983    }
1984
1985    fn askpass_delegate(
1986        &self,
1987        operation: impl Into<SharedString>,
1988        window: &mut Window,
1989        cx: &mut Context<Self>,
1990    ) -> AskPassDelegate {
1991        let this = cx.weak_entity();
1992        let operation = operation.into();
1993        let window = window.window_handle();
1994        AskPassDelegate::new(&mut cx.to_async(), move |prompt, tx, cx| {
1995            window
1996                .update(cx, |_, window, cx| {
1997                    this.update(cx, |this, cx| {
1998                        this.workspace.update(cx, |workspace, cx| {
1999                            workspace.toggle_modal(window, cx, |window, cx| {
2000                                AskPassModal::new(operation.clone(), prompt.into(), tx, window, cx)
2001                            });
2002                        })
2003                    })
2004                })
2005                .ok();
2006        })
2007    }
2008
2009    fn can_push_and_pull(&self, cx: &App) -> bool {
2010        crate::can_push_and_pull(&self.project, cx)
2011    }
2012
2013    fn get_current_remote(
2014        &mut self,
2015        window: &mut Window,
2016        cx: &mut Context<Self>,
2017    ) -> impl Future<Output = anyhow::Result<Option<Remote>>> {
2018        let repo = self.active_repository.clone();
2019        let workspace = self.workspace.clone();
2020        let mut cx = window.to_async(cx);
2021
2022        async move {
2023            let Some(repo) = repo else {
2024                return Err(anyhow::anyhow!("No active repository"));
2025            };
2026
2027            let mut current_remotes: Vec<Remote> = repo
2028                .update(&mut cx, |repo, _| {
2029                    let Some(current_branch) = repo.current_branch() else {
2030                        return Err(anyhow::anyhow!("No active branch"));
2031                    };
2032
2033                    Ok(repo.get_remotes(Some(current_branch.name.to_string())))
2034                })??
2035                .await??;
2036
2037            if current_remotes.len() == 0 {
2038                return Err(anyhow::anyhow!("No active remote"));
2039            } else if current_remotes.len() == 1 {
2040                return Ok(Some(current_remotes.pop().unwrap()));
2041            } else {
2042                let current_remotes: Vec<_> = current_remotes
2043                    .into_iter()
2044                    .map(|remotes| remotes.name)
2045                    .collect();
2046                let selection = cx
2047                    .update(|window, cx| {
2048                        picker_prompt::prompt(
2049                            "Pick which remote to push to",
2050                            current_remotes.clone(),
2051                            workspace,
2052                            window,
2053                            cx,
2054                        )
2055                    })?
2056                    .await;
2057
2058                Ok(selection.map(|selection| Remote {
2059                    name: current_remotes[selection].clone(),
2060                }))
2061            }
2062        }
2063    }
2064
2065    fn potential_co_authors(&self, cx: &App) -> Vec<(String, String)> {
2066        let mut new_co_authors = Vec::new();
2067        let project = self.project.read(cx);
2068
2069        let Some(room) = self
2070            .workspace
2071            .upgrade()
2072            .and_then(|workspace| workspace.read(cx).active_call()?.read(cx).room().cloned())
2073        else {
2074            return Vec::default();
2075        };
2076
2077        let room = room.read(cx);
2078
2079        for (peer_id, collaborator) in project.collaborators() {
2080            if collaborator.is_host {
2081                continue;
2082            }
2083
2084            let Some(participant) = room.remote_participant_for_peer_id(*peer_id) else {
2085                continue;
2086            };
2087            if participant.can_write() && participant.user.email.is_some() {
2088                let email = participant.user.email.clone().unwrap();
2089
2090                new_co_authors.push((
2091                    participant
2092                        .user
2093                        .name
2094                        .clone()
2095                        .unwrap_or_else(|| participant.user.github_login.clone()),
2096                    email,
2097                ))
2098            }
2099        }
2100        if !project.is_local() && !project.is_read_only(cx) {
2101            if let Some(user) = room.local_participant_user(cx) {
2102                if let Some(email) = user.email.clone() {
2103                    new_co_authors.push((
2104                        user.name
2105                            .clone()
2106                            .unwrap_or_else(|| user.github_login.clone()),
2107                        email.clone(),
2108                    ))
2109                }
2110            }
2111        }
2112        new_co_authors
2113    }
2114
2115    fn toggle_fill_co_authors(
2116        &mut self,
2117        _: &ToggleFillCoAuthors,
2118        _: &mut Window,
2119        cx: &mut Context<Self>,
2120    ) {
2121        self.add_coauthors = !self.add_coauthors;
2122        cx.notify();
2123    }
2124
2125    fn fill_co_authors(&mut self, message: &mut String, cx: &mut Context<Self>) {
2126        const CO_AUTHOR_PREFIX: &str = "Co-authored-by: ";
2127
2128        let existing_text = message.to_ascii_lowercase();
2129        let lowercase_co_author_prefix = CO_AUTHOR_PREFIX.to_lowercase();
2130        let mut ends_with_co_authors = false;
2131        let existing_co_authors = existing_text
2132            .lines()
2133            .filter_map(|line| {
2134                let line = line.trim();
2135                if line.starts_with(&lowercase_co_author_prefix) {
2136                    ends_with_co_authors = true;
2137                    Some(line)
2138                } else {
2139                    ends_with_co_authors = false;
2140                    None
2141                }
2142            })
2143            .collect::<HashSet<_>>();
2144
2145        let new_co_authors = self
2146            .potential_co_authors(cx)
2147            .into_iter()
2148            .filter(|(_, email)| {
2149                !existing_co_authors
2150                    .iter()
2151                    .any(|existing| existing.contains(email.as_str()))
2152            })
2153            .collect::<Vec<_>>();
2154
2155        if new_co_authors.is_empty() {
2156            return;
2157        }
2158
2159        if !ends_with_co_authors {
2160            message.push('\n');
2161        }
2162        for (name, email) in new_co_authors {
2163            message.push('\n');
2164            message.push_str(CO_AUTHOR_PREFIX);
2165            message.push_str(&name);
2166            message.push_str(" <");
2167            message.push_str(&email);
2168            message.push('>');
2169        }
2170        message.push('\n');
2171    }
2172
2173    fn schedule_update(
2174        &mut self,
2175        clear_pending: bool,
2176        window: &mut Window,
2177        cx: &mut Context<Self>,
2178    ) {
2179        let handle = cx.entity().downgrade();
2180        self.reopen_commit_buffer(window, cx);
2181        self.update_visible_entries_task = cx.spawn_in(window, |_, mut cx| async move {
2182            cx.background_executor().timer(UPDATE_DEBOUNCE).await;
2183            if let Some(git_panel) = handle.upgrade() {
2184                git_panel
2185                    .update_in(&mut cx, |git_panel, window, cx| {
2186                        if clear_pending {
2187                            git_panel.clear_pending();
2188                        }
2189                        git_panel.update_visible_entries(cx);
2190                        git_panel.update_editor_placeholder(cx);
2191                        git_panel.update_scrollbar_properties(window, cx);
2192                    })
2193                    .ok();
2194            }
2195        });
2196    }
2197
2198    fn reopen_commit_buffer(&mut self, window: &mut Window, cx: &mut Context<Self>) {
2199        let Some(active_repo) = self.active_repository.as_ref() else {
2200            return;
2201        };
2202        let load_buffer = active_repo.update(cx, |active_repo, cx| {
2203            let project = self.project.read(cx);
2204            active_repo.open_commit_buffer(
2205                Some(project.languages().clone()),
2206                project.buffer_store().clone(),
2207                cx,
2208            )
2209        });
2210
2211        cx.spawn_in(window, |git_panel, mut cx| async move {
2212            let buffer = load_buffer.await?;
2213            git_panel.update_in(&mut cx, |git_panel, window, cx| {
2214                if git_panel
2215                    .commit_editor
2216                    .read(cx)
2217                    .buffer()
2218                    .read(cx)
2219                    .as_singleton()
2220                    .as_ref()
2221                    != Some(&buffer)
2222                {
2223                    git_panel.commit_editor = cx.new(|cx| {
2224                        commit_message_editor(
2225                            buffer,
2226                            git_panel.suggest_commit_message().as_deref(),
2227                            git_panel.project.clone(),
2228                            true,
2229                            window,
2230                            cx,
2231                        )
2232                    });
2233                }
2234            })
2235        })
2236        .detach_and_log_err(cx);
2237    }
2238
2239    fn clear_pending(&mut self) {
2240        self.pending.retain(|v| !v.finished)
2241    }
2242
2243    fn update_visible_entries(&mut self, cx: &mut Context<Self>) {
2244        self.entries.clear();
2245        self.single_staged_entry.take();
2246        self.single_staged_entry.take();
2247        let mut changed_entries = Vec::new();
2248        let mut new_entries = Vec::new();
2249        let mut conflict_entries = Vec::new();
2250        let mut last_staged = None;
2251        let mut staged_count = 0;
2252        let mut max_width_item: Option<(RepoPath, usize)> = None;
2253
2254        let Some(repo) = self.active_repository.as_ref() else {
2255            // Just clear entries if no repository is active.
2256            cx.notify();
2257            return;
2258        };
2259
2260        let repo = repo.read(cx);
2261
2262        for entry in repo.status() {
2263            let is_conflict = repo.has_conflict(&entry.repo_path);
2264            let is_new = entry.status.is_created();
2265            let staging = entry.status.staging();
2266
2267            if self.pending.iter().any(|pending| {
2268                pending.target_status == TargetStatus::Reverted
2269                    && !pending.finished
2270                    && pending
2271                        .entries
2272                        .iter()
2273                        .any(|pending| pending.repo_path == entry.repo_path)
2274            }) {
2275                continue;
2276            }
2277
2278            // dot_git_abs path always has at least one component, namely .git.
2279            let abs_path = repo
2280                .dot_git_abs_path
2281                .parent()
2282                .unwrap()
2283                .join(&entry.repo_path);
2284            let worktree_path = repo.repository_entry.unrelativize(&entry.repo_path);
2285            let entry = GitStatusEntry {
2286                repo_path: entry.repo_path.clone(),
2287                worktree_path,
2288                abs_path,
2289                status: entry.status,
2290                staging,
2291            };
2292
2293            if staging.has_staged() {
2294                staged_count += 1;
2295                last_staged = Some(entry.clone());
2296            }
2297
2298            let width_estimate = Self::item_width_estimate(
2299                entry.parent_dir().map(|s| s.len()).unwrap_or(0),
2300                entry.display_name().len(),
2301            );
2302
2303            match max_width_item.as_mut() {
2304                Some((repo_path, estimate)) => {
2305                    if width_estimate > *estimate {
2306                        *repo_path = entry.repo_path.clone();
2307                        *estimate = width_estimate;
2308                    }
2309                }
2310                None => max_width_item = Some((entry.repo_path.clone(), width_estimate)),
2311            }
2312
2313            if is_conflict {
2314                conflict_entries.push(entry);
2315            } else if is_new {
2316                new_entries.push(entry);
2317            } else {
2318                changed_entries.push(entry);
2319            }
2320        }
2321
2322        let mut pending_staged_count = 0;
2323        let mut last_pending_staged = None;
2324        let mut pending_status_for_last_staged = None;
2325        for pending in self.pending.iter() {
2326            if pending.target_status == TargetStatus::Staged {
2327                pending_staged_count += pending.entries.len();
2328                last_pending_staged = pending.entries.iter().next().cloned();
2329            }
2330            if let Some(last_staged) = &last_staged {
2331                if pending
2332                    .entries
2333                    .iter()
2334                    .any(|entry| entry.repo_path == last_staged.repo_path)
2335                {
2336                    pending_status_for_last_staged = Some(pending.target_status);
2337                }
2338            }
2339        }
2340
2341        if conflict_entries.len() == 0 && staged_count == 1 && pending_staged_count == 0 {
2342            match pending_status_for_last_staged {
2343                Some(TargetStatus::Staged) | None => {
2344                    self.single_staged_entry = last_staged;
2345                }
2346                _ => {}
2347            }
2348        } else if conflict_entries.len() == 0 && pending_staged_count == 1 {
2349            self.single_staged_entry = last_pending_staged;
2350        }
2351
2352        if conflict_entries.len() == 0 && changed_entries.len() == 1 {
2353            self.single_tracked_entry = changed_entries.first().cloned();
2354        }
2355
2356        if conflict_entries.len() > 0 {
2357            self.entries.push(GitListEntry::Header(GitHeaderEntry {
2358                header: Section::Conflict,
2359            }));
2360            self.entries.extend(
2361                conflict_entries
2362                    .into_iter()
2363                    .map(GitListEntry::GitStatusEntry),
2364            );
2365        }
2366
2367        if changed_entries.len() > 0 {
2368            self.entries.push(GitListEntry::Header(GitHeaderEntry {
2369                header: Section::Tracked,
2370            }));
2371            self.entries.extend(
2372                changed_entries
2373                    .into_iter()
2374                    .map(GitListEntry::GitStatusEntry),
2375            );
2376        }
2377        if new_entries.len() > 0 {
2378            self.entries.push(GitListEntry::Header(GitHeaderEntry {
2379                header: Section::New,
2380            }));
2381            self.entries
2382                .extend(new_entries.into_iter().map(GitListEntry::GitStatusEntry));
2383        }
2384
2385        if let Some((repo_path, _)) = max_width_item {
2386            self.max_width_item_index = self.entries.iter().position(|entry| match entry {
2387                GitListEntry::GitStatusEntry(git_status_entry) => {
2388                    git_status_entry.repo_path == repo_path
2389                }
2390                GitListEntry::Header(_) => false,
2391            });
2392        }
2393
2394        self.update_counts(repo);
2395
2396        self.select_first_entry_if_none(cx);
2397
2398        cx.notify();
2399    }
2400
2401    fn header_state(&self, header_type: Section) -> ToggleState {
2402        let (staged_count, count) = match header_type {
2403            Section::New => (self.new_staged_count, self.new_count),
2404            Section::Tracked => (self.tracked_staged_count, self.tracked_count),
2405            Section::Conflict => (self.conflicted_staged_count, self.conflicted_count),
2406        };
2407        if staged_count == 0 {
2408            ToggleState::Unselected
2409        } else if count == staged_count {
2410            ToggleState::Selected
2411        } else {
2412            ToggleState::Indeterminate
2413        }
2414    }
2415
2416    fn update_counts(&mut self, repo: &Repository) {
2417        self.conflicted_count = 0;
2418        self.conflicted_staged_count = 0;
2419        self.new_count = 0;
2420        self.tracked_count = 0;
2421        self.new_staged_count = 0;
2422        self.tracked_staged_count = 0;
2423        self.entry_count = 0;
2424        for entry in &self.entries {
2425            let Some(status_entry) = entry.status_entry() else {
2426                continue;
2427            };
2428            self.entry_count += 1;
2429            if repo.has_conflict(&status_entry.repo_path) {
2430                self.conflicted_count += 1;
2431                if self.entry_staging(status_entry).has_staged() {
2432                    self.conflicted_staged_count += 1;
2433                }
2434            } else if status_entry.status.is_created() {
2435                self.new_count += 1;
2436                if self.entry_staging(status_entry).has_staged() {
2437                    self.new_staged_count += 1;
2438                }
2439            } else {
2440                self.tracked_count += 1;
2441                if self.entry_staging(status_entry).has_staged() {
2442                    self.tracked_staged_count += 1;
2443                }
2444            }
2445        }
2446    }
2447
2448    fn entry_staging(&self, entry: &GitStatusEntry) -> StageStatus {
2449        for pending in self.pending.iter().rev() {
2450            if pending
2451                .entries
2452                .iter()
2453                .any(|pending_entry| pending_entry.repo_path == entry.repo_path)
2454            {
2455                match pending.target_status {
2456                    TargetStatus::Staged => return StageStatus::Staged,
2457                    TargetStatus::Unstaged => return StageStatus::Unstaged,
2458                    TargetStatus::Reverted => continue,
2459                    TargetStatus::Unchanged => continue,
2460                }
2461            }
2462        }
2463        entry.staging
2464    }
2465
2466    pub(crate) fn has_staged_changes(&self) -> bool {
2467        self.tracked_staged_count > 0
2468            || self.new_staged_count > 0
2469            || self.conflicted_staged_count > 0
2470    }
2471
2472    pub(crate) fn has_unstaged_changes(&self) -> bool {
2473        self.tracked_count > self.tracked_staged_count
2474            || self.new_count > self.new_staged_count
2475            || self.conflicted_count > self.conflicted_staged_count
2476    }
2477
2478    fn has_conflicts(&self) -> bool {
2479        self.conflicted_count > 0
2480    }
2481
2482    fn has_tracked_changes(&self) -> bool {
2483        self.tracked_count > 0
2484    }
2485
2486    pub fn has_unstaged_conflicts(&self) -> bool {
2487        self.conflicted_count > 0 && self.conflicted_count != self.conflicted_staged_count
2488    }
2489
2490    fn show_error_toast(&self, action: impl Into<SharedString>, e: anyhow::Error, cx: &mut App) {
2491        let action = action.into();
2492        let Some(workspace) = self.workspace.upgrade() else {
2493            return;
2494        };
2495
2496        let message = e.to_string().trim().to_string();
2497        if message
2498            .matches(git::repository::REMOTE_CANCELLED_BY_USER)
2499            .next()
2500            .is_some()
2501        {
2502            return; // Hide the cancelled by user message
2503        } else {
2504            let project = self.project.clone();
2505            workspace.update(cx, |workspace, cx| {
2506                let workspace_weak = cx.weak_entity();
2507                let toast =
2508                    StatusToast::new(format!("git {} failed", action.clone()), cx, |this, _cx| {
2509                        this.icon(ToastIcon::new(IconName::XCircle).color(Color::Error))
2510                            .action("View Log", move |window, cx| {
2511                                let message = message.clone();
2512                                let project = project.clone();
2513                                let action = action.clone();
2514                                workspace_weak
2515                                    .update(cx, move |workspace, cx| {
2516                                        Self::open_output(
2517                                            project, action, workspace, &message, window, cx,
2518                                        )
2519                                    })
2520                                    .ok();
2521                            })
2522                    });
2523                workspace.toggle_status_toast(toast, cx)
2524            });
2525        }
2526    }
2527
2528    fn show_remote_output(&self, action: RemoteAction, info: RemoteCommandOutput, cx: &mut App) {
2529        let Some(workspace) = self.workspace.upgrade() else {
2530            return;
2531        };
2532
2533        workspace.update(cx, |workspace, cx| {
2534            let SuccessMessage { message, style } = remote_output::format_output(&action, info);
2535            let workspace_weak = cx.weak_entity();
2536            let operation = action.name();
2537
2538            let status_toast = StatusToast::new(message, cx, move |this, _cx| {
2539                use remote_output::SuccessStyle::*;
2540                let project = self.project.clone();
2541                match style {
2542                    Toast { .. } => this,
2543                    ToastWithLog { output } => this
2544                        .icon(ToastIcon::new(IconName::GitBranchSmall).color(Color::Muted))
2545                        .action("View Log", move |window, cx| {
2546                            let output = output.clone();
2547                            let project = project.clone();
2548                            let output =
2549                                format!("stdout:\n{}\nstderr:\n{}", output.stdout, output.stderr);
2550                            workspace_weak
2551                                .update(cx, move |workspace, cx| {
2552                                    Self::open_output(
2553                                        project, operation, workspace, &output, window, cx,
2554                                    )
2555                                })
2556                                .ok();
2557                        }),
2558                    PushPrLink { link } => this
2559                        .icon(ToastIcon::new(IconName::GitBranchSmall).color(Color::Muted))
2560                        .action("Open Pull Request", move |_, cx| cx.open_url(&link)),
2561                }
2562            });
2563            workspace.toggle_status_toast(status_toast, cx)
2564        });
2565    }
2566
2567    fn open_output(
2568        project: Entity<Project>,
2569        operation: impl Into<SharedString>,
2570        workspace: &mut Workspace,
2571        output: &str,
2572        window: &mut Window,
2573        cx: &mut Context<Workspace>,
2574    ) {
2575        let operation = operation.into();
2576        let buffer = cx.new(|cx| Buffer::local(output, cx));
2577        let editor = cx.new(|cx| {
2578            let mut editor = Editor::for_buffer(buffer, Some(project), window, cx);
2579            editor.buffer().update(cx, |buffer, cx| {
2580                buffer.set_title(format!("Output from git {operation}"), cx);
2581            });
2582            editor.set_read_only(true);
2583            editor
2584        });
2585
2586        workspace.add_item_to_center(Box::new(editor), window, cx);
2587    }
2588
2589    pub fn render_spinner(&self) -> Option<impl IntoElement> {
2590        (!self.pending_remote_operations.borrow().is_empty()).then(|| {
2591            Icon::new(IconName::ArrowCircle)
2592                .size(IconSize::XSmall)
2593                .color(Color::Info)
2594                .with_animation(
2595                    "arrow-circle",
2596                    Animation::new(Duration::from_secs(2)).repeat(),
2597                    |icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
2598                )
2599                .into_any_element()
2600        })
2601    }
2602
2603    pub fn can_commit(&self) -> bool {
2604        (self.has_staged_changes() || self.has_tracked_changes()) && !self.has_unstaged_conflicts()
2605    }
2606
2607    pub fn can_stage_all(&self) -> bool {
2608        self.has_unstaged_changes()
2609    }
2610
2611    pub fn can_unstage_all(&self) -> bool {
2612        self.has_staged_changes()
2613    }
2614
2615    // eventually we'll need to take depth into account here
2616    // if we add a tree view
2617    fn item_width_estimate(path: usize, file_name: usize) -> usize {
2618        path + file_name
2619    }
2620
2621    fn render_overflow_menu(&self, id: impl Into<ElementId>) -> impl IntoElement {
2622        let focus_handle = self.focus_handle.clone();
2623        PopoverMenu::new(id.into())
2624            .trigger(
2625                IconButton::new("overflow-menu-trigger", IconName::EllipsisVertical)
2626                    .icon_size(IconSize::Small)
2627                    .icon_color(Color::Muted),
2628            )
2629            .menu(move |window, cx| Some(git_panel_context_menu(focus_handle.clone(), window, cx)))
2630            .anchor(Corner::TopRight)
2631    }
2632
2633    pub(crate) fn render_generate_commit_message_button(
2634        &self,
2635        cx: &Context<Self>,
2636    ) -> Option<AnyElement> {
2637        current_language_model(cx).is_some().then(|| {
2638            if self.generate_commit_message_task.is_some() {
2639                return h_flex()
2640                    .gap_1()
2641                    .child(
2642                        Icon::new(IconName::ArrowCircle)
2643                            .size(IconSize::XSmall)
2644                            .color(Color::Info)
2645                            .with_animation(
2646                                "arrow-circle",
2647                                Animation::new(Duration::from_secs(2)).repeat(),
2648                                |icon, delta| {
2649                                    icon.transform(Transformation::rotate(percentage(delta)))
2650                                },
2651                            ),
2652                    )
2653                    .child(
2654                        Label::new("Generating Commit...")
2655                            .size(LabelSize::Small)
2656                            .color(Color::Muted),
2657                    )
2658                    .into_any_element();
2659            }
2660
2661            let can_commit = self.can_commit();
2662            let editor_focus_handle = self.commit_editor.focus_handle(cx);
2663            IconButton::new("generate-commit-message", IconName::AiEdit)
2664                .shape(ui::IconButtonShape::Square)
2665                .icon_color(Color::Muted)
2666                .tooltip(move |window, cx| {
2667                    if can_commit {
2668                        Tooltip::for_action_in(
2669                            "Generate Commit Message",
2670                            &git::GenerateCommitMessage,
2671                            &editor_focus_handle,
2672                            window,
2673                            cx,
2674                        )
2675                    } else {
2676                        Tooltip::simple("No changes to commit", cx)
2677                    }
2678                })
2679                .disabled(!can_commit)
2680                .on_click(cx.listener(move |this, _event, _window, cx| {
2681                    this.generate_commit_message(cx);
2682                }))
2683                .into_any_element()
2684        })
2685    }
2686
2687    pub(crate) fn render_co_authors(&self, cx: &Context<Self>) -> Option<AnyElement> {
2688        let potential_co_authors = self.potential_co_authors(cx);
2689        if potential_co_authors.is_empty() {
2690            None
2691        } else {
2692            Some(
2693                IconButton::new("co-authors", IconName::Person)
2694                    .shape(ui::IconButtonShape::Square)
2695                    .icon_color(Color::Disabled)
2696                    .selected_icon_color(Color::Selected)
2697                    .toggle_state(self.add_coauthors)
2698                    .tooltip(move |_, cx| {
2699                        let title = format!(
2700                            "Add co-authored-by:{}{}",
2701                            if potential_co_authors.len() == 1 {
2702                                ""
2703                            } else {
2704                                "\n"
2705                            },
2706                            potential_co_authors
2707                                .iter()
2708                                .map(|(name, email)| format!(" {} <{}>", name, email))
2709                                .join("\n")
2710                        );
2711                        Tooltip::simple(title, cx)
2712                    })
2713                    .on_click(cx.listener(|this, _, _, cx| {
2714                        this.add_coauthors = !this.add_coauthors;
2715                        cx.notify();
2716                    }))
2717                    .into_any_element(),
2718            )
2719        }
2720    }
2721
2722    pub fn configure_commit_button(&self, cx: &mut Context<Self>) -> (bool, &'static str) {
2723        if self.has_unstaged_conflicts() {
2724            (false, "You must resolve conflicts before committing")
2725        } else if !self.has_staged_changes() && !self.has_tracked_changes() {
2726            (false, "No changes to commit")
2727        } else if self.pending_commit.is_some() {
2728            (false, "Commit in progress")
2729        } else if self.custom_or_suggested_commit_message(cx).is_none() {
2730            (false, "No commit message")
2731        } else if !self.has_write_access(cx) {
2732            (false, "You do not have write access to this project")
2733        } else {
2734            (true, self.commit_button_title())
2735        }
2736    }
2737
2738    pub fn commit_button_title(&self) -> &'static str {
2739        if self.has_staged_changes() {
2740            "Commit"
2741        } else {
2742            "Commit Tracked"
2743        }
2744    }
2745
2746    fn expand_commit_editor(
2747        &mut self,
2748        _: &git::ExpandCommitEditor,
2749        window: &mut Window,
2750        cx: &mut Context<Self>,
2751    ) {
2752        let workspace = self.workspace.clone();
2753        window.defer(cx, move |window, cx| {
2754            workspace
2755                .update(cx, |workspace, cx| {
2756                    CommitModal::toggle(workspace, window, cx)
2757                })
2758                .ok();
2759        })
2760    }
2761
2762    fn render_panel_header(
2763        &self,
2764        window: &mut Window,
2765        cx: &mut Context<Self>,
2766    ) -> Option<impl IntoElement> {
2767        self.active_repository.as_ref()?;
2768
2769        let text;
2770        let action;
2771        let tooltip;
2772        if self.total_staged_count() == self.entry_count && self.entry_count > 0 {
2773            text = "Unstage All";
2774            action = git::UnstageAll.boxed_clone();
2775            tooltip = "git reset";
2776        } else {
2777            text = "Stage All";
2778            action = git::StageAll.boxed_clone();
2779            tooltip = "git add --all ."
2780        }
2781
2782        let change_string = match self.entry_count {
2783            0 => "No Changes".to_string(),
2784            1 => "1 Change".to_string(),
2785            _ => format!("{} Changes", self.entry_count),
2786        };
2787
2788        Some(
2789            self.panel_header_container(window, cx)
2790                .px_2()
2791                .child(
2792                    panel_button(change_string)
2793                        .color(Color::Muted)
2794                        .tooltip(Tooltip::for_action_title_in(
2795                            "Open diff",
2796                            &Diff,
2797                            &self.focus_handle,
2798                        ))
2799                        .on_click(|_, _, cx| {
2800                            cx.defer(|cx| {
2801                                cx.dispatch_action(&Diff);
2802                            })
2803                        }),
2804                )
2805                .child(div().flex_grow()) // spacer
2806                .child(self.render_overflow_menu("overflow_menu"))
2807                .child(div().w_2()) // another spacer
2808                .child(
2809                    panel_filled_button(text)
2810                        .tooltip(Tooltip::for_action_title_in(
2811                            tooltip,
2812                            action.as_ref(),
2813                            &self.focus_handle,
2814                        ))
2815                        .disabled(self.entry_count == 0)
2816                        .on_click(move |_, _, cx| {
2817                            let action = action.boxed_clone();
2818                            cx.defer(move |cx| {
2819                                cx.dispatch_action(action.as_ref());
2820                            })
2821                        }),
2822                ),
2823        )
2824    }
2825
2826    pub fn render_footer(
2827        &self,
2828        window: &mut Window,
2829        cx: &mut Context<Self>,
2830    ) -> Option<impl IntoElement> {
2831        let active_repository = self.active_repository.clone()?;
2832        let (can_commit, tooltip) = self.configure_commit_button(cx);
2833        let project = self.project.clone().read(cx);
2834        let panel_editor_style = panel_editor_style(true, window, cx);
2835
2836        let enable_coauthors = self.render_co_authors(cx);
2837        let title = self.commit_button_title();
2838
2839        let editor_focus_handle = self.commit_editor.focus_handle(cx);
2840        let commit_tooltip_focus_handle = editor_focus_handle.clone();
2841        let expand_tooltip_focus_handle = editor_focus_handle.clone();
2842
2843        let branch = active_repository.read(cx).current_branch().cloned();
2844
2845        let footer_size = px(32.);
2846        let gap = px(9.0);
2847        let max_height = panel_editor_style
2848            .text
2849            .line_height_in_pixels(window.rem_size())
2850            * MAX_PANEL_EDITOR_LINES
2851            + gap;
2852
2853        let git_panel = cx.entity().clone();
2854        let display_name = SharedString::from(Arc::from(
2855            active_repository
2856                .read(cx)
2857                .display_name(project, cx)
2858                .trim_end_matches("/"),
2859        ));
2860        let editor_is_long = self.commit_editor.update(cx, |editor, cx| {
2861            editor.max_point(cx).row().0 >= MAX_PANEL_EDITOR_LINES as u32
2862        });
2863
2864        let footer = v_flex()
2865            .child(PanelRepoFooter::new(
2866                "footer-button",
2867                display_name,
2868                branch,
2869                Some(git_panel),
2870            ))
2871            .child(
2872                panel_editor_container(window, cx)
2873                    .id("commit-editor-container")
2874                    .relative()
2875                    .w_full()
2876                    .h(max_height + footer_size)
2877                    .border_t_1()
2878                    .border_color(cx.theme().colors().border_variant)
2879                    .cursor_text()
2880                    .on_click(cx.listener(move |this, _: &ClickEvent, window, cx| {
2881                        window.focus(&this.commit_editor.focus_handle(cx));
2882                    }))
2883                    .child(
2884                        h_flex()
2885                            .id("commit-footer")
2886                            .border_t_1()
2887                            .when(editor_is_long, |el| {
2888                                el.border_color(cx.theme().colors().border_variant)
2889                            })
2890                            .absolute()
2891                            .bottom_0()
2892                            .left_0()
2893                            .w_full()
2894                            .px_2()
2895                            .h(footer_size)
2896                            .flex_none()
2897                            .justify_between()
2898                            .child(
2899                                self.render_generate_commit_message_button(cx)
2900                                    .unwrap_or_else(|| div().into_any_element()),
2901                            )
2902                            .child(
2903                                h_flex().gap_0p5().children(enable_coauthors).child(
2904                                    panel_filled_button(title)
2905                                        .tooltip(move |window, cx| {
2906                                            if can_commit {
2907                                                Tooltip::for_action_in(
2908                                                    tooltip,
2909                                                    &Commit,
2910                                                    &commit_tooltip_focus_handle,
2911                                                    window,
2912                                                    cx,
2913                                                )
2914                                            } else {
2915                                                Tooltip::simple(tooltip, cx)
2916                                            }
2917                                        })
2918                                        .disabled(!can_commit || self.modal_open)
2919                                        .on_click({
2920                                            cx.listener(move |this, _: &ClickEvent, window, cx| {
2921                                                this.commit_changes(window, cx)
2922                                            })
2923                                        }),
2924                                ),
2925                            ),
2926                    )
2927                    .child(
2928                        div()
2929                            .pr_2p5()
2930                            .on_action(|&editor::actions::MoveUp, _, cx| {
2931                                cx.stop_propagation();
2932                            })
2933                            .on_action(|&editor::actions::MoveDown, _, cx| {
2934                                cx.stop_propagation();
2935                            })
2936                            .child(EditorElement::new(&self.commit_editor, panel_editor_style)),
2937                    )
2938                    .child(
2939                        h_flex()
2940                            .absolute()
2941                            .top_2()
2942                            .right_2()
2943                            .opacity(0.5)
2944                            .hover(|this| this.opacity(1.0))
2945                            .child(
2946                                panel_icon_button("expand-commit-editor", IconName::Maximize)
2947                                    .icon_size(IconSize::Small)
2948                                    .size(ui::ButtonSize::Default)
2949                                    .tooltip(move |window, cx| {
2950                                        Tooltip::for_action_in(
2951                                            "Open Commit Modal",
2952                                            &git::ExpandCommitEditor,
2953                                            &expand_tooltip_focus_handle,
2954                                            window,
2955                                            cx,
2956                                        )
2957                                    })
2958                                    .on_click(cx.listener({
2959                                        move |_, _, window, cx| {
2960                                            window.dispatch_action(
2961                                                git::ExpandCommitEditor.boxed_clone(),
2962                                                cx,
2963                                            )
2964                                        }
2965                                    })),
2966                            ),
2967                    ),
2968            );
2969
2970        Some(footer)
2971    }
2972
2973    fn render_previous_commit(&self, cx: &mut Context<Self>) -> Option<impl IntoElement> {
2974        let active_repository = self.active_repository.as_ref()?;
2975        let branch = active_repository.read(cx).current_branch()?;
2976        let commit = branch.most_recent_commit.as_ref()?.clone();
2977
2978        let this = cx.entity();
2979        Some(
2980            h_flex()
2981                .items_center()
2982                .py_2()
2983                .px(px(8.))
2984                .border_color(cx.theme().colors().border)
2985                .gap_1p5()
2986                .child(
2987                    div()
2988                        .flex_grow()
2989                        .overflow_hidden()
2990                        .items_center()
2991                        .max_w(relative(0.85))
2992                        .h_full()
2993                        .child(
2994                            Label::new(commit.subject.clone())
2995                                .size(LabelSize::Small)
2996                                .truncate(),
2997                        )
2998                        .id("commit-msg-hover")
2999                        .hoverable_tooltip(move |window, cx| {
3000                            GitPanelMessageTooltip::new(
3001                                this.clone(),
3002                                commit.sha.clone(),
3003                                window,
3004                                cx,
3005                            )
3006                            .into()
3007                        }),
3008                )
3009                .child(div().flex_1())
3010                .when(commit.has_parent, |this| {
3011                    let has_unstaged = self.has_unstaged_changes();
3012                    this.child(
3013                        panel_icon_button("undo", IconName::Undo)
3014                            .icon_size(IconSize::Small)
3015                            .icon_color(Color::Muted)
3016                            .tooltip(move |window, cx| {
3017                                Tooltip::with_meta(
3018                                    "Uncommit",
3019                                    Some(&git::Uncommit),
3020                                    if has_unstaged {
3021                                        "git reset HEAD^ --soft"
3022                                    } else {
3023                                        "git reset HEAD^"
3024                                    },
3025                                    window,
3026                                    cx,
3027                                )
3028                            })
3029                            .on_click(cx.listener(|this, _, window, cx| this.uncommit(window, cx))),
3030                    )
3031                }),
3032        )
3033    }
3034
3035    fn render_empty_state(&self, cx: &mut Context<Self>) -> impl IntoElement {
3036        h_flex()
3037            .h_full()
3038            .flex_grow()
3039            .justify_center()
3040            .items_center()
3041            .child(
3042                v_flex()
3043                    .gap_2()
3044                    .child(h_flex().w_full().justify_around().child(
3045                        if self.active_repository.is_some() {
3046                            "No changes to commit"
3047                        } else {
3048                            "No Git repositories"
3049                        },
3050                    ))
3051                    .children(self.active_repository.is_none().then(|| {
3052                        h_flex().w_full().justify_around().child(
3053                            panel_filled_button("Initialize Repository")
3054                                .tooltip(Tooltip::for_action_title_in(
3055                                    "git init",
3056                                    &git::Init,
3057                                    &self.focus_handle,
3058                                ))
3059                                .on_click(move |_, _, cx| {
3060                                    cx.defer(move |cx| {
3061                                        cx.dispatch_action(&git::Init);
3062                                    })
3063                                }),
3064                        )
3065                    }))
3066                    .text_ui_sm(cx)
3067                    .mx_auto()
3068                    .text_color(Color::Placeholder.color(cx)),
3069            )
3070    }
3071
3072    fn render_vertical_scrollbar(
3073        &self,
3074        show_horizontal_scrollbar_container: bool,
3075        cx: &mut Context<Self>,
3076    ) -> impl IntoElement {
3077        div()
3078            .id("git-panel-vertical-scroll")
3079            .occlude()
3080            .flex_none()
3081            .h_full()
3082            .cursor_default()
3083            .absolute()
3084            .right_0()
3085            .top_0()
3086            .bottom_0()
3087            .w(px(12.))
3088            .when(show_horizontal_scrollbar_container, |this| {
3089                this.pb_neg_3p5()
3090            })
3091            .on_mouse_move(cx.listener(|_, _, _, cx| {
3092                cx.notify();
3093                cx.stop_propagation()
3094            }))
3095            .on_hover(|_, _, cx| {
3096                cx.stop_propagation();
3097            })
3098            .on_any_mouse_down(|_, _, cx| {
3099                cx.stop_propagation();
3100            })
3101            .on_mouse_up(
3102                MouseButton::Left,
3103                cx.listener(|this, _, window, cx| {
3104                    if !this.vertical_scrollbar.state.is_dragging()
3105                        && !this.focus_handle.contains_focused(window, cx)
3106                    {
3107                        this.vertical_scrollbar.hide(window, cx);
3108                        cx.notify();
3109                    }
3110
3111                    cx.stop_propagation();
3112                }),
3113            )
3114            .on_scroll_wheel(cx.listener(|_, _, _, cx| {
3115                cx.notify();
3116            }))
3117            .children(Scrollbar::vertical(
3118                // percentage as f32..end_offset as f32,
3119                self.vertical_scrollbar.state.clone(),
3120            ))
3121    }
3122
3123    /// Renders the horizontal scrollbar.
3124    ///
3125    /// The right offset is used to determine how far to the right the
3126    /// scrollbar should extend to, useful for ensuring it doesn't collide
3127    /// with the vertical scrollbar when visible.
3128    fn render_horizontal_scrollbar(
3129        &self,
3130        right_offset: Pixels,
3131        cx: &mut Context<Self>,
3132    ) -> impl IntoElement {
3133        div()
3134            .id("git-panel-horizontal-scroll")
3135            .occlude()
3136            .flex_none()
3137            .w_full()
3138            .cursor_default()
3139            .absolute()
3140            .bottom_neg_px()
3141            .left_0()
3142            .right_0()
3143            .pr(right_offset)
3144            .on_mouse_move(cx.listener(|_, _, _, cx| {
3145                cx.notify();
3146                cx.stop_propagation()
3147            }))
3148            .on_hover(|_, _, cx| {
3149                cx.stop_propagation();
3150            })
3151            .on_any_mouse_down(|_, _, cx| {
3152                cx.stop_propagation();
3153            })
3154            .on_mouse_up(
3155                MouseButton::Left,
3156                cx.listener(|this, _, window, cx| {
3157                    if !this.horizontal_scrollbar.state.is_dragging()
3158                        && !this.focus_handle.contains_focused(window, cx)
3159                    {
3160                        this.horizontal_scrollbar.hide(window, cx);
3161                        cx.notify();
3162                    }
3163
3164                    cx.stop_propagation();
3165                }),
3166            )
3167            .on_scroll_wheel(cx.listener(|_, _, _, cx| {
3168                cx.notify();
3169            }))
3170            .children(Scrollbar::horizontal(
3171                // percentage as f32..end_offset as f32,
3172                self.horizontal_scrollbar.state.clone(),
3173            ))
3174    }
3175
3176    fn render_buffer_header_controls(
3177        &self,
3178        entity: &Entity<Self>,
3179        file: &Arc<dyn File>,
3180        _: &Window,
3181        cx: &App,
3182    ) -> Option<AnyElement> {
3183        let repo = self.active_repository.as_ref()?.read(cx);
3184        let repo_path = repo.worktree_id_path_to_repo_path(file.worktree_id(cx), file.path())?;
3185        let ix = self.entry_by_path(&repo_path)?;
3186        let entry = self.entries.get(ix)?;
3187
3188        let entry_staging = self.entry_staging(entry.status_entry()?);
3189
3190        let checkbox = Checkbox::new("stage-file", entry_staging.as_bool().into())
3191            .disabled(!self.has_write_access(cx))
3192            .fill()
3193            .elevation(ElevationIndex::Surface)
3194            .on_click({
3195                let entry = entry.clone();
3196                let git_panel = entity.downgrade();
3197                move |_, window, cx| {
3198                    git_panel
3199                        .update(cx, |this, cx| {
3200                            this.toggle_staged_for_entry(&entry, window, cx);
3201                            cx.stop_propagation();
3202                        })
3203                        .ok();
3204                }
3205            });
3206        Some(
3207            h_flex()
3208                .id("start-slot")
3209                .text_lg()
3210                .child(checkbox)
3211                .on_mouse_down(MouseButton::Left, |_, _, cx| {
3212                    // prevent the list item active state triggering when toggling checkbox
3213                    cx.stop_propagation();
3214                })
3215                .into_any_element(),
3216        )
3217    }
3218
3219    fn render_entries(
3220        &self,
3221        has_write_access: bool,
3222        _: &Window,
3223        cx: &mut Context<Self>,
3224    ) -> impl IntoElement {
3225        let entry_count = self.entries.len();
3226
3227        let scroll_track_size = px(16.);
3228
3229        let h_scroll_offset = if self.vertical_scrollbar.show_scrollbar {
3230            // magic number
3231            px(3.)
3232        } else {
3233            px(0.)
3234        };
3235
3236        v_flex()
3237            .flex_1()
3238            .size_full()
3239            .overflow_hidden()
3240            .relative()
3241            // Show a border on the top and bottom of the container when
3242            // the vertical scrollbar container is visible so we don't have a
3243            // floating left border in the panel.
3244            .when(self.vertical_scrollbar.show_track, |this| {
3245                this.border_t_1()
3246                    .border_b_1()
3247                    .border_color(cx.theme().colors().border)
3248            })
3249            .child(
3250                h_flex()
3251                    .flex_1()
3252                    .size_full()
3253                    .relative()
3254                    .overflow_hidden()
3255                    .child(
3256                        uniform_list(cx.entity().clone(), "entries", entry_count, {
3257                            move |this, range, window, cx| {
3258                                let mut items = Vec::with_capacity(range.end - range.start);
3259
3260                                for ix in range {
3261                                    match &this.entries.get(ix) {
3262                                        Some(GitListEntry::GitStatusEntry(entry)) => {
3263                                            items.push(this.render_entry(
3264                                                ix,
3265                                                entry,
3266                                                has_write_access,
3267                                                window,
3268                                                cx,
3269                                            ));
3270                                        }
3271                                        Some(GitListEntry::Header(header)) => {
3272                                            items.push(this.render_list_header(
3273                                                ix,
3274                                                header,
3275                                                has_write_access,
3276                                                window,
3277                                                cx,
3278                                            ));
3279                                        }
3280                                        None => {}
3281                                    }
3282                                }
3283
3284                                items
3285                            }
3286                        })
3287                        .size_full()
3288                        .flex_grow()
3289                        .with_sizing_behavior(ListSizingBehavior::Auto)
3290                        .with_horizontal_sizing_behavior(
3291                            ListHorizontalSizingBehavior::Unconstrained,
3292                        )
3293                        .with_width_from_item(self.max_width_item_index)
3294                        .track_scroll(self.scroll_handle.clone()),
3295                    )
3296                    .on_mouse_down(
3297                        MouseButton::Right,
3298                        cx.listener(move |this, event: &MouseDownEvent, window, cx| {
3299                            this.deploy_panel_context_menu(event.position, window, cx)
3300                        }),
3301                    )
3302                    .when(self.vertical_scrollbar.show_track, |this| {
3303                        this.child(
3304                            v_flex()
3305                                .h_full()
3306                                .flex_none()
3307                                .w(scroll_track_size)
3308                                .bg(cx.theme().colors().panel_background)
3309                                .child(
3310                                    div()
3311                                        .size_full()
3312                                        .flex_1()
3313                                        .border_l_1()
3314                                        .border_color(cx.theme().colors().border),
3315                                ),
3316                        )
3317                    })
3318                    .when(self.vertical_scrollbar.show_scrollbar, |this| {
3319                        this.child(
3320                            self.render_vertical_scrollbar(
3321                                self.horizontal_scrollbar.show_track,
3322                                cx,
3323                            ),
3324                        )
3325                    }),
3326            )
3327            .when(self.horizontal_scrollbar.show_track, |this| {
3328                this.child(
3329                    h_flex()
3330                        .w_full()
3331                        .h(scroll_track_size)
3332                        .flex_none()
3333                        .relative()
3334                        .child(
3335                            div()
3336                                .w_full()
3337                                .flex_1()
3338                                // for some reason the horizontal scrollbar is 1px
3339                                // taller than the vertical scrollbar??
3340                                .h(scroll_track_size - px(1.))
3341                                .bg(cx.theme().colors().panel_background)
3342                                .border_t_1()
3343                                .border_color(cx.theme().colors().border),
3344                        )
3345                        .when(self.vertical_scrollbar.show_track, |this| {
3346                            this.child(
3347                                div()
3348                                    .flex_none()
3349                                    // -1px prevents a missing pixel between the two container borders
3350                                    .w(scroll_track_size - px(1.))
3351                                    .h_full(),
3352                            )
3353                            .child(
3354                                // HACK: Fill the missing 1px 🥲
3355                                div()
3356                                    .absolute()
3357                                    .right(scroll_track_size - px(1.))
3358                                    .bottom(scroll_track_size - px(1.))
3359                                    .size_px()
3360                                    .bg(cx.theme().colors().border),
3361                            )
3362                        }),
3363                )
3364            })
3365            .when(self.horizontal_scrollbar.show_scrollbar, |this| {
3366                this.child(self.render_horizontal_scrollbar(h_scroll_offset, cx))
3367            })
3368    }
3369
3370    fn entry_label(&self, label: impl Into<SharedString>, color: Color) -> Label {
3371        Label::new(label.into()).color(color).single_line()
3372    }
3373
3374    fn list_item_height(&self) -> Rems {
3375        rems(1.75)
3376    }
3377
3378    fn render_list_header(
3379        &self,
3380        ix: usize,
3381        header: &GitHeaderEntry,
3382        _: bool,
3383        _: &Window,
3384        _: &Context<Self>,
3385    ) -> AnyElement {
3386        let id: ElementId = ElementId::Name(format!("header_{}", ix).into());
3387
3388        h_flex()
3389            .id(id)
3390            .h(self.list_item_height())
3391            .w_full()
3392            .items_end()
3393            .px(rems(0.75)) // ~12px
3394            .pb(rems(0.3125)) // ~ 5px
3395            .child(
3396                Label::new(header.title())
3397                    .color(Color::Muted)
3398                    .size(LabelSize::Small)
3399                    .line_height_style(LineHeightStyle::UiLabel)
3400                    .single_line(),
3401            )
3402            .into_any_element()
3403    }
3404
3405    fn load_commit_details(
3406        &self,
3407        sha: &str,
3408        cx: &mut Context<Self>,
3409    ) -> Task<anyhow::Result<CommitDetails>> {
3410        let Some(repo) = self.active_repository.clone() else {
3411            return Task::ready(Err(anyhow::anyhow!("no active repo")));
3412        };
3413        repo.update(cx, |repo, cx| {
3414            let show = repo.show(sha);
3415            cx.spawn(|_, _| async move { show.await? })
3416        })
3417    }
3418
3419    fn deploy_entry_context_menu(
3420        &mut self,
3421        position: Point<Pixels>,
3422        ix: usize,
3423        window: &mut Window,
3424        cx: &mut Context<Self>,
3425    ) {
3426        let Some(entry) = self.entries.get(ix).and_then(|e| e.status_entry()) else {
3427            return;
3428        };
3429        let stage_title = if entry.status.staging().is_fully_staged() {
3430            "Unstage File"
3431        } else {
3432            "Stage File"
3433        };
3434        let restore_title = if entry.status.is_created() {
3435            "Trash File"
3436        } else {
3437            "Restore File"
3438        };
3439        let context_menu = ContextMenu::build(window, cx, |context_menu, _, _| {
3440            context_menu
3441                .context(self.focus_handle.clone())
3442                .action(stage_title, ToggleStaged.boxed_clone())
3443                .action(restore_title, git::RestoreFile.boxed_clone())
3444                .separator()
3445                .action("Open Diff", Confirm.boxed_clone())
3446                .action("Open File", SecondaryConfirm.boxed_clone())
3447        });
3448        self.selected_entry = Some(ix);
3449        self.set_context_menu(context_menu, position, window, cx);
3450    }
3451
3452    fn deploy_panel_context_menu(
3453        &mut self,
3454        position: Point<Pixels>,
3455        window: &mut Window,
3456        cx: &mut Context<Self>,
3457    ) {
3458        let context_menu = git_panel_context_menu(self.focus_handle.clone(), window, cx);
3459        self.set_context_menu(context_menu, position, window, cx);
3460    }
3461
3462    fn set_context_menu(
3463        &mut self,
3464        context_menu: Entity<ContextMenu>,
3465        position: Point<Pixels>,
3466        window: &Window,
3467        cx: &mut Context<Self>,
3468    ) {
3469        let subscription = cx.subscribe_in(
3470            &context_menu,
3471            window,
3472            |this, _, _: &DismissEvent, window, cx| {
3473                if this.context_menu.as_ref().is_some_and(|context_menu| {
3474                    context_menu.0.focus_handle(cx).contains_focused(window, cx)
3475                }) {
3476                    cx.focus_self(window);
3477                }
3478                this.context_menu.take();
3479                cx.notify();
3480            },
3481        );
3482        self.context_menu = Some((context_menu, position, subscription));
3483        cx.notify();
3484    }
3485
3486    fn render_entry(
3487        &self,
3488        ix: usize,
3489        entry: &GitStatusEntry,
3490        has_write_access: bool,
3491        window: &Window,
3492        cx: &Context<Self>,
3493    ) -> AnyElement {
3494        let display_name = entry.display_name();
3495
3496        let selected = self.selected_entry == Some(ix);
3497        let marked = self.marked_entries.contains(&ix);
3498        let status_style = GitPanelSettings::get_global(cx).status_style;
3499        let status = entry.status;
3500        let modifiers = self.current_modifiers;
3501        let shift_held = modifiers.shift;
3502
3503        let has_conflict = status.is_conflicted();
3504        let is_modified = status.is_modified();
3505        let is_deleted = status.is_deleted();
3506
3507        let label_color = if status_style == StatusStyle::LabelColor {
3508            if has_conflict {
3509                Color::Conflict
3510            } else if is_modified {
3511                Color::Modified
3512            } else if is_deleted {
3513                // We don't want a bunch of red labels in the list
3514                Color::Disabled
3515            } else {
3516                Color::Created
3517            }
3518        } else {
3519            Color::Default
3520        };
3521
3522        let path_color = if status.is_deleted() {
3523            Color::Disabled
3524        } else {
3525            Color::Muted
3526        };
3527
3528        let id: ElementId = ElementId::Name(format!("entry_{}_{}", display_name, ix).into());
3529        let checkbox_wrapper_id: ElementId =
3530            ElementId::Name(format!("entry_{}_{}_checkbox_wrapper", display_name, ix).into());
3531        let checkbox_id: ElementId =
3532            ElementId::Name(format!("entry_{}_{}_checkbox", display_name, ix).into());
3533
3534        let entry_staging = self.entry_staging(entry);
3535        let mut is_staged: ToggleState = self.entry_staging(entry).as_bool().into();
3536
3537        if !self.has_staged_changes() && !self.has_conflicts() && !entry.status.is_created() {
3538            is_staged = ToggleState::Selected;
3539        }
3540
3541        let handle = cx.weak_entity();
3542
3543        let selected_bg_alpha = 0.08;
3544        let marked_bg_alpha = 0.12;
3545        let state_opacity_step = 0.04;
3546
3547        let base_bg = match (selected, marked) {
3548            (true, true) => cx
3549                .theme()
3550                .status()
3551                .info
3552                .alpha(selected_bg_alpha + marked_bg_alpha),
3553            (true, false) => cx.theme().status().info.alpha(selected_bg_alpha),
3554            (false, true) => cx.theme().status().info.alpha(marked_bg_alpha),
3555            _ => cx.theme().colors().ghost_element_background,
3556        };
3557
3558        let hover_bg = if selected {
3559            cx.theme()
3560                .status()
3561                .info
3562                .alpha(selected_bg_alpha + state_opacity_step)
3563        } else {
3564            cx.theme().colors().ghost_element_hover
3565        };
3566
3567        let active_bg = if selected {
3568            cx.theme()
3569                .status()
3570                .info
3571                .alpha(selected_bg_alpha + state_opacity_step * 2.0)
3572        } else {
3573            cx.theme().colors().ghost_element_active
3574        };
3575
3576        h_flex()
3577            .id(id)
3578            .h(self.list_item_height())
3579            .w_full()
3580            .items_center()
3581            .border_1()
3582            .when(selected && self.focus_handle.is_focused(window), |el| {
3583                el.border_color(cx.theme().colors().border_focused)
3584            })
3585            .px(rems(0.75)) // ~12px
3586            .overflow_hidden()
3587            .flex_none()
3588            .gap_1p5()
3589            .bg(base_bg)
3590            .hover(|this| this.bg(hover_bg))
3591            .active(|this| this.bg(active_bg))
3592            .on_click({
3593                cx.listener(move |this, event: &ClickEvent, window, cx| {
3594                    this.selected_entry = Some(ix);
3595                    cx.notify();
3596                    if event.modifiers().secondary() {
3597                        this.open_file(&Default::default(), window, cx)
3598                    } else {
3599                        this.open_diff(&Default::default(), window, cx);
3600                        this.focus_handle.focus(window);
3601                    }
3602                })
3603            })
3604            .on_mouse_down(
3605                MouseButton::Right,
3606                move |event: &MouseDownEvent, window, cx| {
3607                    // why isn't this happening automatically? we are passing MouseButton::Right to `on_mouse_down`?
3608                    if event.button != MouseButton::Right {
3609                        return;
3610                    }
3611
3612                    let Some(this) = handle.upgrade() else {
3613                        return;
3614                    };
3615                    this.update(cx, |this, cx| {
3616                        this.deploy_entry_context_menu(event.position, ix, window, cx);
3617                    });
3618                    cx.stop_propagation();
3619                },
3620            )
3621            // .on_secondary_mouse_down(cx.listener(
3622            //     move |this, event: &MouseDownEvent, window, cx| {
3623            //         this.deploy_entry_context_menu(event.position, ix, window, cx);
3624            //         cx.stop_propagation();
3625            //     },
3626            // ))
3627            .child(
3628                div()
3629                    .id(checkbox_wrapper_id)
3630                    .flex_none()
3631                    .occlude()
3632                    .cursor_pointer()
3633                    .child(
3634                        Checkbox::new(checkbox_id, is_staged)
3635                            .disabled(!has_write_access)
3636                            .fill()
3637                            .placeholder(
3638                                !self.has_staged_changes()
3639                                    && !self.has_conflicts()
3640                                    && !entry.status.is_created(),
3641                            )
3642                            .elevation(ElevationIndex::Surface)
3643                            .on_click({
3644                                let entry = entry.clone();
3645                                cx.listener(move |this, _, window, cx| {
3646                                    if !has_write_access {
3647                                        return;
3648                                    }
3649                                    this.toggle_staged_for_entry(
3650                                        &GitListEntry::GitStatusEntry(entry.clone()),
3651                                        window,
3652                                        cx,
3653                                    );
3654                                    cx.stop_propagation();
3655                                })
3656                            })
3657                            .tooltip(move |window, cx| {
3658                                let is_staged = entry_staging.is_fully_staged();
3659
3660                                let action = if is_staged { "Unstage" } else { "Stage" };
3661                                let tooltip_name = if shift_held {
3662                                    format!("{} section", action)
3663                                } else {
3664                                    action.to_string()
3665                                };
3666
3667                                let meta = if shift_held {
3668                                    format!(
3669                                        "Release shift to {} single entry",
3670                                        action.to_lowercase()
3671                                    )
3672                                } else {
3673                                    format!("Shift click to {} section", action.to_lowercase())
3674                                };
3675
3676                                Tooltip::with_meta(
3677                                    tooltip_name,
3678                                    Some(&ToggleStaged),
3679                                    meta,
3680                                    window,
3681                                    cx,
3682                                )
3683                            }),
3684                    ),
3685            )
3686            .child(git_status_icon(status))
3687            .child(
3688                h_flex()
3689                    .items_center()
3690                    .flex_1()
3691                    // .overflow_hidden()
3692                    .when_some(entry.parent_dir(), |this, parent| {
3693                        if !parent.is_empty() {
3694                            this.child(
3695                                self.entry_label(format!("{}/", parent), path_color)
3696                                    .when(status.is_deleted(), |this| this.strikethrough()),
3697                            )
3698                        } else {
3699                            this
3700                        }
3701                    })
3702                    .child(
3703                        self.entry_label(display_name.clone(), label_color)
3704                            .when(status.is_deleted(), |this| this.strikethrough()),
3705                    ),
3706            )
3707            .into_any_element()
3708    }
3709
3710    fn has_write_access(&self, cx: &App) -> bool {
3711        !self.project.read(cx).is_read_only(cx)
3712    }
3713}
3714
3715fn current_language_model(cx: &Context<'_, GitPanel>) -> Option<Arc<dyn LanguageModel>> {
3716    assistant_settings::AssistantSettings::get_global(cx)
3717        .enabled
3718        .then(|| {
3719            let provider = LanguageModelRegistry::read_global(cx).active_provider()?;
3720            let model = LanguageModelRegistry::read_global(cx).active_model()?;
3721            provider.is_authenticated(cx).then(|| model)
3722        })
3723        .flatten()
3724}
3725
3726impl Render for GitPanel {
3727    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
3728        let project = self.project.read(cx);
3729        let has_entries = self.entries.len() > 0;
3730        let room = self
3731            .workspace
3732            .upgrade()
3733            .and_then(|workspace| workspace.read(cx).active_call()?.read(cx).room().cloned());
3734
3735        let has_write_access = self.has_write_access(cx);
3736
3737        let has_co_authors = room.map_or(false, |room| {
3738            room.read(cx)
3739                .remote_participants()
3740                .values()
3741                .any(|remote_participant| remote_participant.can_write())
3742        });
3743
3744        v_flex()
3745            .id("git_panel")
3746            .key_context(self.dispatch_context(window, cx))
3747            .track_focus(&self.focus_handle)
3748            .on_modifiers_changed(cx.listener(Self::handle_modifiers_changed))
3749            .when(has_write_access && !project.is_read_only(cx), |this| {
3750                this.on_action(cx.listener(Self::toggle_staged_for_selected))
3751                    .on_action(cx.listener(GitPanel::commit))
3752                    .on_action(cx.listener(Self::stage_all))
3753                    .on_action(cx.listener(Self::unstage_all))
3754                    .on_action(cx.listener(Self::stage_selected))
3755                    .on_action(cx.listener(Self::unstage_selected))
3756                    .on_action(cx.listener(Self::restore_tracked_files))
3757                    .on_action(cx.listener(Self::revert_selected))
3758                    .on_action(cx.listener(Self::clean_all))
3759                    .on_action(cx.listener(Self::generate_commit_message_action))
3760            })
3761            .on_action(cx.listener(Self::select_first))
3762            .on_action(cx.listener(Self::select_next))
3763            .on_action(cx.listener(Self::select_previous))
3764            .on_action(cx.listener(Self::select_last))
3765            .on_action(cx.listener(Self::close_panel))
3766            .on_action(cx.listener(Self::open_diff))
3767            .on_action(cx.listener(Self::open_file))
3768            .on_action(cx.listener(Self::focus_changes_list))
3769            .on_action(cx.listener(Self::focus_editor))
3770            .on_action(cx.listener(Self::expand_commit_editor))
3771            .when(has_write_access && has_co_authors, |git_panel| {
3772                git_panel.on_action(cx.listener(Self::toggle_fill_co_authors))
3773            })
3774            .on_hover(cx.listener(move |this, hovered, window, cx| {
3775                if *hovered {
3776                    this.horizontal_scrollbar.show(cx);
3777                    this.vertical_scrollbar.show(cx);
3778                    cx.notify();
3779                } else if !this.focus_handle.contains_focused(window, cx) {
3780                    this.hide_scrollbars(window, cx);
3781                }
3782            }))
3783            .size_full()
3784            .overflow_hidden()
3785            .bg(ElevationIndex::Surface.bg(cx))
3786            .child(
3787                v_flex()
3788                    .size_full()
3789                    .children(self.render_panel_header(window, cx))
3790                    .map(|this| {
3791                        if has_entries {
3792                            this.child(self.render_entries(has_write_access, window, cx))
3793                        } else {
3794                            this.child(self.render_empty_state(cx).into_any_element())
3795                        }
3796                    })
3797                    .children(self.render_footer(window, cx))
3798                    .children(self.render_previous_commit(cx))
3799                    .into_any_element(),
3800            )
3801            .children(self.context_menu.as_ref().map(|(menu, position, _)| {
3802                deferred(
3803                    anchored()
3804                        .position(*position)
3805                        .anchor(gpui::Corner::TopLeft)
3806                        .child(menu.clone()),
3807                )
3808                .with_priority(1)
3809            }))
3810    }
3811}
3812
3813impl Focusable for GitPanel {
3814    fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
3815        self.focus_handle.clone()
3816    }
3817}
3818
3819impl EventEmitter<Event> for GitPanel {}
3820
3821impl EventEmitter<PanelEvent> for GitPanel {}
3822
3823pub(crate) struct GitPanelAddon {
3824    pub(crate) workspace: WeakEntity<Workspace>,
3825}
3826
3827impl editor::Addon for GitPanelAddon {
3828    fn to_any(&self) -> &dyn std::any::Any {
3829        self
3830    }
3831
3832    fn render_buffer_header_controls(
3833        &self,
3834        excerpt_info: &ExcerptInfo,
3835        window: &Window,
3836        cx: &App,
3837    ) -> Option<AnyElement> {
3838        let file = excerpt_info.buffer.file()?;
3839        let git_panel = self.workspace.upgrade()?.read(cx).panel::<GitPanel>(cx)?;
3840
3841        git_panel
3842            .read(cx)
3843            .render_buffer_header_controls(&git_panel, &file, window, cx)
3844    }
3845}
3846
3847impl Panel for GitPanel {
3848    fn persistent_name() -> &'static str {
3849        "GitPanel"
3850    }
3851
3852    fn position(&self, _: &Window, cx: &App) -> DockPosition {
3853        GitPanelSettings::get_global(cx).dock
3854    }
3855
3856    fn position_is_valid(&self, position: DockPosition) -> bool {
3857        matches!(position, DockPosition::Left | DockPosition::Right)
3858    }
3859
3860    fn set_position(&mut self, position: DockPosition, _: &mut Window, cx: &mut Context<Self>) {
3861        settings::update_settings_file::<GitPanelSettings>(
3862            self.fs.clone(),
3863            cx,
3864            move |settings, _| settings.dock = Some(position),
3865        );
3866    }
3867
3868    fn size(&self, _: &Window, cx: &App) -> Pixels {
3869        self.width
3870            .unwrap_or_else(|| GitPanelSettings::get_global(cx).default_width)
3871    }
3872
3873    fn set_size(&mut self, size: Option<Pixels>, _: &mut Window, cx: &mut Context<Self>) {
3874        self.width = size;
3875        self.serialize(cx);
3876        cx.notify();
3877    }
3878
3879    fn icon(&self, _: &Window, cx: &App) -> Option<ui::IconName> {
3880        Some(ui::IconName::GitBranchSmall).filter(|_| GitPanelSettings::get_global(cx).button)
3881    }
3882
3883    fn icon_tooltip(&self, _window: &Window, _cx: &App) -> Option<&'static str> {
3884        Some("Git Panel")
3885    }
3886
3887    fn toggle_action(&self) -> Box<dyn Action> {
3888        Box::new(ToggleFocus)
3889    }
3890
3891    fn activation_priority(&self) -> u32 {
3892        2
3893    }
3894}
3895
3896impl PanelHeader for GitPanel {}
3897
3898struct GitPanelMessageTooltip {
3899    commit_tooltip: Option<Entity<CommitTooltip>>,
3900}
3901
3902impl GitPanelMessageTooltip {
3903    fn new(
3904        git_panel: Entity<GitPanel>,
3905        sha: SharedString,
3906        window: &mut Window,
3907        cx: &mut App,
3908    ) -> Entity<Self> {
3909        cx.new(|cx| {
3910            cx.spawn_in(window, |this, mut cx| async move {
3911                let details = git_panel
3912                    .update(&mut cx, |git_panel, cx| {
3913                        git_panel.load_commit_details(&sha, cx)
3914                    })?
3915                    .await?;
3916
3917                let commit_details = editor::commit_tooltip::CommitDetails {
3918                    sha: details.sha.clone(),
3919                    committer_name: details.committer_name.clone(),
3920                    committer_email: details.committer_email.clone(),
3921                    commit_time: OffsetDateTime::from_unix_timestamp(details.commit_timestamp)?,
3922                    message: Some(editor::commit_tooltip::ParsedCommitMessage {
3923                        message: details.message.clone(),
3924                        ..Default::default()
3925                    }),
3926                };
3927
3928                this.update_in(&mut cx, |this: &mut GitPanelMessageTooltip, window, cx| {
3929                    this.commit_tooltip =
3930                        Some(cx.new(move |cx| CommitTooltip::new(commit_details, window, cx)));
3931                    cx.notify();
3932                })
3933            })
3934            .detach();
3935
3936            Self {
3937                commit_tooltip: None,
3938            }
3939        })
3940    }
3941}
3942
3943impl Render for GitPanelMessageTooltip {
3944    fn render(&mut self, _window: &mut Window, _cx: &mut Context<'_, Self>) -> impl IntoElement {
3945        if let Some(commit_tooltip) = &self.commit_tooltip {
3946            commit_tooltip.clone().into_any_element()
3947        } else {
3948            gpui::Empty.into_any_element()
3949        }
3950    }
3951}
3952
3953#[derive(IntoElement, IntoComponent)]
3954#[component(scope = "Version Control")]
3955pub struct PanelRepoFooter {
3956    id: SharedString,
3957    active_repository: SharedString,
3958    branch: Option<Branch>,
3959    // Getting a GitPanel in previews will be difficult.
3960    //
3961    // For now just take an option here, and we won't bind handlers to buttons in previews.
3962    git_panel: Option<Entity<GitPanel>>,
3963}
3964
3965impl PanelRepoFooter {
3966    pub fn new(
3967        id: impl Into<SharedString>,
3968        active_repository: SharedString,
3969        branch: Option<Branch>,
3970        git_panel: Option<Entity<GitPanel>>,
3971    ) -> Self {
3972        Self {
3973            id: id.into(),
3974            active_repository,
3975            branch,
3976            git_panel,
3977        }
3978    }
3979
3980    pub fn new_preview(
3981        id: impl Into<SharedString>,
3982        active_repository: SharedString,
3983        branch: Option<Branch>,
3984    ) -> Self {
3985        Self {
3986            id: id.into(),
3987            active_repository,
3988            branch,
3989            git_panel: None,
3990        }
3991    }
3992}
3993
3994impl RenderOnce for PanelRepoFooter {
3995    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
3996        let project = self
3997            .git_panel
3998            .as_ref()
3999            .map(|panel| panel.read(cx).project.clone());
4000
4001        let repo = self
4002            .git_panel
4003            .as_ref()
4004            .and_then(|panel| panel.read(cx).active_repository.clone());
4005
4006        let single_repo = project
4007            .as_ref()
4008            .map(|project| {
4009                filtered_repository_entries(project.read(cx).git_store().read(cx), cx).len() == 1
4010            })
4011            .unwrap_or(true);
4012
4013        const MAX_BRANCH_LEN: usize = 16;
4014        const MAX_REPO_LEN: usize = 16;
4015        const LABEL_CHARACTER_BUDGET: usize = MAX_BRANCH_LEN + MAX_REPO_LEN;
4016
4017        let branch = self.branch.clone();
4018        let branch_name = branch
4019            .as_ref()
4020            .map_or(" (no branch)".into(), |branch| branch.name.clone());
4021        let active_repo_name = self.active_repository.clone();
4022
4023        let branch_actual_len = branch_name.len();
4024        let repo_actual_len = active_repo_name.len();
4025
4026        // ideally, show the whole branch and repo names but
4027        // when we can't, use a budget to allocate space between the two
4028        let (repo_display_len, branch_display_len) = if branch_actual_len + repo_actual_len
4029            <= LABEL_CHARACTER_BUDGET
4030        {
4031            (repo_actual_len, branch_actual_len)
4032        } else {
4033            if branch_actual_len <= MAX_BRANCH_LEN {
4034                let repo_space = (LABEL_CHARACTER_BUDGET - branch_actual_len).min(MAX_REPO_LEN);
4035                (repo_space, branch_actual_len)
4036            } else if repo_actual_len <= MAX_REPO_LEN {
4037                let branch_space = (LABEL_CHARACTER_BUDGET - repo_actual_len).min(MAX_BRANCH_LEN);
4038                (repo_actual_len, branch_space)
4039            } else {
4040                (MAX_REPO_LEN, MAX_BRANCH_LEN)
4041            }
4042        };
4043
4044        let truncated_repo_name = if repo_actual_len <= repo_display_len {
4045            active_repo_name.to_string()
4046        } else {
4047            util::truncate_and_trailoff(active_repo_name.trim_ascii(), repo_display_len)
4048        };
4049
4050        let truncated_branch_name = if branch_actual_len <= branch_display_len {
4051            branch_name.to_string()
4052        } else {
4053            util::truncate_and_trailoff(branch_name.trim_ascii(), branch_display_len)
4054        };
4055
4056        let repo_selector_trigger = Button::new("repo-selector", truncated_repo_name)
4057            .style(ButtonStyle::Transparent)
4058            .size(ButtonSize::None)
4059            .label_size(LabelSize::Small)
4060            .color(Color::Muted);
4061
4062        let repo_selector = PopoverMenu::new("repository-switcher")
4063            .menu({
4064                let project = project.clone();
4065                move |window, cx| {
4066                    let project = project.clone()?;
4067                    Some(cx.new(|cx| RepositorySelector::new(project, window, cx)))
4068                }
4069            })
4070            .trigger_with_tooltip(
4071                repo_selector_trigger.disabled(single_repo).truncate(true),
4072                Tooltip::text("Switch active repository"),
4073            )
4074            .attach(gpui::Corner::BottomLeft)
4075            .into_any_element();
4076
4077        let branch_selector_button = Button::new("branch-selector", truncated_branch_name)
4078            .style(ButtonStyle::Transparent)
4079            .size(ButtonSize::None)
4080            .label_size(LabelSize::Small)
4081            .truncate(true)
4082            .tooltip(Tooltip::for_action_title(
4083                "Switch Branch",
4084                &zed_actions::git::Branch,
4085            ))
4086            .on_click(|_, window, cx| {
4087                window.dispatch_action(zed_actions::git::Branch.boxed_clone(), cx);
4088            });
4089
4090        let branch_selector = PopoverMenu::new("popover-button")
4091            .menu(move |window, cx| Some(branch_picker::popover(repo.clone(), window, cx)))
4092            .trigger_with_tooltip(
4093                branch_selector_button,
4094                Tooltip::for_action_title("Switch Branch", &zed_actions::git::Branch),
4095            )
4096            .anchor(Corner::TopLeft)
4097            .offset(gpui::Point {
4098                x: px(0.0),
4099                y: px(-2.0),
4100            });
4101
4102        let spinner = self
4103            .git_panel
4104            .as_ref()
4105            .and_then(|git_panel| git_panel.read(cx).render_spinner());
4106
4107        h_flex()
4108            .w_full()
4109            .px_2()
4110            .h(px(36.))
4111            .items_center()
4112            .justify_between()
4113            .gap_1()
4114            .child(
4115                h_flex()
4116                    .flex_1()
4117                    .overflow_hidden()
4118                    .items_center()
4119                    .child(
4120                        div().child(
4121                            Icon::new(IconName::GitBranchSmall)
4122                                .size(IconSize::Small)
4123                                .color(if single_repo {
4124                                    Color::Disabled
4125                                } else {
4126                                    Color::Muted
4127                                }),
4128                        ),
4129                    )
4130                    .child(repo_selector)
4131                    .when_some(branch.clone(), |this, _| {
4132                        this.child(
4133                            div()
4134                                .text_color(cx.theme().colors().text_muted)
4135                                .text_sm()
4136                                .child("/"),
4137                        )
4138                    })
4139                    .child(branch_selector),
4140            )
4141            .child(
4142                h_flex()
4143                    .gap_1()
4144                    .flex_shrink_0()
4145                    .children(spinner)
4146                    .when_some(branch, |this, branch| {
4147                        let mut focus_handle = None;
4148                        if let Some(git_panel) = self.git_panel.as_ref() {
4149                            if !git_panel.read(cx).can_push_and_pull(cx) {
4150                                return this;
4151                            }
4152                            focus_handle = Some(git_panel.focus_handle(cx));
4153                        }
4154
4155                        this.children(render_remote_button(
4156                            self.id.clone(),
4157                            &branch,
4158                            focus_handle,
4159                            true,
4160                        ))
4161                    }),
4162            )
4163    }
4164}
4165
4166impl ComponentPreview for PanelRepoFooter {
4167    fn preview(_window: &mut Window, _cx: &mut App) -> AnyElement {
4168        let unknown_upstream = None;
4169        let no_remote_upstream = Some(UpstreamTracking::Gone);
4170        let ahead_of_upstream = Some(
4171            UpstreamTrackingStatus {
4172                ahead: 2,
4173                behind: 0,
4174            }
4175            .into(),
4176        );
4177        let behind_upstream = Some(
4178            UpstreamTrackingStatus {
4179                ahead: 0,
4180                behind: 2,
4181            }
4182            .into(),
4183        );
4184        let ahead_and_behind_upstream = Some(
4185            UpstreamTrackingStatus {
4186                ahead: 3,
4187                behind: 1,
4188            }
4189            .into(),
4190        );
4191
4192        let not_ahead_or_behind_upstream = Some(
4193            UpstreamTrackingStatus {
4194                ahead: 0,
4195                behind: 0,
4196            }
4197            .into(),
4198        );
4199
4200        fn branch(upstream: Option<UpstreamTracking>) -> Branch {
4201            Branch {
4202                is_head: true,
4203                name: "some-branch".into(),
4204                upstream: upstream.map(|tracking| Upstream {
4205                    ref_name: "origin/some-branch".into(),
4206                    tracking,
4207                }),
4208                most_recent_commit: Some(CommitSummary {
4209                    sha: "abc123".into(),
4210                    subject: "Modify stuff".into(),
4211                    commit_timestamp: 1710932954,
4212                    has_parent: true,
4213                }),
4214            }
4215        }
4216
4217        fn custom(branch_name: &str, upstream: Option<UpstreamTracking>) -> Branch {
4218            Branch {
4219                is_head: true,
4220                name: branch_name.to_string().into(),
4221                upstream: upstream.map(|tracking| Upstream {
4222                    ref_name: format!("zed/{}", branch_name).into(),
4223                    tracking,
4224                }),
4225                most_recent_commit: Some(CommitSummary {
4226                    sha: "abc123".into(),
4227                    subject: "Modify stuff".into(),
4228                    commit_timestamp: 1710932954,
4229                    has_parent: true,
4230                }),
4231            }
4232        }
4233
4234        fn active_repository(id: usize) -> SharedString {
4235            format!("repo-{}", id).into()
4236        }
4237
4238        let example_width = px(340.);
4239
4240        v_flex()
4241            .gap_6()
4242            .w_full()
4243            .flex_none()
4244            .children(vec![example_group_with_title(
4245                "Action Button States",
4246                vec![
4247                    single_example(
4248                        "No Branch",
4249                        div()
4250                            .w(example_width)
4251                            .overflow_hidden()
4252                            .child(PanelRepoFooter::new_preview(
4253                                "no-branch",
4254                                active_repository(1).clone(),
4255                                None,
4256                            ))
4257                            .into_any_element(),
4258                    )
4259                    .grow(),
4260                    single_example(
4261                        "Remote status unknown",
4262                        div()
4263                            .w(example_width)
4264                            .overflow_hidden()
4265                            .child(PanelRepoFooter::new_preview(
4266                                "unknown-upstream",
4267                                active_repository(2).clone(),
4268                                Some(branch(unknown_upstream)),
4269                            ))
4270                            .into_any_element(),
4271                    )
4272                    .grow(),
4273                    single_example(
4274                        "No Remote Upstream",
4275                        div()
4276                            .w(example_width)
4277                            .overflow_hidden()
4278                            .child(PanelRepoFooter::new_preview(
4279                                "no-remote-upstream",
4280                                active_repository(3).clone(),
4281                                Some(branch(no_remote_upstream)),
4282                            ))
4283                            .into_any_element(),
4284                    )
4285                    .grow(),
4286                    single_example(
4287                        "Not Ahead or Behind",
4288                        div()
4289                            .w(example_width)
4290                            .overflow_hidden()
4291                            .child(PanelRepoFooter::new_preview(
4292                                "not-ahead-or-behind",
4293                                active_repository(4).clone(),
4294                                Some(branch(not_ahead_or_behind_upstream)),
4295                            ))
4296                            .into_any_element(),
4297                    )
4298                    .grow(),
4299                    single_example(
4300                        "Behind remote",
4301                        div()
4302                            .w(example_width)
4303                            .overflow_hidden()
4304                            .child(PanelRepoFooter::new_preview(
4305                                "behind-remote",
4306                                active_repository(5).clone(),
4307                                Some(branch(behind_upstream)),
4308                            ))
4309                            .into_any_element(),
4310                    )
4311                    .grow(),
4312                    single_example(
4313                        "Ahead of remote",
4314                        div()
4315                            .w(example_width)
4316                            .overflow_hidden()
4317                            .child(PanelRepoFooter::new_preview(
4318                                "ahead-of-remote",
4319                                active_repository(6).clone(),
4320                                Some(branch(ahead_of_upstream)),
4321                            ))
4322                            .into_any_element(),
4323                    )
4324                    .grow(),
4325                    single_example(
4326                        "Ahead and behind remote",
4327                        div()
4328                            .w(example_width)
4329                            .overflow_hidden()
4330                            .child(PanelRepoFooter::new_preview(
4331                                "ahead-and-behind",
4332                                active_repository(7).clone(),
4333                                Some(branch(ahead_and_behind_upstream)),
4334                            ))
4335                            .into_any_element(),
4336                    )
4337                    .grow(),
4338                ],
4339            )
4340            .grow()
4341            .vertical()])
4342            .children(vec![example_group_with_title(
4343                "Labels",
4344                vec![
4345                    single_example(
4346                        "Short Branch & Repo",
4347                        div()
4348                            .w(example_width)
4349                            .overflow_hidden()
4350                            .child(PanelRepoFooter::new_preview(
4351                                "short-branch",
4352                                SharedString::from("zed"),
4353                                Some(custom("main", behind_upstream)),
4354                            ))
4355                            .into_any_element(),
4356                    )
4357                    .grow(),
4358                    single_example(
4359                        "Long Branch",
4360                        div()
4361                            .w(example_width)
4362                            .overflow_hidden()
4363                            .child(PanelRepoFooter::new_preview(
4364                                "long-branch",
4365                                SharedString::from("zed"),
4366                                Some(custom(
4367                                    "redesign-and-update-git-ui-list-entry-style",
4368                                    behind_upstream,
4369                                )),
4370                            ))
4371                            .into_any_element(),
4372                    )
4373                    .grow(),
4374                    single_example(
4375                        "Long Repo",
4376                        div()
4377                            .w(example_width)
4378                            .overflow_hidden()
4379                            .child(PanelRepoFooter::new_preview(
4380                                "long-repo",
4381                                SharedString::from("zed-industries-community-examples"),
4382                                Some(custom("gpui", ahead_of_upstream)),
4383                            ))
4384                            .into_any_element(),
4385                    )
4386                    .grow(),
4387                    single_example(
4388                        "Long Repo & Branch",
4389                        div()
4390                            .w(example_width)
4391                            .overflow_hidden()
4392                            .child(PanelRepoFooter::new_preview(
4393                                "long-repo-and-branch",
4394                                SharedString::from("zed-industries-community-examples"),
4395                                Some(custom(
4396                                    "redesign-and-update-git-ui-list-entry-style",
4397                                    behind_upstream,
4398                                )),
4399                            ))
4400                            .into_any_element(),
4401                    )
4402                    .grow(),
4403                    single_example(
4404                        "Uppercase Repo",
4405                        div()
4406                            .w(example_width)
4407                            .overflow_hidden()
4408                            .child(PanelRepoFooter::new_preview(
4409                                "uppercase-repo",
4410                                SharedString::from("LICENSES"),
4411                                Some(custom("main", ahead_of_upstream)),
4412                            ))
4413                            .into_any_element(),
4414                    )
4415                    .grow(),
4416                    single_example(
4417                        "Uppercase Branch",
4418                        div()
4419                            .w(example_width)
4420                            .overflow_hidden()
4421                            .child(PanelRepoFooter::new_preview(
4422                                "uppercase-branch",
4423                                SharedString::from("zed"),
4424                                Some(custom("update-README", behind_upstream)),
4425                            ))
4426                            .into_any_element(),
4427                    )
4428                    .grow(),
4429                ],
4430            )
4431            .grow()
4432            .vertical()])
4433            .into_any_element()
4434    }
4435}
4436
4437#[cfg(test)]
4438mod tests {
4439    use git::status::StatusCode;
4440    use gpui::TestAppContext;
4441    use project::{FakeFs, WorktreeSettings};
4442    use serde_json::json;
4443    use settings::SettingsStore;
4444    use theme::LoadThemes;
4445    use util::path;
4446
4447    use super::*;
4448
4449    fn init_test(cx: &mut gpui::TestAppContext) {
4450        if std::env::var("RUST_LOG").is_ok() {
4451            env_logger::try_init().ok();
4452        }
4453
4454        cx.update(|cx| {
4455            let settings_store = SettingsStore::test(cx);
4456            cx.set_global(settings_store);
4457            AssistantSettings::register(cx);
4458            WorktreeSettings::register(cx);
4459            workspace::init_settings(cx);
4460            theme::init(LoadThemes::JustBase, cx);
4461            language::init(cx);
4462            editor::init(cx);
4463            Project::init_settings(cx);
4464            crate::init(cx);
4465        });
4466    }
4467
4468    #[gpui::test]
4469    async fn test_entry_worktree_paths(cx: &mut TestAppContext) {
4470        init_test(cx);
4471        let fs = FakeFs::new(cx.background_executor.clone());
4472        fs.insert_tree(
4473            "/root",
4474            json!({
4475                "zed": {
4476                    ".git": {},
4477                    "crates": {
4478                        "gpui": {
4479                            "gpui.rs": "fn main() {}"
4480                        },
4481                        "util": {
4482                            "util.rs": "fn do_it() {}"
4483                        }
4484                    }
4485                },
4486            }),
4487        )
4488        .await;
4489
4490        fs.set_status_for_repo_via_git_operation(
4491            Path::new(path!("/root/zed/.git")),
4492            &[
4493                (
4494                    Path::new("crates/gpui/gpui.rs"),
4495                    StatusCode::Modified.worktree(),
4496                ),
4497                (
4498                    Path::new("crates/util/util.rs"),
4499                    StatusCode::Modified.worktree(),
4500                ),
4501            ],
4502        );
4503
4504        let project =
4505            Project::test(fs.clone(), [path!("/root/zed/crates/gpui").as_ref()], cx).await;
4506        let (workspace, cx) =
4507            cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
4508
4509        cx.read(|cx| {
4510            project
4511                .read(cx)
4512                .worktrees(cx)
4513                .nth(0)
4514                .unwrap()
4515                .read(cx)
4516                .as_local()
4517                .unwrap()
4518                .scan_complete()
4519        })
4520        .await;
4521
4522        cx.executor().run_until_parked();
4523
4524        let app_state = workspace.update(cx, |workspace, _| workspace.app_state().clone());
4525        let panel = cx.new_window_entity(|window, cx| {
4526            GitPanel::new(workspace.clone(), project.clone(), app_state, window, cx)
4527        });
4528
4529        let handle = cx.update_window_entity(&panel, |panel, _, _| {
4530            std::mem::replace(&mut panel.update_visible_entries_task, Task::ready(()))
4531        });
4532        cx.executor().advance_clock(2 * UPDATE_DEBOUNCE);
4533        handle.await;
4534
4535        let entries = panel.update(cx, |panel, _| panel.entries.clone());
4536        pretty_assertions::assert_eq!(
4537            entries,
4538            [
4539                GitListEntry::Header(GitHeaderEntry {
4540                    header: Section::Tracked
4541                }),
4542                GitListEntry::GitStatusEntry(GitStatusEntry {
4543                    abs_path: path!("/root/zed/crates/gpui/gpui.rs").into(),
4544                    repo_path: "crates/gpui/gpui.rs".into(),
4545                    worktree_path: Path::new("gpui.rs").into(),
4546                    status: StatusCode::Modified.worktree(),
4547                    staging: StageStatus::Unstaged,
4548                }),
4549                GitListEntry::GitStatusEntry(GitStatusEntry {
4550                    abs_path: path!("/root/zed/crates/util/util.rs").into(),
4551                    repo_path: "crates/util/util.rs".into(),
4552                    worktree_path: Path::new("../util/util.rs").into(),
4553                    status: StatusCode::Modified.worktree(),
4554                    staging: StageStatus::Unstaged,
4555                },),
4556            ],
4557        );
4558
4559        cx.update_window_entity(&panel, |panel, window, cx| {
4560            panel.select_last(&Default::default(), window, cx);
4561            assert_eq!(panel.selected_entry, Some(2));
4562            panel.open_diff(&Default::default(), window, cx);
4563        });
4564        cx.run_until_parked();
4565
4566        let worktree_roots = workspace.update(cx, |workspace, cx| {
4567            workspace
4568                .worktrees(cx)
4569                .map(|worktree| worktree.read(cx).abs_path())
4570                .collect::<Vec<_>>()
4571        });
4572        pretty_assertions::assert_eq!(
4573            worktree_roots,
4574            vec![
4575                Path::new(path!("/root/zed/crates/gpui")).into(),
4576                Path::new(path!("/root/zed/crates/util/util.rs")).into(),
4577            ]
4578        );
4579
4580        let repo_from_single_file_worktree = project.update(cx, |project, cx| {
4581            let git_store = project.git_store().read(cx);
4582            // The repo that comes from the single-file worktree can't be selected through the UI.
4583            let filtered_entries = filtered_repository_entries(git_store, cx)
4584                .iter()
4585                .map(|repo| repo.read(cx).worktree_abs_path.clone())
4586                .collect::<Vec<_>>();
4587            assert_eq!(
4588                filtered_entries,
4589                [Path::new(path!("/root/zed/crates/gpui")).into()]
4590            );
4591            // But we can select it artificially here.
4592            git_store
4593                .all_repositories()
4594                .into_iter()
4595                .find(|repo| {
4596                    &*repo.read(cx).worktree_abs_path
4597                        == Path::new(path!("/root/zed/crates/util/util.rs"))
4598                })
4599                .unwrap()
4600        });
4601
4602        // Paths still make sense when we somehow activate a repo that comes from a single-file worktree.
4603        repo_from_single_file_worktree.update(cx, |repo, cx| repo.activate(cx));
4604        let handle = cx.update_window_entity(&panel, |panel, _, _| {
4605            std::mem::replace(&mut panel.update_visible_entries_task, Task::ready(()))
4606        });
4607        cx.executor().advance_clock(2 * UPDATE_DEBOUNCE);
4608        handle.await;
4609        let entries = panel.update(cx, |panel, _| panel.entries.clone());
4610        pretty_assertions::assert_eq!(
4611            entries,
4612            [
4613                GitListEntry::Header(GitHeaderEntry {
4614                    header: Section::Tracked
4615                }),
4616                GitListEntry::GitStatusEntry(GitStatusEntry {
4617                    abs_path: path!("/root/zed/crates/gpui/gpui.rs").into(),
4618                    repo_path: "crates/gpui/gpui.rs".into(),
4619                    worktree_path: Path::new("../../gpui/gpui.rs").into(),
4620                    status: StatusCode::Modified.worktree(),
4621                    staging: StageStatus::Unstaged,
4622                }),
4623                GitListEntry::GitStatusEntry(GitStatusEntry {
4624                    abs_path: path!("/root/zed/crates/util/util.rs").into(),
4625                    repo_path: "crates/util/util.rs".into(),
4626                    worktree_path: Path::new("util.rs").into(),
4627                    status: StatusCode::Modified.worktree(),
4628                    staging: StageStatus::Unstaged,
4629                },),
4630            ],
4631        );
4632    }
4633}