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 inner.borrow_mut().observers.retain(|e| e.id != observer_id);
295 }),
296 )
297 }
298
299 fn notify(&self, change: DataChange) {
300 let callbacks: Vec<Rc<dyn Fn(&DataChange)>> = self
301 .inner
302 .borrow()
303 .observers
304 .iter()
305 .map(|e| e.callback.clone())
306 .collect();
307 for cb in &callbacks {
308 cb(&change);
309 }
310 }
311}
312
313impl<T: PartialEq + 'static> ListModel<T> {
314 pub fn reconcile_by_key<K: Eq + Hash>(&self, new_items: Vec<T>, key_fn: impl Fn(&T) -> K) {
379 let mut changes: Vec<DataChange> = Vec::new();
380 {
381 let mut guard = self.inner.borrow_mut();
382 reconcile_vec(&mut guard.items, new_items, &key_fn, &mut changes);
383 }
384 for change in changes {
385 self.notify(change);
386 }
387 }
388}
389
390fn reconcile_vec<T: PartialEq, K: Eq + Hash>(
397 items: &mut Vec<T>,
398 new_items: Vec<T>,
399 key_fn: &impl Fn(&T) -> K,
400 out: &mut Vec<DataChange>,
401) {
402 let new_pairs: Vec<(K, T)> = new_items.into_iter().map(|it| (key_fn(&it), it)).collect();
406 let new_key_set: HashSet<&K> = new_pairs.iter().map(|(k, _)| k).collect();
407
408 let old_keys: Vec<K> = items.iter().map(key_fn).collect();
413 let remove_idxs: Vec<usize> = (0..items.len())
414 .filter(|&i| !new_key_set.contains(&old_keys[i]))
415 .collect();
416 for range in coalesce_ranges(&remove_idxs).into_iter().rev() {
417 items.drain(range.clone());
418 out.push(DataChange::ItemsRemoved { range });
419 }
420
421 let remaining_keys: HashSet<K> = items.iter().map(key_fn).collect();
424
425 let mut cursor = 0usize;
431 let mut pending_inserts: Vec<T> = Vec::new();
432
433 for (key, new_item) in new_pairs {
434 if remaining_keys.contains(&key) {
435 flush_inserts(items, &mut cursor, &mut pending_inserts, out);
436
437 let pos = items
441 .iter()
442 .skip(cursor)
443 .position(|it| key_fn(it) == key)
444 .expect(
445 "reconcile_by_key: key reported common but not found — \
446 key_fn must be stable and keys unique",
447 );
448 let actual = cursor + pos;
449 if actual != cursor {
450 let val = items.remove(actual);
451 items.insert(cursor, val);
452 out.push(DataChange::ItemsMoved {
453 from: actual,
454 to: cursor,
455 count: 1,
456 });
457 }
458 if items[cursor] != new_item {
459 items[cursor] = new_item;
460 out.push(DataChange::ItemUpdated { index: cursor });
461 }
462 cursor += 1;
463 } else {
464 pending_inserts.push(new_item);
465 }
466 }
467 flush_inserts(items, &mut cursor, &mut pending_inserts, out);
468}
469
470fn flush_inserts<T>(
474 items: &mut Vec<T>,
475 cursor: &mut usize,
476 pending: &mut Vec<T>,
477 out: &mut Vec<DataChange>,
478) {
479 if pending.is_empty() {
480 return;
481 }
482 let start = *cursor;
483 let n = pending.len();
484 items.splice(start..start, pending.drain(..));
485 out.push(DataChange::ItemsInserted {
486 range: start..start + n,
487 });
488 *cursor += n;
489}
490
491fn coalesce_ranges(sorted_idxs: &[usize]) -> Vec<Range<usize>> {
494 let mut ranges = Vec::new();
495 let mut iter = sorted_idxs.iter().peekable();
496 while let Some(&start) = iter.next() {
497 let mut end = start + 1;
498 while iter.peek().is_some_and(|&&n| n == end) {
499 end += 1;
500 iter.next();
501 }
502 ranges.push(start..end);
503 }
504 ranges
505}
506
507impl<T: std::fmt::Debug + 'static> ListModel<T> {
508 pub fn debug_named(self, _name: impl Into<String>) -> Self {
516 #[cfg(debug_assertions)]
517 {
518 let weak = Rc::downgrade(&self.inner);
519 let adapter: Rc<dyn crate::debug_registry::ModelDebug> =
520 Rc::new(ListModelDebug::<T> { weak });
521 let name = _name.into();
522 crate::debug_registry::register(name, Rc::downgrade(&adapter));
523 self.inner.borrow_mut().debug_adapter = Some(adapter);
524 }
525 self
526 }
527}
528
529#[cfg(debug_assertions)]
530struct ListModelDebug<T> {
531 weak: std::rc::Weak<RefCell<ListModelInner<T>>>,
532}
533
534#[cfg(debug_assertions)]
535impl<T: std::fmt::Debug + 'static> crate::debug_registry::ModelDebug for ListModelDebug<T> {
536 fn kind(&self) -> &'static str {
537 "ListModel"
538 }
539 fn len(&self) -> usize {
540 self.weak
541 .upgrade()
542 .map(|inner| inner.borrow().items.len())
543 .unwrap_or(0)
544 }
545 fn debug_dump(&self, out: &mut dyn std::fmt::Write) {
546 let Some(inner) = self.weak.upgrade() else {
547 return;
548 };
549 let guard = inner.borrow();
550 for (i, item) in guard.items.iter().enumerate() {
551 let _ = writeln!(out, "[{}] {:?}", i, item);
552 }
553 }
554}
555
556impl<T: 'static> Default for ListModel<T> {
557 fn default() -> Self {
558 Self::new()
559 }
560}
561
562impl<T: 'static> Clone for ListModel<T> {
563 fn clone(&self) -> Self {
564 Self {
565 inner: self.inner.clone(),
566 }
567 }
568}
569
570impl<T: std::fmt::Debug + 'static> std::fmt::Debug for ListModel<T> {
571 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
572 f.debug_struct("ListModel")
573 .field("len", &self.inner.borrow().items.len())
574 .finish()
575 }
576}
577
578impl<T: 'static> ListDataSource for ListModel<T> {
583 type Item = T;
584 type Key = usize;
585
586 fn len(&self) -> usize {
587 ListModel::len(self)
588 }
589
590 fn with_item<R>(&self, index: usize, f: impl FnOnce(&T) -> R) -> Option<R> {
591 ListModel::with_item(self, index, f)
592 }
593
594 fn key_at(&self, index: usize) -> Option<usize> {
595 (index < ListModel::len(self)).then_some(index)
596 }
597
598 fn index_of(&self, key: &usize) -> Option<usize> {
599 (*key < ListModel::len(self)).then_some(*key)
600 }
601
602 fn observe_changes(&self, f: impl Fn(&DataChange) + 'static) -> ObserverHandle {
603 ListModel::observe_changes(self, f)
604 }
605
606 fn drag(&self, _key: &usize) -> DragEligibility {
607 DragEligibility::CanDrag
608 }
609
610 fn can_accept(&self, query: &DropQuery<'_, usize>) -> DropResponse {
611 match &query.source {
612 DragSource::SameView { .. } => match query.position {
613 DropPosition::Into => DropResponse::Reject,
614 DropPosition::Before | DropPosition::After => DropResponse::Accept,
615 },
616 DragSource::Foreign { .. } => DropResponse::Reject,
617 }
618 }
619
620 fn accept_drop(&self, commit: DropCommit<'_, usize>) -> bool {
621 let DragSource::SameView { key: from } = commit.source else {
622 return false;
623 };
624 let len = ListModel::len(self);
625 if from >= len {
626 return false;
627 }
628 let target = commit.target;
629 let shift = if from < target { 1 } else { 0 };
632 let to = match commit.position {
633 DropPosition::Before => target.saturating_sub(shift),
634 DropPosition::After => (target + 1).saturating_sub(shift),
635 DropPosition::Into => return false,
636 };
637 let to = to.min(len.saturating_sub(1));
638 self.move_item(from, to);
639 true
640 }
641
642 fn reorder_within(&self, sources: &[usize], target: &usize, position: DropPosition) -> bool {
643 if sources.len() <= 1 {
648 let Some(&from) = sources.first() else {
649 return false;
650 };
651 return self.accept_drop(DropCommit {
652 source: DragSource::SameView { key: from },
653 target: *target,
654 position,
655 });
656 }
657 let gap = match position {
658 DropPosition::Before => *target,
659 DropPosition::After => *target + 1,
660 DropPosition::Into => return false,
661 };
662 self.move_items(sources, gap)
663 }
664
665 fn on_drag_out(&self, key: &usize) {
666 if *key < ListModel::len(self) {
670 let _ = self.remove(*key);
671 }
672 }
673}
674
675#[cfg(test)]
676mod tests {
677 use std::cell::Cell;
678
679 use super::*;
680
681 #[test]
682 fn new_is_empty() {
683 let model: ListModel<String> = ListModel::new();
684 assert!(model.is_empty());
685 assert_eq!(model.len(), 0);
686 }
687
688 #[test]
689 fn from_vec() {
690 let model = ListModel::from_vec(vec![10, 20, 30]);
691 assert_eq!(model.len(), 3);
692 assert_eq!(model.with_item(1, |v| *v), Some(20));
693 }
694
695 #[test]
696 fn push_emits_inserted() {
697 let model = ListModel::new();
698 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
699 let c = changes.clone();
700 let _handle = model.observe_changes(move |change| {
701 c.borrow_mut().push(change.clone());
702 });
703
704 model.push("a");
705 model.push("b");
706
707 let log = changes.borrow();
708 assert_eq!(log.len(), 2);
709 assert_eq!(log[0], DataChange::ItemsInserted { range: 0..1 });
710 assert_eq!(log[1], DataChange::ItemsInserted { range: 1..2 });
711 }
712
713 #[test]
714 fn insert_emits_inserted() {
715 let model = ListModel::from_vec(vec![1, 2, 3]);
716 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
717 let c = changes.clone();
718 let _handle = model.observe_changes(move |change| {
719 c.borrow_mut().push(change.clone());
720 });
721
722 model.insert(1, 99);
723
724 assert_eq!(model.len(), 4);
725 assert_eq!(model.with_item(1, |v| *v), Some(99));
726 let log = changes.borrow();
727 assert_eq!(log.len(), 1, "insert should emit exactly one change");
728 assert_eq!(log[0], DataChange::ItemsInserted { range: 1..2 });
729 }
730
731 #[test]
732 fn remove_emits_removed() {
733 let model = ListModel::from_vec(vec!["a", "b", "c"]);
734 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
735 let c = changes.clone();
736 let _handle = model.observe_changes(move |change| {
737 c.borrow_mut().push(change.clone());
738 });
739
740 let removed = model.remove(1);
741 assert_eq!(removed, "b");
742 assert_eq!(model.len(), 2);
743 let log = changes.borrow();
744 assert_eq!(log.len(), 1, "remove should emit exactly one change");
745 assert_eq!(log[0], DataChange::ItemsRemoved { range: 1..2 });
746 }
747
748 #[test]
749 fn set_emits_updated() {
750 let model = ListModel::from_vec(vec![10, 20, 30]);
751 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
752 let c = changes.clone();
753 let _handle = model.observe_changes(move |change| {
754 c.borrow_mut().push(change.clone());
755 });
756
757 model.set(2, 99);
758 assert_eq!(model.with_item(2, |v| *v), Some(99));
759 let log = changes.borrow();
760 assert_eq!(log.len(), 1, "set should emit exactly one change");
761 assert_eq!(log[0], DataChange::ItemUpdated { index: 2 });
762 }
763
764 #[test]
765 fn move_item_emits_moved() {
766 let model = ListModel::from_vec(vec!["a", "b", "c", "d"]);
767 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
768 let c = changes.clone();
769 let _handle = model.observe_changes(move |change| {
770 c.borrow_mut().push(change.clone());
771 });
772
773 model.move_item(0, 2);
774 assert_eq!(model.with_item(0, |v| *v), Some("b"));
776 assert_eq!(model.with_item(2, |v| *v), Some("a"));
777 let log = changes.borrow();
778 assert_eq!(log.len(), 1, "move_item should emit exactly one change");
779 assert_eq!(
780 log[0],
781 DataChange::ItemsMoved {
782 from: 0,
783 to: 2,
784 count: 1
785 }
786 );
787 }
788
789 #[test]
790 fn move_item_same_index_is_noop() {
791 let model = ListModel::from_vec(vec![1, 2, 3]);
792 let count = Rc::new(Cell::new(0));
793 let c = count.clone();
794 let _handle = model.observe_changes(move |_| {
795 c.set(c.get() + 1);
796 });
797
798 model.move_item(1, 1);
799 assert_eq!(count.get(), 0);
800 }
801
802 #[test]
803 fn replace_all_emits_reset() {
804 let model = ListModel::from_vec(vec![1, 2]);
805 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
806 let c = changes.clone();
807 let _handle = model.observe_changes(move |change| {
808 c.borrow_mut().push(change.clone());
809 });
810
811 model.replace_all(vec![10, 20, 30]);
812 assert_eq!(model.len(), 3);
813 let log = changes.borrow();
814 assert_eq!(log[0], DataChange::Reset);
815 }
816
817 #[test]
818 fn clear_emits_reset() {
819 let model = ListModel::from_vec(vec![1, 2, 3]);
820 let changes: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
821 let c = changes.clone();
822 let _handle = model.observe_changes(move |change| {
823 c.borrow_mut().push(change.clone());
824 });
825
826 model.clear();
827 assert!(model.is_empty());
828 let log = changes.borrow();
829 assert_eq!(log[0], DataChange::Reset);
830 }
831
832 #[test]
833 fn observer_removed_on_handle_drop() {
834 let model = ListModel::new();
835 let count = Rc::new(Cell::new(0));
836 let c = count.clone();
837 let handle = model.observe_changes(move |_| {
838 c.set(c.get() + 1);
839 });
840
841 model.push(1);
842 assert_eq!(count.get(), 1);
843
844 drop(handle);
845 model.push(2);
846 assert_eq!(count.get(), 1); }
848
849 #[test]
850 fn multiple_observers() {
851 let model = ListModel::new();
852 let count = Rc::new(Cell::new(0));
853 let c1 = count.clone();
854 let c2 = count.clone();
855 let _h1 = model.observe_changes(move |_| c1.set(c1.get() + 1));
856 let _h2 = model.observe_changes(move |_| c2.set(c2.get() + 1));
857
858 model.push(42);
859 assert_eq!(count.get(), 2);
860 }
861
862 #[test]
863 fn clone_shares_data() {
864 let model = ListModel::from_vec(vec![1, 2, 3]);
865 let clone = model.clone();
866
867 model.push(4);
868 assert_eq!(clone.len(), 4);
869 assert_eq!(clone.with_item(3, |v| *v), Some(4));
870 }
871
872 #[test]
873 fn clone_shares_observers() {
874 let model = ListModel::from_vec(vec![1, 2]);
875 let count = Rc::new(Cell::new(0));
876 let c = count.clone();
877 let _handle = model.observe_changes(move |_| c.set(c.get() + 1));
878
879 let clone = model.clone();
880 clone.push(3); assert_eq!(count.get(), 1);
882 }
883
884 #[test]
885 fn with_item_out_of_bounds_returns_none() {
886 let model = ListModel::from_vec(vec![1, 2]);
887 assert_eq!(model.with_item(5, |v| *v), None);
888 }
889
890 #[test]
891 #[should_panic]
892 fn remove_out_of_bounds_panics() {
893 let model = ListModel::from_vec(vec![1]);
894 model.remove(5);
895 }
896
897 fn order<T: Clone>(model: &ListModel<T>) -> Vec<T> {
900 (0..model.len())
901 .map(|i| model.with_item(i, |v| v.clone()).unwrap())
902 .collect()
903 }
904
905 #[test]
906 fn list_source_accept_drop_after_reorders() {
907 let model = ListModel::from_vec(vec!["a", "b", "c", "d"]);
909 assert!(model.accept_drop(DropCommit {
910 source: DragSource::SameView { key: 0 },
911 target: 2,
912 position: DropPosition::After,
913 }));
914 assert_eq!(order(&model), vec!["b", "c", "a", "d"]);
915 }
916
917 #[test]
918 fn list_source_accept_drop_before_reorders() {
919 let model = ListModel::from_vec(vec!["a", "b", "c", "d"]);
921 assert!(model.accept_drop(DropCommit {
922 source: DragSource::SameView { key: 3 },
923 target: 1,
924 position: DropPosition::Before,
925 }));
926 assert_eq!(order(&model), vec!["a", "d", "b", "c"]);
927 }
928
929 #[test]
930 fn list_source_can_accept_rejects_into_accepts_sibling() {
931 let model = ListModel::from_vec(vec![1, 2, 3]);
932 assert_eq!(
934 model.can_accept(&DropQuery {
935 source: DragSource::SameView { key: 0 },
936 target: 1,
937 position: DropPosition::Into,
938 }),
939 DropResponse::Reject
940 );
941 assert_eq!(
943 model.can_accept(&DropQuery {
944 source: DragSource::SameView { key: 0 },
945 target: 1,
946 position: DropPosition::After,
947 }),
948 DropResponse::Accept
949 );
950 }
951
952 #[test]
953 fn list_source_key_is_positional_identity() {
954 let model = ListModel::from_vec(vec![10, 20, 30]);
955 assert_eq!(model.key_at(1), Some(1));
956 assert_eq!(model.index_of(&2), Some(2));
957 assert_eq!(model.key_at(5), None);
958 assert_eq!(model.index_of(&9), None);
959 }
960
961 fn snapshot<T: Clone>(model: &ListModel<T>) -> Vec<T> {
962 (0..model.len())
963 .filter_map(|i| model.with_item(i, |v| v.clone()))
964 .collect()
965 }
966
967 #[test]
968 fn move_items_block_move_contiguous_and_ordered() {
969 let model = ListModel::from_vec(vec!['A', 'B', 'C', 'D', 'E', 'F']);
972 model.move_items(&[0, 2, 4], 3);
973 assert_eq!(snapshot(&model), vec!['B', 'A', 'C', 'E', 'D', 'F']);
976 }
977
978 #[test]
979 fn move_items_to_end() {
980 let model = ListModel::from_vec(vec![1, 2, 3, 4]);
981 model.move_items(&[0, 1], 4);
982 assert_eq!(snapshot(&model), vec![3, 4, 1, 2]);
983 }
984
985 #[test]
986 fn move_items_ignores_out_of_range_and_dedups() {
987 let model = ListModel::from_vec(vec![1, 2, 3]);
988 model.move_items(&[1, 1, 9], 3);
989 assert_eq!(snapshot(&model), vec![1, 3, 2]);
990 }
991
992 #[test]
993 fn move_items_single_matches_move_item() {
994 let a = ListModel::from_vec(vec![1, 2, 3, 4, 5]);
995 let b = ListModel::from_vec(vec![1, 2, 3, 4, 5]);
996 a.move_items(&[1], 4);
998 b.move_item(1, 3);
1000 assert_eq!(snapshot(&a), snapshot(&b));
1001 }
1002
1003 #[test]
1004 fn reorder_within_multi_row_lands_contiguously() {
1005 let model = ListModel::from_vec(vec![0, 1, 2, 3, 4, 5]);
1007 assert!(model.reorder_within(&[0, 1], &4, DropPosition::After));
1009 assert_eq!(snapshot(&model), vec![2, 3, 4, 0, 1, 5]);
1010 }
1011
1012 #[test]
1013 fn reorder_within_single_row_uses_accept_drop() {
1014 let model = ListModel::from_vec(vec![10, 20, 30]);
1015 assert!(model.reorder_within(&[0], &2, DropPosition::After));
1016 assert_eq!(snapshot(&model), vec![20, 30, 10]);
1017 }
1018
1019 #[test]
1020 fn reorder_within_into_is_rejected_for_flat_list() {
1021 let model = ListModel::from_vec(vec![1, 2, 3]);
1022 assert!(!model.reorder_within(&[0, 1], &2, DropPosition::Into));
1023 assert_eq!(snapshot(&model), vec![1, 2, 3]);
1024 }
1025
1026 #[test]
1027 fn on_drag_out_removes_the_moved_row() {
1028 let model = ListModel::from_vec(vec!['a', 'b', 'c']);
1029 model.on_drag_out(&1);
1030 assert_eq!(snapshot(&model), vec!['a', 'c']);
1031 }
1032
1033 #[test]
1034 fn move_items_contiguous_emits_moved_non_contiguous_resets() {
1035 let model = ListModel::from_vec(vec![0, 1, 2, 3, 4]);
1036 let log: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
1037 let l = log.clone();
1038 let _h = model.observe_changes(move |c| l.borrow_mut().push(c.clone()));
1039 assert!(model.move_items(&[1, 2], 5));
1041 assert!(matches!(
1042 log.borrow().last(),
1043 Some(DataChange::ItemsMoved { .. })
1044 ));
1045 log.borrow_mut().clear();
1046 assert!(model.move_items(&[0, 2], 0));
1048 assert!(matches!(log.borrow().last(), Some(DataChange::Reset)));
1049 }
1050
1051 #[test]
1052 fn reorder_within_and_move_items_report_no_move_for_out_of_range() {
1053 let model = ListModel::from_vec(vec![1, 2, 3]);
1054 assert!(!model.reorder_within(&[99, 100], &0, DropPosition::Before));
1055 assert!(!model.move_items(&[99, 100], 0));
1056 assert_eq!(snapshot(&model), vec![1, 2, 3]);
1057 }
1058
1059 #[derive(Debug, Clone, PartialEq, Eq)]
1062 struct Row {
1063 id: u64,
1064 val: &'static str,
1065 }
1066
1067 fn row(id: u64, val: &'static str) -> Row {
1068 Row { id, val }
1069 }
1070
1071 fn key(r: &Row) -> u64 {
1072 r.id
1073 }
1074
1075 fn ids(model: &ListModel<Row>) -> Vec<u64> {
1076 (0..model.len())
1077 .map(|i| model.with_item(i, |r| r.id).unwrap())
1078 .collect()
1079 }
1080
1081 fn vals(model: &ListModel<Row>) -> Vec<&'static str> {
1082 (0..model.len())
1083 .map(|i| model.with_item(i, |r| r.val).unwrap())
1084 .collect()
1085 }
1086
1087 fn record_changes(model: &ListModel<Row>) -> (Rc<RefCell<Vec<DataChange>>>, ObserverHandle) {
1088 let log: Rc<RefCell<Vec<DataChange>>> = Rc::new(RefCell::new(Vec::new()));
1089 let l = log.clone();
1090 let handle = model.observe_changes(move |c| l.borrow_mut().push(c.clone()));
1091 (log, handle)
1092 }
1093
1094 #[test]
1095 fn reconcile_pure_insert_emits_one_coalesced_range() {
1096 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b")]);
1097 let (log, _h) = record_changes(&model);
1098
1099 model.reconcile_by_key(
1100 vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")],
1101 key,
1102 );
1103
1104 assert_eq!(ids(&model), vec![1, 2, 3, 4]);
1105 assert_eq!(vals(&model), vec!["a", "b", "c", "d"]);
1106 let entries = log.borrow();
1107 assert_eq!(entries.len(), 1, "contiguous inserts coalesce: {entries:?}");
1108 assert_eq!(entries[0], DataChange::ItemsInserted { range: 2..4 });
1109 }
1110
1111 #[test]
1112 fn reconcile_insert_at_front_and_middle() {
1113 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b")]);
1114 let (log, _h) = record_changes(&model);
1115
1116 model.reconcile_by_key(
1118 vec![row(0, "z"), row(1, "a"), row(5, "m"), row(2, "b")],
1119 key,
1120 );
1121
1122 assert_eq!(ids(&model), vec![0, 1, 5, 2]);
1123 let entries = log.borrow();
1124 assert_eq!(entries.len(), 2, "{entries:?}");
1127 assert_eq!(entries[0], DataChange::ItemsInserted { range: 0..1 });
1128 assert_eq!(entries[1], DataChange::ItemsInserted { range: 2..3 });
1129 }
1130
1131 #[test]
1132 fn reconcile_pure_remove_emits_one_coalesced_range() {
1133 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")]);
1134 let (log, _h) = record_changes(&model);
1135
1136 model.reconcile_by_key(vec![row(1, "a"), row(4, "d")], key);
1137
1138 assert_eq!(ids(&model), vec![1, 4]);
1139 let entries = log.borrow();
1140 assert_eq!(entries.len(), 1, "contiguous removes coalesce: {entries:?}");
1141 assert_eq!(entries[0], DataChange::ItemsRemoved { range: 1..3 });
1142 }
1143
1144 #[test]
1145 fn reconcile_remove_scattered_emits_separate_ranges() {
1146 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")]);
1147 let (log, _h) = record_changes(&model);
1148
1149 model.reconcile_by_key(vec![row(1, "a"), row(3, "c")], key);
1150
1151 assert_eq!(ids(&model), vec![1, 3]);
1152 let entries = log.borrow();
1153 assert_eq!(entries.len(), 2, "{entries:?}");
1154 assert_eq!(entries[0], DataChange::ItemsRemoved { range: 3..4 });
1156 assert_eq!(entries[1], DataChange::ItemsRemoved { range: 1..2 });
1157 }
1158
1159 #[test]
1160 fn reconcile_reorder_emits_only_moves() {
1161 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c")]);
1162 let (log, _h) = record_changes(&model);
1163
1164 model.reconcile_by_key(vec![row(3, "c"), row(2, "b"), row(1, "a")], key);
1165
1166 assert_eq!(ids(&model), vec![3, 2, 1]);
1167 let entries = log.borrow();
1168 assert!(
1169 entries
1170 .iter()
1171 .all(|c| matches!(c, DataChange::ItemsMoved { .. })),
1172 "a pure reorder must only emit moves: {entries:?}"
1173 );
1174 assert!(!entries.is_empty());
1175 }
1176
1177 #[test]
1178 fn reconcile_no_reorder_when_relative_order_already_matches() {
1179 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")]);
1182 let (log, _h) = record_changes(&model);
1183
1184 model.reconcile_by_key(vec![row(1, "a"), row(3, "c"), row(4, "d")], key);
1185
1186 assert_eq!(ids(&model), vec![1, 3, 4]);
1187 let entries = log.borrow();
1188 assert!(
1189 entries
1190 .iter()
1191 .all(|c| !matches!(c, DataChange::ItemsMoved { .. })),
1192 "untouched relative order must not emit moves: {entries:?}"
1193 );
1194 }
1195
1196 #[test]
1197 fn reconcile_in_place_update_emits_item_updated() {
1198 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c")]);
1199 let (log, _h) = record_changes(&model);
1200
1201 model.reconcile_by_key(vec![row(1, "a"), row(2, "CHANGED"), row(3, "c")], key);
1202
1203 assert_eq!(vals(&model), vec!["a", "CHANGED", "c"]);
1204 let entries = log.borrow();
1205 assert_eq!(entries.len(), 1, "{entries:?}");
1206 assert_eq!(entries[0], DataChange::ItemUpdated { index: 1 });
1207 }
1208
1209 #[test]
1210 fn reconcile_combined_insert_remove_reorder_update() {
1211 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")]);
1218 let (log, _h) = record_changes(&model);
1219
1220 model.reconcile_by_key(
1221 vec![row(4, "d"), row(2, "B!"), row(5, "e"), row(1, "a")],
1222 key,
1223 );
1224
1225 assert_eq!(ids(&model), vec![4, 2, 5, 1]);
1226 assert_eq!(vals(&model), vec!["d", "B!", "e", "a"]);
1227 let entries = log.borrow();
1228 assert!(!entries.is_empty());
1229 assert!(
1230 entries
1231 .iter()
1232 .any(|c| matches!(c, DataChange::ItemsMoved { .. })),
1233 "{entries:?}"
1234 );
1235 assert!(
1236 entries
1237 .iter()
1238 .any(|c| matches!(c, DataChange::ItemsInserted { .. })),
1239 "{entries:?}"
1240 );
1241 assert!(
1242 entries
1243 .iter()
1244 .any(|c| matches!(c, DataChange::ItemsRemoved { .. })),
1245 "{entries:?}"
1246 );
1247 assert!(
1248 entries
1249 .iter()
1250 .any(|c| matches!(c, DataChange::ItemUpdated { .. })),
1251 "{entries:?}"
1252 );
1253 assert!(
1254 !entries.iter().any(|c| matches!(c, DataChange::Reset)),
1255 "{entries:?}"
1256 );
1257 }
1258
1259 #[test]
1260 fn reconcile_empty_to_full() {
1261 let model: ListModel<Row> = ListModel::new();
1262 let (log, _h) = record_changes(&model);
1263
1264 model.reconcile_by_key(vec![row(1, "a"), row(2, "b"), row(3, "c")], key);
1265
1266 assert_eq!(ids(&model), vec![1, 2, 3]);
1267 let entries = log.borrow();
1268 assert_eq!(entries.len(), 1, "{entries:?}");
1269 assert_eq!(entries[0], DataChange::ItemsInserted { range: 0..3 });
1270 }
1271
1272 #[test]
1273 fn reconcile_full_to_empty() {
1274 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c")]);
1275 let (log, _h) = record_changes(&model);
1276
1277 model.reconcile_by_key(vec![], key);
1278
1279 assert!(model.is_empty());
1280 let entries = log.borrow();
1281 assert_eq!(entries.len(), 1, "{entries:?}");
1282 assert_eq!(entries[0], DataChange::ItemsRemoved { range: 0..3 });
1283 }
1284
1285 #[test]
1286 fn reconcile_identical_input_emits_nothing() {
1287 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b"), row(3, "c")]);
1288 let (log, _h) = record_changes(&model);
1289
1290 model.reconcile_by_key(vec![row(1, "a"), row(2, "b"), row(3, "c")], key);
1291
1292 assert_eq!(ids(&model), vec![1, 2, 3]);
1293 assert!(
1294 log.borrow().is_empty(),
1295 "identical reconcile must not notify: {:?}",
1296 log.borrow()
1297 );
1298 }
1299
1300 #[test]
1301 fn reconcile_never_emits_reset() {
1302 let scenarios: Vec<(Vec<Row>, Vec<Row>)> = vec![
1306 (
1307 vec![row(1, "a"), row(2, "b")],
1308 vec![row(1, "a"), row(2, "b"), row(3, "c")],
1309 ),
1310 (
1311 vec![row(1, "a"), row(2, "b"), row(3, "c")],
1312 vec![row(1, "a")],
1313 ),
1314 (
1315 vec![row(1, "a"), row(2, "b"), row(3, "c")],
1316 vec![row(3, "c"), row(1, "a"), row(2, "b")],
1317 ),
1318 (vec![], vec![row(1, "a"), row(2, "b")]),
1319 (vec![row(1, "a"), row(2, "b")], vec![]),
1320 (
1321 vec![row(1, "a"), row(2, "b"), row(3, "c"), row(4, "d")],
1322 vec![row(9, "x"), row(8, "y"), row(7, "z")],
1323 ),
1324 ];
1325 for (before, after) in scenarios {
1326 let model = ListModel::from_vec(before.clone());
1327 let (log, _h) = record_changes(&model);
1328 model.reconcile_by_key(after.clone(), key);
1329 assert!(
1330 !log.borrow().iter().any(|c| matches!(c, DataChange::Reset)),
1331 "reconcile must never emit Reset — before {before:?}, after {after:?}, got {:?}",
1332 log.borrow()
1333 );
1334 }
1335 }
1336
1337 #[test]
1338 #[should_panic(expected = "reconcile_by_key")]
1339 fn reconcile_duplicate_key_in_new_items_panics() {
1340 let model = ListModel::from_vec(vec![row(1, "a"), row(2, "b")]);
1341 model.reconcile_by_key(vec![row(1, "a"), row(1, "a-dup"), row(2, "b")], key);
1345 }
1346}