Increment version number

code to remove duplicate arguments

.gitignore

@@ -5,3 +5,4 @@
 # These are backup files generated by rustfmt
 **/*.rs.bk
 *.swp
+.vscode/*

Cargo.lock

@@ -121,12 +121,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "du-dust"
-version = "0.2.4"
+version = "0.3.1"
 dependencies = [
  "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "assert_cli 0.5.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "clap 2.31.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "tempfile 3.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "walkdir 2.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -259,6 +260,14 @@ dependencies = [
  "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "same-file"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "semver"
 version = "0.8.0"
@@ -403,6 +412,15 @@ dependencies = [
  "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "walkdir"
+version = "2.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "same-file 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "winapi"
 version = "0.2.8"
@@ -467,6 +485,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum remove_dir_all 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "dfc5b3ce5d5ea144bb04ebd093a9e14e9765bcfec866aecda9b6dec43b3d1e24"
 "checksum rustc-demangle 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "11fb43a206a04116ffd7cfcf9bcb941f8eb6cc7ff667272246b0a1c74259a3cb"
 "checksum same-file 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d931a44fdaa43b8637009e7632a02adc4f2b2e0733c08caa4cf00e8da4a117a7"
+"checksum same-file 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "cfb6eded0b06a0b512c8ddbcf04089138c9b4362c2f696f3c3d76039d68f3637"
 "checksum semver 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bee2bc909ab2d8d60dab26e8cad85b25d795b14603a0dcb627b78b9d30b6454b"
 "checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 "checksum serde 1.0.37 (registry+https://github.com/rust-lang/crates.io-index)" = "d3bcee660dcde8f52c3765dd9ca5ee36b4bf35470a738eb0bd5a8752b0389645"
@@ -484,6 +503,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc"
 "checksum vec_map 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "887b5b631c2ad01628bbbaa7dd4c869f80d3186688f8d0b6f58774fbe324988c"
 "checksum walkdir 1.0.7 (registry+https://github.com/rust-lang/crates.io-index)" = "bb08f9e670fab86099470b97cd2b252d6527f0b3cc1401acdb595ffc9dd288ff"
+"checksum walkdir 2.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "63636bd0eb3d00ccb8b9036381b526efac53caf112b7783b730ab3f8e44da369"
 "checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
 "checksum winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "04e3bd221fcbe8a271359c04f21a76db7d0c6028862d1bb5512d85e1e2eb5bb3"
 "checksum winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "du-dust"
 description = "A more intuitive version of du"
-version = "0.2.4"
+version = "0.3.1"
 authors = ["bootandy <bootandy@gmail.com>", "nebkor <code@ardent.nebcorp.com>"]
 
 documentation = "https://github.com/bootandy/dust"
@@ -24,4 +24,5 @@ ansi_term = "0.11"
 clap = "2.31"
 assert_cli = "0.5"
 tempfile = "3"
+walkdir = "2"
 

README.md

@@ -1,58 +1,72 @@
+
 [![Build Status](https://travis-ci.org/bootandy/dust.svg?branch=master)](https://travis-ci.org/bootandy/dust)
 
-
 # Dust
+
 du + rust = dust. Like du but more intuitive
 
 ## Install
 
- * Download linux / mac binary from [Releases](https://github.com/bootandy/dust/releases)
+#### Cargo Install
- * unzip file: tar -xvf _downloaded_file.tar.gz_
+
- * move file to executable path: sudo mv dust /usr/local/bin/
+* cargo install du-dust
+
+#### Download Install
+
+* Download linux / mac binary from [Releases](https://github.com/bootandy/dust/releases)
+* unzip file: tar -xvf _downloaded_file.tar.gz_
+* move file to executable path: sudo mv dust /usr/local/bin/
 
 ## Overview
+
 Dust is meant to give you an instant overview of which directories are using disk space without requiring sort or head. Dust will print a maximum of 1 'Did not have permissions message'.
 
-Dust will list the 15 biggest sub directories or files and will smartly recurse down the tree to find the larger ones. There is no need for a '-d' flag or a '-h' flag. The largest sub directory will have its size shown in *red*
+Dust will list the 20 biggest sub directories or files and will smartly recurse down the tree to find the larger ones. There is no need for a '-d' flag or a '-h' flag. The largest sub directory will have its size shown in *red*
 
 ## Why?
-du has a number of ways of showing you what it finds, in terms of disk consumption, but really, there are only one or two ways you invoke it: with -h for “human readable” units, like 100G or 89k, or with -b for “bytes”. The former is generally used for a quick survey of a directory with a small number of things in it, and the latter for when you have a bunch and need to sort the output numerically, and you’re obligated to either further pass it into something like awk to turn bytes into the appropriate human-friendly unit like mega or gigabytes, or you just do some rough math in your head and use the ordering to sanity check. Then once you have the top offenders, you recurse down into the largest one and repeat the process until you’ve found your cruft or gems and can move on.
 
-Dust assumes that’s what you wanted to do in the first place, and takes care of tracking the largest offenders in terms of actual size, and showing them to you with human-friendly units and in-context within the filetree. 
+du has a number of ways of showing you what it finds, in terms of disk consumption, but really, there are only one or two ways you invoke it: with -h for “human readable” units, like 100G or 89k, or with -b for “bytes”. The former is generally used for a quick survey of a directory with a small number of things in it, and the latter for when you have a bunch and need to sort the output numerically, and you’re obligated to either further pass it into something like awk to turn bytes into the appropriate human-friendly unit like mega or gigabytes, or pipe thru sort and head while remembering the '-h' flag. Then once you have the top offenders, you recurse down into the largest one and repeat the process until you’ve found your cruft or gems and can move on.
+
+Dust assumes that’s what you wanted to do in the first place, and takes care of tracking the largest offenders in terms of actual size, and showing them to you with human-friendly units and in-context within the filetree.
 
 ## Usage
+
 ```
 Usage: dust <dir>
-Usage: dust <dir> <another_dir> <and_more>
+Usage: dust <dir>  <another_dir> <and_more>
-Usage: dust -s <dir> (apparent-size - shows the length of the file as opposed to the amount of disk space it uses)
+Usage: dust -p <dir>  (full-path - does not shorten the path of the subdirectories)
-Usage: dust -n 30  <dir>  (Shows 30 directories not 15)
+Usage: dust -s <dir>  (apparent-size - shows the length of the file as opposed to the amount of disk space it uses)
+Usage: dust -n 30  <dir>  (Shows 30 directories not 20)
+Usage: dust -d 3  <dir>  (Shows 3 levels of subdirectories)
 ```
 
-
 ```
 djin:git/dust> dust
-  65M  .
+ 1.2G  target
-  65M └─┬ ./target
+ 622M ├─┬ debug
-  49M   ├─┬ ./target/debug
+ 445M │ ├── deps
-  26M   │ ├─┬ ./target/debug/deps
+  70M │ ├── incremental
-  21M   │ │ └── ./target/debug/deps/libclap-9e6625ac8ff074ad.rlib
+  56M │ └── build
-  13M   │ ├── ./target/debug/dust
+ 262M ├─┬ rls
- 8.9M   │ └─┬ ./target/debug/incremental
+ 262M │ └─┬ debug
- 6.7M   │   ├─┬ ./target/debug/incremental/dust-2748eiei2tcnp
+ 203M │   ├── deps
- 6.7M   │   │ └─┬ ./target/debug/incremental/dust-2748eiei2tcnp/s-ezd6jnik5u-163pyem-1aab9ncf5glum
+  56M │   └── build
- 3.0M   │   │   └── ./target/debug/incremental/dust-2748eiei2tcnp/s-ezd6jnik5u-163pyem-1aab9ncf5glum/dep-graph.bin
+ 165M ├─┬ package
- 2.2M   │   └─┬ ./target/debug/incremental/dust-1dlon65p8m3vl
+ 165M │ └─┬ du-dust-0.2.4
- 2.2M   │     └── ./target/debug/incremental/dust-1dlon65p8m3vl/s-ezd6jncecv-1xsnfd0-4dw9l1r2th2t
+ 165M │   └─┬ target
-  15M   └─┬ ./target/release
+ 165M │     └─┬ debug
- 9.2M     ├─┬ ./target/release/deps
+ 131M │       └── deps
- 6.7M     │ └── ./target/release/deps/libclap-87bc2534ea57f044.rlib
+ 165M └─┬ release
- 5.9M     └── ./target/release/dust
+ 124M   └── deps
 ```
+
 ## Performance
-dust is currently about 4 times slower than du.
+
+Dust is currently about 4 times slower than du.
 
 ## Alternatives
- * [NCDU](https://dev.yorhel.nl/ncdu)
+
- * du -d 1 -h | sort -h
+* [NCDU](https://dev.yorhel.nl/ncdu)
+* du -d 1 -h | sort -h
 
 Note: Apparent-size is calculated slightly differently in dust to gdu. In dust each hard link is counted as using file_length space. In gdu only the first entry is counted.

src/display.rs

@@ -1,91 +1,170 @@
 extern crate ansi_term;
 
 use self::ansi_term::Colour::Fixed;
-
+use std::collections::HashSet;
-use lib::Node;
 
 static UNITS: [char; 4] = ['T', 'G', 'M', 'K'];
 
-pub fn draw_it(permissions: bool, heads: &Vec<Node>, to_display: &Vec<&Node>) -> () {
+pub fn draw_it(
+    permissions: bool,
+    short_paths: bool,
+    depth: Option<u64>,
+    base_dirs: HashSet<String>,
+    to_display: Vec<(String, u64)>,
+) -> () {
     if !permissions {
         eprintln!("Did not have permissions for all directories");
     }
+    let mut found = HashSet::new();
 
-    for d in to_display {
+    for &(ref k, _) in to_display.iter() {
-        if heads.contains(d) {
+        if base_dirs.contains(k) {
-            display_node(d, &to_display, true, "")
+            display_node(&k, &mut found, &to_display, true, short_paths, depth, "─┬")
         }
     }
 }
 
+fn get_size(nodes: &Vec<(String, u64)>, node_to_print: &String) -> Option<u64> {
+    for &(ref k, ref v) in nodes.iter() {
+        if *k == *node_to_print {
+            return Some(*v);
+        }
+    }
+    None
+}
+
 fn display_node<S: Into<String>>(
-    node_to_print: &Node,
+    node_to_print: &String,
-    to_display: &Vec<&Node>,
+    found: &mut HashSet<String>,
-    is_first: bool,
+    to_display: &Vec<(String, u64)>,
+    is_biggest: bool,
+    short_paths: bool,
+    depth: Option<u64>,
     indentation_str: S,
 ) {
-    let mut is = indentation_str.into();
+    if found.contains(node_to_print) {
-    print_this_node(node_to_print, is_first, is.as_ref());
+        return;
+    }
+    found.insert(node_to_print.to_string());
 
-    is = is.replace("└─┬", "  ");
+    let new_depth = match depth {
-    is = is.replace("└──", "  ");
+        None => None,
-    is = is.replace("├──", "│ ");
+        Some(0) => return,
-    is = is.replace("├─┬", "│ ");
+        Some(d) => Some(d - 1),
+    };
+    match get_size(to_display, node_to_print) {
+        None => println!("Can not find path: {}", node_to_print),
+        Some(size) => {
+            let is = indentation_str.into();
+            let ntp: &str = node_to_print.as_ref();
 
-    let printable_node_slashes = node_to_print.name().matches('/').count();
+            print_this_node(ntp, size, is_biggest, short_paths, is.as_ref());
+            let new_indent_str = clean_indentation_string(is);
 
-    let mut num_siblings = to_display.iter().fold(0, |a, b| {
+            let num_slashes = node_to_print.matches('/').count();
-        if node_to_print.children().contains(b)
+            let mut num_siblings = count_siblings(to_display, num_slashes, ntp);
-            && b.name().matches('/').count() == printable_node_slashes + 1
-        {
-            a + 1
-        } else {
-            a
-        }
-    });
 
-    let mut is_biggest = true;
+            let mut is_biggest = true;
-    for node in to_display {
+            for &(ref k, _) in to_display.iter() {
-        if node_to_print.children().contains(node) {
+                if k.starts_with(ntp) && k.matches('/').count() == num_slashes + 1 {
-            let has_display_children = node.children()
+                    num_siblings -= 1;
-                .iter()
-                .fold(false, |has_kids, n| has_kids || to_display.contains(&n));
 
-            let has_children = node.children().len() > 0 && has_display_children;
+                    let mut has_children = false;
-            if node.name().matches('/').count() == printable_node_slashes + 1 {
+                    if new_depth.is_none() || new_depth.unwrap() != 1 {
-                num_siblings -= 1;
+                        for &(ref k2, _) in to_display.iter() {
-
+                            let kk: &str = k.as_ref();
-                let tree_chars = {
+                            if k2.starts_with(kk) && k2.matches('/').count() == num_slashes + 2 {
-                    if num_siblings == 0 {
+                                has_children = true;
-                        if has_children {
+                            }
-                            "└─┬"
-                        } else {
-                            "└──"
-                        }
-                    } else {
-                        if has_children {
-                            "├─┬"
-                        } else {
-                            "├──"
                         }
                     }
-                };
+
-                display_node(&node, to_display, is_biggest, is.to_string() + tree_chars);
+                    display_node(
-                is_biggest = false;
+                        k,
+                        found,
+                        to_display,
+                        is_biggest,
+                        short_paths,
+                        new_depth,
+                        new_indent_str.to_string() + get_tree_chars(num_siblings, has_children),
+                    );
+                    is_biggest = false;
+                }
             }
         }
     }
 }
 
-fn print_this_node(node: &Node, is_biggest: bool, indentation: &str) {
+fn clean_indentation_string<S: Into<String>>(s: S) -> String {
-    let pretty_size = format!("{:>5}", human_readable_number(node.size()),);
+    let mut is = s.into();
+    is = is.replace("└─┬", "  ");
+    is = is.replace("└──", "  ");
+    is = is.replace("├──", "│ ");
+    is = is.replace("├─┬", "│ ");
+    is = is.replace("─┬", " ");
+    is
+}
+
+fn count_siblings(to_display: &Vec<(String, u64)>, num_slashes: usize, ntp: &str) -> u64 {
+    to_display.iter().fold(0, |a, b| {
+        if b.0.starts_with(ntp) && b.0.matches('/').count() == num_slashes + 1 {
+            a + 1
+        } else {
+            a
+        }
+    })
+}
+
+fn get_tree_chars(num_siblings: u64, has_children: bool) -> &'static str {
+    if num_siblings == 0 {
+        if has_children {
+            "└─┬"
+        } else {
+            "└──"
+        }
+    } else {
+        if has_children {
+            "├─┬"
+        } else {
+            "├──"
+        }
+    }
+}
+
+fn print_this_node(
+    node_name: &str,
+    size: u64,
+    is_biggest: bool,
+    short_paths: bool,
+    indentation: &str,
+) {
+    let pretty_size = format!("{:>5}", human_readable_number(size),);
     println!(
         "{}",
-        format_string(node.name(), is_biggest, pretty_size.as_ref(), indentation)
+        format_string(
+            node_name,
+            is_biggest,
+            short_paths,
+            pretty_size.as_ref(),
+            indentation
+        )
     )
 }
 
-pub fn format_string(dir_name: &str, is_biggest: bool, size: &str, indentation: &str) -> String {
+pub fn format_string(
+    dir_name: &str,
+    is_biggest: bool,
+    short_paths: bool,
+    size: &str,
+    indentation: &str,
+) -> String {
+    let printable_name = {
+        if short_paths {
+            dir_name.split('/').last().unwrap_or(dir_name)
+        } else {
+            dir_name
+        }
+    };
     format!(
         "{} {} {}",
         if is_biggest {
@@ -94,7 +173,7 @@ pub fn format_string(dir_name: &str, is_biggest: bool, size: &str, indentation:
             Fixed(7).paint(size)
         },
         indentation,
-        dir_name,
+        printable_name,
     )
 }
 

src/lib.rs

@@ -1,68 +0,0 @@
-use std::cmp::{Eq, Ord, Ordering, PartialEq, PartialOrd};
-
-#[derive(Clone, Debug)]
-pub struct Node {
-    name: String,
-    size: u64,
-    children: Vec<Node>,
-}
-
-impl Node {
-    pub fn new<S: Into<String>>(name: S, size: u64, children: Vec<Node>) -> Self {
-        Node {
-            children: children,
-            name: name.into(),
-            size: size,
-        }
-    }
-
-    pub fn children(&self) -> &Vec<Node> {
-        &self.children
-    }
-
-    pub fn name(&self) -> &String {
-        &self.name
-    }
-
-    pub fn size(&self) -> u64 {
-        self.size
-    }
-}
-
-impl Ord for Node {
-    fn cmp(&self, other: &Self) -> Ordering {
-        if self.size > other.size {
-            Ordering::Less
-        } else if self.size < other.size {
-            Ordering::Greater
-        } else {
-            let my_slashes = self.name.matches('/').count();
-            let other_slashes = other.name.matches('/').count();
-
-            if my_slashes > other_slashes {
-                Ordering::Greater
-            } else if my_slashes < other_slashes {
-                Ordering::Less
-            } else {
-                if self.name < other.name {
-                    Ordering::Less
-                } else if self.name > other.name {
-                    Ordering::Greater
-                } else {
-                    Ordering::Equal
-                }
-            }
-        }
-    }
-}
-impl PartialOrd for Node {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-impl PartialEq for Node {
-    fn eq(&self, other: &Self) -> bool {
-        (&self.name, self.size) == (&other.name, other.size)
-    }
-}
-impl Eq for Node {}

src/main.rs

@@ -1,48 +1,104 @@
 #[macro_use]
 extern crate clap;
 extern crate assert_cli;
+extern crate walkdir;
 
 use self::display::draw_it;
 use clap::{App, AppSettings, Arg};
-use utils::{find_big_ones, get_dir_tree};
+use utils::{find_big_ones, get_dir_tree, simplify_dir_names, sort};
-
 
 mod display;
 mod utils;
-mod lib;
 
-static DEFAULT_NUMBER_OF_LINES: &'static str = "15";
+static DEFAULT_NUMBER_OF_LINES: usize = 20;
 
 fn main() {
+    let def_num_str = DEFAULT_NUMBER_OF_LINES.to_string();
     let options = App::new("Dust")
         .setting(AppSettings::TrailingVarArg)
         .arg(
-            Arg::with_name("number_of_lines")
+            Arg::with_name("depth")
-                .short("n")
+                .short("d")
-                .help("Number of lines of output to show")
+                .long("depth")
-                .takes_value(true)
+                .help("Depth to show")
-                .default_value(DEFAULT_NUMBER_OF_LINES),
+                .takes_value(true),
         )
         .arg(
-            Arg::with_name("use_apparent_size")
+            Arg::with_name("number_of_lines")
+                .short("n")
+                .long("number-of-lines")
+                .help("Number of lines of output to show")
+                .takes_value(true)
+                .default_value(def_num_str.as_ref()),
+        )
+        .arg(
+            Arg::with_name("display_full_paths")
+                .short("p")
+                .long("full-paths")
+                .help("If set sub directories will not have their path shortened"),
+        )
+        .arg(
+            Arg::with_name("display_apparent_size")
                 .short("s")
+                .long("apparent-size")
                 .help("If set will use file length. Otherwise we use blocks"),
         )
         .arg(Arg::with_name("inputs").multiple(true))
         .get_matches();
 
-    let filenames = {
+    let target_dirs = {
         match options.values_of("inputs") {
             None => vec!["."],
             Some(r) => r.collect(),
         }
     };
-    let number_of_lines = value_t!(options.value_of("number_of_lines"), usize).unwrap();
-    let use_apparent_size = options.is_present("use_apparent_size");
 
-    let (permissions, node_per_top_level_dir) = get_dir_tree(&filenames, use_apparent_size);
+    let number_of_lines = match value_t!(options.value_of("number_of_lines"), usize) {
-    let slice_it = find_big_ones(&node_per_top_level_dir, number_of_lines);
+        Ok(v) => v,
-    draw_it(permissions, &node_per_top_level_dir, &slice_it);
+        Err(_) => {
+            eprintln!("Ignoring bad value for number_of_lines");
+            DEFAULT_NUMBER_OF_LINES
+        }
+    };
+
+    let depth = {
+        if options.is_present("depth") {
+            match value_t!(options.value_of("depth"), u64) {
+                Ok(v) => Some(v + 1),
+                Err(_) => {
+                    eprintln!("Ignoring bad value for depth");
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    };
+    if options.is_present("depth") && number_of_lines != DEFAULT_NUMBER_OF_LINES {
+        eprintln!("Use either -n or -d. Not both");
+        return;
+    }
+
+    let use_apparent_size = options.is_present("display_apparent_size");
+    let use_full_path = options.is_present("display_full_paths");
+
+    let simplified_dirs = simplify_dir_names(target_dirs);
+    let (permissions, nodes, top_level_names) = get_dir_tree(simplified_dirs, use_apparent_size);
+    let sorted_data = sort(nodes);
+    let biggest_ones = {
+        if depth.is_none() {
+            find_big_ones(sorted_data, number_of_lines)
+        } else {
+            sorted_data
+        }
+    };
+    draw_it(
+        permissions,
+        !use_full_path,
+        depth,
+        top_level_names,
+        biggest_ones,
+    );
 }
 
 #[cfg(test)]

src/tests.rs

@@ -15,52 +15,91 @@ pub fn test_main() {
     assert_cli::Assert::main_binary()
         .with_args(&["src/test_dir"])
         .stdout()
-        .is(main_output())
+        .is(main_output(true))
+        .unwrap();
+}
+
+#[test]
+pub fn test_main_long_paths() {
+    assert_cli::Assert::main_binary()
+        .with_args(&["-p", "src/test_dir"])
+        .stdout()
+        .is(main_output(false))
+        .unwrap();
+}
+
+#[test]
+pub fn test_main_multi_arg() {
+    assert_cli::Assert::main_binary()
+        .with_args(&["src/test_dir/many/", "src/test_dir/", "src/test_dir"])
+        .stdout()
+        .is(main_output(true))
         .unwrap();
 }
 
 #[cfg(target_os = "macos")]
-fn main_output() -> String {
+fn main_output(short_paths: bool) -> String {
     format!(
         "{}
 {}
 {}
 {}",
-        format_string("src/test_dir", true, " 4.0K", ""),
+        format_string("src/test_dir", true, short_paths, " 4.0K", "─┬"),
-        format_string("src/test_dir/many", true, " 4.0K", "└─┬",),
+        format_string("src/test_dir/many", true, short_paths, " 4.0K", " └─┬",),
-        format_string("src/test_dir/many/hello_file", true, " 4.0K", "  ├──",),
+        format_string(
-        format_string("src/test_dir/many/a_file", false, "   0B", "  └──",),
+            "src/test_dir/many/hello_file",
+            true,
+            short_paths,
+            " 4.0K",
+            "   ├──",
+        ),
+        format_string(
+            "src/test_dir/many/a_file",
+            false,
+            short_paths,
+            "   0B",
+            "   └──",
+        ),
     )
 }
 
 #[cfg(target_os = "linux")]
-fn main_output() -> String {
+fn main_output(short_paths: bool) -> String {
     format!(
         "{}
 {}
 {}
 {}",
-        format_string("src/test_dir", true, " 8.0K", ""),
+        format_string("src/test_dir", true, short_paths, "  12K", "─┬"),
-        format_string("src/test_dir/many", true, " 4.0K", "└─┬",),
+        format_string("src/test_dir/many", true, short_paths, " 8.0K", " └─┬",),
-        format_string("src/test_dir/many/hello_file", true, " 4.0K", "  ├──",),
+        format_string(
-        format_string("src/test_dir/many/a_file", false, "   0B", "  └──",),
+            "src/test_dir/many/hello_file",
+            true,
+            short_paths,
+            " 4.0K",
+            "   ├──",
+        ),
+        format_string(
+            "src/test_dir/many/a_file",
+            false,
+            short_paths,
+            "   0B",
+            "   └──",
+        ),
     )
 }
 
-#[test]
-pub fn test_main_extra_slash() {
-    assert_cli::Assert::main_binary()
-        .with_args(&["src/test_dir/"])
-        .stdout()
-        .is(main_output())
-        .unwrap();
-}
-
 #[test]
 pub fn test_apparent_size() {
     let r = format!(
         "{}",
-        format_string("src/test_dir/many/hello_file", true, "   6B", "  ├──",),
+        format_string(
+            "src/test_dir/many/hello_file",
+            true,
+            true,
+            "   6B",
+            "   ├──",
+        ),
     );
 
     assert_cli::Assert::main_binary()
@@ -93,10 +132,14 @@ pub fn test_soft_sym_link() {
         .output();
     assert!(c.is_ok());
 
+    let r = soft_sym_link_output(dir_s, file_path_s, link_name_s);
+
+    // We cannot guarantee which version will appear first.
+    // TODO: Consider adding predictable itteration order (sort file entries by name?)
     assert_cli::Assert::main_binary()
         .with_args(&[dir_s])
         .stdout()
-        .contains(soft_sym_link_output(dir_s, file_path_s, link_name_s))
+        .contains(r)
         .unwrap();
 }
 
@@ -106,20 +149,21 @@ fn soft_sym_link_output(dir: &str, file_path: &str, link_name: &str) -> String {
         "{}
 {}
 {}",
-        format_string(dir, true, " 8.0K", ""),
+        format_string(dir, true, true, " 8.0K", "─┬"),
-        format_string(file_path, true, " 4.0K", "├──",),
+        format_string(file_path, true, true, " 4.0K", " ├──",),
-        format_string(link_name, false, " 4.0K", "└──",),
+        format_string(link_name, false, true, " 4.0K", " └──",),
     )
 }
+
 #[cfg(target_os = "linux")]
 fn soft_sym_link_output(dir: &str, file_path: &str, link_name: &str) -> String {
     format!(
         "{}
 {}
 {}",
-        format_string(dir, true, " 4.0K", ""),
+        format_string(dir, true, true, " 8.0K", "─┬"),
-        format_string(file_path, true, " 4.0K", "├──",),
+        format_string(file_path, true, true, " 4.0K", " ├──",),
-        format_string(link_name, false, "   0B", "└──",),
+        format_string(link_name, false, true, "   0B", " └──",),
     )
 }
 
@@ -139,18 +183,7 @@ pub fn test_hard_sym_link() {
         .output();
     assert!(c.is_ok());
 
-    let r = format!(
+    let (r, r2) = hard_link_output(dir_s, file_path_s, link_name_s);
-        "{}
-{}",
-        format_string(dir_s, true, " 4.0K", ""),
-        format_string(file_path_s, true, " 4.0K", "└──")
-    );
-    let r2 = format!(
-        "{}
-{}",
-        format_string(dir_s, true, " 4.0K", ""),
-        format_string(link_name_s, true, " 4.0K", "└──")
-    );
 
     // Because this is a hard link the file and hard link look identicle. Therefore
     // we cannot guarantee which version will appear first.
@@ -171,6 +204,40 @@ pub fn test_hard_sym_link() {
     }
 }
 
+#[cfg(target_os = "macos")]
+fn hard_link_output(dir_s: &str, file_path_s: &str, link_name_s: &str) -> (String, String) {
+    let r = format!(
+        "{}
+{}",
+        format_string(dir_s, true, true, " 4.0K", "─┬"),
+        format_string(file_path_s, true, true, " 4.0K", " └──")
+    );
+    let r2 = format!(
+        "{}
+{}",
+        format_string(dir_s, true, true, " 4.0K", "─┬"),
+        format_string(link_name_s, true, true, " 4.0K", " └──")
+    );
+    (r, r2)
+}
+
+#[cfg(target_os = "linux")]
+fn hard_link_output(dir_s: &str, file_path_s: &str, link_name_s: &str) -> (String, String) {
+    let r = format!(
+        "{}
+{}",
+        format_string(dir_s, true, true, " 8.0K", "─┬"),
+        format_string(file_path_s, true, true, " 4.0K", " └──")
+    );
+    let r2 = format!(
+        "{}
+{}",
+        format_string(dir_s, true, true, " 8.0K", "─┬"),
+        format_string(link_name_s, true, true, " 4.0K", " └──")
+    );
+    (r, r2)
+}
+
 //Check we don't recurse down an infinite symlink tree
 #[test]
 pub fn test_recursive_sym_link() {
@@ -199,8 +266,8 @@ fn recursive_sym_link_output(dir: &str, link_name: &str) -> String {
     format!(
         "{}
 {}",
-        format_string(dir, true, " 4.0K", ""),
+        format_string(dir, true, true, " 4.0K", "─┬"),
-        format_string(link_name, true, " 4.0K", "└──",),
+        format_string(link_name, true, true, " 4.0K", " └──",),
     )
 }
 #[cfg(target_os = "linux")]
@@ -208,7 +275,8 @@ fn recursive_sym_link_output(dir: &str, link_name: &str) -> String {
     format!(
         "{}
 {}",
-        format_string(dir, true, "   0B", ""),
+        format_string(dir, true, true, " 4.0K", "─┬"),
-        format_string(link_name, true, "   0B", "└──",),
+        format_string(link_name, true, true, "   0B", " └──",),
     )
 }
+

src/utils/mod.rs

@@ -1,27 +1,51 @@
+use std::cmp::Ordering;
+use std::collections::HashMap;
 use std::collections::HashSet;
 
-use std::fs;
+use walkdir::WalkDir;
 
-use std::path::Path;
-
-use lib::Node;
 mod platform;
 use self::platform::*;
 
-pub fn get_dir_tree(filenames: &Vec<&str>, apparent_size: bool) -> (bool, Vec<Node>) {
+pub fn simplify_dir_names(filenames: Vec<&str>) -> HashSet<String> {
-    let mut permissions = true;
+    let mut top_level_names: HashSet<String> = HashSet::new();
-    let mut inodes: HashSet<(u64, u64)> = HashSet::new();
+
-    let mut results = vec![];
+    for t in filenames {
-    for &b in filenames {
+        let top_level_name = strip_end_slashes(t);
-        let filename = strip_end_slashes(b);
+        let mut can_add = true;
-        let (hp, data) = examine_dir(&Path::new(&filename), apparent_size, &mut inodes);
+        let mut to_remove: Vec<String> = Vec::new();
-        permissions = permissions && hp;
+
-        match data {
+        for tt in top_level_names.iter() {
-            Some(d) => results.push(d),
+            let temp = tt.to_string();
-            None => permissions = false,
+            if top_level_name.starts_with(&temp) {
+                can_add = false;
+            } else if tt.starts_with(&top_level_name) {
+                to_remove.push(temp);
+            }
+        }
+        for tr in to_remove {
+            top_level_names.remove(&tr);
+        }
+        if can_add {
+            top_level_names.insert(top_level_name);
         }
     }
-    (permissions, results)
+
+    top_level_names
+}
+
+pub fn get_dir_tree(
+    top_level_names: HashSet<String>,
+    apparent_size: bool,
+) -> (bool, HashMap<String, u64>, HashSet<String>) {
+    let mut permissions = 0;
+    let mut inodes: HashSet<(u64, u64)> = HashSet::new();
+    let mut data: HashMap<String, u64> = HashMap::new();
+
+    for b in top_level_names.iter() {
+        examine_dir(&b, apparent_size, &mut inodes, &mut data, &mut permissions);
+    }
+    (permissions == 0, data, top_level_names)
 }
 
 fn strip_end_slashes(s: &str) -> String {
@@ -33,89 +57,99 @@ fn strip_end_slashes(s: &str) -> String {
 }
 
 fn examine_dir(
-    sdir: &Path,
+    top_dir: &String,
     apparent_size: bool,
     inodes: &mut HashSet<(u64, u64)>,
-) -> (bool, Option<Node>) {
+    data: &mut HashMap<String, u64>,
-    match fs::read_dir(sdir) {
+    permissions: &mut u64,
-        Ok(file_iter) => {
+) {
-            let mut result = vec![];
+    for entry in WalkDir::new(top_dir) {
-            let mut have_permission = true;
+        match entry {
-            let mut total_size = 0;
+            Ok(e) => {
+                let maybe_size_and_inode = get_metadata(&e, apparent_size);
 
-            for single_path in file_iter {
+                match maybe_size_and_inode {
-                match single_path {
+                    Some((size, maybe_inode)) => {
-                    Ok(d) => {
+                        if !apparent_size {
-                        let file_type = d.file_type().ok();
+                            if let Some(inode_dev_pair) = maybe_inode {
-                        let maybe_size_and_inode = get_metadata(&d, apparent_size);
+                                if inodes.contains(&inode_dev_pair) {
-
+                                    continue;
-                        match (file_type, maybe_size_and_inode) {
-                            (Some(file_type), Some((size, maybe_inode))) => {
-                                if !apparent_size {
-                                    if let Some(inode_dev_pair) = maybe_inode {
-                                        if inodes.contains(&inode_dev_pair) {
-                                            continue;
-                                        }
-                                        inodes.insert(inode_dev_pair);
-                                    }
-                                }
-                                total_size += size;
-
-                                if d.path().is_dir() && !file_type.is_symlink() {
-                                    let (hp, child) = examine_dir(&d.path(), apparent_size, inodes);
-                                    have_permission = have_permission && hp;
-
-                                    match child {
-                                        Some(c) => {
-                                            total_size += c.size();
-                                            result.push(c);
-                                        }
-                                        None => (),
-                                    }
-                                } else {
-                                    let path_name = d.path().to_string_lossy().to_string();
-                                    result.push(Node::new(path_name, size, vec![]))
                                 }
+                                inodes.insert(inode_dev_pair);
                             }
-                            (_, None) => have_permission = false,
+                        }
-                            (_, _) => (),
+                        let mut e_path = e.path().to_path_buf();
+                        loop {
+                            let path_name = e_path.to_string_lossy().to_string();
+                            let s = data.entry(path_name.clone()).or_insert(0);
+                            *s += size;
+                            if path_name == *top_dir {
+                                break;
+                            }
+                            e_path.pop();
                         }
                     }
-                    Err(_) => (),
+                    None => *permissions += 1,
                 }
             }
-            let n = Node::new(sdir.to_string_lossy().to_string(), total_size, result);
+            _ => {}
-            (have_permission, Some(n))
         }
-        Err(_) => (false, None),
+    }
+}
+pub fn compare_tuple(a: &(String, u64), b: &(String, u64)) -> Ordering {
+    let result = b.1.cmp(&a.1);
+    if result == Ordering::Equal {
+        a.0.cmp(&b.0)
+    } else {
+        result
     }
 }
 
-// We start with a list of root directories - these must be the biggest folders
+pub fn sort<'a>(data: HashMap<String, u64>) -> Vec<(String, u64)> {
-// We then repeadedly merge in the children of the biggest directory - Each iteration
+    let mut new_l: Vec<(String, u64)> = data.iter().map(|(a, b)| (a.clone(), *b)).collect();
-// the next biggest directory's children are merged in.
+    new_l.sort_by(|a, b| compare_tuple(&a, &b));
-pub fn find_big_ones<'a>(l: &'a Vec<Node>, max_to_show: usize) -> Vec<&Node> {
+    new_l
-    let mut new_l: Vec<&Node> = l.iter().map(|a| a).collect();
+}
-    new_l.sort();
 
-    for processed_pointer in 0..max_to_show {
+pub fn find_big_ones<'a>(new_l: Vec<(String, u64)>, max_to_show: usize) -> Vec<(String, u64)> {
-        if new_l.len() == processed_pointer {
+    if max_to_show > 0 && new_l.len() > max_to_show {
-            break;
-        }
-        // Must be a list of pointers into new_l otherwise b_list will go out of scope
-        // when it is deallocated
-        let mut b_list: Vec<&Node> = new_l[processed_pointer]
-            .children()
-            .iter()
-            .map(|a| a)
-            .collect();
-        new_l.extend(b_list);
-        new_l.sort();
-    }
-
-    if new_l.len() > max_to_show {
         new_l[0..max_to_show + 1].to_vec()
     } else {
         new_l
     }
 }
+
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+
+    #[test]
+    fn test_simplify_dir() {
+        let mut correct = HashSet::new();
+        correct.insert("a".to_string());
+        assert!(simplify_dir_names(vec!["a"]) == correct);
+    }
+
+    #[test]
+    fn test_simplify_dir_rm_subdir() {
+        let mut correct = HashSet::new();
+        correct.insert("a/b".to_string());
+        assert!(simplify_dir_names(vec!["a/b", "a/b/c", "a/b/d/f"]) == correct);
+    }
+
+    #[test]
+    fn test_simplify_dir_duplicates() {
+        let mut correct = HashSet::new();
+        correct.insert("a/b".to_string());
+        correct.insert("c".to_string());
+        assert!(simplify_dir_names(vec!["a/b", "a/b//", "c", "c/"]) == correct);
+    }
+    #[test]
+    fn test_simplify_dir_rm_subdir_and_not_substrings() {
+        let mut correct = HashSet::new();
+        correct.insert("a/b".to_string());
+        correct.insert("c/a/b".to_string());
+        correct.insert("b".to_string());
+        assert!(simplify_dir_names(vec!["a/b", "c/a/b/", "b"]) == correct);
+    }
+}

src/utils/platform.rs

@@ -1,4 +1,4 @@
-use std;
+use walkdir::DirEntry;
 
 fn get_block_size() -> u64 {
     // All os specific implementations of MetatdataExt seem to define a block as 512 bytes
@@ -6,67 +6,20 @@ fn get_block_size() -> u64 {
     512
 }
 
-#[cfg(target_os = "linux")]
+#[cfg(target_family = "unix")]
-pub fn get_metadata(
+pub fn get_metadata(d: &DirEntry, use_apparent_size: bool) -> Option<(u64, Option<(u64, u64)>)> {
-    d: &std::fs::DirEntry,
-    use_apparent_size: bool,
-) -> Option<(u64, Option<(u64, u64)>)> {
-    use std::os::linux::fs::MetadataExt;
-    match d.metadata().ok() {
-        Some(md) => {
-            let inode = Some((md.st_ino(), md.st_dev()));
-            if use_apparent_size {
-                Some((md.len(), inode))
-            } else {
-                Some((md.st_blocks() * get_block_size(), inode))
-            }
-        }
-        None => None,
-    }
-}
-
-#[cfg(target_os = "unix")]
-pub fn get_metadata(
-    d: &std::fs::DirEntry,
-    use_apparent_size: bool,
-) -> Option<(u64, Option<(u64, u64)>)> {
     use std::os::unix::fs::MetadataExt;
-    match d.metadata().ok() {
+    d.metadata().ok().map_or(None, |md| {
-        Some(md) => {
+        let inode = Some((md.ino(), md.dev()));
-            let inode = Some((md.ino(), md.dev()));
+        if use_apparent_size {
-            if use_apparent_size {
+            Some((md.len(), inode))
-                Some((md.len(), inode))
+        } else {
-            } else {
+            Some((md.blocks() * get_block_size(), inode))
-                Some((md.blocks() * get_block_size(), inode))
-            }
         }
-        None => None,
+    })
-    }
 }
 
-#[cfg(target_os = "macos")]
+#[cfg(not(target_family = "unix"))]
-pub fn get_metadata(
+pub fn get_metadata(d: &DirEntry, _apparent: bool) -> Option<(u64, Option<(u64, u64)>)> {
-    d: &std::fs::DirEntry,
+    d.metadata().ok().map_or(None, |md| Some((md.len(), None)))
-    use_apparent_size: bool,
-) -> Option<(u64, Option<(u64, u64)>)> {
-    use std::os::macos::fs::MetadataExt;
-    match d.metadata().ok() {
-        Some(md) => {
-            let inode = Some((md.st_ino(), md.st_dev()));
-            if use_apparent_size {
-                Some((md.len(), inode))
-            } else {
-                Some((md.st_blocks() * get_block_size(), inode))
-            }
-        }
-        None => None,
-    }
-}
-
-#[cfg(not(any(target_os = "linux", target_os = "unix", target_os = "macos")))]
-pub fn get_metadata(d: &std::fs::DirEntry, _apparent: bool) -> Option<(u64, Option<(u64, u64)>)> {
-    match d.metadata().ok() {
-        Some(md) => Some((md.len(), None)),
-        None => None,
-    }
 }