Rewrite untar: Takes a filter fn instead of array

Signed-off-by: Jiahao XU <Jiahao_XU@outlook.com>

src/helpers/async_extracter.rs

@@ -1,4 +1,3 @@
-use std::borrow::Cow;
 use std::fs;
 use std::io::{self, Seek, Write};
 use std::path::Path;
@@ -29,12 +28,14 @@ struct AsyncExtracterInner {
 }
 
 impl AsyncExtracterInner {
-    ///  * `desired_outputs - If Some(_), then it will filter the tar
-    ///    and only extract files specified in it.
-    fn new<const N: usize>(
+    ///  * `filter` - If Some, then it will pass the path of the file to it
+    ///    and only extract ones which filter returns `true`.
+    ///    Note that this is a best-effort and it only works when `fmt`
+    ///    is not `PkgFmt::Bin` or `PkgFmt::Zip`.
+    fn new<Filter: FnMut(&Path) -> bool + Send + 'static>(
         path: &Path,
         fmt: PkgFmt,
-        desired_outputs: Option<[Cow<'static, Path>; N]>,
+        filter: Option<Filter>,
     ) -> Self {
         let path = path.to_owned();
         let (tx, rx) = mpsc::channel::<Content>(100);
@@ -73,12 +74,9 @@ impl AsyncExtracterInner {
 
                     unzip(file, &path)?;
                 }
-                _ => extract_compressed_from_readable(
-                    ReadableRx::new(&mut rx),
-                    fmt,
-                    &path,
-                    desired_outputs.as_ref().map(|arr| &arr[..]),
-                )?,
+                _ => {
+                    extract_compressed_from_readable(ReadableRx::new(&mut rx), fmt, &path, filter)?
+                }
             }
 
             Ok(())
@@ -181,16 +179,16 @@ impl AsyncExtracter {
     ///    for the bin.
     ///    Otherwise, it is the directory where the extracted content will be put.
     ///  * `fmt` - The format of the archive to feed in.
-    ///  * `desired_outputs - If Some(_), then it will filter the tar and
-    ///    only extract files specified in it.
+    ///  * `filter` - If Some, then it will pass the path of the file to it
+    ///    and only extract ones which filter returns `true`.
     ///    Note that this is a best-effort and it only works when `fmt`
     ///    is not `PkgFmt::Bin` or `PkgFmt::Zip`.
-    fn new<const N: usize>(
+    fn new<Filter: FnMut(&Path) -> bool + Send + 'static>(
         path: &Path,
         fmt: PkgFmt,
-        desired_outputs: Option<[Cow<'static, Path>; N]>,
+        filter: Option<Filter>,
     ) -> Self {
-        let inner = AsyncExtracterInner::new(path, fmt, desired_outputs);
+        let inner = AsyncExtracterInner::new(path, fmt, filter);
         Self(guard(inner, AsyncExtracterInner::abort))
     }
 
@@ -209,20 +207,20 @@ impl AsyncExtracter {
 ///    for the bin.
 ///    Otherwise, it is the directory where the extracted content will be put.
 ///  * `fmt` - The format of the archive to feed in.
-///  * `desired_outputs - If Some(_), then it will filter the tar and
-///    only extract files specified in it.
+///  * `filter` - If Some, then it will pass the path of the file to it
+///    and only extract ones which filter returns `true`.
 ///    Note that this is a best-effort and it only works when `fmt`
 ///    is not `PkgFmt::Bin` or `PkgFmt::Zip`.
-pub async fn extract_archive_stream<E, const N: usize>(
+pub async fn extract_archive_stream<Filter: FnMut(&Path) -> bool + Send + 'static, E>(
     mut stream: impl Stream<Item = Result<Bytes, E>> + Unpin,
     output: &Path,
     fmt: PkgFmt,
-    desired_outputs: Option<[Cow<'static, Path>; N]>,
+    filter: Option<Filter>,
 ) -> Result<(), BinstallError>
 where
     BinstallError: From<E>,
 {
-    let mut extracter = AsyncExtracter::new(output, fmt, desired_outputs);
+    let mut extracter = AsyncExtracter::new(output, fmt, filter);
 
     while let Some(res) = stream.next().await {
         extracter.feed(res?).await?;

src/helpers/extracter.rs

@@ -1,4 +1,3 @@
-use std::borrow::Cow;
 use std::fs::{self, File};
 use std::io::Read;
 use std::path::Path;
@@ -12,23 +11,25 @@ use zstd::stream::Decoder as ZstdDecoder;
 
 use crate::{BinstallError, PkgFmt};
 
-///  * `desired_outputs - If Some(_), then it will filter the tar
-///    and only extract files specified in it.
-fn untar(
+///  * `filter` - If Some, then it will pass the path of the file to it
+///    and only extract ones which filter returns `true`.
+///    Note that this is a best-effort and it only works when `fmt`
+///    is not `PkgFmt::Bin` or `PkgFmt::Zip`.
+fn untar<Filter: FnMut(&Path) -> bool>(
     dat: impl Read,
     path: &Path,
-    desired_outputs: Option<&[Cow<'_, Path>]>,
+    filter: Option<Filter>,
 ) -> Result<(), BinstallError> {
     let mut tar = Archive::new(dat);
 
-    if let Some(desired_outputs) = desired_outputs {
-        debug!("Untaring only {desired_outputs:#?}");
+    if let Some(mut filter) = filter {
+        debug!("Untaring with filter");
 
         for res in tar.entries()? {
             let mut entry = res?;
             let entry_path = entry.path()?;
 
-            if desired_outputs.contains(&entry_path) {
+            if filter(&entry_path) {
                 debug!("Extracting {entry_path:#?}");
 
                 let dst = path.join(entry_path);
@@ -49,34 +50,36 @@ fn untar(
 /// Extract files from the specified source onto the specified path.
 ///
 ///  * `fmt` - must not be `PkgFmt::Bin` or `PkgFmt::Zip`.
-///  * `desired_outputs - If Some(_), then it will filter the tar
-///    and only extract files specified in it.
-pub(crate) fn extract_compressed_from_readable(
+///  * `filter` - If Some, then it will pass the path of the file to it
+///    and only extract ones which filter returns `true`.
+///    Note that this is a best-effort and it only works when `fmt`
+///    is not `PkgFmt::Bin` or `PkgFmt::Zip`.
+pub(crate) fn extract_compressed_from_readable<Filter: FnMut(&Path) -> bool>(
     dat: impl Read,
     fmt: PkgFmt,
     path: &Path,
-    desired_outputs: Option<&[Cow<'_, Path>]>,
+    filter: Option<Filter>,
 ) -> Result<(), BinstallError> {
     match fmt {
         PkgFmt::Tar => {
             // Extract to install dir
             debug!("Extracting from tar archive to `{path:?}`");
 
-            untar(dat, path, desired_outputs)?
+            untar(dat, path, filter)?
         }
         PkgFmt::Tgz => {
             // Extract to install dir
             debug!("Decompressing from tgz archive to `{path:?}`");
 
             let tar = GzDecoder::new(dat);
-            untar(tar, path, desired_outputs)?;
+            untar(tar, path, filter)?;
         }
         PkgFmt::Txz => {
             // Extract to install dir
             debug!("Decompressing from txz archive to `{path:?}`");
 
             let tar = XzDecoder::new(dat);
-            untar(tar, path, desired_outputs)?;
+            untar(tar, path, filter)?;
         }
         PkgFmt::Tzstd => {
             // Extract to install dir
@@ -87,7 +90,7 @@ pub(crate) fn extract_compressed_from_readable(
             // as &[] by ZstdDecoder::new, thus ZstdDecoder::new
             // should not return any error.
             let tar = ZstdDecoder::new(dat)?;
-            untar(tar, path, desired_outputs)?;
+            untar(tar, path, filter)?;
         }
         PkgFmt::Zip => panic!("Unexpected PkgFmt::Zip!"),
         PkgFmt::Bin => panic!("Unexpected PkgFmt::Bin!"),