1use std::cell::RefCell;
47use std::collections::HashSet;
48use std::hash::Hash;
49use std::ops::Range;
50use std::rc::Rc;
51
52use teksilo_core::ObserverHandle;
53
54use crate::data_change::DataChange;
55use crate::dnd_types::{
56 DragEligibility, DragSource, DropCommit, DropPosition, DropQuery, DropResponse,
57};
58use crate::list_data_source::ListDataSource;
59
60struct ObserverEntry {
61 id: u64,
62 callback: Rc<dyn Fn(&DataChange)>,
63}
64
65struct ListModelInner<T> {
66 items: Vec<T>,
67 observers: Vec<ObserverEntry>,
68 next_observer_id: u64,
69 #[cfg(debug_assertions)]
75 debug_adapter: Option<Rc<dyn crate::debug_registry::ModelDebug>>,
76}
77
78pub struct ListModel<T: 'static> {
87 inner: Rc<RefCell<ListModelInner<T>>>,
88}
89
90impl<T: 'static> ListModel<T> {
91 pub fn new() -> Self {
93 Self {
94 inner: Rc::new(RefCell::new(ListModelInner {
95 items: Vec::new(),
96 observers: Vec::new(),
97 next_observer_id: 1,
98 #[cfg(debug_assertions)]
99 debug_adapter: None,
100 })),
101 }
102 }
103
104 pub fn from_vec(items: Vec<T>) -> Self {
106 Self {
107 inner: Rc::new(RefCell::new(ListModelInner {
108 items,
109 observers: Vec::new(),
110 next_observer_id: 1,
111 #[cfg(debug_assertions)]
112 debug_adapter: None,
113 })),
114 }
115 }
116
117 pub fn len(&self) -> usize {
119 self.inner.borrow().items.len()
120 }
121
122 pub fn is_empty(&self) -> bool {
124 self.inner.borrow().items.is_empty()
125 }
126
127 pub fn with_item<R>(&self, index: usize, f: impl FnOnce(&T) -> R) -> Option<R> {
132 let guard = self.inner.borrow();
133 guard.items.get(index).map(f)
134 }
135
136 pub fn push(&self, item: T) {
138 let index = {
139 let mut guard = self.inner.borrow_mut();
140 let index = guard.items.len();
141 guard.items.push(item);
142 index
143 };
144 self.notify(DataChange::ItemsInserted {
145 range: index..index + 1,
146 });
147 }
148
149 pub fn insert(&self, index: usize, item: T) {
154 {
155 let mut guard = self.inner.borrow_mut();
156 guard.items.insert(index, item);
157 }
158 self.notify(DataChange::ItemsInserted {
159 range: index..index + 1,
160 });
161 }
162
163 pub fn remove(&self, index: usize) -> T {
168 let item = {
169 let mut guard = self.inner.borrow_mut();
170 guard.items.remove(index)
171 };
172 self.notify(DataChange::ItemsRemoved {
173 range: index..index + 1,
174 });
175 item
176 }
177
178 pub fn set(&self, index: usize, item: T) {
183 {
184 let mut guard = self.inner.borrow_mut();
185 guard.items[index] = item;
186 }
187 self.notify(DataChange::ItemUpdated { index });
188 }
189
190 pub fn move_item(&self, from: usize, to: usize) {
197 if from == to {
198 return;
199 }
200 {
201 let mut guard = self.inner.borrow_mut();
202 let item = guard.items.remove(from);
203 guard.items.insert(to, item);
204 }
205 self.notify(DataChange::ItemsMoved { from, to, count: 1 });
206 }
207
208 pub fn move_items(&self, indices: &[usize], insert_gap: usize) -> bool {
222 let len = self.len();
223 let mut idx: Vec<usize> = indices.iter().copied().filter(|&i| i < len).collect();
224 idx.sort_unstable();
225 idx.dedup();
226 if idx.is_empty() {
227 return false;
228 }
229 let contiguous = idx.windows(2).all(|w| w[1] == w[0] + 1);
230 let from0 = idx[0];
231 let count = idx.len();
232 let at;
233 {
234 let mut guard = self.inner.borrow_mut();
235 let mut block: Vec<T> = idx.iter().rev().map(|&i| guard.items.remove(i)).collect();
238 block.reverse();
239 let removed_before = idx.iter().filter(|&&i| i < insert_gap).count();
240 at = insert_gap
241 .saturating_sub(removed_before)
242 .min(guard.items.len());
243 for (off, item) in block.into_iter().enumerate() {
244 guard.items.insert(at + off, item);
245 }
246 }
247 if contiguous && from0 != at {
248 self.notify(DataChange::ItemsMoved {
249 from: from0,
250 to: at,
251 count,
252 });
253 } else if contiguous {
254 } else {
256 self.notify(DataChange::Reset);
257 }
258 true
259 }
260
261 pub fn replace_all(&self, items: Vec<T>) {
263 {
264 let mut guard = self.inner.borrow_mut();
265 guard.items = items;
266 }
267 self.notify(DataChange::Reset);
268 }
269
270 pub fn clear(&self) {
272 {
273 let mut guard = self.inner.borrow_mut();
274 guard.items.clear();
275 }
276 self.notify(DataChange::Reset);
277 }
278
279 pub fn observe_changes(&self, f: impl Fn(&DataChange) + 'static) -> ObserverHandle {
282 let mut guard = self.inner.borrow_mut();
283 let id = guard.next_observer_id;
284 guard.next_observer_id += 1;
285 guard.observers.push(ObserverEntry {
286 id,
287 callback: Rc::new(f),
288 });
289 let inner = self.inner.clone();
290 ObserverHandle::new(
291 self.inner.clone(),
292 id,
293 Rc::new(move |observer_id| {
294 let removed = {
297 let mut guard = inner.borrow_mut();
298 let index = guard.observers.iter().position(|e| e.id == observer_id);
299 index.map(|i| guard.observers.remove(i))
300 };
301 drop(removed);
302 }),
303 )
304 }
305
306 fn notify(&self, change: DataChange) {
307 let callbacks: Vec<Rc<dyn Fn(&DataChange)>> = self
308 .inner
309 .borrow()
310 .observers
311 .iter()
312 .map(|e| e.callback.clone())
313 .collect();
314 for cb in &callbacks {
315 cb(&change);
316 }
317 }
318}
319
320impl<T: PartialEq + 'static> ListModel<T> {
321 pub fn reconcile_by_key<K: Eq + Hash>(&self, new_items: Vec<T>, key_fn: impl Fn(&T) -> K) {
403 let mut changes: Vec<DataChange> = Vec::new();
404 {
405 let mut guard = self.inner.borrow_mut();
406 reconcile_vec(&mut guard.items, new_items, &key_fn, &mut changes);
407 }
408 for change in changes {
409 self.notify(change);
410 }
411 }
412}
413
414fn reconcile_vec<T: PartialEq, K: Eq + Hash>(
421 items: &mut Vec<T>,
422 new_items: Vec<T>,
423 key_fn: &impl Fn(&T) -> K,
424 out: &mut Vec<DataChange>,
425) {
426 let new_pairs: Vec<(K, T)> = new_items.into_iter().map(|it| (key_fn(&it), it)).collect();
430 let new_key_set: HashSet<&K> = new_pairs.iter().map(|(k, _)| k).collect();
431
432 let old_keys: Vec<K> = items.iter().map(key_fn).collect();
437 let remove_idxs: Vec<usize> = (0..items.len())
438 .filter(|&i| !new_key_set.contains(&old_keys[i]))
439 .collect();
440 for range in coalesce_ranges(&remove_idxs).into_iter().rev() {
441 items.drain(range.clone());
442 out.push(DataChange::ItemsRemoved { range });
443 }
444
445 let remaining_keys: HashSet<K> = items.iter().map(key_fn).collect();
448
449 let mut cursor = 0usize;
455 let mut pending_inserts: Vec<T> = Vec::new();
456
457 for (key, new_item) in new_pairs {
458 if remaining_keys.contains(&key) {
459 flush_inserts(items, &mut cursor, &mut pending_inserts, out);
460
461 let pos = items
465 .iter()
466 .skip(cursor)
467 .position(|it| key_fn(it) == key)
468 .expect(
469 "reconcile_by_key: key reported common but not found — \
470 key_fn must be stable and keys unique",
471 );
472 let actual = cursor + pos;
473 if actual != cursor {
474 let val = items.remove(actual);
475 items.insert(cursor, val);
476 out.push(DataChange::ItemsMoved {
477 from: actual,
478 to: cursor,
479 count: 1,
480 });
481 }
482 if items[cursor] != new_item {
483 items[cursor] = new_item;
484 out.push(DataChange::ItemUpdated { index: cursor });
485 }
486 cursor += 1;
487 } else {
488 pending_inserts.push(new_item);
489 }
490 }
491 flush_inserts(items, &mut cursor, &mut pending_inserts, out);
492}
493
494fn flush_inserts<T>(
498 items: &mut Vec<T>,
499 cursor: &mut usize,
500 pending: &mut Vec<T>,
501 out: &mut Vec<DataChange>,
502) {
503 if pending.is_empty() {
504 return;
505 }
506 let start = *cursor;
507 let n = pending.len();
508 items.splice(start..start, pending.drain(..));
509 out.push(DataChange::ItemsInserted {
510 range: start..start + n,
511 });
512 *cursor += n;
513}
514
515fn coalesce_ranges(sorted_idxs: &[usize]) -> Vec<Range<usize>> {
518 let mut ranges = Vec::new();
519 let mut iter = sorted_idxs.iter().peekable();
520 while let Some(&start) = iter.next() {
521 let mut end = start + 1;
522 while iter.peek().is_some_and(|&&n| n == end) {
523 end += 1;
524 iter.next();
525 }
526 ranges.push(start..end);
527 }
528 ranges
529}
530
531impl<T: std::fmt::Debug + 'static> ListModel<T> {
532 pub fn debug_named(self, _name: impl Into<String>) -> Self {
540 #[cfg(debug_assertions)]
541 {
542 let weak = Rc::downgrade(&self.inner);
543 let adapter: Rc<dyn crate::debug_registry::ModelDebug> =
544 Rc::new(ListModelDebug::<T> { weak });
545 let name = _name.into();
546 crate::debug_registry::register(name, Rc::downgrade(&adapter));
547 self.inner.borrow_mut().debug_adapter = Some(adapter);
548 }
549 self
550 }
551}
552
553#[cfg(debug_assertions)]
554struct ListModelDebug<T> {
555 weak: std::rc::Weak<RefCell<ListModelInner<T>>>,
556}
557
558#[cfg(debug_assertions)]
559impl<T: std::fmt::Debug + 'static> crate::debug_registry::ModelDebug for ListModelDebug<T> {
560 fn kind(&self) -> &'static str {
561 "ListModel"
562 }
563 fn len(&self) -> usize {
564 self.weak
565 .upgrade()
566 .map(|inner| inner.borrow().items.len())
567 .unwrap_or(0)
568 }
569 fn debug_dump(&self, out: &mut dyn std::fmt::Write) {
570 let Some(inner) = self.weak.upgrade() else {
571 return;
572 };
573 let guard = inner.borrow();
574 for (i, item) in guard.items.iter().enumerate() {
575 let _ = writeln!(out, "[{}] {:?}", i, item);
576 }
577 }
578}
579
580impl<T: 'static> Default for ListModel<T> {
581 fn default() -> Self {
582 Self::new()
583 }
584}
585
586impl<T: 'static> Clone for ListModel<T> {
587 fn clone(&self) -> Self {
588 Self {
589 inner: self.inner.clone(),
590 }
591 }
592}
593
594impl<T: std::fmt::Debug + 'static> std::fmt::Debug for ListModel<T> {
595 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
596 f.debug_struct("ListModel")
597 .field("len", &self.inner.borrow().items.len())
598 .finish()
599 }
600}
601
602impl<T: 'static> ListDataSource for ListModel<T> {
607 type Item = T;
608 type Key = usize;
609
610 fn len(&self) -> usize {
611 ListModel::len(self)
612 }
613
614 fn with_item<R>(&self, index: usize, f: impl FnOnce(&T) -> R) -> Option<R> {
615 ListModel::with_item(self, index, f)
616 }
617
618 fn key_at(&self, index: usize) -> Option<usize> {
619 (index < ListModel::len(self)).then_some(index)
620 }
621
622 fn index_of(&self, key: &usize) -> Option<usize> {
623 (*key < ListModel::len(self)).then_some(*key)
624 }
625
626 fn observe_changes(&self, f: impl Fn(&DataChange) + 'static) -> ObserverHandle {
627 ListModel::observe_changes(self, f)
628 }
629
630 fn drag(&self, _key: &usize) -> DragEligibility {
631 DragEligibility::CanDrag
632 }
633
634 fn can_accept(&self, query: &DropQuery<'_, usize>) -> DropResponse {
635 match &query.source {
636 DragSource::SameView { .. } => match query.position {
637 DropPosition::Into => DropResponse::Reject,
638 DropPosition::Before | DropPosition::After => DropResponse::Accept,
639 },
640 DragSource::Foreign { .. } => DropResponse::Reject,
641 }
642 }
643
644 fn accept_drop(&self, commit: DropCommit<'_, usize>) -> bool {
645 let DragSource::SameView { key: from } = commit.source else {
646 return false;
647 };
648 let len = ListModel::len(self);
649 if from >= len {
650 return false;
651 }
652 let target = commit.target;
653 let shift = if from < target { 1 } else { 0 };
656 let to = match commit.position {
657 DropPosition::Before => target.saturating_sub(shift),
658 DropPosition::After => (target + 1).saturating_sub(shift),
659 DropPosition::Into => return false,
660 };
661 let to = to.min(len.saturating_sub(1));
662 self.move_item(from, to);
663 true
664 }
665
666 fn reorder_within(&self, sources: &[usize], target: &usize, position: DropPosition) -> bool {
667 if sources.len() <= 1 {
672 let Some(&from) = sources.first() else {
673 return false;
674 };
675 return self.accept_drop(DropCommit {
676 source: DragSource::SameView { key: from },
677 target: *target,
678 position,
679 });
680 }
681 let gap = match position {
682 DropPosition::Before => *target,
683 DropPosition::After => *target + 1,
684 DropPosition::Into => return false,
685 };
686 self.move_items(sources, gap)
687 }
688
689 fn on_drag_out(&self, key: &usize) {
690 if *key < ListModel::len(self) {
694 let _ = self.remove(*key);
695 }
696 }
697}
698
699#[cfg(test)]
700mod tests {
701 use std::cell::Cell;
702
703 use super::*;
704
705 #[test]
706 fn new_is_empty() {
707 let model: ListModel<String> = ListModel::new();
708 assert!(model.is_empty());
709 assert_eq!(model.len(), 0);
710 }
711
712 #[test]
716 fn removing_an_observer_that_owns_the_last_reference_to_another_does_not_panic() {
717 struct Owner {
718 items: ListModel<u8>,
719 own: RefCell<Vec<ObserverHandle>>,
720 }
721 let owner = Rc::new(Owner {
722 items: ListModel::new(),
723 own: RefCell::new(Vec::new()),
724 });
725 owner
726 .own
727 .borrow_mut()
728 .push(owner.items.observe_changes(|_| {}));
729 let items = owner.items.clone();
730 let held = Rc::clone(&owner);
731 let handle = owner.items.observe_changes(move |_| {
732 let _ = &held;
733 });
734 drop(owner);
735
736 drop(handle);
737 let fired = Rc::new(Cell::new(false));
738 let f = fired.clone();
739 let _h = items.observe_changes(move |_| f.set(true));
740 items.push(1);
741 assert!(fired.get(), "the model still notifies after the removal");
742 }
743
744 #[test]
745 fn from_vec() {
746 let model = ListModel::from_vec(vec![10, 20, 30]);
747 assert_eq!(model.len(), 3);
748 assert_eq!(model.with_item(1, |v| *v), Some(20));
749 }
750
751 #[test]
752 fn push_emits_inserted() {
753 let model = ListModel::new();
754 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
755 let c = changes.clone();
756 let _handle = model.observe_changes(move |change| {
757 c.borrow_mut().push(change.clone());
758 });
759
760 model.push("a");
761 model.push("b");
762
763 let log = changes.borrow();
764 assert_eq!(log.len(), 2);
765 assert_eq!(log[0], DataChange::ItemsInserted { range: 0..1 });
766 assert_eq!(log[1], DataChange::ItemsInserted { range: 1..2 });
767 }
768
769 #[test]
770 fn insert_emits_inserted() {
771 let model = ListModel::from_vec(vec![1, 2, 3]);
772 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
773 let c = changes.clone();
774 let _handle = model.observe_changes(move |change| {
775 c.borrow_mut().push(change.clone());
776 });
777
778 model.insert(1, 99);
779
780 assert_eq!(model.len(), 4);
781 assert_eq!(model.with_item(1, |v| *v), Some(99));
782 let log = changes.borrow();
783 assert_eq!(log.len(), 1, "insert should emit exactly one change");
784 assert_eq!(log[0], DataChange::ItemsInserted { range: 1..2 });
785 }
786
787 #[test]
788 fn remove_emits_removed() {
789 let model = ListModel::from_vec(vec!["a", "b", "c"]);
790 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
791 let c = changes.clone();
792 let _handle = model.observe_changes(move |change| {
793 c.borrow_mut().push(change.clone());
794 });
795
796 let removed = model.remove(1);
797 assert_eq!(removed, "b");
798 assert_eq!(model.len(), 2);
799 let log = changes.borrow();
800 assert_eq!(log.len(), 1, "remove should emit exactly one change");
801 assert_eq!(log[0], DataChange::ItemsRemoved { range: 1..2 });
802 }
803
804 #[test]
805 fn set_emits_updated() {
806 let model = ListModel::from_vec(vec![10, 20, 30]);
807 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
808 let c = changes.clone();
809 let _handle = model.observe_changes(move |change| {
810 c.borrow_mut().push(change.clone());
811 });
812
813 model.set(2, 99);
814 assert_eq!(model.with_item(2, |v| *v), Some(99));
815 let log = changes.borrow();
816 assert_eq!(log.len(), 1, "set should emit exactly one change");
817 assert_eq!(log[0], DataChange::ItemUpdated { index: 2 });
818 }
819
820 #[test]
821 fn move_item_emits_moved() {
822 let model = ListModel::from_vec(vec!["a", "b", "c", "d"]);
823 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
824 let c = changes.clone();
825 let _handle = model.observe_changes(move |change| {
826 c.borrow_mut().push(change.clone());
827 });
828
829 model.move_item(0, 2);
830 assert_eq!(model.with_item(0, |v| *v), Some("b"));
832 assert_eq!(model.with_item(2, |v| *v), Some("a"));
833 let log = changes.borrow();
834 assert_eq!(log.len(), 1, "move_item should emit exactly one change");
835 assert_eq!(
836 log[0],
837 DataChange::ItemsMoved {
838 from: 0,
839 to: 2,
840 count: 1
841 }
842 );
843 }
844
845 #[test]
846 fn move_item_same_index_is_noop() {
847 let model = ListModel::from_vec(vec![1, 2, 3]);
848 let count = Rc::new(Cell::new(0));
849 let c = count.clone();
850 let _handle = model.observe_changes(move |_| {
851 c.set(c.get() + 1);
852 });
853
854 model.move_item(1, 1);
855 assert_eq!(count.get(), 0);
856 }
857
858 #[test]
859 fn replace_all_emits_reset() {
860 let model = ListModel::from_vec(vec![1, 2]);
861 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
862 let c = changes.clone();
863 let _handle = model.observe_changes(move |change| {
864 c.borrow_mut().push(change.clone());
865 });
866
867 model.replace_all(vec![10, 20, 30]);
868 assert_eq!(model.len(), 3);
869 let log = changes.borrow();
870 assert_eq!(log[0], DataChange::Reset);
871 }
872
873 #[test]
874 fn clear_emits_reset() {
875 let model = ListModel::from_vec(vec![1, 2, 3]);
876 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
877 let c = changes.clone();
878 let _handle = model.observe_changes(move |change| {
879 c.borrow_mut().push(change.clone());
880 });
881
882 model.clear();
883 assert!(model.is_empty());
884 let log = changes.borrow();
885 assert_eq!(log[0], DataChange::Reset);
886 }
887
888 #[test]
889 fn observer_removed_on_handle_drop() {
890 let model = ListModel::new();
891 let count = Rc::new(Cell::new(0));
892 let c = count.clone();
893 let handle = model.observe_changes(move |_| {
894 c.set(c.get() + 1);
895 });
896
897 model.push(1);
898 assert_eq!(count.get(), 1);
899
900 drop(handle);
901 model.push(2);
902 assert_eq!(count.get(), 1); }
904
905 #[test]
906 fn multiple_observers() {
907 let model = ListModel::new();
908 let count = Rc::new(Cell::new(0));
909 let c1 = count.clone();
910 let c2 = count.clone();
911 let _h1 = model.observe_changes(move |_| c1.set(c1.get() + 1));
912 let _h2 = model.observe_changes(move |_| c2.set(c2.get() + 1));
913
914 model.push(42);
915 assert_eq!(count.get(), 2);
916 }
917
918 #[test]
919 fn clone_shares_data() {
920 let model = ListModel::from_vec(vec![1, 2, 3]);
921 let clone = model.clone();
922
923 model.push(4);
924 assert_eq!(clone.len(), 4);
925 assert_eq!(clone.with_item(3, |v| *v), Some(4));
926 }
927
928 #[test]
929 fn clone_shares_observers() {
930 let model = ListModel::from_vec(vec![1, 2]);
931 let count = Rc::new(Cell::new(0));
932 let c = count.clone();
933 let _handle = model.observe_changes(move |_| c.set(c.get() + 1));
934
935 let clone = model.clone();
936 clone.push(3); assert_eq!(count.get(), 1);
938 }
939
940 #[test]
941 fn with_item_out_of_bounds_returns_none() {
942 let model = ListModel::from_vec(vec![1, 2]);
943 assert_eq!(model.with_item(5, |v| *v), None);
944 }
945
946 #[test]
947 #[should_panic]
948 fn remove_out_of_bounds_panics() {
949 let model = ListModel::from_vec(vec![1]);
950 model.remove(5);
951 }
952
953 fn order<T: Clone>(model: &ListModel<T>) -> Vec<T> {
956 (0..model.len())
957 .map(|i| model.with_item(i, |v| v.clone()).unwrap())
958 .collect()
959 }
960
961 #[test]
962 fn list_source_accept_drop_after_reorders() {
963 let model = ListModel::from_vec(vec!["a", "b", "c", "d"]);
965 assert!(model.accept_drop(DropCommit {
966 source: DragSource::SameView { key: 0 },
967 target: 2,
968 position: DropPosition::After,
969 }));
970 assert_eq!(order(&model), vec!["b", "c", "a", "d"]);
971 }
972
973 #[test]
974 fn list_source_accept_drop_before_reorders() {
975 let model = ListModel::from_vec(vec!["a", "b", "c", "d"]);
977 assert!(model.accept_drop(DropCommit {
978 source: DragSource::SameView { key: 3 },
979 target: 1,
980 position: DropPosition::Before,
981 }));
982 assert_eq!(order(&model), vec!["a", "d", "b", "c"]);
983 }
984
985 #[test]
986 fn list_source_can_accept_rejects_into_accepts_sibling() {
987 let model = ListModel::from_vec(vec![1, 2, 3]);
988 assert_eq!(
990 model.can_accept(&DropQuery {
991 source: DragSource::SameView { key: 0 },
992 target: 1,
993 position: DropPosition::Into,
994 }),
995 DropResponse::Reject
996 );
997 assert_eq!(
999 model.can_accept(&DropQuery {
1000 source: DragSource::SameView { key: 0 },
1001 target: 1,
1002 position: DropPosition::After,
1003 }),
1004 DropResponse::Accept
1005 );
1006 }
1007
1008 #[test]
1009 fn list_source_key_is_positional_identity() {
1010 let model = ListModel::from_vec(vec![10, 20, 30]);
1011 assert_eq!(model.key_at(1), Some(1));
1012 assert_eq!(model.index_of(&2), Some(2));
1013 assert_eq!(model.key_at(5), None);
1014 assert_eq!(model.index_of(&9), None);
1015 }
1016
1017 fn snapshot<T: Clone>(model: &ListModel<T>) -> Vec<T> {
1018 (0..model.len())
1019 .filter_map(|i| model.with_item(i, |v| v.clone()))
1020 .collect()
1021 }
1022
1023 #[test]
1024 fn move_items_block_move_contiguous_and_ordered() {
1025 let model = ListModel::from_vec(vec!['A', 'B', 'C', 'D', 'E', 'F']);
1028 model.move_items(&[0, 2, 4], 3);
1029 assert_eq!(snapshot(&model), vec!['B', 'A', 'C', 'E', 'D', 'F']);
1032 }
1033
1034 #[test]
1035 fn move_items_to_end() {
1036 let model = ListModel::from_vec(vec![1, 2, 3, 4]);
1037 model.move_items(&[0, 1], 4);
1038 assert_eq!(snapshot(&model), vec![3, 4, 1, 2]);
1039 }
1040
1041 #[test]
1042 fn move_items_ignores_out_of_range_and_dedups() {
1043 let model = ListModel::from_vec(vec![1, 2, 3]);
1044 model.move_items(&[1, 1, 9], 3);
1045 assert_eq!(snapshot(&model), vec![1, 3, 2]);
1046 }
1047
1048 #[test]
1049 fn move_items_single_matches_move_item() {
1050 let a = ListModel::from_vec(vec![1, 2, 3, 4, 5]);
1051 let b = ListModel::from_vec(vec![1, 2, 3, 4, 5]);
1052 a.move_items(&[1], 4);
1054 b.move_item(1, 3);
1056 assert_eq!(snapshot(&a), snapshot(&b));
1057 }
1058
1059 #[test]
1060 fn reorder_within_multi_row_lands_contiguously() {
1061 let model = ListModel::from_vec(vec![0, 1, 2, 3, 4, 5]);
1063 assert!(model.reorder_within(&[0, 1], &4, DropPosition::After));
1065 assert_eq!(snapshot(&model), vec![2, 3, 4, 0, 1, 5]);
1066 }
1067
1068 #[test]
1069 fn reorder_within_single_row_uses_accept_drop() {
1070 let model = ListModel::from_vec(vec![10, 20, 30]);
1071 assert!(model.reorder_within(&[0], &2, DropPosition::After));
1072 assert_eq!(snapshot(&model), vec![20, 30, 10]);
1073 }
1074
1075 #[test]
1076 fn reorder_within_into_is_rejected_for_flat_list() {
1077 let model = ListModel::from_vec(vec![1, 2, 3]);
1078 assert!(!model.reorder_within(&[0, 1], &2, DropPosition::Into));
1079 assert_eq!(snapshot(&model), vec![1, 2, 3]);
1080 }
1081
1082 #[test]
1083 fn on_drag_out_removes_the_moved_row() {
1084 let model = ListModel::from_vec(vec!['a', 'b', 'c']);
1085 model.on_drag_out(&1);
1086 assert_eq!(snapshot(&model), vec!['a', 'c']);
1087 }
1088
1089 #[test]
1090 fn move_items_contiguous_emits_moved_non_contiguous_resets() {
1091 let model = ListModel::from_vec(vec![0, 1, 2, 3, 4]);
1092 let log: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
1093 let l = log.clone();
1094 let _h = model.observe_changes(move |c| l.borrow_mut().push(c.clone()));
1095 assert!(model.move_items(&[1, 2], 5));
1097 assert!(matches!(
1098 log.borrow().last(),
1099 Some(DataChange::ItemsMoved { .. })
1100 ));
1101 log.borrow_mut().clear();
1102 assert!(model.move_items(&[0, 2], 0));
1104 assert!(matches!(log.borrow().last(), Some(DataChange::Reset)));
1105 }
1106
1107 #[test]
1108 fn reorder_within_and_move_items_report_no_move_for_out_of_range() {
1109 let model = ListModel::from_vec(vec![1, 2, 3]);
1110 assert!(!model.reorder_within(&[99, 100], &0, DropPosition::Before));
1111 assert!(!model.move_items(&[99, 100], 0));
1112 assert_eq!(snapshot(&model), vec![1, 2, 3]);
1113 }
1114
1115 #[derive(Debug, Clone, PartialEq, Eq)]
1118 struct Row {
1119 id: u64,
1120 val: &'static str,
1121 }
1122
1123 fn row(id: u64, val: &'static str) -> Row {
1124 Row { id, val }
1125 }
1126
1127 fn key(r: &Row) -> u64 {
1128 r.id
1129 }
1130
1131 fn ids(model: &ListModel<Row>) -> Vec<u64> {
1132 (0..model.len())
1133 .map(|i| model.with_item(i, |r| r.id).unwrap())
1134 .collect()
1135 }
1136
1137 fn vals(model: &ListModel<Row>) -> Vec<&'static str> {
1138 (0..model.len())
1139 .map(|i| model.with_item(i, |r| r.val).unwrap())
1140 .collect()
1141 }
1142
1143 fn record_changes(model: &ListModel<Row>) -> (Rc<RefCell<Vec<DataChange>>>, ObserverHandle) {
1144 let log: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
1145 let l = log.clone();
1146 let handle = model.observe_changes(move |c| l.borrow_mut().push(c.clone()));
1147 (log, handle)
1148 }
1149
1150 #[test]
1151 fn reconcile_pure_insert_emits_one_coalesced_range() {
1152 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b")]);
1153 let (log, _h) = record_changes(&model);
1154
1155 model.reconcile_by_key(
1156 vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")],
1157 key,
1158 );
1159
1160 assert_eq!(ids(&model), vec![1, 2, 3, 4]);
1161 assert_eq!(vals(&model), vec!["a", "b", "c", "d"]);
1162 let entries = log.borrow();
1163 assert_eq!(entries.len(), 1, "contiguous inserts coalesce: {entries:?}");
1164 assert_eq!(entries[0], DataChange::ItemsInserted { range: 2..4 });
1165 }
1166
1167 #[test]
1168 fn reconcile_insert_at_front_and_middle() {
1169 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b")]);
1170 let (log, _h) = record_changes(&model);
1171
1172 model.reconcile_by_key(
1174 vec![row(0, "z"), row(1, "a"), row(5, "m"), row(2, "b")],
1175 key,
1176 );
1177
1178 assert_eq!(ids(&model), vec![0, 1, 5, 2]);
1179 let entries = log.borrow();
1180 assert_eq!(entries.len(), 2, "{entries:?}");
1183 assert_eq!(entries[0], DataChange::ItemsInserted { range: 0..1 });
1184 assert_eq!(entries[1], DataChange::ItemsInserted { range: 2..3 });
1185 }
1186
1187 #[test]
1188 fn reconcile_pure_remove_emits_one_coalesced_range() {
1189 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")]);
1190 let (log, _h) = record_changes(&model);
1191
1192 model.reconcile_by_key(vec![row(1, "a"), row(4, "d")], key);
1193
1194 assert_eq!(ids(&model), vec![1, 4]);
1195 let entries = log.borrow();
1196 assert_eq!(entries.len(), 1, "contiguous removes coalesce: {entries:?}");
1197 assert_eq!(entries[0], DataChange::ItemsRemoved { range: 1..3 });
1198 }
1199
1200 #[test]
1201 fn reconcile_remove_scattered_emits_separate_ranges() {
1202 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")]);
1203 let (log, _h) = record_changes(&model);
1204
1205 model.reconcile_by_key(vec![row(1, "a"), row(3, "c")], key);
1206
1207 assert_eq!(ids(&model), vec![1, 3]);
1208 let entries = log.borrow();
1209 assert_eq!(entries.len(), 2, "{entries:?}");
1210 assert_eq!(entries[0], DataChange::ItemsRemoved { range: 3..4 });
1212 assert_eq!(entries[1], DataChange::ItemsRemoved { range: 1..2 });
1213 }
1214
1215 #[test]
1216 fn reconcile_reorder_emits_only_moves() {
1217 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c")]);
1218 let (log, _h) = record_changes(&model);
1219
1220 model.reconcile_by_key(vec![row(3, "c"), row(2, "b"), row(1, "a")], key);
1221
1222 assert_eq!(ids(&model), vec![3, 2, 1]);
1223 let entries = log.borrow();
1224 assert!(
1225 entries
1226 .iter()
1227 .all(|c| matches!(c, DataChange::ItemsMoved { .. })),
1228 "a pure reorder must only emit moves: {entries:?}"
1229 );
1230 assert!(!entries.is_empty());
1231 }
1232
1233 #[test]
1234 fn reconcile_no_reorder_when_relative_order_already_matches() {
1235 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")]);
1238 let (log, _h) = record_changes(&model);
1239
1240 model.reconcile_by_key(vec![row(1, "a"), row(3, "c"), row(4, "d")], key);
1241
1242 assert_eq!(ids(&model), vec![1, 3, 4]);
1243 let entries = log.borrow();
1244 assert!(
1245 entries
1246 .iter()
1247 .all(|c| !matches!(c, DataChange::ItemsMoved { .. })),
1248 "untouched relative order must not emit moves: {entries:?}"
1249 );
1250 }
1251
1252 #[test]
1253 fn reconcile_in_place_update_emits_item_updated() {
1254 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c")]);
1255 let (log, _h) = record_changes(&model);
1256
1257 model.reconcile_by_key(vec![row(1, "a"), row(2, "CHANGED"), row(3, "c")], key);
1258
1259 assert_eq!(vals(&model), vec!["a", "CHANGED", "c"]);
1260 let entries = log.borrow();
1261 assert_eq!(entries.len(), 1, "{entries:?}");
1262 assert_eq!(entries[0], DataChange::ItemUpdated { index: 1 });
1263 }
1264
1265 #[test]
1266 fn reconcile_combined_insert_remove_reorder_update() {
1267 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")]);
1274 let (log, _h) = record_changes(&model);
1275
1276 model.reconcile_by_key(
1277 vec![row(4, "d"), row(2, "B!"), row(5, "e"), row(1, "a")],
1278 key,
1279 );
1280
1281 assert_eq!(ids(&model), vec![4, 2, 5, 1]);
1282 assert_eq!(vals(&model), vec!["d", "B!", "e", "a"]);
1283 let entries = log.borrow();
1284 assert!(!entries.is_empty());
1285 assert!(
1286 entries
1287 .iter()
1288 .any(|c| matches!(c, DataChange::ItemsMoved { .. })),
1289 "{entries:?}"
1290 );
1291 assert!(
1292 entries
1293 .iter()
1294 .any(|c| matches!(c, DataChange::ItemsInserted { .. })),
1295 "{entries:?}"
1296 );
1297 assert!(
1298 entries
1299 .iter()
1300 .any(|c| matches!(c, DataChange::ItemsRemoved { .. })),
1301 "{entries:?}"
1302 );
1303 assert!(
1304 entries
1305 .iter()
1306 .any(|c| matches!(c, DataChange::ItemUpdated { .. })),
1307 "{entries:?}"
1308 );
1309 assert!(
1310 !entries.iter().any(|c| matches!(c, DataChange::Reset)),
1311 "{entries:?}"
1312 );
1313 }
1314
1315 #[test]
1316 fn reconcile_emits_in_walk_order_with_sequential_indices() {
1317 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b")]);
1319 let (log, _h) = record_changes(&model);
1320 model.reconcile_by_key(vec![row(1, "a"), row(2, "B"), row(3, "c")], key);
1321 assert_eq!(
1322 *log.borrow(),
1323 vec![
1324 DataChange::ItemUpdated { index: 1 },
1325 DataChange::ItemsInserted { range: 2..3 },
1326 ]
1327 );
1328
1329 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")]);
1333 let (log, _h) = record_changes(&model);
1334 model.reconcile_by_key(
1335 vec![row(4, "d"), row(9, "n"), row(2, "B"), row(1, "a")],
1336 key,
1337 );
1338 assert_eq!(ids(&model), vec![4, 9, 2, 1]);
1339 assert_eq!(
1340 *log.borrow(),
1341 vec![
1342 DataChange::ItemsRemoved { range: 2..3 },
1344 DataChange::ItemsMoved {
1346 from: 2,
1347 to: 0,
1348 count: 1
1349 },
1350 DataChange::ItemsInserted { range: 1..2 },
1352 DataChange::ItemsMoved {
1354 from: 3,
1355 to: 2,
1356 count: 1
1357 },
1358 DataChange::ItemUpdated { index: 2 },
1359 ]
1360 );
1361 }
1362
1363 #[test]
1364 fn reconcile_empty_to_full() {
1365 let model: ListModel<Row> = ListModel::new();
1366 let (log, _h) = record_changes(&model);
1367
1368 model.reconcile_by_key(vec![row(1, "a"), row(2, "b"), row(3, "c")], key);
1369
1370 assert_eq!(ids(&model), vec![1, 2, 3]);
1371 let entries = log.borrow();
1372 assert_eq!(entries.len(), 1, "{entries:?}");
1373 assert_eq!(entries[0], DataChange::ItemsInserted { range: 0..3 });
1374 }
1375
1376 #[test]
1377 fn reconcile_full_to_empty() {
1378 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c")]);
1379 let (log, _h) = record_changes(&model);
1380
1381 model.reconcile_by_key(vec![], key);
1382
1383 assert!(model.is_empty());
1384 let entries = log.borrow();
1385 assert_eq!(entries.len(), 1, "{entries:?}");
1386 assert_eq!(entries[0], DataChange::ItemsRemoved { range: 0..3 });
1387 }
1388
1389 #[test]
1390 fn reconcile_identical_input_emits_nothing() {
1391 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c")]);
1392 let (log, _h) = record_changes(&model);
1393
1394 model.reconcile_by_key(vec![row(1, "a"), row(2, "b"), row(3, "c")], key);
1395
1396 assert_eq!(ids(&model), vec![1, 2, 3]);
1397 assert!(
1398 log.borrow().is_empty(),
1399 "identical reconcile must not notify: {:?}",
1400 log.borrow()
1401 );
1402 }
1403
1404 #[test]
1405 fn reconcile_never_emits_reset() {
1406 let scenarios: Vec<(Vec<Row>, Vec<Row>)> = vec![
1410 (
1411 vec![row(1, "a"), row(2, "b")],
1412 vec![row(1, "a"), row(2, "b"), row(3, "c")],
1413 ),
1414 (
1415 vec![row(1, "a"), row(2, "b"), row(3, "c")],
1416 vec![row(1, "a")],
1417 ),
1418 (
1419 vec![row(1, "a"), row(2, "b"), row(3, "c")],
1420 vec![row(3, "c"), row(1, "a"), row(2, "b")],
1421 ),
1422 (vec![], vec![row(1, "a"), row(2, "b")]),
1423 (vec![row(1, "a"), row(2, "b")], vec![]),
1424 (
1425 vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")],
1426 vec![row(9, "x"), row(8, "y"), row(7, "z")],
1427 ),
1428 ];
1429 for (before, after) in scenarios {
1430 let model = ListModel::from_vec(before.clone());
1431 let (log, _h) = record_changes(&model);
1432 model.reconcile_by_key(after.clone(), key);
1433 assert!(
1434 !log.borrow().iter().any(|c| matches!(c, DataChange::Reset)),
1435 "reconcile must never emit Reset — before {before:?}, after {after:?}, got {:?}",
1436 log.borrow()
1437 );
1438 }
1439 }
1440
1441 #[test]
1442 #[should_panic(expected = "reconcile_by_key")]
1443 fn reconcile_duplicate_key_in_new_items_panics() {
1444 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b")]);
1445 model.reconcile_by_key(vec![row(1, "a"), row(1, "a-dup"), row(2, "b")], key);
1449 }
1450}