progress

gpx-rs/src/engine/state/clipboard.rs

@@ -0,0 +1,469 @@
+use std::rc::Rc;
+
+use uuid::Uuid;
+
+use crate::{
+    File, FileId, Files, Selection, Track, TrackId, TrackSegment, TrackSegmentId, Waypoint,
+    WaypointId,
+};
+
+/// A track in the clipboard, with the name of the file it comes from (the name of the new file
+/// when it is pasted on its own).
+#[derive(Debug, Clone)]
+pub struct ClipboardTrack {
+    pub track: Track,
+    pub file_name: String,
+}
+
+/// A segment in the clipboard, with the name of its track, or of its file when the track has
+/// none (the name of the new file when it is pasted on its own).
+#[derive(Debug, Clone)]
+pub struct ClipboardSegment {
+    pub segment: TrackSegment,
+    pub name: String,
+}
+
+/// The elements that were copied or cut, in the order of the files.
+///
+/// It holds the elements themselves, not references to them: they are cheap to keep (files are
+/// shared, and so are the trackpoints of tracks and segments), and the clipboard stays valid
+/// when the elements are changed or deleted.
+#[derive(Debug, Clone)]
+pub enum ClipboardContent {
+    Files(Vec<Rc<File>>),
+    Tracks(Vec<ClipboardTrack>),
+    Segments(Vec<ClipboardSegment>),
+    Waypoints(Vec<Waypoint>),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct ClipboardId(Uuid);
+
+impl Default for ClipboardId {
+    fn default() -> Self {
+        Self(Uuid::new_v4())
+    }
+}
+
+/// What was copied or cut, to be pasted, as many times as needed.
+///
+/// What is pasted is always the elements as they were when they were copied or cut, whatever
+/// happened to them since, even if they were deleted. Pasting what was copied makes copies, with
+/// new ids. What was cut is moved, with its ids, the first time it is pasted (the elements that
+/// are still there are removed): the clipboard is not cut anymore after that, and the next
+/// pastes make copies.
+#[derive(Debug, Clone)]
+pub struct Clipboard {
+    id: ClipboardId,
+    pub content: ClipboardContent,
+    pub cut: bool,
+}
+
+/// Two clipboards are the same when they come from the same copy, and are cut the same way.
+impl PartialEq for Clipboard {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id && self.cut == other.cut
+    }
+}
+
+impl Clipboard {
+    /// The clipboard for the selected elements, `None` if nothing is selected (or if what is
+    /// selected does not exist).
+    pub fn new(
+        selection: &Selection,
+        files: &Files,
+        order: &[FileId],
+        cut: bool,
+    ) -> Option<Clipboard> {
+        let content = match selection {
+            Selection::Empty => return None,
+            Selection::File { file_ids } => ClipboardContent::Files(
+                order
+                    .iter()
+                    .filter(|id| file_ids.contains(id))
+                    .filter_map(|id| files.get(id).cloned())
+                    .collect(),
+            ),
+            Selection::Track { file_id, trk_ids } => {
+                let file = files.get(file_id)?;
+                ClipboardContent::Tracks(
+                    file.trk
+                        .iter()
+                        .filter(|trk| trk_ids.contains(&trk.id))
+                        .map(|trk| ClipboardTrack {
+                            track: trk.clone(),
+                            file_name: file.info.name.clone(),
+                        })
+                        .collect(),
+                )
+            }
+            Selection::TrackSegment {
+                file_id,
+                trk_id,
+                trkseg_ids,
+            } => {
+                let file = files.get(file_id)?;
+                let trk = file.trk.iter().find(|trk| trk.id == *trk_id)?;
+                let name = trk
+                    .info
+                    .name
+                    .clone()
+                    .unwrap_or_else(|| file.info.name.clone());
+                ClipboardContent::Segments(
+                    trk.trkseg
+                        .iter()
+                        .filter(|seg| trkseg_ids.contains(&seg.id))
+                        .map(|seg| ClipboardSegment {
+                            segment: seg.clone(),
+                            name: name.clone(),
+                        })
+                        .collect(),
+                )
+            }
+            Selection::Waypoints { file_id } => {
+                ClipboardContent::Waypoints(files.get(file_id)?.wpt.iter().cloned().collect())
+            }
+            Selection::Waypoint { file_id, wpt_ids } => ClipboardContent::Waypoints(
+                files
+                    .get(file_id)?
+                    .wpt
+                    .iter()
+                    .filter(|wpt| wpt_ids.contains(&wpt.id))
+                    .cloned()
+                    .collect(),
+            ),
+        };
+        let clipboard = Clipboard {
+            id: ClipboardId::default(),
+            content,
+            cut,
+        };
+        (!clipboard.is_empty()).then_some(clipboard)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        match &self.content {
+            ClipboardContent::Files(files) => files.is_empty(),
+            ClipboardContent::Tracks(tracks) => tracks.is_empty(),
+            ClipboardContent::Segments(segments) => segments.is_empty(),
+            ClipboardContent::Waypoints(waypoints) => waypoints.is_empty(),
+        }
+    }
+
+    /// Whether the content can be pasted when `target` is selected: files and tracks can be
+    /// pasted anywhere above them in the file tree, and nothing selected stands for the list of
+    /// files.
+    ///
+    /// | copied    | pasted when selected                     |
+    /// |-----------|------------------------------------------|
+    /// | files     | nothing, a file                          |
+    /// | tracks    | nothing, a file, a track                 |
+    /// | segments  | nothing, a file, a track, a segment      |
+    /// | waypoints | a file, the waypoints, a waypoint        |
+    pub fn can_paste(&self, target: &Selection) -> bool {
+        use ClipboardContent as C;
+        use Selection::*;
+        matches!(
+            (&self.content, target),
+            (C::Files(_), Empty | File { .. })
+                | (C::Tracks(_), Empty | File { .. } | Track { .. })
+                | (
+                    C::Segments(_),
+                    Empty | File { .. } | Track { .. } | TrackSegment { .. }
+                )
+                | (
+                    C::Waypoints(_),
+                    File { .. } | Waypoints { .. } | Waypoint { .. }
+                )
+        )
+    }
+}
+
+/// The ids of the elements of the content, by kind.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ClipboardIds {
+    Files(Vec<FileId>),
+    Tracks(Vec<TrackId>),
+    Segments(Vec<TrackSegmentId>),
+    Waypoints(Vec<WaypointId>),
+}
+
+impl ClipboardContent {
+    pub fn ids(&self) -> ClipboardIds {
+        match self {
+            ClipboardContent::Files(files) => {
+                ClipboardIds::Files(files.iter().map(|file| file.id).collect())
+            }
+            ClipboardContent::Tracks(tracks) => {
+                ClipboardIds::Tracks(tracks.iter().map(|trk| trk.track.id).collect())
+            }
+            ClipboardContent::Segments(segments) => {
+                ClipboardIds::Segments(segments.iter().map(|seg| seg.segment.id).collect())
+            }
+            ClipboardContent::Waypoints(waypoints) => {
+                ClipboardIds::Waypoints(waypoints.iter().map(|wpt| wpt.id).collect())
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{TrackInfo, WaypointChunk};
+
+    use super::*;
+
+    /// A file with 3 tracks (named "t0", "t1", "t2") of 2 segments and 3 waypoints.
+    fn file(name: &str) -> File {
+        let mut file = File::default();
+        file.info.name = name.to_owned();
+        for i in 0..3 {
+            file.trk.push(Track {
+                info: TrackInfo {
+                    name: (i < 2).then(|| format!("t{i}")),
+                    ..Default::default()
+                },
+                trkseg: vec![TrackSegment::default(), TrackSegment::default()],
+                ..Default::default()
+            });
+        }
+        file.wpt.push(WaypointChunk {
+            wpt: vec![Waypoint::default(), Waypoint::default()],
+            ..Default::default()
+        });
+        file.wpt.push(WaypointChunk {
+            wpt: vec![Waypoint::default()],
+            ..Default::default()
+        });
+        file
+    }
+
+    fn files_of(files: Vec<File>) -> Files {
+        files
+            .into_iter()
+            .map(|file| (file.id, Rc::new(file)))
+            .collect()
+    }
+
+    fn order_of(files: &Files) -> Vec<FileId> {
+        files.keys().copied().collect()
+    }
+
+    fn tracks(file: &File, ids: &[usize]) -> Selection {
+        Selection::Track {
+            file_id: file.id,
+            trk_ids: ids.iter().map(|i| file.trk[*i].id).collect(),
+        }
+    }
+
+    #[test]
+    fn test_the_clipboard_holds_what_is_selected() {
+        let file = file("source");
+        let (t0, t2) = (file.trk[0].id, file.trk[2].id);
+        let (s0, s1) = (file.trk[1].trkseg[0].id, file.trk[1].trkseg[1].id);
+        let wpt: Vec<_> = file.wpt.iter().map(|w| w.id).collect();
+        let files = files_of(vec![file.clone()]);
+
+        // tracks, in the order of the file, with the name of their file
+        let clipboard =
+            Clipboard::new(&tracks(&file, &[2, 0]), &files, &order_of(&files), false).unwrap();
+        assert!(!clipboard.cut);
+        match &clipboard.content {
+            ClipboardContent::Tracks(copied) => {
+                assert_eq!(
+                    copied.iter().map(|c| c.track.id).collect::<Vec<_>>(),
+                    vec![t0, t2]
+                );
+                assert!(copied.iter().all(|c| c.file_name == "source"));
+            }
+            other => panic!("{other:?}"),
+        }
+
+        // segments, with the name of their track, or else of their file
+        let segments = |trk: usize, ids: &[TrackSegmentId]| Selection::TrackSegment {
+            file_id: file.id,
+            trk_id: file.trk[trk].id,
+            trkseg_ids: ids.iter().copied().collect(),
+        };
+        match Clipboard::new(&segments(1, &[s1, s0]), &files, &order_of(&files), true)
+            .unwrap()
+            .content
+        {
+            ClipboardContent::Segments(copied) => {
+                assert_eq!(
+                    copied.iter().map(|c| c.segment.id).collect::<Vec<_>>(),
+                    vec![s0, s1]
+                );
+                assert!(copied.iter().all(|c| c.name == "t1"));
+            }
+            other => panic!("{other:?}"),
+        }
+        let unnamed = file.trk[2].trkseg[0].id;
+        match Clipboard::new(&segments(2, &[unnamed]), &files, &order_of(&files), true)
+            .unwrap()
+            .content
+        {
+            ClipboardContent::Segments(copied) => assert_eq!(copied[0].name, "source"),
+            other => panic!("{other:?}"),
+        }
+
+        // waypoints: some of them, or all of them
+        let some = Selection::Waypoint {
+            file_id: file.id,
+            wpt_ids: [wpt[2], wpt[0]].into(),
+        };
+        assert_eq!(
+            Clipboard::new(&some, &files, &order_of(&files), false)
+                .unwrap()
+                .content
+                .ids(),
+            ClipboardIds::Waypoints(vec![wpt[0], wpt[2]])
+        );
+        assert_eq!(
+            Clipboard::new(
+                &Selection::Waypoints { file_id: file.id },
+                &files,
+                &order_of(&files),
+                false
+            )
+            .unwrap()
+            .content
+            .ids(),
+            ClipboardIds::Waypoints(wpt)
+        );
+
+        // files
+        let selection = Selection::File {
+            file_ids: [file.id].into(),
+        };
+        assert_eq!(
+            Clipboard::new(&selection, &files, &order_of(&files), false)
+                .unwrap()
+                .content
+                .ids(),
+            ClipboardIds::Files(vec![file.id])
+        );
+    }
+
+    #[test]
+    fn test_nothing_to_copy() {
+        let file = file("f");
+        let files = files_of(vec![file.clone()]);
+        assert!(Clipboard::new(&Selection::Empty, &files, &order_of(&files), false).is_none());
+        // elements that do not exist
+        let unknown = Selection::Track {
+            file_id: FileId::default(),
+            trk_ids: [TrackId::default()].into(),
+        };
+        assert!(Clipboard::new(&unknown, &files, &order_of(&files), false).is_none());
+        let unknown = Selection::Track {
+            file_id: file.id,
+            trk_ids: [TrackId::default()].into(),
+        };
+        assert!(Clipboard::new(&unknown, &files, &order_of(&files), false).is_none());
+        assert!(
+            Clipboard::new(
+                &Selection::File {
+                    file_ids: [FileId::default()].into()
+                },
+                &files,
+                &order_of(&files),
+                false
+            )
+            .is_none()
+        );
+        // a file without waypoints
+        let empty = files_of(vec![File::default()]);
+        let id = *empty.keys().next().unwrap();
+        assert!(
+            Clipboard::new(
+                &Selection::Waypoints { file_id: id },
+                &empty,
+                &order_of(&empty),
+                true
+            )
+            .is_none()
+        );
+    }
+
+    #[test]
+    fn test_two_clipboards_are_the_same_when_they_come_from_the_same_copy() {
+        let file = file("f");
+        let files = files_of(vec![file.clone()]);
+        let selection = tracks(&file, &[0]);
+        let clipboard = Clipboard::new(&selection, &files, &order_of(&files), false).unwrap();
+        assert_eq!(clipboard, clipboard.clone());
+        // the same elements copied again make another clipboard
+        assert_ne!(
+            clipboard,
+            Clipboard::new(&selection, &files, &order_of(&files), false).unwrap()
+        );
+        // and it is not the same once it is not cut
+        let mut copy = clipboard.clone();
+        copy.cut = true;
+        assert_ne!(clipboard, copy);
+    }
+
+    #[test]
+    fn test_the_clipboard_survives_what_happens_to_the_files() {
+        let file = file("f");
+        let mut files = files_of(vec![file.clone()]);
+        let clipboard =
+            Clipboard::new(&tracks(&file, &[0, 1]), &files, &order_of(&files), true).unwrap();
+        files.clear();
+        assert!(!clipboard.is_empty());
+        assert_eq!(
+            clipboard.content.ids(),
+            ClipboardIds::Tracks(vec![file.trk[0].id, file.trk[1].id])
+        );
+    }
+
+    #[test]
+    fn test_where_things_can_be_pasted() {
+        let file = file("f");
+        let files = files_of(vec![file.clone()]);
+        let selection_of = |selection: Selection| {
+            Clipboard::new(&selection, &files, &order_of(&files), false).unwrap()
+        };
+        let file_selection = Selection::File {
+            file_ids: [file.id].into(),
+        };
+        let track = tracks(&file, &[0]);
+        let segment = Selection::TrackSegment {
+            file_id: file.id,
+            trk_id: file.trk[0].id,
+            trkseg_ids: [file.trk[0].trkseg[0].id].into(),
+        };
+        let waypoints = Selection::Waypoints { file_id: file.id };
+        let waypoint = Selection::Waypoint {
+            file_id: file.id,
+            wpt_ids: [file.wpt[0].id].into(),
+        };
+        let targets = [
+            Selection::Empty,
+            file_selection.clone(),
+            track.clone(),
+            segment.clone(),
+            waypoints.clone(),
+            waypoint.clone(),
+        ];
+        let expected = [
+            // nothing, file, track, segment, waypoints, waypoint
+            (file_selection, [true, true, false, false, false, false]),
+            (track, [true, true, true, false, false, false]),
+            (segment, [true, true, true, true, false, false]),
+            (waypoints, [false, true, false, false, true, true]),
+            (waypoint, [false, true, false, false, true, true]),
+        ];
+        for (copied, allowed) in expected {
+            let clipboard = selection_of(copied.clone());
+            for (target, allowed) in targets.iter().zip(allowed) {
+                assert_eq!(
+                    clipboard.can_paste(target),
+                    allowed,
+                    "{copied:?} on {target:?}"
+                );
+            }
+        }
+    }
+}