Feature: Adding file types filter & F flag changed

-t = Show summary of types

-e = Filter by regex
	allows you to specify a file type like -e "\.txt$"

Change behaviour of '-f' flag - it now counts only files. Before it
counted files & directories. This was needed for compatibility with
the new '-e' filter flag

src/filter.rs

@@ -1,6 +1,7 @@
 use crate::display_node::DisplayNode;
 use crate::node::Node;
 use std::collections::BinaryHeap;
+use std::collections::HashMap;
 use std::collections::HashSet;
 use std::path::PathBuf;
 
@@ -13,7 +14,11 @@ pub fn get_by_depth(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode>
     Some(build_by_depth(&root, n - 1))
 }
 
-pub fn get_biggest(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode> {
+pub fn get_biggest(
+    top_level_nodes: Vec<Node>,
+    n: usize,
+    using_file_type_filter: bool,
+) -> Option<DisplayNode> {
     if top_level_nodes.is_empty() {
         // perhaps change this, bring back Error object?
         return None;
@@ -22,18 +27,17 @@ pub fn get_biggest(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode>
     let mut heap = BinaryHeap::new();
     let number_top_level_nodes = top_level_nodes.len();
     let root = get_new_root(top_level_nodes);
-
-    root.children.iter().for_each(|c| heap.push(c));
-
     let mut allowed_nodes = HashSet::new();
+
     allowed_nodes.insert(&root.name);
+    heap = add_children(using_file_type_filter, &root, heap);
 
     for _ in number_top_level_nodes..n {
         let line = heap.pop();
         match line {
             Some(line) => {
-                line.children.iter().for_each(|c| heap.push(c));
                 allowed_nodes.insert(&line.name);
+                heap = add_children(using_file_type_filter, line, heap);
             }
             None => break,
         }
@@ -41,6 +45,72 @@ pub fn get_biggest(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode>
     recursive_rebuilder(&allowed_nodes, &root)
 }
 
+pub fn get_all_file_types(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode> {
+    let mut map: HashMap<String, DisplayNode> = HashMap::new();
+    build_by_all_file_types(top_level_nodes, &mut map);
+    let mut by_types: Vec<DisplayNode> = map.into_iter().map(|(_k, v)| v).collect();
+    by_types.sort();
+    by_types.reverse();
+
+    let displayed = if by_types.len() <= n {
+        by_types
+    } else {
+        let (displayed, rest) = by_types.split_at(if n > 1 { n - 1 } else { 1 });
+        let remaining = DisplayNode {
+            name: PathBuf::from("(others)"),
+            size: rest.iter().map(|a| a.size).sum(),
+            children: vec![],
+        };
+
+        let mut displayed = displayed.to_vec();
+        displayed.push(remaining);
+        displayed
+    };
+
+    let result = DisplayNode {
+        name: PathBuf::from("(total)"),
+        size: displayed.iter().map(|a| a.size).sum(),
+        children: displayed,
+    };
+    Some(result)
+}
+
+fn add_children<'a>(
+    using_file_type_filter: bool,
+    line: &'a Node,
+    mut heap: BinaryHeap<&'a Node>,
+) -> BinaryHeap<&'a Node> {
+    if using_file_type_filter {
+        line.children.iter().for_each(|c| {
+            if c.name.is_file() || c.size > 0 {
+                heap.push(c)
+            }
+        });
+    } else {
+        line.children.iter().for_each(|c| heap.push(c));
+    }
+    heap
+}
+
+fn build_by_all_file_types(top_level_nodes: Vec<Node>, counter: &mut HashMap<String, DisplayNode>) {
+    for node in top_level_nodes {
+        if node.name.is_file() {
+            let ext = node.name.extension();
+            let key: String = match ext {
+                Some(e) => ".".to_string() + &e.to_string_lossy(),
+                None => "(no extension)".into(),
+            };
+            let mut display_node = counter.entry(key.clone()).or_insert(DisplayNode {
+                name: PathBuf::from(key),
+                size: 0,
+                children: vec![],
+            });
+            display_node.size += node.size;
+        }
+        build_by_all_file_types(node.children, counter)
+    }
+}
+
 fn build_by_depth(node: &Node, depth: usize) -> DisplayNode {
     let new_children = {
         if depth == 0 {