Refactor to support append_xxx and prepend_xxx

Author: hyf0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "string_wizard"
-version = "0.0.3"
+version = "0.0.4"
 edition = "2021"
 license = "MIT"
 description = "manipulate string like wizards"
@@ -10,4 +10,3 @@ description = "manipulate string like wizards"
 [dependencies]
 index_vec = { version = "0.1.3" }
 rustc-hash = { version = "1.1.0" }
-text-size = "1.1.1"

src/chunk.rs

@@ -1,10 +1,12 @@
+use std::collections::VecDeque;
+
 use crate::{span::Span, ChunkIdx, CowStr};
 
 #[derive(Debug, Default)]
-pub struct Chunk<'s> {
-    intro: Vec<CowStr<'s>>,
+pub struct Chunk<'str> {
+    intro: VecDeque<CowStr<'str>>,
     span: Span,
-    outro: Vec<CowStr<'s>>,
+    outro: VecDeque<CowStr<'str>>,
     len: usize,
     pub(crate) next: Option<ChunkIdx>,
 }
@@ -19,22 +21,50 @@ impl<'s> Chunk<'s> {
     }
 }
 
-impl<'s> Chunk<'s> {
-    pub fn fragments(&'s self, original_source: &'s CowStr<'s>) -> impl Iterator<Item = &'s str> {
-        let intro_iter = self.intro.iter().map(|frag| frag.as_ref());
-        let source_frag = self.span.text(original_source.as_ref());
-        let outro_iter = self.outro.iter().map(|frag| frag.as_ref());
-        intro_iter.chain(Some(source_frag)).chain(outro_iter)
+impl<'str> Chunk<'str> {
+    pub fn start(&self) -> u32 {
+        self.span.start()
+    }
+
+    pub fn end(&self) -> u32 {
+        self.span.end()
+    }
+
+    pub fn contains(&self, text_index: u32) -> bool {
+        self.start() < text_index && text_index < self.end()
+    }
+
+    pub fn append_outro(&mut self, content: CowStr<'str>) {
+        self.outro.push_back(content)
+    }
+
+    pub fn append_intro(&mut self, content: CowStr<'str>) {
+        self.intro.push_back(content)
     }
 
-    pub fn append(&mut self, frag: CowStr<'s>) {
-        self.len += frag.len();
-        self.outro.push(frag.into())
+    pub fn prepend_outro(&mut self, content: CowStr<'str>) {
+        self.outro.push_front(content)
     }
 
-    pub fn prepend(&mut self, frag: CowStr<'s>) {
-        self.len += frag.len();
-        self.intro.push(frag.into())
+    pub fn prepend_intro(&mut self, content: CowStr<'str>) {
+        self.intro.push_front(content)
+    }
+
+    pub fn split<'a,>(&'a mut self, text_index: u32)  -> Chunk<'str> {
+        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);
+        std::mem::swap(&mut new_chunk.outro, &mut self.outro);
+        self.span = first_slice_span;
+        new_chunk.next = self.next;
+        new_chunk
+    }
+
+    pub fn fragments(&'str self, original_source: &'str CowStr<'str>) -> impl Iterator<Item = &'str str> {
+        let intro_iter = self.intro.iter().map(|frag| frag.as_ref());
+        let source_frag = self.span.text(original_source.as_ref());
+        let outro_iter = self.outro.iter().map(|frag| frag.as_ref());
+        intro_iter.chain(Some(source_frag)).chain(outro_iter)
     }
 
     pub fn len(&self) -> usize {

src/lib.rs

@@ -4,7 +4,6 @@ mod span;
 mod joiner;
 mod magic_string;
 use std::borrow::Cow;
-mod intersperse_shim;
 
 type CowStr<'s> = Cow<'s, str>;
 

src/magic_string.rs

@@ -7,14 +7,14 @@ pub struct MagicStringOptions {
     pub filename: Option<String>,
 }
 
-#[derive(Default)]
 pub struct MagicString<'s> {
     pub filename: Option<String>,
-    
+
     source: CowStr<'s>,
     source_len: u32,
     chunks: ChunkVec<'s>,
-    first_chunk_idx: Option<ChunkIdx>,
+    first_chunk_idx: ChunkIdx,
+    last_chunk_idx: ChunkIdx,
     chunk_by_start: FxHashMap<u32, ChunkIdx>,
     chunk_by_end: FxHashMap<u32, ChunkIdx>,
 }
@@ -29,26 +29,86 @@ impl<'s> MagicString<'s> {
     pub fn with_options(source: impl Into<CowStr<'s>>, options: MagicStringOptions) -> Self {
         let source = source.into();
         let source_len: u32 = source.len().try_into().expect("source is too big");
+        let initial_chunk = Chunk::new(Span(0, source_len));
+        let mut chunks = ChunkVec::with_capacity(1);
+        let initial_chunk_idx = chunks.push(initial_chunk);
         let mut magic_string = Self {
             source,
             source_len,
-            ..Default::default()
+            first_chunk_idx: initial_chunk_idx,
+            last_chunk_idx: initial_chunk_idx,
+            chunks,
+            chunk_by_start: Default::default(),
+            chunk_by_end: Default::default(),
+            // setup options
+            filename: options.filename,
         };
-        magic_string.split_at(source_len);
-        magic_string.first_chunk_idx = Some(ChunkIdx::from_raw(0));
 
-        magic_string.filename = options.filename;
+        magic_string.chunk_by_start.insert(0, initial_chunk_idx);
+        magic_string
+            .chunk_by_end
+            .insert(source_len, initial_chunk_idx);
 
         magic_string
     }
 
     pub fn append(&mut self, source: impl Into<CowStr<'s>>) -> &mut Self {
-        self.last_chunk_mut().append(source.into());
+        self.last_chunk_mut().append_outro(source.into());
+        self
+    }
+
+    /// # Example
+    ///```rust
+    /// use string_wizard::MagicString;
+    /// let mut s = MagicString::new("01234");
+    /// s.append_left(2, "a");
+    /// s.append_left(2, "b");
+    /// assert_eq!(s.to_string(), "01ab234")
+    ///```
+    pub fn append_left(&mut self, text_index: u32, source: impl Into<CowStr<'s>>) -> &mut Self {
+        self.split_at(text_index);
+        let idx = self.chunk_by_end.get(&text_index).unwrap();
+        let chunk = &mut self.chunks[*idx];
+        chunk.append_outro(source.into());
+        self
+    }
+
+    /// # Example
+    /// ```rust
+    /// use string_wizard::MagicString;
+    /// let mut s = MagicString::new("01234");
+    /// s.append_right(2, "A");
+    /// s.append_right(2, "B");
+    /// s.append_left(2, "a");
+    /// s.append_left(2, "b");
+    /// assert_eq!(s.to_string(), "01abAB234")
+    ///```
+    pub fn append_right(&mut self, text_index: u32, source: impl Into<CowStr<'s>>) -> &mut Self {
+        self.split_at(text_index);
+        let idx = self.chunk_by_start.get(&text_index).unwrap();
+        let chunk = &mut self.chunks[*idx];
+        chunk.append_intro(source.into());
         self
     }
 
     pub fn prepend(&mut self, source: impl Into<CowStr<'s>>) -> &mut Self {
-        self.first_chunk_mut().prepend(source.into());
+        self.first_chunk_mut().prepend_intro(source.into());
+        self
+    }
+
+    pub fn prepend_left(&mut self, text_index: u32, content: impl Into<CowStr<'s>>) -> &mut Self {
+        self.split_at(text_index);
+        let idx = self.chunk_by_end.get(&text_index).unwrap();
+        let chunk = &mut self.chunks[*idx];
+        chunk.prepend_outro(content.into());
+        self
+    }
+
+    pub fn prepend_right(&mut self, text_index: u32, content: impl Into<CowStr<'s>>) -> &mut Self {
+        self.split_at(text_index);
+        let idx = self.chunk_by_start.get(&text_index).unwrap();
+        let chunk = &mut self.chunks[*idx];
+        chunk.prepend_intro(content.into());
         self
     }
 
@@ -67,7 +127,7 @@ impl<'s> MagicString<'s> {
 
     fn iter_chunks(&self) -> impl Iterator<Item = &Chunk> {
         ChunkIter {
-            next: self.first_chunk_idx,
+            next: Some(self.first_chunk_idx),
             chunks: &self.chunks,
         }
     }
@@ -76,39 +136,62 @@ impl<'s> MagicString<'s> {
         self.iter_chunks().flat_map(|c| c.fragments(&self.source))
     }
 
-    /// a b c d e f g
-    /// 0 1 2 3 4 5 6
-    /// split_at(3)
-    ///  a b c  d e f g
-    /// [0 1 2][3 4 5 6]
-    fn split_at(&mut self, idx: u32) {
-        let source_len = self.source_len;
-        debug_assert!(idx <= source_len);
-        if self.chunks.is_empty() {
-            let prev_span = Span(0, idx);
-            self.create_chunk(prev_span);
-            if idx < source_len {
-                self.create_chunk(Span(idx, source_len));
-            }
-        } else {
+    /// For input
+    /// "abcdefg"
+    ///  0123456
+    ///
+    /// Chunk{span: (0, 7)} => "abcdefg"
+    ///
+    /// split_at(3) would create
+    ///
+    /// Chunk{span: (0, 3)} => "abc"
+    /// Chunk{span: (3, 7)} => "defg"
+    fn split_at(&mut self, text_index: u32) {
+        debug_assert!(text_index <= self.source_len);
+
+        if self.chunk_by_start.contains_key(&text_index)
+            || self.chunk_by_end.contains_key(&text_index)
+        {
+            return;
         }
-    }
 
-    fn create_chunk(&mut self, span: Span) -> ChunkIdx {
-        let idx = self.chunks.push(Chunk::new(span));
-        self.chunk_by_start.insert(span.start(), idx);
-        self.chunk_by_end.insert(span.end(), idx);
-        idx
+        let mut target = &self.chunks[self.first_chunk_idx];
+        let mut target_idx = self.first_chunk_idx;
+
+        let search_right = text_index > target.end();
+
+        while !target.contains(text_index) {
+            let next_idx = if search_right {
+                self.chunk_by_start.get(&target.end()).unwrap()
+            } else {
+                self.chunk_by_end.get(&target.start()).unwrap()
+            };
+            target = &self.chunks[*next_idx];
+            target_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
+        }
+        chunk_contains_index.next = Some(new_chunk_idx);
     }
 
     fn last_chunk_mut(&mut self) -> &mut Chunk<'s> {
-        let idx = self.chunk_by_end.get(&(self.source_len)).unwrap();
-        &mut self.chunks[*idx]
+        &mut self.chunks[self.last_chunk_idx]
     }
 
     fn first_chunk_mut(&mut self) -> &mut Chunk<'s> {
-        let idx = self.chunk_by_start.get(&0).unwrap();
-        &mut self.chunks[*idx]
+        &mut self.chunks[self.first_chunk_idx]
     }
 }
 

tests/magic_string.rs

@@ -29,6 +29,38 @@ mod append {
     }
 }
 
+mod prepend_append_left_right {
+    use super::*;
+
+    #[test]
+    fn preserves_intended_order() {
+        let mut s = MagicString::new("0123456789");
+        s.append_left(5, "A");
+        s.prepend_right(5, "a");
+        s.prepend_right(5, "b");
+        s.append_left(5, "B");
+        s.append_left(5, "C");
+        s.prepend_right(5, "c");
+
+        assert_eq!(s.to_string(), "01234ABCcba56789");
+        
+        s.prepend_left(5, "<");
+        s.prepend_left(5, "{");
+        assert_eq!(s.to_string(), "01234{<ABCcba56789");
+
+        s.append_right(5, ">");
+        s.append_right(5, "}");
+        assert_eq!(s.to_string(), "01234{<ABCcba>}56789");
+
+        s.append_left(5, "(");
+        s.append_left(5, "[");
+        assert_eq!(s.to_string(), "01234{<ABC([cba>}56789");
+
+        s.prepend_right(5, ")");
+        s.prepend_right(5, "]");
+        assert_eq!(s.to_string(), "01234{<ABC([])cba>}56789");
+    }
+}
 mod prepend {
     use super::*;