Add IFlate struct giving access to uncompressed data

compress/src/lib.rs

@@ -57,7 +57,7 @@ impl fmt::Display for FlateCompressionError {
     }
 }
 
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, PartialEq)]
 pub enum CompressionMethod {
     #[cfg(feature = "deflate")]
     Deflate,
@@ -95,6 +95,17 @@ impl Default for CompressionMethod {
     }
 }
 
+impl ToString for CompressionMethod {
+    fn to_string(&self) -> String {
+        match self {
+            #[cfg(feature = "deflate")]
+            Self::Deflate => "deflate".to_owned(),
+            #[cfg(feature = "zstd")]
+            Self::Zstd => "zstd".to_owned(),
+        }
+    }
+}
+
 pub enum FlateEncoder<W: Write> {
     #[cfg(feature = "deflate")]
     Deflate(DeflateEncoder<W>),

src/lib.rs

@@ -29,8 +29,8 @@
 /// The low-level macros used by this crate.
 pub use include_flate_codegen as codegen;
 use include_flate_compress::apply_decompression;
+use std::string::FromUtf8Error;
 
-#[doc(hidden)]
 pub use include_flate_compress::CompressionMethod;
 
 /// This macro is like [`include_bytes!`][1] or [`include_str!`][2], but compresses at compile time
@@ -117,6 +117,51 @@ macro_rules! flate {
             $crate::decode_string($crate::codegen::deflate_utf8_file!($path $($algo)?), Some($crate::CompressionMethodTy(algo)))
         });
     };
+    ($(#[$meta:meta])*
+        $(pub $(($($vis:tt)+))?)? static $name:ident: IFlate from $path:literal $(with $algo:ident)?) => {
+        // HACK: workaround to make cargo auto rebuild on modification of source file
+        const _: &'static [u8] = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/", $path));
+
+        $(#[$meta])*
+        $(pub $(($($vis)+))?)? static $name: ::std::sync::LazyLock<$crate::IFlate> = ::std::sync::LazyLock::new(|| {
+            let algo = match stringify!($($algo)?){
+                "deflate" => $crate::CompressionMethod::Deflate,
+                "zstd" => $crate::CompressionMethod::Zstd,
+                _ => $crate::CompressionMethod::default(),
+            };
+            let compressed = $crate::codegen::deflate_file!($path $($algo)?);
+            $crate::IFlate::new(compressed, algo)
+        });
+    };
+}
+
+#[derive(Debug)]
+pub struct IFlate {
+    compressed: &'static [u8],
+    algo: CompressionMethod,
+}
+
+impl IFlate {
+    #[doc(hidden)]
+    pub fn new(compressed: &'static [u8], algo: CompressionMethod) -> Self {
+        Self { compressed, algo }
+    }
+
+    pub fn compressed(&self) -> &[u8] {
+        &self.compressed
+    }
+
+    pub fn decoded(&self) -> Vec<u8> {
+        decode(&self.compressed, Some(CompressionMethodTy(self.algo)))
+    }
+
+    pub fn decode_string(&self) -> Result<String, FromUtf8Error> {
+        String::from_utf8(self.decoded())
+    }
+
+    pub fn algo(&self) -> CompressionMethod {
+        self.algo
+    }
 }
 
 #[derive(Debug)]

test_util.rs

@@ -70,3 +70,19 @@ pub fn verify_str(name: &str, data: &str) {
         data
     );
 }
+
+pub fn verify_iflate<P: AsRef<Path>>(name: P, method: CompressionMethod, iflate: &include_flate::IFlate) {
+    assert_eq!(iflate.algo(), method);
+    let path = get_file_path(None, &name);
+    let mut file = File::open(&path).unwrap();
+    let mut file_buffer = Vec::new();
+    file.read_to_end(&mut file_buffer).unwrap();
+    let mut source = std::io::Cursor::new(file_buffer);
+    let mut compressed_buffer = Vec::new();
+    {
+        let mut compressed_cursor = std::io::Cursor::new(&mut compressed_buffer);
+        apply_compression(&mut source, &mut compressed_cursor, method).unwrap();
+        compressed_cursor.seek(SeekFrom::Start(0)).unwrap(); // Reset cursor position
+    }
+    assert_eq!(&iflate.compressed(), &compressed_buffer);
+}

