Update version

README: Add another tool to list of alternatives
README: Remove -x option
2025-12-11 23:30:39 -08:00 · 2021-06-23 09:25:04 +01:00 · 2021-06-22 13:17:34 +01:00 · 2021-06-22 13:17:26 +01:00
16 changed files with 588 additions and 844 deletions
--- a/.github/workflows/CICD.yml
+++ b/.github/workflows/CICD.yml
@@ -81,14 +81,12 @@ jobs:
      matrix:
        job:
          # { os, target, cargo-options, features, use-cross, toolchain }
-          - { os: ubuntu-latest  , target: aarch64-unknown-linux-gnu   , use-cross: use-cross }
-          - { os: ubuntu-latest  , target: aarch64-unknown-linux-musl  , use-cross: use-cross }
          - { os: ubuntu-latest  , target: arm-unknown-linux-gnueabihf , use-cross: use-cross }
-          - { os: ubuntu-20.04   , target: i686-unknown-linux-gnu      , use-cross: use-cross }
-          - { os: ubuntu-20.04   , target: i686-unknown-linux-musl     , use-cross: use-cross }
-          - { os: ubuntu-20.04   , target: x86_64-unknown-linux-gnu    , use-cross: use-cross }
-          - { os: ubuntu-20.04   , target: x86_64-unknown-linux-musl   , use-cross: use-cross }
+          - { os: ubuntu-18.04   , target: i686-unknown-linux-gnu      , use-cross: use-cross }
+          - { os: ubuntu-18.04   , target: i686-unknown-linux-musl     , use-cross: use-cross }
          - { os: ubuntu-18.04   , target: x86_64-unknown-linux-gnu    , use-cross: use-cross }
+          - { os: ubuntu-18.04   , target: x86_64-unknown-linux-musl   , use-cross: use-cross }
+          - { os: ubuntu-16.04   , target: x86_64-unknown-linux-gnu    , use-cross: use-cross }
          - { os: macos-latest   , target: x86_64-apple-darwin         }
          - { os: windows-latest , target: i686-pc-windows-gnu         }
          - { os: windows-latest , target: i686-pc-windows-msvc        }
@@ -101,7 +99,6 @@ jobs:
      run: |
        case ${{ matrix.job.target }} in
          arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
-          aarch64-unknown-linux-gnu) sudo apt-get -y update ; sudo apt-get -y install binutils-aarch64-linux-gnu ;;
        esac
    - name: Initialize workflow variables
      id: vars
@@ -137,7 +134,7 @@ jobs:
        echo ::set-output name=REF_TAG::${REF_TAG}
        echo ::set-output name=REF_SHAS::${REF_SHAS}
        # parse target
-        unset TARGET_ARCH ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) TARGET_ARCH=arm ;; aarch-*) TARGET_ARCH=aarch64 ;; i686-*) TARGET_ARCH=i686 ;; x86_64-*) TARGET_ARCH=x86_64 ;; esac;
+        unset TARGET_ARCH ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) TARGET_ARCH=arm ;; i686-*) TARGET_ARCH=i686 ;; x86_64-*) TARGET_ARCH=x86_64 ;; esac;
        echo set-output name=TARGET_ARCH::${TARGET_ARCH}
        echo ::set-output name=TARGET_ARCH::${TARGET_ARCH}
        unset TARGET_OS ; case ${{ matrix.job.target }} in *-linux-*) TARGET_OS=linux ;; *-apple-*) TARGET_OS=macos ;; *-windows-*) TARGET_OS=windows ;; esac;
@@ -169,16 +166,16 @@ jobs:
        echo ::set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS}
        # # * `arm` cannot be tested on ubuntu-* hosts (b/c testing is currently primarily done via comparison of target outputs with built-in outputs and the `arm` target is not executable on the host)
        JOB_DO_TESTING="true"
-        case ${{ matrix.job.target }} in arm-*|aarch64-*) unset JOB_DO_TESTING ;; esac;
+        case ${{ matrix.job.target }} in arm-*) unset JOB_DO_TESTING ;; esac;
        echo set-output name=JOB_DO_TESTING::${JOB_DO_TESTING:-<empty>/false}
        echo ::set-output name=JOB_DO_TESTING::${JOB_DO_TESTING}
        # # * test only binary for arm-type targets
        unset CARGO_TEST_OPTIONS
-        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-*|aarch64-*) CARGO_TEST_OPTIONS="--bin ${PROJECT_NAME}" ;; esac;
+        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-*) CARGO_TEST_OPTIONS="--bin ${PROJECT_NAME}" ;; esac;
        echo set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
        echo ::set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
        # * strip executable?
-        STRIP="strip" ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;; *-pc-windows-msvc) STRIP="" ;; aarch64-unknown-linux-gnu) STRIP="aarch64-linux-gnu-strip" ;; aarch64-unknown-linux-musl) STRIP="" ;;esac;
+        STRIP="strip" ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;; *-pc-windows-msvc) STRIP="" ;; esac;
        echo set-output name=STRIP::${STRIP}
        echo ::set-output name=STRIP::${STRIP}
    - name: Create all needed build/work directories
@@ -208,18 +205,6 @@ jobs:
        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
        command: build
        args: --release --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
-    - name: Install cargo-deb
-      uses: actions-rs/cargo@v1
-      with:
-          command: install
-          args: cargo-deb
-      if: matrix.job.target == 'i686-unknown-linux-musl' || matrix.job.target == 'x86_64-unknown-linux-musl'
-    - name: Build deb
-      uses: actions-rs/cargo@v1
-      with:
-          command: deb
-          args: --no-build --target=${{ matrix.job.target }}
-      if: matrix.job.target == 'i686-unknown-linux-musl' || matrix.job.target == 'x86_64-unknown-linux-musl'
    - name: Test
      uses: actions-rs/cargo@v1
      with:
@@ -231,12 +216,6 @@ jobs:
      with:
        name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}
        path: target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}
-    - name: Archive deb artifacts
-      uses: actions/upload-artifact@master
-      with:
-        name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}.deb
-        path: target/${{ matrix.job.target }}/debian
-      if: matrix.job.target == 'i686-unknown-linux-musl' || matrix.job.target == 'x86_64-unknown-linux-musl'
    - name: Package
      shell: bash
      run: |
@@ -260,8 +239,6 @@ jobs:
      with:
        files: |
          ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_NAME }}
