feat: support indent

Author: hyf0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "string_wizard"
-version = "0.0.9"
+version = "0.0.10"
 edition = "2021"
 license = "MIT"
 description = "manipulate string like wizards"
@@ -10,6 +10,7 @@ description = "manipulate string like wizards"
 [dependencies]
 index_vec = { version = "0.1.3" }
 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 }
 

src/basic_types.rs

@@ -1,43 +1,4 @@
-use std::{borrow::Cow, fmt::Debug};
-
-#[derive(Debug, Clone)]
-pub struct BasicCowStr<'text> {
-    inner: Cow<'text, str>,
-}
-
-impl<'text> BasicCowStr<'text> {
-    pub fn new(inner: Cow<'text, str>) -> Self {
-        assert!(
-            u32::try_from(inner.len()).is_ok(),
-            "We only support string up to 4GB in size, which is the maximum size of the u32."
-        );
-        Self { inner }
-    }
-
-    pub fn len(&self) -> u32 {
-        // We can safely do converting here because we have already asserted that
-        // the length of the string is less than or equal `u32::MAX`
-        self.inner.len() as u32
-    }
-
-    pub fn as_str(&self) -> &str {
-        self.inner.as_ref()
-    }
-}
-
-impl<'text> std::ops::Deref for BasicCowStr<'text> {
-    type Target = Cow<'text, str>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<'text, T: Into<Cow<'text, str>>> From<T> for BasicCowStr<'text> {
-    fn from(value: T) -> Self {
-        Self::new(value.into())
-    }
-}
+use std::{fmt::Debug};
 
 // This is basically doing the same thing as `TryInto<u32>`.
 // If we use `TryInto<u32>`, we need to put `where <T as TryInto<u32>>::Error: Debug` everywhere.

src/chunk.rs

@@ -107,8 +107,8 @@ impl<'str> Chunk<'str> {
         let source_frag = self
             .edited_content
             .as_ref()
-            .map(|s| s.as_str())
-            .unwrap_or_else(|| self.span.text(original_source.as_str()));
+            .map(|s| s.as_ref())
+            .unwrap_or_else(|| self.span.text(&original_source));
         let outro_iter = self.outro.iter().map(|frag| frag.as_ref());
         intro_iter.chain(Some(source_frag)).chain(outro_iter)
     }

src/lib.rs

@@ -7,15 +7,16 @@ mod magic_string;
 mod source_map;
 mod span;
 
-type CowStr<'text> = BasicCowStr<'text>;
+type CowStr<'text> = Cow<'text, str>;
 
 pub(crate) type TextSize = u32;
 
-use basic_types::BasicCowStr;
+use std::borrow::Cow;
+
 
 pub use crate::{
     joiner::{Joiner, JoinerOptions},
-    magic_string::{mutation::UpdateOptions, MagicString, MagicStringOptions},
+    magic_string::{mutation::UpdateOptions, MagicString, MagicStringOptions, indent::IndentOptions},
 };
 
 #[cfg(feature = "source_map")]

src/magic_string/indent.rs

@@ -0,0 +1,155 @@
+use crate::{CowStr, MagicString};
+
+fn guess_indent_str(source: &str) -> Option<String> {
+    let mut tabbed_count = 0;
+    let mut spaced_line = vec![];
+    for line in source.lines() {
+        if line.starts_with('\t') {
+            tabbed_count += 1;
+        } else if line.starts_with("  ") {
+            spaced_line.push(line);
+        }
+    }
+
+    if tabbed_count == 0 && spaced_line.is_empty() {
+        return None;
+    }
+
+    if tabbed_count >= spaced_line.len() {
+        return Some("\t".to_string());
+    }
+
+    let min_space_count = spaced_line
+        .iter()
+        .map(|line| line.chars().take_while(|c| *c == ' ').count())
+        .min()
+        .unwrap_or(0);
+
+    let mut indent_str = String::with_capacity(min_space_count);
+    for _ in 0..min_space_count {
+        indent_str.push(' ');
+    }
+    Some(indent_str)
+}
+
+#[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>,
+}
+
+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 indent(&mut self) -> &mut Self {
+        self.indent_with(IndentOptions { indent_str: None })
+    }
+
+    /// 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),
+        })
+    }
+
+    pub fn indent_with(&mut self, opts: IndentOptions<'_>) -> &mut Self {
+        if opts.indent_str.map_or(false, |s| s.is_empty()) {
+            return self;
+        }
+        struct IndentReplacer {
+            should_indent_next_char: bool,
+            indent_str: String,
+        }
+
+        impl regex::Replacer for &mut &mut IndentReplacer {
+            fn replace_append(&mut self, caps: &regex::Captures<'_>, dst: &mut String) {
+                if self.should_indent_next_char {
+                    dst.push_str(&self.indent_str);
+                }
+                for cap in caps.iter() {
+                    if let Some(cap) = cap {
+                        dst.push_str(cap.as_str());
+                    }
+                }
+            }
+        }
+
+        fn indent_frag<'text>(
+            frag: &mut CowStr<'text>,
+            pattern: &regex::Regex,
+            mut indent_replacer: &mut IndentReplacer,
+        ) {
+            match frag {
+                std::borrow::Cow::Borrowed(str) => {
+                    let might_replaced = pattern.replace_all(str, &mut indent_replacer);
+                    *frag = might_replaced;
+                }
+                std::borrow::Cow::Owned(str) => {
+                    let might_replaced = pattern.replace_all(str, &mut indent_replacer);
+                    match might_replaced {
+                        std::borrow::Cow::Owned(replaced) => {
+                            *frag = replaced.into();
+                        }
+                        std::borrow::Cow::Borrowed(_) => {
+                            // Since nothing was replaced, we can just use the original string.
+                        }
+                    }
+                }
+            }
+        }
+
+        let indent_str = opts.indent_str.unwrap_or_else(|| self.ensure_indent_str());
+
+        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(),
+        };
+
+        for intro_frag in self.intro.iter_mut() {
+            indent_frag(intro_frag, &pattern, &mut indent_replacer)
+        }
+
+        let mut next_chunk_id = Some(self.first_chunk_idx);
+
+        while let Some(chunk_idx) = next_chunk_id {
+            // Make sure the `next_chunk_id` is updated before we split the chunk. Otherwise, we
+            // might process the same chunk twice.
+            next_chunk_id = self.chunks[chunk_idx].next;
+            if let Some(edited_content) = self.chunks[chunk_idx].edited_content.as_mut() {
+                indent_frag(edited_content, &pattern, &mut indent_replacer);
+            } else {
+                let chunk = &self.chunks[chunk_idx];
+                let mut line_starts = vec![];
+                let mut char_index = chunk.start();
+                for char in chunk.span.text(&self.source).chars() {
+                    debug_assert!(self.source.is_char_boundary(char_index as usize));
+                    if char == '\n' {
+                        indent_replacer.should_indent_next_char = true;
+                    } else if char != '\r' && indent_replacer.should_indent_next_char {
+                        indent_replacer.should_indent_next_char = false;
+                        debug_assert!(!line_starts.contains(&char_index));
+                        line_starts.push(char_index);
+                    }
+                    char_index += char.len_utf8() as u32;
+                }
+                for line_start in line_starts {
+                    self.prepend_right(line_start, indent_replacer.indent_str.clone());
+                }
+            }
+        }
+
+        for frag in self.outro.iter_mut() {
+            indent_frag(frag, &pattern, &mut indent_replacer)
+        }
+
+        self
+    }
+}

