basic impl

Author: hyf0

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "cSpell.words": [
+        "outro"
+    ]
+}

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "string_wizard"
+version = "0.0.1"
+edition = "2021"
+license = "MIT"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+index_vec = { version = "0.1.3" }
+rustc-hash = { version = "1.1.0" }
+text-size = "1.1.1"

src/chunk.rs

@@ -0,0 +1,38 @@
+use crate::{CowStr, span::Span, ChunkIdx};
+
+#[derive(Debug, Default)]
+pub struct Chunk<'s> {
+    intro: Vec<CowStr<'s>>,
+    span: Span,
+    outro: Vec<CowStr<'s>>,
+    len: usize,
+    pub(crate) next: Option<ChunkIdx>
+}
+
+impl<'s> Chunk<'s> {
+    pub fn new(span: Span) -> Self {
+        Self {
+            len: span.size(),
+            span,
+            ..Default::default()
+        }
+    }
+}
+
+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)
+    }
+
+    pub fn append_outro(&mut self, frag: CowStr<'s>) {
+        self.len += frag.len();
+        self.outro.push(frag.into())
+    }
+
+    pub fn len(&self) -> usize {
+        self.len
+    }
+}

src/joiner.rs

@@ -0,0 +1,39 @@
+use crate::{MagicString, CowStr};
+
+#[derive(Default)]
+pub struct Joiner<'s> {
+    sources: Vec<MagicString<'s>>,
+}
+
+impl<'s> Joiner<'s> {
+    // --- public
+    pub fn append(&mut self, source: MagicString<'s>) -> &mut Self {
+        self.sources.push(source);
+        self
+    }
+
+    pub fn append_raw(&mut self, raw: impl Into<CowStr<'s>>) -> &mut Self {
+        self.sources.push(MagicString::new(raw));
+        self
+    }
+
+    pub fn len(&self) -> usize {
+        self.sources.iter().map(|s| s.len()).sum()
+    }
+
+    pub fn join(&self) -> String {
+        let mut ret = String::with_capacity(self.len());
+        self.fragments().for_each(|frag| {
+            ret.push_str(frag);
+        });
+        ret
+    }
+
+    // --- private
+
+    fn fragments(&'s self) -> impl Iterator<Item = &'s str> {
+        self.sources.iter().flat_map(|c| c.fragments())
+    }
+
+    
+}

src/lib.rs

@@ -0,0 +1,28 @@
+
+mod chunk;
+mod span;
+mod joiner;
+mod magic_string;
+use std::borrow::Cow;
+
+type CowStr<'s> = Cow<'s, str>;
+
+use chunk::Chunk;
+use index_vec::IndexVec;
+
+pub use crate::{magic_string::{MagicString, MagicStringOptions}, joiner::Joiner};
+
+
+index_vec::define_index_type! {
+    struct ChunkIdx = u32;
+}
+
+type ChunkVec<'s> = IndexVec<ChunkIdx, Chunk<'s>>;
+
+index_vec::define_index_type! {
+    struct SourceIdx = u32;
+}
+
+
+
+pub struct Bundle {}

src/magic_string.rs

@@ -0,0 +1,120 @@
+use rustc_hash::FxHashMap;
+
+use crate::{chunk::Chunk, span::Span, ChunkIdx, ChunkVec, CowStr};
+
+#[derive(Debug, Default)]
+pub struct MagicStringOptions {
+    pub filename: Option<String>,
+}
+
+#[derive(Default)]
+pub struct MagicString<'s> {
+    source: CowStr<'s>,
+    source_len: u32,
+    chunks: ChunkVec<'s>,
+    first_chunk: Option<ChunkIdx>,
+    chunk_by_start: FxHashMap<u32, ChunkIdx>,
+    chunk_by_end: FxHashMap<u32, ChunkIdx>,
+    pub filename: Option<String>,
+}
+
+impl<'s> MagicString<'s> {
+    // --- public
+
+    pub fn new(source: impl Into<CowStr<'s>>) -> Self {
+        Self::with_options(source, Default::default())
+    }
+
+    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 mut magic_string = Self {
+            source,
+            source_len,
+            ..Default::default()
+        };
+        magic_string.split_at(source_len);
+        magic_string.first_chunk = Some(ChunkIdx::from_raw(0));
+
+        magic_string.filename = options.filename;
+
+        magic_string
+    }
+
+    pub fn append(&mut self, source: impl Into<CowStr<'s>>) -> &mut Self {
+        self.last_chunk_mut().append_outro(source.into());
+        self
+    }
+
+    pub fn len(&self) -> usize {
+        self.chunks.iter().map(|c| c.len()).sum()
+    }
+
+    pub fn to_string(&self) -> String {
+        let size_hint = self.len();
+        let mut ret = String::with_capacity(size_hint);
+        self.fragments().for_each(|f| ret.push_str(f));
+        ret
+    }
+
+    // --- private
+
+    fn iter_chunks(&self) -> impl Iterator<Item = &Chunk> {
+        ChunkIter {
+            next: self.first_chunk,
+            chunks: &self.chunks,
+        }
+    }
+
+    pub(crate) fn fragments(&'s self) -> impl Iterator<Item = &'s str> {
+        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 {
+        }
+    }
+
+    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
+    }
+
+    fn last_chunk_mut(&mut self) -> &mut Chunk<'s> {
+        let idx = self.chunk_by_end.get(&(self.source_len)).unwrap();
+        &mut self.chunks[*idx]
+    }
+}
+
+struct ChunkIter<'a> {
+    next: Option<ChunkIdx>,
+    chunks: &'a ChunkVec<'a>,
+}
+
+impl<'a> Iterator for ChunkIter<'a> {
+    type Item = &'a Chunk<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.next.take().map(|next| {
+            let chunk = &self.chunks[next];
+            self.next = chunk.next;
+
+            chunk
+        })
+    }
+}