-          target/${{ matrix.job.target }}/debian/*.deb
-
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11,6 +11,15 @@ dependencies = [
 "memchr",
 ]

+[[package]]
+name = "ansi_term"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "ansi_term"
 version = "0.12.1"
@@ -22,9 +31,9 @@ dependencies = [

 [[package]]
 name = "assert_cmd"
-version = "1.0.8"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c98233c6673d8601ab23e77eb38f999c51100d46c5703b17288c57fddf3a1ffe"
+checksum = "a88b6bd5df287567ffdf4ddf4d33060048e1068308e5f62d81c6f9824a045a48"
 dependencies = [
 "bstr",
 "doc-comment",
@@ -47,21 +56,21 @@ dependencies = [

 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"

 [[package]]
 name = "bitflags"
-version = "1.3.2"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"

 [[package]]
 name = "bstr"
-version = "0.2.17"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
+checksum = "90682c8d613ad3373e66de8c6411e0ae2ab2571e879d2efbf73558cc66f21279"
 dependencies = [
 "lazy_static",
 "memchr",
@@ -76,25 +85,25 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

 [[package]]
 name = "clap"
-version = "3.1.2"
+version = "2.33.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5177fac1ab67102d8989464efd043c6ff44191b1557ec1ddd489b4f7e1447e77"
+checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
 dependencies = [
+ "ansi_term 0.11.0",
 "atty",
 "bitflags",
- "indexmap",
- "lazy_static",
- "os_str_bytes",
 "strsim",
- "termcolor",
+ "term_size",
 "textwrap",
+ "unicode-width",
+ "vec_map",
 ]

 [[package]]
 name = "crossbeam-channel"
-version = "0.5.2"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e54ea8bc3fb1ee042f5aace6e3c6e025d3874866da222930f70ce62aceba0bfa"
+checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
 dependencies = [
 "cfg-if",
 "crossbeam-utils",
@@ -102,9 +111,9 @@ dependencies = [

 [[package]]
 name = "crossbeam-deque"
-version = "0.8.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
+checksum = "94af6efb46fef72616855b036a624cf27ba656ffc9be1b9a3c931cfc7749a9a9"
 dependencies = [
 "cfg-if",
 "crossbeam-epoch",
@@ -113,9 +122,9 @@ dependencies = [

 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.7"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c00d6d2ea26e8b151d99093005cb442fb9a37aeaca582a03ec70946f49ab5ed9"
+checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
 dependencies = [
 "cfg-if",
 "crossbeam-utils",
@@ -126,19 +135,19 @@ dependencies = [

 [[package]]
 name = "crossbeam-utils"
-version = "0.8.7"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e5bed1f1c269533fa816a0a5492b3545209a205ca1a54842be180eb63a16a6"
+checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
 dependencies = [
 "cfg-if",
 "lazy_static",
 ]

 [[package]]
-name = "difflib"
-version = "0.4.0"
+name = "difference"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"

 [[package]]
 name = "doc-comment"
@@ -148,14 +157,14 @@ checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"

 [[package]]
 name = "du-dust"
-version = "0.8.0"
+version = "0.6.0"
 dependencies = [
- "ansi_term",
+ "ansi_term 0.12.1",
 "assert_cmd",
 "clap",
 "lscolors",
+ "num_cpus",
 "rayon",
- "regex",
 "stfu8",
 "tempfile",
 "terminal_size",
@@ -171,57 +180,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"

 [[package]]
-name = "fastrand"
-version = "1.7.0"
+name = "getrandom"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
 dependencies = [
- "instant",
+ "cfg-if",
+ "libc",
+ "wasi",
 ]

-[[package]]
-name = "hashbrown"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
-
 [[package]]
 name = "hermit-abi"
-version = "0.1.19"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
 dependencies = [
 "libc",
 ]

-[[package]]
-name = "indexmap"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
-dependencies = [
- "autocfg",
- "hashbrown",
-]
-
-[[package]]
-name = "instant"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "itertools"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -230,9 +207,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.119"
+version = "0.2.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bf2e165bb3457c8e098ea76f3e3bc9db55f87aa90d52d0e6be741470916aaa4"
+checksum = "12b8adadd720df158f4d70dfe7ccc6adb0472d7c55ca83445f6a5ab3e36f8fb6"

 [[package]]
 name = "lscolors"
@@ -240,68 +217,104 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d24b894c45c9da468621cdd615a5a79ee5e5523dd4f75c76ebc03d458940c16e"
 dependencies = [
- "ansi_term",
+ "ansi_term 0.12.1",
 ]

 [[package]]
 name = "memchr"
-version = "2.4.1"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc"

 [[package]]
 name = "memoffset"
-version = "0.6.5"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
+checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"
 dependencies = [
 "autocfg",
 ]

 [[package]]
 name = "num_cpus"
-version = "1.13.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19e64526ebdee182341572e50e9ad03965aa510cd94427a4549448f285e957a1"
+checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
 dependencies = [
 "hermit-abi",
 "libc",
 ]

 [[package]]
-name = "os_str_bytes"
-version = "6.0.0"
+name = "ppv-lite86"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
-dependencies = [
- "memchr",
-]
+checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"

 [[package]]
 name = "predicates"
-version = "2.1.1"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5aab5be6e4732b473071984b3164dbbfb7a3674d30ea5ff44410b6bcd960c3c"
+checksum = "f49cfaf7fdaa3bfacc6fa3e7054e65148878354a5cfddcf661df4c851f8021df"
 dependencies = [
- "difflib",
- "itertools",
+ "difference",
 "predicates-core",
 ]

 [[package]]
 name = "predicates-core"
-version = "1.0.3"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da1c2388b1513e1b605fcec39a95e0a9e8ef088f71443ef37099fa9ae6673fcb"
+checksum = "57e35a3326b75e49aa85f5dc6ec15b41108cf5aee58eabb1f274dd18b73c2451"

 [[package]]
 name = "predicates-tree"
-version = "1.0.5"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d86de6de25020a36c6d3643a86d9a6a9f552107c0559c60ea03551b5e16c032"
+checksum = "15f553275e5721409451eb85e15fd9a860a6e5ab4496eb215987502b5f5391f2"
 dependencies = [
 "predicates-core",
- "termtree",
+ "treeline",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
+dependencies = [
+ "rand_core",
 ]

 [[package]]
@@ -331,18 +344,18 @@ dependencies = [

 [[package]]
 name = "redox_syscall"
-version = "0.2.10"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+checksum = "5ab49abadf3f9e1c4bc499e8845e152ad87d2ad2d30371841171169e9d75feee"
 dependencies = [
 "bitflags",
 ]

 [[package]]
 name = "regex"
-version = "1.5.5"
+version = "1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a11647b6b25ff05a515cb92c365cec08801e83423a235b51e231e1808747286"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
 dependencies = [
 "aho-corasick",
 "memchr",
@@ -378,9 +391,9 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"

 [[package]]
 name = "stfu8"
-version = "0.2.5"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "019f0c664fd85d5a87dcfb62b40b691055392a35a6e59f4df83d4b770db7e876"
+checksum = "4bf70433e3300a3c395d06606a700cdf4205f4f14dbae2c6833127c6bb22db77"
 dependencies = [
 "lazy_static",
 "regex",
@@ -388,31 +401,32 @@ dependencies = [

 [[package]]
 name = "strsim"
-version = "0.10.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"

 [[package]]
 name = "tempfile"
-version = "3.3.0"
+version = "3.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
+checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
 dependencies = [
 "cfg-if",
- "fastrand",
 "libc",
+ "rand",
 "redox_syscall",
 "remove_dir_all",
 "winapi",
 ]

 [[package]]
-name = "termcolor"
-version = "1.1.2"
+name = "term_size"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+checksum = "1e4129646ca0ed8f45d09b929036bafad5377103edd06e50bf574b353d2b08d9"
 dependencies = [
- "winapi-util",
+ "libc",
+ "winapi",
 ]

 [[package]]
@@ -425,17 +439,15 @@ dependencies = [
 "winapi",
 ]

-[[package]]
-name = "termtree"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "507e9898683b6c43a9aa55b64259b721b52ba226e0f3779137e50ad114a4c90b"
-
 [[package]]
 name = "textwrap"
-version = "0.14.2"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0066c8d12af8b5acd21e00547c3797fde4e8677254a7ee429176ccebbe93dd80"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "term_size",
+ "unicode-width",
+]

 [[package]]
 name = "thousands"
@@ -444,10 +456,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3bf63baf9f5039dadc247375c29eb13706706cfde997d0330d05aa63a77d8820"

 [[package]]
-name = "unicode-width"
-version = "0.1.9"
+name = "treeline"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+checksum = "a7f741b240f1a48843f9b8e0444fb55fb2a4ff67293b50a9179dfd5ea67f8d41"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
+
+[[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"

 [[package]]
 name = "wait-timeout"
@@ -458,6 +482,12 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "wasi"
+version = "0.10.2+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,10 +1,9 @@
 [package]
 name = "du-dust"
 description = "A more intuitive version of du"
-version = "0.8.0"
+version = "0.6.0"
 authors = ["bootandy <bootandy@gmail.com>", "nebkor <code@ardent.nebcorp.com>"]
 edition = "2018"
-readme = "README.md"

 documentation = "https://github.com/bootandy/dust"
 homepage = "https://github.com/bootandy/dust"
@@ -23,14 +22,14 @@ path = "src/main.rs"

 [dependencies]
 ansi_term = "0.12"
-clap = { version = "=3", features=["cargo"] }
+clap = { version = "=2.33", features = ["wrap_help"] }
 lscolors = "0.7"
+num_cpus = "1"
 terminal_size = "0.1"
 unicode-width = "0.1"
 rayon="1"
 thousands = "0.2"
 stfu8 = "0.2"
-regex = "1"

 [target.'cfg(windows)'.dependencies]
 winapi-util = "0.1"
@@ -42,16 +41,3 @@ tempfile = "=3"
 [[test]]
 name = "integration"
 path = "tests/tests.rs"
-
-[package.metadata.deb]
-section = "utils"
-assets = [
-  ["target/release/dust", "usr/bin/", "755"],
-  ["LICENSE", "usr/share/doc/du-dust/", "644"],
-  ["README.md", "usr/share/doc/du-dust/README", "644"],
-]
-extended-description = """\
-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 one
-'Did not have permissions message'.
-"""
--- a/README.md
+++ b/README.md
@@ -26,14 +26,6 @@ Because I want an easy way to see where my disk is being used.

 * `brew tap tgotwig/linux-dust && brew install dust`

-#### [Pacstall](https://github.com/pacstall/pacstall) (Debian/Ubuntu)
-
-* `pacstall -I dust-bin`
-
-#### Windows:
-* Windows GNU version - works
-* Windows MSVC - requires: [VCRUNTIME140.dll](https://docs.microsoft.com/en-gb/cpp/windows/latest-supported-vc-redist?view=msvc-170)
-
 #### Download

 * Download Linux/Mac binary from [Releases](https://github.com/bootandy/dust/releases)
@@ -46,27 +38,19 @@ Dust is meant to give you an instant overview of which directories are using dis

 Dust will list a slightly-less-than-the-terminal-height number of the biggest subdirectories 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 subdirectories will be colored.

-The different colors on the bars: These represent the combined tree hierarchy & disk usage. The shades of grey are used to indicate which parent folder a subfolder belongs to. For instance, look at the above screenshot. `.steam` is a folder taking 44% of the space. From the `.steam` bar is a light grey line that goes up. All these folders are inside `.steam` so if you delete `.steam` all that stuff will be gone too.
-
 ## Usage

 ```
 Usage: dust
 Usage: dust <dir>
 Usage: dust <dir>  <another_dir> <and_more>
-Usage: dust -p (full-path - Show fullpath of the subdirectories)
-Usage: dust -s (apparent-size - shows the length of the file as opposed to the amount of disk space it uses)
-Usage: dust -n 30 (shows 30 directories instead of the default [default is terminal height])
-Usage: dust -d 3  (shows 3 levels of subdirectories)
-Usage: dust -r  (reverse order of output)
-Usage: dust -X ignore  (ignore all files and directories with the name 'ignore')
-Usage: dust -x (only show directories on the same filesystem)
-Usage: dust -b (do not show percentages or draw ASCII bars)
-Usage: dust -i (do not show hidden files)
-Usage: dust -c (No colors [monochrome])
-Usage: dust -f (Count files instead of diskspace)
-Usage: dust -t Group by filetype
-Usage: dust -e regex Only include files matching this regex (eg dust -e "\.png$" would match png files)
+Usage: dust -p <dir>  (full-path - does not shorten the path of the subdirectories)
+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 instead of the default)
+Usage: dust -d 3  <dir>  (shows 3 levels of subdirectories)
+Usage: dust -r  <dir>  (reverse order of output, with root at the lowest)
+Usage: dust -X ignore  <dir>  (ignore all files and directories with the name 'ignore')
+Usage: dust -b <dir>  (do not show percentages or draw ASCII bars)
 ```


--- a/ci/how2publish.txt
+++ b/ci/how2publish.txt
@@ -1,6 +1,6 @@
 # ----------- To do a release ---------
 # edit version in cargo.toml
-# tag a commit and push (increment version in Cargo.toml first):
+# tag a commit and push (increment version first):
 #   git tag v0.4.5
 #   git push origin v0.4.5

--- a/src/dir_walker.rs
+++ b/src/dir_walker.rs
@@ -1,11 +1,8 @@
 use std::fs;

 use crate::node::Node;
-use crate::utils::is_filtered_out_due_to_invert_regex;
-use crate::utils::is_filtered_out_due_to_regex;
 use rayon::iter::ParallelBridge;
 use rayon::prelude::ParallelIterator;
-use regex::Regex;
 use std::path::PathBuf;

 use std::sync::atomic;
@@ -16,29 +13,30 @@ use std::collections::HashSet;
 use crate::node::build_node;
 use std::fs::DirEntry;

-use crate::platform::get_metadata;
-
-pub struct WalkData<'a> {
-    pub ignore_directories: HashSet<PathBuf>,
-    pub filter_regex: &'a [Regex],
-    pub invert_filter_regex: &'a [Regex],
-    pub allowed_filesystems: HashSet<u64>,
-    pub use_apparent_size: bool,
-    pub by_filecount: bool,
-    pub ignore_hidden: bool,
-}
-
-pub fn walk_it(dirs: HashSet<PathBuf>, walk_data: WalkData) -> (Vec<Node>, bool) {
+pub fn walk_it(
+    dirs: HashSet<PathBuf>,
+    ignore_directories: HashSet<PathBuf>,
+    use_apparent_size: bool,
+    by_filecount: bool,
+    ignore_hidden: bool,
+) -> (Vec<Node>, bool) {
    let permissions_flag = AtomicBool::new(false);

    let top_level_nodes: Vec<_> = dirs
        .into_iter()
        .filter_map(|d| {
-            let n = walk(d, &permissions_flag, &walk_data, 0);
+            let n = walk(
+                d,
+                &permissions_flag,
+                &ignore_directories,
+                use_apparent_size,
+                by_filecount,
+                ignore_hidden,
+            );
            match n {
                Some(n) => {
                    let mut inodes: HashSet<(u64, u64)> = HashSet::new();
-                    clean_inodes(n, &mut inodes, walk_data.use_apparent_size)
+                    clean_inodes(n, &mut inodes, use_apparent_size)
                }
                None => None,
            }
@@ -73,47 +71,26 @@ fn clean_inodes(
        size: x.size + new_children.iter().map(|c| c.size).sum::<u64>(),
        children: new_children,
        inode_device: x.inode_device,
-        depth: x.depth,
    });
 }

-fn ignore_file(entry: &DirEntry, walk_data: &WalkData) -> bool {
+fn ignore_file(
+    entry: &DirEntry,
+    ignore_hidden: bool,
+    ignore_directories: &HashSet<PathBuf>,
+) -> bool {
    let is_dot_file = entry.file_name().to_str().unwrap_or("").starts_with('.');
-    let is_ignored_path = walk_data.ignore_directories.contains(&entry.path());
-
-    if !walk_data.allowed_filesystems.is_empty() {
-        let size_inode_device = get_metadata(&entry.path(), false);
-
-        if let Some((_size, Some((_id, dev)))) = size_inode_device {
-            if !walk_data.allowed_filesystems.contains(&dev) {
-                return true;
-            }
-        }
-    }
-
-    // Keeping `walk_data.filter_regex.is_empty()` is important for performance reasons, it stops unnecessary work
-    if !walk_data.filter_regex.is_empty()
-        && entry.path().is_file()
-        && is_filtered_out_due_to_regex(walk_data.filter_regex, &entry.path())
-    {
-        return true;
-    }
-
-    if !walk_data.invert_filter_regex.is_empty()
-        && entry.path().is_file()
-        && is_filtered_out_due_to_invert_regex(walk_data.invert_filter_regex, &entry.path())
-    {
-        return true;
-    }
-
-    (is_dot_file && walk_data.ignore_hidden) || is_ignored_path
+    let is_ignored_path = ignore_directories.contains(&entry.path());
+    (is_dot_file && ignore_hidden) || is_ignored_path
 }

 fn walk(
    dir: PathBuf,
    permissions_flag: &AtomicBool,
-    walk_data: &WalkData,
-    depth: usize,
+    ignore_directories: &HashSet<PathBuf>,
+    use_apparent_size: bool,
+    by_filecount: bool,
+    ignore_hidden: bool,
 ) -> Option<Node> {
    let mut children = vec![];

@@ -127,23 +104,25 @@ fn walk(
                    // rayon doesn't parallelise as well giving a 3X performance drop
                    // hence we unravel the recursion a bit

-                    // return walk(entry.path(), permissions_flag, ignore_directories, allowed_filesystems, use_apparent_size, by_filecount, ignore_hidden);
+                    // return walk(entry.path(), permissions_flag, ignore_directories, use_apparent_size, by_filecount, ignore_hidden);

-                    if !ignore_file(entry, walk_data) {
+                    if !ignore_file(&entry, ignore_hidden, &ignore_directories) {
                        if let Ok(data) = entry.file_type() {
                            if data.is_dir() && !data.is_symlink() {
-                                return walk(entry.path(), permissions_flag, walk_data, depth + 1);
+                                return walk(
+                                    entry.path(),
+                                    permissions_flag,
+                                    ignore_directories,
+                                    use_apparent_size,
+                                    by_filecount,
+                                    ignore_hidden,
+                                );
                            }
                            return build_node(
                                entry.path(),
                                vec![],
-                                walk_data.filter_regex,
-                                walk_data.invert_filter_regex,
-                                walk_data.use_apparent_size,
-                                data.is_symlink(),
-                                data.is_file(),
-                                walk_data.by_filecount,
-                                depth + 1,
+                                use_apparent_size,
+                                by_filecount,
                            );
                        }
                    }
@@ -156,17 +135,7 @@ fn walk(
    } else {
        permissions_flag.store(true, atomic::Ordering::Relaxed);
    }
-    build_node(
-        dir,
-        children,
-        walk_data.filter_regex,
-        walk_data.invert_filter_regex,
-        walk_data.use_apparent_size,
-        false,
-        false,
-        walk_data.by_filecount,
-        depth,
-    )
+    build_node(dir, children, use_apparent_size, by_filecount)
 }

 mod tests {
@@ -180,7 +149,6 @@ mod tests {
            size: 10,
            children: vec![],
            inode_device: Some((5, 6)),
-            depth: 0,
        }
    }

--- a/src/display.rs
+++ b/src/display.rs
@@ -28,7 +28,6 @@ pub struct DisplayData {
    pub base_size: u64,
    pub longest_string_length: usize,
    pub ls_colors: LsColors,
-    pub iso: bool,
 }

 impl DisplayData {
@@ -84,13 +83,13 @@ impl DrawData<'_> {
    }

    // TODO: can we test this?
-    fn generate_bar(&self, node: &DisplayNode) -> String {
+    fn generate_bar(&self, node: &DisplayNode, level: usize) -> String {
        let chars_in_bar = self.percent_bar.chars().count();
        let num_bars = chars_in_bar as f32 * self.display_data.percent_size(node);
        let mut num_not_my_bar = (chars_in_bar as i32) - num_bars as i32;

        let mut new_bar = "".to_string();
-        let idx = 5 - min(4, max(1, node.depth));
+        let idx = 5 - min(4, max(1, level));

        for c in self.percent_bar.chars() {
            num_not_my_bar -= 1;
@@ -108,36 +107,39 @@ impl DrawData<'_> {

 #[allow(clippy::too_many_arguments)]
 pub fn draw_it(
+    permission_error: bool,
    use_full_path: bool,
    is_reversed: bool,
    no_colors: bool,
    no_percents: bool,
    terminal_width: usize,
    by_filecount: bool,
-    root_node: DisplayNode,
-    iso: bool,
+    option_root_node: Option<DisplayNode>,
 ) {
+    if permission_error {
+        eprintln!("Did not have permissions for all directories");
+    }
+    if option_root_node.is_none() {
+        return;
+    }
+    let root_node = option_root_node.unwrap();
+
    let num_chars_needed_on_left_most = if by_filecount {
-        let max_size = root_node.size;
+        let max_size = root_node.children.iter().map(|n| n.size).fold(0, max);
        max_size.separate_with_commas().chars().count()
    } else {
        5 // Under normal usage we need 5 chars to display the size of a directory
    };

-    assert!(
-        terminal_width > num_chars_needed_on_left_most + 2,
-        "Not enough terminal width"
-    );
-
-    let allowed_width = terminal_width - num_chars_needed_on_left_most - 2;
+    let terminal_width = terminal_width - 9 - num_chars_needed_on_left_most;
    let num_indent_chars = 3;
    let longest_string_length =
-        find_longest_dir_name(&root_node, num_indent_chars, allowed_width, !use_full_path);
+        find_longest_dir_name(&root_node, num_indent_chars, terminal_width, !use_full_path);

-    let max_bar_length = if no_percents || longest_string_length + 7 >= allowed_width as usize {
+    let max_bar_length = if no_percents || longest_string_length >= terminal_width as usize {
        0
    } else {
-        allowed_width as usize - longest_string_length - 7
+        terminal_width as usize - longest_string_length
    };

    let first_size_bar = repeat(BLOCKS[0]).take(max_bar_length).collect::<String>();
@@ -151,7 +153,6 @@ pub fn draw_it(
        base_size: root_node.size,
        longest_string_length,
        ls_colors: LsColors::from_env().unwrap_or_default(),
-        iso,
    };
    let draw_data = DrawData {
        indent: "".to_string(),
@@ -181,8 +182,10 @@ fn find_longest_dir_name(
 }

 fn display_node(node: DisplayNode, draw_data: &DrawData, is_biggest: bool, is_last: bool) {
+    // hacky way of working out how deep we are in the tree
    let indent = draw_data.get_new_indent(!node.children.is_empty(), is_last);
-    let bar_text = draw_data.generate_bar(&node);
+    let level = ((indent.chars().count() - 1) / 2) - 1;
+    let bar_text = draw_data.generate_bar(&node, level);

    let to_print = format_string(
        &node,
@@ -258,30 +261,23 @@ fn pad_or_trim_filename(node: &DisplayNode, indent: &str, display_data: &Display
    let indent_and_name = format!("{} {}", indent, name);
    let width = UnicodeWidthStr::width(&*indent_and_name);

-    assert!(
-        display_data.longest_string_length >= width,
-        "Terminal width not wide enough to draw directory tree"
-    );
+    assert!(display_data.longest_string_length >= width);

    // Add spaces after the filename so we can draw the % used bar chart.
    let name_and_padding = name
-        + " "
-            .repeat(display_data.longest_string_length - width)
-            .as_str();
+        + &(repeat(" ")
+            .take(display_data.longest_string_length - width)
+            .collect::<String>());

-    name_and_padding
+    maybe_trim_filename(name_and_padding, display_data)
 }

-fn maybe_trim_filename(name_in: String, indent: &str, display_data: &DisplayData) -> String {
-    let indent_length = UnicodeWidthStr::width(indent);
-    assert!(
-        display_data.longest_string_length >= indent_length + 2,
-        "Terminal width not wide enough to draw directory tree"
-    );
-
-    let max_size = display_data.longest_string_length - indent_length;
-    if UnicodeWidthStr::width(&*name_in) > max_size {
-        let name = name_in.chars().take(max_size - 2).collect::<String>();
+fn maybe_trim_filename(name_in: String, display_data: &DisplayData) -> String {
+    if UnicodeWidthStr::width(&*name_in) > display_data.longest_string_length {
+        let name = name_in
+            .chars()
+            .take(display_data.longest_string_length - 2)
+            .collect::<String>();
        name + ".."
    } else {
        name_in
@@ -314,7 +310,7 @@ fn get_name_percent(
        (percents, name_and_padding)
    } else {
        let n = get_printable_name(&node.name, display_data.short_paths);
-        let name = maybe_trim_filename(n, indent, display_data);
+        let name = maybe_trim_filename(n, display_data);
        ("".into(), name)
    }
 }
@@ -324,9 +320,9 @@ fn get_pretty_size(node: &DisplayNode, is_biggest: bool, display_data: &DisplayD
        let size_as_str = node.size.separate_with_commas();
        let spaces_to_add =
            display_data.num_chars_needed_on_left_most - size_as_str.chars().count();
-        size_as_str + " ".repeat(spaces_to_add).as_str()
+        size_as_str + &*repeat(' ').take(spaces_to_add).collect::<String>()
    } else {
-        format!("{:>5}", human_readable_number(node.size, display_data.iso))
+        format!("{:>5}", human_readable_number(node.size))
    };

    if is_biggest && display_data.colors_on {
@@ -355,10 +351,9 @@ fn get_pretty_name(
    }
 }

-fn human_readable_number(size: u64, iso: bool) -> String {
+fn human_readable_number(size: u64) -> String {
    for (i, u) in UNITS.iter().enumerate() {
-        let num: u64 = if iso { 1000 } else { 1024 };
-        let marker = num.pow((UNITS.len() - i) as u32);
+        let marker = 1024u64.pow((UNITS.len() - i) as u32);
        if size >= marker {
            if size / marker < 10 {
                return format!("{:.1}{}", (size as f32 / marker as f32), u);
@@ -387,7 +382,6 @@ mod tests {
            base_size: 1,
            longest_string_length,
            ls_colors: LsColors::from_env().unwrap_or_default(),
-            iso: false,
        }
    }

@@ -396,7 +390,6 @@ mod tests {
        let n = DisplayNode {
            name: PathBuf::from("/short"),
            size: 2_u64.pow(12), // This is 4.0K
-            depth: 1,
            children: vec![],
        };
        let indent = "┌─┴";
@@ -408,7 +401,7 @@ mod tests {
            indent,
            percent_bar,
            is_biggest,
-            &get_fake_display_data(20),
+            &get_fake_display_data(6),
        );
        assert_eq!(s, " 4.0K ┌─┴ short");
    }
@@ -419,7 +412,6 @@ mod tests {
        let n = DisplayNode {
            name: PathBuf::from(name),
            size: 2_u64.pow(12), // This is 4.0K
-            depth: 1,
            children: vec![],
        };
        let indent = "┌─┴";
@@ -430,27 +422,21 @@ mod tests {
        let s = format_string(&n, indent, percent_bar, is_biggest, &dd);
        assert_eq!(
            s,
-            " 4.0K ┌─┴ very_long_name_longer_than_the_eighty_character_limit_very_.."
+            " 4.0K ┌─┴ very_long_name_longer_than_the_eighty_character_limit_very_lon.."
        );
    }

    #[test]
    fn test_human_readable_number() {
-        assert_eq!(human_readable_number(1, false), "1B");
-        assert_eq!(human_readable_number(956, false), "956B");
-        assert_eq!(human_readable_number(1004, false), "1004B");
-        assert_eq!(human_readable_number(1024, false), "1.0K");
-        assert_eq!(human_readable_number(1536, false), "1.5K");
-        assert_eq!(human_readable_number(1024 * 512, false), "512K");
-        assert_eq!(human_readable_number(1024 * 1024, false), "1.0M");
-        assert_eq!(
-            human_readable_number(1024 * 1024 * 1024 - 1, false),
-            "1023M"
-        );
-        assert_eq!(human_readable_number(1024 * 1024 * 1024 * 20, false), "20G");
-        assert_eq!(
-            human_readable_number(1024 * 1024 * 1024 * 1024, false),
-            "1.0T"
-        );
+        assert_eq!(human_readable_number(1), "1B");
+        assert_eq!(human_readable_number(956), "956B");
+        assert_eq!(human_readable_number(1004), "1004B");
+        assert_eq!(human_readable_number(1024), "1.0K");
+        assert_eq!(human_readable_number(1536), "1.5K");
+        assert_eq!(human_readable_number(1024 * 512), "512K");
+        assert_eq!(human_readable_number(1024 * 1024), "1.0M");
+        assert_eq!(human_readable_number(1024 * 1024 * 1024 - 1), "1023M");
+        assert_eq!(human_readable_number(1024 * 1024 * 1024 * 20), "20G");
+        assert_eq!(human_readable_number(1024 * 1024 * 1024 * 1024), "1.0T");
    }
 }
--- a/src/display_node.rs
+++ b/src/display_node.rs
@@ -5,7 +5,6 @@ use std::path::PathBuf;
 pub struct DisplayNode {
    pub name: PathBuf, //todo: consider moving to a string?
    pub size: u64,
-    pub depth: usize,
    pub children: Vec<DisplayNode>,
 }

@@ -37,12 +36,11 @@ impl DisplayNode {
    }

    pub fn get_children_from_node(&self, is_reversed: bool) -> impl Iterator<Item = DisplayNode> {
-        // we box to avoid the clippy lint warning
-        let out: Box<dyn Iterator<Item = DisplayNode>> = if is_reversed {
-            Box::new(self.children.clone().into_iter().rev())
+        if is_reversed {
+            let children: Vec<DisplayNode> = self.children.clone().into_iter().rev().collect();
+            children.into_iter()
        } else {
-            Box::new(self.children.clone().into_iter())
-        };
-        out
+            self.children.clone().into_iter()
+        }
    }
 }
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -1,16 +1,19 @@
 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;

-pub fn get_biggest(
-    top_level_nodes: Vec<Node>,
-    n: usize,
-    depth: usize,
-    using_a_filter: bool,
-) -> Option<DisplayNode> {
+pub fn get_by_depth(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode> {
+    if top_level_nodes.is_empty() {
+        // perhaps change this, bring back Error object?
+        return None;
+    }
+    let root = get_new_root(top_level_nodes);
+    Some(build_by_depth(&root, n - 1))
+}
+
+pub fn get_biggest(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode> {
    if top_level_nodes.is_empty() {
        // perhaps change this, bring back Error object?
        return None;
@@ -19,17 +22,18 @@ pub fn get_biggest(
    let mut heap = BinaryHeap::new();
    let number_top_level_nodes = top_level_nodes.len();
    let root = get_new_root(top_level_nodes);
-    let mut allowed_nodes = HashSet::new();

+    root.children.iter().for_each(|c| heap.push(c));
+
+    let mut allowed_nodes = HashSet::new();
    allowed_nodes.insert(&root.name);
-    heap = add_children(using_a_filter, &root, depth, 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_a_filter, line, depth, heap);
            }
            None => break,
        }
@@ -37,75 +41,26 @@ pub fn get_biggest(
    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(),
-            depth: 1,
-            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(),
-        depth: 0,
-        children: displayed,
-    };
-    Some(result)
-}
-
-fn add_children<'a>(
-    using_a_filter: bool,
-    file_or_folder: &'a Node,
-    depth: usize,
-    mut heap: BinaryHeap<&'a Node>,
-) -> BinaryHeap<&'a Node> {
-    if depth > file_or_folder.depth {
-        if using_a_filter {
-            file_or_folder.children.iter().for_each(|c| {
-                if c.name.is_file() || c.size > 0 {
-                    heap.push(c)
-                }
-            });
+fn build_by_depth(node: &Node, depth: usize) -> DisplayNode {
+    let new_children = {
+        if depth == 0 {
+            vec![]
        } else {
-            file_or_folder.children.iter().for_each(|c| heap.push(c));
+            let mut new_children: Vec<_> = node
+                .children
+                .iter()
+                .map(|c| build_by_depth(c, depth - 1))
+                .collect();
+            new_children.sort();
+            new_children.reverse();
+            new_children
        }
-    }
-    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,
-                depth: node.depth,
-                children: vec![],
-            });
-            display_node.size += node.size;
-        }
-        build_by_all_file_types(node.children, counter)
+    DisplayNode {
+        name: node.name.clone(),
+        size: node.size,
+        children: new_children,
    }
 }

@@ -117,7 +72,6 @@ fn get_new_root(top_level_nodes: Vec<Node>) -> Node {
            size: total_size,
            children: top_level_nodes,
            inode_device: None,
-            depth: 0,
        }
    } else {
        top_level_nodes.into_iter().next().unwrap()
@@ -144,7 +98,6 @@ fn recursive_rebuilder<'a>(
    let newnode = DisplayNode {
        name: current.name.clone(),
        size: current.size,
-        depth: current.depth,
        children: new_children,
    };
    Some(newnode)
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,24 +1,20 @@
+#[macro_use]
 extern crate clap;
 extern crate rayon;
-extern crate regex;
 extern crate unicode_width;

 use std::collections::HashSet;
-use std::process;

 use self::display::draw_it;
-use clap::{crate_version, Arg};
-use clap::{Command, Values};
-use dir_walker::{walk_it, WalkData};
-use filter::{get_all_file_types, get_biggest};
-use regex::Regex;
+use clap::{App, AppSettings, Arg};
+use dirwalker::walk_it;
+use filter::{get_biggest, get_by_depth};
 use std::cmp::max;
 use std::path::PathBuf;
 use terminal_size::{terminal_size, Height, Width};
-use utils::get_filesystem_devices;
 use utils::simplify_dir_names;

-mod dir_walker;
+mod dirwalker;
 mod display;
 mod display_node;
 mod filter;
@@ -63,7 +59,6 @@ fn get_height_of_terminal() -> usize {
    }
 }

-#[cfg(windows)]
 fn get_width_of_terminal() -> usize {
    // Windows CI runners detect a very low terminal width
    if let Some((Width(w), Height(_h))) = terminal_size() {
@@ -73,193 +68,119 @@ fn get_width_of_terminal() -> usize {
    }
 }

-#[cfg(not(windows))]
-fn get_width_of_terminal() -> usize {
-    if let Some((Width(w), Height(_h))) = terminal_size() {
-        w as usize
-    } else {
-        DEFAULT_TERMINAL_WIDTH
-    }
-}
-
-fn get_regex_value(maybe_value: Option<Values>) -> Vec<Regex> {
-    let mut result = vec![];
-    if let Some(v) = maybe_value {
-        for reg in v {
-            match Regex::new(reg) {
-                Ok(r) => result.push(r),
-                Err(e) => {
-                    eprintln!("Ignoring bad value for regex {:?}", e);
-                    process::exit(1);
-                }
-            }
-        }
-    }
-    result
-}
-
 fn main() {
-    let options = Command::new("Dust")
+    let default_height = get_height_of_terminal();
+    let def_num_str = default_height.to_string();
+
+    let options = App::new("Dust")
        .about("Like du but more intuitive")
        .version(crate_version!())
-        .trailing_var_arg(true)
+        .setting(AppSettings::TrailingVarArg)
        .arg(
-            Arg::new("depth")
-                .short('d')
+            Arg::with_name("depth")
+                .short("d")
                .long("depth")
                .help("Depth to show")
                .takes_value(true)
-                .default_value(usize::MAX.to_string().as_ref())
+                .conflicts_with("number_of_lines"),
        )
        .arg(
-            Arg::new("number_of_lines")
-                .short('n')
+            Arg::with_name("number_of_lines")
+                .short("n")
                .long("number-of-lines")
-                .help("Number of lines of output to show. (Default is terminal_height - 10)")
+                .help("Number of lines of output to show. This is Height, (but h is help)")
                .takes_value(true)
+                .default_value(def_num_str.as_ref()),
        )
        .arg(
-            Arg::new("display_full_paths")
-                .short('p')
+            Arg::with_name("display_full_paths")
+                .short("p")
                .long("full-paths")
                .help("Subdirectories will not have their path shortened"),
        )
        .arg(
-            Arg::new("ignore_directory")
-                .short('X')
+            Arg::with_name("ignore_directory")
+                .short("X")
                .long("ignore-directory")
                .takes_value(true)
                .number_of_values(1)
-                .multiple_occurrences(true)
+                .multiple(true)
                .help("Exclude any file or directory with this name"),
        )
        .arg(
-            Arg::new("limit_filesystem")
-                .short('x')
-                .long("limit-filesystem")
-                .help("Only count the files and directories on the same filesystem as the supplied directory"),
-        )
-        .arg(
-            Arg::new("display_apparent_size")
-                .short('s')
+            Arg::with_name("display_apparent_size")
+                .short("s")
                .long("apparent-size")
                .help("Use file length instead of blocks"),
        )
        .arg(
-            Arg::new("reverse")
-                .short('r')
+            Arg::with_name("reverse")
+                .short("r")
                .long("reverse")
                .help("Print tree upside down (biggest highest)"),
        )
        .arg(
-            Arg::new("no_colors")
-                .short('c')
+            Arg::with_name("no_colors")
+                .short("c")
                .long("no-colors")
-                .help("No colors will be printed (Useful for commands like: watch)"),
+                .help("No colors will be printed (normally largest directories are colored)"),
        )
        .arg(
-            Arg::new("no_bars")
-                .short('b')
+            Arg::with_name("no_bars")
+                .short("b")
                .long("no-percent-bars")
                .help("No percent bars or percentages will be displayed"),
        )
        .arg(
-            Arg::new("by_filecount")
-                .short('f')
+            Arg::with_name("by_filecount")
+                .short("f")
                .long("filecount")
                .help("Directory 'size' is number of child files/dirs not disk size"),
        )
        .arg(
-            Arg::new("ignore_hidden")
-                .short('i') // Do not use 'h' this is used by 'help'
+            Arg::with_name("ignore_hidden")
+                .short("i") // Do not use 'h' this is used by 'help'
                .long("ignore_hidden")
-                .help("Do not display hidden files"),
+                .help("Obey .git_ignore rules & Do not display hidden files"),
        )
        .arg(
-            Arg::new("invert_filter")
-                .short('v')
-                .long("invert-filter")
-                .takes_value(true)
-                .number_of_values(1)
-                .multiple_occurrences(true)
-                .conflicts_with("filter")
-                .conflicts_with("types")
-                .help("Exclude filepaths matching this regex. To ignore png files type: -v \"\\.png$\" "),
-        )
-        .arg(
-            Arg::new("filter")
-                .short('e')
-                .long("filter")
-                .takes_value(true)
-                .number_of_values(1)
-                .multiple_occurrences(true)
-                .conflicts_with("types")
-                .help("Only include filepaths matching this regex. For png files type: -e \"\\.png$\" "),
-        )
-        .arg(
-            Arg::new("types")
-                .short('t')
-                .long("file_types")
-                .conflicts_with("depth")
-                .help("show only these file types"),
-        )
-        .arg(
-            Arg::new("width")
-                .short('w')
+            Arg::with_name("width")
+                .short("w")
                .long("terminal_width")
                .takes_value(true)
                .number_of_values(1)
                .help("Specify width of output overriding the auto detection of terminal width"),
        )
-        .arg(Arg::new("inputs").multiple_occurrences(true).default_value("."))
-        .arg(
-            Arg::new("iso")
-                .short('H')
-                .long("si")
-                .help("print sizes in powers of 1000 (e.g., 1.1G)")
-        )
+        .arg(Arg::with_name("inputs").multiple(true))
        .get_matches();

-    let target_dirs = options
-        .values_of("inputs")
-        .expect("Should be a default value here")
-        .collect();
+    let target_dirs = {
+        match options.values_of("inputs") {
+            None => vec!["."],
+            Some(r) => r.collect(),
+        }
+    };

-    let summarize_file_types = options.is_present("types");
+    let number_of_lines = match value_t!(options.value_of("number_of_lines"), usize) {
+        Ok(v) => v,
+        Err(_) => {
+            eprintln!("Ignoring bad value for number_of_lines");
+            default_height
+        }
+    };

-    let filter_regexs = get_regex_value(options.values_of("filter"));
-    let invert_filter_regexs = get_regex_value(options.values_of("invert_filter"));
-
-    let terminal_width = match options.value_of_t("width") {
+    let terminal_width = match value_t!(options.value_of("width"), usize) {
        Ok(v) => v,
        Err(_) => get_width_of_terminal(),
    };

-    let depth = match options.value_of_t("depth") {
-        Ok(v) => v,
-        Err(_) => {
-            eprintln!("Ignoring bad value for depth");
-            usize::MAX
-        }
-    };
-    // If depth is set we set the default number_of_lines to be max
-    // instead of screen height
-    let default_height = if depth != usize::MAX {
-        usize::MAX
-    } else {
-        get_height_of_terminal()
-    };
-
-    let number_of_lines = match options.value_of("number_of_lines") {
-        Some(v) => match v.parse::<usize>() {
-            Ok(num_lines) => num_lines,
-            Err(_) => {
-                eprintln!("Ignoring bad value for number_of_lines");
-                default_height
-            }
-        },
-        None => default_height,
-    };
+    let depth = options.value_of("depth").and_then(|depth| {
+        depth
+            .parse::<usize>()
+            .map(|v| v + 1)
+            .map_err(|_| eprintln!("Ignoring bad value for depth"))
+            .ok()
+    });

    let no_colors = init_color(options.is_present("no_colors"));
    let use_apparent_size = options.is_present("display_apparent_size");
@@ -270,61 +191,37 @@ fn main() {

    let by_filecount = options.is_present("by_filecount");
    let ignore_hidden = options.is_present("ignore_hidden");
-    let limit_filesystem = options.is_present("limit_filesystem");

    let simplified_dirs = simplify_dir_names(target_dirs);
-    let allowed_filesystems = {
-        if limit_filesystem {
-            get_filesystem_devices(simplified_dirs.iter())
-        } else {
-            HashSet::new()
-        }
-    };

    let ignored_full_path: HashSet<PathBuf> = ignore_directories
        .into_iter()
        .flat_map(|x| simplified_dirs.iter().map(move |d| d.join(x.clone())))
        .collect();

-    let walk_data = WalkData {
-        ignore_directories: ignored_full_path,
-        filter_regex: &filter_regexs,
-        invert_filter_regex: &invert_filter_regexs,
-        allowed_filesystems,
+    let (nodes, errors) = walk_it(
+        simplified_dirs,
+        ignored_full_path,
        use_apparent_size,
        by_filecount,
        ignore_hidden,
-    };
-
-    let (top_level_nodes, has_errors) = walk_it(simplified_dirs, walk_data);
+    );

    let tree = {
-        match (depth, summarize_file_types) {
-            (_, true) => get_all_file_types(top_level_nodes, number_of_lines),
-            (depth, _) => get_biggest(
-                top_level_nodes,
-                number_of_lines,
-                depth,
-                options.values_of("filter").is_some()
-                    || options.value_of("invert_filter").is_some(),
-            ),
+        match depth {
+            None => get_biggest(nodes, number_of_lines),
+            Some(depth) => get_by_depth(nodes, depth),
        }
    };

-    if has_errors {
-        eprintln!("Did not have permissions for all directories");
-    }
-    match tree {
-        None => {}
-        Some(root_node) => draw_it(
-            options.is_present("display_full_paths"),
-            !options.is_present("reverse"),
-            no_colors,
-            options.is_present("no_bars"),
-            terminal_width,
-            by_filecount,
-            root_node,
-            options.is_present("iso"),
-        ),
-    }
+    draw_it(
+        errors,
+        options.is_present("display_full_paths"),
+        !options.is_present("reverse"),
+        no_colors,
+        options.is_present("no_bars"),
+        terminal_width,
+        by_filecount,
+        tree,
+    );
 }
--- a/src/node.rs
+++ b/src/node.rs
@@ -1,8 +1,5 @@
 use crate::platform::get_metadata;
-use crate::utils::is_filtered_out_due_to_invert_regex;
-use crate::utils::is_filtered_out_due_to_regex;

-use regex::Regex;
 use std::cmp::Ordering;
 use std::path::PathBuf;

@@ -12,47 +9,22 @@ pub struct Node {
    pub size: u64,
    pub children: Vec<Node>,
    pub inode_device: Option<(u64, u64)>,
-    pub depth: usize,
 }

-#[allow(clippy::too_many_arguments)]
 pub fn build_node(
    dir: PathBuf,
    children: Vec<Node>,
-    filter_regex: &[Regex],
-    invert_filter_regex: &[Regex],
    use_apparent_size: bool,
-    is_symlink: bool,
-    is_file: bool,
    by_filecount: bool,
-    depth: usize,
 ) -> Option<Node> {
    match get_metadata(&dir, use_apparent_size) {
        Some(data) => {
-            let inode_device = if is_symlink && !use_apparent_size {
-                None
-            } else {
-                data.1
-            };
-
-            let size = if is_filtered_out_due_to_regex(filter_regex, &dir)
-                || is_filtered_out_due_to_invert_regex(invert_filter_regex, &dir)
-                || (is_symlink && !use_apparent_size)
-                || by_filecount && !is_file
-            {
-                0
-            } else if by_filecount {
-                1
-            } else {
-                data.0
-            };
-
+            let (size, inode_device) = if by_filecount { (1, data.1) } else { data };
            Some(Node {
                name: dir,
                size,
                children,
                inode_device,
-                depth,
            })
        }
        None => None,
--- a/src/platform.rs
+++ b/src/platform.rs
@@ -114,15 +114,15 @@ pub fn get_metadata(d: &Path, _use_apparent_size: bool) -> Option<(u64, Option<(

            let attr_filtered = md.file_attributes()
                & !(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_SYSTEM);
-            if (attr_filtered & FILE_ATTRIBUTE_ARCHIVE) != 0
-                || (attr_filtered & FILE_ATTRIBUTE_DIRECTORY) != 0
+            if attr_filtered == FILE_ATTRIBUTE_ARCHIVE
+                || attr_filtered == FILE_ATTRIBUTE_DIRECTORY
                || md.file_attributes() == FILE_ATTRIBUTE_NORMAL
            {
                Some((md.len(), None))
            } else {
-                get_metadata_expensive(d)
+                get_metadata_expensive(&d)
            }
        }
-        _ => get_metadata_expensive(d),
+        _ => get_metadata_expensive(&d),
    }
 }
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,16 +1,19 @@
-use platform::get_metadata;
 use std::collections::HashSet;
 use std::path::{Path, PathBuf};

-use crate::platform;
-use regex::Regex;
+fn is_a_parent_of<P: AsRef<Path>>(parent: P, child: P) -> bool {
+    let parent = parent.as_ref();
+    let child = child.as_ref();
+    child.starts_with(parent) && !parent.starts_with(child)
+}

 pub fn simplify_dir_names<P: AsRef<Path>>(filenames: Vec<P>) -> HashSet<PathBuf> {
    let mut top_level_names: HashSet<PathBuf> = HashSet::with_capacity(filenames.len());
+    let mut to_remove: Vec<PathBuf> = Vec::with_capacity(filenames.len());
+
    for t in filenames {
        let top_level_name = normalize_path(t);
        let mut can_add = true;
-        let mut to_remove: Vec<PathBuf> = Vec::new();

        for tt in top_level_names.iter() {
            if is_a_parent_of(&top_level_name, tt) {
@@ -19,32 +22,17 @@ pub fn simplify_dir_names<P: AsRef<Path>>(filenames: Vec<P>) -> HashSet<PathBuf>
                can_add = false;
            }
        }
-        for r in to_remove {
-            top_level_names.remove(&r);
-        }
+        to_remove.sort_unstable();
+        top_level_names.retain(|tr| to_remove.binary_search(tr).is_err());
+        to_remove.clear();
        if can_add {
            top_level_names.insert(top_level_name);
        }
    }
+
    top_level_names
 }

-pub fn get_filesystem_devices<'a, P: IntoIterator<Item = &'a PathBuf>>(paths: P) -> HashSet<u64> {
-    // Gets the device ids for the filesystems which are used by the argument paths
-    paths
-        .into_iter()
-        .filter_map(|p| {
-            let meta = get_metadata(p, false);
-
-            if let Some((_size, Some((_id, dev)))) = meta {
-                Some(dev)
-            } else {
-                None
-            }
-        })
-        .collect()
-}
-
 pub fn normalize_path<P: AsRef<Path>>(path: P) -> PathBuf {
    // normalize path ...
    // 1. removing repeated separators
@@ -55,28 +43,6 @@ pub fn normalize_path<P: AsRef<Path>>(path: P) -> PathBuf {
    path.as_ref().components().collect::<PathBuf>()
 }

-pub fn is_filtered_out_due_to_regex(filter_regex: &[Regex], dir: &Path) -> bool {
-    if filter_regex.is_empty() {
-        false
-    } else {
-        filter_regex
-            .iter()
-            .all(|f| !f.is_match(&dir.as_os_str().to_string_lossy()))
-    }
-}
-
-pub fn is_filtered_out_due_to_invert_regex(filter_regex: &[Regex], dir: &Path) -> bool {
-    filter_regex
-        .iter()
-        .any(|f| f.is_match(&dir.as_os_str().to_string_lossy()))
-}
-
-fn is_a_parent_of<P: AsRef<Path>>(parent: P, child: P) -> bool {
-    let parent = parent.as_ref();
-    let child = child.as_ref();
-    child.starts_with(parent) && !parent.starts_with(child)
-}
-
 mod tests {
    #[allow(unused_imports)]
    use super::*;
@@ -92,7 +58,6 @@ mod tests {
    fn test_simplify_dir_rm_subdir() {
        let mut correct = HashSet::new();
        correct.insert(["a", "b"].iter().collect::<PathBuf>());
-        assert_eq!(simplify_dir_names(vec!["a/b/c", "a/b", "a/b/d/f"]), correct);
        assert_eq!(simplify_dir_names(vec!["a/b", "a/b/c", "a/b/d/f"]), correct);
    }

--- a/tests/test_exact_output.rs
+++ b/tests/test_exact_output.rs
@@ -1,10 +1,11 @@
 use assert_cmd::Command;
-use std::ffi::OsStr;
 use std::str;
 use std::sync::Once;

 static INIT: Once = Once::new();

+mod tests_symlinks;
+
 /**
 * This file contains tests that verify the exact output of the command.
 * This output differs on Linux / Mac so the tests are harder to write and debug
@@ -36,7 +37,7 @@ fn copy_test_data(dir: &str) {
    };
 }

-fn initialize() {
+pub fn initialize() {
    INIT.call_once(|| {
        copy_test_data("tests/test_dir");
        copy_test_data("tests/test_dir2");
@@ -44,102 +45,161 @@ fn initialize() {
    });
 }

-fn exact_output_test<T: AsRef<OsStr>>(valid_outputs: Vec<String>, command_args: Vec<T>) {
-    initialize();
-
-    let mut a = &mut Command::cargo_bin("dust").unwrap();
-    for p in command_args {
-        a = a.arg(p);
-    }
-    let output: String = str::from_utf8(&a.unwrap().stdout).unwrap().into();
-
-    assert!(valid_outputs
-        .iter()
-        .fold(false, |sum, i| sum || output.contains(i)));
-}
-
 // "windows" result data can vary by host (size seems to be variable by one byte); fix code vs test and re-enable
 #[cfg_attr(target_os = "windows", ignore)]
 #[test]
 pub fn test_main_basic() {
    // -c is no color mode - This makes testing much simpler
-    exact_output_test(main_output(), vec!["-c", "/tmp/test_dir/"])
+    initialize();
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let assert = cmd.arg("-c").arg("/tmp/test_dir/").unwrap().stdout;
+    let output = str::from_utf8(&assert).unwrap();
+    assert!(output.contains(&main_output()));
 }

 #[cfg_attr(target_os = "windows", ignore)]
 #[test]
 pub fn test_main_multi_arg() {
-    let command_args = vec![
-        "-c",
-        "/tmp/test_dir/many/",
-        "/tmp/test_dir",
-        "/tmp/test_dir",
-    ];
-    exact_output_test(main_output(), command_args);
+    initialize();
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let assert = cmd
+        .arg("-c")
+        .arg("/tmp/test_dir/many/")
+        .arg("/tmp/test_dir")
+        .arg("/tmp/test_dir")
+        .unwrap()
+        .stdout;
+    let output = str::from_utf8(&assert).unwrap();
+    assert!(output.contains(&main_output()));
 }

-fn main_output() -> Vec<String> {
-    // Some linux currently thought to be Manjaro, Arch
-    // Although probably depends on how drive is formatted
-    let mac_and_some_linux = r#"
+#[cfg(target_os = "macos")]
+fn main_output() -> String {
+    r#"
   0B     ┌── a_file    │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
 4.0K     ├── hello_file│████████████████████████████████████████████████ │ 100%
 4.0K   ┌─┴ many        │████████████████████████████████████████████████ │ 100%
 4.0K ┌─┴ test_dir      │████████████████████████████████████████████████ │ 100%
 "#
    .trim()
-    .to_string();
+    .to_string()
+}

-    let ubuntu = r#"
+#[cfg(target_os = "linux")]
+fn main_output() -> String {
+    r#"
   0B     ┌── a_file    │               ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
 4.0K     ├── hello_file│               ░░░░░░░░░░░░░░░░█████████████████ │  33%
 8.0K   ┌─┴ many        │               █████████████████████████████████ │  67%
  12K ┌─┴ test_dir      │████████████████████████████████████████████████ │ 100%
  "#
    .trim()
-    .to_string();
+    .to_string()
+}

-    vec![mac_and_some_linux, ubuntu]
+#[cfg(target_os = "windows")]
+fn main_output() -> String {
+    "windows results vary by host".to_string()
 }

 #[cfg_attr(target_os = "windows", ignore)]
 #[test]
 pub fn test_main_long_paths() {
-    let command_args = vec!["-c", "-p", "/tmp/test_dir/"];
-    exact_output_test(main_output_long_paths(), command_args);
+    initialize();
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let assert = cmd
+        .arg("-c")
+        .arg("-p")
+        .arg("/tmp/test_dir/")
+        .unwrap()
+        .stdout;
+    let output = str::from_utf8(&assert).unwrap();
+    assert!(output.contains(&main_output_long_paths()));
 }

-fn main_output_long_paths() -> Vec<String> {
-    let mac_and_some_linux = r#"
+#[cfg(target_os = "macos")]
+fn main_output_long_paths() -> String {
+    r#"
   0B     ┌── /tmp/test_dir/many/a_file    │░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
 4.0K     ├── /tmp/test_dir/many/hello_file│█████████████████████████████ │ 100%
 4.0K   ┌─┴ /tmp/test_dir/many             │█████████████████████████████ │ 100%
 4.0K ┌─┴ /tmp/test_dir                    │█████████████████████████████ │ 100%
 "#
    .trim()
-    .to_string();
-    let ubuntu = r#"
+    .to_string()
+}
+
+#[cfg(target_os = "linux")]
+fn main_output_long_paths() -> String {
+    r#"   
   0B     ┌── /tmp/test_dir/many/a_file    │         ░░░░░░░░░░░░░░░░░░░█ │   0%
 4.0K     ├── /tmp/test_dir/many/hello_file│         ░░░░░░░░░░██████████ │  33%
 8.0K   ┌─┴ /tmp/test_dir/many             │         ████████████████████ │  67%
  12K ┌─┴ /tmp/test_dir                    │█████████████████████████████ │ 100%
 "#
    .trim()
-    .to_string();
-    vec![mac_and_some_linux, ubuntu]
+    .to_string()
+}
+
+#[cfg(target_os = "windows")]
+fn main_output_long_paths() -> String {
+    "windows results vary by host".to_string()
+}
+
+#[cfg_attr(target_os = "windows", ignore)]
+#[test]
+pub fn test_apparent_size() {
+    initialize();
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let assert = cmd.arg("-c").arg("-s").arg("/tmp/test_dir").unwrap().stdout;
+    let output = str::from_utf8(&assert).unwrap();
+    assert!(output.contains(&output_apparent_size()));
+}
+
+#[cfg(target_os = "linux")]
+fn output_apparent_size() -> String {
+    r#"
+   0B     ┌── a_file    │                       ░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
+   6B     ├── hello_file│                       ░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
+ 4.0K   ┌─┴ many        │                       █████████████████████████ │  50%
+ 8.0K ┌─┴ test_dir      │████████████████████████████████████████████████ │ 100%     
+"#
+    .trim()
+    .to_string()
+}
+
+#[cfg(target_os = "macos")]
+fn output_apparent_size() -> String {
+    r#"
+   0B     ┌── a_file    │                    ░░░░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
+   6B     ├── hello_file│                    ░░░░░░░░░░░░░░░░░░░░░░░░░░██ │   3%
+ 134B   ┌─┴ many        │                    ████████████████████████████ │  58%
+ 230B ┌─┴ test_dir      │████████████████████████████████████████████████ │ 100%
+"#
+    .trim()
+    .to_string()
+}
+
+#[cfg(target_os = "windows")]
+fn output_apparent_size() -> String {
+    "windows results vary by host".to_string()
 }

 // Check against directories and files whos names are substrings of each other
 #[cfg_attr(target_os = "windows", ignore)]
 #[test]
 pub fn test_substring_of_names_and_long_names() {
-    let command_args = vec!["-c", "/tmp/test_dir2"];
-    exact_output_test(no_substring_of_names_output(), command_args);
+    initialize();
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd.arg("-c").arg("/tmp/test_dir2").unwrap().stdout;
+    let output = str::from_utf8(&output).unwrap();
+    assert!(output.contains(&no_substring_of_names_output()));
 }

-fn no_substring_of_names_output() -> Vec<String> {
-    let ubuntu = "
-   0B   ┌── long_dir_name_what_a_very_long_dir_name_what_happens_when_this_goe..
+#[cfg(target_os = "linux")]
+fn no_substring_of_names_output() -> String {
+    "
+   0B   ┌── long_dir_name_what_a_very_long_dir_name_what_happens_when_this_g..
 4.0K   ├── dir_name_clash
 4.0K   │ ┌── hello
 8.0K   ├─┴ dir
@@ -148,10 +208,13 @@ fn no_substring_of_names_output() -> Vec<String> {
  24K ┌─┴ test_dir2
    "
    .trim()
-    .into();
+    .into()
+}

-    let mac_and_some_linux = "
-   0B   ┌── long_dir_name_what_a_very_long_dir_name_what_happens_when_this_goe..
+#[cfg(target_os = "macos")]
+fn no_substring_of_names_output() -> String {
+    "
+   0B   ┌── long_dir_name_what_a_very_long_dir_name_what_happens_when_this_g..
 4.0K   │ ┌── hello
 4.0K   ├─┴ dir
 4.0K   ├── dir_name_clash
@@ -160,52 +223,48 @@ fn no_substring_of_names_output() -> Vec<String> {
  12K ┌─┴ test_dir2
  "
    .trim()
-    .into();
-    vec![mac_and_some_linux, ubuntu]
+    .into()
+}
+
+#[cfg(target_os = "windows")]
+fn no_substring_of_names_output() -> String {
+    "PRs".into()
 }

 #[cfg_attr(target_os = "windows", ignore)]
 #[test]
 pub fn test_unicode_directories() {
-    let command_args = vec!["-c", "/tmp/test_dir_unicode"];
-    exact_output_test(unicode_dir(), command_args);
+    initialize();
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd.arg("-c").arg("/tmp/test_dir_unicode").unwrap().stdout;
+    let output = str::from_utf8(&output).unwrap();
+    assert!(output.contains(&unicode_dir()));
 }

-fn unicode_dir() -> Vec<String> {
+#[cfg(target_os = "linux")]
+fn unicode_dir() -> String {
    // The way unicode & asian characters are rendered on the terminal should make this line up
-    let ubuntu = "
+    "
   0B   ┌── ラウトは難しいです！.japan│                                 █ │   0%
   0B   ├── 👩.unicode                │                                 █ │   0%
 4.0K ┌─┴ test_dir_unicode            │██████████████████████████████████ │ 100%
    "
    .trim()
-    .into();
+    .into()
+}

-    let mac_and_some_linux = "
+#[cfg(target_os = "macos")]
+fn unicode_dir() -> String {
+    "
   0B   ┌── ラウトは難しいです！.japan│                                 █ │   0%
   0B   ├── 👩.unicode                │                                 █ │   0%
   0B ┌─┴ test_dir_unicode            │                                 █ │   0%
    "
    .trim()
-    .into();
-    vec![mac_and_some_linux, ubuntu]
+    .into()
 }

-#[cfg_attr(target_os = "windows", ignore)]
-#[test]
-pub fn test_apparent_size() {
-    let command_args = vec!["-c", "-s", "-b", "/tmp/test_dir"];
-    exact_output_test(apparent_size_output(), command_args);
-}
-
-fn apparent_size_output() -> Vec<String> {
-    // The apparent directory sizes are too unpredictable and system dependant to try and match
-    let files = r#"
-   0B     ┌── a_file
-   6B     ├── hello_file
- "#
-    .trim()
-    .to_string();
-
-    vec![files]
+#[cfg(target_os = "windows")]
+fn unicode_dir() -> String {
+    "".into()
 }
--- a/tests/test_flags.rs
+++ b/tests/test_flags.rs
@@ -1,25 +1,17 @@
 use assert_cmd::Command;
-use std::ffi::OsStr;
 use std::str;
-
 /**
 * This file contains tests that test a substring of the output using '.contains'
 *
 * These tests should be the same cross platform
 */

