Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

outline_panel: Show deleted files inside the file tree (#63570)

František Gažod27fa556ce1e
diff --git a/Cargo.lock b/Cargo.lock
index d4b1f45f770..940ebfa13b5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -12505,14 +12505,15 @@ version = "0.1.0"
dependencies = [
"anyhow",
"async-channel 2.5.0",
+ "buffer_diff",
"collections",
"db",
"editor",
"file_icons",
"futures 0.3.34",
"fuzzy",
+ "git",
"gpui",
- "itertools 0.14.0",
"language",
"log",
"lsp",
diff --git a/crates/outline_panel/Cargo.toml b/crates/outline_panel/Cargo.toml
index 2db006dc156..af3e8bdc43f 100644
--- a/crates/outline_panel/Cargo.toml
+++ b/crates/outline_panel/Cargo.toml
@@ -21,8 +21,8 @@ editor.workspace = true
file_icons.workspace = true
fuzzy.workspace = true
futures.workspace = true
+git.workspace = true
gpui.workspace = true
-itertools.workspace = true
language.workspace = true
log.workspace = true
menu.workspace = true
@@ -42,6 +42,7 @@ worktree.workspace = true
zed_actions.workspace = true
[dev-dependencies]
+buffer_diff.workspace = true
lsp.workspace = true
search = { workspace = true, features = ["test-support"] }
pretty_assertions.workspace = true
diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rs
index 4e8b0beb464..083d4fcacec 100644
--- a/crates/outline_panel/src/outline_panel.rs
+++ b/crates/outline_panel/src/outline_panel.rs
@@ -1,7 +1,7 @@
mod outline_panel_settings;
use anyhow::Context as _;
-use collections::{BTreeSet, HashMap, HashSet};
+use collections::{BTreeMap, BTreeSet, HashMap, HashSet, IndexMap};
use db::kvp::KeyValueStore;
use editor::{
AnchorRangeExt, Bias, DisplayPoint, Editor, EditorEvent, ExcerptRange, MultiBufferSnapshot,
@@ -13,23 +13,22 @@ use editor::{
use file_icons::FileIcons;
use fuzzy::{StringMatch, StringMatchCandidate, match_strings};
+use git::status::{FileStatus, GitSummary};
use gpui::{
Action, AnyElement, App, AppContext as _, AsyncWindowContext, Bounds, ClipboardItem, Context,
DismissEvent, Div, ElementId, Entity, EventEmitter, FocusHandle, Focusable, HighlightStyle,
InteractiveElement, IntoElement, KeyContext, ListHorizontalSizingBehavior, ListSizingBehavior,
MouseButton, MouseDownEvent, ParentElement, Pixels, Point, Render, ScrollStrategy,
- SharedString, Stateful, StatefulInteractiveElement as _, Styled, Subscription, Task, TaskExt,
+ SharedString, Stateful, StatefulInteractiveElement as _, Styled, Subscription, Task,
UniformListScrollHandle, WeakEntity, Window, actions, anchored, deferred, div, point, px, size,
uniform_list,
};
-use itertools::Itertools;
-use language::{Anchor, BufferId, BufferSnapshot, OffsetRangeExt, OutlineItem};
+use language::{Anchor, BufferId, BufferSnapshot, DiskState, OffsetRangeExt, OutlineItem};
use language::{LanguageAwareStyling, language_settings::LanguageSettings};
use menu::{Cancel, SelectFirst, SelectLast, SelectNext, SelectPrevious};
use std::{
cmp,
- collections::BTreeMap,
hash::Hash,
ops::Range,
path::{Path, PathBuf},
@@ -42,11 +41,11 @@ use std::{
};
use outline_panel_settings::{DockSide, FolderIndicator, OutlinePanelSettings, ShowIndentGuides};
-use project::{File, Fs, GitEntry, GitTraversal, Project, ProjectItem};
+use project::{File, Fs, Project, ProjectPath};
use search::{BufferSearchBar, ProjectSearchView};
use serde::{Deserialize, Serialize};
use settings::{Settings, SettingsStore};
-use theme::SyntaxTheme;
+use theme::{GlobalTheme, SyntaxTheme};
use theme_settings::ThemeSettings;
use ui::{
ContextMenu, FluentBuilder, HighlightedLabel, IconButton, IconButtonShape, IndentGuideColors,
@@ -60,7 +59,7 @@ use workspace::{
item::ItemHandle,
searchable::{SearchEvent, SearchableItem},
};
-use worktree::{Entry, ProjectEntryId, WorktreeId};
+use worktree::{PathProgress, PathTarget, WorktreeId};
use crate::outline_panel_settings::OutlinePanelSettingsScrollbarProxy;
@@ -110,6 +109,7 @@ const OUTLINE_PANEL_KEY: &str = "OutlinePanel";
const UPDATE_DEBOUNCE: Duration = Duration::from_millis(50);
type Outline = OutlineItem<language::Anchor>;
+type OutlineChildren = HashMap<(Range<Anchor>, usize), bool>;
type HighlightStyleData = Arc<OnceLock<Vec<(Range<usize>, HighlightStyle)>>>;
pub struct OutlinePanel {
@@ -123,11 +123,11 @@ pub struct OutlinePanel {
context_menu: Option<(Entity<ContextMenu>, Point<Pixels>, Subscription)>,
focus_handle: FocusHandle,
pending_serialization: Task<Option<()>>,
- fs_entries_depth: HashMap<(WorktreeId, ProjectEntryId), usize>,
+
fs_entries: Vec<FsEntry>,
fs_children_count: HashMap<WorktreeId, HashMap<Arc<RelPath>, FsChildren>>,
collapsed_entries: HashSet<CollapsedEntry>,
- unfolded_dirs: HashMap<WorktreeId, BTreeSet<ProjectEntryId>>,
+ unfolded_dirs: HashMap<WorktreeId, BTreeSet<Arc<RelPath>>>,
selected_entry: SelectedEntry,
active_item: Option<ActiveItem>,
_subscriptions: Vec<Subscription>,
@@ -135,8 +135,9 @@ pub struct OutlinePanel {
fs_entries_update_task: Task<()>,
fs_entries_update_pending: bool,
cached_entries_update_task: Task<()>,
- cached_entries_update_pending: bool,
+ cached_entries_update_pending: Option<CachedEntriesUpdate>,
reveal_selection_task: Task<anyhow::Result<()>>,
+ lsp_outline_refresh_task: Task<()>,
outline_fetch_tasks: HashMap<BufferId, Task<()>>,
buffers: HashMap<BufferId, BufferOutlines>,
cached_entries: Vec<CachedEntry>,
@@ -146,7 +147,7 @@ pub struct OutlinePanel {
preserve_selection_on_buffer_fold_toggles: HashSet<BufferId>,
pending_default_expansion_depth: Option<usize>,
default_depth_applied_buffers: HashSet<BufferId>,
- outline_children_cache: HashMap<BufferId, HashMap<(Range<Anchor>, usize), bool>>,
+ outline_children_cache: HashMap<BufferId, OutlineChildren>,
hide_symbols_override: Option<bool>,
}
@@ -331,6 +332,12 @@ impl FsChildren {
}
}
+#[derive(PartialEq, Eq)]
+enum CachedEntriesUpdate {
+ Entries,
+ Contents,
+}
+
#[derive(Clone, Debug)]
struct CachedEntry {
depth: usize,
@@ -340,7 +347,7 @@ struct CachedEntry {
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
enum CollapsedEntry {
- Dir(WorktreeId, ProjectEntryId),
+ Dir(WorktreeId, Arc<RelPath>),
File(WorktreeId, BufferId),
ExternalFile(BufferId),
Excerpt(ExcerptRange<Anchor>),
@@ -352,6 +359,34 @@ struct BufferOutlines {
outlines: OutlineState,
}
+struct IndexedOutline<'a> {
+ outline: &'a Outline,
+ ranked_range: Range<usize>,
+ collapsed: bool,
+}
+
+struct ExcerptOutlines<'a> {
+ excerpt: &'a ExcerptRange<Anchor>,
+ ranked_range: Range<usize>,
+ expanded: bool,
+ visible: Vec<&'a Outline>,
+ children_to_cache: Vec<usize>,
+}
+
+impl IndexedOutline<'_> {
+ fn is_hidden_by(&self, ancestor: &Self) -> bool {
+ self.outline.depth > ancestor.outline.depth
+ && ancestor.ranked_range.contains(&self.ranked_range.start)
+ }
+
+ fn cache_children(&self, next: Option<&Self>, children: &mut OutlineChildren) {
+ children.insert(
+ (self.outline.range.clone(), self.outline.depth),
+ next.is_some_and(|next| next.outline.depth > self.outline.depth),
+ );
+ }
+}
+
impl BufferOutlines {
fn invalidate_outlines(&mut self) {
if let OutlineState::Outlines(valid_outlines) = &mut self.outlines {
@@ -374,6 +409,247 @@ impl BufferOutlines {
OutlineState::NotFetched => true,
}
}
+
+ fn assign_outline_cache_owners(
+ outlines: &[IndexedOutline<'_>],
+ excerpts: &mut [ExcerptOutlines<'_>],
+ ) {
+ let mut outline_order = (0..outlines.len()).collect::<Vec<_>>();
+ let mut excerpt_order = excerpts
+ .iter()
+ .enumerate()
+ .filter(|(_, excerpt)| excerpt.expanded)
+ .collect::<Vec<_>>();
+ outline_order
+ .sort_unstable_by_key(|&index| cmp::Reverse(outlines[index].ranked_range.start));
+ excerpt_order.sort_unstable_by_key(|(_, excerpt)| cmp::Reverse(excerpt.ranked_range.end));
+ let mut owners = vec![None; outlines.len()];
+ let mut frontier = BTreeMap::new();
+ let mut cursor = 0;
+ for index in outline_order {
+ let outline = &outlines[index];
+ while let Some(&(excerpt_index, excerpt)) = excerpt_order.get(cursor)
+ && excerpt.ranked_range.end >= outline.ranked_range.start
+ {
+ Self::insert_outline_prefix_minimum(
+ &mut frontier,
+ excerpt.ranked_range.start,
+ cmp::Reverse(excerpt_index),
+ );
+ cursor += 1;
+ }
+ let last = frontier.range(..=outline.ranked_range.end).next_back();
+ owners[index] = last.map(|(_, &cmp::Reverse(owner))| owner);
+ }
+ for (index, owner) in owners.into_iter().enumerate() {
+ if let Some(owner) = owner {
+ excerpts[owner].children_to_cache.push(index);
+ }
+ }
+ }
+
+ fn outlines_are_well_formed(outlines: &[IndexedOutline<'_>]) -> bool {
+ if outlines
+ .windows(2)
+ .any(|pair| pair[0].ranked_range.start > pair[1].ranked_range.start)
+ {
+ return false;
+ }
+ let mut ancestors: Vec<&IndexedOutline<'_>> = Vec::new();
+ for outline in outlines {
+ if outline.ranked_range.start > outline.ranked_range.end {
+ return false;
+ }
+ while let Some(&parent) = ancestors.last()
+ && parent.outline.depth >= outline.outline.depth
+ {
+ ancestors.pop();
+ if parent.ranked_range.end > outline.ranked_range.start {
+ return false;
+ }
+ }
+ if ancestors
+ .last()
+ .is_some_and(|parent| outline.ranked_range.end > parent.ranked_range.end)
+ {
+ return false;
+ }
+ ancestors.push(outline);
+ }
+ true
+ }
+
+ fn collect_nested_outlines<'a>(
+ outlines: &[IndexedOutline<'a>],
+ excerpts: &mut [ExcerptOutlines<'a>],
+ children: &mut OutlineChildren,
+ ) {
+ let mut collapsed_ancestor = None;
+ let unfolded = outlines
+ .iter()
+ .enumerate()
+ .filter_map(|(index, outline)| {
+ if collapsed_ancestor.is_some_and(|ancestor| outline.is_hidden_by(ancestor)) {
+ return None;
+ }
+ collapsed_ancestor = outline.collapsed.then_some(outline);
+ Some(index)
+ })
+ .collect::<BTreeSet<_>>();
+ let mut active = BTreeSet::new();
+ let mut unfolded_active = BTreeSet::new();
+ let mut outline_order = (0..outlines.len()).collect::<Vec<_>>();
+ let mut excerpt_order = excerpts
+ .iter_mut()
+ .filter(|excerpt| excerpt.expanded)
+ .collect::<Vec<_>>();
+ outline_order.sort_unstable_by_key(|&index| cmp::Reverse(outlines[index].ranked_range.end));
+ excerpt_order.sort_unstable_by_key(|excerpt| cmp::Reverse(excerpt.ranked_range.start));
+ let mut cursor = 0;
+ for excerpt in excerpt_order {
+ while let Some(&index) = outline_order.get(cursor)
+ && outlines[index].ranked_range.end >= excerpt.ranked_range.start
+ {
+ active.insert(index);
+ if unfolded.contains(&index) {
+ unfolded_active.insert(index);
+ }
+ cursor += 1;
+ }
+ let limit = outlines
+ .partition_point(|outline| outline.ranked_range.start <= excerpt.ranked_range.end);
+ excerpt.visible.extend(
+ unfolded_active
+ .range(..limit)
+ .map(|&index| outlines[index].outline),
+ );
+ for &index in &excerpt.children_to_cache {
+ let next = active
+ .range(index + 1..limit)
+ .next()
+ .map(|&next| &outlines[next]);
+ outlines[index].cache_children(next, children);
+ }
+ }
+ }
+
+ fn collect_overlapping_outlines<'a>(
+ outlines: &[IndexedOutline<'a>],
+ excerpts: &mut [ExcerptOutlines<'a>],
+ children: &mut OutlineChildren,
+ ) {
+ let leaf_count = outlines.len().next_power_of_two();
+ let mut starts = vec![BTreeSet::new(); 2 * leaf_count];
+ let mut depths = vec![BTreeMap::new(); 2 * leaf_count];
+ let mut outline_order = (0..outlines.len()).collect::<Vec<_>>();
+ let mut excerpt_order = excerpts
+ .iter_mut()
+ .filter(|excerpt| excerpt.expanded)
+ .collect::<Vec<_>>();
+ outline_order.sort_unstable_by_key(|&index| cmp::Reverse(outlines[index].ranked_range.end));
+ excerpt_order.sort_unstable_by_key(|excerpt| cmp::Reverse(excerpt.ranked_range.start));
+ let mut cursor = 0;
+ for excerpt in excerpt_order {
+ while let Some(&index) = outline_order.get(cursor)
+ && outlines[index].ranked_range.end >= excerpt.ranked_range.start
+ {
+ let outline = &outlines[index];
+ let mut node = leaf_count + index;
+ while node > 0 {
+ starts[node].insert(outline.ranked_range.start);
+ Self::insert_outline_prefix_minimum(
+ &mut depths[node],
+ outline.ranked_range.start,
+ outline.outline.depth,
+ );
+ node /= 2;
+ }
+ cursor += 1;
+ }
+ for &index in &excerpt.children_to_cache {
+ let next = Self::next_outline(index + 1, leaf_count, |node| {
+ starts[node]
+ .first()
+ .is_some_and(|&start| start <= excerpt.ranked_range.end)
+ });
+ outlines[index].cache_children(next.map(|next| &outlines[next]), children);
+ }
+ let mut collapsed_ancestor: Option<&IndexedOutline<'_>> = None;
+ let mut first = 0;
+ while let Some(index) = Self::next_outline(first, leaf_count, |node| {
+ let Some(&first_start) = starts[node]
+ .first()
+ .filter(|&&start| start <= excerpt.ranked_range.end)
+ else {
+ return false;
+ };
+ let Some(ancestor) = collapsed_ancestor else {
+ return true;
+ };
+ first_start < ancestor.ranked_range.start
+ || starts[node]
+ .range(..=excerpt.ranked_range.end)
+ .next_back()
+ .is_some_and(|&start| start >= ancestor.ranked_range.end)
+ || depths[node]
+ .range(..=excerpt.ranked_range.end)
+ .next_back()
+ .is_some_and(|(_, &depth)| depth <= ancestor.outline.depth)
+ }) {
+ let outline = &outlines[index];
+ excerpt.visible.push(outline.outline);
+ collapsed_ancestor = outline.collapsed.then_some(outline);
+ first = index + 1;
+ }
+ }
+ }
+
+ fn next_outline(
+ first: usize,
+ leaf_count: usize,
+ has_match: impl Fn(usize) -> bool,
+ ) -> Option<usize> {
+ if first >= leaf_count {
+ return None;
+ }
+ let mut node = leaf_count + first;
+ loop {
+ while node.is_multiple_of(2) {
+ node /= 2;
+ }
+ if has_match(node) {
+ while node < leaf_count {
+ node *= 2;
+ if !has_match(node) {
+ node += 1;
+ }
+ }
+ return Some(node - leaf_count);
+ }
+ node += 1;
+ if node.is_power_of_two() {
+ return None;
+ }
+ }
+ }
+
+ fn insert_outline_prefix_minimum<T: Copy + Ord>(
+ minimums: &mut BTreeMap<usize, T>,
+ position: usize,
+ value: T,
+ ) {
+ let previous = minimums.range(..=position).next_back();
+ if previous.is_some_and(|(_, &current)| current <= value) {
+ return;
+ }
+ while let Some((&next_position, &next_value)) = minimums.range(position..).next() {
+ if next_value < value {
+ break;
+ }
+ minimums.remove(&next_position);
+ }
+ minimums.insert(position, value);
+ }
}
#[derive(Debug)]
@@ -386,7 +662,8 @@ enum OutlineState {
#[derive(Clone, Debug, PartialEq, Eq)]
struct FoldedDirsEntry {
worktree_id: WorktreeId,
- entries: Vec<GitEntry>,
+ first_buffer_id: BufferId,
+ entries: Vec<FsEntryPath>,
}
// TODO: collapse the inner enums into panel entry
@@ -431,16 +708,7 @@ impl PartialEq for PanelEntry {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(Self::Fs(a), Self::Fs(b)) => a == b,
- (
- Self::FoldedDirs(FoldedDirsEntry {
- worktree_id: worktree_id_a,
- entries: entries_a,
- }),
- Self::FoldedDirs(FoldedDirsEntry {
- worktree_id: worktree_id_b,
- entries: entries_b,
- }),
- ) => worktree_id_a == worktree_id_b && entries_a == entries_b,
+ (Self::FoldedDirs(left), Self::FoldedDirs(right)) => left == right,
(Self::Outline(a), Self::Outline(b)) => a == b,
(
Self::Search(SearchEntry {
@@ -520,7 +788,7 @@ impl SearchData {
&& extended_context_left_border < context_left_border
&& multi_buffer_snapshot
.chars_at(extended_context_left_border)
- .last()
+ .next()
.is_some_and(|c| !c.is_whitespace());
let truncated_right = entire_context_text
.chars()
@@ -572,50 +840,65 @@ impl OutlineEntry {
}
}
+#[derive(Debug, Clone, Eq)]
+struct FsEntryPath {
+ path: Arc<RelPath>,
+ git_summary: GitSummary,
+ is_ignored: bool,
+}
+
+impl PartialEq for FsEntryPath {
+ fn eq(&self, other: &Self) -> bool {
+ self.path == other.path
+ }
+}
+
#[derive(Debug, Clone, Eq)]
struct FsEntryFile {
worktree_id: WorktreeId,
- entry: GitEntry,
+ entry: FsEntryPath,
buffer_id: BufferId,
- excerpts: Vec<ExcerptRange<language::Anchor>>,
+ excerpts: Arc<[ExcerptRange<Anchor>]>,
+ is_deleted: bool,
}
impl PartialEq for FsEntryFile {
fn eq(&self, other: &Self) -> bool {
- self.worktree_id == other.worktree_id
- && self.entry.id == other.entry.id
- && self.buffer_id == other.buffer_id
+ self.buffer_id == other.buffer_id
}
}
impl Hash for FsEntryFile {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
- (self.buffer_id, self.entry.id, self.worktree_id).hash(state);
+ self.buffer_id.hash(state);
}
}
#[derive(Debug, Clone, Eq)]
struct FsEntryDirectory {
worktree_id: WorktreeId,
- entry: GitEntry,
+ first_buffer_id: BufferId,
+ entry: FsEntryPath,
}
impl PartialEq for FsEntryDirectory {
fn eq(&self, other: &Self) -> bool {
- self.worktree_id == other.worktree_id && self.entry.id == other.entry.id
+ self.worktree_id == other.worktree_id
+ && self.first_buffer_id == other.first_buffer_id
+ && self.entry.path == other.entry.path
}
}
impl Hash for FsEntryDirectory {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
- (self.worktree_id, self.entry.id).hash(state);
+ (self.worktree_id, self.first_buffer_id, &self.entry.path).hash(state);
}
}
#[derive(Debug, Clone, Eq)]
struct FsEntryExternalFile {
buffer_id: BufferId,
- excerpts: Vec<ExcerptRange<language::Anchor>>,
+ excerpts: Arc<[ExcerptRange<Anchor>]>,
}
impl PartialEq for FsEntryExternalFile {
@@ -630,13 +913,78 @@ impl Hash for FsEntryExternalFile {
}
}
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq)]
enum FsEntry {
ExternalFile(FsEntryExternalFile),
Directory(FsEntryDirectory),
File(FsEntryFile),
}
+impl PartialEq for FsEntry {
+ fn eq(&self, other: &Self) -> bool {
+ match (self, other) {
+ (Self::Directory(left), Self::Directory(right)) => left == right,
+ _ => self
+ .buffer_id()
+ .is_some_and(|id| Some(id) == other.buffer_id()),
+ }
+ }
+}
+
+impl FsEntry {
+ fn buffer_id(&self) -> Option<BufferId> {
+ match self {
+ Self::File(file) => Some(file.buffer_id),
+ Self::ExternalFile(file) => Some(file.buffer_id),
+ Self::Directory(_) => None,
+ }
+ }
+}
+
+fn directory_element_id(
+ worktree_id: WorktreeId,
+ first_buffer_id: BufferId,
+ path: &RelPath,
+) -> ElementId {
+ ElementId::from((
+ SharedString::from(format!("directory-{first_buffer_id}-{path}")),
+ worktree_id.to_proto() as usize,
+ ))
+}
+
+fn is_parent_row(entry: &PanelEntry, worktree_id: WorktreeId, parent_path: &RelPath) -> bool {
+ match entry {
+ PanelEntry::Fs(FsEntry::Directory(directory)) => {
+ directory.worktree_id == worktree_id && directory.entry.path.as_ref() == parent_path
+ }
+ PanelEntry::FoldedDirs(folded_dirs) => {
+ folded_dirs.worktree_id == worktree_id
+ && folded_dirs
+ .entries
+ .last()
+ .is_some_and(|dir| dir.path.as_ref() == parent_path)
+ }
+ _ => false,
+ }
+}
+
+fn is_deleted_file(file: &File, status: Option<FileStatus>, has_base_text: bool) -> bool {
+ match file.disk_state {
+ DiskState::Deleted => true,
+ DiskState::Historic { was_deleted } => was_deleted,
+ DiskState::Present { .. } => false,
+ DiskState::New => status.is_some_and(|status| status.is_deleted()) || has_base_text,
+ }
+}
+
+struct BufferExcerpts {
+ is_new: bool,
+ is_folded: bool,
+ excerpts: Vec<ExcerptRange<Anchor>>,
+ file: Option<(worktree::Snapshot, FsEntryPath)>,
+ is_deleted: bool,
+}
+
struct ActiveItem {
item_handle: Box<dyn WeakItemHandle>,
active_editor: WeakEntity<Editor>,
@@ -770,6 +1118,13 @@ impl OutlinePanel {
cx.notify();
});
+ let theme_subscription =
+ cx.observe_global_in::<GlobalTheme>(window, |panel, window, cx| {
+ let buffers = panel.buffers.keys().copied().collect::<Vec<_>>();
+ panel.invalidate_outlines(&buffers);
+ panel.update_contents(Some(UPDATE_DEBOUNCE), window, cx);
+ });
+
let mut outline_panel_settings = *OutlinePanelSettings::get_global(cx);
let mut current_theme = ThemeSettings::get_global(cx).clone();
let mut document_symbols_by_buffer = HashMap::default();
@@ -777,18 +1132,21 @@ impl OutlinePanel {
cx.observe_global_in::<SettingsStore>(window, move |outline_panel, window, cx| {
let new_settings = OutlinePanelSettings::get_global(cx);
let new_theme = ThemeSettings::get_global(cx);
+ let auto_fold_dirs_changed =
+ outline_panel_settings.auto_fold_dirs != new_settings.auto_fold_dirs;
let mut outlines_invalidated = false;
if &current_theme != new_theme {
outline_panel_settings = *new_settings;
current_theme = new_theme.clone();
+ outline_panel.outline_fetch_tasks.clear();
for buffer in outline_panel.buffers.values_mut() {
buffer.invalidate_outlines();
}
outlines_invalidated = true;
- let update_cached_items = outline_panel.update_non_fs_items(window, cx);
- if update_cached_items {
- outline_panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx);
+ if matches!(outline_panel.selected_entry(), Some(PanelEntry::Outline(_))) {
+ outline_panel.selected_entry.invalidate();
}
+ outline_panel.update_contents(Some(UPDATE_DEBOUNCE), window, cx);
} else if &outline_panel_settings != new_settings {
let old_expansion_depth = outline_panel_settings.expand_outlines_with_depth;
let old_hide_symbols = outline_panel_settings.multi_buffer_hide_symbols;
@@ -852,6 +1210,10 @@ impl OutlinePanel {
}
}
+ if auto_fold_dirs_changed && let Some(editor) = outline_panel.active_editor() {
+ outline_panel.update_fs_entries(editor, Some(UPDATE_DEBOUNCE), window, cx);
+ }
+
if !outlines_invalidated {
let new_document_symbols = outline_panel
.buffers
@@ -869,17 +1231,17 @@ impl OutlinePanel {
.collect();
if new_document_symbols != document_symbols_by_buffer {
document_symbols_by_buffer = new_document_symbols;
+ outline_panel.outline_fetch_tasks.clear();
for buffer in outline_panel.buffers.values_mut() {
buffer.invalidate_outlines();
}
- let update_cached_items = outline_panel.update_non_fs_items(window, cx);
- if update_cached_items {
- outline_panel.update_cached_entries(
- Some(UPDATE_DEBOUNCE),
- window,
- cx,
- );
+ if matches!(
+ outline_panel.selected_entry(),
+ Some(PanelEntry::Outline(_))
+ ) {
+ outline_panel.selected_entry.invalidate();
}
+ outline_panel.update_contents(Some(UPDATE_DEBOUNCE), window, cx);
}
}
});
@@ -899,7 +1261,6 @@ impl OutlinePanel {
focus_handle,
filter_editor,
fs_entries: Vec::new(),
- fs_entries_depth: HashMap::default(),
fs_children_count: HashMap::default(),
collapsed_entries: HashSet::default(),
unfolded_dirs: HashMap::default(),
@@ -914,12 +1275,14 @@ impl OutlinePanel {
fs_entries_update_task: Task::ready(()),
fs_entries_update_pending: false,
cached_entries_update_task: Task::ready(()),
- cached_entries_update_pending: false,
+ cached_entries_update_pending: None,
reveal_selection_task: Task::ready(Ok(())),
+ lsp_outline_refresh_task: Task::ready(()),
outline_fetch_tasks: HashMap::default(),
buffers: HashMap::default(),
cached_entries: Vec::new(),
_subscriptions: vec![
+ theme_subscription,
settings_subscription,
icons_subscription,
focus_subscription,
@@ -998,7 +1361,7 @@ impl OutlinePanel {
self.unfolded_dirs
.entry(worktree_id)
.or_default()
- .extend(entries.iter().map(|entry| entry.id));
+ .extend(entries.iter().map(|entry| entry.path.clone()));
self.update_cached_entries(None, window, cx);
}
}
@@ -1026,7 +1389,7 @@ impl OutlinePanel {
return;
};
- unfolded_dirs.remove(&entry.id);
+ unfolded_dirs.remove(&entry.path);
self.update_cached_entries(None, window, cx);
}
@@ -1126,17 +1489,10 @@ impl OutlinePanel {
PanelEntry::Fs(FsEntry::File(file)) => {
change_selection = false;
scroll_to_buffer = Some(file.buffer_id);
- self.project
- .update(cx, |project, cx| {
- project
- .path_for_entry(file.entry.id, cx)
- .and_then(|path| project.get_open_buffer(&path, cx))
- })
- .map(|buffer| {
- multi_buffer_snapshot.excerpts_for_buffer(buffer.read(cx).remote_id())
- })
- .and_then(|mut excerpts| {
- let excerpt_range = excerpts.next()?;
+ multi_buffer_snapshot
+ .excerpts_for_buffer(file.buffer_id)
+ .next()
+ .and_then(|excerpt_range| {
multi_buffer_snapshot.anchor_in_excerpt(excerpt_range.context.start)
})
}
@@ -1318,23 +1674,8 @@ impl OutlinePanel {
| FsEntry::Directory(FsEntryDirectory {
worktree_id, entry, ..
}) => entry.path.parent().and_then(|parent_path| {
- previous_entries.find(|entry| match entry {
- PanelEntry::Fs(FsEntry::Directory(directory)) => {
- directory.worktree_id == *worktree_id
- && directory.entry.path.as_ref() == parent_path
- }
- PanelEntry::FoldedDirs(FoldedDirsEntry {
- worktree_id: dirs_worktree_id,
- entries: dirs,
- ..
- }) => {
- dirs_worktree_id == worktree_id
- && dirs
- .last()
- .is_some_and(|dir| dir.path.as_ref() == parent_path)
- }
- _ => false,
- })
+ previous_entries
+ .find(|entry| is_parent_row(entry, *worktree_id, parent_path))
}),
},
PanelEntry::FoldedDirs(folded_dirs) => folded_dirs
@@ -1343,12 +1684,7 @@ impl OutlinePanel {
.and_then(|entry| entry.path.parent())
.and_then(|parent_path| {
previous_entries.find(|entry| {
- if let PanelEntry::Fs(FsEntry::Directory(directory)) = entry {
- directory.worktree_id == folded_dirs.worktree_id
- && directory.entry.path.as_ref() == parent_path
- } else {
- false
- }
+ is_parent_row(entry, folded_dirs.worktree_id, parent_path)
})
}),
PanelEntry::Outline(OutlineEntry::Excerpt(excerpt)) => {
@@ -1440,40 +1776,16 @@ impl OutlinePanel {
) {
self.select_entry(entry.clone(), true, window, cx);
let is_root = match &entry {
- PanelEntry::Fs(FsEntry::File(FsEntryFile {
- worktree_id, entry, ..
- }))
- | PanelEntry::Fs(FsEntry::Directory(FsEntryDirectory {
- worktree_id, entry, ..
- })) => self
- .project
- .read(cx)
- .worktree_for_id(*worktree_id, cx)
- .map(|worktree| {
- worktree.read(cx).root_entry().map(|entry| entry.id) == Some(entry.id)
- })
- .unwrap_or(false),
- PanelEntry::FoldedDirs(FoldedDirsEntry {
- worktree_id,
- entries,
- ..
- }) => entries
- .first()
- .and_then(|entry| {
- self.project
- .read(cx)
- .worktree_for_id(*worktree_id, cx)
- .map(|worktree| {
- worktree.read(cx).root_entry().map(|entry| entry.id) == Some(entry.id)
- })
- })
- .unwrap_or(false),
- PanelEntry::Fs(FsEntry::ExternalFile(..)) => false,
- PanelEntry::Outline(..) => {
- cx.notify();
- return;
+ PanelEntry::Fs(FsEntry::File(FsEntryFile { entry, .. }))
+ | PanelEntry::Fs(FsEntry::Directory(FsEntryDirectory { entry, .. })) => {
+ entry.path.is_empty()
}
- PanelEntry::Search(_) => {
+ PanelEntry::FoldedDirs(folded_dirs) => folded_dirs
+ .entries
+ .first()
+ .is_some_and(|entry| entry.path.is_empty()),
+ PanelEntry::Fs(FsEntry::ExternalFile(_)) => false,
+ PanelEntry::Outline(_) | PanelEntry::Search(_) => {
cx.notify();
return;
}
@@ -1531,7 +1843,7 @@ impl OutlinePanel {
if self
.unfolded_dirs
.get(&directory_worktree)
- .is_none_or(|unfolded_dirs| !unfolded_dirs.contains(&directory_entry.id))
+ .is_none_or(|unfolded_dirs| !unfolded_dirs.contains(&directory_entry.path))
{
return false;
}
@@ -1566,13 +1878,13 @@ impl OutlinePanel {
..
}) => dir_entries.last().map(|entry| {
buffers_to_unfold.extend(self.buffers_inside_directory(*worktree_id, entry));
- CollapsedEntry::Dir(*worktree_id, entry.id)
+ CollapsedEntry::Dir(*worktree_id, entry.path.clone())
}),
PanelEntry::Fs(FsEntry::Directory(FsEntryDirectory {
worktree_id, entry, ..
})) => {
buffers_to_unfold.extend(self.buffers_inside_directory(*worktree_id, entry));
- Some(CollapsedEntry::Dir(*worktree_id, entry.id))
+ Some(CollapsedEntry::Dir(*worktree_id, entry.path.clone()))
}
PanelEntry::Fs(FsEntry::File(FsEntryFile {
worktree_id,
@@ -1599,15 +1911,6 @@ impl OutlinePanel {
};
let expanded = self.collapsed_entries.remove(&collapsed_entry);
if expanded {
- if let CollapsedEntry::Dir(worktree_id, dir_entry_id) = collapsed_entry {
- let task = self.project.update(cx, |project, cx| {
- project.expand_entry(worktree_id, dir_entry_id, cx)
- });
- if let Some(task) = task {
- task.detach_and_log_err(cx);
- }
- };
-
active_editor.update(cx, |editor, cx| {
buffers_to_unfold.retain(|buffer_id| editor.is_buffer_folded(*buffer_id, cx));
});
@@ -1643,7 +1946,7 @@ impl OutlinePanel {
})) => {
if self
.collapsed_entries
- .insert(CollapsedEntry::Dir(*worktree_id, entry.id))
+ .insert(CollapsedEntry::Dir(*worktree_id, entry.path.clone()))
{
buffers_to_fold.extend(self.buffers_inside_directory(*worktree_id, entry));
true
@@ -1680,9 +1983,10 @@ impl OutlinePanel {
PanelEntry::FoldedDirs(folded_dirs) => {
let mut folded = false;
if let Some(dir_entry) = folded_dirs.entries.last()
- && self
- .collapsed_entries
- .insert(CollapsedEntry::Dir(folded_dirs.worktree_id, dir_entry.id))
+ && self.collapsed_entries.insert(CollapsedEntry::Dir(
+ folded_dirs.worktree_id,
+ dir_entry.path.clone(),
+ ))
{
folded = true;
buffers_to_fold
@@ -1745,7 +2049,7 @@ impl OutlinePanel {
FsEntry::Directory(FsEntryDirectory {
worktree_id, entry, ..
}) => {
- to_uncollapse.insert(CollapsedEntry::Dir(*worktree_id, entry.id));
+ to_uncollapse.insert(CollapsedEntry::Dir(*worktree_id, entry.path.clone()));
}
}
}
@@ -1780,7 +2084,7 @@ impl OutlinePanel {
}) = &cached.entry
{
if let Some(last) = entries.last() {
- to_uncollapse.insert(CollapsedEntry::Dir(*worktree_id, last.id));
+ to_uncollapse.insert(CollapsedEntry::Dir(*worktree_id, last.path.clone()));
}
}
}
@@ -1817,7 +2121,7 @@ impl OutlinePanel {
worktree_id,
entry,
..
- })) => Some(CollapsedEntry::Dir(*worktree_id, entry.id)),
+ })) => Some(CollapsedEntry::Dir(*worktree_id, entry.path.clone())),
PanelEntry::Fs(FsEntry::File(FsEntryFile {
worktree_id,
buffer_id,
@@ -1834,7 +2138,10 @@ impl OutlinePanel {
worktree_id,
entries,
..
- }) => Some(CollapsedEntry::Dir(*worktree_id, entries.last()?.id)),
+ }) => Some(CollapsedEntry::Dir(
+ *worktree_id,
+ entries.last()?.path.clone(),
+ )),
PanelEntry::Outline(OutlineEntry::Excerpt(excerpt)) => {
Some(CollapsedEntry::Excerpt(excerpt.clone()))
}
@@ -1868,17 +2175,10 @@ impl OutlinePanel {
entry: dir_entry,
..
})) => {
- let entry_id = dir_entry.id;
- let collapsed_entry = CollapsedEntry::Dir(*worktree_id, entry_id);
+ let directory_path = &dir_entry.path;
+ let collapsed_entry = CollapsedEntry::Dir(*worktree_id, directory_path.clone());
buffers_to_toggle.extend(self.buffers_inside_directory(*worktree_id, dir_entry));
- if self.collapsed_entries.remove(&collapsed_entry) {
- self.project
- .update(cx, |project, cx| {
- project.expand_entry(*worktree_id, entry_id, cx)
- })
- .unwrap_or_else(|| Task::ready(Ok(())))
- .detach_and_log_err(cx);
- } else {
+ if !self.collapsed_entries.remove(&collapsed_entry) {
self.collapsed_entries.insert(collapsed_entry);
fold = true;
}
@@ -1909,18 +2209,11 @@ impl OutlinePanel {
..
}) => {
if let Some(dir_entry) = dir_entries.first() {
- let entry_id = dir_entry.id;
- let collapsed_entry = CollapsedEntry::Dir(*worktree_id, entry_id);
+ let directory_path = &dir_entry.path;
+ let collapsed_entry = CollapsedEntry::Dir(*worktree_id, directory_path.clone());
buffers_to_toggle
.extend(self.buffers_inside_directory(*worktree_id, dir_entry));
- if self.collapsed_entries.remove(&collapsed_entry) {
- self.project
- .update(cx, |project, cx| {
- project.expand_entry(*worktree_id, entry_id, cx)
- })
- .unwrap_or_else(|| Task::ready(Ok(())))
- .detach_and_log_err(cx);
- } else {
+ if !self.collapsed_entries.remove(&collapsed_entry) {
self.collapsed_entries.insert(collapsed_entry);
fold = true;
}
@@ -1938,7 +2231,7 @@ impl OutlinePanel {
self.collapsed_entries.insert(collapsed_entry);
}
}
- _ => {}
+ PanelEntry::Search(_) => return,
}
active_editor.update(cx, |editor, cx| {
@@ -2084,160 +2377,76 @@ impl OutlinePanel {
{
return;
}
- let project = self.project.clone();
self.reveal_selection_task = cx.spawn_in(window, async move |outline_panel, cx| {
cx.background_executor().timer(UPDATE_DEBOUNCE).await;
- let multibuffer_snapshot =
- editor.read_with(cx, |editor, cx| editor.buffer().read(cx).snapshot(cx));
- let entry_with_selection =
- outline_panel.update_in(cx, |outline_panel, window, cx| {
- outline_panel.location_for_editor_selection(&editor, window, cx)
- })?;
- let Some(entry_with_selection) = entry_with_selection else {
- outline_panel.update(cx, |outline_panel, cx| {
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ let Some(entry) = outline_panel.location_for_editor_selection(&editor, window, cx)
+ else {
outline_panel.selected_entry = SelectedEntry::None;
cx.notify();
- })?;
- return Ok(());
- };
- let related_buffer_entry = match &entry_with_selection {
- PanelEntry::Fs(FsEntry::File(FsEntryFile {
- worktree_id,
- buffer_id,
- ..
- })) => project.update(cx, |project, cx| {
- let entry_id = project
- .buffer_for_id(*buffer_id, cx)
- .and_then(|buffer| buffer.read(cx).entry_id(cx));
- project
- .worktree_for_id(*worktree_id, cx)
- .zip(entry_id)
- .and_then(|(worktree, entry_id)| {
- let entry = worktree.read(cx).entry_for_id(entry_id)?.clone();
- Some((worktree, entry))
- })
- }),
- PanelEntry::Outline(outline_entry) => {
- let buffer_id = outline_entry.buffer_id();
- let outline_range = outline_entry.range();
- outline_panel.update(cx, |outline_panel, cx| {
+ return;
+ };
+ let buffer_id = match &entry {
+ PanelEntry::Fs(entry) => entry.buffer_id(),
+ PanelEntry::Outline(outline) => Some(outline.buffer_id()),
+ PanelEntry::Search(search) => editor
+ .read(cx)
+ .buffer()
+ .read(cx)
+ .snapshot(cx)
+ .anchor_to_buffer_anchor(search.match_range.start)
+ .map(|(anchor, _)| anchor.buffer_id),
+ PanelEntry::FoldedDirs(_) => None,
+ };
+ let Some(buffer_id) = buffer_id else { return };
+ let collapsed_count = outline_panel.collapsed_entries.len();
+ if let PanelEntry::Outline(outline) = &entry {
+ let range = outline.range();
+ if let Some(snapshot) = outline_panel.buffer_snapshot_for_id(buffer_id, cx) {
+ outline_panel.collapsed_entries.retain(|entry| match entry {
+ CollapsedEntry::Excerpt(excerpt) => {
+ excerpt.context.start.buffer_id != buffer_id
+ || !(excerpt.contains(&range.start, &snapshot)
+ || excerpt.contains(&range.end, &snapshot))
+ }
+ _ => true,
+ });
+ }
+ }
+ let file_path = outline_panel
+ .fs_entries
+ .iter()
+ .find_map(|entry| match entry {
+ FsEntry::File(file) if file.buffer_id == buffer_id => Some(ProjectPath {
+ worktree_id: file.worktree_id,
+ path: file.entry.path.clone(),
+ }),
+ _ => None,
+ });
+ let reveal_buffer_contents =
+ matches!(entry, PanelEntry::Outline(_) | PanelEntry::Search(_));
+ if reveal_buffer_contents {
+ outline_panel
+ .collapsed_entries
+ .remove(&CollapsedEntry::ExternalFile(buffer_id));
+ }
+ if let Some(path) = file_path {
+ if reveal_buffer_contents {
outline_panel
.collapsed_entries
- .remove(&CollapsedEntry::ExternalFile(buffer_id));
- if let Some(buffer_snapshot) =
- outline_panel.buffer_snapshot_for_id(buffer_id, cx)
- {
- outline_panel.collapsed_entries.retain(|entry| match entry {
- CollapsedEntry::Excerpt(excerpt_range) => {
- let intersects = excerpt_range.context.start.buffer_id
- == buffer_id
- && (excerpt_range
- .contains(&outline_range.start, &buffer_snapshot)
- || excerpt_range
- .contains(&outline_range.end, &buffer_snapshot));
- !intersects
- }
- _ => true,
- });
- }
- let project = outline_panel.project.read(cx);
- let entry_id = project
- .buffer_for_id(buffer_id, cx)
- .and_then(|buffer| buffer.read(cx).entry_id(cx));
-
- entry_id.and_then(|entry_id| {
- project
- .worktree_for_entry(entry_id, cx)
- .and_then(|worktree| {
- let worktree_id = worktree.read(cx).id();
- outline_panel
- .collapsed_entries
- .remove(&CollapsedEntry::File(worktree_id, buffer_id));
- let entry = worktree.read(cx).entry_for_id(entry_id)?.clone();
- Some((worktree, entry))
- })
- })
- })?
- }
- PanelEntry::Fs(FsEntry::ExternalFile(..)) => None,
- PanelEntry::Search(SearchEntry { match_range, .. }) => multibuffer_snapshot
- .anchor_to_buffer_anchor(match_range.start)
- .map(|(anchor, _)| anchor.buffer_id)
- .map(|buffer_id| {
- outline_panel.update(cx, |outline_panel, cx| {
- outline_panel
- .collapsed_entries
- .remove(&CollapsedEntry::ExternalFile(buffer_id));
- let project = project.read(cx);
- let entry_id = project
- .buffer_for_id(buffer_id, cx)
- .and_then(|buffer| buffer.read(cx).entry_id(cx));
-
- entry_id.and_then(|entry_id| {
- project
- .worktree_for_entry(entry_id, cx)
- .and_then(|worktree| {
- let worktree_id = worktree.read(cx).id();
- outline_panel
- .collapsed_entries
- .remove(&CollapsedEntry::File(worktree_id, buffer_id));
- let entry =
- worktree.read(cx).entry_for_id(entry_id)?.clone();
- Some((worktree, entry))
- })
- })
- })
- })
- .transpose()?
- .flatten(),
- _ => return anyhow::Ok(()),
- };
- if let Some((worktree, buffer_entry)) = related_buffer_entry {
- outline_panel.update(cx, |outline_panel, cx| {
- let worktree_id = worktree.read(cx).id();
- let mut dirs_to_expand = Vec::new();
- {
- let mut traversal = worktree.read(cx).traverse_from_path(
- true,
- true,
- true,
- buffer_entry.path.as_ref(),
- );
- let mut current_entry = buffer_entry;
- loop {
- if current_entry.is_dir()
- && outline_panel
- .collapsed_entries
- .remove(&CollapsedEntry::Dir(worktree_id, current_entry.id))
- {
- dirs_to_expand.push(current_entry.id);
- }
-
- if traversal.back_to_parent()
- && let Some(parent_entry) = traversal.entry()
- {
- current_entry = parent_entry.clone();
- continue;
- }
- break;
- }
+ .remove(&CollapsedEntry::File(path.worktree_id, buffer_id));
}
- for dir_to_expand in dirs_to_expand {
- project
- .update(cx, |project, cx| {
- project.expand_entry(worktree_id, dir_to_expand, cx)
- })
- .unwrap_or_else(|| Task::ready(Ok(())))
- .detach_and_log_err(cx)
+ for ancestor in path.path.ancestors().skip(1) {
+ outline_panel
+ .collapsed_entries
+ .remove(&CollapsedEntry::Dir(path.worktree_id, Arc::from(ancestor)));
}
- })?
- }
-
- outline_panel.update_in(cx, |outline_panel, window, cx| {
- outline_panel.select_entry(entry_with_selection, false, window, cx);
- outline_panel.update_cached_entries(None, window, cx);
+ }
+ outline_panel.select_entry(entry, false, window, cx);
+ if outline_panel.collapsed_entries.len() != collapsed_count {
+ outline_panel.update_cached_entries(None, window, cx);
+ }
})?;
-
anyhow::Ok(())
});
}
@@ -2384,7 +2593,10 @@ impl OutlinePanel {
};
let (item_id, label_element, icon) = match rendered_entry {
FsEntry::File(FsEntryFile {
- worktree_id, entry, ..
+ worktree_id,
+ entry,
+ buffer_id,
+ ..
}) => {
let name = self.entry_name(worktree_id, entry, cx);
let color =
@@ -2396,7 +2608,7 @@ impl OutlinePanel {
None
};
(
- ElementId::from(entry.id.to_proto() as usize),
+ ElementId::from(("buffer", buffer_id.to_proto())),
HighlightedLabel::new(
name,
string_match
@@ -2416,7 +2628,7 @@ impl OutlinePanel {
let is_expanded = !self.collapsed_entries.contains(&CollapsedEntry::Dir(
directory.worktree_id,
- directory.entry.id,
+ directory.entry.path.clone(),
));
let color = entry_git_aware_label_color(
directory.entry.git_summary,
@@ -2431,7 +2643,11 @@ impl OutlinePanel {
cx,
);
(
- ElementId::from(directory.entry.id.to_proto() as usize),
+ directory_element_id(
+ directory.worktree_id,
+ directory.first_buffer_id,
+ &directory.entry.path,
+ ),
HighlightedLabel::new(
name,
string_match
@@ -2463,7 +2679,7 @@ impl OutlinePanel {
None => (None, "Unknown buffer".to_string()),
};
(
- ElementId::from(external_file.buffer_id.to_proto() as usize),
+ ElementId::from(("buffer", external_file.buffer_id.to_proto())),
HighlightedLabel::new(
name,
string_match
@@ -2502,19 +2718,17 @@ impl OutlinePanel {
) -> Stateful<Div> {
let settings = OutlinePanelSettings::get_global(cx);
let is_active = match self.selected_entry() {
- Some(PanelEntry::FoldedDirs(selected_dirs)) => {
- selected_dirs.worktree_id == folded_dir.worktree_id
- && selected_dirs.entries == folded_dir.entries
- }
+ Some(PanelEntry::FoldedDirs(selected_dirs)) => selected_dirs == folded_dir,
_ => false,
};
let (item_id, label_element, icon) = {
let name = self.dir_names_string(&folded_dir.entries, folded_dir.worktree_id, cx);
let is_expanded = folded_dir.entries.iter().all(|dir| {
- !self
- .collapsed_entries
- .contains(&CollapsedEntry::Dir(folded_dir.worktree_id, dir.id))
+ !self.collapsed_entries.contains(&CollapsedEntry::Dir(
+ folded_dir.worktree_id,
+ dir.path.clone(),
+ ))
});
let is_ignored = folded_dir.entries.iter().any(|entry| entry.is_ignored);
let git_status = folded_dir
@@ -2531,14 +2745,19 @@ impl OutlinePanel {
cx,
);
(
- ElementId::from(
- folded_dir
- .entries
- .last()
- .map(|entry| entry.id.to_proto())
- .unwrap_or_else(|| folded_dir.worktree_id.to_proto())
- as usize,
- ),
+ folded_dir
+ .entries
+ .last()
+ .map(|entry| {
+ directory_element_id(
+ folded_dir.worktree_id,
+ folded_dir.first_buffer_id,
+ &entry.path,
+ )
+ })
+ .unwrap_or_else(|| {
+ ElementId::from(("empty-folded-dirs", folded_dir.worktree_id.to_proto()))
+ }),
HighlightedLabel::new(
name,
string_match
@@ -2668,6 +2887,10 @@ impl OutlinePanel {
cx: &mut Context<OutlinePanel>,
) -> Stateful<Div> {
let settings = OutlinePanelSettings::get_global(cx);
+ let is_deleted = match &rendered_entry {
+ PanelEntry::Fs(FsEntry::File(file)) => file.is_deleted,
+ _ => false,
+ };
div()
.text_ui(cx)
.id(item_id.clone())
@@ -2699,7 +2922,13 @@ impl OutlinePanel {
.child(
h_flex()
.child(h_flex().min_w(px(16.)).justify_center().child(icon_element))
- .child(h_flex().h_6().child(label_element).ml_1()),
+ .child(
+ h_flex()
+ .h_6()
+ .child(label_element)
+ .ml_1()
+ .when(is_deleted, |this| this.line_through()),
+ ),
)
.on_secondary_mouse_down(cx.listener(
move |outline_panel, event: &MouseDownEvent, window, cx| {
@@ -2732,25 +2961,9 @@ impl OutlinePanel {
)
}
- fn entry_name(&self, worktree_id: &WorktreeId, entry: &Entry, cx: &App) -> String {
+ fn entry_name(&self, worktree_id: &WorktreeId, entry: &FsEntryPath, cx: &App) -> String {
match self.project.read(cx).worktree_for_id(*worktree_id, cx) {
- Some(worktree) => {
- let worktree = worktree.read(cx);
- match worktree.snapshot().root_entry() {
- Some(root_entry) => {
- if root_entry.id == entry.id {
- file_name(worktree.abs_path().as_ref())
- } else {
- let path = worktree.absolutize(entry.path.as_ref());
- file_name(&path)
- }
- }
- None => {
- let path = worktree.absolutize(entry.path.as_ref());
- file_name(&path)
- }
- }
- }
+ Some(worktree) => file_name(&worktree.read(cx).absolutize(&entry.path)),
None => file_name(entry.path.as_std_path()),
}
}
@@ -2782,11 +2995,7 @@ impl OutlinePanel {
window: &mut Window,
cx: &mut Context<Self>,
) {
- if !self.active {
- return;
- }
-
- if debounce.is_some() && self.fs_entries_update_pending {
+ if !self.active || (debounce.is_some() && self.fs_entries_update_pending) {
return;
}
self.fs_entries_update_pending = true;
@@ -2796,386 +3005,299 @@ impl OutlinePanel {
cx.background_executor().timer(debounce).await;
}
- let mut new_collapsed_entries = HashSet::default();
- let mut new_unfolded_dirs = HashMap::default();
- let mut root_entries = HashSet::default();
let mut new_buffers = HashMap::<BufferId, BufferOutlines>::default();
- let Ok((buffer_excerpts, auto_fold_dirs, repo_snapshots)) =
- outline_panel.update(cx, |outline_panel, cx| {
- outline_panel.fs_entries_update_pending = false;
- let auto_fold_dirs = OutlinePanelSettings::get_global(cx).auto_fold_dirs;
- let active_multi_buffer = active_editor.read(cx).buffer().clone();
- let new_entries = outline_panel.new_entries_for_fs_update.clone();
- let repo_snapshots = outline_panel.project.update(cx, |project, cx| {
- project.git_store().read(cx).display_repo_snapshots(cx)
- });
- let git_store = outline_panel.project.read(cx).git_store().clone();
- new_collapsed_entries = outline_panel.collapsed_entries.clone();
- new_unfolded_dirs = outline_panel.unfolded_dirs.clone();
- let multi_buffer_snapshot = active_multi_buffer.read(cx).snapshot(cx);
-
- let buffer_excerpts = multi_buffer_snapshot.excerpts().fold(
- HashMap::default(),
- |mut buffer_excerpts, excerpt_range| {
- let Some(buffer_snapshot) = multi_buffer_snapshot
- .buffer_for_id(excerpt_range.context.start.buffer_id)
- else {
- return buffer_excerpts;
- };
- let buffer_id = buffer_snapshot.remote_id();
- let file = File::from_dyn(buffer_snapshot.file());
- let entry_id = file.and_then(|file| file.project_entry_id());
- let worktree = file.map(|file| file.worktree.read(cx).snapshot());
- let is_new = new_entries.contains(&buffer_id)
- || !outline_panel.buffers.contains_key(&buffer_id);
- let is_folded = active_editor.read(cx).is_buffer_folded(buffer_id, cx);
+ let Ok((
+ buffer_excerpts,
+ auto_fold_dirs,
+ repo_snapshots,
+ mut collapsed_entries,
+ mut unfolded_dirs,
+ )) = outline_panel.update(cx, |outline_panel, cx| {
+ outline_panel.fs_entries_update_pending = false;
+ let auto_fold_dirs = OutlinePanelSettings::get_global(cx).auto_fold_dirs;
+ let git_store = outline_panel.project.read(cx).git_store().clone();
+ let repo_snapshots = git_store.read(cx).display_repo_snapshots(cx);
+ let editor = active_editor.read(cx);
+ let snapshot = editor.buffer().read(cx).snapshot(cx);
+ let mut buffer_excerpts = IndexMap::<BufferId, BufferExcerpts>::default();
+
+ for excerpt in snapshot.excerpts() {
+ let buffer_id = excerpt.context.start.buffer_id;
+ let Some(buffer) = snapshot.buffer_for_id(buffer_id) else {
+ continue;
+ };
+ buffer_excerpts
+ .entry(buffer_id)
+ .or_insert_with(|| {
let status = git_store
.read(cx)
.display_status_for_buffer_id(buffer_id, cx);
- buffer_excerpts
- .entry(buffer_id)
- .or_insert_with(|| {
- (is_new, is_folded, Vec::new(), entry_id, worktree, status)
- })
- .2
- .push(excerpt_range.clone());
-
- new_buffers
- .entry(buffer_id)
- .or_insert_with(|| {
- let outlines = match outline_panel.buffers.get(&buffer_id) {
- Some(old_buffer) => match &old_buffer.outlines {
- OutlineState::Outlines(outlines) => {
- OutlineState::Outlines(outlines.clone())
- }
- OutlineState::Invalidated(_) => {
- OutlineState::NotFetched
- }
- OutlineState::NotFetched => OutlineState::NotFetched,
- },
- None => OutlineState::NotFetched,
- };
- BufferOutlines {
- outlines,
- excerpts: Vec::new(),
- }
- })
- .excerpts
- .push(excerpt_range);
- buffer_excerpts
- },
- );
- (buffer_excerpts, auto_fold_dirs, repo_snapshots)
- })
+ let file = File::from_dyn(buffer.file());
+ let is_deleted = file.is_some_and(|file| {
+ is_deleted_file(
+ file,
+ status,
+ snapshot
+ .diff_for_buffer_id(buffer_id)
+ .is_some_and(|diff| diff.base_text_exists()),
+ )
+ });
+ let file = file.and_then(|file| {
+ let worktree = file.worktree.read(cx).snapshot();
+ let entry = file
+ .project_entry_id()
+ .and_then(|id| worktree.entry_for_id(id));
+ if entry.is_none() && !is_deleted {
+ return None;
+ }
+ let path_entry = FsEntryPath {
+ path: file.path.clone(),
+ git_summary: status.map(GitSummary::from).unwrap_or_default(),
+ is_ignored: entry.is_some_and(|entry| entry.is_ignored),
+ };
+ Some((worktree, path_entry))
+ });
+ BufferExcerpts {
+ is_new: outline_panel
+ .new_entries_for_fs_update
+ .contains(&buffer_id)
+ || !outline_panel.buffers.contains_key(&buffer_id),
+ is_folded: editor.is_buffer_folded(buffer_id, cx),
+ excerpts: Vec::new(),
+ file,
+ is_deleted,
+ }
+ })
+ .excerpts
+ .push(excerpt.clone());
+
+ new_buffers
+ .entry(buffer_id)
+ .or_insert_with(|| {
+ let outlines = match outline_panel.buffers.get(&buffer_id) {
+ Some(BufferOutlines {
+ outlines: OutlineState::Outlines(outlines),
+ ..
+ }) => OutlineState::Outlines(outlines.clone()),
+ _ => OutlineState::NotFetched,
+ };
+ BufferOutlines {
+ outlines,
+ excerpts: Vec::new(),
+ }
+ })
+ .excerpts
+ .push(excerpt);
+ }
+ (
+ buffer_excerpts,
+ auto_fold_dirs,
+ repo_snapshots,
+ outline_panel.collapsed_entries.clone(),
+ outline_panel.unfolded_dirs.clone(),
+ )
+ })
else {
return;
};
- let Some((
- new_collapsed_entries,
- new_unfolded_dirs,
- new_fs_entries,
- new_depth_map,
- new_children_count,
- )) = cx
+ let (fs_entries, children_count, collapsed_entries, unfolded_dirs) = cx
.background_spawn(async move {
- let mut processed_external_buffers = HashSet::default();
- let mut new_worktree_entries =
- BTreeMap::<WorktreeId, HashMap<ProjectEntryId, GitEntry>>::default();
- let mut worktree_excerpts = HashMap::<
- WorktreeId,
- HashMap<ProjectEntryId, (BufferId, Vec<ExcerptRange<Anchor>>)>,
- >::default();
- let mut external_excerpts = HashMap::default();
-
- for (buffer_id, (is_new, is_folded, excerpts, entry_id, worktree, status)) in
- buffer_excerpts
- {
- if is_folded {
- match &worktree {
- Some(worktree) => {
- new_collapsed_entries
- .insert(CollapsedEntry::File(worktree.id(), buffer_id));
- }
- None => {
- new_collapsed_entries
- .insert(CollapsedEntry::ExternalFile(buffer_id));
- }
+ let mut fs_entries = Vec::new();
+ let mut directories = HashMap::<ProjectPath, FsEntryPath>::default();
+ let mut parent_paths = Vec::<ProjectPath>::new();
+ let repositories_by_root = repo_snapshots
+ .values()
+ .map(|snapshot| (snapshot.work_directory_abs_path.as_ref(), snapshot))
+ .collect::<BTreeMap<_, _>>();
+ for (buffer_id, buffer) in buffer_excerpts {
+ let collapsed_entry = match &buffer.file {
+ Some((worktree, _)) => CollapsedEntry::File(worktree.id(), buffer_id),
+ None => CollapsedEntry::ExternalFile(buffer_id),
+ };
+ if buffer.is_folded {
+ collapsed_entries.insert(collapsed_entry);
+ } else if buffer.is_new {
+ collapsed_entries.remove(&collapsed_entry);
+ }
+ let Some((worktree, entry)) = buffer.file else {
+ parent_paths.clear();
+ fs_entries.push(FsEntry::ExternalFile(FsEntryExternalFile {
+ buffer_id,
+ excerpts: Arc::from(buffer.excerpts),
+ }));
+ continue;
+ };
+ let worktree_id = worktree.id();
+ let mut ancestors = entry.path.ancestors().skip(1).collect::<Vec<_>>();
+ ancestors.reverse();
+ let shared_depth = parent_paths
+ .last()
+ .filter(|parent| parent.worktree_id == worktree_id)
+ .zip(ancestors.last())
+ .map(|(parent, ancestor)| {
+ parent
+ .path
+ .components()
+ .zip(ancestor.components())
+ .take_while(|(left, right)| left == right)
+ .count()
+ + 1
+ })
+ .unwrap_or(0);
+ parent_paths.truncate(shared_depth);
+ for (depth, path) in ancestors.into_iter().enumerate() {
+ let ancestor =
+ parent_paths
+ .get(depth)
+ .cloned()
+ .unwrap_or_else(|| ProjectPath {
+ worktree_id,
+ path: Arc::from(path),
+ });
+ if buffer.is_new {
+ collapsed_entries.remove(&CollapsedEntry::Dir(
+ worktree_id,
+ ancestor.path.clone(),
+ ));
}
- } else if is_new {
- match &worktree {
- Some(worktree) => {
- new_collapsed_entries
- .remove(&CollapsedEntry::File(worktree.id(), buffer_id));
- }
- None => {
- new_collapsed_entries
- .remove(&CollapsedEntry::ExternalFile(buffer_id));
- }
+ if depth < shared_depth {
+ continue;
}
- }
-
- if let Some(worktree) = worktree {
- let worktree_id = worktree.id();
- let unfolded_dirs = new_unfolded_dirs.entry(worktree_id).or_default();
-
- match entry_id.and_then(|id| worktree.entry_for_id(id)).cloned() {
- Some(entry) => {
- let entry = GitEntry {
- git_summary: status
- .map(|status| status.summary())
- .unwrap_or_default(),
- entry,
- };
- let mut traversal = GitTraversal::new(
- &repo_snapshots,
- worktree.traverse_from_path(
- true,
- true,
- true,
- entry.path.as_ref(),
- ),
- );
-
- let mut entries_to_add = HashMap::default();
- worktree_excerpts
- .entry(worktree_id)
- .or_default()
- .insert(entry.id, (buffer_id, excerpts));
- let mut current_entry = entry;
- loop {
- if current_entry.is_dir() {
- let is_root =
- worktree.root_entry().map(|entry| entry.id)
- == Some(current_entry.id);
- if is_root {
- root_entries.insert(current_entry.id);
- if auto_fold_dirs {
- unfolded_dirs.insert(current_entry.id);
- }
- }
- if is_new {
- new_collapsed_entries.remove(&CollapsedEntry::Dir(
- worktree_id,
- current_entry.id,
+ let directory =
+ directories.entry(ancestor.clone()).or_insert_with(|| {
+ let indexed_entry = worktree
+ .entry_for_path(&ancestor.path)
+ .filter(|entry| entry.is_dir());
+ let git_summary = indexed_entry
+ .and_then(|_| {
+ let abs_path = worktree.absolutize(&ancestor.path);
+ for query in abs_path.ancestors() {
+ let (_, repository) = repositories_by_root
+ .range(Path::new("")..=query)
+ .next_back()?;
+ let Some(path) =
+ repository.abs_path_to_repo_path(&abs_path)
+ else {
+ continue;
+ };
+ let mut statuses = repository
+ .statuses_by_path
+ .cursor::<PathProgress>(());
+ statuses.seek_forward(
+ &PathTarget::Path(&path),
+ Bias::Left,
+ );
+ return Some(statuses.summary(
+ &PathTarget::Successor(&path),
+ Bias::Left,
));
}
- }
-
- let new_entry_added = entries_to_add
- .insert(current_entry.id, current_entry)
- .is_none();
- if new_entry_added
- && traversal.back_to_parent()
- && let Some(parent_entry) = traversal.entry()
- {
- current_entry = parent_entry.to_owned();
- continue;
- }
- break;
- }
- new_worktree_entries
- .entry(worktree_id)
- .or_insert_with(HashMap::default)
- .extend(entries_to_add);
- }
- None => {
- if processed_external_buffers.insert(buffer_id) {
- external_excerpts
- .entry(buffer_id)
- .or_insert_with(Vec::new)
- .extend(excerpts);
+ None
+ })
+ .unwrap_or_default();
+ FsEntryPath {
+ path: ancestor.path.clone(),
+ git_summary,
+ is_ignored: indexed_entry
+ .is_some_and(|entry| entry.is_ignored),
}
- }
- }
- } else if processed_external_buffers.insert(buffer_id) {
- external_excerpts
- .entry(buffer_id)
- .or_insert_with(Vec::new)
- .extend(excerpts);
+ });
+ fs_entries.push(FsEntry::Directory(FsEntryDirectory {
+ worktree_id,
+ first_buffer_id: buffer_id,
+ entry: directory.clone(),
+ }));
+ parent_paths.push(ancestor);
}
+ fs_entries.push(FsEntry::File(FsEntryFile {
+ worktree_id,
+ entry,
+ buffer_id,
+ excerpts: Arc::from(buffer.excerpts),
+ is_deleted: buffer.is_deleted,
+ }));
}
-
- let mut new_children_count =
+ collapsed_entries.retain(|entry| match entry {
+ CollapsedEntry::Dir(worktree_id, path) => {
+ directories.contains_key(&ProjectPath {
+ worktree_id: *worktree_id,
+ path: path.clone(),
+ })
+ }
+ _ => true,
+ });
+ unfolded_dirs.retain(|worktree_id, paths| {
+ paths.retain(|path| {
+ directories.contains_key(&ProjectPath {
+ worktree_id: *worktree_id,
+ path: path.clone(),
+ })
+ });
+ !paths.is_empty()
+ });
+ let mut children_count =
HashMap::<WorktreeId, HashMap<Arc<RelPath>, FsChildren>>::default();
-
- let worktree_entries = new_worktree_entries
- .into_iter()
- .map(|(worktree_id, entries)| {
- let mut entries = entries.into_values().collect::<Vec<_>>();
- entries.sort_by(|a, b| a.path.as_ref().cmp(b.path.as_ref()));
- (worktree_id, entries)
- })
- .flat_map(|(worktree_id, entries)| {
+ for directory in directories.keys() {
+ if let Some(parent) = directory.path.parent() {
+ children_count
+ .entry(directory.worktree_id)
+ .or_default()
+ .entry(Arc::from(parent))
+ .or_default()
+ .dirs += 1;
+ }
+ }
+ for entry in &fs_entries {
+ if let FsEntry::File(file) = entry
+ && let Some(parent) = file.entry.path.parent()
+ {
+ children_count
+ .entry(file.worktree_id)
+ .or_default()
+ .entry(Arc::from(parent))
+ .or_default()
+ .files += 1;
+ }
+ }
+ if auto_fold_dirs {
+ for entry in &fs_entries {
+ let FsEntry::Directory(directory) = entry else {
+ continue;
+ };
+ let unfolded = unfolded_dirs.entry(directory.worktree_id).or_default();
+ let path = &directory.entry.path;
+ let children = children_count
+ .get(&directory.worktree_id)
+ .and_then(|children| children.get(path))
+ .copied()
+ .unwrap_or_default();
+ let parent_unfolded =
+ path.parent().is_none_or(|parent| unfolded.contains(parent));
+ if path.is_empty()
+ || !children.may_be_fold_part()
+ || (children.dirs == 0 && parent_unfolded)
{
- entries
- .into_iter()
- .filter_map(|entry| {
- if auto_fold_dirs && let Some(parent) = entry.path.parent()
- {
- let children = new_children_count
- .entry(worktree_id)
- .or_default()
- .entry(Arc::from(parent))
- .or_default();
- if entry.is_dir() {
- children.dirs += 1;
- } else {
- children.files += 1;
- }
- }
-
- if entry.is_dir() {
- Some(FsEntry::Directory(FsEntryDirectory {
- worktree_id,
- entry,
- }))
- } else {
- let (buffer_id, excerpts) = worktree_excerpts
- .get_mut(&worktree_id)
- .and_then(|worktree_excerpts| {
- worktree_excerpts.remove(&entry.id)
- })?;
- Some(FsEntry::File(FsEntryFile {
- worktree_id,
- buffer_id,
- entry,
- excerpts,
- }))
- }
- })
- .collect::<Vec<_>>()
- }
- })
- .collect::<Vec<_>>();
-
- let mut visited_dirs = Vec::new();
- let mut new_depth_map = HashMap::default();
- let new_visible_entries = external_excerpts
- .into_iter()
- .sorted_by_key(|(id, _)| *id)
- .map(|(buffer_id, excerpts)| {
- FsEntry::ExternalFile(FsEntryExternalFile {
- buffer_id,
- excerpts,
- })
- })
- .chain(worktree_entries)
- .filter(|visible_item| {
- match visible_item {
- FsEntry::Directory(directory) => {
- let parent_id = back_to_common_visited_parent(
- &mut visited_dirs,
- &directory.worktree_id,
- &directory.entry,
- );
-
- let mut depth = 0;
- if !root_entries.contains(&directory.entry.id) {
- if auto_fold_dirs {
- let children = new_children_count
- .get(&directory.worktree_id)
- .and_then(|children_count| {
- children_count.get(&directory.entry.path)
- })
- .copied()
- .unwrap_or_default();
-
- if !children.may_be_fold_part()
- || (children.dirs == 0
- && visited_dirs
- .last()
- .map(|(parent_dir_id, _)| {
- new_unfolded_dirs
- .get(&directory.worktree_id)
- .is_none_or(|unfolded_dirs| {
- unfolded_dirs
- .contains(parent_dir_id)
- })
- })
- .unwrap_or(true))
- {
- new_unfolded_dirs
- .entry(directory.worktree_id)
- .or_default()
- .insert(directory.entry.id);
- }
- }
-
- depth = parent_id
- .and_then(|(worktree_id, id)| {
- new_depth_map.get(&(worktree_id, id)).copied()
- })
- .unwrap_or(0)
- + 1;
- };
- visited_dirs
- .push((directory.entry.id, directory.entry.path.clone()));
- new_depth_map
- .insert((directory.worktree_id, directory.entry.id), depth);
- }
- FsEntry::File(FsEntryFile {
- worktree_id,
- entry: file_entry,
- ..
- }) => {
- let parent_id = back_to_common_visited_parent(
- &mut visited_dirs,
- worktree_id,
- file_entry,
- );
- let depth = if root_entries.contains(&file_entry.id) {
- 0
- } else {
- parent_id
- .and_then(|(worktree_id, id)| {
- new_depth_map.get(&(worktree_id, id)).copied()
- })
- .unwrap_or(0)
- + 1
- };
- new_depth_map.insert((*worktree_id, file_entry.id), depth);
- }
- FsEntry::ExternalFile(..) => {
- visited_dirs.clear();
- }
+ unfolded.insert(path.clone());
}
-
- true
- })
- .collect::<Vec<_>>();
-
- anyhow::Ok((
- new_collapsed_entries,
- new_unfolded_dirs,
- new_visible_entries,
- new_depth_map,
- new_children_count,
- ))
+ }
+ }
+ (fs_entries, children_count, collapsed_entries, unfolded_dirs)
})
- .await
- .log_err()
- else {
- return;
- };
+ .await;
outline_panel
.update_in(cx, |outline_panel, window, cx| {
outline_panel.new_entries_for_fs_update.clear();
outline_panel.buffers = new_buffers;
- outline_panel.collapsed_entries = new_collapsed_entries;
- outline_panel.unfolded_dirs = new_unfolded_dirs;
- outline_panel.fs_entries = new_fs_entries;
- outline_panel.fs_entries_depth = new_depth_map;
- outline_panel.fs_children_count = new_children_count;
+ outline_panel.collapsed_entries = collapsed_entries;
+ outline_panel.unfolded_dirs = unfolded_dirs;
+ outline_panel.fs_entries = fs_entries;
+ outline_panel.fs_children_count = children_count;
outline_panel.update_non_fs_items(window, cx);
-
- // Only update cached entries if we don't have outlines to fetch
- // If we do have outlines to fetch, let fetch_outdated_outlines handle the update
if outline_panel.buffers_to_fetch(cx).is_empty() {
outline_panel.update_cached_entries(debounce, window, cx);
}
-
cx.notify();
})
.ok();
@@ -3204,11 +3326,8 @@ impl OutlinePanel {
e: &SearchEvent,
window: &mut Window,
cx: &mut Context<Self>| {
- if matches!(e, SearchEvent::MatchesInvalidated)
- && outline_panel.update_search_matches(window, cx)
- {
- outline_panel.selected_entry.invalidate();
- outline_panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx);
+ if matches!(e, SearchEvent::MatchesInvalidated) {
+ outline_panel.update_contents(Some(UPDATE_DEBOUNCE), window, cx);
}
},
);
@@ -3234,9 +3353,10 @@ impl OutlinePanel {
fn clear_previous(&mut self, window: &mut Window, cx: &mut App) {
self.fs_entries_update_task = Task::ready(());
self.fs_entries_update_pending = false;
+ self.lsp_outline_refresh_task = Task::ready(());
self.outline_fetch_tasks.clear();
self.cached_entries_update_task = Task::ready(());
- self.cached_entries_update_pending = false;
+ self.cached_entries_update_pending = None;
self.reveal_selection_task = Task::ready(Ok(()));
self.filter_editor
.update(cx, |editor, cx| editor.clear(window, cx));
@@ -3244,7 +3364,6 @@ impl OutlinePanel {
self.unfolded_dirs.clear();
self.active_item = None;
self.fs_entries.clear();
- self.fs_entries_depth.clear();
self.fs_children_count.clear();
self.buffers.clear();
self.cached_entries = Vec::new();
@@ -3340,14 +3459,48 @@ impl OutlinePanel {
selection_display_point: DisplayPoint,
cx: &App,
) -> Option<PanelEntry> {
+ let buffer_snapshot = multi_buffer_snapshot.buffer_for_id(selection_anchor.buffer_id);
+ let mut excerpt_ranges = multi_buffer_snapshot
+ .excerpts_for_buffer(selection_anchor.buffer_id)
+ .map(|excerpt| excerpt.context)
+ .collect::<Vec<_>>();
+ if let Some(snapshot) = buffer_snapshot {
+ excerpt_ranges.sort_unstable_by(|left, right| left.start.cmp(&right.start, snapshot));
+ let mut maximum_end = None;
+ for range in &mut excerpt_ranges {
+ if let Some(end) = maximum_end
+ && range.end.cmp(&end, snapshot).is_lt()
+ {
+ range.end = end;
+ }
+ maximum_end = Some(range.end);
+ }
+ }
+
let excerpt_outlines = self
.buffers
.get(&selection_anchor.buffer_id)
.into_iter()
.flat_map(|buffer| buffer.iter_outlines())
.flat_map(|outline| {
- let range = multi_buffer_snapshot
- .buffer_anchor_range_to_anchor_range(outline.range.clone())?;
+ let snapshot = buffer_snapshot?;
+ let (start, end) = if outline
+ .range
+ .start
+ .cmp(&outline.range.end, snapshot)
+ .is_gt()
+ {
+ (outline.range.end, outline.range.start)
+ } else {
+ (outline.range.start, outline.range.end)
+ };
+ let index = excerpt_ranges
+ .partition_point(|excerpt| excerpt.start.cmp(&start, snapshot).is_le())
+ .checked_sub(1)?;
+ if excerpt_ranges.get(index)?.end.cmp(&end, snapshot).is_lt() {
+ return None;
+ }
+ let range = multi_buffer_snapshot.anchor_range_in_buffer(outline.range.clone())?;
Some((
range.start.to_display_point(&editor_snapshot)
..range.end.to_display_point(&editor_snapshot),
@@ -3482,7 +3635,12 @@ impl OutlinePanel {
Some(closest_container)
}
- fn fetch_outdated_outlines(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+ fn fetch_outdated_outlines(
+ &mut self,
+ debounce: Option<Duration>,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
let buffers_to_fetch = self.buffers_to_fetch(cx);
if buffers_to_fetch.is_empty() {
return;
@@ -3490,29 +3648,34 @@ impl OutlinePanel {
let first_update = Arc::new(AtomicBool::new(true));
for buffer_id in buffers_to_fetch {
- let outline_task = self.active_editor().map(|editor| {
- editor.update(cx, |editor, cx| editor.buffer_outline_items(buffer_id, cx))
- });
-
+ if self
+ .outline_fetch_tasks
+ .get(&buffer_id)
+ .is_some_and(|task| !task.is_ready())
+ {
+ continue;
+ }
let first_update = first_update.clone();
self.outline_fetch_tasks.insert(
buffer_id,
cx.spawn_in(window, async move |outline_panel, cx| {
- let Some(outline_task) = outline_task else {
+ if let Some(debounce) = debounce {
+ cx.background_executor().timer(debounce).await;
+ }
+ let Some(outline_task) = outline_panel
+ .update(cx, |panel, cx| {
+ let editor = panel.active_editor()?;
+ Some(editor.update(cx, |editor, cx| {
+ editor.buffer_outline_items(buffer_id, cx)
+ }))
+ })
+ .ok()
+ .flatten()
+ else {
return;
};
let fetched_outlines = outline_task.await;
- let outlines_with_children = fetched_outlines
- .array_windows::<2>()
- .filter_map(|[current, next]| {
- if next.depth > current.depth {
- Some((current.range.clone(), current.depth))
- } else {
- None
- }
- })
- .collect::<HashSet<_>>();
outline_panel
.update_in(cx, |outline_panel, window, cx| {
@@ -3523,19 +3686,31 @@ impl OutlinePanel {
.insert(buffer_id)
});
- let debounce =
- if first_update.fetch_and(false, atomic::Ordering::AcqRel) {
- None
- } else {
- Some(UPDATE_DEBOUNCE)
- };
-
+ let mut entries_changed = false;
if let Some(buffer) = outline_panel.buffers.get_mut(&buffer_id) {
- buffer.outlines = OutlineState::Outlines(fetched_outlines.clone());
+ entries_changed = pending_default_depth.is_some()
+ || match &buffer.outlines {
+ OutlineState::Outlines(outlines)
+ | OutlineState::Invalidated(outlines) => {
+ outlines != &fetched_outlines
+ }
+ OutlineState::NotFetched => true,
+ };
+ buffer.outlines = OutlineState::Outlines(fetched_outlines);
if let Some(default_depth) = pending_default_depth
&& let OutlineState::Outlines(outlines) = &buffer.outlines
{
+ let outlines_with_children = outlines
+ .array_windows::<2>()
+ .filter_map(|[current, next]| {
+ if next.depth > current.depth {
+ Some((current.range.clone(), current.depth))
+ } else {
+ None
+ }
+ })
+ .collect::<HashSet<_>>();
outlines
.iter()
.filter(|outline| {
@@ -3553,7 +3728,27 @@ impl OutlinePanel {
}
}
- outline_panel.update_cached_entries(debounce, window, cx);
+ if entries_changed
+ || matches!(
+ &outline_panel.selected_entry,
+ SelectedEntry::Invalidated(Some(PanelEntry::Outline(outline)))
+ if outline.buffer_id() == buffer_id
+ )
+ {
+ let debounce =
+ if first_update.fetch_and(false, atomic::Ordering::AcqRel) {
+ None
+ } else {
+ Some(UPDATE_DEBOUNCE)
+ };
+ if let Some(PanelEntry::Outline(outline)) =
+ outline_panel.selected_entry()
+ && outline.buffer_id() == buffer_id
+ {
+ outline_panel.selected_entry.invalidate();
+ }
+ outline_panel.update_cached_entries(debounce, window, cx);
+ }
})
.ok();
}),
@@ -3622,15 +3817,16 @@ impl OutlinePanel {
}
fn invalidate_outlines(&mut self, ids: &[BufferId]) {
- self.outline_fetch_tasks.clear();
- let mut ids = ids.iter().collect::<HashSet<_>>();
- for (buffer_id, buffer) in self.buffers.iter_mut() {
- if ids.remove(&buffer_id) {
+ if let Some(PanelEntry::Outline(outline)) = self.selected_entry()
+ && ids.contains(&outline.buffer_id())
+ {
+ self.selected_entry.invalidate();
+ }
+ for buffer_id in ids {
+ self.outline_fetch_tasks.remove(buffer_id);
+ if let Some(buffer) = self.buffers.get_mut(buffer_id) {
buffer.invalidate_outlines();
}
- if ids.is_empty() {
- break;
- }
}
}
@@ -3717,6 +3913,19 @@ impl OutlinePanel {
}
}
+ fn update_contents(
+ &mut self,
+ debounce: Option<Duration>,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ if !self.active {
+ return;
+ }
+ self.cached_entries_update_pending = Some(CachedEntriesUpdate::Contents);
+ self.update_cached_entries(debounce, window, cx);
+ }
+
fn update_cached_entries(
&mut self,
debounce: Option<Duration>,
@@ -3727,70 +3936,165 @@ impl OutlinePanel {
return;
}
- // A pending debounced update will read the latest state when it fires,
- // so we don't need to reschedule. Constantly rescheduling under a steady stream
- // of events (e.g. project search streaming results) would starve the task forever.
- if debounce.is_some() && self.cached_entries_update_pending {
+ self.cached_entries_update_pending
+ .get_or_insert(CachedEntriesUpdate::Entries);
+ if !self.cached_entries_update_task.is_ready() {
return;
}
- self.cached_entries_update_pending = true;
self.cached_entries_update_task = cx.spawn_in(window, async move |outline_panel, cx| {
- if let Some(debounce) = debounce {
- cx.background_executor().timer(debounce).await;
- }
- let Some(new_cached_entries) = outline_panel
- .update_in(cx, |outline_panel, window, cx| {
- outline_panel.cached_entries_update_pending = false;
- let is_singleton = outline_panel.is_singleton_active(cx);
- let query = outline_panel.query(cx);
- outline_panel.generate_cached_entries(is_singleton, query, window, cx)
- })
- .ok()
- else {
- return;
- };
- let (new_cached_entries, max_width_item_index) = new_cached_entries.await;
- outline_panel
- .update_in(cx, |outline_panel, window, cx| {
- outline_panel.cached_entries = new_cached_entries;
- outline_panel.max_width_item_index = max_width_item_index;
- if (outline_panel.selected_entry.is_invalidated()
- || matches!(outline_panel.selected_entry, SelectedEntry::None))
- && let Some(new_selected_entry) =
- outline_panel.active_editor().and_then(|active_editor| {
- outline_panel.location_for_editor_selection(
- &active_editor,
- window,
- cx,
- )
- })
- {
- outline_panel.select_entry(new_selected_entry, false, window, cx);
- }
+ let mut debounce = debounce;
+ loop {
+ if let Some(debounce) = debounce {
+ cx.background_executor().timer(debounce).await;
+ }
+ let Some(new_cached_entries) = outline_panel
+ .update_in(cx, |outline_panel, window, cx| {
+ if outline_panel.cached_entries_update_pending.take()
+ == Some(CachedEntriesUpdate::Contents)
+ {
+ outline_panel.update_non_fs_items(window, cx);
+ }
+ let is_singleton = outline_panel.is_singleton_active(cx);
+ let query = outline_panel.query(cx);
+ outline_panel.generate_cached_entries(is_singleton, query, window, cx)
+ })
+ .ok()
+ else {
+ return;
+ };
+ let (new_cached_entries, max_width_item_index) = new_cached_entries.await;
+ outline_panel
+ .update_in(cx, |outline_panel, window, cx| {
+ outline_panel.cached_entries = new_cached_entries;
+ outline_panel.max_width_item_index = max_width_item_index;
+ if let SelectedEntry::Valid(selected, _) = &outline_panel.selected_entry
+ && let Some((index, cached)) =
+ outline_panel.cached_entry_for_selection(selected)
+ {
+ outline_panel.selected_entry =
+ SelectedEntry::Valid(cached.entry.clone(), index);
+ }
+ if (outline_panel.selected_entry.is_invalidated()
+ || matches!(outline_panel.selected_entry, SelectedEntry::None))
+ && let Some(new_selected_entry) =
+ outline_panel.active_editor().and_then(|active_editor| {
+ outline_panel.location_for_editor_selection(
+ &active_editor,
+ window,
+ cx,
+ )
+ })
+ {
+ let awaiting_outlines = match &new_selected_entry {
+ PanelEntry::Outline(outline) => outline_panel
+ .buffers
+ .get(&outline.buffer_id())
+ .is_some_and(BufferOutlines::should_fetch_outlines),
+ _ => false,
+ };
+ outline_panel.select_entry(new_selected_entry, false, window, cx);
+ if awaiting_outlines {
+ outline_panel.selected_entry.invalidate();
+ }
+ }
- cx.notify();
- })
- .ok();
+ cx.notify();
+ })
+ .ok();
+ if !outline_panel
+ .read_with(cx, |panel, _| panel.cached_entries_update_pending.is_some())
+ .unwrap_or(false)
+ {
+ break;
+ }
+ debounce = Some(UPDATE_DEBOUNCE);
+ }
});
}
- fn generate_cached_entries(
- &self,
- is_singleton: bool,
- query: Option<String>,
- window: &mut Window,
- cx: &mut Context<Self>,
- ) -> Task<(Vec<CachedEntry>, Option<usize>)> {
- let project = self.project.clone();
- let Some(active_editor) = self.active_editor() else {
- return Task::ready((Vec::new(), None));
- };
- cx.spawn_in(window, async move |outline_panel, cx| {
- let mut generation_state = GenerationState::default();
-
- let Ok(()) = outline_panel.update(cx, |outline_panel, cx| {
- let auto_fold_dirs = OutlinePanelSettings::get_global(cx).auto_fold_dirs;
+ fn cached_entry_for_selection(&self, selected: &PanelEntry) -> Option<(usize, &CachedEntry)> {
+ if let Some(entry) = self
+ .cached_entries
+ .iter()
+ .enumerate()
+ .find(|(_, cached)| &cached.entry == selected)
+ {
+ return Some(entry);
+ }
+ let (worktree_id, path, first_buffer_id) = match selected {
+ PanelEntry::Fs(FsEntry::Directory(directory)) => (
+ directory.worktree_id,
+ &directory.entry.path,
+ directory.first_buffer_id,
+ ),
+ PanelEntry::FoldedDirs(group) => (
+ group.worktree_id,
+ &group.entries.last()?.path,
+ group.first_buffer_id,
+ ),
+ _ => return None,
+ };
+ let mut first_section = None;
+ let mut current_section = None;
+ let mut selected_section = None;
+ for entry in &self.fs_entries {
+ match entry {
+ FsEntry::Directory(directory)
+ if directory.worktree_id == worktree_id && directory.entry.path == *path =>
+ {
+ first_section.get_or_insert(directory.first_buffer_id);
+ current_section = Some(directory.first_buffer_id);
+ }
+ FsEntry::File(file) if file.buffer_id == first_buffer_id => {
+ if file.worktree_id == worktree_id
+ && file
+ .entry
+ .path
+ .parent()
+ .is_some_and(|parent| parent.starts_with(path))
+ {
+ selected_section = current_section;
+ break;
+ }
+ }
+ _ => {}
+ }
+ }
+ let selected_section = selected_section.or(first_section)?;
+ self.cached_entries
+ .iter()
+ .enumerate()
+ .find(|(_, cached)| match &cached.entry {
+ PanelEntry::Fs(FsEntry::Directory(directory)) => {
+ directory.worktree_id == worktree_id
+ && directory.first_buffer_id == selected_section
+ && directory.entry.path == *path
+ }
+ PanelEntry::FoldedDirs(group) => {
+ group.worktree_id == worktree_id
+ && group.first_buffer_id == selected_section
+ && group.entries.iter().any(|entry| entry.path == *path)
+ }
+ _ => false,
+ })
+ }
+
+ fn generate_cached_entries(
+ &self,
+ is_singleton: bool,
+ query: Option<String>,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) -> Task<(Vec<CachedEntry>, Option<usize>)> {
+ let Some(active_editor) = self.active_editor() else {
+ return Task::ready((Vec::new(), None));
+ };
+ cx.spawn_in(window, async move |outline_panel, cx| {
+ let mut generation_state = GenerationState::default();
+
+ let Ok(()) = outline_panel.update(cx, |outline_panel, cx| {
+ let auto_fold_dirs = OutlinePanelSettings::get_global(cx).auto_fold_dirs;
let hide_symbols = !is_singleton && outline_panel.hide_symbols_active(cx);
let mut folded_dirs_entry = None::<(usize, FoldedDirsEntry)>;
let track_matches = query.is_some();
@@ -3801,6 +4105,7 @@ impl OutlinePanel {
folded: bool,
expanded: bool,
depth: usize,
+ worktree_id: WorktreeId,
}
let search_precomputed = if hide_symbols {
@@ -3863,27 +4168,20 @@ impl OutlinePanel {
let (depth, should_add) = match &entry {
FsEntry::Directory(directory_entry) => {
let mut should_add = true;
- let is_root = project
- .read(cx)
- .worktree_for_id(directory_entry.worktree_id, cx)
- .is_some_and(|worktree| {
- worktree.read(cx).root_entry() == Some(&directory_entry.entry)
- });
+ let is_root = directory_entry.entry.path.is_empty();
let folded = auto_fold_dirs
&& !is_root
&& outline_panel
.unfolded_dirs
.get(&directory_entry.worktree_id)
.is_none_or(|unfolded_dirs| {
- !unfolded_dirs.contains(&directory_entry.entry.id)
+ !unfolded_dirs.contains(&directory_entry.entry.path)
});
- let fs_depth = outline_panel
- .fs_entries_depth
- .get(&(directory_entry.worktree_id, directory_entry.entry.id))
- .copied()
- .unwrap_or(0);
+ let fs_depth = directory_entry.entry.path.components().count();
while let Some(parent) = parent_dirs.last() {
- if !is_root && directory_entry.entry.path.starts_with(&parent.path)
+ if !is_root
+ && parent.worktree_id == directory_entry.worktree_id
+ && directory_entry.entry.path.starts_with(&parent.path)
{
break;
}
@@ -3917,6 +4215,7 @@ impl OutlinePanel {
parent.depth + 1
};
parent_dirs.push(ParentStats {
+ worktree_id: directory_entry.worktree_id,
path: directory_entry.entry.path.clone(),
folded,
expanded: parent_expanded && is_expanded,
@@ -3926,6 +4225,7 @@ impl OutlinePanel {
}
None => {
parent_dirs.push(ParentStats {
+ worktree_id: directory_entry.worktree_id,
path: directory_entry.entry.path.clone(),
folded,
expanded: is_expanded,
@@ -3984,6 +4284,7 @@ impl OutlinePanel {
depth,
FoldedDirsEntry {
worktree_id: directory_entry.worktree_id,
+ first_buffer_id: directory_entry.first_buffer_id,
entries: vec![directory_entry.entry.clone()],
},
))
@@ -3994,6 +4295,7 @@ impl OutlinePanel {
depth,
FoldedDirsEntry {
worktree_id: directory_entry.worktree_id,
+ first_buffer_id: directory_entry.first_buffer_id,
entries: vec![directory_entry.entry.clone()],
},
));
@@ -4005,15 +4307,15 @@ impl OutlinePanel {
}
FsEntry::ExternalFile(..) => {
if let Some((folded_depth, folded_dir)) = folded_dirs_entry.take() {
+ let folded_paths = folded_dir
+ .entries
+ .iter()
+ .map(|entry| &entry.path)
+ .collect::<HashSet<_>>();
let parent_expanded = parent_dirs
.iter()
.rev()
- .find(|parent| {
- folded_dir
- .entries
- .iter()
- .all(|entry| entry.path != parent.path)
- })
+ .find(|parent| !folded_paths.contains(&parent.path))
.is_none_or(|parent| parent.expanded);
if !is_singleton && (parent_expanded || query.is_some()) {
outline_panel.push_entry(
@@ -4030,15 +4332,15 @@ impl OutlinePanel {
}
FsEntry::File(file) => {
if let Some((folded_depth, folded_dirs)) = folded_dirs_entry.take() {
+ let folded_paths = folded_dirs
+ .entries
+ .iter()
+ .map(|entry| &entry.path)
+ .collect::<HashSet<_>>();
let parent_expanded = parent_dirs
.iter()
.rev()
- .find(|parent| {
- folded_dirs
- .entries
- .iter()
- .all(|entry| entry.path != parent.path)
- })
+ .find(|parent| !folded_paths.contains(&parent.path))
.is_none_or(|parent| parent.expanded);
if !is_singleton && (parent_expanded || query.is_some()) {
outline_panel.push_entry(
@@ -4051,13 +4353,15 @@ impl OutlinePanel {
}
}
- let fs_depth = outline_panel
- .fs_entries_depth
- .get(&(file.worktree_id, file.entry.id))
- .copied()
- .unwrap_or(0);
+ let fs_depth = file.entry.path.components().count();
while let Some(parent) = parent_dirs.last() {
- if file.entry.path.starts_with(&parent.path) {
+ if parent.worktree_id == file.worktree_id
+ && file
+ .entry
+ .path
+ .parent()
+ .is_some_and(|path| path.starts_with(&parent.path))
+ {
break;
}
parent_dirs.pop();
@@ -4156,15 +4460,15 @@ impl OutlinePanel {
}
if let Some((folded_depth, folded_dirs)) = folded_dirs_entry.take() {
+ let folded_paths = folded_dirs
+ .entries
+ .iter()
+ .map(|entry| &entry.path)
+ .collect::<HashSet<_>>();
let parent_expanded = parent_dirs
.iter()
.rev()
- .find(|parent| {
- folded_dirs
- .entries
- .iter()
- .all(|entry| entry.path != parent.path)
- })
+ .find(|parent| !folded_paths.contains(&parent.path))
.is_none_or(|parent| parent.expanded);
if parent_expanded || query.is_some() {
outline_panel.push_entry(
@@ -4241,6 +4545,7 @@ impl OutlinePanel {
}
1 => PanelEntry::Fs(FsEntry::Directory(FsEntryDirectory {
worktree_id: folded_dirs_entry.worktree_id,
+ first_buffer_id: folded_dirs_entry.first_buffer_id,
entry: folded_dirs_entry.entries[0].clone(),
})),
_ => entry,
@@ -4306,7 +4611,12 @@ impl OutlinePanel {
});
}
- fn dir_names_string(&self, entries: &[GitEntry], worktree_id: WorktreeId, cx: &App) -> String {
+ fn dir_names_string(
+ &self,
+ entries: &[FsEntryPath],
+ worktree_id: WorktreeId,
+ cx: &App,
+ ) -> String {
let dir_names_segment = entries
.iter()
.map(|entry| self.entry_name(&worktree_id, entry, cx))
@@ -4335,23 +4645,23 @@ impl OutlinePanel {
}) => CollapsedEntry::File(*worktree_id, *buffer_id),
FsEntry::Directory(FsEntryDirectory {
worktree_id, entry, ..
- }) => CollapsedEntry::Dir(*worktree_id, entry.id),
+ }) => CollapsedEntry::Dir(*worktree_id, entry.path.clone()),
};
!self.collapsed_entries.contains(&entry_to_check)
}
- fn update_non_fs_items(&mut self, window: &mut Window, cx: &mut Context<OutlinePanel>) -> bool {
+ fn update_non_fs_items(&mut self, window: &mut Window, cx: &mut Context<OutlinePanel>) {
if !self.active {
- return false;
+ return;
}
- let mut update_cached_items = false;
- update_cached_items |= self.update_search_matches(window, cx);
- self.fetch_outdated_outlines(window, cx);
- if update_cached_items {
+ if self.cached_entries_update_pending == Some(CachedEntriesUpdate::Contents) {
+ self.cached_entries_update_pending = Some(CachedEntriesUpdate::Entries);
+ }
+ if self.update_search_matches(window, cx) {
self.selected_entry.invalidate();
}
- update_cached_items
+ self.fetch_outdated_outlines(None, window, cx);
}
fn update_search_matches(
@@ -4366,31 +4676,21 @@ impl OutlinePanel {
let project_search = self
.active_item()
.and_then(|item| item.downcast::<ProjectSearchView>());
- let project_search_matches = project_search
- .as_ref()
- .map(|project_search| project_search.read(cx).get_matches(cx))
- .unwrap_or_default();
- let buffer_search = self
- .active_item()
- .as_deref()
- .and_then(|active_item| {
- self.workspace
- .upgrade()
- .and_then(|workspace| workspace.read(cx).pane_for(active_item))
- })
- .and_then(|pane| {
- pane.read(cx)
- .toolbar()
- .read(cx)
- .item_of_type::<BufferSearchBar>()
- });
let buffer_search_matches = self
.active_editor()
.map(|active_editor| {
active_editor.update(cx, |editor, cx| editor.get_matches(window, cx).0)
})
.unwrap_or_default();
+ let project_search_matches = if buffer_search_matches.is_empty() {
+ project_search
+ .as_ref()
+ .map(|project_search| project_search.read(cx).get_matches(cx))
+ .unwrap_or_default()
+ } else {
+ Vec::new()
+ };
let mut update_cached_entries = false;
if buffer_search_matches.is_empty() && project_search_matches.is_empty() {
@@ -4408,6 +4708,20 @@ impl OutlinePanel {
.unwrap_or_default(),
)
} else {
+ let buffer_search = self
+ .active_item()
+ .as_deref()
+ .and_then(|active_item| {
+ self.workspace
+ .upgrade()
+ .and_then(|workspace| workspace.read(cx).pane_for(active_item))
+ })
+ .and_then(|pane| {
+ pane.read(cx)
+ .toolbar()
+ .read(cx)
+ .item_of_type::<BufferSearchBar>()
+ });
(
SearchKind::Buffer,
buffer_search_matches,
@@ -4465,119 +4779,142 @@ impl OutlinePanel {
let Some(buffer) = self.buffers.get(&buffer_id) else {
return;
};
-
let buffer_snapshot = self.buffer_snapshot_for_id(buffer_id, cx);
-
- for excerpt in &buffer.excerpts {
- let excerpt_depth = parent_depth + 1;
- self.push_entry(
- state,
- track_matches,
- PanelEntry::Outline(OutlineEntry::Excerpt(excerpt.clone())),
- excerpt_depth,
- cx,
- );
-
- let mut outline_base_depth = excerpt_depth + 1;
- if is_singleton {
- outline_base_depth = 0;
- state.clear();
- } else if query.is_none()
- && self
- .collapsed_entries
- .contains(&CollapsedEntry::Excerpt(excerpt.clone()))
+ let snapshot = buffer_snapshot.as_ref();
+ let mut excerpts = buffer
+ .excerpts
+ .iter()
+ .map(|excerpt| ExcerptOutlines {
+ excerpt,
+ ranked_range: 0..0,
+ expanded: is_singleton
+ || query.is_some()
+ || !self
+ .collapsed_entries
+ .contains(&CollapsedEntry::Excerpt(excerpt.clone())),
+ visible: Vec::new(),
+ children_to_cache: Vec::new(),
+ })
+ .collect::<Vec<_>>();
+ let expanded_excerpts = excerpts.iter().filter(|excerpt| excerpt.expanded).count();
+ if expanded_excerpts > 0 {
+ let children = self.outline_children_cache.entry(buffer_id).or_default();
+ let outlines = buffer.iter_outlines().collect::<Vec<_>>();
+ if let Some(snapshot) = snapshot
+ && expanded_excerpts > 1
+ && !outlines.is_empty()
{
- continue;
- }
-
- let mut last_depth_at_level: Vec<Option<Range<Anchor>>> = vec![None; 10];
-
- let all_outlines = buffer
- .iter_outlines()
- .filter(|outline| match &buffer_snapshot {
- Some(buffer_snapshot) => {
- outline
- .range
- .start
- .cmp(&excerpt.context.end, buffer_snapshot)
- .is_le()
+ let mut coordinates = Vec::new();
+ for outline in &outlines {
+ coordinates.extend([outline.range.start, outline.range.end]);
+ }
+ for excerpt in excerpts.iter().filter(|excerpt| excerpt.expanded) {
+ coordinates
+ .extend([excerpt.excerpt.context.start, excerpt.excerpt.context.end]);
+ }
+ coordinates.sort_unstable_by(|left, right| left.cmp(right, snapshot));
+ coordinates.dedup_by(|left, right| left.cmp(right, snapshot).is_eq());
+ let rank = |anchor: Anchor| {
+ coordinates
+ .partition_point(|coordinate| coordinate.cmp(&anchor, snapshot).is_lt())
+ };
+ let outlines = outlines
+ .iter()
+ .map(|outline| IndexedOutline {
+ outline,
+ ranked_range: rank(outline.range.start)..rank(outline.range.end),
+ collapsed: self
+ .collapsed_entries
+ .contains(&CollapsedEntry::Outline(outline.range.clone())),
+ })
+ .collect::<Vec<_>>();
+ for excerpt in excerpts.iter_mut().filter(|excerpt| excerpt.expanded) {
+ excerpt.ranked_range =
+ rank(excerpt.excerpt.context.start)..rank(excerpt.excerpt.context.end);
+ }
+ BufferOutlines::assign_outline_cache_owners(&outlines, &mut excerpts);
+ if BufferOutlines::outlines_are_well_formed(&outlines) {
+ BufferOutlines::collect_nested_outlines(&outlines, &mut excerpts, children);
+ } else {
+ BufferOutlines::collect_overlapping_outlines(
+ &outlines,
+ &mut excerpts,
+ children,
+ );
+ }
+ } else {
+ for excerpt in excerpts.iter_mut().filter(|excerpt| excerpt.expanded) {
+ let mut matches = outlines
+ .iter()
+ .copied()
+ .filter(|outline| {
+ snapshot.is_none_or(|snapshot| {
+ outline
+ .range
+ .start
+ .cmp(&excerpt.excerpt.context.end, snapshot)
+ .is_le()
+ && outline
+ .range
+ .end
+ .cmp(&excerpt.excerpt.context.start, snapshot)
+ .is_ge()
+ })
+ })
+ .peekable();
+ let mut collapsed_ancestor: Option<&Outline> = None;
+ while let Some(outline) = matches.next() {
+ children.insert(
+ (outline.range.clone(), outline.depth),
+ matches
+ .peek()
+ .is_some_and(|next| next.depth > outline.depth),
+ );
+ if let Some(ancestor) = collapsed_ancestor
+ && let Some(snapshot) = snapshot
+ && outline.depth > ancestor.depth
&& outline
.range
- .end
- .cmp(&excerpt.context.start, buffer_snapshot)
+ .start
+ .cmp(&ancestor.range.start, snapshot)
.is_ge()
- }
- None => true,
- })
- .collect::<Vec<_>>();
-
- let mut outline_has_children = HashMap::default();
- let mut visible_outlines = Vec::new();
- let mut collapsed_state: Option<(usize, Range<Anchor>)> = None;
-
- for (i, &outline) in all_outlines.iter().enumerate() {
- let has_children = all_outlines
- .get(i + 1)
- .map(|next| next.depth > outline.depth)
- .unwrap_or(false);
-
- outline_has_children.insert((outline.range.clone(), outline.depth), has_children);
-
- let mut should_include = true;
-
- if let Some((collapsed_depth, collapsed_range)) = &collapsed_state {
- if outline.depth <= *collapsed_depth {
- collapsed_state = None;
- } else if let Some(buffer_snapshot) = buffer_snapshot.as_ref() {
- let outline_start = outline.range.start;
- if outline_start
- .cmp(&collapsed_range.start, buffer_snapshot)
- .is_ge()
- && outline_start
- .cmp(&collapsed_range.end, buffer_snapshot)
+ && outline
+ .range
+ .start
+ .cmp(&ancestor.range.end, snapshot)
.is_lt()
{
- should_include = false; // Skip - inside collapsed range
- } else {
- collapsed_state = None;
+ continue;
}
+ excerpt.visible.push(outline);
+ collapsed_ancestor = self
+ .collapsed_entries
+ .contains(&CollapsedEntry::Outline(outline.range.clone()))
+ .then_some(outline);
}
}
-
- // Check if this outline itself is collapsed
- if should_include
- && self
- .collapsed_entries
- .contains(&CollapsedEntry::Outline(outline.range.clone()))
- {
- collapsed_state = Some((outline.depth, outline.range.clone()));
- }
-
- if should_include {
- visible_outlines.push(outline);
- }
}
-
- self.outline_children_cache
- .entry(buffer_id)
- .or_default()
- .extend(outline_has_children);
-
- for outline in visible_outlines {
- let outline_entry = outline.clone();
-
- if outline.depth < last_depth_at_level.len() {
- last_depth_at_level[outline.depth] = Some(outline.range.clone());
- // Clear deeper levels when we go back to a shallower depth
- for d in (outline.depth + 1)..last_depth_at_level.len() {
- last_depth_at_level[d] = None;
- }
- }
-
+ }
+ for excerpt in excerpts {
+ let excerpt_depth = parent_depth + 1;
+ self.push_entry(
+ state,
+ track_matches,
+ PanelEntry::Outline(OutlineEntry::Excerpt(excerpt.excerpt.clone())),
+ excerpt_depth,
+ cx,
+ );
+ let outline_base_depth = if is_singleton {
+ state.clear();
+ 0
+ } else {
+ excerpt_depth + 1
+ };
+ for outline in excerpt.visible {
self.push_entry(
state,
track_matches,
- PanelEntry::Outline(OutlineEntry::Outline(outline_entry)),
+ PanelEntry::Outline(OutlineEntry::Outline(outline.clone())),
outline_base_depth + outline.depth,
cx,
);
@@ -4613,7 +4950,7 @@ impl OutlinePanel {
return;
};
- let excerpt_ranges = excerpts
+ let mut excerpt_ranges = excerpts
.iter()
.filter_map(|excerpt| {
let start = search
@@ -4626,11 +4963,25 @@ impl OutlinePanel {
})
.collect::<Vec<_>>();
+ let snapshot = &search.multi_buffer_snapshot;
+ excerpt_ranges.sort_unstable_by(|left, right| left.start.cmp(&right.start, snapshot));
+ let mut maximum_end = None;
+ for range in &mut excerpt_ranges {
+ if let Some(end) = maximum_end
+ && range.end.cmp(&end, snapshot).is_lt()
+ {
+ range.end = end;
+ }
+ maximum_end = Some(range.end);
+ }
let depth = if is_singleton { 0 } else { parent_depth + 1 };
for (match_range, search_data) in buffer_matches.iter().filter(|(match_range, _)| {
- excerpt_ranges.iter().any(|excerpt_range| {
- excerpt_range.overlaps(match_range, &search.multi_buffer_snapshot)
- })
+ let index = excerpt_ranges
+ .partition_point(|excerpt| excerpt.start.cmp(&match_range.end, snapshot).is_le());
+ index
+ .checked_sub(1)
+ .and_then(|index| excerpt_ranges.get(index))
+ .is_some_and(|excerpt| excerpt.end.cmp(&match_range.start, snapshot).is_ge())
}) {
self.push_entry(
state,
@@ -4820,9 +5171,12 @@ impl OutlinePanel {
} else {
let list_contents = {
let items_len = self.cached_entries.len();
- let multi_buffer_snapshot = self
- .active_editor()
- .map(|editor| editor.read(cx).buffer().read(cx).snapshot(cx));
+ let multi_buffer_snapshot = match self.mode {
+ ItemsDisplayMode::Search(_) => self
+ .active_editor()
+ .map(|editor| editor.read(cx).buffer().read(cx).snapshot(cx)),
+ ItemsDisplayMode::Outline => None,
+ };
uniform_list(
"entries",
items_len,
@@ -5048,35 +5402,19 @@ impl OutlinePanel {
fn buffers_inside_directory(
&self,
- dir_worktree: WorktreeId,
- dir_entry: &GitEntry,
+ worktree_id: WorktreeId,
+ directory: &FsEntryPath,
) -> HashSet<BufferId> {
- if !dir_entry.is_dir() {
- debug_panic!("buffers_inside_directory called on a non-directory entry {dir_entry:?}");
- return HashSet::default();
- }
-
self.fs_entries
.iter()
- .skip_while(|fs_entry| match fs_entry {
- FsEntry::Directory(directory) => {
- directory.worktree_id != dir_worktree || &directory.entry != dir_entry
- }
- _ => true,
- })
- .skip(1)
- .take_while(|fs_entry| match fs_entry {
- FsEntry::ExternalFile(..) => false,
- FsEntry::Directory(directory) => {
- directory.worktree_id == dir_worktree
- && directory.entry.path.starts_with(&dir_entry.path)
- }
- FsEntry::File(file) => {
- file.worktree_id == dir_worktree && file.entry.path.starts_with(&dir_entry.path)
+ .filter_map(|entry| match entry {
+ FsEntry::File(file)
+ if file.worktree_id == worktree_id
+ && file.entry.path != directory.path
+ && file.entry.path.starts_with(&directory.path) =>
+ {
+ Some(file.buffer_id)
}
- })
- .filter_map(|fs_entry| match fs_entry {
- FsEntry::File(file) => Some(file.buffer_id),
_ => None,
})
.collect()
@@ -5094,27 +5432,6 @@ fn workspace_active_editor(
Some((active_item, active_editor))
}
-fn back_to_common_visited_parent(
- visited_dirs: &mut Vec<(ProjectEntryId, Arc<RelPath>)>,
- worktree_id: &WorktreeId,
- new_entry: &Entry,
-) -> Option<(WorktreeId, ProjectEntryId)> {
- while let Some((visited_dir_id, visited_path)) = visited_dirs.last() {
- match new_entry.path.parent() {
- Some(parent_path) => {
- if parent_path == visited_path.as_ref() {
- return Some((*worktree_id, *visited_dir_id));
- }
- }
- None => {
- break;
- }
- }
- visited_dirs.pop();
- }
- None
-}
-
fn file_name(path: &Path) -> String {
let mut current_path = path;
loop {
@@ -5191,6 +5508,8 @@ impl Panel for OutlinePanel {
let old_active = outline_panel.active;
outline_panel.active = active;
if old_active != active {
+ outline_panel.lsp_outline_refresh_task = Task::ready(());
+ outline_panel.outline_fetch_tasks.clear();
if active
&& let Some((active_item, active_editor)) =
outline_panel.workspace.upgrade().and_then(|workspace| {
@@ -5380,12 +5699,12 @@ fn subscribe_for_editor_events(
match e {
EditorEvent::SelectionsChanged { local: true } => {
outline_panel.reveal_entry_for_selection(editor.clone(), window, cx);
- cx.notify();
}
EditorEvent::BuffersRemoved { removed_buffer_ids } => {
- outline_panel
- .buffers
- .retain(|buffer_id, _| !removed_buffer_ids.contains(buffer_id));
+ for buffer_id in removed_buffer_ids {
+ outline_panel.buffers.remove(buffer_id);
+ outline_panel.outline_fetch_tasks.remove(buffer_id);
+ }
outline_panel.update_fs_entries(editor.clone(), debounce, window, cx);
}
EditorEvent::BufferRangesUpdated { buffer, .. } => {
@@ -5397,10 +5716,7 @@ fn subscribe_for_editor_events(
}
EditorEvent::BuffersEdited { buffer_ids } => {
outline_panel.invalidate_outlines(buffer_ids);
- let update_cached_items = outline_panel.update_non_fs_items(window, cx);
- if update_cached_items {
- outline_panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx);
- }
+ outline_panel.update_contents(debounce, window, cx);
}
EditorEvent::BufferFoldToggled { ids, .. } => {
outline_panel.invalidate_outlines(ids);
@@ -5459,26 +5775,42 @@ fn subscribe_for_editor_events(
outline_panel.update_fs_entries(editor.clone(), debounce, window, cx);
}
EditorEvent::Reparsed(buffer_id) => {
- if let Some(buffer) = outline_panel.buffers.get_mut(buffer_id) {
- buffer.invalidate_outlines();
- }
- let update_cached_items = outline_panel.update_non_fs_items(window, cx);
- if update_cached_items {
- outline_panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx);
- }
+ outline_panel.invalidate_outlines(&[*buffer_id]);
+ outline_panel.update_contents(debounce, window, cx);
}
EditorEvent::OutlineSymbolsChanged => {
- for buffer in outline_panel.buffers.values_mut() {
- buffer.invalidate_outlines();
- }
- if matches!(
- outline_panel.selected_entry(),
- Some(PanelEntry::Outline(..)),
- ) {
- outline_panel.selected_entry.invalidate();
- }
- if outline_panel.update_non_fs_items(window, cx) {
- outline_panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx);
+ if outline_panel.lsp_outline_refresh_task.is_ready() {
+ outline_panel.lsp_outline_refresh_task =
+ cx.spawn_in(window, async move |outline_panel, cx| {
+ cx.background_executor().timer(UPDATE_DEBOUNCE).await;
+ outline_panel
+ .update_in(cx, |outline_panel, window, cx| {
+ let Some(editor) = outline_panel.active_editor() else {
+ return;
+ };
+ let editor_buffer = editor.read(cx).buffer().read(cx);
+ let mut invalidated = false;
+ for (buffer_id, outlines) in &mut outline_panel.buffers {
+ if editor_buffer.buffer(*buffer_id).is_some_and(
+ |buffer| {
+ LanguageSettings::for_buffer(
+ buffer.read(cx),
+ cx,
+ )
+ .document_symbols
+ .lsp_enabled()
+ },
+ ) {
+ outlines.invalidate_outlines();
+ invalidated = true;
+ }
+ }
+ if invalidated {
+ outline_panel.fetch_outdated_outlines(None, window, cx);
+ }
+ })
+ .ok();
+ });
}
}
EditorEvent::TitleChanged => {
@@ -5557,8 +5889,10 @@ impl GenerationState {
#[cfg(test)]
mod tests {
+ use buffer_diff::BufferDiff;
use db::indoc;
- use futures::stream::StreamExt as _;
+ use editor::{HiddenUnstagedDiffHunkRenderer, PathKey};
+ use futures::{FutureExt as _, StreamExt as _, future::poll_fn, task::Poll};
use gpui::{TestAppContext, UpdateGlobal, VisualTestContext, WindowHandle};
use language::{self, FakeLspAdapter, markdown_lang, rust_lang};
use pretty_assertions::assert_eq;
@@ -5568,13 +5902,97 @@ mod tests {
project_search::{self, perform_project_search},
};
use serde_json::json;
- use util::path;
+ use util::{path, rel_path::rel_path};
use workspace::{MultiWorkspace, OpenOptions, OpenVisible, ToolbarItemView};
use super::*;
const SELECTED_MARKER: &str = " <==== selected";
+ #[gpui::test]
+ async fn test_outline_fetches_survive_unrelated_updates_but_not_deactivation(
+ cx: &mut TestAppContext,
+ ) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.background_executor.clone());
+ let project = Project::test(fs, [], cx).await;
+ let (window, workspace) = add_outline_panel(&project, cx).await;
+ let cx = &mut VisualTestContext::from_window(window.into(), cx);
+ let panel = outline_panel(&workspace, cx);
+ let [requested_id, retained_id, unknown_id] =
+ [1, 2, 3].map(|id| BufferId::new(id).expect("nonzero buffer ID"));
+ let (requested_sender, requested_receiver) = futures::channel::oneshot::channel::<()>();
+ let (retained_sender, retained_receiver) = futures::channel::oneshot::channel::<()>();
+ let (refresh_sender, refresh_receiver) = futures::channel::oneshot::channel::<()>();
+ panel.update(cx, |panel, cx| {
+ panel.lsp_outline_refresh_task = cx.background_spawn(async move {
+ refresh_receiver
+ .await
+ .expect("LSP refresh should be canceled before completion");
+ });
+ for buffer_id in [requested_id, retained_id] {
+ panel.buffers.insert(
+ buffer_id,
+ BufferOutlines {
+ excerpts: Vec::new(),
+ outlines: OutlineState::Outlines(Vec::new()),
+ },
+ );
+ }
+ for (buffer_id, receiver) in [
+ (requested_id, requested_receiver),
+ (retained_id, retained_receiver),
+ ] {
+ panel.outline_fetch_tasks.insert(
+ buffer_id,
+ cx.background_spawn(async move {
+ receiver
+ .await
+ .expect("outline fetch should be canceled before completion");
+ }),
+ );
+ }
+ panel.invalidate_outlines(&[]);
+ panel.invalidate_outlines(&[unknown_id]);
+ assert_eq!(panel.outline_fetch_tasks.len(), 2);
+ panel.invalidate_outlines(&[requested_id, requested_id, unknown_id]);
+ assert_eq!(
+ panel
+ .outline_fetch_tasks
+ .keys()
+ .copied()
+ .collect::<Vec<_>>(),
+ vec![retained_id]
+ );
+ assert!(matches!(
+ panel.buffers[&requested_id].outlines,
+ OutlineState::Invalidated(_)
+ ));
+ assert!(matches!(
+ panel.buffers[&retained_id].outlines,
+ OutlineState::Outlines(_)
+ ));
+ });
+ cx.run_until_parked();
+ assert!(requested_sender.is_canceled());
+ assert!(!retained_sender.is_canceled());
+ assert!(!refresh_sender.is_canceled());
+
+ panel.update_in(cx, |panel, window, cx| {
+ panel.active = true;
+ panel.pinned = true;
+ panel.set_active(false, window, cx);
+ });
+ cx.run_until_parked();
+ assert!(retained_sender.is_canceled());
+ assert!(refresh_sender.is_canceled());
+ panel.read_with(cx, |panel, _| {
+ assert!(!panel.active);
+ assert!(panel.outline_fetch_tasks.is_empty());
+ assert_eq!(panel.buffers.len(), 2);
+ });
+ }
+
#[gpui::test(iterations = 10)]
async fn test_project_search_results_toggling(cx: &mut TestAppContext) {
init_test(cx);
@@ -6114,211 +6532,2484 @@ mod tests {
);
});
- outline_panel.update_in(cx, |outline_panel, window, cx| {
- outline_panel.open_excerpts(&editor::actions::OpenExcerpts, window, cx);
- });
- cx.executor()
- .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
- cx.run_until_parked();
- let new_active_editor = outline_panel.read_with(cx, |outline_panel, _| {
- outline_panel
- .active_editor()
- .expect("should have an active editor open")
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.open_excerpts(&editor::actions::OpenExcerpts, window, cx);
+ });
+ cx.executor()
+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
+ cx.run_until_parked();
+ let new_active_editor = outline_panel.read_with(cx, |outline_panel, _| {
+ outline_panel
+ .active_editor()
+ .expect("should have an active editor open")
+ });
+ outline_panel.update(cx, |outline_panel, cx| {
+ assert_ne!(
+ active_editor, new_active_editor,
+ "After opening an excerpt, new editor should be open"
+ );
+ assert_eq!(
+ display_entries(
+ &project,
+ &snapshot(outline_panel, cx),
+ &outline_panel.cached_entries,
+ outline_panel.selected_entry(),
+ cx,
+ ),
+ "outline: pub(super) fn hints
+outline: fn hints_lifetimes_named <==== selected"
+ );
+ assert_eq!(
+ selected_row_text(&new_active_editor, cx),
+ clear_outline_metadata(next_navigated_outline_selection),
+ "When opening the excerpt, should navigate to the place corresponding the outline entry"
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_multiple_worktrees(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "one": {
+ "a.txt": "aaa aaa"
+ },
+ "two": {
+ "b.txt": "a aaa"
+ }
+
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root/one"))], cx).await;
+ let (window, workspace) = add_outline_panel(&project, cx).await;
+ let cx = &mut VisualTestContext::from_window(window.into(), cx);
+ let outline_panel = outline_panel(&workspace, cx);
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.set_active(true, window, cx)
+ });
+
+ let items = workspace
+ .update_in(cx, |workspace, window, cx| {
+ workspace.open_paths(
+ vec![PathBuf::from(path!("/root/two"))],
+ OpenOptions {
+ visible: Some(OpenVisible::OnlyDirectories),
+ ..Default::default()
+ },
+ None,
+ window,
+ cx,
+ )
+ })
+ .await;
+ assert_eq!(items.len(), 1, "Were opening another worktree directory");
+ assert!(
+ items[0].is_none(),
+ "Directory should be opened successfully"
+ );
+
+ workspace.update_in(cx, |workspace, window, cx| {
+ ProjectSearchView::deploy_search(
+ workspace,
+ &workspace::DeploySearch::default(),
+ window,
+ cx,
+ )
+ });
+ let search_view = workspace.update_in(cx, |workspace, _window, cx| {
+ workspace
+ .active_pane()
+ .read(cx)
+ .items()
+ .find_map(|item| item.downcast::<ProjectSearchView>())
+ .expect("Project search view expected to appear after new search event trigger")
+ });
+
+ let query = "aaa";
+ perform_project_search(&search_view, query, cx);
+ search_view.update(cx, |search_view, cx| {
+ search_view
+ .results_editor()
+ .update(cx, |results_editor, cx| {
+ assert_eq!(
+ results_editor.display_text(cx).match_indices(query).count(),
+ 3
+ );
+ });
+ });
+
+ cx.executor()
+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
+ cx.run_until_parked();
+ outline_panel.update(cx, |outline_panel, cx| {
+ assert_eq!(
+ display_entries(
+ &project,
+ &snapshot(outline_panel, cx),
+ &outline_panel.cached_entries,
+ outline_panel.selected_entry(),
+ cx,
+ ),
+ r#"one/
+ a.txt
+ search: «aaa» aaa <==== selected
+ search: aaa «aaa»
+two/
+ b.txt
+ search: a «aaa»"#
+ .to_string(),
+ );
+ });
+
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.select_previous(&SelectPrevious, window, cx);
+ outline_panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ });
+ cx.executor()
+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
+ cx.run_until_parked();
+ outline_panel.update(cx, |outline_panel, cx| {
+ assert_eq!(
+ display_entries(
+ &project,
+ &snapshot(outline_panel, cx),
+ &outline_panel.cached_entries,
+ outline_panel.selected_entry(),
+ cx,
+ ),
+ r#"one/
+ a.txt <==== selected
+two/
+ b.txt
+ search: a «aaa»"#
+ .to_string(),
+ );
+ });
+
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.select_next(&SelectNext, window, cx);
+ outline_panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ });
+ cx.executor()
+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
+ cx.run_until_parked();
+ outline_panel.update(cx, |outline_panel, cx| {
+ assert_eq!(
+ display_entries(
+ &project,
+ &snapshot(outline_panel, cx),
+ &outline_panel.cached_entries,
+ outline_panel.selected_entry(),
+ cx,
+ ),
+ r#"one/
+ a.txt
+two/ <==== selected"#
+ .to_string(),
+ );
+ });
+
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.expand_selected_entry(&ExpandSelectedEntry, window, cx);
+ });
+ cx.executor()
+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
+ cx.run_until_parked();
+ outline_panel.update(cx, |outline_panel, cx| {
+ assert_eq!(
+ display_entries(
+ &project,
+ &snapshot(outline_panel, cx),
+ &outline_panel.cached_entries,
+ outline_panel.selected_entry(),
+ cx,
+ ),
+ r#"one/
+ a.txt
+two/ <==== selected
+ b.txt
+ search: a «aaa»"#
+ .to_string()
+ );
+ });
+ }
+
+ #[gpui::test]
+ async fn test_file_order_matches_diff_multibuffer(cx: &mut TestAppContext) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "crates": { "ide": {
+ "asdsads": "new file",
+ "src": {
+ "interpret.rs": "fn interpret() {}",
+ "join_lines.rs": "fn join_lines() {}"
+ }
+ } }
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(true);
+ settings.multi_buffer_hide_symbols = Some(true);
+ });
+ let added = open_buffer(&project, path!("/root/crates/ide/asdsads"), cx).await;
+ let deleted = open_buffer(&project, path!("/root/crates/ide/src/join_lines.rs"), cx).await;
+ let modified = open_buffer(&project, path!("/root/crates/ide/src/interpret.rs"), cx).await;
+ fs.remove_file(
+ Path::new(path!("/root/crates/ide/src/join_lines.rs")),
+ project::RemoveOptions::default(),
+ )
+ .await
+ .expect("file deletion should succeed");
+ deleted.update(cx, |buffer, cx| {
+ buffer.edit(
+ [(language::Point::default()..buffer.max_point(), "")],
+ None,
+ cx,
+ );
+ });
+ let editor = add_diff_editor(
+ &workspace,
+ &project,
+ &[
+ (&modified, "old interpret"),
+ (&deleted, "fn join_lines() {}"),
+ (&added, ""),
+ ],
+ cx,
+ );
+ set_buffer_order(&editor, &[&modified, &deleted, &added], cx);
+ workspace.update_in(cx, |workspace, window, cx| {
+ workspace
+ .focus_panel::<OutlinePanel>(window, cx)
+ .expect("outline panel should be installed");
+ });
+ select_file(
+ &outline_panel,
+ modified.read_with(cx, |buffer, _| buffer.remote_id()),
+ cx,
+ );
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ crates/ide/
+ src/
+ interpret.rs <==== selected
+ ~~join_lines.rs~~
+ asdsads"
+ ),
+ cx,
+ );
+ set_buffer_order(&editor, &[&added, &deleted, &modified], cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ crates/ide/
+ asdsads
+ src/
+ ~~join_lines.rs~~
+ interpret.rs <==== selected"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_file_order_preserves_interleaved_directory_sections(cx: &mut TestAppContext) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/one"),
+ json!({ "é": { "子": { "first.txt": "first", "second.txt": "second" } } }),
+ )
+ .await;
+ fs.insert_tree(path!("/two"), json!({ "other.txt": "other" }))
+ .await;
+ let project = Project::test(
+ fs.clone(),
+ [Path::new(path!("/one")), Path::new(path!("/two"))],
+ cx,
+ )
+ .await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(true);
+ settings.multi_buffer_hide_symbols = Some(true);
+ });
+ let first = open_buffer(&project, path!("/one/é/子/first.txt"), cx).await;
+ let second = open_buffer(&project, path!("/one/é/子/second.txt"), cx).await;
+ let other = open_buffer(&project, path!("/two/other.txt"), cx).await;
+ let untitled = project.update(cx, |project, cx| {
+ project.create_local_buffer("untitled", None, true, cx)
+ });
+ fs.remove_dir(
+ Path::new(path!("/one/é")),
+ project::RemoveOptions {
+ recursive: true,
+ ignore_if_not_exists: false,
+ },
+ )
+ .await
+ .expect("ancestor deletion should succeed");
+ fs.insert_file(path!("/one/é"), b"replacement".to_vec())
+ .await;
+ let replacement = open_buffer(&project, path!("/one/é"), cx).await;
+ let editor = add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[
+ (&first, Vec::new()),
+ (&second, Vec::new()),
+ (&other, Vec::new()),
+ (&untitled, Vec::new()),
+ (&replacement, Vec::new()),
+ ],
+ cx,
+ );
+ set_buffer_order(
+ &editor,
+ &[&second, &other, &untitled, &first, &replacement],
+ cx,
+ );
+ select_file(
+ &outline_panel,
+ first.read_with(cx, |buffer, _| buffer.remote_id()),
+ cx,
+ );
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.select_parent(&SelectParent, window, cx);
+ });
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ one/
+ é/子/
+ ~~second.txt~~
+ two/
+ other.txt
+ external: untitled
+ one/
+ é/子/ <==== selected
+ ~~first.txt~~
+ é"
+ ),
+ cx,
+ );
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ one/
+ é/子/
+ two/
+ other.txt
+ external: untitled
+ one/
+ é/子/ <==== selected
+ é"
+ ),
+ cx,
+ );
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.expand_selected_entry(&ExpandSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ one/
+ é/子/
+ ~~second.txt~~
+ two/
+ other.txt
+ external: untitled
+ one/
+ é/子/ <==== selected
+ ~~first.txt~~
+ é"
+ ),
+ cx,
+ );
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(false);
+ });
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ select_file(
+ &outline_panel,
+ first.read_with(cx, |buffer, _| buffer.remote_id()),
+ cx,
+ );
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.select_parent(&SelectParent, window, cx);
+ });
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ one/
+ é/
+ 子/
+ ~~second.txt~~
+ two/
+ other.txt
+ external: untitled
+ one/
+ é/
+ 子/ <==== selected
+ ~~first.txt~~
+ é"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_directory_selection_survives_buffer_reordering(cx: &mut TestAppContext) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({ "dir": { "sub": { "a.txt": "a", "b.txt": "b" } }, "z.txt": "z" }),
+ )
+ .await;
+ let project = Project::test(fs, [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(true);
+ settings.multi_buffer_hide_symbols = Some(true);
+ });
+ let buffer_a = open_buffer(&project, path!("/root/dir/sub/a.txt"), cx).await;
+ let buffer_b = open_buffer(&project, path!("/root/dir/sub/b.txt"), cx).await;
+ let buffer_z = open_buffer(&project, path!("/root/z.txt"), cx).await;
+ let worktree_id = buffer_a.read_with(cx, |buffer, cx| {
+ File::from_dyn(buffer.file())
+ .expect("buffer should have a file")
+ .worktree
+ .read(cx)
+ .id()
+ });
+ let editor = add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[
+ (&buffer_a, Vec::new()),
+ (&buffer_b, Vec::new()),
+ (&buffer_z, Vec::new()),
+ ],
+ cx,
+ );
+ set_buffer_order(&editor, &[&buffer_b, &buffer_a, &buffer_z], cx);
+ workspace.update_in(cx, |workspace, window, cx| {
+ workspace
+ .focus_panel::<OutlinePanel>(window, cx)
+ .expect("outline panel should be installed");
+ });
+ select_directory(&outline_panel, worktree_id, rel_path("dir/sub"), cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/sub/ <==== selected
+ b.txt
+ a.txt
+ z.txt"
+ ),
+ cx,
+ );
+ set_buffer_order(&editor, &[&buffer_a, &buffer_b, &buffer_z], cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/sub/ <==== selected
+ a.txt
+ b.txt
+ z.txt"
+ ),
+ cx,
+ );
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.select_next(&SelectNext, window, cx);
+ });
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/sub/
+ a.txt <==== selected
+ b.txt
+ z.txt"
+ ),
+ cx,
+ );
+ select_directory(&outline_panel, worktree_id, rel_path("dir/sub"), cx);
+ rename_buffer(&project, &buffer_a, rel_path("a.txt"), cx).await;
+ set_buffer_order(&editor, &[&buffer_a, &buffer_b, &buffer_z], cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ a.txt
+ dir/sub/ <==== selected
+ b.txt
+ z.txt"
+ ),
+ cx,
+ );
+ rename_buffer(&project, &buffer_a, rel_path("dir/sub/a.txt"), cx).await;
+ set_buffer_order(&editor, &[&buffer_a, &buffer_b, &buffer_z], cx);
+ let buffer_a_id = buffer_a.read_with(cx, |buffer, _| buffer.remote_id());
+ editor.update(cx, |editor, cx| {
+ editor.buffer().update(cx, |multibuffer, cx| {
+ multibuffer.remove_excerpts_for_buffer(buffer_a_id, cx);
+ });
+ });
+ set_buffer_order(&editor, &[&buffer_b, &buffer_z], cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/sub/ <==== selected
+ b.txt
+ z.txt"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_selected_file_survives_rename_and_deletion(cx: &mut TestAppContext) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(path!("/root"), json!({ "a.txt": "a", "z.txt": "z" }))
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.multi_buffer_hide_symbols = Some(true);
+ });
+ let buffer_a = open_buffer(&project, path!("/root/a.txt"), cx).await;
+ let buffer_z = open_buffer(&project, path!("/root/z.txt"), cx).await;
+ let buffer_id = buffer_a.read_with(cx, |buffer, _| buffer.remote_id());
+ add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer_a, Vec::new()), (&buffer_z, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
+ workspace.update_in(cx, |workspace, window, cx| {
+ workspace
+ .focus_panel::<OutlinePanel>(window, cx)
+ .expect("outline panel should be installed");
+ });
+ select_file(&outline_panel, buffer_id, cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ a.txt <==== selected
+ z.txt"
+ ),
+ cx,
+ );
+
+ fs.rename(
+ Path::new(path!("/root/a.txt")),
+ Path::new(path!("/root/b.txt")),
+ project::RenameOptions::default(),
+ )
+ .await
+ .expect("file rename should succeed");
+ flush_outline_tasks(cx);
+ buffer_a.read_with(cx, |buffer, _| {
+ assert_eq!(
+ File::from_dyn(buffer.file())
+ .expect("buffer should retain its file")
+ .path
+ .as_ref(),
+ rel_path("b.txt"),
+ );
+ });
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ b.txt <==== selected
+ z.txt"
+ ),
+ cx,
+ );
+ outline_panel.update_in(cx, |panel, window, cx| {
+ assert!(panel.focus_handle.is_focused(window));
+ match &panel.selected_entry {
+ SelectedEntry::Valid(PanelEntry::Fs(FsEntry::File(file)), _) => {
+ assert_eq!(
+ (file.buffer_id, file.entry.path.as_ref()),
+ (buffer_id, rel_path("b.txt"))
+ );
+ }
+ selected => {
+ panic!("expected the renamed file to remain selected, got {selected:?}")
+ }
+ }
+ panel.select_next(&SelectNext, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ b.txt
+ z.txt <==== selected"
+ ),
+ cx,
+ );
+
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.select_previous(&SelectPrevious, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ b.txt <==== selected
+ z.txt"
+ ),
+ cx,
+ );
+ fs.remove_file(
+ Path::new(path!("/root/b.txt")),
+ project::RemoveOptions::default(),
+ )
+ .await
+ .expect("renamed file deletion should succeed");
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ ~~b.txt~~ <==== selected
+ z.txt"
+ ),
+ cx,
+ );
+ outline_panel.read_with(cx, |panel, _| match &panel.selected_entry {
+ SelectedEntry::Valid(PanelEntry::Fs(FsEntry::File(file)), _) => {
+ assert_eq!(
+ (file.buffer_id, file.entry.path.as_ref()),
+ (buffer_id, rel_path("b.txt"))
+ );
+ assert!(file.is_deleted);
+ }
+ selected => panic!("expected the deleted file to remain selected, got {selected:?}"),
+ });
+ }
+
+ #[gpui::test]
+ async fn test_directory_state_prunes_paths_after_repeated_renames(cx: &mut TestAppContext) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({ "d0": { "file.txt": "retained buffer" }, "z.txt": "z" }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(true);
+ settings.multi_buffer_hide_symbols = Some(true);
+ });
+ let buffer = open_buffer(&project, path!("/root/d0/file.txt"), cx).await;
+ let buffer_z = open_buffer(&project, path!("/root/z.txt"), cx).await;
+ let (buffer_id, worktree_id) = buffer.read_with(cx, |buffer, cx| {
+ let file = File::from_dyn(buffer.file()).expect("buffer should have a file");
+ (buffer.remote_id(), file.worktree.read(cx).id())
+ });
+ let buffer_z_id = buffer_z.read_with(cx, |buffer, _| buffer.remote_id());
+ add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer, Vec::new()), (&buffer_z, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
+ select_file(&outline_panel, buffer_z_id, cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ d0/
+ file.txt
+ z.txt <==== selected"
+ ),
+ cx,
+ );
+ assert_directory_paths(&outline_panel, worktree_id, &["", "d0"], &[], cx);
+
+ for (previous, next) in [("d0", "d1"), ("d1", "d2"), ("d2", "d3"), ("d3", "d4")] {
+ select_directory(&outline_panel, worktree_id, rel_path(previous), cx);
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+ select_file(&outline_panel, buffer_z_id, cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ &format!(
+ indoc!(
+ "
+ root/
+ {previous}/
+ z.txt <==== selected"
+ ),
+ previous = previous,
+ ),
+ cx,
+ );
+ assert_directory_paths(
+ &outline_panel,
+ worktree_id,
+ &["", previous],
+ &[previous],
+ cx,
+ );
+
+ let next_directory = Path::new(path!("/root")).join(next);
+ fs.create_dir(&next_directory)
+ .await
+ .expect("destination directory should be created");
+ let entry_id = buffer.read_with(cx, |buffer, _| {
+ File::from_dyn(buffer.file())
+ .and_then(|file| file.project_entry_id())
+ .expect("file should have a worktree entry")
+ });
+ project
+ .update(cx, |project, cx| {
+ project.rename_entry(
+ entry_id,
+ ProjectPath {
+ worktree_id,
+ path: Arc::from(rel_path(&format!("{next}/file.txt"))),
+ },
+ cx,
+ )
+ })
+ .await
+ .expect("file rename should succeed");
+ cx.run_until_parked();
+ project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+ flush_outline_tasks(cx);
+ buffer.read_with(cx, |buffer, _| {
+ let file = File::from_dyn(buffer.file()).expect("buffer should retain its file");
+ assert_eq!(buffer.remote_id(), buffer_id);
+ assert_eq!(file.path.as_ref(), rel_path(&format!("{next}/file.txt")));
+ });
+ assert_tree(
+ &outline_panel,
+ &project,
+ &format!(
+ indoc!(
+ "
+ root/
+ {next}/
+ file.txt
+ z.txt <==== selected"
+ ),
+ next = next,
+ ),
+ cx,
+ );
+ assert_directory_paths(&outline_panel, worktree_id, &["", next], &[], cx);
+ }
+ }
+
+ #[gpui::test]
+ async fn test_ignored_directory_expansion_does_not_scan_worktree(cx: &mut TestAppContext) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ ".gitignore": "ignored\n",
+ "ignored": {
+ "a": { "deep": { "open.txt": "first\n" } },
+ "b": { "open.txt": "second\n" },
+ "c": { "unopened.txt": "unopened\n" }
+ }
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.multi_buffer_hide_symbols = Some(true);
+ });
+ let buffer_a = open_buffer(&project, path!("/root/ignored/a/deep/open.txt"), cx).await;
+ let buffer_b = open_buffer(&project, path!("/root/ignored/b/open.txt"), cx).await;
+ let worktree = buffer_a.read_with(cx, |buffer, _| {
+ File::from_dyn(buffer.file()).unwrap().worktree.clone()
+ });
+ let worktree_id = worktree.read_with(cx, |worktree, _| worktree.id());
+ let buffer_a_id = buffer_a.read_with(cx, |buffer, _| buffer.remote_id());
+ let editor = add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer_a, Vec::new()), (&buffer_b, Vec::new())],
+ cx,
+ );
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ let scan_id = worktree.read_with(cx, |worktree, _| worktree.scan_id());
+ let read_dir_calls = fs.read_dir_call_count();
+ let metadata_calls = fs.metadata_call_count();
+
+ for auto_fold_dirs in [false, true] {
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(auto_fold_dirs);
+ });
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ let expanded_tree = if auto_fold_dirs {
+ indoc!(
+ "
+ root/
+ ignored/
+ a/deep/ <==== selected
+ open.txt
+ b/
+ open.txt"
+ )
+ } else {
+ indoc!(
+ "
+ root/
+ ignored/
+ a/
+ deep/ <==== selected
+ open.txt
+ b/
+ open.txt"
+ )
+ };
+ select_directory(&outline_panel, worktree_id, rel_path("ignored/a/deep"), cx);
+ for keyboard in [true, false] {
+ outline_panel.update_in(cx, |panel, window, cx| {
+ if keyboard {
+ panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ } else {
+ let entry = panel.selected_entry().unwrap().clone();
+ panel.toggle_expanded(&entry, window, cx);
+ }
+ });
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ assert!(
+ editor.read_with(cx, |editor, cx| editor.is_buffer_folded(buffer_a_id, cx))
+ );
+ outline_panel.update_in(cx, |panel, window, cx| {
+ if keyboard {
+ panel.expand_selected_entry(&ExpandSelectedEntry, window, cx);
+ } else {
+ let entry = panel.selected_entry().unwrap().clone();
+ panel.toggle_expanded(&entry, window, cx);
+ }
+ });
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ assert!(
+ !editor.read_with(cx, |editor, cx| editor.is_buffer_folded(buffer_a_id, cx))
+ );
+ assert_tree(&outline_panel, &project, expanded_tree, cx);
+ assert_eq!(
+ worktree.read_with(cx, |worktree, _| worktree.scan_id()),
+ scan_id
+ );
+ assert_eq!(fs.read_dir_call_count(), read_dir_calls);
+ assert_eq!(fs.metadata_call_count(), metadata_calls);
+ }
+
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ });
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ select_in_buffer(&editor, buffer_a_id, cx);
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ let revealed_tree = if auto_fold_dirs {
+ indoc!(
+ "
+ root/
+ ignored/
+ a/deep/
+ open.txt <==== selected
+ b/
+ open.txt"
+ )
+ } else {
+ indoc!(
+ "
+ root/
+ ignored/
+ a/
+ deep/
+ open.txt <==== selected
+ b/
+ open.txt"
+ )
+ };
+ assert_tree(&outline_panel, &project, revealed_tree, cx);
+ assert_eq!(
+ worktree.read_with(cx, |worktree, _| worktree.scan_id()),
+ scan_id
+ );
+ assert_eq!(fs.read_dir_call_count(), read_dir_calls);
+ assert_eq!(fs.metadata_call_count(), metadata_calls);
+ worktree.read_with(cx, |worktree, _| {
+ assert_eq!(
+ worktree
+ .entry_for_path(rel_path("ignored/c"))
+ .map(|entry| entry.kind),
+ Some(worktree::EntryKind::UnloadedDir),
+ );
+ assert_eq!(
+ worktree.entry_for_path(rel_path("ignored/c/unopened.txt")),
+ None
+ );
+ });
+ outline_panel.read_with(cx, |panel, _| {
+ assert_eq!(
+ panel
+ .fs_entries
+ .iter()
+ .map(|entry| match entry {
+ FsEntry::Directory(directory) =>
+ (directory.entry.path.as_ref(), directory.entry.is_ignored),
+ FsEntry::File(file) =>
+ (file.entry.path.as_ref(), file.entry.is_ignored),
+ FsEntry::ExternalFile(_) =>
+ panic!("indexed ignored files should not be external"),
+ })
+ .collect::<Vec<_>>(),
+ vec![
+ (rel_path(""), false),
+ (rel_path("ignored"), true),
+ (rel_path("ignored/a"), true),
+ (rel_path("ignored/a/deep"), true),
+ (rel_path("ignored/a/deep/open.txt"), true),
+ (rel_path("ignored/b"), true),
+ (rel_path("ignored/b/open.txt"), true),
+ ],
+ );
+ });
+ }
+ }
+
+ #[gpui::test]
+ async fn test_selected_folded_directory_survives_git_metadata_changes(cx: &mut TestAppContext) {
+ init_test(cx);
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ ".git": {},
+ "a": { "b": { "file.txt": "modified\n" } },
+ "z.txt": "unchanged\n"
+ }),
+ )
+ .await;
+ let base_contents = [
+ ("a/b/file.txt", "base\n".to_string()),
+ ("z.txt", "unchanged\n".to_string()),
+ ];
+ let dot_git = Path::new(path!("/root/.git"));
+ fs.set_head_for_repo(dot_git, &base_contents, "deadbeef");
+ fs.set_index_for_repo(dot_git, &base_contents);
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(true);
+ settings.multi_buffer_hide_symbols = Some(true);
+ });
+ let buffer = open_buffer(&project, path!("/root/a/b/file.txt"), cx).await;
+ let buffer_z = open_buffer(&project, path!("/root/z.txt"), cx).await;
+ let worktree_id = buffer.read_with(cx, |buffer, cx| {
+ File::from_dyn(buffer.file())
+ .expect("buffer should have a file")
+ .worktree
+ .read(cx)
+ .id()
+ });
+ add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer, Vec::new()), (&buffer_z, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
+ select_directory(&outline_panel, worktree_id, rel_path("a/b"), cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ a/b/ <==== selected
+ file.txt
+ z.txt"
+ ),
+ cx,
+ );
+ let metadata_before = outline_panel.read_with(cx, |panel, _| {
+ let Some(PanelEntry::FoldedDirs(group)) = panel.selected_entry() else {
+ panic!("folded directory should be selected");
+ };
+ assert_eq!(
+ group
+ .entries
+ .iter()
+ .map(|entry| (
+ entry.path.as_ref(),
+ entry.git_summary.worktree.modified,
+ entry.is_ignored
+ ))
+ .collect::<Vec<_>>(),
+ vec![(rel_path("a"), 1, false), (rel_path("a/b"), 1, false)],
+ );
+ group
+ .entries
+ .iter()
+ .map(|entry| entry.git_summary)
+ .collect::<Vec<_>>()
+ });
+
+ fs.remove_dir(
+ Path::new(path!("/root/a")),
+ project::RemoveOptions {
+ recursive: true,
+ ignore_if_not_exists: false,
+ },
+ )
+ .await
+ .expect("ancestor deletion should succeed");
+ cx.run_until_parked();
+ project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+ flush_outline_tasks(cx);
+ buffer.read_with(cx, |buffer, cx| {
+ let file = File::from_dyn(buffer.file()).expect("buffer should retain its file");
+ assert_eq!(file.disk_state, DiskState::Deleted);
+ assert_eq!(
+ file.worktree
+ .read(cx)
+ .entry_for_path(rel_path("a"))
+ .map(|entry| entry.kind),
+ None
+ );
+ });
+ let metadata_after = outline_panel.read_with(cx, |panel, _| {
+ let group = panel
+ .cached_entries
+ .iter()
+ .find_map(|cached| match &cached.entry {
+ PanelEntry::FoldedDirs(group)
+ if group.worktree_id == worktree_id
+ && group
+ .entries
+ .last()
+ .is_some_and(|entry| entry.path.as_ref() == rel_path("a/b")) =>
+ {
+ Some(group)
+ }
+ _ => None,
+ })
+ .expect("folded directory should retain its row");
+ assert_eq!(
+ group
+ .entries
+ .iter()
+ .map(|entry| entry.path.as_ref())
+ .collect::<Vec<_>>(),
+ vec![rel_path("a"), rel_path("a/b")],
+ );
+ group
+ .entries
+ .iter()
+ .map(|entry| entry.git_summary)
+ .collect::<Vec<_>>()
+ });
+ assert_ne!(metadata_before, metadata_after);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ a/b/ <==== selected
+ ~~file.txt~~
+ z.txt"
+ ),
+ cx,
+ );
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.select_next(&SelectNext, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ a/b/
+ ~~file.txt~~ <==== selected
+ z.txt"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_deleted_file_nests_under_existing_parent(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "dir": {
+ "a.txt": "hello world",
+ "b.txt": "hello there",
+ }
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+
+ let buffer_a = open_buffer(&project, path!("/root/dir/a.txt"), cx).await;
+ let buffer_b = open_buffer(&project, path!("/root/dir/b.txt"), cx).await;
+ add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer_a, Vec::new()), (&buffer_b, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/
+ a.txt
+ b.txt"
+ ),
+ cx,
+ );
+
+ fs.remove_file(Path::new(path!("/root/dir/a.txt")), Default::default())
+ .await
+ .unwrap();
+ flush_outline_tasks(cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/
+ ~~a.txt~~
+ b.txt"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_directory_collapse_survives_ancestor_changes(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "keep.txt": "hello there",
+ "dir": { "sub": { "a.txt": "hello world" } }
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(false);
+ });
+
+ let buffer_keep = open_buffer(&project, path!("/root/keep.txt"), cx).await;
+ let buffer_a = open_buffer(&project, path!("/root/dir/sub/a.txt"), cx).await;
+ let worktree_id = buffer_a.read_with(cx, |buffer, cx| {
+ File::from_dyn(buffer.file())
+ .expect("buffer should have a file")
+ .worktree
+ .read(cx)
+ .id()
+ });
+ add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer_keep, Vec::new()), (&buffer_a, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/
+ sub/
+ a.txt
+ keep.txt"
+ ),
+ cx,
+ );
+
+ fs.remove_file(
+ Path::new(path!("/root/dir/sub/a.txt")),
+ project::RemoveOptions::default(),
+ )
+ .await
+ .expect("file deletion should succeed");
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/
+ sub/
+ ~~a.txt~~
+ keep.txt"
+ ),
+ cx,
+ );
+
+ select_directory(&outline_panel, worktree_id, rel_path("dir"), cx);
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/ <==== selected
+ keep.txt"
+ ),
+ cx,
+ );
+
+ fs.remove_dir(
+ Path::new(path!("/root/dir")),
+ project::RemoveOptions {
+ recursive: true,
+ ignore_if_not_exists: false,
+ },
+ )
+ .await
+ .expect("ancestor deletion should succeed");
+ flush_outline_tasks(cx);
+ buffer_a.read_with(cx, |buffer, cx| {
+ let file = File::from_dyn(buffer.file()).expect("buffer should retain its file");
+ assert_eq!(file.disk_state, DiskState::Deleted);
+ assert_eq!(
+ file.worktree
+ .read(cx)
+ .entry_for_path(rel_path("dir"))
+ .map(|entry| entry.kind),
+ None,
+ );
+ });
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/ <==== selected
+ keep.txt"
+ ),
+ cx,
+ );
+
+ fs.create_dir(Path::new(path!("/root/dir/sub")))
+ .await
+ .expect("ancestor recreation should succeed");
+ flush_outline_tasks(cx);
+ buffer_a.read_with(cx, |buffer, cx| {
+ let file = File::from_dyn(buffer.file()).expect("buffer should retain its file");
+ assert_eq!(
+ file.worktree
+ .read(cx)
+ .entry_for_path(rel_path("dir/sub"))
+ .map(|entry| entry.is_dir()),
+ Some(true),
+ );
+ });
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/ <==== selected
+ keep.txt"
+ ),
+ cx,
+ );
+
+ fs.insert_file(path!("/root/dir/sub/a.txt"), b"hello world".to_vec())
+ .await;
+ flush_outline_tasks(cx);
+ buffer_a.read_with(cx, |buffer, _| {
+ let file = File::from_dyn(buffer.file()).expect("buffer should retain its file");
+ assert!(matches!(file.disk_state, DiskState::Present { .. }));
+ });
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/ <==== selected
+ keep.txt"
+ ),
+ cx,
+ );
+
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.expand_selected_entry(&ExpandSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/ <==== selected
+ sub/
+ a.txt
+ keep.txt"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_only_deleted_files_in_multiple_worktrees(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "one": { "é": { "子": { "a.txt": "one" } } },
+ "two": { "é": { "子": { "a.txt": "two" } } }
+ }),
+ )
+ .await;
+ let project = Project::test(
+ fs.clone(),
+ [Path::new(path!("/root/one")), Path::new(path!("/root/two"))],
+ cx,
+ )
+ .await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(false);
+ });
+
+ let buffer_one = open_buffer(&project, path!("/root/one/é/子/a.txt"), cx).await;
+ let buffer_two = open_buffer(&project, path!("/root/two/é/子/a.txt"), cx).await;
+ let worktree_one = buffer_one.read_with(cx, |buffer, cx| {
+ File::from_dyn(buffer.file())
+ .expect("buffer should have a file")
+ .worktree
+ .read(cx)
+ .id()
+ });
+ add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer_two, Vec::new()), (&buffer_one, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ one/
+ é/
+ 子/
+ a.txt
+ two/
+ é/
+ 子/
+ a.txt"
+ ),
+ cx,
+ );
+
+ for path in [path!("/root/one/é"), path!("/root/two/é")] {
+ fs.remove_dir(
+ Path::new(path),
+ project::RemoveOptions {
+ recursive: true,
+ ignore_if_not_exists: false,
+ },
+ )
+ .await
+ .expect("directory deletion should succeed");
+ }
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ one/
+ é/
+ 子/
+ ~~a.txt~~
+ two/
+ é/
+ 子/
+ ~~a.txt~~"
+ ),
+ cx,
+ );
+
+ select_directory(&outline_panel, worktree_one, rel_path("é"), cx);
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ one/
+ é/ <==== selected
+ two/
+ é/
+ 子/
+ ~~a.txt~~"
+ ),
+ cx,
+ );
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.expand_selected_entry(&ExpandSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ one/
+ é/ <==== selected
+ 子/
+ ~~a.txt~~
+ two/
+ é/
+ 子/
+ ~~a.txt~~"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_untitled_buffer_still_external(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(path!("/root"), json!({ "existing.txt": "hello" }))
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+
+ let untitled_buffer = project.update(cx, |project, cx| {
+ project.create_local_buffer("untitled content", None, true, cx)
+ });
+ add_multi_buffer_editor(&workspace, &project, &[(&untitled_buffer, Vec::new())], cx);
+ flush_outline_tasks(cx);
+
+ assert_tree(&outline_panel, &project, "external: untitled", cx);
+ }
+
+ #[gpui::test]
+ async fn test_auto_reveal_expands_ancestor_of_deleted_file(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "dir": {
+ "a.rs": indoc!(
+ "
+ pub fn foo() {
+ let x = 1;
+ }
+ "
+ ),
+ "b.rs": "pub fn bar() {}\n",
+ }
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+
+ let buffer_a = open_buffer(&project, path!("/root/dir/a.rs"), cx).await;
+ let buffer_b = open_buffer(&project, path!("/root/dir/b.rs"), cx).await;
+ let editor = add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer_a, Vec::new()), (&buffer_b, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
+
+ fs.remove_file(
+ Path::new(path!("/root/dir/a.rs")),
+ project::RemoveOptions::default(),
+ )
+ .await
+ .unwrap();
+ flush_outline_tasks(cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/
+ ~~a.rs~~
+ outline: pub fn foo <==== selected
+ b.rs
+ outline: pub fn bar"
+ ),
+ cx,
+ );
+
+ let buffer_a_id = buffer_a.read_with(cx, |buffer, _cx| buffer.remote_id());
+ let buffer_b_id = buffer_b.read_with(cx, |buffer, _cx| buffer.remote_id());
+ select_in_buffer(&editor, buffer_b_id, cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/
+ ~~a.rs~~
+ outline: pub fn foo
+ b.rs
+ outline: pub fn bar <==== selected"
+ ),
+ cx,
+ );
+
+ let worktree_id = buffer_a.read_with(cx, |buffer, cx| {
+ File::from_dyn(buffer.file())
+ .expect("buffer should have a file")
+ .worktree
+ .read(cx)
+ .id()
+ });
+ select_directory(&outline_panel, worktree_id, rel_path("dir"), cx);
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/ <==== selected"
+ ),
+ cx,
+ );
+
+ select_in_buffer(&editor, buffer_a_id, cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/
+ ~~a.rs~~ <==== selected
+ b.rs"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_open_deleted_file_entry_navigates_editor(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "dir": {
+ "a.txt": "hello world",
+ "b.txt": "hello there",
+ }
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+
+ let buffer_a = open_buffer(&project, path!("/root/dir/a.txt"), cx).await;
+ let buffer_b = open_buffer(&project, path!("/root/dir/b.txt"), cx).await;
+ let editor = add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer_a, Vec::new()), (&buffer_b, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
+
+ let buffer_b_id = buffer_b.read_with(cx, |buffer, _cx| buffer.remote_id());
+ select_in_buffer(&editor, buffer_b_id, cx);
+
+ fs.remove_file(Path::new(path!("/root/dir/a.txt")), Default::default())
+ .await
+ .unwrap();
+ flush_outline_tasks(cx);
+
+ let deleted_row = outline_panel.read_with(cx, |outline_panel, _cx| {
+ outline_panel
+ .cached_entries
+ .iter()
+ .find_map(|cached_entry| match &cached_entry.entry {
+ PanelEntry::Fs(FsEntry::File(file))
+ if file.entry.path.as_ref() == rel_path("dir/a.txt") =>
+ {
+ Some(cached_entry.entry.clone())
+ }
+ _ => None,
+ })
+ .expect("the deleted file should have a row")
+ });
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.select_entry(deleted_row, true, window, cx);
+ });
+ editor.update_in(cx, |editor, window, cx| {
+ assert!(
+ !editor.focus_handle(cx).is_focused(window),
+ "sanity check: selecting a row focuses the panel, not the editor"
+ );
+ });
+
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.open_selected_entry(&OpenSelectedEntry, window, cx);
+ });
+ cx.run_until_parked();
+
+ let buffer_a_id = buffer_a.read_with(cx, |buffer, _cx| buffer.remote_id());
+ editor.update_in(cx, |editor, window, cx| {
+ assert_eq!(
+ editor
+ .scroll_manager
+ .shared_scroll_anchor(cx)
+ .scroll_anchor
+ .anchor
+ .buffer_id(),
+ Some(buffer_a_id),
+ "opening the deleted file's row should scroll the editor to its excerpt"
+ );
+ assert!(editor.focus_handle(cx).is_focused(window));
+ });
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ dir/
+ ~~a.txt~~ <==== selected
+ b.txt"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_buffer_for_nonexistent_path_not_treated_as_deleted(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(path!("/root"), json!({ "existing.txt": "hello" }))
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+
+ let new_buffer = project
+ .update(cx, |project, cx| {
+ let path = project
+ .find_project_path(path!("/root/missing_dir/new.txt"), cx)
+ .expect("path inside the worktree should resolve");
+ project.open_buffer(path, cx)
+ })
+ .await
+ .unwrap();
+ new_buffer.read_with(cx, |buffer, _cx| {
+ assert_eq!(
+ buffer.file().map(|file| file.disk_state()),
+ Some(language::DiskState::New),
+ "sanity check: a buffer opened on a nonexistent path should be DiskState::New"
+ );
+ });
+ add_multi_buffer_editor(&workspace, &project, &[(&new_buffer, Vec::new())], cx);
+ flush_outline_tasks(cx);
+
+ assert_tree(&outline_panel, &project, "external: new.txt", cx);
+ }
+
+ #[gpui::test]
+ async fn test_deleted_file_ancestor_replaced_by_file(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "éx": "hello there",
+ "é": {
+ "a.rs": indoc!(
+ "
+ pub fn foo() {
+ let x = 1;
+ }
+ "
+ )
+ }
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(false);
+ });
+
+ let buffer_keep = open_buffer(&project, path!("/root/éx"), cx).await;
+ let buffer_a = open_buffer(&project, path!("/root/é/a.rs"), cx).await;
+ add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer_keep, Vec::new()), (&buffer_a, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
+
+ fs.remove_dir(
+ Path::new(path!("/root/é")),
+ project::RemoveOptions {
+ recursive: true,
+ ignore_if_not_exists: false,
+ },
+ )
+ .await
+ .unwrap();
+ fs.insert_file(path!("/root/é"), b"not a directory anymore".to_vec())
+ .await;
+ flush_outline_tasks(cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ é/
+ ~~a.rs~~
+ outline: pub fn foo <==== selected
+ éx"
+ ),
+ cx,
+ );
+
+ let buffer_replacement = open_buffer(&project, path!("/root/é"), cx).await;
+ let editor = add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[
+ (&buffer_keep, Vec::new()),
+ (&buffer_a, Vec::new()),
+ (&buffer_replacement, Vec::new()),
+ ],
+ cx,
+ );
+ flush_outline_tasks(cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ é
+ é/
+ ~~a.rs~~
+ outline: pub fn foo
+ éx"
+ ),
+ cx,
+ );
+
+ let worktree_id = buffer_a.read_with(cx, |buffer, cx| {
+ File::from_dyn(buffer.file())
+ .expect("buffer should have a file")
+ .worktree
+ .read(cx)
+ .id()
+ });
+ select_directory(&outline_panel, worktree_id, rel_path("é"), cx);
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ é
+ é/ <==== selected
+ éx"
+ ),
+ cx,
+ );
+
+ let buffer_a_id = buffer_a.read_with(cx, |buffer, _cx| buffer.remote_id());
+ select_in_buffer(&editor, buffer_a_id, cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ é
+ é/
+ ~~a.rs~~ <==== selected
+ éx"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_folded_directories_survive_ancestor_changes(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ "keep.txt": "hello there",
+ "a": {
+ "b": {
+ "c": {
+ "d": {
+ "gone.txt": "hello world"
+ }
+ }
+ }
+ }
+ }),
+ )
+ .await;
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(true);
+ });
+
+ let buffer_keep = open_buffer(&project, path!("/root/keep.txt"), cx).await;
+ let buffer_gone = open_buffer(&project, path!("/root/a/b/c/d/gone.txt"), cx).await;
+ add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer_keep, Vec::new()), (&buffer_gone, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ a/b/c/d/
+ gone.txt
+ keep.txt"
+ ),
+ cx,
+ );
+
+ fs.remove_dir(
+ Path::new(path!("/root/a/b/c")),
+ project::RemoveOptions {
+ recursive: true,
+ ignore_if_not_exists: false,
+ },
+ )
+ .await
+ .unwrap();
+ flush_outline_tasks(cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ a/b/c/d/
+ ~~gone.txt~~
+ keep.txt"
+ ),
+ cx,
+ );
+ fs.create_dir(Path::new(path!("/root/a/b/c/d")))
+ .await
+ .expect("ancestor recreation should succeed");
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ a/b/c/d/
+ ~~gone.txt~~
+ keep.txt"
+ ),
+ cx,
+ );
+
+ let deleted_file_row = outline_panel.read_with(cx, |outline_panel, _cx| {
+ outline_panel
+ .cached_entries
+ .iter()
+ .find_map(|cached_entry| match &cached_entry.entry {
+ PanelEntry::Fs(FsEntry::File(file))
+ if file.entry.path.as_ref() == rel_path("a/b/c/d/gone.txt") =>
+ {
+ Some(cached_entry.entry.clone())
+ }
+ _ => None,
+ })
+ .expect("the deleted file should have a row")
+ });
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.select_entry(deleted_file_row, true, window, cx);
+ });
+
+ for expected in [
+ indoc!(
+ "
+ root/
+ a/b/c/d/ <==== selected
+ ~~gone.txt~~
+ keep.txt"
+ ),
+ indoc!(
+ "
+ root/ <==== selected
+ a/b/c/d/
+ ~~gone.txt~~
+ keep.txt"
+ ),
+ ] {
+ outline_panel.update_in(cx, |outline_panel, window, cx| {
+ outline_panel.select_parent(&SelectParent, window, cx);
+ });
+ assert_tree(&outline_panel, &project, expected, cx);
+ }
+
+ let worktree_id = buffer_gone.read_with(cx, |buffer, cx| {
+ File::from_dyn(buffer.file())
+ .expect("buffer should have a file")
+ .worktree
+ .read(cx)
+ .id()
+ });
+ select_directory(&outline_panel, worktree_id, rel_path("a/b/c/d"), cx);
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ a/b/c/d/ <==== selected
+ keep.txt"
+ ),
+ cx,
+ );
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.expand_selected_entry(&ExpandSelectedEntry, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ a/b/c/d/ <==== selected
+ ~~gone.txt~~
+ keep.txt"
+ ),
+ cx,
+ );
+ for expected in [
+ indoc!(
+ "
+ root/
+ a/b/c/d/ <==== selected
+ keep.txt"
+ ),
+ indoc!(
+ "
+ root/
+ a/b/c/d/ <==== selected
+ ~~gone.txt~~
+ keep.txt"
+ ),
+ ] {
+ outline_panel.update_in(cx, |panel, window, cx| {
+ let entry = panel
+ .selected_entry()
+ .expect("folded directory should be selected")
+ .clone();
+ panel.toggle_expanded(&entry, window, cx);
+ });
+ flush_outline_tasks(cx);
+ assert_tree(&outline_panel, &project, expected, cx);
+ }
+ }
+
+ #[gpui::test]
+ async fn test_scan_excluded_modified_file_stays_external(cx: &mut TestAppContext) {
+ init_test(cx);
+ cx.update(|cx| {
+ SettingsStore::update_global(cx, |store, cx| {
+ store.update_user_settings(cx, |settings| {
+ settings.project.worktree.file_scan_exclusions =
+ Some(settings::SplicingVec::from(vec![
+ "**/excluded.txt".to_string(),
+ ]));
+ });
+ });
+ });
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ ".git": {},
+ "keep.txt": "hello there",
+ "excluded.txt": "new",
+ }),
+ )
+ .await;
+ let dot_git = Path::new(path!("/root/.git"));
+ fs.set_head_for_repo(
+ dot_git,
+ &[
+ ("keep.txt", "hello there".into()),
+ ("excluded.txt", "old".into()),
+ ],
+ "deadbeef",
+ );
+
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+
+ let buffer_keep = open_buffer(&project, path!("/root/keep.txt"), cx).await;
+ let buffer_excluded = open_buffer(&project, path!("/root/excluded.txt"), cx).await;
+ buffer_excluded.read_with(cx, |buffer, _cx| {
+ let file = File::from_dyn(buffer.file()).expect("excluded buffer should have a file");
+ assert_eq!(
+ file.project_entry_id(),
+ None,
+ "sanity check: a scan-excluded file has no worktree entry"
+ );
+ assert!(
+ matches!(file.disk_state, language::DiskState::Present { .. }),
+ "sanity check: a scan-excluded file is present on disk, got {:?}",
+ file.disk_state
+ );
+ });
+
+ add_diff_editor(
+ &workspace,
+ &project,
+ &[
+ (&buffer_keep, "previous contents\n"),
+ (&buffer_excluded, "old\n"),
+ ],
+ cx,
+ );
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ external: excluded.txt
+ root/
+ keep.txt"
+ ),
+ cx,
+ );
+ }
+
+ #[gpui::test]
+ async fn test_diff_deletions_group_under_scanned_and_excluded_parents(cx: &mut TestAppContext) {
+ init_test(cx);
+ cx.update(|cx| {
+ SettingsStore::update_global(cx, |store, cx| {
+ store.update_user_settings(cx, |settings| {
+ settings.project.worktree.file_scan_exclusions =
+ Some(settings::SplicingVec::from(vec![
+ "**/excluded".to_string(),
+ "**/missing".to_string(),
+ ]));
+ });
+ });
});
- outline_panel.update(cx, |outline_panel, cx| {
- assert_ne!(
- active_editor, new_active_editor,
- "After opening an excerpt, new editor should be open"
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ path!("/root"),
+ json!({
+ ".git": {},
+ "scanned": { "keep.txt": "still here" },
+ "excluded": { "keep.txt": "still here" }
+ }),
+ )
+ .await;
+ let dot_git = Path::new(path!("/root/.git"));
+ fs.set_branch_name(dot_git, Some("feature"));
+ fs.insert_branches(dot_git, &["main"]);
+ fs.set_head_for_repo(
+ dot_git,
+ &[
+ ("scanned/keep.txt", "still here".to_string()),
+ ("excluded/keep.txt", "still here".to_string()),
+ ],
+ "deadbeef",
+ );
+
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+ update_outline_panel_settings(cx, |settings| {
+ settings.auto_fold_dirs = Some(false);
+ });
+
+ let buffer_scanned = open_buffer(&project, path!("/root/scanned/gone.txt"), cx).await;
+ let buffer_excluded = open_buffer(&project, path!("/root/excluded/gone.txt"), cx).await;
+ let buffer_missing = open_buffer(&project, path!("/root/missing/gone.txt"), cx).await;
+ for buffer in [&buffer_scanned, &buffer_excluded, &buffer_missing] {
+ buffer.read_with(cx, |buffer, cx| {
+ let file = File::from_dyn(buffer.file()).expect("buffer should have a file");
+ assert_eq!(file.disk_state, DiskState::New);
+ assert_eq!(file.project_entry_id(), None);
+ assert_eq!(
+ project
+ .read(cx)
+ .git_store()
+ .read(cx)
+ .display_status_for_buffer_id(buffer.remote_id(), cx),
+ None,
+ );
+ });
+ }
+ buffer_excluded.read_with(cx, |buffer, cx| {
+ let file = File::from_dyn(buffer.file()).expect("buffer should have a file");
+ let worktree = file.worktree.read(cx);
+ assert_eq!(
+ worktree
+ .entry_for_path(rel_path("excluded"))
+ .map(|entry| entry.kind),
+ None
);
assert_eq!(
- display_entries(
- &project,
- &snapshot(outline_panel, cx),
- &outline_panel.cached_entries,
- outline_panel.selected_entry(),
- cx,
- ),
- "outline: pub(super) fn hints
-outline: fn hints_lifetimes_named <==== selected"
+ worktree
+ .entry_for_path(rel_path("missing"))
+ .map(|entry| entry.kind),
+ None
);
assert_eq!(
- selected_row_text(&new_active_editor, cx),
- clear_outline_metadata(next_navigated_outline_selection),
- "When opening the excerpt, should navigate to the place corresponding the outline entry"
+ worktree
+ .entry_for_path(rel_path("scanned"))
+ .map(|entry| entry.is_dir()),
+ Some(true),
);
});
+ assert_eq!(
+ fs.metadata(Path::new(path!("/root/excluded")))
+ .await
+ .expect("metadata should be readable")
+ .map(|metadata| metadata.is_dir),
+ Some(true),
+ );
+ assert_eq!(
+ fs.metadata(Path::new(path!("/root/missing")))
+ .await
+ .expect("metadata should be readable")
+ .map(|metadata| metadata.is_dir),
+ None,
+ );
+ add_diff_editor(
+ &workspace,
+ &project,
+ &[
+ (&buffer_scanned, "scanned base\n"),
+ (&buffer_excluded, "excluded base\n"),
+ (&buffer_missing, "missing base\n"),
+ ],
+ cx,
+ );
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ root/
+ excluded/
+ ~~gone.txt~~
+ missing/
+ ~~gone.txt~~
+ scanned/
+ ~~gone.txt~~"
+ ),
+ cx,
+ );
}
#[gpui::test]
- async fn test_multiple_worktrees(cx: &mut TestAppContext) {
+ async fn test_auto_reveal_ignores_external_file_on_nonexistent_path(cx: &mut TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.background_executor.clone());
fs.insert_tree(
path!("/root"),
json!({
- "one": {
- "a.txt": "aaa aaa"
- },
- "two": {
- "b.txt": "a aaa"
+ "dir": {
+ "real.rs": "pub fn real() {}\n",
}
-
}),
)
.await;
- let project = Project::test(fs.clone(), [Path::new(path!("/root/one"))], cx).await;
- let (window, workspace) = add_outline_panel(&project, cx).await;
- let cx = &mut VisualTestContext::from_window(window.into(), cx);
- let outline_panel = outline_panel(&workspace, cx);
- outline_panel.update_in(cx, |outline_panel, window, cx| {
- outline_panel.set_active(true, window, cx)
+ let project = Project::test(fs.clone(), [Path::new(path!("/root"))], cx).await;
+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));
+ let (workspace, outline_panel, mut cx) = active_outline_panel(&project, cx).await;
+ let cx = &mut cx;
+
+ let buffer_real = open_buffer(&project, path!("/root/dir/real.rs"), cx).await;
+ let buffer_new = open_buffer(&project, path!("/root/dir/never_existed.rs"), cx).await;
+ buffer_new.update(cx, |buffer, cx| {
+ buffer.edit(
+ [(
+ 0..0,
+ indoc!(
+ "
+ pub fn phantom() {
+ let x = 1;
+ }
+ "
+ ),
+ )],
+ None,
+ cx,
+ );
});
+ let editor = add_multi_buffer_editor(
+ &workspace,
+ &project,
+ &[(&buffer_real, Vec::new()), (&buffer_new, Vec::new())],
+ cx,
+ );
+ flush_outline_tasks(cx);
- let items = workspace
- .update_in(cx, |workspace, window, cx| {
- workspace.open_paths(
- vec![PathBuf::from(path!("/root/two"))],
- OpenOptions {
- visible: Some(OpenVisible::OnlyDirectories),
- ..Default::default()
- },
- None,
- window,
- cx,
- )
- })
- .await;
- assert_eq!(items.len(), 1, "Were opening another worktree directory");
- assert!(
- items[0].is_none(),
- "Directory should be opened successfully"
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ external: never_existed.rs
+ outline: pub fn phantom <==== selected
+ root/
+ dir/
+ real.rs
+ outline: pub fn real"
+ ),
+ cx,
);
- workspace.update_in(cx, |workspace, window, cx| {
- ProjectSearchView::deploy_search(
- workspace,
- &workspace::DeploySearch::default(),
- window,
- cx,
- )
- });
- let search_view = workspace.update_in(cx, |workspace, _window, cx| {
- workspace
- .active_pane()
+ let worktree_id = buffer_real.read_with(cx, |buffer, cx| {
+ File::from_dyn(buffer.file())
+ .expect("buffer should have a file")
+ .worktree
.read(cx)
- .items()
- .find_map(|item| item.downcast::<ProjectSearchView>())
- .expect("Project search view expected to appear after new search event trigger")
- });
-
- let query = "aaa";
- perform_project_search(&search_view, query, cx);
- search_view.update(cx, |search_view, cx| {
- search_view
- .results_editor()
- .update(cx, |results_editor, cx| {
- assert_eq!(
- results_editor.display_text(cx).match_indices(query).count(),
- 3
- );
- });
- });
-
- cx.executor()
- .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
- cx.run_until_parked();
- outline_panel.update(cx, |outline_panel, cx| {
- assert_eq!(
- display_entries(
- &project,
- &snapshot(outline_panel, cx),
- &outline_panel.cached_entries,
- outline_panel.selected_entry(),
- cx,
- ),
- r#"one/
- a.txt
- search: «aaa» aaa <==== selected
- search: aaa «aaa»
-two/
- b.txt
- search: a «aaa»"#
- .to_string(),
- );
+ .id()
});
-
+ select_directory(&outline_panel, worktree_id, rel_path("dir"), cx);
outline_panel.update_in(cx, |outline_panel, window, cx| {
- outline_panel.select_previous(&SelectPrevious, window, cx);
outline_panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
});
- cx.executor()
- .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
- cx.run_until_parked();
- outline_panel.update(cx, |outline_panel, cx| {
- assert_eq!(
- display_entries(
- &project,
- &snapshot(outline_panel, cx),
- &outline_panel.cached_entries,
- outline_panel.selected_entry(),
- cx,
- ),
- r#"one/
- a.txt <==== selected
-two/
- b.txt
- search: a «aaa»"#
- .to_string(),
- );
- });
+ flush_outline_tasks(cx);
- outline_panel.update_in(cx, |outline_panel, window, cx| {
- outline_panel.select_next(&SelectNext, window, cx);
- outline_panel.collapse_selected_entry(&CollapseSelectedEntry, window, cx);
- });
- cx.executor()
- .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
- cx.run_until_parked();
- outline_panel.update(cx, |outline_panel, cx| {
- assert_eq!(
- display_entries(
- &project,
- &snapshot(outline_panel, cx),
- &outline_panel.cached_entries,
- outline_panel.selected_entry(),
- cx,
- ),
- r#"one/
- a.txt
-two/ <==== selected"#
- .to_string(),
- );
- });
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ external: never_existed.rs
+ outline: pub fn phantom
+ root/
+ dir/ <==== selected"
+ ),
+ cx,
+ );
- outline_panel.update_in(cx, |outline_panel, window, cx| {
- outline_panel.expand_selected_entry(&ExpandSelectedEntry, window, cx);
- });
- cx.executor()
- .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
- cx.run_until_parked();
- outline_panel.update(cx, |outline_panel, cx| {
- assert_eq!(
- display_entries(
- &project,
- &snapshot(outline_panel, cx),
- &outline_panel.cached_entries,
- outline_panel.selected_entry(),
- cx,
- ),
- r#"one/
- a.txt
-two/ <==== selected
- b.txt
- search: a «aaa»"#
- .to_string()
- );
- });
+ let buffer_new_id = buffer_new.read_with(cx, |buffer, _cx| buffer.remote_id());
+ select_in_buffer(&editor, buffer_new_id, cx);
+
+ assert_tree(
+ &outline_panel,
+ &project,
+ indoc!(
+ "
+ external: never_existed.rs
+ outline: pub fn phantom <==== selected
+ root/
+ dir/"
+ ),
+ cx,
+ );
}
#[gpui::test]
@@ -7002,11 +9693,44 @@ outline: struct OutlineEntryExcerpt
) -> Entity<language::Buffer> {
project
.update(cx, |project, cx| {
- let path = project.find_project_path(abs_path, cx).unwrap();
- project.open_buffer(path, cx)
+ let path = project.find_project_path(abs_path, cx).unwrap();
+ project.open_buffer(path, cx)
+ })
+ .await
+ .unwrap()
+ }
+
+ async fn rename_buffer(
+ project: &Entity<Project>,
+ buffer: &Entity<language::Buffer>,
+ path: &RelPath,
+ cx: &mut VisualTestContext,
+ ) {
+ let (entry_id, worktree_id) = buffer.read_with(cx, |buffer, cx| {
+ let file = File::from_dyn(buffer.file()).expect("buffer should have a file");
+ (
+ file.project_entry_id()
+ .expect("file should have a worktree entry"),
+ file.worktree.read(cx).id(),
+ )
+ });
+ project
+ .update(cx, |project, cx| {
+ project.rename_entry(
+ entry_id,
+ ProjectPath {
+ worktree_id,
+ path: Arc::from(path),
+ },
+ cx,
+ )
})
.await
- .unwrap()
+ .expect("file rename should succeed");
+ cx.run_until_parked();
+ project
+ .update(cx, |project, cx| project.git_scans_complete(cx))
+ .await;
}
fn add_multi_buffer_editor(
@@ -7038,17 +9762,87 @@ outline: struct OutlineEntryExcerpt
})
}
- fn settle_outline_panel(outline_panel: &Entity<OutlinePanel>, cx: &mut VisualTestContext) {
- cx.executor()
- .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));
- cx.run_until_parked();
- outline_panel.update_in(cx, |panel, window, cx| {
- panel.update_non_fs_items(window, cx);
- panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx);
+ fn set_buffer_order(
+ editor: &Entity<Editor>,
+ buffers: &[&Entity<language::Buffer>],
+ cx: &mut VisualTestContext,
+ ) {
+ editor.update_in(cx, |editor, window, cx| {
+ editor.buffer().update(cx, |multibuffer, cx| {
+ for (index, buffer) in buffers.iter().enumerate() {
+ let mut path = PathKey::for_buffer(buffer, cx);
+ path.sort_prefix = Some(index as u64);
+ let range = language::Point::default()..buffer.read(cx).max_point();
+ multibuffer.set_excerpts_for_path(path, (*buffer).clone(), [range], 0, cx);
+ }
+ assert_eq!(
+ multibuffer
+ .snapshot(cx)
+ .excerpts()
+ .map(|excerpt| excerpt.context.start.buffer_id)
+ .collect::<Vec<_>>(),
+ buffers
+ .iter()
+ .map(|buffer| buffer.read(cx).remote_id())
+ .collect::<Vec<_>>(),
+ );
+ });
+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {
+ selections.select_ranges([language::Point::default()..language::Point::default()]);
+ });
});
- cx.executor()
- .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));
+ flush_outline_tasks(cx);
+ }
+
+ fn select_in_buffer(editor: &Entity<Editor>, buffer_id: BufferId, cx: &mut VisualTestContext) {
+ let anchor = editor.read_with(cx, |editor, cx| {
+ let snapshot = editor.buffer().read(cx).snapshot(cx);
+ let excerpt = snapshot
+ .excerpts_for_buffer(buffer_id)
+ .next()
+ .expect("buffer should have an excerpt in the multi-buffer");
+ snapshot
+ .anchor_in_excerpt(excerpt.context.start)
+ .expect("the excerpt's start should resolve")
+ });
+ cx.update(|window, cx| {
+ window.focus(&editor.focus_handle(cx), cx);
+ editor.update(cx, |editor, cx| {
+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {
+ selections.select_ranges(Some(anchor..anchor))
+ });
+ });
+ });
+ flush_outline_tasks(cx);
+ }
+
+ async fn wait_for_outline_tasks(
+ outline_panel: &Entity<OutlinePanel>,
+ cx: &mut VisualTestContext,
+ ) {
cx.run_until_parked();
+ poll_fn(|task_context| {
+ outline_panel.update(cx, |panel, _| {
+ for task in [
+ &mut panel.fs_entries_update_task,
+ &mut panel.lsp_outline_refresh_task,
+ &mut panel.cached_entries_update_task,
+ ]
+ .into_iter()
+ .chain(panel.outline_fetch_tasks.values_mut())
+ {
+ if !task.is_ready() {
+ futures::ready!(task.poll_unpin(task_context));
+ }
+ }
+ if !panel.reveal_selection_task.is_ready() {
+ futures::ready!(panel.reveal_selection_task.poll_unpin(task_context))
+ .expect("selection reveal should complete");
+ }
+ Poll::Ready(())
+ })
+ })
+ .await;
}
fn update_outline_panel_settings(
@@ -7064,6 +9858,34 @@ outline: struct OutlineEntryExcerpt
});
}
+ fn assert_tree(
+ outline_panel: &Entity<OutlinePanel>,
+ project: &Entity<Project>,
+ expected: &str,
+ cx: &mut VisualTestContext,
+ ) {
+ outline_panel.update(cx, |outline_panel, cx| {
+ assert_eq!(
+ display_entries(
+ project,
+ &snapshot(outline_panel, cx),
+ &outline_panel.cached_entries,
+ outline_panel.selected_entry(),
+ cx,
+ ),
+ expected
+ );
+ });
+ }
+
+ fn mark_deleted(name: String, is_deleted: bool) -> String {
+ if is_deleted {
+ format!("~~{name}~~")
+ } else {
+ name
+ }
+ }
+
fn display_entries(
project: &Entity<Project>,
multi_buffer_snapshot: &MultiBufferSnapshot,
@@ -7085,15 +9907,19 @@ outline: struct OutlineEntryExcerpt
}
display_string += &match &entry.entry {
PanelEntry::Fs(entry) => match entry {
- FsEntry::ExternalFile(_) => {
- panic!("Did not cover external files with tests")
+ FsEntry::ExternalFile(external_file) => {
+ let name = multi_buffer_snapshot
+ .buffer_for_id(external_file.buffer_id)
+ .and_then(|buffer| buffer.file())
+ .map(|file| file.file_name(cx).to_string())
+ .unwrap_or_else(|| "untitled".to_string());
+ format!("external: {name}")
}
FsEntry::Directory(directory) => {
let path = if let Some(worktree) = project
.worktree_for_id(directory.worktree_id, cx)
- .filter(|worktree| {
- worktree.read(cx).root_entry() == Some(&directory.entry.entry)
- }) {
+ .filter(|_| directory.entry.path.is_empty())
+ {
worktree
.read(cx)
.root_name()
@@ -7110,12 +9936,14 @@ outline: struct OutlineEntryExcerpt
};
format!("{path}/")
}
- FsEntry::File(file) => file
- .entry
- .path
- .file_name()
- .map(|name| name.to_string())
- .unwrap_or_default(),
+ FsEntry::File(file) => mark_deleted(
+ file.entry
+ .path
+ .file_name()
+ .map(|name| name.to_string())
+ .unwrap_or_default(),
+ file.is_deleted,
+ ),
},
PanelEntry::FoldedDirs(folded_dirs) => folded_dirs
.entries
@@ -7385,6 +10213,174 @@ outline: struct OutlineEntryExcerpt
})
}
+ async fn active_outline_panel(
+ project: &Entity<Project>,
+ cx: &mut TestAppContext,
+ ) -> (Entity<Workspace>, Entity<OutlinePanel>, VisualTestContext) {
+ let (window, workspace) = add_outline_panel(project, cx).await;
+ let mut cx = VisualTestContext::from_window(window.into(), cx);
+ let panel = outline_panel(&workspace, &mut cx);
+ panel.update_in(&mut cx, |panel, window, cx| {
+ panel.set_active(true, window, cx);
+ });
+ (workspace, panel, cx)
+ }
+
+ fn add_diff_editor(
+ workspace: &Entity<Workspace>,
+ project: &Entity<Project>,
+ entries: &[(&Entity<language::Buffer>, &str)],
+ cx: &mut VisualTestContext,
+ ) -> Entity<Editor> {
+ let (editor, diffs) = workspace.update_in(cx, |workspace, window, cx| {
+ let mut diffs = Vec::new();
+ let multibuffer = cx.new(|cx| {
+ let mut multibuffer = editor::MultiBuffer::new(language::Capability::ReadWrite);
+ for (buffer, base_text) in entries {
+ let diff = cx.new(|cx| {
+ BufferDiff::new_with_base_text(
+ base_text,
+ &buffer.read(cx).text_snapshot(),
+ cx,
+ )
+ });
+ let buffer_snapshot = buffer.read(cx).snapshot();
+ let ranges = diff
+ .read(cx)
+ .snapshot(cx)
+ .hunks(&buffer_snapshot)
+ .map(|hunk| hunk.buffer_range.to_point(&buffer_snapshot))
+ .collect::<Vec<_>>();
+ assert!(
+ !ranges.is_empty(),
+ "diff fixture must have at least one hunk"
+ );
+ multibuffer.set_excerpts_for_buffer((*buffer).clone(), ranges, 0, cx);
+ multibuffer.add_diff(diff.clone(), cx);
+ diffs.push(diff);
+ }
+ multibuffer
+ });
+ let editor = cx.new(|cx| {
+ let mut editor =
+ Editor::for_multibuffer(multibuffer, Some(project.clone()), window, cx);
+ editor.set_diff_hunk_renderer(Some(Arc::new(HiddenUnstagedDiffHunkRenderer)), cx);
+ editor.set_expand_all_diff_hunks(cx);
+ editor
+ });
+ workspace.add_item_to_active_pane(Box::new(editor.clone()), None, true, window, cx);
+ (editor, diffs)
+ });
+ flush_outline_tasks(cx);
+ editor.read_with(cx, |editor, cx| {
+ let multibuffer = editor.buffer().read(cx);
+ let snapshot = multibuffer.snapshot(cx);
+ for ((buffer, base_text), diff) in entries.iter().zip(&diffs) {
+ let buffer_id = buffer.read(cx).remote_id();
+ assert_eq!(
+ multibuffer.diff_for(buffer_id).map(|diff| diff.entity_id()),
+ Some(diff.entity_id()),
+ );
+ let diff = snapshot
+ .diff_for_buffer_id(buffer_id)
+ .expect("fixture diff should remain attached");
+ assert!(diff.base_text_exists());
+ assert_eq!(diff.base_text().text(), *base_text);
+ }
+ });
+ editor
+ }
+
+ fn flush_outline_tasks(cx: &mut VisualTestContext) {
+ cx.run_until_parked();
+ cx.executor().advance_clock(UPDATE_DEBOUNCE * 3);
+ cx.run_until_parked();
+ }
+
+ fn select_directory(
+ panel: &Entity<OutlinePanel>,
+ worktree_id: WorktreeId,
+ path: &RelPath,
+ cx: &mut VisualTestContext,
+ ) {
+ panel.update_in(cx, |panel, window, cx| {
+ let mut entries = panel
+ .cached_entries
+ .iter()
+ .filter(|cached| match &cached.entry {
+ PanelEntry::Fs(FsEntry::Directory(directory)) => {
+ directory.worktree_id == worktree_id
+ && directory.entry.path.as_ref() == path
+ }
+ PanelEntry::FoldedDirs(directories) => {
+ directories.worktree_id == worktree_id
+ && directories
+ .entries
+ .last()
+ .is_some_and(|entry| entry.path.as_ref() == path)
+ }
+ _ => false,
+ });
+ let entry = entries
+ .next()
+ .expect("directory should have a row")
+ .entry
+ .clone();
+ assert!(
+ entries.next().is_none(),
+ "directory should have exactly one row"
+ );
+ panel.select_entry(entry, true, window, cx);
+ });
+ }
+
+ fn select_file(panel: &Entity<OutlinePanel>, buffer_id: BufferId, cx: &mut VisualTestContext) {
+ panel.update_in(cx, |panel, window, cx| {
+ let mut entries = panel.cached_entries.iter().filter(|cached| {
+ matches!(&cached.entry, PanelEntry::Fs(FsEntry::File(file)) if file.buffer_id == buffer_id)
+ });
+ let entry = entries.next().expect("file should have a row").entry.clone();
+ assert_eq!(entries.count(), 0, "file should have exactly one row");
+ panel.select_entry(entry, true, window, cx);
+ });
+ }
+
+ fn assert_directory_paths(
+ panel: &Entity<OutlinePanel>,
+ worktree_id: WorktreeId,
+ expected_unfolded: &[&str],
+ expected_collapsed: &[&str],
+ cx: &mut VisualTestContext,
+ ) {
+ panel.read_with(cx, |panel, _| {
+ assert_eq!(
+ panel.unfolded_dirs,
+ HashMap::from_iter([(
+ worktree_id,
+ expected_unfolded
+ .iter()
+ .map(|path| Arc::<RelPath>::from(rel_path(path)))
+ .collect::<BTreeSet<_>>(),
+ )]),
+ );
+ assert_eq!(
+ panel
+ .collapsed_entries
+ .iter()
+ .filter_map(|entry| match entry {
+ CollapsedEntry::Dir(worktree_id, path) =>
+ Some((*worktree_id, path.clone())),
+ _ => None,
+ })
+ .collect::<HashSet<_>>(),
+ expected_collapsed
+ .iter()
+ .map(|path| (worktree_id, Arc::<RelPath>::from(rel_path(path))))
+ .collect::<HashSet<_>>(),
+ );
+ });
+ }
+
#[gpui::test]
async fn test_outline_keyboard_expand_collapse(cx: &mut TestAppContext) {
init_test(cx);
@@ -8139,6 +11135,52 @@ search: | Field | Meaning « » |
search: | Field | Meaning « »|"
);
});
+
+ let entries_capacity = outline_panel.update_in(cx, |panel, window, cx| {
+ panel
+ .cached_entries
+ .reserve(panel.cached_entries.capacity() + 1);
+ let entry = panel
+ .cached_entries
+ .get(1)
+ .expect("second search result")
+ .entry
+ .clone();
+ panel.toggle_expanded(&entry, window, cx);
+ panel.scroll_editor_to_entry(&entry, true, false, window, cx);
+ panel.cached_entries.capacity()
+ });
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ outline_panel.read_with(cx, |panel, _| {
+ assert_eq!(panel.cached_entries.capacity(), entries_capacity);
+ assert_eq!(
+ panel.selected_entry(),
+ panel.cached_entries.get(1).map(|cached| &cached.entry)
+ );
+ });
+
+ search_bar
+ .update_in(cx, |search_bar, window, cx| {
+ search_bar.search("Field", None, true, window, cx)
+ })
+ .await
+ .expect("search should complete");
+ outline_panel.update_in(cx, |panel, window, cx| {
+ panel.update_cached_entries(None, window, cx);
+ });
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ outline_panel.update(cx, |panel, cx| {
+ assert_eq!(
+ display_entries(
+ &project,
+ &snapshot(panel, cx),
+ &panel.cached_entries,
+ panel.selected_entry(),
+ cx
+ ),
+ "search: | «Field» | Meaning | <==== selected"
+ );
+ });
}
#[gpui::test]
@@ -8151,7 +11193,14 @@ search: | Field | Meaning « »|"
root,
json!({
"src": {
- "lib.rs": "struct Foo {\n bar: u32,\n baz: String,\n}\n",
+ "lib.rs": indoc!(
+ "
+ struct Foo {
+ bar: u32,
+ baz: String,
+ }
+ "
+ ),
}
}),
)
@@ -8242,7 +11291,7 @@ search: | Field | Meaning « »|"
});
});
- let _editor = workspace
+ let editor = workspace
.update_in(cx, |workspace, window, cx| {
workspace.open_abs_path(
PathBuf::from(path!("/root/src/lib.rs")),
@@ -8295,9 +11344,7 @@ outline: struct Foo <==== selected
},
);
});
- cx.executor()
- .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
- cx.run_until_parked();
+ wait_for_outline_tasks(&outline_panel, cx).await;
outline_panel.update(cx, |outline_panel, cx| {
assert_eq!(
@@ -8318,6 +11365,67 @@ outline: struct Foo <==== selected
);
});
+ for _ in 0..2 {
+ outline_panel.update(cx, |panel, _| panel.outline_fetch_tasks.clear());
+ editor.update(cx, |_, cx| cx.emit(EditorEvent::OutlineSymbolsChanged));
+ cx.run_until_parked();
+ cx.executor()
+ .advance_clock(UPDATE_DEBOUNCE - Duration::from_millis(1));
+ editor.update(cx, |_, cx| {
+ for _ in 0..8 {
+ cx.emit(EditorEvent::OutlineSymbolsChanged);
+ }
+ });
+ cx.run_until_parked();
+ outline_panel.read_with(cx, |panel, _| {
+ assert!(panel.outline_fetch_tasks.is_empty());
+ assert!(
+ panel
+ .buffers
+ .values()
+ .all(|buffer| { matches!(buffer.outlines, OutlineState::Outlines(_)) })
+ );
+ });
+ cx.executor().advance_clock(Duration::from_millis(1));
+ cx.run_until_parked();
+ outline_panel.read_with(cx, |panel, _| {
+ assert_eq!(panel.outline_fetch_tasks.len(), 1);
+ assert!(panel.outline_fetch_tasks.values().all(Task::is_ready));
+ assert!(
+ panel
+ .buffers
+ .values()
+ .all(|buffer| { matches!(buffer.outlines, OutlineState::Outlines(_)) })
+ );
+ });
+ }
+
+ let entries_capacity = outline_panel.update(cx, |panel, _| {
+ panel
+ .cached_entries
+ .reserve(panel.cached_entries.capacity() + 1);
+ panel.cached_entries.capacity()
+ });
+ for (row, expected_symbol) in [(1, "bar"), (2, "lsp_only_field"), (0, "struct Foo")] {
+ editor.update_in(cx, |editor, window, cx| {
+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {
+ let point = language::Point::new(row, 4);
+ selections.select_ranges([point..point]);
+ });
+ });
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ outline_panel.read_with(cx, |panel, _| {
+ assert_eq!(panel.cached_entries.capacity(), entries_capacity);
+ let selected_symbol = panel.selected_entry().and_then(|entry| match entry {
+ PanelEntry::Outline(OutlineEntry::Outline(outline)) => {
+ Some(outline.text.as_ref())
+ }
+ _ => None,
+ });
+ assert_eq!(selected_symbol, Some(expected_symbol));
+ });
+ }
+
// Step 3: Switch back to tree-sitter
cx.update(|_, cx| {
settings::SettingsStore::update_global(
@@ -8330,9 +11438,7 @@ outline: struct Foo <==== selected
},
);
});
- cx.executor()
- .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));
- cx.run_until_parked();
+ wait_for_outline_tasks(&outline_panel, cx).await;
outline_panel.update(cx, |outline_panel, cx| {
assert_eq!(
@@ -8352,6 +11458,14 @@ outline: struct Foo <==== selected
"Step 3: tree-sitter outlines should be restored"
);
});
+
+ editor.update(cx, |_, cx| cx.emit(EditorEvent::OutlineSymbolsChanged));
+ cx.run_until_parked();
+ outline_panel.update_in(cx, |panel, window, cx| {
+ assert!(!panel.lsp_outline_refresh_task.is_ready());
+ panel.clear_previous(window, cx);
+ assert!(panel.lsp_outline_refresh_task.is_ready());
+ });
}
#[gpui::test]
@@ -8402,17 +11516,19 @@ outline: struct Foo <==== selected
.downcast::<Editor>()
.unwrap();
- cx.run_until_parked();
+ wait_for_outline_tasks(&outline_panel, cx).await;
- outline_panel.update_in(cx, |panel, window, cx| {
- panel.update_non_fs_items(window, cx);
- panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx);
+ let entries_capacity = outline_panel.update(cx, |panel, _| {
+ panel
+ .cached_entries
+ .reserve(panel.cached_entries.capacity() + 1);
+ panel.cached_entries.capacity()
});
// Helper function to move the cursor to the first column of a given row
// and return the selected outline entry's text.
let move_cursor_and_get_selection =
- |row: u32, cx: &mut VisualTestContext| -> Option<SharedString> {
+ async |row: u32, cx: &mut VisualTestContext| -> Option<SharedString> {
cx.update(|window, cx| {
editor.update(cx, |editor, cx| {
editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
@@ -8423,9 +11539,10 @@ outline: struct Foo <==== selected
});
});
- cx.run_until_parked();
+ wait_for_outline_tasks(&outline_panel, cx).await;
outline_panel.read_with(cx, |panel, _cx| {
+ assert_eq!(panel.cached_entries.capacity(), entries_capacity);
panel.selected_entry().and_then(|entry| match entry {
PanelEntry::Outline(OutlineEntry::Outline(outline)) => {
Some(outline.text.clone())
@@ -8436,28 +11553,48 @@ outline: struct Foo <==== selected
};
assert_eq!(
- move_cursor_and_get_selection(0, cx).as_deref(),
+ move_cursor_and_get_selection(0, cx).await.as_deref(),
Some("# Section A"),
"Cursor at row 0 should select '# Section A'"
);
assert_eq!(
- move_cursor_and_get_selection(2, cx).as_deref(),
+ move_cursor_and_get_selection(2, cx).await.as_deref(),
Some("## Sub Section A"),
"Cursor at row 2 should select '## Sub Section A'"
);
assert_eq!(
- move_cursor_and_get_selection(4, cx).as_deref(),
+ move_cursor_and_get_selection(4, cx).await.as_deref(),
Some("## Sub Section B"),
"Cursor at row 4 should select '## Sub Section B'"
);
assert_eq!(
- move_cursor_and_get_selection(6, cx).as_deref(),
+ move_cursor_and_get_selection(6, cx).await.as_deref(),
Some("# Section B"),
"Cursor at row 6 should select '# Section B'"
);
+
+ cx.update(|_, cx| {
+ SettingsStore::update_global(cx, |store, cx| {
+ store.update_user_settings(cx, |settings| {
+ settings
+ .outline_panel
+ .get_or_insert_default()
+ .auto_reveal_entries = Some(false);
+ });
+ });
+ });
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ let mut notifications = cx.notifications(&outline_panel);
+ editor.update_in(cx, |editor, window, cx| {
+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selections| {
+ selections.select_ranges([language::Point::new(0, 0)..language::Point::new(0, 0)]);
+ });
+ });
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ assert_eq!(notifications.next().now_or_never(), None);
}
#[gpui::test]
@@ -8501,7 +11638,7 @@ outline: struct Foo <==== selected
&[(&buffer_one, Vec::new()), (&buffer_two, Vec::new())],
cx,
);
- settle_outline_panel(&outline_panel, cx);
+ wait_for_outline_tasks(&outline_panel, cx).await;
outline_panel.update(cx, |panel, _cx| {
assert!(
@@ -9041,7 +12178,7 @@ rust-analyzer/
],
cx,
);
- settle_outline_panel(&outline_panel, cx);
+ wait_for_outline_tasks(&outline_panel, cx).await;
outline_panel.update(cx, |outline_panel, cx| {
assert_eq!(
@@ -9071,6 +12208,87 @@ test/
and without outlines that lie outside every excerpt"
);
});
+
+ let count = 256_u32;
+ let text = (0..count)
+ .map(|index| format!("fn needle_{index:04}() {{}}\n\n\n\n\n\n\n\n"))
+ .collect::<String>();
+ buffer_one.update(cx, |buffer, cx| {
+ buffer.edit([(0..buffer.len(), text)], None, cx);
+ });
+ let excerpts = (0..count)
+ .step_by(2)
+ .map(|index| language::Point::new(index * 8, 0)..language::Point::new(index * 8 + 1, 0))
+ .collect::<Vec<_>>();
+ let editor = add_multi_buffer_editor(&workspace, &project, &[(&buffer_one, excerpts)], cx);
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ outline_panel.read_with(cx, |panel, _| {
+ assert_eq!(
+ panel
+ .cached_entries
+ .iter()
+ .filter_map(|cached| match &cached.entry {
+ PanelEntry::Outline(OutlineEntry::Outline(outline)) =>
+ Some(outline.text.to_string()),
+ _ => None,
+ })
+ .collect::<Vec<_>>(),
+ (0..count)
+ .step_by(2)
+ .map(|index| format!("fn needle_{index:04}"))
+ .collect::<Vec<_>>(),
+ );
+ });
+ let search_bar = cx.update(|window, cx| {
+ cx.new(|cx| {
+ let mut search_bar = BufferSearchBar::new(None, window, cx);
+ search_bar.set_active_pane_item(Some(&editor), window, cx);
+ search_bar.show(window, cx);
+ search_bar
+ })
+ });
+ for dense in [false, true] {
+ if dense {
+ editor.update(cx, |editor, cx| {
+ editor.buffer().update(cx, |multibuffer, cx| {
+ multibuffer.set_excerpts_for_buffer(
+ buffer_one.clone(),
+ [language::Point::default()..buffer_one.read(cx).max_point()],
+ 0,
+ cx,
+ );
+ });
+ });
+ }
+ search_bar
+ .update_in(cx, |search_bar, window, cx| {
+ search_bar.search("needle", None, true, window, cx)
+ })
+ .await
+ .unwrap();
+ wait_for_outline_tasks(&outline_panel, cx).await;
+ outline_panel.update(cx, |panel, cx| {
+ let snapshot = snapshot(panel, cx);
+ assert_eq!(
+ snapshot.excerpts().count(),
+ if dense { 1 } else { count as usize / 2 }
+ );
+ let mut expected = indoc!(
+ "
+ test/
+ src/
+ one.rs"
+ )
+ .to_string();
+ for index in (0..count).step_by(if dense { 1 } else { 2 }) {
+ expected.push_str(&format!("\n search: fn «needle»_{index:04}() {{}}"));
+ }
+ assert_eq!(
+ display_entries(&project, &snapshot, &panel.cached_entries, None, cx),
+ expected
+ );
+ });
+ }
}
#[gpui::test]
@@ -9114,7 +12332,7 @@ test/
&[(&buffer_one, Vec::new()), (&buffer_two, Vec::new())],
cx,
);
- settle_outline_panel(&outline_panel, cx);
+ wait_for_outline_tasks(&outline_panel, cx).await;
outline_panel.update(cx, |panel, _cx| {
assert!(
@@ -9236,7 +12454,7 @@ test/
&[(&buffer_one, Vec::new()), (&buffer_two, Vec::new())],
cx,
);
- settle_outline_panel(&outline_panel, cx);
+ wait_for_outline_tasks(&outline_panel, cx).await;
outline_panel.update_in(cx, |panel, window, cx| {
panel.filter_editor.update(cx, |filter_editor, cx| {
@@ -9372,7 +12590,7 @@ test/
&[(&buffer_one, Vec::new()), (&buffer_two, Vec::new())],
cx,
);
- settle_outline_panel(&outline_panel, cx);
+ wait_for_outline_tasks(&outline_panel, cx).await;
outline_panel.update(cx, |panel, cx| {
assert_eq!(
@@ -9458,7 +12676,7 @@ test/
&[(&buffer_one, Vec::new()), (&buffer_two, Vec::new())],
cx,
);
- settle_outline_panel(&outline_panel, cx);
+ wait_for_outline_tasks(&outline_panel, cx).await;
outline_panel.update(cx, |panel, _cx| {
assert!(
@@ -9474,7 +12692,7 @@ test/
settings.multi_buffer_hide_symbols = Some(false);
settings.expand_outlines_with_depth = Some(0);
});
- settle_outline_panel(&outline_panel, cx);
+ wait_for_outline_tasks(&outline_panel, cx).await;
outline_panel.update(cx, |panel, cx| {
assert_eq!(
diff --git a/docs/src/outline-panel.md b/docs/src/outline-panel.md
index aa4c193a5eb..f6c3dc59b25 100644
--- a/docs/src/outline-panel.md
+++ b/docs/src/outline-panel.md
@@ -13,6 +13,12 @@ When viewing a "singleton" buffer (i.e., a single file on a tab), the outline pa
## Usage with multibuffers
+File rows follow the order of the files in the multibuffer.
+If files from a folder appear in separate parts of the multibuffer, the outline panel repeats that folder's path group to preserve their order.
+
+When a multibuffer includes deleted project files, they remain grouped under their original paths with struck-through file names.
+Folder rows group files by path and are not struck through, even when the folders no longer exist on disk.
+
The outline panel truly excels when used with multi-buffers. Here are some examples of its versatility:
### Project Search Results