src/span.rs

@@ -0,0 +1,20 @@
+#[derive(Debug, Default, Clone, Copy)]
+pub struct Span(pub u32, pub u32);
+
+impl Span {
+    pub fn start(&self) -> u32 {
+        self.0
+    }
+
+    pub fn end(&self) -> u32 {
+        self.1
+    }
+
+    pub fn text<'s>(&self, source: &'s str) -> &'s str {
+        &source[self.start() as usize..self.end() as usize]
+    }
+
+    pub fn size(&self) -> usize {
+        (self.1 - self.0) as usize
+    }
+}

tests/joiner.rs

@@ -0,0 +1,12 @@
+use string_wizard::{Joiner, MagicString};
+mod append {
+    use super::*;
+
+    #[test]
+    fn should_append_content() {
+        let mut j = Joiner::default();
+        j.append(MagicString::new("*"));
+        j.append_raw("123").append_raw("456");
+        assert_eq!(j.join(), "*123456");
+    }
+}

tests/magic_string.rs

@@ -0,0 +1,30 @@
+use string_wizard::MagicString;
+
+use string_wizard::MagicStringOptions;
+mod options {
+    use super::*;
+    #[test]
+    fn stores_source_file_information() {
+        let s = MagicString::with_options(
+            "abc",
+            MagicStringOptions {
+                filename: Some("foo.js".to_string()),
+            },
+        );
+        assert_eq!(s.filename, Some("foo.js".to_string()))
+    }
+}
+
+mod append {
+    use super::*;
+    
+    #[test]
+    fn should_append_content() {
+        // should append content
+        let mut s = MagicString::new("abcdefghijkl");
+        s.append("xyz");
+        assert_eq!(s.to_string(), "abcdefghijklxyz");
+        s.append("xyz");
+        assert_eq!(s.to_string(), "abcdefghijklxyzxyz");
+    }
+}