refactor: source() return SourceValue (#185)

Author: SyMind

src/cached_source.rs

@@ -12,6 +12,7 @@ use crate::{
     stream_chunks_of_source_map, StreamChunks,
   },
   rope::Rope,
+  source::SourceValue,
   BoxSource, MapOptions, Source, SourceExt, SourceMap,
 };
 
@@ -30,11 +31,11 @@ struct CachedData {
 /// ```
 /// use rspack_sources::{
 ///   BoxSource, CachedSource, ConcatSource, MapOptions, OriginalSource,
-///   RawSource, Source, SourceExt, SourceMap,
+///   RawStringSource, Source, SourceExt, SourceMap,
 /// };
 ///
 /// let mut concat = ConcatSource::new([
-///   RawSource::from("Hello World\n".to_string()).boxed(),
+///   RawStringSource::from("Hello World\n".to_string()).boxed(),
 ///   OriginalSource::new(
 ///     "console.log('test');\nconsole.log('test2');\n",
 ///     "console.js",
@@ -46,12 +47,12 @@ struct CachedData {
 /// let cached = CachedSource::new(concat);
 ///
 /// assert_eq!(
-///   cached.source(),
+///   cached.source().into_string_lossy(),
 ///   "Hello World\nconsole.log('test');\nconsole.log('test2');\nHello2\n"
 /// );
 /// // second time will be fast.
 /// assert_eq!(
-///   cached.source(),
+///   cached.source().into_string_lossy(),
 ///   "Hello World\nconsole.log('test');\nconsole.log('test2');\nHello2\n"
 /// );
 /// ```
@@ -79,7 +80,7 @@ impl CachedSource {
 }
 
 impl Source for CachedSource {
-  fn source(&self) -> Cow<str> {
+  fn source(&self) -> SourceValue {
     self.inner.source()
   }
 
@@ -209,16 +210,16 @@ impl std::fmt::Debug for CachedSource {
 #[cfg(test)]
 mod tests {
   use crate::{
-    ConcatSource, OriginalSource, RawBufferSource, RawSource, ReplaceSource,
-    SourceExt, SourceMapSource, WithoutOriginalOptions,
+    ConcatSource, OriginalSource, RawBufferSource, RawStringSource,
+    ReplaceSource, SourceExt, SourceMapSource, WithoutOriginalOptions,
   };
 
   use super::*;
 
   #[test]
   fn line_number_should_not_add_one() {
     let source = ConcatSource::new([
-      CachedSource::new(RawSource::from("\n")).boxed(),
+      CachedSource::new(RawStringSource::from("\n")).boxed(),
       SourceMapSource::new(WithoutOriginalOptions {
         value: "\nconsole.log(1);\n".to_string(),
         name: "index.js".to_string(),
@@ -305,7 +306,7 @@ mod tests {
       final_source: true,
     };
 
-    let source = RawSource::from("Test\nTest\nTest\n");
+    let source = RawStringSource::from("Test\nTest\nTest\n");
     let mut on_chunk_count = 0;
     let mut on_source_count = 0;
     let mut on_name_count = 0;
@@ -355,7 +356,7 @@ mod tests {
   #[test]
   fn should_have_correct_buffer_if_cache_buffer_from_cache_source() {
     let buf = vec![128u8];
-    let source = CachedSource::new(RawSource::from(buf.clone()));
+    let source = CachedSource::new(RawBufferSource::from(buf.clone()));
 
     source.source();
     assert_eq!(source.buffer(), buf.as_slice());

src/concat_source.rs

@@ -10,7 +10,7 @@ use crate::{
   helpers::{get_map, GeneratedInfo, OnChunk, OnName, OnSource, StreamChunks},
   linear_map::LinearMap,
   source::{Mapping, OriginalLocation},
-  BoxSource, MapOptions, Rope, Source, SourceExt, SourceMap,
+  BoxSource, MapOptions, Rope, Source, SourceExt, SourceMap, SourceValue,
 };
 
 /// Concatenate multiple [Source]s to a single [Source].
@@ -19,12 +19,12 @@ use crate::{
 ///
 /// ```
 /// use rspack_sources::{
-///   BoxSource, ConcatSource, MapOptions, OriginalSource, RawSource, Source,
+///   BoxSource, ConcatSource, MapOptions, OriginalSource, RawStringSource, Source,
 ///   SourceExt, SourceMap,
 /// };
 ///
 /// let mut source = ConcatSource::new([
-///   RawSource::from("Hello World\n".to_string()).boxed(),
+///   RawStringSource::from("Hello World\n".to_string()).boxed(),
 ///   OriginalSource::new(
 ///     "console.log('test');\nconsole.log('test2');\n",
 ///     "console.js",
@@ -35,7 +35,7 @@ use crate::{
 ///
 /// assert_eq!(source.size(), 62);
 /// assert_eq!(
-///   source.source(),
+///   source.source().into_string_lossy(),
 ///   "Hello World\nconsole.log('test');\nconsole.log('test2');\nHello2\n"
 /// );
 /// assert_eq!(
@@ -117,13 +117,16 @@ impl ConcatSource {
 }
 
 impl Source for ConcatSource {
-  fn source(&self) -> Cow<str> {
+  fn source(&self) -> SourceValue {
     let children = self.children();
     if children.len() == 1 {
       children[0].source()
     } else {
-      let all = self.children().iter().map(|child| child.source()).collect();
-      Cow::Owned(all)
+      let mut content = String::new();
+      for child in self.children() {
+        content.push_str(child.source().into_string_lossy().as_ref());
+      }
+      SourceValue::String(Cow::Owned(content))
     }
   }
 
@@ -355,14 +358,14 @@ impl StreamChunks for ConcatSource {
 
 #[cfg(test)]
 mod tests {
-  use crate::{OriginalSource, RawBufferSource, RawSource, RawStringSource};
+  use crate::{OriginalSource, RawBufferSource, RawStringSource};
 
   use super::*;
 
   #[test]
   fn should_concat_two_sources() {
     let mut source = ConcatSource::new([
-      RawSource::from("Hello World\n".to_string()).boxed(),
+      RawStringSource::from("Hello World\n".to_string()).boxed(),
       OriginalSource::new(
         "console.log('test');\nconsole.log('test2');\n",
         "console.js",
@@ -374,7 +377,7 @@ mod tests {
     let expected_source =
       "Hello World\nconsole.log('test');\nconsole.log('test2');\nHello2\n";
     assert_eq!(source.size(), 62);
-    assert_eq!(source.source(), expected_source);
+    assert_eq!(source.source().into_string_lossy(), expected_source);
     assert_eq!(
       source.map(&MapOptions::new(false)).unwrap(),
       SourceMap::from_json(
@@ -424,7 +427,7 @@ mod tests {
     let expected_source =
       "Hello World\nconsole.log('test');\nconsole.log('test2');\nHello2\n";
     assert_eq!(source.size(), 62);
-    assert_eq!(source.source(), expected_source);
+    assert_eq!(source.source().into_string_lossy(), expected_source);
     assert_eq!(
       source.map(&MapOptions::new(false)).unwrap(),
       SourceMap::from_json(
@@ -474,7 +477,7 @@ mod tests {
     let expected_source =
       "Hello World\nconsole.log('test');\nconsole.log('test2');\nHello2\n";
     assert_eq!(source.size(), 62);
-    assert_eq!(source.source(), expected_source);
+    assert_eq!(source.source().into_string_lossy(), expected_source);
     assert_eq!(
       source.map(&MapOptions::new(false)).unwrap(),
       SourceMap::from_json(
@@ -512,18 +515,21 @@ mod tests {
   #[test]
   fn should_be_able_to_handle_strings_for_all_methods() {
     let mut source = ConcatSource::new([
-      RawSource::from("Hello World\n".to_string()).boxed(),
+      RawStringSource::from("Hello World\n".to_string()).boxed(),
       OriginalSource::new(
         "console.log('test');\nconsole.log('test2');\n",
         "console.js",
       )
       .boxed(),
     ]);
-    let inner_source =
-      ConcatSource::new([RawSource::from("("), "'string'".into(), ")".into()]);
-    source.add(RawSource::from("console"));
-    source.add(RawSource::from("."));
-    source.add(RawSource::from("log"));
+    let inner_source = ConcatSource::new([
+      RawStringSource::from("("),
+      "'string'".into(),
+      ")".into(),
+    ]);
+    source.add(RawStringSource::from("console"));
+    source.add(RawStringSource::from("."));
+    source.add(RawStringSource::from("log"));
     source.add(inner_source);
     let expected_source =
       "Hello World\nconsole.log('test');\nconsole.log('test2');\nconsole.log('string')";
@@ -538,7 +544,7 @@ mod tests {
     )
     .unwrap();
     assert_eq!(source.size(), 76);
-    assert_eq!(source.source(), expected_source);
+    assert_eq!(source.source().into_string_lossy(), expected_source);
     assert_eq!(source.buffer(), expected_source.as_bytes());
 
     let map = source.map(&MapOptions::new(false)).unwrap();
@@ -550,16 +556,19 @@ mod tests {
   #[test]
   fn should_return_null_as_map_when_only_generated_code_is_concatenated() {
     let source = ConcatSource::new([
-      RawSource::from("Hello World\n"),
-      RawSource::from("Hello World\n".to_string()),
-      RawSource::from(""),
+      RawStringSource::from("Hello World\n"),
+      RawStringSource::from("Hello World\n".to_string()),
+      RawStringSource::from(""),
     ]);
 
     let result_text = source.source();
     let result_map = source.map(&MapOptions::default());
     let result_list_map = source.map(&MapOptions::new(false));
 
-    assert_eq!(result_text, "Hello World\nHello World\n");
+    assert_eq!(
+      result_text.into_string_lossy(),
+      "Hello World\nHello World\n"
+    );
     assert!(result_map.is_none());
     assert!(result_list_map.is_none());
   }
@@ -568,13 +577,13 @@ mod tests {
   fn should_allow_to_concatenate_in_a_single_line() {
     let source = ConcatSource::new([
       OriginalSource::new("Hello", "hello.txt").boxed(),
-      RawSource::from(" ").boxed(),
+      RawStringSource::from(" ").boxed(),
       OriginalSource::new("World ", "world.txt").boxed(),
-      RawSource::from("is here\n").boxed(),
+      RawStringSource::from("is here\n").boxed(),
       OriginalSource::new("Hello\n", "hello.txt").boxed(),
-      RawSource::from(" \n").boxed(),
+      RawStringSource::from(" \n").boxed(),
       OriginalSource::new("World\n", "world.txt").boxed(),
-      RawSource::from("is here").boxed(),
+      RawStringSource::from("is here").boxed(),
     ]);
 
     assert_eq!(
@@ -591,36 +600,44 @@ mod tests {
       .unwrap(),
     );
     assert_eq!(
-      source.source(),
+      source.source().into_string_lossy(),
       "Hello World is here\nHello\n \nWorld\nis here",
     );
   }
 
   #[test]
   fn should_allow_to_concat_buffer_sources() {
     let source = ConcatSource::new([
-      RawSource::from("a"),
-      RawSource::from(Vec::from("b")),
-      RawSource::from("c"),
+      RawStringSource::from("a"),
+      RawStringSource::from("b"),
+      RawStringSource::from("c"),
     ]);
-    assert_eq!(source.source(), "abc");
+    assert_eq!(source.source().into_string_lossy(), "abc");
     assert!(source.map(&MapOptions::default()).is_none());
   }
 
   #[test]
   fn should_flatten_nested_concat_sources() {
-    let inner_concat =
-      ConcatSource::new([RawSource::from("Hello "), RawSource::from("World")]);
+    let inner_concat = ConcatSource::new([
+      RawStringSource::from("Hello "),
+      RawStringSource::from("World"),
+    ]);
 
     let outer_concat = ConcatSource::new([
       inner_concat.boxed(),
-      RawSource::from("!").boxed(),
-      ConcatSource::new([RawSource::from(" How"), RawSource::from(" are")])
-        .boxed(),
-      RawSource::from(" you?").boxed(),
+      RawStringSource::from("!").boxed(),
+      ConcatSource::new([
+        RawStringSource::from(" How"),
+        RawStringSource::from(" are"),
+      ])
+      .boxed(),
+      RawStringSource::from(" you?").boxed(),
     ]);
 
-    assert_eq!(outer_concat.source(), "Hello World! How are you?");
+    assert_eq!(
+      outer_concat.source().into_string_lossy(),
+      "Hello World! How are you?"
+    );
     // The key test: verify that nested ConcatSources are flattened
     // Should have 6 direct children instead of nested structure
     assert_eq!(outer_concat.children.len(), 6);

src/lib.rs

@@ -19,12 +19,12 @@ pub use cached_source::CachedSource;
 pub use concat_source::ConcatSource;
 pub use error::{Error, Result};
 pub use original_source::OriginalSource;
-pub use raw_source::{RawBufferSource, RawSource, RawStringSource};
+pub use raw_source::{RawBufferSource, RawStringSource};
 pub use replace_source::{ReplaceSource, ReplacementEnforce};
 pub use rope::Rope;
 pub use source::{
   BoxSource, MapOptions, Mapping, OriginalLocation, Source, SourceExt,
-  SourceMap,
+  SourceMap, SourceValue,
 };
 pub use source_map_source::{
   SourceMapSource, SourceMapSourceOptions, WithoutOriginalOptions,

src/original_source.rs

@@ -10,7 +10,7 @@ use crate::{
     SourceText, StreamChunks,
   },
   source::{Mapping, OriginalLocation},
-  MapOptions, Rope, Source, SourceMap,
+  MapOptions, Rope, Source, SourceMap, SourceValue,
 };
 
 /// Represents source code, it will create source map for the source code,
@@ -24,7 +24,7 @@ use crate::{
 ///
 /// let input = "if (hello()) { world(); hi(); there(); } done();\nif (hello()) { world(); hi(); there(); } done();";
 /// let source = OriginalSource::new(input, "file.js");
-/// assert_eq!(source.source(), input);
+/// assert_eq!(source.source().into_string_lossy(), input);
 /// assert_eq!(
 ///   source.map(&MapOptions::default()).unwrap().mappings(),
 ///   "AAAA,eAAe,SAAS,MAAM,WAAW;AACzC,eAAe,SAAS,MAAM,WAAW",
@@ -51,8 +51,8 @@ impl OriginalSource {
 }
 
 impl Source for OriginalSource {
-  fn source(&self) -> Cow<str> {
-    Cow::Borrowed(&self.value)
+  fn source(&self) -> SourceValue {
+    SourceValue::String(Cow::Borrowed(&self.value))
   }
 
   fn rope(&self) -> Rope<'_> {
@@ -247,7 +247,7 @@ mod tests {
     let result_map = source.map(&MapOptions::default()).unwrap();
     let result_list_map = source.map(&MapOptions::new(false)).unwrap();
 
-    assert_eq!(result_text, "Line1\n\nLine3\n");
+    assert_eq!(result_text.into_string_lossy(), "Line1\n\nLine3\n");
     assert_eq!(result_map.sources(), &["file.js".to_string()]);
     assert_eq!(result_list_map.sources(), ["file.js".to_string()]);
     assert_eq!(
@@ -269,7 +269,7 @@ mod tests {
     let result_map = source.map(&MapOptions::default());
     let result_list_map = source.map(&MapOptions::new(false));
 
-    assert_eq!(result_text, "");
+    assert_eq!(result_text.into_string_lossy(), "");
     assert!(result_map.is_none());
     assert!(result_list_map.is_none());
   }
@@ -300,7 +300,7 @@ mod tests {
   fn should_split_code_into_statements() {
     let input = "if (hello()) { world(); hi(); there(); } done();\nif (hello()) { world(); hi(); there(); } done();";
     let source = OriginalSource::new(input, "file.js");
-    assert_eq!(source.source(), input);
+    assert_eq!(source.source().into_string_lossy(), input);
     assert_eq!(
       source.map(&MapOptions::default()).unwrap().mappings(),
       "AAAA,eAAe,SAAS,MAAM,WAAW;AACzC,eAAe,SAAS,MAAM,WAAW",