src/magic_string/mod.rs

@@ -1,3 +1,4 @@
+pub mod indent;
 pub mod mutation;
 #[cfg(feature = "source_map")]
 pub mod source_map;
@@ -23,8 +24,9 @@ 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,
@@ -41,26 +43,29 @@ impl<'text> MagicString<'text> {
 
     pub fn with_options(source: impl Into<CowStr<'text>>, options: MagicStringOptions) -> Self {
         let source = source.into();
-        let initial_chunk = Chunk::new(Span(0, source.len()));
+        let source_len = u32::try_from(source.len()).unwrap();
+        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 {
             intro: Default::default(),
             outro: Default::default(),
             source,
+            source_len,
             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,
+            indent_str: None,
         };
 
         magic_string.chunk_by_start.insert(0, initial_chunk_idx);
         magic_string
             .chunk_by_end
-            .insert(magic_string.source.len(), initial_chunk_idx);
+            .insert(source_len, initial_chunk_idx);
 
         magic_string
     }
@@ -201,15 +206,13 @@ impl<'text> MagicString<'text> {
     /// Chunk{span: (0, 3)} => "abc"
     /// Chunk{span: (3, 7)} => "defg"
     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)
+        if at_index == 0 || at_index >= self.source_len || self.chunk_by_end.contains_key(&at_index)
         {
             return;
         }
 
         let (mut candidate, mut candidate_idx, search_right) =
-            if (self.source.len() - at_index) > at_index {
+            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)
@@ -250,7 +253,7 @@ impl<'text> MagicString<'text> {
 
     fn by_start_mut(&mut self, text_index: impl AssertIntoU32) -> Option<&mut Chunk<'text>> {
         let text_index = text_index.assert_into_u32();
-        if text_index == self.source.len() {
+        if text_index == self.source_len {
             None
         } else {
             self.split_at(text_index);
@@ -298,3 +301,4 @@ impl<'a> Iterator for ChunkIter<'a> {
         })
     }
 }
+

src/magic_string/source_map.rs

@@ -55,7 +55,7 @@ impl<'s> MagicString<'s> {
             sources: vec!["".to_string()],
             sources_content: opts
                 .include_content
-                .then(|| vec![self.source.as_str().to_string()])
+                .then(|| vec![self.source.as_ref().to_string()])
                 .unwrap_or_default(),
             mappings,
             names,