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