feat: support relocate (#6)

Author: hyf0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "string_wizard"
-version = "0.0.7"
+version = "0.0.8"
 edition = "2021"
 license = "MIT"
 description = "manipulate string like wizards"

src/chunk.rs

@@ -32,8 +32,9 @@ pub struct Chunk<'str> {
     pub outro: VecDeque<CowStr<'str>>,
     pub span: Span,
     pub edited_content: Option<CowStr<'str>>,
-    pub(crate) next: Option<ChunkIdx>,
-    pub store_name: bool,
+    pub next: Option<ChunkIdx>,
+    pub prev: Option<ChunkIdx>,
+    pub keep_in_mappings: bool,
 }
 
 impl<'s> Chunk<'s> {
@@ -76,20 +77,26 @@ impl<'str> Chunk<'str> {
     }
 
     pub fn split<'a>(&'a mut self, text_index: TextSize) -> Chunk<'str> {
-        debug_assert!(text_index > self.start());
-        debug_assert!(text_index < self.end());
+        if !(text_index > self.start() && text_index < self.end()) {
+            panic!("Cannot split chunk at {text_index} between {:?}", self.span);
+        }
         if self.edited_content.is_some() {
             panic!("Cannot split a chunk that has already been edited")
         }
-        let first_slice_span = Span(self.start(), text_index);
-        let last_slice_span = Span(text_index, self.end());
-        let mut new_chunk = Chunk::new(last_slice_span);
+        let first_half_slice = Span(self.start(), text_index);
+        let second_half_slice = Span(text_index, self.end());
+        let mut new_chunk = Chunk::new(second_half_slice);
         if self.is_edited() {
-            new_chunk.edit("".into(), Default::default());
+            new_chunk.edit(
+                "".into(),
+                EditOptions {
+                    store_name: self.keep_in_mappings,
+                    overwrite: false,
+                },
+            );
         }
         std::mem::swap(&mut new_chunk.outro, &mut self.outro);
-        self.span = first_slice_span;
-        new_chunk.next = self.next;
+        self.span = first_half_slice;
         new_chunk
     }
 
@@ -112,7 +119,7 @@ impl<'str> Chunk<'str> {
             self.intro.clear();
             self.outro.clear();
         }
-        self.store_name = opts.store_name;
+        self.keep_in_mappings = opts.store_name;
         self.edited_content = Some(content);
     }
 

src/magic_string/mod.rs

