feat: update MagicString module with new features and

bug fixes

Author: hyf0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "string_wizard"
-version = "0.0.11"
+version = "0.0.12"
 edition = "2021"
 license = "MIT"
 description = "manipulate string like wizards"
@@ -13,6 +13,7 @@ rustc-hash = { version = "1.1.0" }
 regex = "1.10.2"
 serde = { version = "1.0", features = ["derive"], optional = true }
 serde_json = { version = "1.0", optional = true }
+once_cell = "1.18.0"
 
 [features]
 # Enable source map functionality

src/lib.rs

@@ -16,7 +16,7 @@ use std::borrow::Cow;
 
 pub use crate::{
     joiner::{Joiner, JoinerOptions},
-    magic_string::{mutation::UpdateOptions, MagicString, MagicStringOptions, indent::IndentOptions},
+    magic_string::{update::UpdateOptions, MagicString, MagicStringOptions, indent::IndentOptions},
 };
 
 #[cfg(feature = "source_map")]

src/magic_string/indent.rs

@@ -2,7 +2,7 @@ use rustc_hash::FxHashSet;
 
 use crate::{CowStr, MagicString, TextSize};
 
-fn guess_indent_str(source: &str) -> Option<String> {
+pub fn guess_indentor(source: &str) -> Option<String> {
     let mut tabbed_count = 0;
     let mut spaced_line = vec![];
     for line in source.lines() {
@@ -36,37 +36,27 @@ fn guess_indent_str(source: &str) -> Option<String> {
 
 #[derive(Debug, Default)]
 pub struct IndentOptions<'a> {
-    /// MagicString will guess the `indent_str`` from lines of the source if passed `None`.
-    pub indent_str: Option<&'a str>,
+    /// MagicString will guess the `indentor`` from lines of the source if passed `None`.
+    pub indentor: Option<&'a str>,
     pub exclude: Vec<TextSize>,
 }
 
 impl<'text> MagicString<'text> {
-    fn ensure_indent_str(&mut self) -> &str {
-        if self.indent_str.is_none() {
-            self.indent_str = guess_indent_str(&self.source);
-        }
-
-        self.indent_str.as_deref().unwrap_or(&"\t")
+    pub fn guessed_indentor(&mut self) -> &str {
+        let guessed_indentor = self.guessed_indentor.get_or_init(|| guess_indentor(&self.source).unwrap_or_else(|| "\t".to_string()));
+        guessed_indentor
     }
 
     pub fn indent(&mut self) -> &mut Self {
         self.indent_with(IndentOptions {
-            indent_str: None,
-            ..Default::default()
-        })
-    }
-
-    /// Shortcut for `indent_with(IndentOptions { indent_str: Some(indent_str), ..Default::default() })`
-    pub fn indent_str(&mut self, indent_str: &str) -> &mut Self {
-        self.indent_with(IndentOptions {
-            indent_str: Some(indent_str),
+            indentor: None,
             ..Default::default()
         })
     }
 
+ 
     pub fn indent_with(&mut self, opts: IndentOptions<'_>) -> &mut Self {
-        if opts.indent_str.map_or(false, |s| s.is_empty()) {
+        if opts.indentor.map_or(false, |s| s.is_empty()) {
             return self;
         }
         struct IndentReplacer {
@@ -111,13 +101,13 @@ impl<'text> MagicString<'text> {
             }
         }
 
-        let indent_str = opts.indent_str.unwrap_or_else(|| self.ensure_indent_str());
+        let indentor = opts.indentor.unwrap_or_else(|| self.guessed_indentor());
 
         let pattern = regex::Regex::new(r"(?m)^[^\r\n]").unwrap();
 
         let mut indent_replacer = IndentReplacer {
             should_indent_next_char: true,
-            indent_str: indent_str.to_string(),
+            indent_str: indentor.to_string(),
         };
 
         for intro_frag in self.intro.iter_mut() {

src/magic_string/mod.rs

@@ -2,9 +2,11 @@ pub mod indent;
 pub mod mutation;
 #[cfg(feature = "source_map")]
 pub mod source_map;
+pub mod update;
 
 use std::collections::VecDeque;
 
+use once_cell::sync::OnceCell;
 use rustc_hash::FxHashMap;
 
 use crate::{
@@ -24,14 +26,14 @@ pub struct MagicString<'s> {
     pub filename: Option<String>,
     intro: VecDeque<CowStr<'s>>,
     outro: VecDeque<CowStr<'s>>,
-    indent_str: Option<String>,
     source: CowStr<'s>,
     source_len: TextSize,
     chunks: ChunkVec<'s>,
     first_chunk_idx: ChunkIdx,
     last_chunk_idx: ChunkIdx,
     chunk_by_start: FxHashMap<TextSize, ChunkIdx>,
     chunk_by_end: FxHashMap<TextSize, ChunkIdx>,
+    guessed_indentor: OnceCell<String>,
 }
 
 impl<'text> MagicString<'text> {
@@ -59,7 +61,7 @@ impl<'text> MagicString<'text> {
             chunk_by_end: Default::default(),
             // setup options
             filename: options.filename,
-            indent_str: None,
+            guessed_indentor: OnceCell::default(),
         };
 
         magic_string.chunk_by_start.insert(0, initial_chunk_idx);
@@ -301,4 +303,3 @@ impl<'a> Iterator for ChunkIter<'a> {
         })
     }
 }
-

src/magic_string/mutation.rs

@@ -1,42 +1,8 @@
-use crate::{basic_types::AssertIntoU32, chunk::EditOptions, CowStr, MagicString};
+use crate::{basic_types::AssertIntoU32, MagicString};
 
-#[derive(Debug, Default, Clone)]
-pub struct UpdateOptions {
-    /// `true` will store the original content in the `name` field of the generated sourcemap.
-    pub keep_original: bool,
-
-    /// `true` will clear the `intro` and `outro` for the corresponding range.
-    pub overwrite: bool,
-}
+use super::update::UpdateOptions;
 
 impl<'text> MagicString<'text> {
-    /// A shorthand for `update_with(start, end, content, Default::default())`;
-    pub fn update(
-        &mut self,
-        start: impl AssertIntoU32,
-        end: impl AssertIntoU32,
-        content: impl Into<CowStr<'text>>,
-    ) -> &mut Self {
-        self.update_with(start, end, content, Default::default())
-    }
-
-    pub fn update_with(
-        &mut self,
-        start: impl AssertIntoU32,
-        end: impl AssertIntoU32,
-        content: impl Into<CowStr<'text>>,
-        opts: UpdateOptions,
-    ) -> &mut Self {
-        self.update_with_inner(
-            start.assert_into_u32(),
-            end.assert_into_u32(),
-            content.into(),
-            opts,
-            true,
-        );
-        self
-    }
-
     pub fn remove(&mut self, start: impl AssertIntoU32, end: impl AssertIntoU32) -> &mut Self {
         self.update_with_inner(
             start.assert_into_u32(),
@@ -115,7 +81,7 @@ impl<'text> MagicString<'text> {
             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;
         }
@@ -126,54 +92,6 @@ impl<'text> MagicString<'text> {
         self.chunks[first_idx].prev = new_left_idx;
         self.chunks[last_idx].next = new_right_idx;
 
-
-        self
-    }
-
-    // --- private
-
-    fn update_with_inner(
-        &mut self,
-        start: u32,
-        end: u32,
-        content: CowStr<'text>,
-        opts: UpdateOptions,
-        panic_if_start_equal_end: bool,
-    ) -> &mut Self {
-        let start = start as u32;
-        let end = end as u32;
-        if panic_if_start_equal_end && start == end {
-            panic!(
-                "Cannot overwrite a zero-length range – use append_left or prepend_right instead"
-            )
-        }
-        assert!(start < end);
-        self.split_at(start);
-        self.split_at(end);
-
-        let start_idx = self.chunk_by_start.get(&start).copied().unwrap();
-        let end_idx = self.chunk_by_end.get(&end).copied().unwrap();
-
-        let start_chunk = &mut self.chunks[start_idx];
-        start_chunk.edit(
-            content.into(),
-            EditOptions {
-                overwrite: opts.overwrite,
-                store_name: opts.keep_original,
-            },
-        );
-
-        let mut rest_chunk_idx = if start_idx != end_idx {
-            start_chunk.next.unwrap()
-        } else {
-            return self;
-        };
-
-        while rest_chunk_idx != end_idx {
-            let rest_chunk = &mut self.chunks[rest_chunk_idx];
-            rest_chunk.edit("".into(), Default::default());
-            rest_chunk_idx = rest_chunk.next.unwrap();
-        }
         self
     }
 }

src/magic_string/update.rs

@@ -0,0 +1,86 @@
+use crate::{basic_types::AssertIntoU32, chunk::EditOptions, CowStr, MagicString};
+
+#[derive(Debug, Default, Clone)]
+pub struct UpdateOptions {
+    /// `true` will store the original content in the `name` field of the generated sourcemap.
+    pub keep_original: bool,
+
+    /// `true` will clear the `intro` and `outro` for the corresponding range.
+    pub overwrite: bool,
+}
+
+impl<'text> MagicString<'text> {
+    /// A shorthand for `update_with(start, end, content, Default::default())`;
+    pub fn update(
+        &mut self,
+        start: impl AssertIntoU32,
+        end: impl AssertIntoU32,
+        content: impl Into<CowStr<'text>>,
+    ) -> &mut Self {
+        self.update_with(start, end, content, Default::default())
+    }
+
+    pub fn update_with(
+        &mut self,
+        start: impl AssertIntoU32,
+        end: impl AssertIntoU32,
+        content: impl Into<CowStr<'text>>,
+        opts: UpdateOptions,
+    ) -> &mut Self {
+        self.update_with_inner(
+            start.assert_into_u32(),
+            end.assert_into_u32(),
+            content.into(),
+            opts,
+            true,
+        );
+        self
+    }
+
+    // --- private
+
+    pub(super) fn update_with_inner(
+        &mut self,
+        start: u32,
+        end: u32,
+        content: CowStr<'text>,
+        opts: UpdateOptions,
+        panic_if_start_equal_end: bool,
+    ) -> &mut Self {
+        let start = start as u32;
+        let end = end as u32;
+        if panic_if_start_equal_end && start == end {
+            panic!(
+                "Cannot overwrite a zero-length range – use append_left or prepend_right instead"
+            )
+        }
+        assert!(start < end);
+        self.split_at(start);
+        self.split_at(end);
+
+        let start_idx = self.chunk_by_start.get(&start).copied().unwrap();
+        let end_idx = self.chunk_by_end.get(&end).copied().unwrap();
+
+        let start_chunk = &mut self.chunks[start_idx];
+        start_chunk.edit(
+            content.into(),
+            EditOptions {
+                overwrite: opts.overwrite,
+                store_name: opts.keep_original,
+            },
+        );
+
+        let mut rest_chunk_idx = if start_idx != end_idx {
+            start_chunk.next.unwrap()
+        } else {
+            return self;
+        };
+
+        while rest_chunk_idx != end_idx {
+            let rest_chunk = &mut self.chunks[rest_chunk_idx];
+            rest_chunk.edit("".into(), Default::default());
+            rest_chunk_idx = rest_chunk.next.unwrap();
+        }
+        self
+    }
+}

tests/magic_string.rs

@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 
+use string_wizard::IndentOptions;
 use string_wizard::MagicString;
 use string_wizard::MagicStringOptions;
 use string_wizard::UpdateOptions;
@@ -11,6 +12,8 @@ trait MagicStringExt<'text> {
         end: usize,
         content: impl Into<Cow<'text, str>>,
     ) -> &mut Self;
+
+    fn indent_str(&mut self, indent_str: &str) -> &mut Self;
 }
 
 impl<'text> MagicStringExt<'text> for MagicString<'text> {
@@ -30,6 +33,14 @@ impl<'text> MagicStringExt<'text> for MagicString<'text> {
             },
         )
     }
+       /// Shortcut for `indent_with(IndentOptions { indent_str: Some(indent_str), ..Default::default() })`
+    fn indent_str(&mut self, indent_str: &str) -> &mut Self {
+        self.indent_with(IndentOptions {
+            indentor: Some(indent_str),
+            ..Default::default()
+        })
+    }
+
 }
 
 mod options {
@@ -329,12 +340,12 @@ mod indent {
     fn should_prevent_excluded_characters_from_being_indented() {
         let mut s = MagicString::new("abc\ndef\nghi\njkl");
         s.indent_with(IndentOptions {
-            indent_str: Some("  "),
+            indentor: Some("  "),
             exclude: vec![7, 15],
         });
         assert_eq!(s.to_string(), "  abc\n  def\nghi\njkl");
         s.indent_with(IndentOptions {
-            indent_str: Some(">>"),
+            indentor: Some(">>"),
             exclude: vec![7, 15],
         });
         assert_eq!(s.to_string(), ">>  abc\n>>  def\nghi\njkl");