1use crate::mouse::MouseResult;
22use crate::stateful::Stateful;
23use crate::undo_support::{TreeUndoExt, UndoSupport, UndoWidgetId};
24use crate::{Widget, clear_text_area, draw_text_span};
25use ftui_core::event::{KeyCode, KeyEvent, KeyEventKind, MouseButton, MouseEvent, MouseEventKind};
26use ftui_core::geometry::Rect;
27use ftui_render::frame::{Frame, HitId, HitRegion};
28use ftui_style::Style;
29use std::any::Any;
30use std::collections::HashSet;
31#[cfg(feature = "tracing")]
32use web_time::Instant;
33
34#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
36pub enum TreeGuides {
37 Ascii,
39 #[default]
41 Unicode,
42 Bold,
44 Double,
46 Rounded,
48}
49
50impl TreeGuides {
51 #[must_use]
53 pub const fn vertical(&self) -> &str {
54 match self {
55 Self::Ascii => "| ",
56 Self::Unicode | Self::Rounded => "\u{2502} ",
57 Self::Bold => "\u{2503} ",
58 Self::Double => "\u{2551} ",
59 }
60 }
61
62 #[must_use]
64 pub const fn branch(&self) -> &str {
65 match self {
66 Self::Ascii => "+-- ",
67 Self::Unicode => "\u{251C}\u{2500}\u{2500} ",
68 Self::Bold => "\u{2523}\u{2501}\u{2501} ",
69 Self::Double => "\u{2560}\u{2550}\u{2550} ",
70 Self::Rounded => "\u{251C}\u{2500}\u{2500} ",
71 }
72 }
73
74 #[must_use]
76 pub const fn last(&self) -> &str {
77 match self {
78 Self::Ascii => "`-- ",
79 Self::Unicode => "\u{2514}\u{2500}\u{2500} ",
80 Self::Bold => "\u{2517}\u{2501}\u{2501} ",
81 Self::Double => "\u{255A}\u{2550}\u{2550} ",
82 Self::Rounded => "\u{2570}\u{2500}\u{2500} ",
83 }
84 }
85
86 #[must_use]
88 pub const fn space(&self) -> &str {
89 " "
90 }
91
92 #[inline]
94 #[must_use]
95 pub fn width(&self) -> usize {
96 4
97 }
98}
99
100#[derive(Debug, Clone)]
102pub struct TreeNode {
103 label: String,
104 icon: Option<String>,
105 pub(crate) children: Vec<TreeNode>,
107 lazy_children: Option<Vec<TreeNode>>,
109 pub(crate) expanded: bool,
111}
112
113impl TreeNode {
114 #[must_use]
116 pub fn new(label: impl Into<String>) -> Self {
117 Self {
118 label: label.into(),
119 icon: None,
120 children: Vec::new(),
121 lazy_children: None,
122 expanded: true,
123 }
124 }
125
126 #[must_use]
128 pub fn child(mut self, node: TreeNode) -> Self {
129 self.children.push(node);
130 self
131 }
132
133 #[must_use]
135 pub fn with_children(mut self, nodes: Vec<TreeNode>) -> Self {
136 self.children = nodes;
137 self
138 }
139
140 #[must_use]
142 pub fn with_icon(mut self, icon: impl Into<String>) -> Self {
143 self.icon = Some(icon.into());
144 self
145 }
146
147 #[must_use]
151 pub fn with_lazy_children(mut self, nodes: Vec<TreeNode>) -> Self {
152 self.lazy_children = Some(nodes);
153 self.expanded = false;
154 self
155 }
156
157 #[must_use]
159 pub fn with_expanded(mut self, expanded: bool) -> Self {
160 if expanded {
161 self.materialize_lazy_children();
162 }
163 self.expanded = expanded;
164 self
165 }
166
167 #[must_use]
169 pub fn label(&self) -> &str {
170 &self.label
171 }
172
173 #[must_use]
175 pub fn children(&self) -> &[TreeNode] {
176 &self.children
177 }
178
179 #[must_use]
181 pub fn icon(&self) -> Option<&str> {
182 self.icon.as_deref()
183 }
184
185 #[must_use]
187 pub fn has_children(&self) -> bool {
188 !self.children.is_empty()
189 || self
190 .lazy_children
191 .as_ref()
192 .is_some_and(|children| !children.is_empty())
193 }
194
195 #[must_use]
197 pub fn is_expanded(&self) -> bool {
198 self.expanded
199 }
200
201 pub fn toggle_expanded(&mut self) {
203 if !self.expanded {
204 self.materialize_lazy_children();
205 }
206 self.expanded = !self.expanded;
207 }
208
209 fn materialize_lazy_children(&mut self) {
210 if let Some(mut lazy) = self.lazy_children.take() {
211 self.children.append(&mut lazy);
212 }
213 }
214
215 fn materialize_all_lazy_children(&mut self) {
216 self.materialize_lazy_children();
217 for child in &mut self.children {
218 child.materialize_all_lazy_children();
219 }
220 }
221
222 #[cfg(feature = "tracing")]
223 fn total_count(&self) -> usize {
224 let mut count = 1usize;
225 for child in &self.children {
226 count = count.saturating_add(child.total_count());
227 }
228 if let Some(lazy) = &self.lazy_children {
229 for child in lazy {
230 count = count.saturating_add(child.total_count());
231 }
232 }
233 count
234 }
235
236 #[cfg(feature = "tracing")]
237 fn expanded_count(&self) -> usize {
238 let mut count = usize::from(self.expanded && self.has_children());
239 for child in &self.children {
240 count = count.saturating_add(child.expanded_count());
241 }
242 if let Some(lazy) = &self.lazy_children {
243 for child in lazy {
244 count = count.saturating_add(child.expanded_count());
245 }
246 }
247 count
248 }
249
250 #[must_use]
252 pub fn visible_count(&self) -> usize {
253 let mut count = 1;
254 if self.expanded {
255 for child in &self.children {
256 count += child.visible_count();
257 }
258 }
259 count
260 }
261
262 #[allow(dead_code)]
264 pub(crate) fn collect_expanded(&self, prefix: &str, out: &mut HashSet<String>) {
265 let path = if prefix.is_empty() {
266 self.label.clone()
267 } else {
268 format!("{}/{}", prefix, self.label)
269 };
270
271 if self.expanded && self.has_children() {
272 out.insert(path.clone());
273 }
274
275 for child in &self.children {
276 child.collect_expanded(&path, out);
277 }
278 }
279
280 #[allow(dead_code)]
282 pub(crate) fn apply_expanded(&mut self, prefix: &str, expanded_paths: &HashSet<String>) {
283 let path = if prefix.is_empty() {
284 self.label.clone()
285 } else {
286 format!("{}/{}", prefix, self.label)
287 };
288
289 if self.has_children() {
290 self.expanded = expanded_paths.contains(&path);
291 if self.expanded {
292 self.materialize_lazy_children();
293 }
294 }
295
296 for child in &mut self.children {
297 child.apply_expanded(&path, expanded_paths);
298 }
299 }
300}
301
302#[derive(Debug, Clone)]
304pub struct Tree {
305 undo_id: UndoWidgetId,
307 root: TreeNode,
308 show_root: bool,
310 guides: TreeGuides,
312 guide_style: Style,
314 label_style: Style,
316 root_style: Style,
318 persistence_id: Option<String>,
320 hit_id: Option<HitId>,
322 accessibility_id: Option<u64>,
324 selected_visible_index: Option<usize>,
326 focused: bool,
328 search_query: Option<String>,
330}
331
332impl Tree {
333 #[must_use]
335 pub fn new(root: TreeNode) -> Self {
336 Self {
337 undo_id: UndoWidgetId::new(),
338 root,
339 show_root: true,
340 guides: TreeGuides::default(),
341 guide_style: Style::default(),
342 label_style: Style::default(),
343 root_style: Style::default(),
344 persistence_id: None,
345 hit_id: None,
346 accessibility_id: None,
347 selected_visible_index: None,
348 focused: false,
349 search_query: None,
350 }
351 }
352
353 #[must_use]
355 pub fn with_show_root(mut self, show: bool) -> Self {
356 self.show_root = show;
357 self
358 }
359
360 #[must_use]
362 pub fn with_guides(mut self, guides: TreeGuides) -> Self {
363 self.guides = guides;
364 self
365 }
366
367 #[must_use]
369 pub fn with_guide_style(mut self, style: Style) -> Self {
370 self.guide_style = style;
371 self
372 }
373
374 #[must_use]
376 pub fn with_label_style(mut self, style: Style) -> Self {
377 self.label_style = style;
378 self
379 }
380
381 #[must_use]
383 pub fn with_root_style(mut self, style: Style) -> Self {
384 self.root_style = style;
385 self
386 }
387
388 #[must_use]
391 pub fn with_persistence_id(mut self, id: impl Into<String>) -> Self {
392 self.persistence_id = Some(id.into());
393 self
394 }
395
396 #[must_use]
398 pub fn persistence_id(&self) -> Option<&str> {
399 self.persistence_id.as_deref()
400 }
401
402 #[must_use]
404 pub fn hit_id(mut self, id: HitId) -> Self {
405 self.hit_id = Some(id);
406 self
407 }
408
409 #[must_use]
412 pub fn with_accessibility_id(mut self, id: u64) -> Self {
413 self.accessibility_id = Some(id);
414 self
415 }
416
417 #[must_use]
419 pub fn with_selected_visible_index(mut self, index: Option<usize>) -> Self {
420 self.selected_visible_index = index;
421 self
422 }
423
424 #[must_use]
426 pub fn with_focused(mut self, focused: bool) -> Self {
427 self.focused = focused;
428 self
429 }
430
431 #[must_use]
433 pub fn with_search_query(mut self, query: impl Into<String>) -> Self {
434 let query = query.into();
435 self.search_query = if query.trim().is_empty() {
436 None
437 } else {
438 Some(query)
439 };
440 self
441 }
442
443 #[must_use]
445 pub fn without_search_query(mut self) -> Self {
446 self.search_query = None;
447 self
448 }
449
450 fn accessibility_root_id(&self, area: Rect) -> u64 {
451 if let Some(id) = self.accessibility_id {
452 return id;
453 }
454 if let Some(hit) = self.hit_id {
455 use std::hash::{Hash, Hasher};
456 let mut hasher = std::collections::hash_map::DefaultHasher::new();
457 ("ftui.tree.hit", hit.id()).hash(&mut hasher);
458 return hasher.finish();
459 }
460 if let Some(ref pid) = self.persistence_id {
461 use std::hash::{Hash, Hasher};
462 let mut hasher = std::collections::hash_map::DefaultHasher::new();
463 ("ftui.tree.persist", pid.as_str()).hash(&mut hasher);
464 return hasher.finish();
465 }
466 crate::a11y_node_id(area)
467 }
468
469 #[must_use]
472 pub fn accessibility_item_id(root_id: u64, path: &[usize]) -> u64 {
473 use std::hash::{Hash, Hasher};
474 let mut hasher = std::collections::hash_map::DefaultHasher::new();
475 ("ftui.tree.node", root_id, path).hash(&mut hasher);
476 hasher.finish()
477 }
478
479 #[cfg(feature = "tracing")]
480 fn total_nodes(&self) -> usize {
481 if self.show_root {
482 self.root.total_count()
483 } else if self.root.expanded {
484 self.root
485 .children
486 .iter()
487 .fold(0usize, |acc, child| acc.saturating_add(child.total_count()))
488 } else {
489 0
490 }
491 }
492
493 #[cfg(feature = "tracing")]
494 fn visible_nodes(&self) -> usize {
495 if self.show_root {
496 self.root.visible_count()
497 } else if self.root.expanded {
498 self.root.children.iter().fold(0usize, |acc, child| {
499 acc.saturating_add(child.visible_count())
500 })
501 } else {
502 0
503 }
504 }
505
506 #[cfg(feature = "tracing")]
507 fn expanded_nodes(&self) -> usize {
508 if self.show_root {
509 self.root.expanded_count()
510 } else if self.root.expanded {
511 self.root.children.iter().fold(0usize, |acc, child| {
512 acc.saturating_add(child.expanded_count())
513 })
514 } else {
515 0
516 }
517 }
518
519 #[must_use]
521 pub fn root(&self) -> &TreeNode {
522 &self.root
523 }
524
525 pub fn root_mut(&mut self) -> &mut TreeNode {
527 &mut self.root
528 }
529
530 fn build_a11y_item_node(
531 &self,
532 node: &TreeNode,
533 depth: usize,
534 row_idx: usize,
535 row_bounds: Rect,
536 root_id: u64,
537 path: &[usize],
538 ) -> ftui_a11y::node::A11yNodeInfo {
539 let item_id = Self::accessibility_item_id(root_id, path);
540 let mut item = ftui_a11y::node::A11yNodeInfo::new(
541 item_id,
542 ftui_a11y::node::A11yRole::ListItem,
543 row_bounds,
544 );
545 if !node.label.is_empty() {
546 item.name = Some(node.label.clone());
547 }
548 item.description = Some(match node.icon() {
549 Some(icon) if !icon.is_empty() => format!("level {}, icon {}", depth + 1, icon),
550 _ => format!("level {}", depth + 1),
551 });
552 let has_children = self
553 .get_node_at_path(path)
554 .map_or_else(|| node.has_children(), TreeNode::has_children);
555 if has_children {
556 item.state.expanded = Some(node.is_expanded());
557 }
558 item.state.selected = self.selected_visible_index == Some(row_idx);
559 item.state.focused = self.focused && self.selected_visible_index == Some(row_idx);
560 item
561 }
562
563 #[allow(clippy::too_many_arguments)]
564 fn render_node(
565 &self,
566 node: &TreeNode,
567 depth: usize,
568 is_last: &mut Vec<bool>,
569 area: Rect,
570 frame: &mut Frame,
571 current_row: &mut usize,
572 deg: ftui_render::budget::DegradationLevel,
573 a11y_root_id: u64,
574 ) {
575 if *current_row >= area.height as usize {
576 return;
577 }
578
579 let row_idx = *current_row;
580 let y = area.y.saturating_add(row_idx as u16);
581 let mut x = area.x;
582 let max_x = area.right();
583
584 if depth > 0 && deg.apply_styling() {
586 for d in 0..depth {
587 let is_last_at_depth = is_last.get(d).copied().unwrap_or(false);
588 let guide = if d == depth - 1 {
589 if is_last_at_depth {
591 self.guides.last()
592 } else {
593 self.guides.branch()
594 }
595 } else {
596 if is_last_at_depth {
598 self.guides.space()
599 } else {
600 self.guides.vertical()
601 }
602 };
603
604 x = draw_text_span(frame, x, y, guide, self.guide_style, max_x);
605 }
606 } else if depth > 0 {
607 for _ in 0..depth {
610 x = draw_text_span(frame, x, y, " ", Style::default(), max_x);
611 if x >= max_x {
612 break;
613 }
614 }
615 }
616
617 let style = if depth == 0 && self.show_root {
619 self.root_style
620 } else {
621 self.label_style
622 };
623 if let Some(icon) = node.icon() {
624 let icon_style = if deg.apply_styling() {
625 style
626 } else {
627 Style::default()
628 };
629 x = draw_text_span(frame, x, y, icon, icon_style, max_x);
630 if x < max_x {
631 x = draw_text_span(frame, x, y, " ", icon_style, max_x);
632 }
633 }
634
635 if deg.apply_styling() {
636 draw_text_span(frame, x, y, &node.label, style, max_x);
637 } else {
638 draw_text_span(frame, x, y, &node.label, Style::default(), max_x);
639 }
640
641 let row_area = Rect::new(area.x, y, area.width, 1);
642
643 if let Some(id) = self.hit_id {
645 frame.register_hit(row_area, id, HitRegion::Content, row_idx as u64);
646 }
647
648 let a11y_item = if frame.a11y_enabled() {
649 let row_bounds = row_area.intersection(&frame.buffer.current_scissor());
650 if row_bounds.is_empty() {
651 None
652 } else {
653 let path = self
654 .find_path_indices_at_visible_index(row_idx)
655 .unwrap_or_default();
656 Some(self.build_a11y_item_node(
657 node,
658 depth,
659 row_idx,
660 row_bounds,
661 a11y_root_id,
662 &path,
663 ))
664 }
665 } else {
666 None
667 };
668
669 *current_row += 1;
670
671 if !node.expanded || node.children.is_empty() || *current_row >= area.height as usize {
672 if let Some(item_node) = a11y_item {
673 frame.push_a11y(item_node);
674 }
675 return;
676 }
677
678 let mut render_children = |frame: &mut Frame| {
679 let child_count = node.children.len();
680 for (i, child) in node.children.iter().enumerate() {
681 if *current_row >= area.height as usize {
682 break;
683 }
684 is_last.push(i == child_count - 1);
685 self.render_node(
686 child,
687 depth + 1,
688 is_last,
689 area,
690 frame,
691 current_row,
692 deg,
693 a11y_root_id,
694 );
695 is_last.pop();
696 }
697 };
698
699 if let Some(item_node) = a11y_item {
700 frame.with_a11y_scope(item_node, render_children);
701 } else {
702 render_children(frame);
703 }
704 }
705}
706
707fn filter_node(node: &TreeNode, query_lower: &str) -> Option<TreeNode> {
708 let label_matches = crate::contains_ignore_case(&node.label, query_lower)
709 || node
710 .icon
711 .as_deref()
712 .is_some_and(|icon| crate::contains_ignore_case(icon, query_lower));
713
714 let mut filtered_children = Vec::new();
715 for child in &node.children {
716 if let Some(filtered) = filter_node(child, query_lower) {
717 filtered_children.push(filtered);
718 }
719 }
720
721 let mut filtered_lazy = Vec::new();
722 if let Some(lazy) = &node.lazy_children {
723 for child in lazy {
724 if let Some(filtered) = filter_node(child, query_lower) {
725 filtered_lazy.push(filtered);
726 }
727 }
728 }
729
730 if !label_matches && filtered_children.is_empty() && filtered_lazy.is_empty() {
731 return None;
732 }
733
734 let mut filtered = node.clone();
735 if label_matches {
736 filtered.materialize_all_lazy_children();
740 filtered.expanded = true;
741 } else {
742 filtered.children = filtered_children;
745 filtered.children.extend(filtered_lazy);
746 filtered.lazy_children = None;
747 filtered.expanded = true;
748 }
749 Some(filtered)
750}
751
752struct FilteredPathNode {
753 expanded: bool,
754 children: Vec<(usize, FilteredPathNode)>,
755}
756
757fn create_unfiltered_path_node(node: &TreeNode) -> FilteredPathNode {
758 let mut children = Vec::new();
759 for (idx, child) in node.children.iter().enumerate() {
760 children.push((idx, create_unfiltered_path_node(child)));
761 }
762 let lazy_offset = node.children.len();
763 if let Some(lazy) = &node.lazy_children {
764 for (idx, child) in lazy.iter().enumerate() {
765 children.push((lazy_offset + idx, create_unfiltered_path_node(child)));
766 }
767 }
768 FilteredPathNode {
769 expanded: node.expanded,
770 children,
771 }
772}
773
774fn filter_node_paths(
775 node: &TreeNode,
776 query_lower: &str,
777) -> Option<(bool, Vec<(usize, FilteredPathNode)>)> {
778 let label_matches = crate::contains_ignore_case(&node.label, query_lower)
779 || node
780 .icon
781 .as_deref()
782 .is_some_and(|icon| crate::contains_ignore_case(icon, query_lower));
783
784 if label_matches {
785 let mut children = Vec::new();
786 for (idx, child) in node.children.iter().enumerate() {
787 children.push((idx, create_unfiltered_path_node(child)));
788 }
789 let lazy_offset = node.children.len();
790 if let Some(lazy) = &node.lazy_children {
791 for (idx, child) in lazy.iter().enumerate() {
792 children.push((lazy_offset + idx, create_unfiltered_path_node(child)));
793 }
794 }
795 return Some((true, children));
796 }
797
798 let mut filtered_children = Vec::new();
799 for (idx, child) in node.children.iter().enumerate() {
800 if let Some(filtered) = filter_node_paths(child, query_lower) {
801 filtered_children.push((
802 idx,
803 FilteredPathNode {
804 expanded: filtered.0,
805 children: filtered.1,
806 },
807 ));
808 }
809 }
810
811 let mut filtered_lazy = Vec::new();
812 let lazy_offset = node.children.len();
813 if let Some(lazy) = &node.lazy_children {
814 for (idx, child) in lazy.iter().enumerate() {
815 if let Some(filtered) = filter_node_paths(child, query_lower) {
816 filtered_lazy.push((
817 lazy_offset + idx,
818 FilteredPathNode {
819 expanded: filtered.0,
820 children: filtered.1,
821 },
822 ));
823 }
824 }
825 }
826
827 if filtered_children.is_empty() && filtered_lazy.is_empty() {
828 return None;
829 }
830
831 filtered_children.extend(filtered_lazy);
832 Some((true, filtered_children))
833}
834
835impl Widget for Tree {
836 fn render(&self, area: Rect, frame: &mut Frame) {
837 if area.width == 0 || area.height == 0 {
838 return;
839 }
840
841 #[cfg(feature = "tracing")]
842 let render_start = Instant::now();
843 #[cfg(feature = "tracing")]
844 let total_nodes = self.total_nodes();
845 #[cfg(feature = "tracing")]
846 let visible_nodes = self.visible_nodes();
847 #[cfg(feature = "tracing")]
848 let expanded_count = self.expanded_nodes();
849 #[cfg(feature = "tracing")]
850 let render_span = tracing::debug_span!(
851 "tree.render",
852 total_nodes,
853 visible_nodes,
854 expanded_count,
855 render_duration_us = tracing::field::Empty,
856 );
857 #[cfg(feature = "tracing")]
858 let _render_guard = render_span.enter();
859
860 let deg = frame.buffer.degradation;
861 let base_style = if deg.apply_styling() {
862 self.label_style
863 } else {
864 Style::default()
865 };
866 clear_text_area(frame, area, base_style);
867 let mut current_row = 0;
868 let mut is_last = Vec::with_capacity(8);
869
870 let search_query = self
871 .search_query
872 .as_deref()
873 .filter(|q| !q.trim().is_empty());
874 let is_searching = search_query.is_some();
875 let filtered_root = if let Some(q) = search_query {
876 let query_lower = q.trim().to_lowercase();
877 filter_node(&self.root, &query_lower)
878 } else {
879 Some(self.root.clone())
880 };
881
882 let a11y_root_id = self.accessibility_root_id(area);
883 let a11y_bounds = area.intersection(&frame.buffer.current_scissor());
884 let tree_title = if self.root.label().trim().is_empty() {
885 "Tree"
886 } else {
887 self.root.label()
888 };
889
890 if is_searching && filtered_root.is_none() {
891 if frame.a11y_enabled() && !a11y_bounds.is_empty() {
892 let root_node = ftui_a11y::node::A11yNodeInfo::new(
893 a11y_root_id,
894 ftui_a11y::node::A11yRole::List,
895 a11y_bounds,
896 )
897 .with_name(tree_title)
898 .with_description("0 matching items");
899 frame.push_a11y(root_node);
900 }
901 #[cfg(feature = "tracing")]
902 {
903 let elapsed = render_start.elapsed();
904 let elapsed_us = elapsed.as_micros() as u64;
905 render_span.record("render_duration_us", elapsed_us);
906 tracing::debug!(
907 render_duration_us = elapsed_us,
908 "Tree render complete (empty search)"
909 );
910 }
911 return;
912 }
913
914 let root_fallback = self.root.clone();
915 let root = filtered_root.as_ref().unwrap_or(&root_fallback);
916
917 let visible_item_count = if self.show_root {
918 root.visible_count()
919 } else if root.expanded {
920 root.children.iter().fold(0usize, |acc, child| {
921 acc.saturating_add(child.visible_count())
922 })
923 } else {
924 0
925 };
926
927 let mut render_tree_rows = |frame: &mut Frame| {
928 if self.show_root {
929 self.render_node(
930 root,
931 0,
932 &mut is_last,
933 area,
934 frame,
935 &mut current_row,
936 deg,
937 a11y_root_id,
938 );
939 } else if root.expanded {
940 let child_count = root.children.len();
944 for (i, child) in root.children.iter().enumerate() {
945 is_last.push(i == child_count - 1);
946 self.render_node(
947 child,
948 0, &mut is_last,
950 area,
951 frame,
952 &mut current_row,
953 deg,
954 a11y_root_id,
955 );
956 is_last.pop();
957 }
958 }
959 };
960
961 if frame.a11y_enabled() && !a11y_bounds.is_empty() {
962 let desc = if is_searching {
963 format!("{visible_item_count} matching items")
964 } else {
965 format!("{visible_item_count} visible items")
966 };
967 let root_node = ftui_a11y::node::A11yNodeInfo::new(
968 a11y_root_id,
969 ftui_a11y::node::A11yRole::List,
970 a11y_bounds,
971 )
972 .with_name(tree_title)
973 .with_description(desc);
974 frame.with_a11y_scope(root_node, render_tree_rows);
975 } else {
976 render_tree_rows(frame);
977 }
978
979 #[cfg(feature = "tracing")]
980 {
981 let elapsed = render_start.elapsed();
982 let elapsed_us = elapsed.as_micros() as u64;
983 render_span.record("render_duration_us", elapsed_us);
984 tracing::debug!(
985 message = "tree.metrics",
986 tree_render_duration_us = elapsed_us,
987 total_nodes,
988 visible_nodes,
989 expanded_count
990 );
991 }
992 }
993
994 fn is_essential(&self) -> bool {
995 false
996 }
997}
998
999impl ftui_a11y::Accessible for Tree {
1000 fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
1001 if area.is_empty() {
1002 return Vec::new();
1003 }
1004 let mut pool = ftui_render::grapheme_pool::GraphemePool::new();
1005 let mut builder = ftui_a11y::tree::A11yTreeBuilder::new();
1006 let width = area.right().max(1);
1007 let height = area.bottom().max(1);
1008 let order = {
1009 let mut frame = Frame::new(width, height, &mut pool);
1010 frame.set_a11y(&mut builder);
1011 Widget::render(self, area, &mut frame);
1012 frame.finish_a11y();
1013 frame.take_a11y_order()
1014 };
1015 let tree = builder.build();
1016 order
1017 .into_iter()
1018 .filter_map(|id| tree.node(id).cloned())
1019 .collect()
1020 }
1021}
1022
1023#[derive(Clone, Debug, Default, PartialEq)]
1031#[cfg_attr(
1032 feature = "state-persistence",
1033 derive(serde::Serialize, serde::Deserialize)
1034)]
1035pub struct TreePersistState {
1036 pub expanded_paths: HashSet<String>,
1038}
1039
1040impl crate::stateful::Stateful for Tree {
1041 type State = TreePersistState;
1042
1043 fn state_key(&self) -> Option<crate::stateful::StateKey> {
1044 self.persistence_id
1046 .as_deref()
1047 .map(|id| crate::stateful::StateKey::new("Tree", id))
1048 }
1049
1050 fn save_state(&self) -> TreePersistState {
1051 let mut expanded_paths = HashSet::new();
1052 self.root.collect_expanded("", &mut expanded_paths);
1053 TreePersistState { expanded_paths }
1054 }
1055
1056 fn restore_state(&mut self, state: TreePersistState) {
1057 self.root.apply_expanded("", &state.expanded_paths);
1058 }
1059}
1060
1061impl UndoSupport for Tree {
1066 fn undo_widget_id(&self) -> UndoWidgetId {
1067 self.undo_id
1068 }
1069
1070 fn create_snapshot(&self) -> Box<dyn Any + Send> {
1071 Box::new(self.save_state())
1072 }
1073
1074 fn restore_snapshot(&mut self, snapshot: &dyn Any) -> bool {
1075 if let Some(snap) = snapshot.downcast_ref::<TreePersistState>() {
1076 self.restore_state(snap.clone());
1077 true
1078 } else {
1079 false
1080 }
1081 }
1082}
1083
1084impl TreeUndoExt for Tree {
1085 fn is_node_expanded(&self, path: &[usize]) -> bool {
1086 self.get_node_at_path(path)
1087 .map(|node| node.is_expanded())
1088 .unwrap_or(false)
1089 }
1090
1091 fn expand_node(&mut self, path: &[usize]) {
1092 if let Some(node) = self.get_node_at_path_mut(path) {
1093 node.materialize_lazy_children();
1094 node.expanded = true;
1095 }
1096 }
1097
1098 fn collapse_node(&mut self, path: &[usize]) {
1099 if let Some(node) = self.get_node_at_path_mut(path) {
1100 node.expanded = false;
1101 }
1102 }
1103}
1104
1105impl Tree {
1106 #[must_use]
1108 pub fn undo_id(&self) -> UndoWidgetId {
1109 self.undo_id
1110 }
1111
1112 fn get_node_at_path(&self, path: &[usize]) -> Option<&TreeNode> {
1114 let mut current = &self.root;
1115 for &idx in path {
1116 current = current.children.get(idx)?;
1117 }
1118 Some(current)
1119 }
1120
1121 fn get_node_at_path_mut(&mut self, path: &[usize]) -> Option<&mut TreeNode> {
1123 let mut current = &mut self.root;
1124 for &idx in path {
1125 current = current.children.get_mut(idx)?;
1126 }
1127 Some(current)
1128 }
1129
1130 #[cfg(feature = "tracing")]
1131 fn log_expand_collapse(action: &str, source: &str, index: usize, label: &str) {
1132 tracing::debug!(
1133 message = "tree.toggle",
1134 action,
1135 source,
1136 visible_index = index,
1137 label
1138 );
1139 }
1140
1141 fn toggle_node_at_visible_index(&mut self, index: usize, source: &str) -> bool {
1142 #[cfg(not(feature = "tracing"))]
1143 let _ = source;
1144 let Some(node) = self.node_at_visible_index_mut(index) else {
1145 return false;
1146 };
1147 if !node.has_children() {
1148 return false;
1149 }
1150 #[cfg(feature = "tracing")]
1151 let action = if node.is_expanded() {
1152 "collapse"
1153 } else {
1154 "expand"
1155 };
1156 #[cfg(feature = "tracing")]
1157 let label = node.label().to_owned();
1158 node.toggle_expanded();
1159 #[cfg(feature = "tracing")]
1160 Self::log_expand_collapse(action, source, index, &label);
1161 true
1162 }
1163
1164 pub fn handle_key(&mut self, key: &KeyEvent, selected_visible_index: usize) -> bool {
1177 if key.kind == KeyEventKind::Release {
1178 return false;
1179 }
1180 match key.code {
1181 KeyCode::Enter | KeyCode::Char(' ') => {
1182 self.toggle_node_at_visible_index(selected_visible_index, "keyboard")
1183 }
1184 KeyCode::Right => {
1185 if let Some(node) = self.node_at_visible_index_mut(selected_visible_index)
1187 && !node.is_expanded()
1188 && node.has_children()
1189 {
1190 #[cfg(feature = "tracing")]
1191 let label = node.label().to_owned();
1192 node.toggle_expanded();
1193 #[cfg(feature = "tracing")]
1194 Self::log_expand_collapse("expand", "keyboard", selected_visible_index, &label);
1195 return true;
1196 }
1197 false
1198 }
1199 KeyCode::Left => {
1200 if let Some(node) = self.node_at_visible_index_mut(selected_visible_index)
1202 && node.is_expanded()
1203 && node.has_children()
1204 {
1205 #[cfg(feature = "tracing")]
1206 let label = node.label().to_owned();
1207 node.toggle_expanded();
1208 #[cfg(feature = "tracing")]
1209 Self::log_expand_collapse(
1210 "collapse",
1211 "keyboard",
1212 selected_visible_index,
1213 &label,
1214 );
1215 return true;
1216 }
1217 false
1218 }
1219 _ => false,
1220 }
1221 }
1222
1223 pub fn handle_mouse(
1240 &mut self,
1241 event: &MouseEvent,
1242 hit: Option<(HitId, HitRegion, u64)>,
1243 expected_id: HitId,
1244 ) -> MouseResult {
1245 match event.kind {
1246 MouseEventKind::Down(MouseButton::Left) => {
1247 if let Some((id, HitRegion::Content, data)) = hit
1248 && id == expected_id
1249 {
1250 let index = data as usize;
1251 if let Some(node) = self.node_at_visible_index_mut(index)
1252 && !node.has_children()
1253 {
1254 return MouseResult::Selected(index);
1255 }
1256 if self.toggle_node_at_visible_index(index, "mouse") {
1257 return MouseResult::Activated(index);
1258 }
1259 }
1260 MouseResult::Ignored
1261 }
1262 _ => MouseResult::Ignored,
1263 }
1264 }
1265
1266 pub fn node_at_visible_index_mut(&mut self, target: usize) -> Option<&mut TreeNode> {
1272 let path = self.find_path_indices_at_visible_index(target)?;
1273
1274 let mut current = &mut self.root;
1275 for &idx in &path {
1276 current.materialize_lazy_children();
1277 current = current.children.get_mut(idx)?;
1278 }
1279 Some(current)
1280 }
1281
1282 fn find_path_indices_at_visible_index(&self, target: usize) -> Option<Vec<usize>> {
1283 let query = self
1284 .search_query
1285 .as_deref()
1286 .map(str::trim)
1287 .filter(|q| !q.is_empty());
1288 let mut counter = 0usize;
1289 let mut path = Vec::new();
1290
1291 if let Some(q) = query {
1292 let query_lower = q.to_lowercase();
1293 let (expanded, children) = filter_node_paths(&self.root, &query_lower)?;
1294 let root_node = FilteredPathNode { expanded, children };
1295
1296 if self.show_root {
1297 Self::walk_filtered_path(&root_node, target, &mut counter, &mut path)
1298 } else if root_node.expanded {
1299 for &(idx, ref child) in &root_node.children {
1300 path.push(idx);
1301 if let Some(p) =
1302 Self::walk_filtered_path(child, target, &mut counter, &mut path)
1303 {
1304 return Some(p);
1305 }
1306 path.pop();
1307 }
1308 None
1309 } else {
1310 None
1311 }
1312 } else {
1313 if self.show_root {
1314 Self::walk_visible_index_path(&self.root, target, &mut counter, &mut path)
1315 } else if self.root.expanded {
1316 for (idx, child) in self.root.children.iter().enumerate() {
1317 path.push(idx);
1318 if let Some(p) =
1319 Self::walk_visible_index_path(child, target, &mut counter, &mut path)
1320 {
1321 return Some(p);
1322 }
1323 path.pop();
1324 }
1325 None
1326 } else {
1327 None
1328 }
1329 }
1330 }
1331
1332 fn walk_filtered_path(
1333 node: &FilteredPathNode,
1334 target: usize,
1335 counter: &mut usize,
1336 current_path: &mut Vec<usize>,
1337 ) -> Option<Vec<usize>> {
1338 if *counter == target {
1339 return Some(current_path.clone());
1340 }
1341 *counter += 1;
1342 if node.expanded {
1343 for &(idx, ref child) in &node.children {
1344 current_path.push(idx);
1345 if let Some(found) = Self::walk_filtered_path(child, target, counter, current_path)
1346 {
1347 return Some(found);
1348 }
1349 current_path.pop();
1350 }
1351 }
1352 None
1353 }
1354
1355 fn walk_visible_index_path(
1356 node: &TreeNode,
1357 target: usize,
1358 counter: &mut usize,
1359 current_path: &mut Vec<usize>,
1360 ) -> Option<Vec<usize>> {
1361 if *counter == target {
1362 return Some(current_path.clone());
1363 }
1364 *counter += 1;
1365 if node.expanded {
1366 for (idx, child) in node.children.iter().enumerate() {
1367 current_path.push(idx);
1368 if let Some(found) =
1369 Self::walk_visible_index_path(child, target, counter, current_path)
1370 {
1371 return Some(found);
1372 }
1373 current_path.pop();
1374 }
1375 }
1376 None
1377 }
1378}
1379
1380#[cfg(test)]
1385#[derive(Debug, Clone, PartialEq, Eq)]
1386struct FlatNode {
1387 label: String,
1388 depth: usize,
1389}
1390
1391#[cfg(test)]
1392fn flatten_visible(node: &TreeNode, depth: usize, out: &mut Vec<FlatNode>) {
1393 out.push(FlatNode {
1394 label: node.label.clone(),
1395 depth,
1396 });
1397 if node.expanded {
1398 for child in &node.children {
1399 flatten_visible(child, depth + 1, out);
1400 }
1401 }
1402}
1403
1404#[cfg(test)]
1405impl Tree {
1406 fn flatten(&self) -> Vec<FlatNode> {
1407 let mut out = Vec::new();
1408 let search_query = self
1409 .search_query
1410 .as_deref()
1411 .filter(|q| !q.trim().is_empty());
1412 let is_searching = search_query.is_some();
1413 let filtered_root = if let Some(q) = search_query {
1414 let query_lower = q.trim().to_lowercase();
1415 filter_node(&self.root, &query_lower)
1416 } else {
1417 Some(self.root.clone())
1418 };
1419
1420 if is_searching && filtered_root.is_none() {
1421 return out;
1422 }
1423
1424 let root_fallback = self.root.clone();
1425 let root = filtered_root.as_ref().unwrap_or(&root_fallback);
1426 if self.show_root {
1427 flatten_visible(root, 0, &mut out);
1428 } else if root.expanded {
1429 for child in &root.children {
1430 flatten_visible(child, 0, &mut out);
1431 }
1432 }
1433 out
1434 }
1435}
1436
1437#[cfg(test)]
1438mod tests {
1439 use super::*;
1440 use ftui_render::frame::Frame;
1441 use ftui_render::grapheme_pool::GraphemePool;
1442 #[cfg(feature = "tracing")]
1443 use std::sync::{Arc, Mutex};
1444 #[cfg(feature = "tracing")]
1445 use tracing::Subscriber;
1446 #[cfg(feature = "tracing")]
1447 use tracing_subscriber::Layer;
1448 #[cfg(feature = "tracing")]
1449 use tracing_subscriber::layer::{Context, SubscriberExt};
1450
1451 fn line_text(frame: &Frame, y: u16, width: u16) -> String {
1452 (0..width)
1453 .map(|x| {
1454 frame
1455 .buffer
1456 .get(x, y)
1457 .and_then(|cell| cell.content.as_char())
1458 .unwrap_or(' ')
1459 })
1460 .collect()
1461 }
1462
1463 fn simple_tree() -> TreeNode {
1464 TreeNode::new("root")
1465 .child(
1466 TreeNode::new("a")
1467 .child(TreeNode::new("a1"))
1468 .child(TreeNode::new("a2")),
1469 )
1470 .child(TreeNode::new("b"))
1471 }
1472
1473 #[cfg(feature = "tracing")]
1474 #[derive(Debug, Default)]
1475 struct TreeTraceState {
1476 tree_render_seen: bool,
1477 has_total_nodes_field: bool,
1478 has_visible_nodes_field: bool,
1479 has_expanded_count_field: bool,
1480 render_duration_recorded: bool,
1481 toggle_events: usize,
1482 }
1483
1484 #[cfg(feature = "tracing")]
1485 struct TreeTraceCapture {
1486 state: Arc<Mutex<TreeTraceState>>,
1487 }
1488
1489 #[cfg(feature = "tracing")]
1490 impl<S> Layer<S> for TreeTraceCapture
1491 where
1492 S: Subscriber + for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>,
1493 {
1494 fn on_new_span(
1495 &self,
1496 attrs: &tracing::span::Attributes<'_>,
1497 _id: &tracing::Id,
1498 _ctx: Context<'_, S>,
1499 ) {
1500 if attrs.metadata().name() != "tree.render" {
1501 return;
1502 }
1503 let fields = attrs.metadata().fields();
1504 let mut state = self.state.lock().expect("tree trace state lock");
1505 state.tree_render_seen = true;
1506 state.has_total_nodes_field |= fields.field("total_nodes").is_some();
1507 state.has_visible_nodes_field |= fields.field("visible_nodes").is_some();
1508 state.has_expanded_count_field |= fields.field("expanded_count").is_some();
1509 }
1510
1511 fn on_record(
1512 &self,
1513 id: &tracing::Id,
1514 values: &tracing::span::Record<'_>,
1515 ctx: Context<'_, S>,
1516 ) {
1517 let Some(span) = ctx.span(id) else {
1518 return;
1519 };
1520 if span.metadata().name() != "tree.render" {
1521 return;
1522 }
1523
1524 struct DurationVisitor {
1525 saw_duration: bool,
1526 }
1527 impl tracing::field::Visit for DurationVisitor {
1528 fn record_u64(&mut self, field: &tracing::field::Field, _value: u64) {
1529 if field.name() == "render_duration_us" {
1530 self.saw_duration = true;
1531 }
1532 }
1533
1534 fn record_debug(
1535 &mut self,
1536 field: &tracing::field::Field,
1537 _value: &dyn std::fmt::Debug,
1538 ) {
1539 if field.name() == "render_duration_us" {
1540 self.saw_duration = true;
1541 }
1542 }
1543 }
1544
1545 let mut visitor = DurationVisitor {
1546 saw_duration: false,
1547 };
1548 values.record(&mut visitor);
1549 if visitor.saw_duration {
1550 self.state
1551 .lock()
1552 .expect("tree trace state lock")
1553 .render_duration_recorded = true;
1554 }
1555 }
1556
1557 fn on_event(&self, event: &tracing::Event<'_>, _ctx: Context<'_, S>) {
1558 struct MessageVisitor {
1559 message: Option<String>,
1560 }
1561 impl tracing::field::Visit for MessageVisitor {
1562 fn record_str(&mut self, field: &tracing::field::Field, value: &str) {
1563 if field.name() == "message" {
1564 self.message = Some(value.to_owned());
1565 }
1566 }
1567
1568 fn record_debug(
1569 &mut self,
1570 field: &tracing::field::Field,
1571 value: &dyn std::fmt::Debug,
1572 ) {
1573 if field.name() == "message" {
1574 self.message = Some(format!("{value:?}").trim_matches('"').to_owned());
1575 }
1576 }
1577 }
1578
1579 let mut visitor = MessageVisitor { message: None };
1580 event.record(&mut visitor);
1581 if visitor.message.as_deref() == Some("tree.toggle") {
1582 let mut state = self.state.lock().expect("tree trace state lock");
1583 state.toggle_events = state.toggle_events.saturating_add(1);
1584 }
1585 }
1586 }
1587
1588 #[test]
1589 fn tree_node_basics() {
1590 let node = TreeNode::new("hello");
1591 assert_eq!(node.label(), "hello");
1592 assert!(node.children().is_empty());
1593 assert!(node.is_expanded());
1594 }
1595
1596 #[test]
1597 fn tree_node_children() {
1598 let root = simple_tree();
1599 assert_eq!(root.children().len(), 2);
1600 assert_eq!(root.children()[0].label(), "a");
1601 assert_eq!(root.children()[0].children().len(), 2);
1602 }
1603
1604 #[test]
1605 fn tree_node_visible_count() {
1606 let root = simple_tree();
1607 assert_eq!(root.visible_count(), 5);
1609 }
1610
1611 #[test]
1612 fn tree_node_collapsed() {
1613 let root = TreeNode::new("root")
1614 .child(
1615 TreeNode::new("a")
1616 .with_expanded(false)
1617 .child(TreeNode::new("a1"))
1618 .child(TreeNode::new("a2")),
1619 )
1620 .child(TreeNode::new("b"));
1621 assert_eq!(root.visible_count(), 3);
1623 }
1624
1625 #[test]
1626 fn tree_node_toggle() {
1627 let mut node = TreeNode::new("x");
1628 assert!(node.is_expanded());
1629 node.toggle_expanded();
1630 assert!(!node.is_expanded());
1631 node.toggle_expanded();
1632 assert!(node.is_expanded());
1633 }
1634
1635 #[test]
1636 fn tree_node_lazy_children_materialize_on_expand() {
1637 let mut node = TreeNode::new("root")
1638 .with_lazy_children(vec![TreeNode::new("child"), TreeNode::new("child2")]);
1639 assert!(!node.is_expanded());
1640 assert_eq!(node.children().len(), 0);
1641 assert!(node.has_children());
1642
1643 node.toggle_expanded();
1644 assert!(node.is_expanded());
1645 assert_eq!(node.children().len(), 2);
1646 }
1647
1648 #[test]
1649 fn tree_guides_unicode() {
1650 let g = TreeGuides::Unicode;
1651 assert!(g.branch().contains('├'));
1652 assert!(g.last().contains('└'));
1653 assert!(g.vertical().contains('│'));
1654 }
1655
1656 #[test]
1657 fn tree_guides_ascii() {
1658 let g = TreeGuides::Ascii;
1659 assert!(g.branch().contains('+'));
1660 assert!(g.vertical().contains('|'));
1661 }
1662
1663 #[test]
1664 fn tree_guides_width() {
1665 for g in [
1666 TreeGuides::Ascii,
1667 TreeGuides::Unicode,
1668 TreeGuides::Bold,
1669 TreeGuides::Double,
1670 TreeGuides::Rounded,
1671 ] {
1672 assert_eq!(g.width(), 4);
1673 }
1674 }
1675
1676 #[test]
1677 fn tree_render_basic() {
1678 let tree = Tree::new(simple_tree());
1679
1680 let mut pool = GraphemePool::new();
1681 let mut frame = Frame::new(40, 10, &mut pool);
1682 let area = Rect::new(0, 0, 40, 10);
1683 tree.render(area, &mut frame);
1684
1685 let cell = frame.buffer.get(0, 0).unwrap();
1687 assert_eq!(cell.content.as_char(), Some('r'));
1688 }
1689
1690 #[test]
1691 fn tree_render_guides_present() {
1692 let tree = Tree::new(simple_tree()).with_guides(TreeGuides::Ascii);
1693
1694 let mut pool = GraphemePool::new();
1695 let mut frame = Frame::new(40, 10, &mut pool);
1696 let area = Rect::new(0, 0, 40, 10);
1697 tree.render(area, &mut frame);
1698
1699 let cell = frame.buffer.get(0, 1).unwrap();
1702 assert_eq!(cell.content.as_char(), Some('+'));
1703 }
1704
1705 #[test]
1706 fn tree_render_last_guide() {
1707 let tree = Tree::new(
1708 TreeNode::new("root")
1709 .child(TreeNode::new("a"))
1710 .child(TreeNode::new("b")),
1711 )
1712 .with_guides(TreeGuides::Ascii);
1713
1714 let mut pool = GraphemePool::new();
1715 let mut frame = Frame::new(40, 10, &mut pool);
1716 let area = Rect::new(0, 0, 40, 10);
1717 tree.render(area, &mut frame);
1718
1719 let cell = frame.buffer.get(0, 1).unwrap();
1721 assert_eq!(cell.content.as_char(), Some('+'));
1722
1723 let cell = frame.buffer.get(0, 2).unwrap();
1725 assert_eq!(cell.content.as_char(), Some('`'));
1726 }
1727
1728 #[test]
1729 fn tree_render_icon_before_label() {
1730 let tree = Tree::new(TreeNode::new("root").with_icon(">"));
1731 let mut pool = GraphemePool::new();
1732 let mut frame = Frame::new(12, 2, &mut pool);
1733 tree.render(Rect::new(0, 0, 12, 2), &mut frame);
1734
1735 assert_eq!(
1736 frame.buffer.get(0, 0).and_then(|c| c.content.as_char()),
1737 Some('>')
1738 );
1739 assert_eq!(
1740 frame.buffer.get(2, 0).and_then(|c| c.content.as_char()),
1741 Some('r')
1742 );
1743 }
1744
1745 #[test]
1746 fn tree_search_query_filters_to_matching_branches() {
1747 let tree = Tree::new(
1748 TreeNode::new("root")
1749 .child(TreeNode::new("alpha").child(TreeNode::new("target-file")))
1750 .child(TreeNode::new("beta")),
1751 )
1752 .with_search_query("target");
1753
1754 let flat = tree.flatten();
1755 assert_eq!(flat.len(), 3);
1756 assert_eq!(flat[0].label, "root");
1757 assert_eq!(flat[1].label, "alpha");
1758 assert_eq!(flat[2].label, "target-file");
1759 }
1760
1761 #[test]
1762 fn tree_search_query_includes_lazy_matching_descendants() {
1763 let tree =
1764 Tree::new(TreeNode::new("root").child(
1765 TreeNode::new("alpha").with_lazy_children(vec![TreeNode::new("target-file")]),
1766 ))
1767 .with_search_query("target");
1768
1769 let flat = tree.flatten();
1770 assert_eq!(flat.len(), 3);
1771 assert_eq!(flat[0].label, "root");
1772 assert_eq!(flat[1].label, "alpha");
1773 assert_eq!(flat[2].label, "target-file");
1774 }
1775
1776 #[test]
1777 fn tree_search_query_on_matching_parent_includes_immediate_lazy_children() {
1778 let tree = Tree::new(TreeNode::new("root").child(
1779 TreeNode::new("alpha").with_lazy_children(vec![
1780 TreeNode::new("lazy-child")
1781 .with_lazy_children(vec![TreeNode::new("deep-grandchild")]),
1782 ]),
1783 ))
1784 .with_search_query("alpha");
1785
1786 let flat = tree.flatten();
1787 assert_eq!(flat.len(), 3);
1788 assert_eq!(flat[0].label, "root");
1789 assert_eq!(flat[1].label, "alpha");
1790 assert_eq!(flat[2].label, "lazy-child");
1791 }
1792
1793 #[test]
1794 fn tree_render_zero_area() {
1795 let tree = Tree::new(simple_tree());
1796 let mut pool = GraphemePool::new();
1797 let mut frame = Frame::new(40, 10, &mut pool);
1798 tree.render(Rect::new(0, 0, 0, 0), &mut frame); }
1800
1801 #[test]
1802 fn tree_render_shorter_label_clears_stale_suffix() {
1803 let mut pool = GraphemePool::new();
1804 let mut frame = Frame::new(20, 3, &mut pool);
1805 let area = Rect::new(0, 0, 20, 3);
1806
1807 Tree::new(TreeNode::new("root-with-long-tail")).render(area, &mut frame);
1808 Tree::new(TreeNode::new("r")).render(area, &mut frame);
1809
1810 assert_eq!(line_text(&frame, 0, 20), "r ");
1811 assert_eq!(line_text(&frame, 1, 20), " ");
1812 assert_eq!(line_text(&frame, 2, 20), " ");
1813 }
1814
1815 #[test]
1816 fn tree_render_truncated_height() {
1817 let tree = Tree::new(simple_tree());
1818 let mut pool = GraphemePool::new();
1819 let mut frame = Frame::new(40, 2, &mut pool);
1820 let area = Rect::new(0, 0, 40, 2);
1821 tree.render(area, &mut frame); }
1823
1824 #[test]
1825 fn is_not_essential() {
1826 let tree = Tree::new(TreeNode::new("x"));
1827 assert!(!tree.is_essential());
1828 }
1829
1830 #[test]
1831 fn tree_root_access() {
1832 let mut tree = Tree::new(TreeNode::new("root"));
1833 assert_eq!(tree.root().label(), "root");
1834 tree.root_mut().toggle_expanded();
1835 assert!(!tree.root().is_expanded());
1836 }
1837
1838 #[test]
1839 fn tree_guides_default() {
1840 let g = TreeGuides::default();
1841 assert_eq!(g, TreeGuides::Unicode);
1842 }
1843
1844 #[test]
1845 fn tree_guides_rounded() {
1846 let g = TreeGuides::Rounded;
1847 assert!(g.last().contains('╰'));
1848 }
1849
1850 #[test]
1851 fn tree_deep_nesting() {
1852 let node = TreeNode::new("d3");
1853 let node = TreeNode::new("d2").child(node);
1854 let node = TreeNode::new("d1").child(node);
1855 let root = TreeNode::new("root").child(node);
1856
1857 let tree = Tree::new(root);
1858 let flat = tree.flatten();
1859 assert_eq!(flat.len(), 4);
1860 assert_eq!(flat[3].depth, 3);
1861 }
1862
1863 #[test]
1864 fn tree_node_with_children_vec() {
1865 let root = TreeNode::new("root").with_children(vec![
1866 TreeNode::new("a"),
1867 TreeNode::new("b"),
1868 TreeNode::new("c"),
1869 ]);
1870 assert_eq!(root.children().len(), 3);
1871 }
1872
1873 use crate::stateful::Stateful;
1876
1877 #[test]
1878 fn tree_with_persistence_id() {
1879 let tree = Tree::new(TreeNode::new("root")).with_persistence_id("file-tree");
1880 assert_eq!(tree.persistence_id(), Some("file-tree"));
1881 }
1882
1883 #[test]
1884 fn tree_default_no_persistence_id() {
1885 let tree = Tree::new(TreeNode::new("root"));
1886 assert_eq!(tree.persistence_id(), None);
1887 }
1888
1889 #[test]
1890 fn tree_save_restore_round_trip() {
1891 let mut tree = Tree::new(
1893 TreeNode::new("root")
1894 .child(
1895 TreeNode::new("src")
1896 .child(TreeNode::new("main.rs"))
1897 .child(TreeNode::new("lib.rs")),
1898 )
1899 .child(TreeNode::new("tests").with_expanded(false)),
1900 )
1901 .with_persistence_id("test");
1902
1903 assert!(tree.root().is_expanded());
1905 assert!(tree.root().children()[0].is_expanded()); assert!(!tree.root().children()[1].is_expanded()); let saved = tree.save_state();
1909
1910 assert!(saved.expanded_paths.contains("root"));
1912 assert!(saved.expanded_paths.contains("root/src"));
1913 assert!(!saved.expanded_paths.contains("root/tests"));
1914
1915 tree.root_mut().children[0].toggle_expanded();
1917 assert!(!tree.root().children()[0].is_expanded());
1918
1919 tree.restore_state(saved);
1921
1922 assert!(tree.root().is_expanded());
1924 assert!(tree.root().children()[0].is_expanded()); assert!(!tree.root().children()[1].is_expanded()); }
1927
1928 #[test]
1929 fn tree_state_key_uses_persistence_id() {
1930 let tree = Tree::new(TreeNode::new("root")).with_persistence_id("project-explorer");
1931 let key = tree.state_key().expect("named tree has a key");
1932 assert_eq!(key.widget_type, "Tree");
1933 assert_eq!(key.instance_id, "project-explorer");
1934 }
1935
1936 #[test]
1937 fn tree_without_id_is_not_persisted() {
1938 assert!(Tree::new(TreeNode::new("root")).state_key().is_none());
1939 }
1940
1941 #[test]
1942 fn tree_persist_state_default() {
1943 let persist = TreePersistState::default();
1944 assert!(persist.expanded_paths.is_empty());
1945 }
1946
1947 #[test]
1948 fn tree_collect_expanded_only_includes_nodes_with_children() {
1949 let tree = Tree::new(
1950 TreeNode::new("root").child(TreeNode::new("leaf")), );
1952
1953 let saved = tree.save_state();
1954
1955 assert!(saved.expanded_paths.contains("root"));
1957 assert!(!saved.expanded_paths.contains("root/leaf"));
1959 }
1960
1961 #[test]
1966 fn tree_undo_widget_id_unique() {
1967 let tree1 = Tree::new(TreeNode::new("root1"));
1968 let tree2 = Tree::new(TreeNode::new("root2"));
1969 assert_ne!(tree1.undo_id(), tree2.undo_id());
1970 }
1971
1972 #[test]
1973 fn tree_undo_snapshot_and_restore() {
1974 let mut tree = Tree::new(
1976 TreeNode::new("root")
1977 .child(
1978 TreeNode::new("a")
1979 .with_expanded(true)
1980 .child(TreeNode::new("a_child")),
1981 )
1982 .child(
1983 TreeNode::new("b")
1984 .with_expanded(false)
1985 .child(TreeNode::new("b_child")),
1986 ),
1987 );
1988
1989 let snapshot = tree.create_snapshot();
1991
1992 assert!(tree.is_node_expanded(&[0])); assert!(!tree.is_node_expanded(&[1])); tree.collapse_node(&[0]); tree.expand_node(&[1]); assert!(!tree.is_node_expanded(&[0]));
2000 assert!(tree.is_node_expanded(&[1]));
2001
2002 assert!(tree.restore_snapshot(&*snapshot));
2004
2005 assert!(tree.is_node_expanded(&[0])); assert!(!tree.is_node_expanded(&[1])); }
2009
2010 #[test]
2011 fn tree_expand_collapse_node() {
2012 let mut tree =
2013 Tree::new(TreeNode::new("root").child(TreeNode::new("child").with_expanded(true)));
2014
2015 assert!(tree.is_node_expanded(&[0]));
2017
2018 tree.collapse_node(&[0]);
2020 assert!(!tree.is_node_expanded(&[0]));
2021
2022 tree.expand_node(&[0]);
2024 assert!(tree.is_node_expanded(&[0]));
2025 }
2026
2027 #[test]
2028 fn tree_node_path_navigation() {
2029 let tree = Tree::new(
2030 TreeNode::new("root")
2031 .child(
2032 TreeNode::new("a")
2033 .child(TreeNode::new("a1"))
2034 .child(TreeNode::new("a2")),
2035 )
2036 .child(TreeNode::new("b")),
2037 );
2038
2039 assert_eq!(tree.get_node_at_path(&[]).map(|n| n.label()), Some("root"));
2041 assert_eq!(tree.get_node_at_path(&[0]).map(|n| n.label()), Some("a"));
2042 assert_eq!(tree.get_node_at_path(&[1]).map(|n| n.label()), Some("b"));
2043 assert_eq!(
2044 tree.get_node_at_path(&[0, 0]).map(|n| n.label()),
2045 Some("a1")
2046 );
2047 assert_eq!(
2048 tree.get_node_at_path(&[0, 1]).map(|n| n.label()),
2049 Some("a2")
2050 );
2051 assert!(tree.get_node_at_path(&[5]).is_none()); }
2053
2054 #[test]
2055 fn tree_restore_wrong_snapshot_type_fails() {
2056 use std::any::Any;
2057 let mut tree = Tree::new(TreeNode::new("root"));
2058 let wrong_snapshot: Box<dyn Any + Send> = Box::new(42i32);
2059 assert!(!tree.restore_snapshot(&*wrong_snapshot));
2060 }
2061
2062 use crate::mouse::MouseResult;
2065 use ftui_core::event::{KeyCode, KeyEvent, MouseButton, MouseEvent, MouseEventKind};
2066
2067 #[test]
2068 fn tree_click_expands_parent() {
2069 let mut tree = Tree::new(
2070 TreeNode::new("root")
2071 .child(
2072 TreeNode::new("a")
2073 .child(TreeNode::new("a1"))
2074 .child(TreeNode::new("a2")),
2075 )
2076 .child(TreeNode::new("b")),
2077 );
2078 assert!(tree.root().children()[0].is_expanded());
2079
2080 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 1);
2082 let hit = Some((HitId::new(1), HitRegion::Content, 1u64));
2083 let result = tree.handle_mouse(&event, hit, HitId::new(1));
2084 assert_eq!(result, MouseResult::Activated(1));
2085 assert!(!tree.root().children()[0].is_expanded()); }
2087
2088 #[test]
2089 fn tree_click_selects_leaf() {
2090 let mut tree = Tree::new(
2091 TreeNode::new("root")
2092 .child(
2093 TreeNode::new("a")
2094 .child(TreeNode::new("a1"))
2095 .child(TreeNode::new("a2")),
2096 )
2097 .child(TreeNode::new("b")),
2098 );
2099
2100 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 4);
2102 let hit = Some((HitId::new(1), HitRegion::Content, 4u64));
2103 let result = tree.handle_mouse(&event, hit, HitId::new(1));
2104 assert_eq!(result, MouseResult::Selected(4));
2105 }
2106
2107 #[test]
2108 fn tree_click_wrong_id_ignored() {
2109 let mut tree = Tree::new(TreeNode::new("root").child(TreeNode::new("a")));
2110 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
2111 let hit = Some((HitId::new(99), HitRegion::Content, 0u64));
2112 let result = tree.handle_mouse(&event, hit, HitId::new(1));
2113 assert_eq!(result, MouseResult::Ignored);
2114 }
2115
2116 #[test]
2117 fn tree_click_no_hit_ignored() {
2118 let mut tree = Tree::new(TreeNode::new("root"));
2119 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
2120 let result = tree.handle_mouse(&event, None, HitId::new(1));
2121 assert_eq!(result, MouseResult::Ignored);
2122 }
2123
2124 #[test]
2125 fn tree_right_click_ignored() {
2126 let mut tree = Tree::new(TreeNode::new("root").child(TreeNode::new("a")));
2127 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Right), 0, 0);
2128 let hit = Some((HitId::new(1), HitRegion::Content, 0u64));
2129 let result = tree.handle_mouse(&event, hit, HitId::new(1));
2130 assert_eq!(result, MouseResult::Ignored);
2131 }
2132
2133 #[test]
2134 fn tree_node_at_visible_index_with_show_root() {
2135 let mut tree = Tree::new(
2136 TreeNode::new("root")
2137 .child(
2138 TreeNode::new("a")
2139 .child(TreeNode::new("a1"))
2140 .child(TreeNode::new("a2")),
2141 )
2142 .child(TreeNode::new("b")),
2143 );
2144
2145 assert_eq!(
2147 tree.node_at_visible_index_mut(0)
2148 .map(|n| n.label().to_string()),
2149 Some("root".to_string())
2150 );
2151 assert_eq!(
2152 tree.node_at_visible_index_mut(1)
2153 .map(|n| n.label().to_string()),
2154 Some("a".to_string())
2155 );
2156 assert_eq!(
2157 tree.node_at_visible_index_mut(2)
2158 .map(|n| n.label().to_string()),
2159 Some("a1".to_string())
2160 );
2161 assert_eq!(
2162 tree.node_at_visible_index_mut(3)
2163 .map(|n| n.label().to_string()),
2164 Some("a2".to_string())
2165 );
2166 assert_eq!(
2167 tree.node_at_visible_index_mut(4)
2168 .map(|n| n.label().to_string()),
2169 Some("b".to_string())
2170 );
2171 assert!(tree.node_at_visible_index_mut(5).is_none());
2172 }
2173
2174 #[test]
2175 fn tree_node_at_visible_index_hidden_root() {
2176 let mut tree = Tree::new(
2177 TreeNode::new("root")
2178 .child(TreeNode::new("a").child(TreeNode::new("a1")))
2179 .child(TreeNode::new("b")),
2180 )
2181 .with_show_root(false);
2182
2183 assert_eq!(
2185 tree.node_at_visible_index_mut(0)
2186 .map(|n| n.label().to_string()),
2187 Some("a".to_string())
2188 );
2189 assert_eq!(
2190 tree.node_at_visible_index_mut(1)
2191 .map(|n| n.label().to_string()),
2192 Some("a1".to_string())
2193 );
2194 assert_eq!(
2195 tree.node_at_visible_index_mut(2)
2196 .map(|n| n.label().to_string()),
2197 Some("b".to_string())
2198 );
2199 assert!(tree.node_at_visible_index_mut(3).is_none());
2200 }
2201
2202 #[test]
2203 fn tree_node_at_visible_index_collapsed() {
2204 let mut tree = Tree::new(
2205 TreeNode::new("root")
2206 .child(
2207 TreeNode::new("a")
2208 .with_expanded(false)
2209 .child(TreeNode::new("a1"))
2210 .child(TreeNode::new("a2")),
2211 )
2212 .child(TreeNode::new("b")),
2213 );
2214
2215 assert_eq!(
2217 tree.node_at_visible_index_mut(0)
2218 .map(|n| n.label().to_string()),
2219 Some("root".to_string())
2220 );
2221 assert_eq!(
2222 tree.node_at_visible_index_mut(1)
2223 .map(|n| n.label().to_string()),
2224 Some("a".to_string())
2225 );
2226 assert_eq!(
2227 tree.node_at_visible_index_mut(2)
2228 .map(|n| n.label().to_string()),
2229 Some("b".to_string())
2230 );
2231 assert!(tree.node_at_visible_index_mut(3).is_none());
2232 }
2233
2234 #[test]
2235 fn tree_click_toggles_collapsed_node() {
2236 let mut tree = Tree::new(
2237 TreeNode::new("root")
2238 .child(
2239 TreeNode::new("a")
2240 .with_expanded(false)
2241 .child(TreeNode::new("a1")),
2242 )
2243 .child(TreeNode::new("b")),
2244 );
2245 assert!(!tree.root().children()[0].is_expanded());
2246
2247 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 1);
2249 let hit = Some((HitId::new(1), HitRegion::Content, 1u64));
2250 let result = tree.handle_mouse(&event, hit, HitId::new(1));
2251 assert_eq!(result, MouseResult::Activated(1));
2252 assert!(tree.root().children()[0].is_expanded()); }
2254
2255 #[test]
2256 fn tree_handle_key_enter_toggles_parent() {
2257 let mut tree = Tree::new(
2258 TreeNode::new("root")
2259 .child(TreeNode::new("a").child(TreeNode::new("a1")))
2260 .child(TreeNode::new("b")),
2261 );
2262
2263 assert!(tree.root().children()[0].is_expanded());
2265 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Enter), 1));
2266 assert!(!tree.root().children()[0].is_expanded());
2267 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Char(' ')), 1));
2268 assert!(tree.root().children()[0].is_expanded());
2269 }
2270
2271 #[test]
2272 fn tree_handle_key_ignores_key_release() {
2273 let mut tree = Tree::new(
2276 TreeNode::new("root")
2277 .child(TreeNode::new("a").child(TreeNode::new("a1")))
2278 .child(TreeNode::new("b")),
2279 );
2280 let enter = KeyEvent::new(KeyCode::Enter);
2281 assert!(tree.handle_key(&enter, 1));
2282 assert!(!tree.handle_key(&enter.with_kind(KeyEventKind::Release), 1));
2283 assert!(!tree.root().children()[0].is_expanded());
2284 }
2285
2286 #[test]
2291 fn tree_handle_key_right_expands_collapsed_node() {
2292 let mut tree = Tree::new(
2293 TreeNode::new("root")
2294 .child(
2295 TreeNode::new("a")
2296 .with_expanded(false)
2297 .child(TreeNode::new("a1")),
2298 )
2299 .child(TreeNode::new("b")),
2300 );
2301 assert!(!tree.root().children()[0].is_expanded());
2302
2303 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Right), 1));
2305 assert!(tree.root().children()[0].is_expanded());
2306 }
2307
2308 #[test]
2309 fn tree_handle_key_right_on_expanded_node_is_noop() {
2310 let mut tree = Tree::new(
2311 TreeNode::new("root")
2312 .child(TreeNode::new("a").child(TreeNode::new("a1")))
2313 .child(TreeNode::new("b")),
2314 );
2315 assert!(tree.root().children()[0].is_expanded());
2316
2317 assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Right), 1));
2319 assert!(tree.root().children()[0].is_expanded());
2320 }
2321
2322 #[test]
2323 fn tree_handle_key_right_on_leaf_is_noop() {
2324 let mut tree = Tree::new(
2325 TreeNode::new("root")
2326 .child(TreeNode::new("a").child(TreeNode::new("a1")))
2327 .child(TreeNode::new("b")),
2328 );
2329
2330 assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Right), 3));
2332 }
2333
2334 #[test]
2335 fn tree_handle_key_left_collapses_expanded_node() {
2336 let mut tree = Tree::new(
2337 TreeNode::new("root")
2338 .child(TreeNode::new("a").child(TreeNode::new("a1")))
2339 .child(TreeNode::new("b")),
2340 );
2341 assert!(tree.root().children()[0].is_expanded());
2342
2343 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2345 assert!(!tree.root().children()[0].is_expanded());
2346 }
2347
2348 #[test]
2349 fn tree_handle_key_left_on_collapsed_node_is_noop() {
2350 let mut tree = Tree::new(
2351 TreeNode::new("root")
2352 .child(
2353 TreeNode::new("a")
2354 .with_expanded(false)
2355 .child(TreeNode::new("a1")),
2356 )
2357 .child(TreeNode::new("b")),
2358 );
2359 assert!(!tree.root().children()[0].is_expanded());
2360
2361 assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2363 assert!(!tree.root().children()[0].is_expanded());
2364 }
2365
2366 #[test]
2367 fn tree_handle_key_left_on_leaf_is_noop() {
2368 let mut tree = Tree::new(
2369 TreeNode::new("root")
2370 .child(TreeNode::new("a").child(TreeNode::new("a1")))
2371 .child(TreeNode::new("b")),
2372 );
2373
2374 assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Left), 3));
2376 }
2377
2378 #[test]
2379 fn tree_handle_key_left_right_round_trip() {
2380 let mut tree = Tree::new(
2381 TreeNode::new("root")
2382 .child(TreeNode::new("a").child(TreeNode::new("a1")))
2383 .child(TreeNode::new("b")),
2384 );
2385
2386 assert!(tree.root().children()[0].is_expanded());
2388 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2389 assert!(!tree.root().children()[0].is_expanded());
2390
2391 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Right), 1));
2393 assert!(tree.root().children()[0].is_expanded());
2394 }
2395
2396 #[test]
2397 fn tree_handle_key_unhandled_keys_return_false() {
2398 let mut tree = Tree::new(
2399 TreeNode::new("root")
2400 .child(TreeNode::new("a").child(TreeNode::new("a1")))
2401 .child(TreeNode::new("b")),
2402 );
2403
2404 assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Up), 1));
2406 assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Down), 1));
2407 assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Tab), 1));
2408 assert!(!tree.handle_key(&KeyEvent::new(KeyCode::Escape), 1));
2409 }
2410
2411 #[test]
2412 fn tree_visible_index_navigation_after_collapse() {
2413 let mut tree = Tree::new(
2414 TreeNode::new("root")
2415 .child(
2416 TreeNode::new("a")
2417 .child(TreeNode::new("a1"))
2418 .child(TreeNode::new("a2")),
2419 )
2420 .child(TreeNode::new("b")),
2421 );
2422
2423 assert_eq!(
2425 tree.node_at_visible_index_mut(4)
2426 .map(|n| n.label().to_string()),
2427 Some("b".to_string())
2428 );
2429
2430 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2432
2433 assert_eq!(
2435 tree.node_at_visible_index_mut(2)
2436 .map(|n| n.label().to_string()),
2437 Some("b".to_string())
2438 );
2439 assert!(tree.node_at_visible_index_mut(3).is_none());
2440 }
2441
2442 #[test]
2447 fn tree_lazy_children_materialized_visible_count() {
2448 let mut node = TreeNode::new("root").with_lazy_children(vec![
2449 TreeNode::new("child1").child(TreeNode::new("grandchild")),
2450 TreeNode::new("child2"),
2451 ]);
2452
2453 assert_eq!(node.visible_count(), 1);
2455
2456 node.toggle_expanded();
2458 assert_eq!(node.visible_count(), 4);
2460 }
2461
2462 #[test]
2463 fn tree_lazy_children_second_toggle_collapses() {
2464 let mut node = TreeNode::new("root")
2465 .with_lazy_children(vec![TreeNode::new("child1"), TreeNode::new("child2")]);
2466
2467 node.toggle_expanded();
2469 assert!(node.is_expanded());
2470 assert_eq!(node.children().len(), 2);
2471
2472 node.toggle_expanded();
2474 assert!(!node.is_expanded());
2475 assert_eq!(node.children().len(), 2); assert_eq!(node.visible_count(), 1); }
2478
2479 #[test]
2480 fn tree_lazy_children_with_right_key() {
2481 let mut tree = Tree::new(TreeNode::new("root").child(
2482 TreeNode::new("lazy-parent").with_lazy_children(vec![TreeNode::new("lazy-child")]),
2483 ));
2484
2485 assert!(!tree.root().children()[0].is_expanded());
2487 assert!(tree.root().children()[0].has_children());
2488
2489 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Right), 1));
2491 assert!(tree.root().children()[0].is_expanded());
2492 assert_eq!(tree.root().children()[0].children().len(), 1);
2493 assert_eq!(
2494 tree.root().children()[0].children()[0].label(),
2495 "lazy-child"
2496 );
2497 }
2498
2499 #[test]
2504 fn tree_search_case_insensitive() {
2505 let tree = Tree::new(
2506 TreeNode::new("root")
2507 .child(TreeNode::new("Alpha"))
2508 .child(TreeNode::new("Beta")),
2509 )
2510 .with_search_query("alpha");
2511
2512 let flat = tree.flatten();
2513 assert_eq!(flat.len(), 2); assert_eq!(flat[1].label, "Alpha");
2515 }
2516
2517 #[test]
2518 fn tree_search_no_match_returns_empty() {
2519 let tree = Tree::new(
2520 TreeNode::new("root")
2521 .child(TreeNode::new("Alpha"))
2522 .child(TreeNode::new("Beta")),
2523 )
2524 .with_search_query("zzz-no-match");
2525
2526 let flat = tree.flatten();
2527 assert_eq!(flat.len(), 0);
2530 }
2531
2532 #[test]
2533 fn tree_search_no_match_clears_stale_rows() {
2534 let base_tree = Tree::new(
2535 TreeNode::new("root")
2536 .child(TreeNode::new("Alpha"))
2537 .child(TreeNode::new("Beta")),
2538 );
2539 let filtered_tree = Tree::new(
2540 TreeNode::new("root")
2541 .child(TreeNode::new("Alpha"))
2542 .child(TreeNode::new("Beta")),
2543 )
2544 .with_search_query("zzz-no-match");
2545
2546 let mut pool = GraphemePool::new();
2547 let mut frame = Frame::new(20, 4, &mut pool);
2548 let area = Rect::new(0, 0, 20, 4);
2549
2550 base_tree.render(area, &mut frame);
2551 filtered_tree.render(area, &mut frame);
2552
2553 assert_eq!(line_text(&frame, 0, 20), " ");
2554 assert_eq!(line_text(&frame, 1, 20), " ");
2555 assert_eq!(line_text(&frame, 2, 20), " ");
2556 assert_eq!(line_text(&frame, 3, 20), " ");
2557 }
2558
2559 #[test]
2560 fn tree_search_cleared() {
2561 let tree = Tree::new(
2562 TreeNode::new("root")
2563 .child(TreeNode::new("Alpha"))
2564 .child(TreeNode::new("Beta")),
2565 )
2566 .with_search_query("alpha")
2567 .without_search_query();
2568
2569 let flat = tree.flatten();
2570 assert_eq!(flat.len(), 3); }
2572
2573 #[test]
2578 fn tree_expand_deep_nesting() {
2579 let mut tree = Tree::new(
2580 TreeNode::new("root").child(
2581 TreeNode::new("d1").with_expanded(false).child(
2582 TreeNode::new("d2")
2583 .with_expanded(false)
2584 .child(TreeNode::new("d3")),
2585 ),
2586 ),
2587 );
2588
2589 assert_eq!(tree.root().visible_count(), 2);
2591
2592 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Right), 1));
2594 assert_eq!(tree.root().visible_count(), 3);
2596
2597 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Right), 2));
2599 assert_eq!(tree.root().visible_count(), 4);
2601 }
2602
2603 #[test]
2604 fn tree_collapse_parent_hides_all_descendants() {
2605 let mut tree = Tree::new(
2606 TreeNode::new("root")
2607 .child(
2608 TreeNode::new("a")
2609 .child(TreeNode::new("a1").child(TreeNode::new("a1x")))
2610 .child(TreeNode::new("a2")),
2611 )
2612 .child(TreeNode::new("b")),
2613 );
2614
2615 assert_eq!(tree.root().visible_count(), 6);
2617
2618 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2620 assert_eq!(tree.root().visible_count(), 3);
2622 }
2623
2624 #[cfg(feature = "tracing")]
2625 #[test]
2626 fn tree_tracing_span_and_toggle_events_are_emitted() {
2627 let trace_state = Arc::new(Mutex::new(TreeTraceState::default()));
2628 let _trace_test_guard = crate::tracing_test_support::acquire();
2629 let subscriber = tracing_subscriber::registry().with(TreeTraceCapture {
2630 state: Arc::clone(&trace_state),
2631 });
2632 let _guard = tracing::subscriber::set_default(subscriber);
2633 tracing::callsite::rebuild_interest_cache();
2634
2635 let mut tree = Tree::new(
2636 TreeNode::new("root")
2637 .child(TreeNode::new("a").child(TreeNode::new("a1")))
2638 .child(TreeNode::new("b")),
2639 );
2640 let mut pool = GraphemePool::new();
2641 let mut frame = Frame::new(20, 6, &mut pool);
2642 tracing::callsite::rebuild_interest_cache();
2643 tree.render(Rect::new(0, 0, 20, 6), &mut frame);
2644 tracing::callsite::rebuild_interest_cache();
2645 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Enter), 1));
2646
2647 tracing::callsite::rebuild_interest_cache();
2648 let snapshot = trace_state.lock().expect("tree trace state lock");
2649 assert!(snapshot.tree_render_seen, "expected tree.render span");
2650 assert!(
2651 snapshot.has_total_nodes_field,
2652 "tree.render missing total_nodes"
2653 );
2654 assert!(
2655 snapshot.has_visible_nodes_field,
2656 "tree.render missing visible_nodes"
2657 );
2658 assert!(
2659 snapshot.has_expanded_count_field,
2660 "tree.render missing expanded_count"
2661 );
2662 assert!(
2663 snapshot.render_duration_recorded,
2664 "tree.render did not record render_duration_us"
2665 );
2666 assert!(
2667 snapshot.toggle_events >= 1,
2668 "expected tree.toggle debug event"
2669 );
2670 }
2671
2672 #[test]
2673 fn tree_accessibility_emits_nested_hierarchy_and_states() {
2674 use ftui_a11y::node::A11yRole;
2675 use ftui_a11y::tree::A11yTreeBuilder;
2676
2677 let root_id = 0x72EE_0000_0000_0001;
2678 let root_node = TreeNode::new("workspace")
2679 .child(
2680 TreeNode::new("src").child(TreeNode::new("main.rs")).child(
2681 TreeNode::new("nested_collapsed")
2682 .with_expanded(false)
2683 .child(TreeNode::new("hidden.rs")),
2684 ),
2685 )
2686 .child(TreeNode::new("README.md"));
2687
2688 let tree_widget = Tree::new(root_node)
2689 .with_accessibility_id(root_id)
2690 .with_selected_visible_index(Some(2))
2691 .with_focused(true);
2692
2693 let mut pool = GraphemePool::new();
2694 let mut builder = A11yTreeBuilder::new();
2695 let area = Rect::new(0, 0, 40, 10);
2696 {
2697 let mut frame = Frame::new(40, 10, &mut pool);
2698 frame.set_a11y(&mut builder);
2699 tree_widget.render(area, &mut frame);
2700 frame.finish_a11y();
2701 }
2702 let a11y_tree = builder.build();
2703
2704 assert_eq!(a11y_tree.node_count(), 6);
2706
2707 let list_container = a11y_tree.node(root_id).expect("tree container node");
2708 assert_eq!(list_container.role, A11yRole::List);
2709 assert_eq!(list_container.name.as_deref(), Some("workspace"));
2710 assert_eq!(
2711 list_container.description.as_deref(),
2712 Some("5 visible items")
2713 );
2714
2715 let ws_id = Tree::accessibility_item_id(root_id, &[]);
2716 let src_id = Tree::accessibility_item_id(root_id, &[0]);
2717 let main_id = Tree::accessibility_item_id(root_id, &[0, 0]);
2718 let collapsed_id = Tree::accessibility_item_id(root_id, &[0, 1]);
2719 let readme_id = Tree::accessibility_item_id(root_id, &[1]);
2720
2721 let ws_node = a11y_tree.node(ws_id).expect("workspace item");
2722 assert_eq!(ws_node.parent, Some(root_id));
2723 assert_eq!(ws_node.state.expanded, Some(true));
2724 assert_eq!(ws_node.children, vec![src_id, readme_id]);
2725
2726 let src_node = a11y_tree.node(src_id).expect("src item");
2727 assert_eq!(src_node.parent, Some(ws_id));
2728 assert_eq!(src_node.state.expanded, Some(true));
2729 assert_eq!(src_node.children, vec![main_id, collapsed_id]);
2730
2731 let main_node = a11y_tree.node(main_id).expect("main.rs item");
2732 assert_eq!(main_node.parent, Some(src_id));
2733 assert_eq!(main_node.state.expanded, None);
2734 assert!(main_node.state.selected);
2735 assert!(main_node.state.focused);
2736 assert_eq!(a11y_tree.focused().map(|n| n.id), Some(main_id));
2737
2738 let collapsed_node = a11y_tree.node(collapsed_id).expect("collapsed dir item");
2739 assert_eq!(collapsed_node.parent, Some(src_id));
2740 assert_eq!(collapsed_node.state.expanded, Some(false));
2741 assert!(collapsed_node.children.is_empty());
2742
2743 let readme_node = a11y_tree.node(readme_id).expect("README.md item");
2744 assert_eq!(readme_node.parent, Some(ws_id));
2745 assert_eq!(readme_node.state.expanded, None);
2746 }
2747
2748 #[test]
2749 fn tree_accessibility_canonical_path_ids_survive_sibling_collapse_and_search() {
2750 use ftui_a11y::tree::A11yTreeBuilder;
2751
2752 let root_id = 0x72EE_0000_0000_0002;
2753 let make_root = || {
2754 TreeNode::new("root")
2755 .child(
2756 TreeNode::new("alpha")
2757 .child(TreeNode::new("alpha_one"))
2758 .child(TreeNode::new("alpha_two")),
2759 )
2760 .child(TreeNode::new("beta").child(TreeNode::new("beta_target")))
2761 };
2762
2763 let render_a11y = |tree: &Tree| {
2764 let mut pool = GraphemePool::new();
2765 let mut builder = A11yTreeBuilder::new();
2766 let mut frame = Frame::new(40, 10, &mut pool);
2767 frame.set_a11y(&mut builder);
2768 tree.render(Rect::new(0, 0, 40, 10), &mut frame);
2769 frame.finish_a11y();
2770 builder.build()
2771 };
2772
2773 let mut tree = Tree::new(make_root()).with_accessibility_id(root_id);
2774 let expanded_a11y = render_a11y(&tree);
2775 let beta_id = Tree::accessibility_item_id(root_id, &[1]);
2776 let beta_target_id = Tree::accessibility_item_id(root_id, &[1, 0]);
2777 assert!(expanded_a11y.node(beta_id).is_some());
2778 assert!(expanded_a11y.node(beta_target_id).is_some());
2779
2780 assert!(tree.handle_key(&KeyEvent::new(KeyCode::Left), 1));
2783 let collapsed_a11y = render_a11y(&tree);
2784 let beta_after_collapse = collapsed_a11y
2785 .node(beta_id)
2786 .expect("beta retains canonical ID after sibling collapse");
2787 assert_eq!(beta_after_collapse.name.as_deref(), Some("beta"));
2788 assert!(collapsed_a11y.node(beta_target_id).is_some());
2789
2790 let filtered_tree = Tree::new(make_root())
2793 .with_accessibility_id(root_id)
2794 .with_search_query("beta_target");
2795 let filtered_a11y = render_a11y(&filtered_tree);
2796 assert!(filtered_a11y.node(beta_id).is_some());
2797 let target_node = filtered_a11y
2798 .node(beta_target_id)
2799 .expect("filtered target keeps canonical path ID");
2800 assert_eq!(target_node.parent, Some(beta_id));
2801 }
2802
2803 #[test]
2804 fn tree_accessibility_focus_sync_delegates_to_selected_descendant() {
2805 use crate::focus::{FocusManager, FocusNode};
2806 use ftui_a11y::tree::A11yTreeBuilder;
2807
2808 let root_id = 0x72EE_0000_0000_0003;
2809 let tree_widget = Tree::new(simple_tree())
2810 .with_accessibility_id(root_id)
2811 .with_selected_visible_index(Some(3)) .with_focused(false); let mut fm = FocusManager::new();
2815 fm.graph_mut()
2816 .insert(FocusNode::new(root_id, Rect::new(0, 0, 40, 10)).with_tab_index(0));
2817 let _ = fm.focus(root_id);
2818 assert_eq!(fm.current(), Some(root_id));
2819
2820 let mut pool = GraphemePool::new();
2821 let mut builder = A11yTreeBuilder::new();
2822 {
2823 let mut frame = Frame::new(40, 10, &mut pool);
2824 frame.set_a11y(&mut builder);
2825 fm.sync_to_frame(&mut frame);
2826 tree_widget.render(Rect::new(0, 0, 40, 10), &mut frame);
2827 frame.finish_a11y();
2828 }
2829 let a11y_tree = builder.build();
2830 let expected_item_id = Tree::accessibility_item_id(root_id, &[0, 1]);
2831 assert_eq!(a11y_tree.focused().map(|n| n.id), Some(expected_item_id));
2832 assert!(
2833 a11y_tree
2834 .node(expected_item_id)
2835 .expect("a2 node")
2836 .state
2837 .focused
2838 );
2839 }
2840
2841 #[test]
2842 fn tree_accessible_trait_matches_rendered_nodes() {
2843 use ftui_a11y::Accessible;
2844
2845 let tree_widget = Tree::new(simple_tree())
2846 .with_accessibility_id(0x72EE_0000_0000_0004)
2847 .with_selected_visible_index(Some(1))
2848 .with_focused(true);
2849 let nodes = tree_widget.accessibility_nodes(Rect::new(0, 0, 40, 10));
2850 assert_eq!(nodes.len(), 6);
2852 assert_eq!(nodes[0].name.as_deref(), Some("root"));
2853 assert_eq!(nodes[2].name.as_deref(), Some("a"));
2854 assert!(nodes[2].state.selected);
2855 assert!(nodes[2].state.focused);
2856 }
2857}