use option for size values instead of size

4 files changed, 67 insertions, 62 deletions

diff --git a/src/batch.rs b/src/batch.rs
index 1f2e7ec..1a5d62b 100644
--- a/src/batch.rs
+++ b/src/batch.rs
@@ -57,15 +57,6 @@ impl Batch {
         for meta in &self.0 {
             let icon = icons.get(&meta.name);
 
-            let mut size_str;
-            if let Some(ref size) = meta.size {
-                size_str = size.render(colors, max_size_value_length, max_size_unit_length);
-            } else {
-                size_str = ANSIString::from(
-                    " ".repeat(max_size_value_length + max_size_unit_length) + "-",
-                );
-            }
-
             let mut link_str = ANSIString::from("");
             if let Some(ref symlink) = meta.symlink {
                 link_str = symlink.render(colors);
@@ -79,7 +70,8 @@ impl Batch {
                 ANSIString::from("  "),
                 meta.owner.render_group(colors, max_group_length),
                 ANSIString::from("  "),
-                size_str,
+                meta.size
+                    .render(colors, max_size_value_length, max_size_unit_length),
                 ANSIString::from("  "),
                 meta.date.render(colors),
                 ANSIString::from("  "),
@@ -125,14 +117,12 @@ impl Batch {
         let mut max_unit_size: usize = 0;
 
         for meta in &self.0 {
-            if let Some(ref size) = meta.size {
-                if size.render_value().len() > max_value_length {
-                    max_value_length = size.render_value().len();
-                }
-
-                if size.render_unit().len() > max_unit_size {
-                    max_unit_size = size.render_unit().len();
-                }
+            if meta.size.render_value().len() > max_value_length {
+                max_value_length = meta.size.render_value().len();
+            }
+
+            if meta.size.render_unit().len() > max_unit_size {
+                max_unit_size = meta.size.render_unit().len();
             }
         }
 
diff --git a/src/color.rs b/src/color.rs
index 9a0d1b4..8f08dfa 100644
--- a/src/color.rs
+++ b/src/color.rs
@@ -32,6 +32,7 @@ pub enum Elem {
     Group,
 
     /// File Size
+    NonFile,
     FileLarge,
     FileMedium,
     FileSmall,
@@ -100,6 +101,7 @@ impl Colors {
         m.insert(Elem::Older, Colour::Fixed(36)); // DarkCyan
 
         // Last Time Modified
+        m.insert(Elem::NonFile, Colour::Fixed(15)); // White
         m.insert(Elem::FileSmall, Colour::Fixed(229)); // Wheat1
         m.insert(Elem::FileMedium, Colour::Fixed(216)); // LightSalmon1
         m.insert(Elem::FileLarge, Colour::Fixed(172)); // Orange3
diff --git a/src/meta/mod.rs b/src/meta/mod.rs
index e53ae6e..2ca56df 100644
--- a/src/meta/mod.rs
+++ b/src/meta/mod.rs
@@ -26,13 +26,8 @@ pub struct Meta {
     pub date: Date,
     pub owner: Owner,
     pub file_type: FileType,
-<<<<<<< HEAD
     pub size: Size,
     pub symlink: SymLink,
-=======
-    pub size: Option<Size>,
-    pub symlink: Option<SymLink>,
->>>>>>> show - for size when if it is not a file
 }
 
 impl Meta {
@@ -58,7 +53,7 @@ impl Meta {
         Some(Meta {
             path: path.to_path_buf(),
             symlink: SymLink::from(path.as_path()),
-            size: Size::from_bytes(&metadata),
+            size: Size::from(&metadata),
             permissions: Permissions::from(&metadata),
             date: Date::from(&metadata),
             owner: Owner::from(&metadata),
diff --git a/src/meta/size.rs b/src/meta/size.rs
index 021b337..29946e2 100644
--- a/src/meta/size.rs
+++ b/src/meta/size.rs
@@ -12,44 +12,51 @@ pub enum Unit {
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct Size {
-    value: i64,
-    unit: Unit,
+    value: Option<i64>,
+    unit: Option<Unit>,
 }
 
-impl Size {
-    pub fn from_bytes(meta: &Metadata) -> Option<Self> {
-        if !meta.is_file() {
-            return None;
-        }
+impl<'a> From<&'a Metadata> for Size {
+    fn from(meta: &Metadata) -> Self {
+        let len = meta.len();
 
-        Some(Size::get_file_size(meta.len() as i64))
+        if meta.is_file() {
+            Size::from_bytes(len as i64)
+        } else {
+            Size {
+                value: None,
+                unit: None,
+            }
+        }
     }
+}
 
-    fn get_file_size(len: i64) -> Self {
+impl Size {
+    fn from_bytes(len: i64) -> Self {
         if len < 1024 {
             Size {
-                value: len * 1024,
-                unit: Unit::Byte,
+                value: Some(len * 1024),
+                unit: Some(Unit::Byte),
             }
         } else if len < 1024 * 1024 {
             Size {
-                value: len,
-                unit: Unit::Kilo,
+                value: Some(len),
+                unit: Some(Unit::Kilo),
             }
         } else if len < 1024 * 1024 * 1024 {
             Size {
-                value: len / 1024,
-                unit: Unit::Mega,
+                value: Some(len / 1024),
+                unit: Some(Unit::Mega),
             }
         } else if len < 1024 * 1024 * 1024 * 1024 {
             Size {
-                value: len / (1024 * 1024),
-                unit: Unit::Giga,
+                value: Some(len / (1024 * 1024)),
+                unit: Some(Unit::Giga),
             }
         } else {
             Size {
-                value: len / (1024 * 1024 * 1024),
-                unit: Unit::Tera,
+                value: Some(len / (1024 * 1024 * 1024)),
+                unit: Some(Unit::Tera),
             }
         }
     }
@@ -81,17 +88,25 @@ impl Size {
     }
 
     fn paint(&self, colors: &Colors, content: String) -> ColoredString {
-        if self.unit == Unit::Byte || self.unit == Unit::Kilo {
-            colors.colorize(content, &Elem::FileSmall)
-        } else if self.unit == Unit::Mega {
-            colors.colorize(content, &Elem::FileMedium)
-        } else {
-            colors.colorize(content, &Elem::FileLarge)
+        match self.unit {
+            Some(ref unit) => {
+                if unit == &Unit::Byte || unit == &Unit::Kilo {
+                    colors.colorize(content, &Elem::FileSmall)
+                } else if unit == &Unit::Mega {
+                    colors.colorize(content, &Elem::FileMedium)
+                } else {
+                    colors.colorize(content, &Elem::FileLarge)
+                }
+            }
+            None => colors.colorize(content, &Elem::NonFile),
         }
     }
 
     pub fn render_value(&self) -> String {
-        let size_str = (self.value as f32 / 1024.0).to_string();
+        let size_str = match self.value {
+            Some(value) => (value as f32 / 1024.0).to_string(),
+            None => "".to_string(),
+        };
 
         // Check if there is a fraction.
         if let Some(fraction_idx) = size_str.find('.') {
@@ -112,11 +127,14 @@ impl Size {
 
     pub fn render_unit(&self) -> String {
         match self.unit {
-            Unit::Byte => String::from("B"),
-            Unit::Kilo => String::from("KB"),
-            Unit::Mega => String::from("MB"),
-            Unit::Giga => String::from("GB"),
-            Unit::Tera => String::from("TB"),
+            Some(ref unit) => match unit {
+                Unit::Byte => String::from("B"),
+                Unit::Kilo => String::from("KB"),
+                Unit::Mega => String::from("MB"),
+                Unit::Giga => String::from("GB"),
+                Unit::Tera => String::from("TB"),
+            },
+            None => String::from("-"),
         }
     }
 }
@@ -127,7 +145,7 @@ mod tests {
 
     #[test]
     fn render_byte() {
-        let size = Size::get_file_size(42); // == 42 bytes
+        let size = Size::from_bytes(42); // == 42 bytes
 
         assert_eq!(size.render_value().as_str(), "42");
         assert_eq!(size.render_unit().as_str(), "B");
@@ -135,7 +153,7 @@ mod tests {
 
     #[test]
     fn render_kilobyte() {
-        let size = Size::get_file_size(42 * 1024); // 42 kilobytes
+        let size = Size::from_bytes(42 * 1024); // 42 kilobytes
 
         assert_eq!(size.render_value().as_str(), "42");
         assert_eq!(size.render_unit().as_str(), "KB");
@@ -143,7 +161,7 @@ mod tests {
 
     #[test]
     fn render_megabyte() {
-        let size = Size::get_file_size(42 * 1024 * 1024); // 42 megabytes
+        let size = Size::from_bytes(42 * 1024 * 1024); // 42 megabytes
 
         assert_eq!(size.render_value().as_str(), "42");
         assert_eq!(size.render_unit().as_str(), "MB");
@@ -151,7 +169,7 @@ mod tests {
 
     #[test]
     fn render_gigabyte() {
-        let size = Size::get_file_size(42 * 1024 * 1024 * 1024); // 42 gigabytes
+        let size = Size::from_bytes(42 * 1024 * 1024 * 1024); // 42 gigabytes
 
         assert_eq!(size.render_value().as_str(), "42");
         assert_eq!(size.render_unit().as_str(), "GB");
@@ -159,7 +177,7 @@ mod tests {
 
     #[test]
     fn render_terabyte() {
-        let size = Size::get_file_size(42 * 1024 * 1024 * 1024 * 1024); // 42 terabytes
+        let size = Size::from_bytes(42 * 1024 * 1024 * 1024 * 1024); // 42 terabytes
 
         assert_eq!(size.render_value().as_str(), "42");
         assert_eq!(size.render_unit().as_str(), "TB");
@@ -167,7 +185,7 @@ mod tests {
 
     #[test]
     fn render_with_a_fraction() {
-        let size = Size::get_file_size(42 * 1024 + 103); // 42.1 kilobytes
+        let size = Size::from_bytes(42 * 1024 + 103); // 42.1 kilobytes
 
         assert_eq!(size.render_value().as_str(), "42.1");
         assert_eq!(size.render_unit().as_str(), "KB");
@@ -175,7 +193,7 @@ mod tests {
 
     #[test]
     fn render_with_a_truncated_fraction() {
-        let size = Size::get_file_size(42 * 1024 + 1); // 42.001 kilobytes == 42 kilobytes
+        let size = Size::from_bytes(42 * 1024 + 1); // 42.001 kilobytes == 42 kilobytes
 
         assert_eq!(size.render_value().as_str(), "42");
         assert_eq!(size.render_unit().as_str(), "KB");