@@ -200,41 +200,52 @@ impl<'text> MagicString<'text> {
     ///
     /// Chunk{span: (0, 3)} => "abc"
     /// Chunk{span: (3, 7)} => "defg"
-    fn split_at(&mut self, text_index: u32) {
-        if text_index == 0 || self.chunk_by_end.contains_key(&text_index) {
+    fn split_at(&mut self, at_index: u32) {
+        if at_index == 0
+            || at_index >= self.source.len()
+            || self.chunk_by_end.contains_key(&at_index)
+        {
             return;
         }
 
-        let (mut target, mut target_idx, search_right) =
-            if (self.source.len() - text_index) > text_index {
+        let (mut candidate, mut candidate_idx, search_right) =
+            if (self.source.len() - at_index) > at_index {
                 (self.first_chunk(), self.first_chunk_idx, true)
             } else {
                 (self.last_chunk(), self.last_chunk_idx, false)
             };
 
-        while !target.contains(text_index) {
+        while !candidate.contains(at_index) {
             let next_idx = if search_right {
-                self.chunk_by_start.get(&target.end()).unwrap()
+                self.chunk_by_start[&candidate.end()]
             } else {
-                self.chunk_by_end.get(&target.start()).unwrap()
+                self.chunk_by_end[&candidate.start()]
             };
-            target = &self.chunks[*next_idx];
-            target_idx = *next_idx;
+            candidate = &self.chunks[next_idx];
+            candidate_idx = next_idx;
         }
 
-        let chunk_contains_index = &mut self.chunks[target_idx];
-        let new_chunk = chunk_contains_index.split(text_index);
-        self.chunk_by_end.insert(text_index, target_idx);
-        let new_chunk_end = new_chunk.end();
-        let new_chunk_idx = self.chunks.push(new_chunk);
-        self.chunk_by_start.insert(text_index, new_chunk_idx);
-        self.chunk_by_end.insert(new_chunk_end, new_chunk_idx);
-
-        let chunk_contains_index = &mut self.chunks[target_idx];
-        if target_idx == self.last_chunk_idx {
-            self.last_chunk_idx = new_chunk_idx
+        let second_half_chunk = self.chunks[candidate_idx].split(at_index);
+        let second_half_span = second_half_chunk.span;
+        let second_half_idx = self.chunks.push(second_half_chunk);
+        let first_half_idx = candidate_idx;
+
+        // Update the chunk_by_start/end maps
+        self.chunk_by_end.insert(at_index, first_half_idx);
+        self.chunk_by_start.insert(at_index, second_half_idx);
+        self.chunk_by_end
+            .insert(second_half_span.end(), second_half_idx);
+
+        // Make sure the new chunk and the old chunk have correct next/prev pointers
+        self.chunks[second_half_idx].next = self.chunks[first_half_idx].next;
+        if let Some(second_half_next_idx) = self.chunks[second_half_idx].next {
+            self.chunks[second_half_next_idx].prev = Some(second_half_idx);
+        }
+        self.chunks[second_half_idx].prev = Some(first_half_idx);
+        self.chunks[first_half_idx].next = Some(second_half_idx);
+        if first_half_idx == self.last_chunk_idx {
+            self.last_chunk_idx = second_half_idx
         }
-        chunk_contains_index.next = Some(new_chunk_idx);
     }
 
     fn by_start_mut(&mut self, text_index: impl AssertIntoU32) -> Option<&mut Chunk<'text>> {

src/magic_string/mutation.rs

@@ -52,6 +52,81 @@ impl<'text> MagicString<'text> {
         self
     }
 
+    /// Moves the characters from start and end to index. Returns this.
+    // `move` is reserved keyword in rust, so we use `relocate` instead.
+    pub fn relocate(
+        &mut self,
+        start: impl AssertIntoU32,
+        end: impl AssertIntoU32,
+        to: impl AssertIntoU32,
+    ) -> &mut Self {
+        let start = start.assert_into_u32();
+        let end = end.assert_into_u32();
+        let to = to.assert_into_u32();
+
+        self.split_at(start);
+        self.split_at(end);
+        self.split_at(to);
+
+        let first_idx = self.chunk_by_start[&start];
+        let last_idx = self.chunk_by_end[&end];
+
+        let old_left_idx = self.chunks[first_idx].prev;
+        let old_right_idx = self.chunks[last_idx].next;
+
+        let new_right_idx = self.chunk_by_start.get(&to).copied();
+
+        // `new_right_idx` is `None` means that the `to` index is at the end of the string.
+        // Moving chunks which contain the last chunk to the end is meaningless.
+        if new_right_idx.is_none() && last_idx == self.last_chunk_idx {
+            return self;
+        }
+
+        let new_left_idx = new_right_idx
+            .map(|idx| self.chunks[idx].prev)
+            // If the `to` index is at the end of the string, then the `new_right_idx` will be `None`.
+            // In this case, we want to use the last chunk as the left chunk to connect the relocated chunk.
+            .unwrap_or(Some(self.last_chunk_idx));
+
+        // Adjust next/prev pointers, this remove the [start, end] range from the old position
+        if let Some(old_left_idx) = old_left_idx {
+            self.chunks[old_left_idx].next = old_right_idx;
+        }
+        if let Some(old_right_idx) = old_right_idx {
+            self.chunks[old_right_idx].prev = old_left_idx;
+        }
+
+        if let Some(new_left_idx) = new_left_idx {
+            self.chunks[new_left_idx].next = Some(first_idx);
+        }
+        if let Some(new_right_idx) = new_right_idx {
+            self.chunks[new_right_idx].prev = Some(last_idx);
+        }
+
+        if self.chunks[first_idx].prev.is_none() {
+            // If the `first_idx` is the first chunk, then we need to update the `first_chunk_idx`.
+            self.first_chunk_idx = self.chunks[last_idx].next.unwrap();
+        }
+        if self.chunks[last_idx].next.is_none() {
+            // If the `last_idx` is the last chunk, then we need to update the `last_chunk_idx`.
+            self.last_chunk_idx = self.chunks[first_idx].prev.unwrap();
+            self.chunks[last_idx].next = None;
+        }
+    
+        if new_left_idx.is_none() {
+            self.first_chunk_idx = first_idx;
+        }
+        if new_right_idx.is_none() {
+            self.last_chunk_idx = last_idx;
+        }
+
+        self.chunks[first_idx].prev = new_left_idx;
+        self.chunks[last_idx].next = new_right_idx;
+
+
+        self
+    }
+
     // --- private
 
     fn update_with_inner(

src/magic_string/source_map.rs

@@ -25,7 +25,7 @@ impl<'s> MagicString<'s> {
                 mappings.advance(frag);
             });
 
-            let name_idx = if chunk.store_name && chunk.is_edited() {
+            let name_idx = if chunk.keep_in_mappings && chunk.is_edited() {
                 let original_content = chunk.span.text(&self.source);
 
                 let idx = names

tests/magic_string.rs

@@ -150,6 +150,123 @@ mod overwrite {
     // }
 }
 
+mod relocate {
+    use super::*;
+
+    #[test]
+    fn moves_content_from_the_start() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.relocate(0, 3, 6);
+        assert_eq!(s.to_string(), "defabcghijkl");
+    }
+
+    #[test]
+    fn moves_content_to_the_start() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.relocate(3, 6, 0);
+        assert_eq!(s.to_string(), "defabcghijkl");
+    }
+
+    #[test]
+    fn moves_content_from_the_end() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.relocate(9, 12, 6);
+        assert_eq!(s.to_string(), "abcdefjklghi");
+    }
+
+    #[test]
+    fn moves_content_to_the_end() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.relocate(6, 9, 12);
+        assert_eq!(s.to_string(), "abcdefjklghi");
+    }
+
+    #[test]
+    fn ignores_redundant_move() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.prepend_right(9, "X")
+            .relocate(9, 12, 6)
+            .append_left(12, "Y")
+            // this is redundant – [6,9] is already after [9,12]
+            .relocate(6, 9, 12);
+
+        assert_eq!(s.to_string(), "abcdefXjklYghi");
+    }
+
+    #[test]
+    fn moves_content_to_the_middle() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.relocate(3, 6, 9);
+        assert_eq!(s.to_string(), "abcghidefjkl");
+    }
+
+    #[test]
+    fn handles_multiple_moves_of_the_same_snippet() {
+        let mut s = MagicString::new("abcdefghijkl");
+
+        s.relocate(0, 3, 6);
+        assert_eq!(s.to_string(), "defabcghijkl");
+
+        s.relocate(0, 3, 9);
+        assert_eq!(s.to_string(), "defghiabcjkl");
+    }
+
+    #[test]
+    fn handles_moves_of_adjacent_snippets() {
+        let mut s = MagicString::new("abcdefghijkl");
+
+        s.relocate(0, 2, 6);
+        assert_eq!(s.to_string(), "cdefabghijkl");
+        s.relocate(2, 4, 6);
+        assert_eq!(s.to_string(), "efabcdghijkl");
+    }
+
+    #[test]
+    fn handles_moves_to_same_index() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.relocate(0, 2, 6).relocate(3, 5, 6);
+        assert_eq!(s.to_string(), "cfabdeghijkl");
+    }
+
+    #[test]
+    #[should_panic]
+    fn refuses_to_move_a_selection_to_inside_itself() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.relocate(3, 6, 3);
+    }
+    #[test]
+    #[should_panic]
+    fn refuses_to_move_a_selection_to_inside_itself2() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.relocate(3, 6, 4);
+    }
+    #[test]
+    #[should_panic]
+    fn refuses_to_move_a_selection_to_inside_itself3() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.relocate(3, 6, 6);
+    }
+
+    #[test]
+    fn allows_edits_of_moved_content() {
+        let mut s1 = MagicString::new("abcdefghijkl");
+        s1.relocate(3, 6, 9);
+        s1.overwrite(3, 6, "DEF");
+        assert_eq!(s1.to_string(), "abcghiDEFjkl");
+        let mut s2 = MagicString::new("abcdefghijkl");
+        s2.relocate(3, 6, 9);
+        s2.overwrite(4, 5, "E");
+        assert_eq!(s2.to_string(), "abcghidEfjkl");
+    }
+
+    #[test]
+    fn moves_content_inserted_at_end_of_range() {
+        let mut s = MagicString::new("abcdefghijkl");
+        s.append_left(6, "X").relocate(3, 6, 9);
+        assert_eq!(s.to_string(), "abcghidefXjkl");
+    }
+}
+
 mod misc {
     use super::*;