feat: move api (#20)

Author: faga295

core/src/magic_string.rs

@@ -631,6 +631,100 @@ impl MagicString {
     SourceMap::new_from_decoded(decoded_map)
   }
 
+  /// ## Move
+  /// Moves the string between start and end to the specified position.Return `self`.
+  ///
+  /// Example:
+  /// ```
+  /// use magic_string::MagicString;
+  /// let mut s = MagicString::new("abcdefghijkl");
+  /// s._move(3, 6, 9);
+  /// assert_eq!(s.to_string(), "abcghidefjkl");
+  ///
+  /// ```
+  ///
+  pub fn _move(&mut self, start: i64, end: i64, index: i64) -> Result<&mut Self> {
+    let start = normalize_index(self.original_str.as_str(), start)?;
+    let end = normalize_index(self.original_str.as_str(), end)?;
+    let index = normalize_index(self.original_str.as_str(), index)?;
+
+    let start = start as u32;
+    let end = end as u32;
+    let index = index as u32;
+
+    if index >= start && index <= end {
+      return Err(Error::new_with_reason(
+        MagicStringErrorType::MagicStringUnknownError,
+        "Cannot move a selection inside itself",
+      ));
+    }
+
+    if start > end {
+      return Err(Error::new_with_reason(
+        MagicStringErrorType::MagicStringOutOfRangeError,
+        "Start must be greater than end.",
+      ));
+    }
+
+    self._split_at_index(start)?;
+    self._split_at_index(end)?;
+    self._split_at_index(index)?;
+
+    let first = self.chunk_by_start.get(&start).map(Rc::clone).unwrap();
+    let last = self.chunk_by_end.get(&end).map(Rc::clone).unwrap();
+
+    let old_left = first.borrow().clone().prev;
+    let old_right = last.borrow().clone().next;
+
+    let new_right = self.chunk_by_start.get(&index).map(Rc::clone);
+    let new_left = match new_right.clone() {
+      Some(l) => Rc::clone(&l).borrow().clone().prev,
+      None => Some(Rc::clone(&self.last_chunk)),
+    };
+    let clone_old_left = old_left.clone();
+
+    match old_left {
+      Some(old_left) => {
+        old_left.borrow_mut().next = old_right.clone();
+      }
+      None => self.first_chunk = old_right.clone().unwrap(),
+    }
+
+    match old_right {
+      Some(old_right) => old_right.borrow_mut().prev = clone_old_left,
+      None => self.last_chunk = clone_old_left.unwrap(),
+    }
+
+    match new_left {
+      Some(new_left) => {
+        new_left.borrow_mut().next = Some(Rc::clone(&first));
+        first.borrow_mut().prev = Some(new_left);
+      }
+      None => {
+        let first = Rc::clone(&first);
+        self.first_chunk.borrow_mut().prev = Some(Rc::clone(&first));
+        last.borrow_mut().next = Some(Rc::clone(&self.first_chunk));
+        self.first_chunk = first;
+      }
+    }
+
+    match new_right {
+      Some(new_right) => {
+        new_right.borrow_mut().prev = Some(Rc::clone(&last));
+        last.borrow_mut().next = Some(new_right);
+      }
+      None => {
+        let last = Rc::clone(&last);
+        self.last_chunk.borrow_mut().next = Some(Rc::clone(&last));
+        first.borrow_mut().prev = Some(Rc::clone(&self.last_chunk));
+        last.borrow_mut().next = None;
+        self.last_chunk = last;
+      }
+    }
+
+    Ok(self)
+  }
+
   fn _split_at_index(&mut self, index: u32) -> Result {
     if self.chunk_by_end.contains_key(&index) || self.chunk_by_start.contains_key(&index) {
       // early bail-out if it's already split
@@ -667,8 +761,13 @@ impl MagicString {
         MagicStringErrorType::MagicStringDoubleSplitError,
       ));
     }
+    let next_chunk = chunk.borrow().clone().next;
     let new_chunk = Chunk::split(Rc::clone(&chunk), index);
 
+    if let Some(next_chunk) = next_chunk {
+      next_chunk.borrow_mut().prev = Some(Rc::clone(&new_chunk));
+    }
+
     let new_chunk_original = new_chunk.borrow();
     self.chunk_by_end.insert(index, Rc::clone(&chunk));
 

core/tests/move.rs

@@ -0,0 +1,164 @@
+#[cfg(test)]
+mod _move {
+  use magic_string::{MagicString, OverwriteOptions, Result};
+
+  #[test]
+  fn should_move_from_start() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+
+    s._move(0, 3, 6)?;
+    assert_eq!(s.to_string(), "defabcghijkl");
+    Ok(())
+  }
+
+  #[test]
+  fn should_move_to_start() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+
+    s._move(3, 6, 0)?;
+
+    assert_eq!(s.to_string(), "defabcghijkl");
+    Ok(())
+  }
+
+  #[test]
+  fn should_move_from_end() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+
+    s._move(9, 12, 3)?;
+
+    assert_eq!(s.to_string(), "abcjkldefghi");
+    Ok(())
+  }
+  #[test]
+  fn should_move_to_end() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+
+    s._move(3, 6, 12)?;
+
+    assert_eq!(s.to_string(), "abcghijkldef");
+    Ok(())
+  }
+
+  #[test]
+  fn should_move_and_remove() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+
+    s._move(3, 6, 12)?;
+    s._move(3, 5, 0)?;
+
+    assert_eq!(s.to_string(), "deabcghijklf");
+
+    Ok(())
+  }
+
+  #[test]
+  fn should_move_after_insert() -> Result {
+    let mut s = MagicString::new("abcdefghijk");
+
+    s.prepend("xyz")?;
+    s.append("mn")?;
+    s.prepend_left(4, "A")?;
+    s.append_left(4, "B")?;
+    s.prepend_right(4, "C")?;
+    s.append_right(4, "D")?;
+    s._move(0, 3, 6)?;
+    assert_eq!(s.to_string(), "xyzdABCDefabcghijkmn");
+    Ok(())
+  }
+
+  #[test]
+  fn should_ignores_redundant_move() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+    s.prepend_right(9, "X")?;
+    s._move(9, 12, 6)?;
+    s.append_left(12, "Y")?;
+    s._move(6, 9, 12)?; // this is redundant – [6,9] is already after [9,12]
+
+    assert_eq!(s.to_string(), "abcdefXjklYghi");
+
+    Ok(())
+  }
+
+  #[test]
+  fn should_move_content_to_middle() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+    s._move(3, 6, 9)?;
+
+    assert_eq!(s.to_string(), "abcghidefjkl");
+    Ok(())
+  }
+
+  #[test]
+  fn should_handles_multiple_moves_of_same_snippet() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+    s._move(0, 3, 6)?;
+    assert_eq!(s.to_string(), "defabcghijkl");
+
+    s._move(0, 3, 9)?;
+    assert_eq!(s.to_string(), "defghiabcjkl");
+
+    Ok(())
+  }
+  #[test]
+  fn should_handles_moves_of_adjacent_snippets() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+    s._move(0, 2, 6)?;
+    assert_eq!(s.to_string(), "cdefabghijkl");
+
+    s._move(2, 4, 6)?;
+    assert_eq!(s.to_string(), "efabcdghijkl");
+
+    Ok(())
+  }
+  #[test]
+  fn should_handles_moves_to_same_index() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+    s._move(0, 2, 6)?._move(3, 5, 6)?;
+    assert_eq!(s.to_string(), "cfabdeghijkl");
+
+    Ok(())
+  }
+  #[test]
+  fn should_allows_edits_of_moved_content() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+    s._move(3, 6, 9)?;
+    s.overwrite(3, 6, "DEF", OverwriteOptions::default())?;
+    assert_eq!(s.to_string(), "abcghiDEFjkl");
+
+    let mut s = MagicString::new("abcdefghijkl");
+
+    s._move(3, 6, 9)?;
+    s.overwrite(4, 5, "E", OverwriteOptions::default())?;
+    assert_eq!(s.to_string(), "abcghidEfjkl");
+    Ok(())
+  }
+  //   #[test]
+  //   fn should_move_follows_inserts() -> Result {
+  //     let mut s = MagicString::new("abcdefghijkl");
+  //     s._move(3, 6, 9)?;
+
+  //     assert_eq!(s.to_string(), "abcghidefjkl");
+  //     Ok(())
+  //   }
+  #[test]
+  fn should_moves_content_inserted_at_end_of_range() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+    s.append_left(6, "X")?._move(3, 6, 9)?;
+
+    assert_eq!(s.to_string(), "abcghidefXjkl");
+
+    Ok(())
+  }
+  #[test]
+  fn should_returns_this() -> Result {
+    let mut s = MagicString::new("abcdefghijkl");
+
+    let result = s._move(3, 6, 9)?;
+    let result_ptr = result as *mut _;
+    let s_ptr = &s as *const _;
+
+    assert_eq!(s_ptr, result_ptr);
+    Ok(())
+  }
+}

node/index.d.ts

@@ -49,6 +49,7 @@ export class MagicString {
   trimEnd(pattern?: string | undefined | null): this
   trimLines(): this
   remove(start: number, end: number): this
+  move(start: number, end: number, index: number): this
   isEmpty(): boolean
   generateMap(options?: Partial<GenerateDecodedMapOptions>): {
     toString: () => string

node/src/lib.rs

@@ -104,6 +104,11 @@ impl MagicString {
     Ok(self)
   }
 
+  #[napi]
+  pub fn _move(&mut self, start: i64, end: i64, index: i64) -> Result<&Self> {
+    self.0._move(start, end, index)?;
+    Ok(self)
+  }
   #[napi]
   pub fn is_empty(&self) -> Result<bool> {
     Ok(self.0.is_empty())