First part of migration to prodash 8.0, but…

…supporting more features like throughput and custom formatting won't
really be possible without duplicating/providing all trait
implementations.

Maybe prodash could in fact provide a version of itself without the
tree, making it optional, to allow avoiding to continue duplicating
efforts.

Author: Byron

Diff for: Cargo.lock

@@ -63,7 +63,7 @@ git-features = { version = "^0.2.0", path = "git-features" }
 
 clap = { version = "3.0.0-beta.1", optional = true }
 argh = { version = "0.1.3", optional = true, default-features = false }
-prodash = { version = "7.0.2", optional = true, default-features = false }
+prodash = { version = "8.0.0", optional = true, default-features = false }
 atty = { version = "0.2.14", optional = true, default-features = false }
 env_logger = { version = "0.7.1", optional = true, default-features = false, features = ["humantime", "termcolor", "atty"] }
 crosstermion = { version = "0.3.0", optional = true, default-features = false }
@@ -89,3 +89,6 @@ members = [
     "git-tui",
     "demos"
 ]
+
+[patch.crates-io]
+prodash = { path = "../crates-io/prodash" }

Diff for: Cargo.toml

@@ -46,7 +46,7 @@ fastsha1 = { package = "sha-1", version = "0.9.1", optional = true }
 
 # progress
 log = { version = "0.4.8", optional = true }
-prodash = { version = "7.0.2", optional = true, default-features = false }
+prodash = { version = "8.0.0", optional = true, default-features = false }
 
 # interruptible
 ctrlc = { version = "3.1.4", optional = true, default-features = false, features = ['termination'] }

Diff for: git-features/Cargo.toml

@@ -3,10 +3,10 @@ use std::time::Duration;
 
 pub struct Log {
     name: String,
-    max: Option<u32>,
+    max: Option<usize>,
     unit: Option<&'static str>,
     last_set: Option<std::time::SystemTime>,
-    step: u32,
+    step: usize,
     current_level: usize,
     max_level: usize,
 }
@@ -42,12 +42,12 @@ impl Progress for Log {
         }
     }
 