tests/009f.rs

@@ -20,10 +20,14 @@ use include_flate::flate;
 flate!(pub static DATA1: [u8] from "assets/009f.dat");
 flate!(pub static DATA2: [u8] from "assets/009f.dat" with deflate);
 flate!(pub static DATA3: [u8] from "assets/009f.dat" with zstd);
+flate!(pub static DATA4: IFlate from "assets/009f.dat" with deflate);
+flate!(pub static DATA5: IFlate from "assets/009f.dat" with zstd);
 
 #[test]
 fn test() {
     verify("009f.dat", &DATA1);
     verify("009f.dat", &DATA2);
     verify("009f.dat", &DATA3);
+    verify_iflate("009f.dat", CompressionMethod::Deflate, &DATA4);
+    verify_iflate("009f.dat", CompressionMethod::Zstd, &DATA5);
 }

tests/ascii-control.rs

@@ -17,13 +17,17 @@ include!("../test_util.rs");
 
 use include_flate::flate;
 
-flate!(pub static DATA1: str from "assets/ascii-printable.txt");
-flate!(pub static DATA2: str from "assets/ascii-printable.txt" with deflate);
-flate!(pub static DATA3: str from "assets/ascii-printable.txt" with zstd);
+flate!(pub static DATA1: str from "assets/ascii-control.txt");
+flate!(pub static DATA2: str from "assets/ascii-control.txt" with deflate);
+flate!(pub static DATA3: str from "assets/ascii-control.txt" with zstd);
+flate!(pub static DATA4: IFlate from "assets/ascii-control.txt" with deflate);
+flate!(pub static DATA5: IFlate from "assets/ascii-control.txt" with zstd);
 
 #[test]
 fn test() {
-    verify_str("ascii-printable.txt", &DATA1);
-    verify_str("ascii-printable.txt", &DATA2);
-    verify_str("ascii-printable.txt", &DATA3);
+    verify_str("ascii-control.txt", &DATA1);
+    verify_str("ascii-control.txt", &DATA2);
+    verify_str("ascii-control.txt", &DATA3);
+    verify_iflate("ascii-control.txt", CompressionMethod::Deflate, &DATA4);
+    verify_iflate("ascii-control.txt", CompressionMethod::Zstd, &DATA5);
 }

tests/ascii-printable.rs

@@ -20,10 +20,14 @@ use include_flate::flate;
 flate!(pub static DATA1: str from "assets/ascii-printable.txt");
 flate!(pub static DATA2: str from "assets/ascii-printable.txt" with deflate);
 flate!(pub static DATA3: str from "assets/ascii-printable.txt" with zstd);
+flate!(pub static DATA4: IFlate from "assets/ascii-printable.txt" with deflate);
+flate!(pub static DATA5: IFlate from "assets/ascii-printable.txt" with zstd);
 
 #[test]
 fn test() {
     verify_str("ascii-printable.txt", &DATA1);
     verify_str("ascii-printable.txt", &DATA2);
     verify_str("ascii-printable.txt", &DATA3);
+    verify_iflate("ascii-printable.txt", CompressionMethod::Deflate, &DATA4);
+    verify_iflate("ascii-printable.txt", CompressionMethod::Zstd, &DATA5);
 }

tests/base64.rs

@@ -17,13 +17,20 @@ include!("../test_util.rs");
 
 use include_flate::flate;
 
+pub static DATA_RAW: &[u8] =
+    include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/assets/base64.txt"));
+
 flate!(pub static DATA1: str from "assets/base64.txt");
 flate!(pub static DATA2: str from "assets/base64.txt" with deflate);
 flate!(pub static DATA3: str from "assets/base64.txt" with zstd);
+flate!(pub static DATA4: IFlate from "assets/base64.txt" with deflate);
+flate!(pub static DATA5: IFlate from "assets/base64.txt" with zstd);
 
 #[test]
 fn test() {
     verify_str("base64.txt", &DATA1);
     verify_str("base64.txt", &DATA2);
     verify_str("base64.txt", &DATA3);
+    verify_iflate("base64.txt", CompressionMethod::Deflate, &DATA4);
+    verify_iflate("base64.txt", CompressionMethod::Zstd, &DATA5);
 }

tests/chinese.rs

