trying to use byte-size shows that the trait interface isn't flexible enough

Byron · Byron · commit f233d43f2d48 · 2020-08-08T15:29:40.000+08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,18 +24,19 @@ required-features = ["tui-renderer", "tui-renderer-termion", "line-renderer", "l
 
 [features]
 default = ["log-renderer", "localtime"]
+unit-bytes = ["bytesize"]
 tui-renderer-termion = ["crosstermion/tui-react-termion"]
 tui-renderer-crossterm = ["crosstermion/tui-react-crossterm", "crosstermion/input-async-crossterm"]
 tui-renderer = ["tui",
-                "unicode-segmentation",
-                "unicode-width",
-                "crosstermion/input-async",
-                "tui-react",
-                "futures-util",
-                "futures-lite",
-                "futures-core",
-                "async-io",
-                "humantime"]
+    "unicode-segmentation",
+    "unicode-width",
+    "crosstermion/input-async",
+    "tui-react",
+    "futures-util",
+    "futures-lite",
+    "futures-core",
+    "async-io",
+    "humantime"]
 line-renderer = ["crosstermion/color", "humantime", "unicode-width"]
 line-renderer-crossterm = ["crosstermion/crossterm"]
 line-renderer-termion = ["crosstermion/termion"]
@@ -69,6 +70,9 @@ time = { version = "0.2.9", optional = true, features = ["std"], default-feature
 # line renderer
 ctrlc = { version = "3.1.4", optional = true, default-features = false, features = ['termination'] }
 
+# units
+bytesize = { version = "1.0.1", optional = true }
+
 [package.metadata.docs.rs]
 all-features = true
 
diff --git a/Makefile b/Makefile
@@ -18,7 +18,7 @@ check: ## build features in commmon combination to be sure it all stays together
 	$(MAKE) -C crosstermion check
 
 unit-test: ## Run all unit tests
-	cargo test --examples
+	cargo test --examples --features unit-bytes
 
 tests: check unit-test ## Run all tests we have
 
diff --git a/README.md b/README.md
@@ -56,6 +56,8 @@ This crate comes with various cargo features to tailor it to your needs.
          * Use the `termion` crate as terminal backend 
          * It has less dependencies but works only on `unix` systems
          * to get this, disable default features and chose at least `tui-renderer` and `tui-renderer-termion`.
+* **unit-bytes**
+  * Supports dynamic unit rendering using the tiny `bytesize` crate.
 
 ## Features
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -52,7 +52,7 @@ pub use log::warn;
 
 #[cfg(any(feature = "humantime", feature = "time"))]
 pub mod time;
-mod unit;
+pub mod unit;
 
 #[cfg(not(feature = "log-renderer"))]
 mod log {
diff --git a/src/unit/bytes.rs b/src/unit/bytes.rs
@@ -0,0 +1,37 @@
+use crate::{tree::ProgressStep, unit::DisplayValue};
+use std::fmt;
+
+#[derive(Copy, Clone, Default, Hash, Eq, PartialEq, Ord, PartialOrd, Debug)]
+pub struct Bytes;
+
+impl Bytes {
+    fn format_bytes(f: &mut fmt::Formatter, value: ProgressStep) -> fmt::Result {
+        let string = bytesize::to_string(value as u64, false);
+        for token in string.split(' ') {
+            write!(f, "{}", token)?;
+        }
+        Ok(())
+    }
+}
+
+impl DisplayValue for Bytes {
+    fn display_current_value(
+        &self,
+        f: &mut fmt::Formatter,
+        value: ProgressStep,
+        _upper: Option<ProgressStep>,
+    ) -> fmt::Result {
+        Self::format_bytes(f, value)
+    }
+    fn display_upper_bound(
+        &self,
+        f: &mut fmt::Formatter,
+        upper_bound: ProgressStep,
+        _value: ProgressStep,
+    ) -> fmt::Result {
+        Self::format_bytes(f, upper_bound)
+    }
+    fn display_unit(&self, _f: &mut fmt::Formatter, _value: usize) -> fmt::Result {
+        Ok(())
+    }
+}
diff --git a/src/unit/mod.rs b/src/unit/mod.rs
@@ -1,18 +1,27 @@
 use crate::tree::ProgressStep;
-use std::fmt::Write;
-use std::{fmt, ops::Deref};
+use std::{fmt, fmt::Write, ops::Deref};
+
+#[cfg(feature = "unit-bytes")]
+mod bytes;
+#[cfg(feature = "unit-bytes")]
+pub use bytes::Bytes;
 
 pub trait DisplayValue {
     fn display_current_value(
         &self,
         f: &mut fmt::Formatter,
         value: ProgressStep,
-        _max: Option<ProgressStep>,
+        _upper: Option<ProgressStep>,
     ) -> fmt::Result {
         write!(f, "{}", value)
     }
-    fn display_upper_bound(&self, f: &mut fmt::Formatter, value: ProgressStep) -> fmt::Result {
-        write!(f, "{}", value)
+    fn display_upper_bound(
+        &self,
+        f: &mut fmt::Formatter,
+        upper_bound: ProgressStep,
+        _value: ProgressStep,
+    ) -> fmt::Result {
+        write!(f, "{}", upper_bound)
     }
     fn display_unit(&self, f: &mut fmt::Formatter, value: ProgressStep) -> fmt::Result;
     fn display_percentage(&self, f: &mut fmt::Formatter, percentage: f64) -> fmt::Result {
@@ -39,6 +48,12 @@ impl Unit {
     pub fn label_and_mode(label: &'static str, mode: Mode) -> Self {
         Unit::Label(label, Some(mode))
     }
+    pub fn dynamic(label: impl DisplayValue + 'static) -> Self {
+        Unit::Dynamic(Box::new(label), None)
+    }
+    pub fn dynamic_and_mode(label: impl DisplayValue + 'static, mode: Mode) -> Self {
+        Unit::Dynamic(Box::new(label), Some(mode))
+    }
 }
 
 /// Display and utilities
@@ -121,13 +136,13 @@ impl<'a> fmt::Display for UnitDisplay<'a> {
             unit.display_current_value(f, self.current_value, self.upper_bound)?;
             if let Some(upper) = self.upper_bound {
                 f.write_char('/')?;
-                unit.display_upper_bound(f, upper)?;
-            }
-            if self.display.unit() {
-                f.write_char(' ')?;
+                unit.display_upper_bound(f, upper, self.current_value)?;
             }
         }
         if self.display.unit() {
+            if self.display.values() {
+                f.write_char(' ')?;
+            }
             unit.display_unit(f, self.current_value)?;
 
             if let Some((Mode::PercentageAfterUnit, fraction)) = mode_and_fraction {
diff --git a/src/unit/tests.rs b/src/unit/tests.rs
@@ -1,35 +1,54 @@
-mod label {
-    mod values {
-        use crate::unit::{Mode, Unit};
-        #[test]
-        fn display_current_value_with_upper_bound_percentage_before_value() {
-            assert_eq!(
-                format!(
-                    "{}",
-                    Unit::label_and_mode("items", Mode::PercentageBeforeValue)
-                        .display(123, Some(400))
-                        .values()
-                ),
-                "[30%] 123/400"
-            );
-        }
-    }
-    mod unit {
-        use crate::unit::{Mode, Unit};
+mod dynamic {
+    #[cfg(feature = "unit-bytes")]
+    mod bytes {
+        use crate::unit::{Bytes, Mode, Unit};
+
         #[test]
-        fn display_current_value_with_upper_bound_percentage_after_unit() {
+        fn value_and_upper_bound_use_own_unit() {
             assert_eq!(
                 format!(
                     "{}",
-                    Unit::label_and_mode("items", Mode::PercentageAfterUnit)
-                        .display(123, Some(400))
-                        .unit()
+                    Unit::dynamic_and_mode(Bytes, Mode::PercentageAfterUnit).display(1002, Some(10_000_000_000))
                 ),
-                "items [30%]"
+                "1.0KB/10.0GB [0%]"
             );
         }
     }
+}
+
+mod label {
     mod with_percentage {
+        mod only_values {
+            use crate::unit::{Mode, Unit};
+            #[test]
+            fn display_current_value_with_upper_bound_percentage_before_value() {
+                assert_eq!(
+                    format!(
+                        "{}",
+                        Unit::label_and_mode("items", Mode::PercentageBeforeValue)
+                            .display(123, Some(400))
+                            .values()
+                    ),
+                    "[30%] 123/400"
+                );
+            }
+        }
+
+        mod only_unit {
+            use crate::unit::{Mode, Unit};
+            #[test]
+            fn display_current_value_with_upper_bound_percentage_after_unit() {
+                assert_eq!(
+                    format!(
+                        "{}",
+                        Unit::label_and_mode("items", Mode::PercentageAfterUnit)
+                            .display(123, Some(400))
+                            .unit()
+                    ),
+                    "items [30%]"
+                );
+            }
+        }
         use crate::unit::{Mode, Unit};
 
         #[test]
