Added compression stats

src/main.rs

@@ -1,6 +1,6 @@
 use std::{ffi::OsString, io::Write};
 
-use clap::{Parser};
+use clap::Parser;
 use huffman::{cli, hufftree, storage};
 
 fn main() -> Result<(), std::io::Error> {
@@ -12,63 +12,68 @@ fn main() -> Result<(), std::io::Error> {
 
     let outputf = match outputf {
         Some(name) => name,
-        None => {
-            match mode {
-                cli::Mode::X => {
-                    let mut temp = inputf.clone().into_string().expect("Not a valid input file name.");
-                    if temp.ends_with(".z") {
-                        temp.pop();
-                        temp.pop();
-                    } else {
-                        temp.push_str(".unhuffed");
-                    }
-                    OsString::from(temp)
-                },
-                cli::Mode::C => {
-                    let mut temp = inputf.clone();
-                    temp.push(".z");
-                    temp
-                },
+        None => match mode {
+            cli::Mode::X => {
+                let mut temp = inputf
+                    .clone()
+                    .into_string()
+                    .expect("Not a valid input file name.");
+                if temp.ends_with(".z") {
+                    temp.pop();
+                    temp.pop();
+                } else {
+                    temp.push_str(".unhuffed");
+                }
+                OsString::from(temp)
+            }
+            cli::Mode::C => {
+                let mut temp = inputf.clone();
+                temp.push(".z");
+                temp
             }
         },
     };
 
     let working_directory = std::path::Path::new(".");
     let inputf = working_directory.join(inputf);
+    let in_size = inputf.metadata().unwrap().len();
 
     let outputf = working_directory.join(outputf);
     let mut outputf = std::fs::File::create(outputf)?;
 
     match mode {
         cli::Mode::X => {
-            println!("Reading file...");
             let inputf = std::fs::read(inputf)?;
-            println!("Done.");
+            println!("Read: {} bytes.", in_size);
             println!("Decoding text...");
             let decoded_text = huffman::storage::read_tree_and_text(&mut &inputf[..]);
             println!("Decoded!");
 
-
-            println!("Storing...");
             outputf.write_all(decoded_text.as_bytes()).unwrap();
-            println!("Stored!");
+            let out_size = outputf.metadata().unwrap().len();
+            println!("Stored: {} bytes.", out_size);
+            println!(
+                "Compression Ratio: {:.2}.",
+                in_size as f64 / out_size as f64
+            );
         }
 
         cli::Mode::C => {
-            println!("Reading file...");
             let inputf = std::fs::read_to_string(inputf)?;
-            println!("Done.");
+            println!("Read: {} bytes.", in_size);
             let char_f = huffman::hufftree::base::get_char_frequencies(&inputf);
 
-            println!("Creating Huffman Tree...");
             let base_tree = huffman::hufftree::base::Hufftree::new(char_f);
             let canonical_tree = hufftree::canonical::CanonicalHufftree::from_tree(base_tree);
-            println!("Created!");
 
-            println!("Storing...");
             storage::store_tree_and_text(canonical_tree, &mut outputf, &inputf)
                 .expect("Could not store the tree and text.");
-            println!("Stored!");
+            let out_size = outputf.metadata().unwrap().len();
+            println!("Stored: {} bytes.", out_size);
+            println!(
+                "Compression Ratio: {:.2}.",
+                out_size as f64 / in_size as f64
+            );
         }
     }