From 945687c281616c1bc9216db0e370cdf08327c503 Mon Sep 17 00:00:00 2001
From: Jiahao XU <Jiahao_XU@outlook.com>
Date: Thu, 9 Jun 2022 21:58:51 +1000
Subject: [PATCH] Rename `AsyncFileWriter` to `AsyncExtracter`

Signed-off-by: Jiahao XU <Jiahao_XU@outlook.com>
---
 src/helpers.rs                                   | 10 +++++-----
 .../{async_file_writer.rs => async_extracter.rs} | 16 ++++++++--------
 src/helpers/readable_rx.rs                       |  2 +-
 3 files changed, 14 insertions(+), 14 deletions(-)
 rename src/helpers/{async_file_writer.rs => async_extracter.rs} (92%)

diff --git a/src/helpers.rs b/src/helpers.rs
index 6d84bb3c..bc7ce7c8 100644
--- a/src/helpers.rs
+++ b/src/helpers.rs
@@ -14,8 +14,8 @@ use url::Url;
 
 use crate::{BinstallError, Meta, PkgFmt};
 
-mod async_file_writer;
-pub use async_file_writer::AsyncFileWriter;
+mod async_extracter;
+pub use async_extracter::AsyncExtracter;
 
 mod auto_abort_join_handle;
 pub use auto_abort_join_handle::AutoAbortJoinHandle;
@@ -71,13 +71,13 @@ pub async fn download_and_extract<P: AsRef<Path>, const N: usize>(
     debug!("Downloading to file: '{}'", path.display());
 
     let mut bytes_stream = resp.bytes_stream();
-    let mut writer = AsyncFileWriter::new(path, fmt, desired_outputs);
+    let mut extracter = AsyncExtracter::new(path, fmt, desired_outputs);
 
     while let Some(res) = bytes_stream.next().await {
-        writer.write(res?).await?;
+        extracter.write(res?).await?;
     }
 
-    writer.done().await?;
+    extracter.done().await?;
 
     debug!("Download OK, written to file: '{}'", path.display());
 
diff --git a/src/helpers/async_file_writer.rs b/src/helpers/async_extracter.rs
similarity index 92%
rename from src/helpers/async_file_writer.rs
rename to src/helpers/async_extracter.rs
index 53a61ceb..ea581ebb 100644
--- a/src/helpers/async_file_writer.rs
+++ b/src/helpers/async_extracter.rs
@@ -20,14 +20,14 @@ pub(crate) enum Content {
 }
 
 #[derive(Debug)]
-struct AsyncFileWriterInner {
+struct AsyncExtracterInner {
     /// Use AutoAbortJoinHandle so that the task
     /// will be cancelled on failure.
     handle: AutoAbortJoinHandle<Result<(), BinstallError>>,
     tx: mpsc::Sender<Content>,
 }
 
-impl AsyncFileWriterInner {
+impl AsyncExtracterInner {
     ///  * `desired_outputs - If Some(_), then it will filter the tar
     ///    and only extract files specified in it.
     fn new<const N: usize>(
@@ -148,16 +148,16 @@ impl AsyncFileWriterInner {
     }
 }
 
-/// AsyncFileWriter will pass the `Bytes` you give to another thread via
+/// AsyncExtracter will pass the `Bytes` you give to another thread via
 /// a `mpsc` and decompress and unpack it if needed.
 ///
 /// # Cancellation
 ///
-/// AsyncFileWriter removes the file if `done` isn't called.
+/// AsyncExtracter removes the file if `done` isn't called.
 #[derive(Debug)]
-pub struct AsyncFileWriter(ScopeGuard<AsyncFileWriterInner, fn(AsyncFileWriterInner), Always>);
+pub struct AsyncExtracter(ScopeGuard<AsyncExtracterInner, fn(AsyncExtracterInner), Always>);
 
-impl AsyncFileWriter {
+impl AsyncExtracter {
     ///  * `desired_outputs - If Some(_) and `fmt` is not `PkgFmt::Bin` or
     ///    `PkgFmt::Zip`, then it will filter the tar and only extract files
     ///    specified in it.
@@ -166,8 +166,8 @@ impl AsyncFileWriter {
         fmt: PkgFmt,
         desired_outputs: Option<[Cow<'static, Path>; N]>,
     ) -> Self {
-        let inner = AsyncFileWriterInner::new(path, fmt, desired_outputs);
-        Self(guard(inner, AsyncFileWriterInner::abort))
+        let inner = AsyncExtracterInner::new(path, fmt, desired_outputs);
+        Self(guard(inner, AsyncExtracterInner::abort))
     }
 
     /// Upon error, this writer shall not be reused.
diff --git a/src/helpers/readable_rx.rs b/src/helpers/readable_rx.rs
index 8b387ab6..15aa1300 100644
--- a/src/helpers/readable_rx.rs
+++ b/src/helpers/readable_rx.rs
@@ -4,7 +4,7 @@ use std::io::{self, Read};
 use bytes::{Buf, Bytes};
 use tokio::sync::mpsc::Receiver;
 
-use super::async_file_writer::Content;
+use super::async_extracter::Content;
 
 #[derive(Debug)]
 pub(crate) struct ReadableRx<'a> {