@@ -20,10 +20,14 @@ use include_flate::flate;
 flate!(pub static DATA1: str from "assets/chinese.txt");
 flate!(pub static DATA2: str from "assets/chinese.txt" with deflate);
 flate!(pub static DATA3: str from "assets/chinese.txt" with zstd);
+flate!(pub static DATA4: IFlate from "assets/chinese.txt" with deflate);
+flate!(pub static DATA5: IFlate from "assets/chinese.txt" with zstd);
 
 #[test]
 fn test() {
     verify_str("chinese.txt", &DATA1);
     verify_str("chinese.txt", &DATA2);
     verify_str("chinese.txt", &DATA3);
+    verify_iflate("chinese.txt", CompressionMethod::Deflate, &DATA4);
+    verify_iflate("chinese.txt", CompressionMethod::Zstd, &DATA5);
 }

tests/emoji.rs

@@ -20,10 +20,14 @@ use include_flate::flate;
 flate!(pub static DATA1: str from "assets/emoji.txt");
 flate!(pub static DATA2: str from "assets/emoji.txt" with deflate);
 flate!(pub static DATA3: str from "assets/emoji.txt" with zstd);
+flate!(pub static DATA4: IFlate from "assets/emoji.txt" with deflate);
+flate!(pub static DATA5: IFlate from "assets/emoji.txt" with zstd);
 
 #[test]
 fn test() {
     verify_str("emoji.txt", &DATA1);
     verify_str("emoji.txt", &DATA2);
     verify_str("emoji.txt", &DATA3);
+    verify_iflate("emoji.txt", CompressionMethod::Deflate, &DATA4);
+    verify_iflate("emoji.txt", CompressionMethod::Zstd, &DATA5);
 }

tests/ff.rs

@@ -20,10 +20,14 @@ use include_flate::flate;
 flate!(pub static DATA1: [u8] from "assets/ff.dat");
 flate!(pub static DATA2: [u8] from "assets/ff.dat" with deflate);
 flate!(pub static DATA3: [u8] from "assets/ff.dat" with zstd);
+flate!(pub static DATA4: IFlate from "assets/ff.dat" with deflate);
+flate!(pub static DATA5: IFlate from "assets/ff.dat" with zstd);
 
 #[test]
 fn test() {
     verify("ff.dat", &DATA1);
     verify("ff.dat", &DATA2);
     verify("ff.dat", &DATA3);
+    verify_iflate("ff.dat", CompressionMethod::Deflate, &DATA4);
+    verify_iflate("ff.dat", CompressionMethod::Zstd, &DATA5);
 }

tests/random.rs

@@ -20,10 +20,14 @@ use include_flate::flate;
 flate!(pub static DATA1: [u8] from "assets/random.dat");
 flate!(pub static DATA2: [u8] from "assets/random.dat" with deflate);
 flate!(pub static DATA3: [u8] from "assets/random.dat" with zstd);
+flate!(pub static DATA4: IFlate from "assets/random.dat" with deflate);
+flate!(pub static DATA5: IFlate from "assets/random.dat" with zstd);
 
 #[test]
 fn test() {
     verify("random.dat", &DATA1);
     verify("random.dat", &DATA2);
     verify("random.dat", &DATA3);
+    verify_iflate("random.dat", CompressionMethod::Deflate, &DATA4);
+    verify_iflate("random.dat", CompressionMethod::Zstd, &DATA5);
 }

tests/zero.rs

@@ -20,10 +20,14 @@ use include_flate::flate;
 flate!(pub static DATA1: [u8] from "assets/zero.dat");
 flate!(pub static DATA2: [u8] from "assets/zero.dat" with deflate);
 flate!(pub static DATA3: [u8] from "assets/zero.dat" with zstd);
+flate!(pub static DATA4: IFlate from "assets/zero.dat" with deflate);
+flate!(pub static DATA5: IFlate from "assets/zero.dat" with zstd);
 
 #[test]
 fn test() {
     verify("zero.dat", &DATA1);
     verify("zero.dat", &DATA2);
     verify("zero.dat", &DATA3);
+    verify_iflate("zero.dat", CompressionMethod::Deflate, &DATA4);
+    verify_iflate("zero.dat", CompressionMethod::Zstd, &DATA5);
 }