-    fn init(&mut self, max: Option<u32>, unit: Option<&'static str>) {
+    fn init(&mut self, max: Option<usize>, unit: Option<&'static str>) {
         self.max = max;
         self.unit = unit;
     }
 
-    fn set(&mut self, step: u32) {
+    fn set(&mut self, step: usize) {
         self.step = step;
         if self.current_level > self.max_level {
             return;
@@ -73,7 +73,7 @@ impl Progress for Log {
         }
     }
 
-    fn inc_by(&mut self, step: u32) {
+    fn inc_by(&mut self, step: usize) {
         self.set(self.step + step)
     }
 

Diff for: git-features/src/progress/log.rs

@@ -32,19 +32,19 @@ pub trait Progress {
     /// to the progress tree (e.g. a headline).
     ///
     /// **Note** that this method can be called multiple times, changing the bounded-ness and unit at will.
-    fn init(&mut self, max: Option<u32>, unit: Option<&'static str>);
+    fn init(&mut self, max: Option<usize>, unit: Option<&'static str>);
 
     /// Set the current progress to the given `step`. The cost of this call is negligible,
     /// making manual throttling *not* necessary.
     ///
     /// **Note**: that this call has no effect unless `init(…)` was called before.
-    fn set(&mut self, step: u32);
+    fn set(&mut self, step: usize);
 
     /// Increment the current progress to the given `step`. The cost of this call is negligible,
     /// making manual throttling *not* necessary.
     ///
     /// **Note**: that this call has no effect unless `init(…)` was called before.
-    fn inc_by(&mut self, step: u32);
+    fn inc_by(&mut self, step: usize);
 
     /// Increment the current progress to the given 1. The cost of this call is negligible,
     /// making manual throttling *not* necessary.
@@ -73,7 +73,7 @@ pub trait Progress {
         self.message(MessageLevel::Failure, message)
     }
     /// A shorthand to print throughput information
-    fn show_throughput(&mut self, start: Instant, total_items: u32, item_name: &str) {
+    fn show_throughput(&mut self, start: Instant, total_items: usize, item_name: &str) {
         let elapsed = start.elapsed().as_secs_f32();
         self.info(format!(
             "done {} {} in {:.02}s ({} {}/s)",
@@ -95,11 +95,11 @@ impl Progress for Discard {
         Discard
     }
 
-    fn init(&mut self, _max: Option<u32>, _unit: Option<&'static str>) {}
+    fn init(&mut self, _max: Option<usize>, _unit: Option<&'static str>) {}
 
-    fn set(&mut self, _step: u32) {}
+    fn set(&mut self, _step: usize) {}
 
-    fn inc_by(&mut self, _step: u32) {}
+    fn inc_by(&mut self, _step: usize) {}
 
     fn message(&mut self, _level: MessageLevel, _message: impl Into<String>) {}
 }
@@ -123,21 +123,21 @@ where
         }
     }
 
-    fn init(&mut self, max: Option<u32>, unit: Option<&'static str>) {
+    fn init(&mut self, max: Option<usize>, unit: Option<&'static str>) {
         match self {
             Either::Left(l) => l.init(max, unit),
             Either::Right(r) => r.init(max, unit),
         }
     }
 
-    fn set(&mut self, step: u32) {
+    fn set(&mut self, step: usize) {
         match self {
             Either::Left(l) => l.set(step),
             Either::Right(r) => r.set(step),
         }
     }
 
-    fn inc_by(&mut self, step: u32) {
+    fn inc_by(&mut self, step: usize) {
         match self {
             Either::Left(l) => l.inc_by(step),
             Either::Right(r) => r.inc_by(step),
@@ -184,15 +184,15 @@ where
         DoOrDiscard(self.0.add_child(name))
     }
 
-    fn init(&mut self, max: Option<u32>, unit: Option<&'static str>) {
+    fn init(&mut self, max: Option<usize>, unit: Option<&'static str>) {
         self.0.init(max, unit)
     }
 
-    fn set(&mut self, step: u32) {
+    fn set(&mut self, step: usize) {
         self.0.set(step)
     }
 
-    fn inc_by(&mut self, step: u32) {
+    fn inc_by(&mut self, step: usize) {
         self.0.inc_by(step)
     }
 
@@ -214,7 +214,7 @@ where
 {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let bytes_read = self.reader.read(buf)?;
-        self.progress.inc_by(bytes_read as u32);
+        self.progress.inc_by(bytes_read as usize);
         Ok(bytes_read)
     }
 }

Diff for: git-features/src/progress/mod.rs

@@ -9,15 +9,15 @@ impl Progress for Item {
         Item::add_child(self, name)
     }
 
-    fn init(&mut self, max: Option<u32>, unit: Option<&'static str>) {
-        Item::init(self, max, unit)
+    fn init(&mut self, max: Option<usize>, unit: Option<&'static str>) {
+        Item::init(self, max, unit.map(|u| u.into()))
     }
 
-    fn set(&mut self, step: u32) {
+    fn set(&mut self, step: usize) {
         Item::set(self, step)
     }
 
-    fn inc_by(&mut self, step: u32) {
+    fn inc_by(&mut self, step: usize) {
         self.inc_by(step)
     }
 

Diff for: git-features/src/progress/prodash.rs

@@ -40,7 +40,7 @@ impl pack::Bundle {
         <<P as Progress>::SubProgress as Progress>::SubProgress: Send,
     {
         let mut read_progress = progress.add_child("read pack");
-        read_progress.init(pack_size.map(|s| s as u32), Some("bytes"));
+        read_progress.init(pack_size.map(|s| s as usize), Some("bytes"));
         let pack = progress::Read {
             reader: pack,
             progress: read_progress,

Diff for: git-odb/src/pack/bundle/write/mod.rs

@@ -39,7 +39,7 @@ impl index::File {
         let input_chunks = index_entries.chunks(chunk_size.max(chunk_size));
         let reduce_progress = parking_lot::Mutex::new({
             let mut p = root.add_child("Traversing");
-            p.init(Some(self.num_objects()), Some("objects"));
+            p.init(Some(self.num_objects() as usize), Some("objects"));
             p
         });
         let state_per_thread = |index| {
@@ -59,7 +59,7 @@ impl index::File {
             |entries: &[index::Entry],
              (cache, ref mut processor, buf, progress)|
              -> Result<Vec<decode::Outcome>, Error> {
-                progress.init(Some(entries.len() as u32), Some("entries"));
+                progress.init(Some(entries.len()), Some("entries"));
                 let mut stats = Vec::with_capacity(entries.len());
                 let mut header_buf = [0u8; 64];
                 for index_entry in entries.iter() {

Diff for: git-odb/src/pack/index/traverse/lookup.rs

@@ -22,7 +22,7 @@ pub struct Reducer<'a, P> {
     progress: &'a parking_lot::Mutex<P>,
     check: traverse::SafetyCheck,
     then: Instant,
-    entries_seen: u32,
+    entries_seen: usize,
     stats: traverse::Outcome,
 }
 
@@ -63,7 +63,7 @@ where
             }
             res => res,
         }?;
-        self.entries_seen += chunk_stats.len() as u32;
+        self.entries_seen += chunk_stats.len();
 
         let chunk_total = chunk_stats.into_iter().fold(
             decode::Outcome::default_from_kind(git_object::Kind::Tree),

Diff for: git-odb/src/pack/index/traverse/reduce.rs

@@ -6,7 +6,7 @@ pub(crate) fn index_entries_sorted_by_offset_ascending(
     idx: &pack::index::File,
     mut progress: impl Progress,
 ) -> Vec<pack::index::Entry> {
-    progress.init(Some(idx.num_objects), Some("entries"));
+    progress.init(Some(idx.num_objects as usize), Some("entries"));
     let start = Instant::now();
 
     let mut v = Vec::with_capacity(idx.num_objects as usize);
@@ -16,7 +16,7 @@ pub(crate) fn index_entries_sorted_by_offset_ascending(
     }
     v.sort_by_key(|e| e.pack_offset);
 
-    progress.show_throughput(start, idx.num_objects, "entries");
+    progress.show_throughput(start, idx.num_objects as usize, "entries");
     v
 }
 

Diff for: git-odb/src/pack/index/util.rs

@@ -114,7 +114,7 @@ pub(crate) fn to_write(
     out.inner.inner.flush()?;
 
     progress.inc();
-    progress.show_throughput(start, out.bytes as u32, "bytes");
+    progress.show_throughput(start, out.bytes as usize, "bytes");
 
     Ok(index_hash)
 }

Diff for: git-odb/src/pack/index/write/encode.rs

@@ -68,7 +68,7 @@ impl pack::index::File {
 
         root_progress.init(Some(4), Some("steps"));
         let mut progress = root_progress.add_child("indexing");
-        progress.init(entries.size_hint().1.map(|l| l as u32), Some("objects"));
+        progress.init(entries.size_hint().1, Some("objects"));
         let mut pack_entries_end: u64 = 0;
 
         for (eid, entry) in entries.enumerate() {
@@ -133,7 +133,7 @@ impl pack::index::File {
             .try_into()
             .map_err(|_| Error::IteratorInvariantTooManyObjects(num_objects))?;
         last_base_index.ok_or(Error::IteratorInvariantBasesPresent)?;
-        progress.show_throughput(indexing_start, num_objects, "objects");
+        progress.show_throughput(indexing_start, num_objects as usize, "objects");
         drop(progress);
 
         root_progress.inc();
@@ -174,7 +174,7 @@ impl pack::index::File {
             kind,
             root_progress.add_child("writing index file"),
         )?;
-        root_progress.show_throughput(indexing_start, num_objects, "objects");
+        root_progress.show_throughput(indexing_start, num_objects as usize, "objects");
         Ok(Outcome {
             index_kind: kind,
             index_hash,

Diff for: git-odb/src/pack/index/write/mod.rs

@@ -47,7 +47,7 @@ impl<T> Tree<T> {
         );
 
         let anticpiated_num_objects = if let Some(num_objects) = data_sorted_by_offsets.size_hint().1 {
-            progress.init(Some(num_objects as u32), Some("objects"));
+            progress.init(Some(num_objects), Some("objects"));
             num_objects
         } else {
             0

Diff for: git-odb/src/pack/tree/from_offsets.rs

@@ -94,7 +94,7 @@ where
     P: Progress,
 {
     pub fn new(num_objects: u32, progress: &'a parking_lot::Mutex<P>) -> Self {
-        progress.lock().init(Some(num_objects), Some("objects"));
+        progress.lock().init(Some(num_objects as usize), Some("objects"));
         Reducer {
             item_count: 0,
             progress,
@@ -114,7 +114,7 @@ where
     fn feed(&mut self, input: Self::Input) -> Result<(), Self::Error> {
         let input = input?;
         self.item_count += input;
-        self.progress.lock().set(self.item_count as u32);
+        self.progress.lock().set(self.item_count);
         if is_interrupted() {
             return Err(Error::Interrupted);
         }
@@ -124,7 +124,7 @@ where
     fn finalize(self) -> Result<Self::Output, Self::Error> {
         self.progress
             .lock()
-            .show_throughput(self.start, self.item_count as u32, "objects");
+            .show_throughput(self.start, self.item_count, "objects");
         Ok(())
     }
 }

Diff for: git-odb/src/pack/tree/traverse/mod.rs

@@ -44,7 +44,7 @@
   * [x] use usize for progress counting
   * [x] Unit conversion probably using a new Unit enum (to support more than just bare strings)
   * [x] percentages somewhere near the progress bar
-  * [ ] Find a way to measure live throughput (in line renderer and tui renderer)
+  * [x] Find a way to measure live throughput (in line renderer and tui renderer)
   * [ ] ~~a way to measure throughput on drop~~ - we don't know if the operation was successful, should not be automatic, ever
 * **asciinemas**
    * [ ] explode