Use ProgressBar wrapper

src/lib.rs

@@ -110,6 +110,7 @@ use {
     path_error::PathError,
     percent_encode::PercentEncode,
     private_key_error::PrivateKeyError,
+    progress_bar::ProgressBar,
     public_key_error::PublicKeyError,
     reqwest_response_ext::ReqwestResponseExt,
     resource::Resource,
@@ -163,7 +164,6 @@ use {
   futures_util::StreamExt,
   humansize::{BINARY, BaseUnit, DECIMAL, FormatSizeOptions, SizeFormatter},
   id3::TagLike,
-  indicatif::{ProgressBar, ProgressStyle},
   jiff::{self, civil},
   lexiclean::Lexiclean,
   mime::Mime,

src/metadata.rs

@@ -199,7 +199,7 @@ impl Metadata {
       }
     }
 
-    let bar = progress_bar::count(quiet, images.len().into_u64(), "thumbnails");
+    let bar = ProgressBar::count(quiet, images.len().into_u64(), "thumbnails");
 
     let mut thumbnails = BTreeMap::new();
 

src/progress_bar.rs

@@ -1,4 +1,7 @@
-use super::*;
+use {
+  super::*,
+  indicatif::{ProgressBarIter, ProgressStyle},
+};
 
 const COUNT_TEMPLATE: &str = "{spinner:.green} ⟪{elapsed_precise}⟫ ⟦{wide_bar:.cyan}⟧ \
                               {pos}/{len} {msg} ⟨{eta}⟩";
@@ -48,56 +51,91 @@ const TICK_CHARS: &str = concat!(
   "⠛⠚⠓⠒⠙⠘⠑⠐⠋⠊⠃⠂⠉⠈⠁",
 );
 
-pub(crate) fn count(quiet: bool, len: u64, message: &'static str) -> ProgressBar {
-  if quiet {
-    ProgressBar::hidden()
-  } else {
-    ProgressBar::new(len)
-      .with_style(
-        ProgressStyle::default_bar()
-          .progress_chars(PROGRESS_CHARS)
-          .template(COUNT_TEMPLATE)
-          .unwrap()
-          .tick_chars(TICK_CHARS),
-      )
-      .with_message(message)
-  }
+struct Items {
+  done: u64,
+  noun: &'static str,
+  total: u64,
 }
 
-pub(crate) fn entry_progress_message(downloaded: u64, entries: u64) -> String {
-  format!("{downloaded}/{entries} entries")
+impl Display for Items {
+  fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+    write!(f, "{}/{} {}", self.done, self.total, self.noun)
+  }
 }
 
-pub(crate) fn file_progress_message(uploaded: u64, files: u64) -> String {
-  format!("{uploaded}/{files} files")
+pub(crate) struct ProgressBar {
+  inner: indicatif::ProgressBar,
+  items: Option<Items>,
 }
 
-pub(crate) fn new(options: &Options, bytes: u64) -> ProgressBar {
-  if options.quiet {
-    ProgressBar::hidden()
-  } else {
-    ProgressBar::new(bytes).with_style(
-      ProgressStyle::default_bar()
-        .progress_chars(PROGRESS_CHARS)
-        .template(TEMPLATE)
-        .unwrap()
-        .tick_chars(TICK_CHARS),
-    )
+impl ProgressBar {
+  pub(crate) fn bytes(options: &Options, bytes: u64) -> Self {
+    Self {
+      inner: Self::inner(options.quiet, bytes, TEMPLATE),
+      items: None,
+    }
+  }
+
+  pub(crate) fn count(quiet: bool, len: u64, message: &'static str) -> Self {
+    Self {
+      inner: Self::inner(quiet, len, COUNT_TEMPLATE).with_message(message),
+      items: None,
+    }
+  }
+
+  pub(crate) fn inc(&self, delta: u64) {
+    self.inner.inc(delta);
   }
-}
 
-pub(crate) fn with_message(options: &Options, bytes: u64, message: String) -> ProgressBar {
-  if options.quiet {
-    ProgressBar::hidden()
-  } else {
-    ProgressBar::new(bytes)
-      .with_style(
+  fn inner(quiet: bool, len: u64, template: &str) -> indicatif::ProgressBar {
+    if quiet {
+      indicatif::ProgressBar::hidden()
+    } else {
+      indicatif::ProgressBar::new(len).with_style(
         ProgressStyle::default_bar()
           .progress_chars(PROGRESS_CHARS)
-          .template(TEMPLATE_WITH_MESSAGE)
+          .template(template)
           .unwrap()
           .tick_chars(TICK_CHARS),
       )
-      .with_message(message)
+    }
+  }
+
+  pub(crate) fn item_done(&mut self) {
+    self.items.as_mut().unwrap().done += 1;
+    self.update_message();
+  }
+
+  pub(crate) fn items(options: &Options, bytes: u64, items: u64, noun: &'static str) -> Self {
+    let bar = Self {
+      inner: Self::inner(options.quiet, bytes, TEMPLATE_WITH_MESSAGE),
+      items: Some(Items {
+        done: 0,
+        noun,
+        total: items,
+      }),
+    };
+    bar.update_message();
+    bar
+  }
+
+  pub(crate) fn set_totals(&mut self, bytes: u64, items: u64) {
+    self.inner.set_length(bytes);
+    self.items.as_mut().unwrap().total = items;
+    self.update_message();
+  }
+
+  fn update_message(&self) {
+    self
+      .inner
+      .set_message(self.items.as_ref().unwrap().to_string());
+  }
+
+  pub(crate) fn wrap_read<R: Read>(&self, read: R) -> ProgressBarIter<R> {
+    self.inner.wrap_read(read)
+  }
+
+  pub(crate) fn wrap_write<W: Write>(&self, write: W) -> ProgressBarIter<W> {
+    self.inner.wrap_write(write)
   }
 }

src/subcommand/create.rs

@@ -170,7 +170,7 @@ impl Create {
       && let Some(Media::Audio { items }) = &metadata.media
     {
       let missing = {
-        let bar = progress_bar::count(options.quiet, items.len().into_u64(), "files");
+        let bar = ProgressBar::count(options.quiet, items.len().into_u64(), "files");
 
         let mut missing = Vec::new();
 
@@ -229,7 +229,7 @@ impl Create {
         .context(error::TotalFileSizeOverflow)?;
     }
 
-    let bar = progress_bar::new(&options, total_file_size);
+    let bar = ProgressBar::bytes(&options, total_file_size);
 
     let mut package = DirectoryTree::new();
 

src/subcommand/download.rs

@@ -2,8 +2,6 @@ use {super::*, reqwest::blocking::Response};
 
 struct Context {
   client: Client,
-  entries: u64,
-  entries_downloaded: u64,
   progress_bar: ProgressBar,
 }
 
@@ -41,7 +39,7 @@ impl Download {
 
     let response = client.file(hash)?;
 
-    let bar = progress_bar::new(options, response.content_length().unwrap_or(0));
+    let bar = ProgressBar::bytes(options, response.content_length().unwrap_or_default());
 
     Self::write_response(&client, response, hash, path, &bar)?;
 
@@ -64,9 +62,7 @@ impl Download {
 
     let mut totals = None::<Totals>;
 
-    let mut entries_downloaded = 0;
-
-    let mut progress_bar = None::<ProgressBar>;
+    let mut progress_bar = ProgressBar::items(options, 0, 0, "entries");
 
     while let Some((hash, path, expected_totals)) = stack.pop() {
       let url = client.file_url(hash);
@@ -96,29 +92,19 @@ impl Download {
           .expect(expected)
           .context(error::DirectoryTotals { hash })?;
 
-        let totals = totals.unwrap();
-
-        entries_downloaded += 1;
-
-        let progress_bar = progress_bar.as_ref().unwrap();
-
         progress_bar.inc(cbor.len().into_u64());
-
-        progress_bar.set_message(progress_bar::entry_progress_message(
-          entries_downloaded,
-          totals.files.saturating_add(totals.directories),
-        ));
       } else {
         assert!(totals.is_none());
         totals = Some(actual);
 
-        progress_bar = Some(progress_bar::with_message(
-          options,
+        progress_bar.set_totals(
           actual.file_size.saturating_add(actual.directory_size),
-          progress_bar::entry_progress_message(0, actual.files.saturating_add(actual.directories)),
-        ));
+          actual.files.saturating_add(actual.directories),
+        );
       }
 
+      progress_bar.item_done();
+
       directories.insert(hash, cbor.to_vec());
 
       filesystem::create_dir_all(&path)?;
@@ -136,9 +122,7 @@ impl Download {
 
     let mut context = Context {
       client,
-      entries: totals.files.saturating_add(totals.directories),
-      entries_downloaded,
-      progress_bar: progress_bar.unwrap(),
+      progress_bar,
     };
 
     for (hash, path) in &files {
@@ -191,14 +175,7 @@ impl Download {
 
     Self::write_response(&context.client, response, hash, path, &context.progress_bar)?;
 
-    context.entries_downloaded += 1;
-
-    context
-      .progress_bar
-      .set_message(progress_bar::entry_progress_message(
-        context.entries_downloaded,
-        context.entries,
-      ));
+    context.progress_bar.item_done();
 
     Ok(())
   }

src/subcommand/upload.rs

@@ -3,8 +3,6 @@ use {super::*, reqwest::blocking::Body};
 struct Context {
   archive: Archive,
   client: Client,
-  files: u64,
-  files_uploaded: u64,
   missing: HashSet<Hash>,
   path: Utf8PathBuf,
   progress_bar: ProgressBar,
@@ -57,13 +55,7 @@ impl Upload {
         Entry::File { hash, .. } => {
           if context.missing.contains(hash) {
             Self::upload_package_file(context, entry, &file_path)?;
-            context.files_uploaded += 1;
-            context
-              .progress_bar
-              .set_message(progress_bar::file_progress_message(
-                context.files_uploaded,
-                context.files,
-              ));
+            context.progress_bar.item_done();
           }
         }
       }
@@ -81,7 +73,7 @@ impl Upload {
       .hash_file(input)
       .context(error::FilesystemIo { path: input })?;
 
-    let bar = progress_bar::new(options, size);
+    let bar = ProgressBar::bytes(options, size);
 
     let file = filesystem::open(input)?;
 
@@ -136,20 +128,12 @@ impl Upload {
       );
     }
 
-    let progress_bar = progress_bar::with_message(
-      &options,
-      bytes,
-      progress_bar::file_progress_message(0, files),
-    );
-
     let mut context = Context {
       archive,
-      progress_bar,
+      progress_bar: ProgressBar::items(&options, bytes, files, "files"),
       client,
-      files_uploaded: 0,
       missing,
       path,
-      files,
     };
 
     let root = context.path.parent().unwrap().to_owned();

src/subcommand/verify.rs

@@ -98,7 +98,7 @@ fingerprint mismatch: `{source}`
       return Err(error::FingerprintMismatch.build());
     }
 
-    let bar = progress_bar::new(&options, totals.file_size);
+    let bar = ProgressBar::bytes(&options, totals.file_size);
 
     let mut mismatches = BTreeMap::new();
 

src/yaml/metadata.rs

@@ -37,7 +37,7 @@ impl Metadata {
     let files =
       u64::from(artwork.is_some()) + media.as_ref().map_or(0, |media| media.items().into_u64());
 
-    let bar = progress_bar::count(quiet, files, "files");
+    let bar = ProgressBar::count(quiet, files, "files");
 
     let artwork = if let Some(path) = artwork {
       let image = Image::load(root, path)?.content;