-fn build_command<T: AsRef<OsStr>>(command_args: Vec<T>) -> String {
-    let mut a = &mut Command::cargo_bin("dust").unwrap();
-    for p in command_args {
-        a = a.arg(p);
-    }
-    str::from_utf8(&a.unwrap().stdout).unwrap().into()
-}
-
 // We can at least test the file names are there
 #[test]
 pub fn test_basic_output() {
-    let output = build_command(vec!["tests/test_dir/"]);
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd.arg("tests/test_dir/").unwrap().stdout;
+    let output = str::from_utf8(&output).unwrap();

    assert!(output.contains(" ┌─┴ "));
    assert!(output.contains("test_dir "));
@@ -33,7 +25,9 @@ pub fn test_basic_output() {

 #[test]
 pub fn test_output_no_bars_means_no_excess_spaces() {
-    let output = build_command(vec!["-b", "tests/test_dir/"]);
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd.arg("-b").arg("tests/test_dir/").unwrap().stdout;
+    let output = str::from_utf8(&output).unwrap();
    // If bars are not being shown we don't need to pad the output with spaces
    assert!(output.contains("many"));
    assert!(!output.contains("many    "));
@@ -41,7 +35,15 @@ pub fn test_output_no_bars_means_no_excess_spaces() {

 #[test]
 pub fn test_reverse_flag() {
-    let output = build_command(vec!["-r", "-c", "tests/test_dir/"]);
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd
+        .arg("-c")
+        .arg("-r")
+        .arg("tests/test_dir/")
+        .unwrap()
+        .stdout;
+    let output = str::from_utf8(&output).unwrap();
+
    assert!(output.contains(" └─┬ test_dir "));
    assert!(output.contains("  └─┬ many "));
    assert!(output.contains("    ├── hello_file"));
@@ -51,7 +53,15 @@ pub fn test_reverse_flag() {
 #[test]
 pub fn test_d_flag_works() {
    // We should see the top level directory but not the sub dirs / files:
-    let output = build_command(vec!["-d", "1", "tests/test_dir/"]);
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd
+        .arg("-d")
+        .arg("1")
+        .arg("-s")
+        .arg("tests/test_dir/")
+        .unwrap()
+        .stdout;
+    let output = str::from_utf8(&output).unwrap();
    assert!(!output.contains("hello_file"));
 }

@@ -59,14 +69,31 @@ pub fn test_d_flag_works() {
 pub fn test_d_flag_works_and_still_recurses_down() {
    // We had a bug where running with '-d 1' would stop at the first directory and the code
    // would fail to recurse down
-    let output = build_command(vec!["-d", "1", "-f", "-c", "tests/test_dir2/"]);
-    assert!(output.contains("4 ┌─┴ test_dir2"));
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd
+        .arg("-d")
+        .arg("1")
+        .arg("-f")
+        .arg("-c")
+        .arg("tests/test_dir2/")
+        .unwrap()
+        .stdout;
+    let output = str::from_utf8(&output).unwrap();
+    assert!(output.contains("7 ┌─┴ test_dir2"));
 }

 // Check against directories and files whos names are substrings of each other
 #[test]
 pub fn test_ignore_dir() {
-    let output = build_command(vec!["-c", "-X", "dir_substring", "tests/test_dir2/"]);
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd
+        .arg("-c")
+        .arg("-X")
+        .arg("dir_substring")
+        .arg("tests/test_dir2")
+        .unwrap()
+        .stdout;
+    let output = str::from_utf8(&output).unwrap();
    assert!(!output.contains("dir_substring"));
 }

@@ -81,12 +108,25 @@ pub fn test_with_bad_param() {
 #[test]
 pub fn test_hidden_flag() {
    // Check we can see the hidden file normally
-    let output = build_command(vec!["-c", "tests/test_dir_hidden_entries/"]);
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd
+        .arg("-c")
+        .arg("tests/test_dir_hidden_entries")
+        .unwrap()
+        .stdout;
+    let output = str::from_utf8(&output).unwrap();
    assert!(output.contains(".hidden_file"));
    assert!(output.contains("┌─┴ test_dir_hidden_entries"));

    // Check that adding the '-h' flag causes us to not see hidden files
-    let output = build_command(vec!["-c", "-i", "tests/test_dir_hidden_entries/"]);
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd
+        .arg("-c")
+        .arg("-i")
+        .arg("tests/test_dir_hidden_entries")
+        .unwrap()
+        .stdout;
+    let output = str::from_utf8(&output).unwrap();
    assert!(!output.contains(".hidden_file"));
    assert!(output.contains("┌── test_dir_hidden_entries"));
 }
@@ -94,87 +134,16 @@ pub fn test_hidden_flag() {
 #[test]
 pub fn test_number_of_files() {
    // Check we can see the hidden file normally
-    let output = build_command(vec!["-c", "-f", "tests/test_dir"]);
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd
+        .arg("-c")
+        .arg("-f")
+        .arg("tests/test_dir")
+        .unwrap()
+        .stdout;
+    let output = str::from_utf8(&output).unwrap();
    assert!(output.contains("1     ┌── a_file "));
    assert!(output.contains("1     ├── hello_file"));
-    assert!(output.contains("2   ┌─┴ many"));
-    assert!(output.contains("2 ┌─┴ test_dir"));
-}
-
-#[test]
-pub fn test_show_files_by_type() {
-    // Check we can list files by type
-    let output = build_command(vec!["-c", "-t", "tests"]);
-    assert!(output.contains(" .unicode"));
-    assert!(output.contains(" .japan"));
-    assert!(output.contains(" .rs"));
-    assert!(output.contains(" (no extension)"));
-    assert!(output.contains("┌─┴ (total)"));
-}
-
-#[test]
-pub fn test_show_files_by_regex_match_lots() {
-    // Check we can see '.rs' files in the tests directory
-    let output = build_command(vec!["-c", "-e", "\\.rs$", "tests"]);
-    assert!(output.contains(" ┌─┴ tests"));
-    assert!(!output.contains("0B ┌── tests"));
-    assert!(!output.contains("0B ┌─┴ tests"));
-}
-
-#[test]
-pub fn test_show_files_by_regex_match_nothing() {
-    // Check there are no files named: '.match_nothing' in the tests directory
-    let output = build_command(vec!["-c", "-e", "match_nothing$", "tests"]);
-    assert!(output.contains("0B ┌── tests"));
-}
-
-#[test]
-pub fn test_show_files_by_regex_match_multiple() {
-    let output = build_command(vec![
-        "-c",
-        "-e",
-        "test_dir_hidden",
-        "-e",
-        "test_dir2",
-        "-n",
-        "100",
-        "tests",
-    ]);
-    assert!(output.contains("test_dir2"));
-    assert!(output.contains("test_dir_hidden"));
-    assert!(!output.contains("many")); // We do not find the 'many' folder in the 'test_dir' folder
-}
-
-#[test]
-pub fn test_show_files_by_invert_regex() {
-    let output = build_command(vec!["-c", "-f", "-v", "e", "tests/test_dir2"]);
-    // There are 0 files without 'e' in the name
-    assert!(output.contains("0 ┌── test_dir2"));
-
-    let output = build_command(vec!["-c", "-f", "-v", "a", "tests/test_dir2"]);
-    // There are 2 files without 'a' in the name
-    assert!(output.contains("2 ┌─┴ test_dir2"));
-
-    // There are 4 files in the test_dir2 hierarchy
-    let output = build_command(vec!["-c", "-f", "-v", "match_nothing$", "tests/test_dir2"]);
-    assert!(output.contains("4 ┌─┴ test_dir2"));
-}
-
-#[test]
-pub fn test_show_files_by_invert_regex_match_multiple() {
-    // We ignore test_dir2 & test_dir_unicode, leaving the test_dir folder
-    // which has the 'many' folder inside
-    let output = build_command(vec![
-        "-c",
-        "-v",
-        "test_dir2",
-        "-v",
-        "test_dir_unicode",
-        "-n",
-        "100",
-        "tests",
-    ]);
-    assert!(!output.contains("test_dir2"));
-    assert!(!output.contains("test_dir_unicode"));
-    assert!(output.contains("many"));
+    assert!(output.contains("3   ┌─┴ many"));
+    assert!(output.contains("4 ┌─┴ test_dir"));
 }
--- a/tests/tests_symlinks.rs
+++ b/tests/tests_symlinks.rs
@@ -24,7 +24,7 @@ fn get_width_of_terminal() -> u16 {

 // Mac test runners create tmp files with very long names, hence it may be shortened in the output
 fn get_file_name(name: String) -> String {
-    let terminal_plus_buffer = (get_width_of_terminal() - 12) as usize;
+    let terminal_plus_buffer = (get_width_of_terminal() - 14) as usize;
    if UnicodeWidthStr::width(&*name) > terminal_plus_buffer {
        let trimmed_name = name
            .chars()
Author	SHA1	Message	Date
andy.boot	5c45ed344f	Update version	2021-06-23 09:25:04 +01:00
andy.boot	a8725711fa	README: Add another tool to list of alternatives	2021-06-22 13:17:34 +01:00
andy.boot	811d3b065f	README: Remove -x option This behaviour was removed in previous commit	2021-06-22 13:17:26 +01:00