Update version

README: Add another tool to list of alternatives
README: Remove -x option
2025-12-08 13:50:41 -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
31 changed files with 1316 additions and 3036 deletions
--- a/.github/workflows/CICD.yml
+++ b/.github/workflows/CICD.yml
@@ -22,56 +22,56 @@ jobs:
          - { os: macos-latest }
          - { os: windows-latest }
    steps:
-      - uses: actions/checkout@v1
-      - name: Initialize workflow variables
-        id: vars
-        shell: bash
-        run: |
-          # 'windows-latest' `cargo fmt` is bugged for this project (see reasons @ GH:rust-lang/rustfmt #3324, #3590, #3688 ; waiting for repair)
-          JOB_DO_FORMAT_TESTING="true"
-          case ${{ matrix.job.os }} in windows-latest) unset JOB_DO_FORMAT_TESTING ;; esac;
-          echo set-output name=JOB_DO_FORMAT_TESTING::${JOB_DO_FORMAT_TESTING:-<empty>/false}
-          echo ::set-output name=JOB_DO_FORMAT_TESTING::${JOB_DO_FORMAT_TESTING}
-          # target-specific options
-          # * CARGO_FEATURES_OPTION
-          CARGO_FEATURES_OPTION='' ;
-          if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
-          echo set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
-          echo ::set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
-      - name: Install `rust` toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-          profile: minimal # minimal component installation (ie, no documentation)
-          components: rustfmt, clippy
-      - name: "`fmt` testing"
-        if: steps.vars.outputs.JOB_DO_FORMAT_TESTING
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-      - name: "`clippy` testing"
-        if: success() || failure() # run regardless of prior step ("`fmt` testing") success/failure
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -- -D warnings
+    - uses: actions/checkout@v1
+    - name: Initialize workflow variables
+      id: vars
+      shell: bash
+      run: |
+        # 'windows-latest' `cargo fmt` is bugged for this project (see reasons @ GH:rust-lang/rustfmt #3324, #3590, #3688 ; waiting for repair)
+        JOB_DO_FORMAT_TESTING="true"
+        case ${{ matrix.job.os }} in windows-latest) unset JOB_DO_FORMAT_TESTING ;; esac;
+        echo set-output name=JOB_DO_FORMAT_TESTING::${JOB_DO_FORMAT_TESTING:-<empty>/false}
+        echo ::set-output name=JOB_DO_FORMAT_TESTING::${JOB_DO_FORMAT_TESTING}
+        # target-specific options
+        # * CARGO_FEATURES_OPTION
+        CARGO_FEATURES_OPTION='' ;
+        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
+        echo set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
+        echo ::set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
+    - name: Install `rust` toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+        override: true
+        profile: minimal # minimal component installation (ie, no documentation)
+        components: rustfmt, clippy
+    - name: "`fmt` testing"
+      if: steps.vars.outputs.JOB_DO_FORMAT_TESTING
+      uses: actions-rs/cargo@v1
+      with:
+        command: fmt
+        args: --all -- --check
+    - name: "`clippy` testing"
+      if: success() || failure() # run regardless of prior step ("`fmt` testing") success/failure
+      uses: actions-rs/cargo@v1
+      with:
+        command: clippy
+        args: ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -- -D warnings

  min_version:
    name: MinSRV # Minimum supported rust version
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v1
-      - name: Install `rust` toolchain (v${{ env.RUST_MIN_SRV }})
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ env.RUST_MIN_SRV }}
-          profile: minimal # minimal component installation (ie, no documentation)
-      - name: Test
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
+    - uses: actions/checkout@v1
+    - name: Install `rust` toolchain (v${{ env.RUST_MIN_SRV }})
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: ${{ env.RUST_MIN_SRV }}
+        profile: minimal # minimal component installation (ie, no documentation)
+    - name: Test
+      uses: actions-rs/cargo@v1
+      with:
+        command: test

  build:
    name: Build
@@ -81,216 +81,166 @@ 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-latest,
-              target: i686-unknown-linux-gnu,
-              use-cross: use-cross,
-            }
-          - {
-              os: ubuntu-latest,
-              target: i686-unknown-linux-musl,
-              use-cross: use-cross,
-            }
-          - {
-              os: ubuntu-latest,
-              target: x86_64-unknown-linux-gnu,
-              use-cross: use-cross,
-            }
-          - {
-              os: ubuntu-latest,
-              target: x86_64-unknown-linux-musl,
-              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 }
-          - { os: windows-latest, target: x86_64-pc-windows-gnu } ## !maint: [rivy; 2020-01-21] may break due to rust bug; follow possible solution from GH:rust-lang/rust#47048 (refs: GH:rust-lang/rust#47048 , GH:rust-lang/rust#53454 , GH:bike-barn/hermit#172 )
-          - { os: windows-latest, target: x86_64-pc-windows-msvc }
+          - { os: ubuntu-latest  , target: arm-unknown-linux-gnueabihf , 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        }
+          - { os: windows-latest , target: x86_64-pc-windows-gnu       } ## !maint: [rivy; 2020-01-21] may break due to rust bug; follow possible solution from GH:rust-lang/rust#47048 (refs: GH:rust-lang/rust#47048 , GH:rust-lang/rust#53454 , GH:bike-barn/hermit#172 )
+          - { os: windows-latest , target: x86_64-pc-windows-msvc      }
    steps:
-      - uses: actions/checkout@v1
-      - name: Install any prerequisites
-        shell: bash
-        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
-        shell: bash
-        run: |
-          # toolchain
-          TOOLCHAIN="stable" ## default to "stable" toolchain
-          # * specify alternate TOOLCHAIN for *-pc-windows-gnu targets; gnu targets on Windows are broken for the standard *-pc-windows-msvc toolchain (refs: <https://github.com/rust-lang/rust/issues/47048>, <https://github.com/rust-lang/rust/issues/53454>, <https://github.com/rust-lang/cargo/issues/6754>)
-          case ${{ matrix.job.target }} in *-pc-windows-gnu) TOOLCHAIN="stable-${{ matrix.job.target }}" ;; esac;
-          # * use requested TOOLCHAIN if specified
-          if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
-          echo set-output name=TOOLCHAIN::${TOOLCHAIN}
-          echo ::set-output name=TOOLCHAIN::${TOOLCHAIN}
-          # staging directory
-          STAGING='_staging'
-          echo set-output name=STAGING::${STAGING}
-          echo ::set-output name=STAGING::${STAGING}
-          # determine EXE suffix
-          EXE_suffix="" ; case ${{ matrix.job.target }} in *-pc-windows-*) EXE_suffix=".exe" ;; esac;
-          echo set-output name=EXE_suffix::${EXE_suffix}
-          echo ::set-output name=EXE_suffix::${EXE_suffix}
-          # parse commit reference info
-          REF_NAME=${GITHUB_REF#refs/*/}
-          unset REF_BRANCH ; case ${GITHUB_REF} in refs/heads/*) REF_BRANCH=${GITHUB_REF#refs/heads/} ;; esac;
-          unset REF_TAG ; case ${GITHUB_REF} in refs/tags/*) REF_TAG=${GITHUB_REF#refs/tags/} ;; esac;
-          REF_SHAS=${GITHUB_SHA:0:8}
-          echo set-output name=REF_NAME::${REF_NAME}
-          echo set-output name=REF_BRANCH::${REF_BRANCH}
-          echo set-output name=REF_TAG::${REF_TAG}
-          echo set-output name=REF_SHAS::${REF_SHAS}
-          echo ::set-output name=REF_NAME::${REF_NAME}
-          echo ::set-output name=REF_BRANCH::${REF_BRANCH}
-          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;
-          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;
-          echo set-output name=TARGET_OS::${TARGET_OS}
-          echo ::set-output name=TARGET_OS::${TARGET_OS}
-          # package name
-          PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
-          PKG_BASENAME=${PROJECT_NAME}-${REF_TAG:-$REF_SHAS}-${{ matrix.job.target }}
-          PKG_NAME=${PKG_BASENAME}${PKG_suffix}
-          echo set-output name=PKG_suffix::${PKG_suffix}
-          echo set-output name=PKG_BASENAME::${PKG_BASENAME}
-          echo set-output name=PKG_NAME::${PKG_NAME}
-          echo ::set-output name=PKG_suffix::${PKG_suffix}
-          echo ::set-output name=PKG_BASENAME::${PKG_BASENAME}
-          echo ::set-output name=PKG_NAME::${PKG_NAME}
-          # deployable tag? (ie, leading "vM" or "M"; M == version number)
-          unset DEPLOY ; if [[ $REF_TAG =~ ^[vV]?[0-9].* ]]; then DEPLOY='true' ; fi
-          echo set-output name=DEPLOY::${DEPLOY:-<empty>/false}
-          echo ::set-output name=DEPLOY::${DEPLOY}
-          # target-specific options
-          # * CARGO_FEATURES_OPTION
-          CARGO_FEATURES_OPTION='' ;
-          if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
-          echo set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
-          echo ::set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
-          # * CARGO_USE_CROSS (truthy)
-          CARGO_USE_CROSS='true' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) unset CARGO_USE_CROSS ;; esac;
-          echo set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS:-<empty>/false}
-          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;
-          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;
-          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;
-          echo set-output name=STRIP::${STRIP}
-          echo ::set-output name=STRIP::${STRIP}
-      - name: Create all needed build/work directories
-        shell: bash
-        run: |
-          mkdir -p '${{ steps.vars.outputs.STAGING }}'
-          mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}'
-      - name: rust toolchain ~ install
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
-          target: ${{ matrix.job.target }}
-          override: true
-          profile: minimal # minimal component installation (ie, no documentation)
-      - name: Info
-        shell: bash
-        run: |
-          gcc --version || true
-          rustup -V
-          rustup toolchain list
-          rustup default
-          cargo -V
-          rustc -V
-      - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          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:
-          use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-          command: test
-          args: --target=${{ matrix.job.target }} ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
-      - name: Archive executable artifacts
-        uses: actions/upload-artifact@master
-        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: |
-          # binary
-          cp 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'
-          # `strip` binary (if needed)
-          if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' ; fi
-          # README and LICENSE
-          cp README.md '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'
-          cp LICENSE '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'
-          # base compressed package
-          pushd '${{ steps.vars.outputs.STAGING }}/' >/dev/null
-          case ${{ matrix.job.target }} in
-            *-pc-windows-*) 7z -y a '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* | tail -2 ;;
-            *) tar czf '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* ;;
-          esac;
-          popd >/dev/null
-      - name: Publish
-        uses: softprops/action-gh-release@v1
-        if: steps.vars.outputs.DEPLOY
-        with:
-          files: |
-            ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_NAME }}
-            target/${{ matrix.job.target }}/debian/*.deb
-
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    - uses: actions/checkout@v1
+    - name: Install any prerequisites
+      shell: bash
+      run: |
+        case ${{ matrix.job.target }} in
+          arm-unknown-linux-gnueabihf) sudo apt-get -y update ; sudo apt-get -y install gcc-arm-linux-gnueabihf ;;
+        esac
+    - name: Initialize workflow variables
+      id: vars
+      shell: bash
+      run: |
+        # toolchain
+        TOOLCHAIN="stable" ## default to "stable" toolchain
+        # * specify alternate TOOLCHAIN for *-pc-windows-gnu targets; gnu targets on Windows are broken for the standard *-pc-windows-msvc toolchain (refs: <https://github.com/rust-lang/rust/issues/47048>, <https://github.com/rust-lang/rust/issues/53454>, <https://github.com/rust-lang/cargo/issues/6754>)
+        case ${{ matrix.job.target }} in *-pc-windows-gnu) TOOLCHAIN="stable-${{ matrix.job.target }}" ;; esac;
+        # * use requested TOOLCHAIN if specified
+        if [ -n "${{ matrix.job.toolchain }}" ]; then TOOLCHAIN="${{ matrix.job.toolchain }}" ; fi
+        echo set-output name=TOOLCHAIN::${TOOLCHAIN}
+        echo ::set-output name=TOOLCHAIN::${TOOLCHAIN}
+        # staging directory
+        STAGING='_staging'
+        echo set-output name=STAGING::${STAGING}
+        echo ::set-output name=STAGING::${STAGING}
+        # determine EXE suffix
+        EXE_suffix="" ; case ${{ matrix.job.target }} in *-pc-windows-*) EXE_suffix=".exe" ;; esac;
+        echo set-output name=EXE_suffix::${EXE_suffix}
+        echo ::set-output name=EXE_suffix::${EXE_suffix}
+        # parse commit reference info
+        REF_NAME=${GITHUB_REF#refs/*/}
+        unset REF_BRANCH ; case ${GITHUB_REF} in refs/heads/*) REF_BRANCH=${GITHUB_REF#refs/heads/} ;; esac;
+        unset REF_TAG ; case ${GITHUB_REF} in refs/tags/*) REF_TAG=${GITHUB_REF#refs/tags/} ;; esac;
+        REF_SHAS=${GITHUB_SHA:0:8}
+        echo set-output name=REF_NAME::${REF_NAME}
+        echo set-output name=REF_BRANCH::${REF_BRANCH}
+        echo set-output name=REF_TAG::${REF_TAG}
+        echo set-output name=REF_SHAS::${REF_SHAS}
+        echo ::set-output name=REF_NAME::${REF_NAME}
+        echo ::set-output name=REF_BRANCH::${REF_BRANCH}
+        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 ;; 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;
+        echo set-output name=TARGET_OS::${TARGET_OS}
+        echo ::set-output name=TARGET_OS::${TARGET_OS}
+        # package name
+        PKG_suffix=".tar.gz" ; case ${{ matrix.job.target }} in *-pc-windows-*) PKG_suffix=".zip" ;; esac;
+        PKG_BASENAME=${PROJECT_NAME}-${REF_TAG:-$REF_SHAS}-${{ matrix.job.target }}
+        PKG_NAME=${PKG_BASENAME}${PKG_suffix}
+        echo set-output name=PKG_suffix::${PKG_suffix}
+        echo set-output name=PKG_BASENAME::${PKG_BASENAME}
+        echo set-output name=PKG_NAME::${PKG_NAME}
+        echo ::set-output name=PKG_suffix::${PKG_suffix}
+        echo ::set-output name=PKG_BASENAME::${PKG_BASENAME}
+        echo ::set-output name=PKG_NAME::${PKG_NAME}
+        # deployable tag? (ie, leading "vM" or "M"; M == version number)
+        unset DEPLOY ; if [[ $REF_TAG =~ ^[vV]?[0-9].* ]]; then DEPLOY='true' ; fi
+        echo set-output name=DEPLOY::${DEPLOY:-<empty>/false}
+        echo ::set-output name=DEPLOY::${DEPLOY}
+        # target-specific options
+        # * CARGO_FEATURES_OPTION
+        CARGO_FEATURES_OPTION='' ;
+        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
+        echo set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
+        echo ::set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
+        # * CARGO_USE_CROSS (truthy)
+        CARGO_USE_CROSS='true' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) unset CARGO_USE_CROSS ;; esac;
+        echo set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS:-<empty>/false}
+        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-*) 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-*) 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="" ;; esac;
+        echo set-output name=STRIP::${STRIP}
+        echo ::set-output name=STRIP::${STRIP}
+    - name: Create all needed build/work directories
+      shell: bash
+      run: |
+        mkdir -p '${{ steps.vars.outputs.STAGING }}'
+        mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}'
+    - name: rust toolchain ~ install
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
+        target: ${{ matrix.job.target }}
+        override: true
+        profile: minimal # minimal component installation (ie, no documentation)
+    - name: Info
+      shell: bash
+      run: |
+        gcc --version || true
+        rustup -V
+        rustup toolchain list
+        rustup default
+        cargo -V
+        rustc -V
+    - name: Build
+      uses: actions-rs/cargo@v1
+      with:
+        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: Test
+      uses: actions-rs/cargo@v1
+      with:
+        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
+        command: test
+        args: --target=${{ matrix.job.target }} ${{ steps.vars.outputs.CARGO_TEST_OPTIONS}} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
+    - name: Archive executable artifacts
+      uses: actions/upload-artifact@master
+      with:
+        name: ${{ env.PROJECT_NAME }}-${{ matrix.job.target }}
+        path: target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}
+    - name: Package
+      shell: bash
+      run: |
+        # binary
+        cp 'target/${{ matrix.job.target }}/release/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'
+        # `strip` binary (if needed)
+        if [ -n "${{ steps.vars.outputs.STRIP }}" ]; then "${{ steps.vars.outputs.STRIP }}" '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/${{ env.PROJECT_NAME }}${{ steps.vars.outputs.EXE_suffix }}' ; fi
+        # README and LICENSE
+        cp README.md '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'
+        cp LICENSE '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}/'
+        # base compressed package
+        pushd '${{ steps.vars.outputs.STAGING }}/' >/dev/null
+        case ${{ matrix.job.target }} in
+          *-pc-windows-*) 7z -y a '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* | tail -2 ;;
+          *) tar czf '${{ steps.vars.outputs.PKG_NAME }}' '${{ steps.vars.outputs.PKG_BASENAME }}'/* ;;
+        esac;
+        popd >/dev/null
+    - name: Publish
+      uses: softprops/action-gh-release@v1
+      if: steps.vars.outputs.DEPLOY
+      with:
+        files: |
+          ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_NAME }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  ## fix! [rivy; 2020-22-01] `cargo tarpaulin` is unable to test this repo at the moment; alternate recipe or another testing framework?
  # coverage:
--- a/.gitignore
+++ b/.gitignore
@@ -6,7 +6,4 @@
 **/*.rs.bk
 *.swp
 .vscode/*
-*.idea/*
-
-#ignore macos files
-.DS_Store
+*.idea/*
--- 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 = "2.0.8"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9834fcc22e0874394a010230586367d4a3e9f11b560f469262678547e1d2575e"
+checksum = "a88b6bd5df287567ffdf4ddf4d33060048e1068308e5f62d81c6f9824a045a48"
 dependencies = [
 "bstr",
 "doc-comment",
@@ -47,34 +56,27 @@ 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 = "1.1.0"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b45ea9b00a7b3f2988e9a65ad3917e62123c38dba709b666506207be96d1790b"
+checksum = "90682c8d613ad3373e66de8c6411e0ae2ab2571e879d2efbf73558cc66f21279"
 dependencies = [
+ "lazy_static",
 "memchr",
- "once_cell",
 "regex-automata",
- "serde",
 ]

-[[package]]
-name = "cc"
-version = "1.0.78"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a20104e2335ce8a659d6dd92a51a767a0c062599c73b343fd152cb401e828c3d"
-
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -83,69 +85,25 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

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

-[[package]]
-name = "clap_complete"
-version = "3.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4179da71abd56c26b54dd0c248cc081c1f43b0a1a7e8448e28e57a29baa993d"
-dependencies = [
- "clap",
-]
-
-[[package]]
-name = "clap_lex"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
-dependencies = [
- "os_str_bytes",
-]
-
-[[package]]
-name = "clap_mangen"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "105180c05a72388d5f5e4e4f6c79eecb92497bda749fa8f963a16647c5d5377f"
-dependencies = [
- "clap",
- "roff",
-]
-
-[[package]]
-name = "config-file"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df51e72c150781d2c7d4cbcb0b803277caaa80476786994a62961a8f1010dafb"
-dependencies = [
- "serde",
- "thiserror",
- "toml",
-]
-
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
-
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.6"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
+checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
 dependencies = [
 "cfg-if",
 "crossbeam-utils",
@@ -153,9 +111,9 @@ dependencies = [

 [[package]]
 name = "crossbeam-deque"
-version = "0.8.2"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
+checksum = "94af6efb46fef72616855b036a624cf27ba656ffc9be1b9a3c931cfc7749a9a9"
 dependencies = [
 "cfg-if",
 "crossbeam-epoch",
@@ -164,53 +122,32 @@ dependencies = [

 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.10"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "045ebe27666471bb549370b4b0b3e51b07f56325befa4284db65fc89c02511b1"
+checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
 dependencies = [
- "autocfg",
 "cfg-if",
 "crossbeam-utils",
+ "lazy_static",
 "memoffset",
- "once_cell",
 "scopeguard",
 ]

 [[package]]
 name = "crossbeam-utils"
-version = "0.8.11"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51887d4adc7b564537b15adcfb307936f8075dfcd5f00dde9a9f1d29383682bc"
+checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
 dependencies = [
 "cfg-if",
- "once_cell",
+ "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"
-
-[[package]]
-name = "directories"
-version = "4.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f51c5d4ddabd36886dd3e1438cb358cdcb0d7c499cb99cb4ac2e38e18b5cb210"
-dependencies = [
- "dirs-sys",
-]
-
-[[package]]
-name = "dirs-sys"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
-dependencies = [
- "libc",
- "redox_users",
- "winapi",
-]
+checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"

 [[package]]
 name = "doc-comment"
@@ -220,22 +157,15 @@ checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"

 [[package]]
 name = "du-dust"
-version = "0.8.4"
+version = "0.6.0"
 dependencies = [
- "ansi_term",
+ "ansi_term 0.12.1",
 "assert_cmd",
- "atty",
 "clap",
- "clap_complete",
- "clap_mangen",
- "config-file",
- "directories",
 "lscolors",
+ "num_cpus",
 "rayon",
- "regex",
- "serde",
 "stfu8",
- "sysinfo",
 "tempfile",
 "terminal_size",
 "thousands",
@@ -245,104 +175,30 @@ dependencies = [

 [[package]]
 name = "either"
-version = "1.8.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
-
-[[package]]
-name = "errno"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
-dependencies = [
- "errno-dragonfly",
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
-dependencies = [
- "cc",
- "libc",
-]
-
-[[package]]
-name = "fastrand"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
-dependencies = [
- "instant",
-]
+checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"

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

-[[package]]
-name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
 [[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.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"
-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 = "io-lifetimes"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7d6c6f8c91b4b9ed43484ad1a938e393caf35960fce7f82a040497207bd8e9e"
-dependencies = [
- "libc",
- "windows-sys",
-]
-
-[[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"
@@ -351,138 +207,121 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.139"
+version = "0.2.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
+checksum = "12b8adadd720df158f4d70dfe7ccc6adb0472d7c55ca83445f6a5ab3e36f8fb6"

 [[package]]
 name = "lscolors"
-version = "0.13.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2dedc85d67baf5327114fad78ab9418f8893b1121c17d5538dd11005ad1ddf2"
+checksum = "d24b894c45c9da468621cdd615a5a79ee5e5523dd4f75c76ebc03d458940c16e"
 dependencies = [
- "ansi_term",
- "nu-ansi-term",
+ "ansi_term 0.12.1",
 ]

 [[package]]
 name = "memchr"
-version = "2.5.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+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 = "ntapi"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc51db7b362b205941f71232e56c625156eb9a929f8cf74a428fd5bc094a4afc"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "nu-ansi-term"
-version = "0.46.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
-dependencies = [
- "overload",
- "winapi",
-]
-
 [[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 = "once_cell"
-version = "1.17.0"
+name = "ppv-lite86"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"
-
-[[package]]
-name = "os_str_bytes"
-version = "6.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ff7415e9ae3fff1225851df9e0d9e4e5479f947619774677a63572e55e80eff"
-
-[[package]]
-name = "overload"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+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 = "proc-macro2"
-version = "1.0.43"
+name = "rand"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab"
+checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
 dependencies = [
- "unicode-ident",
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
 ]

 [[package]]
-name = "quote"
-version = "1.0.21"
+name = "rand_chacha"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
- "proc-macro2",
+ "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]]
 name = "rayon"
-version = "1.5.3"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd99e5772ead8baa5215278c9b15bf92087709e9c1b2d1f97cdb5a183c933a7d"
+checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
 dependencies = [
 "autocfg",
 "crossbeam-deque",
@@ -492,41 +331,31 @@ dependencies = [

 [[package]]
 name = "rayon-core"
-version = "1.9.3"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "258bcdb5ac6dad48491bb2992db6b7cf74878b0384908af124823d118c99683f"
+checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
 dependencies = [
 "crossbeam-channel",
 "crossbeam-deque",
 "crossbeam-utils",
+ "lazy_static",
 "num_cpus",
 ]

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

-[[package]]
-name = "redox_users"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
-dependencies = [
- "getrandom",
- "redox_syscall",
- "thiserror",
-]
-
 [[package]]
 name = "regex"
-version = "1.6.0"
+version = "1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c4eb3267174b8c6c2f654116623910a0fef09c4753f8dd83db29c48a0df988b"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
 dependencies = [
 "aho-corasick",
 "memchr",
@@ -541,9 +370,9 @@ checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"

 [[package]]
 name = "regex-syntax"
-version = "0.6.27"
+version = "0.6.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3f87b73ce11b1619a3c6332f45341e0047173771e8b8b73f87bfeefb7b56244"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"

 [[package]]
 name = "remove_dir_all"
@@ -554,57 +383,17 @@ dependencies = [
 "winapi",
 ]

-[[package]]
-name = "roff"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b833d8d034ea094b1ea68aa6d5c740e0d04bad9d16568d08ba6f76823a114316"
-
-[[package]]
-name = "rustix"
-version = "0.36.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4fdebc4b395b7fbb9ab11e462e20ed9051e7b16e42d24042c776eca0ac81b03"
-dependencies = [
- "bitflags",
- "errno",
- "io-lifetimes",
- "libc",
- "linux-raw-sys",
- "windows-sys",
-]
-
 [[package]]
 name = "scopeguard"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"

-[[package]]
-name = "serde"
-version = "1.0.143"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53e8e5d5b70924f74ff5c6d64d9a5acd91422117c60f48c4e07855238a254553"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.143"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3d8e8de557aee63c26b85b947f5e59b690d0454c753f3adeb5cd7835ab88391"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[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",
@@ -612,99 +401,52 @@ dependencies = [

 [[package]]
 name = "strsim"
-version = "0.10.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
-[[package]]
-name = "syn"
-version = "1.0.99"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "sysinfo"
-version = "0.27.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "975fe381e0ecba475d4acff52466906d95b153a40324956552e027b2a9eaa89e"
-dependencies = [
- "cfg-if",
- "core-foundation-sys",
- "libc",
- "ntapi",
- "once_cell",
- "rayon",
- "winapi",
-]
+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.3"
+name = "term_size"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+checksum = "1e4129646ca0ed8f45d09b929036bafad5377103edd06e50bf574b353d2b08d9"
 dependencies = [
- "winapi-util",
+ "libc",
+ "winapi",
 ]

 [[package]]
 name = "terminal_size"
-version = "0.2.3"
+version = "0.1.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb20089a8ba2b69debd491f8d2d023761cbf196e999218c591fa1e7e15a21907"
+checksum = "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df"
 dependencies = [
- "rustix",
- "windows-sys",
+ "libc",
+ "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.15.0"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
-
-[[package]]
-name = "thiserror"
-version = "1.0.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5f6586b7f764adc0231f4c79be7b920e766bb2f3e51b3661cdb263828f19994"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
 dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12bafc5b54507e0149cdf1b145a5d80ab80a90bcd9275df43d4fff68460f6c21"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "term_size",
+ "unicode-width",
 ]

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

 [[package]]
-name = "toml"
-version = "0.5.9"
+name = "treeline"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf"
+checksum = "a7f741b240f1a48843f9b8e0444fb55fb2a4ff67293b50a9179dfd5ea67f8d41"

 [[package]]
 name = "unicode-width"
-version = "0.1.9"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+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"
@@ -745,9 +484,9 @@ dependencies = [

 [[package]]
 name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+version = "0.10.2+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"

 [[package]]
 name = "winapi"
@@ -779,60 +518,3 @@ name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "windows-sys"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
-dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9864e83243fdec7fc9c5444389dcbbfd258f745e7853198f365e3c4968a608"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8b1b673ffc16c47a9ff48570a9d85e25d265735c503681332589af6253c6c7"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3887528ad530ba7bdbb1faa8275ec7a1155a45ffa57c37993960277145d640"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf4d1122317eddd6ff351aa852118a2418ad4214e6613a50e0191f7004372605"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1040f221285e17ebccbc2591ffdc2d44ee1f9186324dd3e84e99ac68d699c45"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "628bfdf232daa22b0d64fdb62b09fcc36bb01f05a3939e20ab73aaf9470d0463"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,10 +1,9 @@
 [package]
 name = "du-dust"
 description = "A more intuitive version of du"
-version = "0.8.4"
+version = "0.6.0"
 authors = ["bootandy <bootandy@gmail.com>", "nebkor <code@ardent.nebcorp.com>"]
-edition = "2021"
-readme = "README.md"
+edition = "2018"

 documentation = "https://github.com/bootandy/dust"
 homepage = "https://github.com/bootandy/dust"
@@ -21,64 +20,24 @@ travis-ci = { repository = "https://travis-ci.org/bootandy/dust" }
 name = "dust"
 path = "src/main.rs"

-[profile.release]
-codegen-units = 1
-lto = true
-strip = true
-
 [dependencies]
 ansi_term = "0.12"
-atty = "0.2.14"
-clap = "3.2.17"
-lscolors = "0.13"
-terminal_size = "0.2"
+clap = { version = "=2.33", features = ["wrap_help"] }
+lscolors = "0.7"
+num_cpus = "1"
+terminal_size = "0.1"
 unicode-width = "0.1"
-rayon = "1"
+rayon="1"
 thousands = "0.2"
 stfu8 = "0.2"
-regex = "1"
-config-file = "0.2"
-serde = { version = "1.0", features = ["derive"] }
-directories = "4"
-sysinfo = "0.27"

 [target.'cfg(windows)'.dependencies]
 winapi-util = "0.1"

 [dev-dependencies]
-assert_cmd = "2"
+assert_cmd = "1"
 tempfile = "=3"

-[build-dependencies]
-clap = "3.2.17"
-clap_complete = "3.2.4"
-clap_mangen = "0.1"
-
 [[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/2
+++ b/2
@@ -186,7 +186,7 @@
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

-   Copyright [2023] [andrew boot]
+   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+
 [![Build Status](https://travis-ci.org/bootandy/dust.svg?branch=master)](https://travis-ci.org/bootandy/dust)

 # Dust
@@ -9,41 +10,27 @@ du + rust = dust. Like du but more intuitive.
 Because I want an easy way to see where my disk is being used.

 # Demo
-
 ![Example](media/snap.png)

 ## Install

 #### Cargo <a href="https://repology.org/project/du-dust/versions"><img src="https://repology.org/badge/vertical-allrepos/du-dust.svg" alt="Packaging status" align="right"></a>

- `cargo install du-dust`
+* `cargo install du-dust`

 #### 🍺 Homebrew (Mac OS)

- `brew install dust`
+* `brew install dust`

 #### 🍺 Homebrew (Linux)

- `brew tap tgotwig/linux-dust && brew install dust`
-
-#### [Pacstall](https://github.com/pacstall/pacstall) (Debian/Ubuntu)
-
- `pacstall -I dust-bin`
-
-#### [deb-get](https://github.com/wimpysworld/deb-get) (Debian/Ubuntu)
-
- `deb-get install du-dust`
-
-#### 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)
+* `brew tap tgotwig/linux-dust && brew install dust`

 #### Download

- 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/`
+* 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

@@ -51,41 +38,29 @@ 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 -D (Show only directories (eg dust -D))
-Usage: dust -r (reverse order of output)
-Usage: dust -H (si print sizes in powers of 1000 instead of 1024)
-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 -z 10M (min-size, Only include files larger than 10M)
-Usage: dust -e regex (Only include files matching this regex (eg dust -e "\.png$" would match png files))
-Usage: dust -v regex (Exclude files matching this regex (eg dust -v "\.png$" would ignore 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)
 ```

+
 ## Alternatives

- [NCDU](https://dev.yorhel.nl/ncdu)
- [dutree](https://github.com/nachoparker/dutree)
- [dua](https://github.com/Byron/dua-cli/)
- [pdu](https://github.com/KSXGitHub/parallel-disk-usage)
- [dirstat-rs](https://github.com/scullionw/dirstat-rs)
- du -d 1 -h | sort -h
+* [NCDU](https://dev.yorhel.nl/ncdu)
+* [dutree](https://github.com/nachoparker/dutree)
+* [dua](https://github.com/Byron/dua-cli/)
+* [pdu](https://github.com/KSXGitHub/parallel-disk-usage)
+* [dirstat-rs](https://github.com/scullionw/dirstat-rs)
+* 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.
--- a/build.rs
+++ b/build.rs
@@ -1,27 +0,0 @@
-use clap_complete::{generate_to, shells::*};
-use clap_mangen::Man;
-use std::fs::File;
-use std::io::Error;
-use std::path::Path;
-
-include!("src/cli.rs");
-
-fn main() -> Result<(), Error> {
-    let outdir = "completions";
-    let app_name = "dust";
-    let mut cmd = build_cli();
-
-    generate_to(Bash, &mut cmd, app_name, outdir)?;
-    generate_to(Zsh, &mut cmd, app_name, outdir)?;
-    generate_to(Fish, &mut cmd, app_name, outdir)?;
-    generate_to(PowerShell, &mut cmd, app_name, outdir)?;
-    generate_to(Elvish, &mut cmd, app_name, outdir)?;
-
-    let file = Path::new("man-page").join("dust.1");
-    std::fs::create_dir_all("man-page")?;
-    let mut file = File::create(file)?;
-
-    Man::new(cmd).render(&mut file)?;
-
-    Ok(())
-}
--- a/ci/how2publish.txt
+++ b/ci/how2publish.txt
@@ -1,10 +1,6 @@
 # ----------- To do a release ---------
-# Compare times of runs to check no drastic slow down:
-#  time target/release/dust   ~/dev
-#  time dust ~dev
-
 # 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/completions/_dust
+++ b/completions/_dust
@@ -1,77 +0,0 @@
-#compdef dust
-
-autoload -U is-at-least
-
-_dust() {
-    typeset -A opt_args
-    typeset -a _arguments_options
-    local ret=1
-
-    if is-at-least 5.2; then
-        _arguments_options=(-s -S -C)
-    else
-        _arguments_options=(-s -C)
-    fi
-
-    local context curcontext="$curcontext" state line
-    _arguments "${_arguments_options[@]}" \
-'-d+[Depth to show]: : ' \
-'--depth=[Depth to show]: : ' \
-'-n+[Number of lines of output to show. (Default is terminal_height - 10)]: : ' \
-'--number-of-lines=[Number of lines of output to show. (Default is terminal_height - 10)]: : ' \
-'*-X+[Exclude any file or directory with this name]: : ' \
-'*--ignore-directory=[Exclude any file or directory with this name]: : ' \
-'-z+[Minimum size file to include in output]: : ' \
-'--min-size=[Minimum size file to include in output]: : ' \
-'(-e --filter -t --file_types)*-v+[Exclude filepaths matching this regex. To ignore png files type: -v "\\.png$" ]: : ' \
-'(-e --filter -t --file_types)*--invert-filter=[Exclude filepaths matching this regex. To ignore png files type: -v "\\.png$" ]: : ' \
-'(-t --file_types)*-e+[Only include filepaths matching this regex. For png files type: -e "\\.png$" ]: : ' \
-'(-t --file_types)*--filter=[Only include filepaths matching this regex. For png files type: -e "\\.png$" ]: : ' \
-'-w+[Specify width of output overriding the auto detection of terminal width]: : ' \
-'--terminal_width=[Specify width of output overriding the auto detection of terminal width]: : ' \
-'-h[Print help information]' \
-'--help[Print help information]' \
-'-V[Print version information]' \
-'--version[Print version information]' \
-'-p[Subdirectories will not have their path shortened]' \
-'--full-paths[Subdirectories will not have their path shortened]' \
-'-L[dereference sym links - Treat sym links as directories and go into them]' \
-'--dereference-links[dereference sym links - Treat sym links as directories and go into them]' \
-'-x[Only count the files and directories on the same filesystem as the supplied directory]' \
-'--limit-filesystem[Only count the files and directories on the same filesystem as the supplied directory]' \
-'-s[Use file length instead of blocks]' \
-'--apparent-size[Use file length instead of blocks]' \
-'-r[Print tree upside down (biggest highest)]' \
-'--reverse[Print tree upside down (biggest highest)]' \
-'-c[No colors will be printed (Useful for commands like: watch)]' \
-'--no-colors[No colors will be printed (Useful for commands like: watch)]' \
-'-b[No percent bars or percentages will be displayed]' \
-'--no-percent-bars[No percent bars or percentages will be displayed]' \
-'-R[For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)]' \
-'--screen-reader[For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)]' \
-'--skip-total[No total row will be displayed]' \
-'-f[Directory '\''size'\'' is number of child files/dirs not disk size]' \
-'--filecount[Directory '\''size'\'' is number of child files/dirs not disk size]' \
-'-i[Do not display hidden files]' \
-'--ignore_hidden[Do not display hidden files]' \
-'(-d --depth -D --only-dir)-t[show only these file types]' \
-'(-d --depth -D --only-dir)--file_types[show only these file types]' \
-'-H[print sizes in powers of 1000 (e.g., 1.1G)]' \
-'--si[print sizes in powers of 1000 (e.g., 1.1G)]' \
-'-P[Disable the progress indication.]' \
-'--no-progress[Disable the progress indication.]' \
-'(-F --only-file -t --file_types)-D[Only directories will be displayed.]' \
-'(-F --only-file -t --file_types)--only-dir[Only directories will be displayed.]' \
-'(-D --only-dir)-F[Only files will be displayed. (Finds your largest files)]' \
-'(-D --only-dir)--only-file[Only files will be displayed. (Finds your largest files)]' \
-'*::inputs:' \
-&& ret=0
-}
-
-(( $+functions[_dust_commands] )) ||
-_dust_commands() {
-    local commands; commands=()
-    _describe -t commands 'dust commands' commands "$@"
-}
-
-_dust "$@"
--- a/completions/_dust.ps1
+++ b/completions/_dust.ps1
@@ -1,79 +0,0 @@
-
-using namespace System.Management.Automation
-using namespace System.Management.Automation.Language
-
-Register-ArgumentCompleter -Native -CommandName 'dust' -ScriptBlock {
-    param($wordToComplete, $commandAst, $cursorPosition)
-
-    $commandElements = $commandAst.CommandElements
-    $command = @(
-        'dust'
-        for ($i = 1; $i -lt $commandElements.Count; $i++) {
-            $element = $commandElements[$i]
-            if ($element -isnot [StringConstantExpressionAst] -or
-                $element.StringConstantType -ne [StringConstantType]::BareWord -or
-                $element.Value.StartsWith('-') -or
-                $element.Value -eq $wordToComplete) {
-                break
-        }
-        $element.Value
-    }) -join ';'
-
-    $completions = @(switch ($command) {
-        'dust' {
-            [CompletionResult]::new('-d', 'd', [CompletionResultType]::ParameterName, 'Depth to show')
-            [CompletionResult]::new('--depth', 'depth', [CompletionResultType]::ParameterName, 'Depth to show')
-            [CompletionResult]::new('-n', 'n', [CompletionResultType]::ParameterName, 'Number of lines of output to show. (Default is terminal_height - 10)')
-            [CompletionResult]::new('--number-of-lines', 'number-of-lines', [CompletionResultType]::ParameterName, 'Number of lines of output to show. (Default is terminal_height - 10)')
-            [CompletionResult]::new('-X', 'X', [CompletionResultType]::ParameterName, 'Exclude any file or directory with this name')
-            [CompletionResult]::new('--ignore-directory', 'ignore-directory', [CompletionResultType]::ParameterName, 'Exclude any file or directory with this name')
-            [CompletionResult]::new('-z', 'z', [CompletionResultType]::ParameterName, 'Minimum size file to include in output')
-            [CompletionResult]::new('--min-size', 'min-size', [CompletionResultType]::ParameterName, 'Minimum size file to include in output')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'Exclude filepaths matching this regex. To ignore png files type: -v "\.png$" ')
-            [CompletionResult]::new('--invert-filter', 'invert-filter', [CompletionResultType]::ParameterName, 'Exclude filepaths matching this regex. To ignore png files type: -v "\.png$" ')
-            [CompletionResult]::new('-e', 'e', [CompletionResultType]::ParameterName, 'Only include filepaths matching this regex. For png files type: -e "\.png$" ')
-            [CompletionResult]::new('--filter', 'filter', [CompletionResultType]::ParameterName, 'Only include filepaths matching this regex. For png files type: -e "\.png$" ')
-            [CompletionResult]::new('-w', 'w', [CompletionResultType]::ParameterName, 'Specify width of output overriding the auto detection of terminal width')
-            [CompletionResult]::new('--terminal_width', 'terminal_width', [CompletionResultType]::ParameterName, 'Specify width of output overriding the auto detection of terminal width')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help information')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help information')
-            [CompletionResult]::new('-V', 'V', [CompletionResultType]::ParameterName, 'Print version information')
-            [CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Print version information')
-            [CompletionResult]::new('-p', 'p', [CompletionResultType]::ParameterName, 'Subdirectories will not have their path shortened')
-            [CompletionResult]::new('--full-paths', 'full-paths', [CompletionResultType]::ParameterName, 'Subdirectories will not have their path shortened')
-            [CompletionResult]::new('-L', 'L', [CompletionResultType]::ParameterName, 'dereference sym links - Treat sym links as directories and go into them')
-            [CompletionResult]::new('--dereference-links', 'dereference-links', [CompletionResultType]::ParameterName, 'dereference sym links - Treat sym links as directories and go into them')
-            [CompletionResult]::new('-x', 'x', [CompletionResultType]::ParameterName, 'Only count the files and directories on the same filesystem as the supplied directory')
-            [CompletionResult]::new('--limit-filesystem', 'limit-filesystem', [CompletionResultType]::ParameterName, 'Only count the files and directories on the same filesystem as the supplied directory')
-            [CompletionResult]::new('-s', 's', [CompletionResultType]::ParameterName, 'Use file length instead of blocks')
-            [CompletionResult]::new('--apparent-size', 'apparent-size', [CompletionResultType]::ParameterName, 'Use file length instead of blocks')
-            [CompletionResult]::new('-r', 'r', [CompletionResultType]::ParameterName, 'Print tree upside down (biggest highest)')
-            [CompletionResult]::new('--reverse', 'reverse', [CompletionResultType]::ParameterName, 'Print tree upside down (biggest highest)')
-            [CompletionResult]::new('-c', 'c', [CompletionResultType]::ParameterName, 'No colors will be printed (Useful for commands like: watch)')
-            [CompletionResult]::new('--no-colors', 'no-colors', [CompletionResultType]::ParameterName, 'No colors will be printed (Useful for commands like: watch)')
-            [CompletionResult]::new('-b', 'b', [CompletionResultType]::ParameterName, 'No percent bars or percentages will be displayed')
-            [CompletionResult]::new('--no-percent-bars', 'no-percent-bars', [CompletionResultType]::ParameterName, 'No percent bars or percentages will be displayed')
-            [CompletionResult]::new('-R', 'R', [CompletionResultType]::ParameterName, 'For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)')
-            [CompletionResult]::new('--screen-reader', 'screen-reader', [CompletionResultType]::ParameterName, 'For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)')
-            [CompletionResult]::new('--skip-total', 'skip-total', [CompletionResultType]::ParameterName, 'No total row will be displayed')
-            [CompletionResult]::new('-f', 'f', [CompletionResultType]::ParameterName, 'Directory ''size'' is number of child files/dirs not disk size')
-            [CompletionResult]::new('--filecount', 'filecount', [CompletionResultType]::ParameterName, 'Directory ''size'' is number of child files/dirs not disk size')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'Do not display hidden files')
-            [CompletionResult]::new('--ignore_hidden', 'ignore_hidden', [CompletionResultType]::ParameterName, 'Do not display hidden files')
-            [CompletionResult]::new('-t', 't', [CompletionResultType]::ParameterName, 'show only these file types')
-            [CompletionResult]::new('--file_types', 'file_types', [CompletionResultType]::ParameterName, 'show only these file types')
-            [CompletionResult]::new('-H', 'H', [CompletionResultType]::ParameterName, 'print sizes in powers of 1000 (e.g., 1.1G)')
-            [CompletionResult]::new('--si', 'si', [CompletionResultType]::ParameterName, 'print sizes in powers of 1000 (e.g., 1.1G)')
-            [CompletionResult]::new('-P', 'P', [CompletionResultType]::ParameterName, 'Disable the progress indication.')
-            [CompletionResult]::new('--no-progress', 'no-progress', [CompletionResultType]::ParameterName, 'Disable the progress indication.')
-            [CompletionResult]::new('-D', 'D', [CompletionResultType]::ParameterName, 'Only directories will be displayed.')
-            [CompletionResult]::new('--only-dir', 'only-dir', [CompletionResultType]::ParameterName, 'Only directories will be displayed.')
-            [CompletionResult]::new('-F', 'F', [CompletionResultType]::ParameterName, 'Only files will be displayed. (Finds your largest files)')
-            [CompletionResult]::new('--only-file', 'only-file', [CompletionResultType]::ParameterName, 'Only files will be displayed. (Finds your largest files)')
-            break
-        }
-    })
-
-    $completions.Where{ $_.CompletionText -like "$wordToComplete*" } |
-        Sort-Object -Property ListItemText
-}
--- a/completions/dust.bash
+++ b/completions/dust.bash
@@ -1,94 +0,0 @@
-_dust() {
-    local i cur prev opts cmds
-    COMPREPLY=()
-    cur="${COMP_WORDS[COMP_CWORD]}"
-    prev="${COMP_WORDS[COMP_CWORD-1]}"
-    cmd=""
-    opts=""
-
-    for i in ${COMP_WORDS[@]}
-    do
-        case "${i}" in
-            "$1")
-                cmd="dust"
-                ;;
-            *)
-                ;;
-        esac
-    done
-
-    case "${cmd}" in
-        dust)
-            opts="-h -V -d -n -p -X -L -x -s -r -c -b -z -R -f -i -v -e -t -w -H -P -D -F --help --version --depth --number-of-lines --full-paths --ignore-directory --dereference-links --limit-filesystem --apparent-size --reverse --no-colors --no-percent-bars --min-size --screen-reader --skip-total --filecount --ignore_hidden --invert-filter --filter --file_types --terminal_width --si --no-progress --only-dir --only-file <inputs>..."
-            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
-                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
-                return 0
-            fi
-            case "${prev}" in
-                --depth)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                -d)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --number-of-lines)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                -n)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --ignore-directory)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                -X)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --min-size)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                -z)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --invert-filter)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                -v)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --filter)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                -e)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                --terminal_width)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                -w)
-                    COMPREPLY=($(compgen -f "${cur}"))
-                    return 0
-                    ;;
-                *)
-                    COMPREPLY=()
-                    ;;
-            esac
-            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
-            return 0
-            ;;
-    esac
-}
-
-complete -F _dust -o bashdefault -o default dust
--- a/completions/dust.elv
+++ b/completions/dust.elv
@@ -1,73 +0,0 @@
-
-use builtin;
-use str;
-
-set edit:completion:arg-completer[dust] = {|@words|
-    fn spaces {|n|
-        builtin:repeat $n ' ' | str:join ''
-    }
-    fn cand {|text desc|
-        edit:complex-candidate $text &display=$text' '(spaces (- 14 (wcswidth $text)))$desc
-    }
-    var command = 'dust'
-    for word $words[1..-1] {
-        if (str:has-prefix $word '-') {
-            break
-        }
-        set command = $command';'$word
-    }
-    var completions = [
-        &'dust'= {
-            cand -d 'Depth to show'
-            cand --depth 'Depth to show'
-            cand -n 'Number of lines of output to show. (Default is terminal_height - 10)'
-            cand --number-of-lines 'Number of lines of output to show. (Default is terminal_height - 10)'
-            cand -X 'Exclude any file or directory with this name'
-            cand --ignore-directory 'Exclude any file or directory with this name'
-            cand -z 'Minimum size file to include in output'
-            cand --min-size 'Minimum size file to include in output'
-            cand -v 'Exclude filepaths matching this regex. To ignore png files type: -v "\.png$" '
-            cand --invert-filter 'Exclude filepaths matching this regex. To ignore png files type: -v "\.png$" '
-            cand -e 'Only include filepaths matching this regex. For png files type: -e "\.png$" '
-            cand --filter 'Only include filepaths matching this regex. For png files type: -e "\.png$" '
-            cand -w 'Specify width of output overriding the auto detection of terminal width'
-            cand --terminal_width 'Specify width of output overriding the auto detection of terminal width'
-            cand -h 'Print help information'
-            cand --help 'Print help information'
-            cand -V 'Print version information'
-            cand --version 'Print version information'
-            cand -p 'Subdirectories will not have their path shortened'
-            cand --full-paths 'Subdirectories will not have their path shortened'
-            cand -L 'dereference sym links - Treat sym links as directories and go into them'
-            cand --dereference-links 'dereference sym links - Treat sym links as directories and go into them'
-            cand -x 'Only count the files and directories on the same filesystem as the supplied directory'
-            cand --limit-filesystem 'Only count the files and directories on the same filesystem as the supplied directory'
-            cand -s 'Use file length instead of blocks'
-            cand --apparent-size 'Use file length instead of blocks'
-            cand -r 'Print tree upside down (biggest highest)'
-            cand --reverse 'Print tree upside down (biggest highest)'
-            cand -c 'No colors will be printed (Useful for commands like: watch)'
-            cand --no-colors 'No colors will be printed (Useful for commands like: watch)'
-            cand -b 'No percent bars or percentages will be displayed'
-            cand --no-percent-bars 'No percent bars or percentages will be displayed'
-            cand -R 'For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)'
-            cand --screen-reader 'For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)'
-            cand --skip-total 'No total row will be displayed'
-            cand -f 'Directory ''size'' is number of child files/dirs not disk size'
-            cand --filecount 'Directory ''size'' is number of child files/dirs not disk size'
-            cand -i 'Do not display hidden files'
-            cand --ignore_hidden 'Do not display hidden files'
-            cand -t 'show only these file types'
-            cand --file_types 'show only these file types'
-            cand -H 'print sizes in powers of 1000 (e.g., 1.1G)'
-            cand --si 'print sizes in powers of 1000 (e.g., 1.1G)'
-            cand -P 'Disable the progress indication.'
-            cand --no-progress 'Disable the progress indication.'
-            cand -D 'Only directories will be displayed.'
-            cand --only-dir 'Only directories will be displayed.'
-            cand -F 'Only files will be displayed. (Finds your largest files)'
-            cand --only-file 'Only files will be displayed. (Finds your largest files)'
-        }
-    ]
-    $completions[$command]
-}
--- a/completions/dust.fish
+++ b/completions/dust.fish
@@ -1,25 +0,0 @@
-complete -c dust -s d -l depth -d 'Depth to show' -r
-complete -c dust -s n -l number-of-lines -d 'Number of lines of output to show. (Default is terminal_height - 10)' -r
-complete -c dust -s X -l ignore-directory -d 'Exclude any file or directory with this name' -r
-complete -c dust -s z -l min-size -d 'Minimum size file to include in output' -r
-complete -c dust -s v -l invert-filter -d 'Exclude filepaths matching this regex. To ignore png files type: -v "\\.png$" ' -r
-complete -c dust -s e -l filter -d 'Only include filepaths matching this regex. For png files type: -e "\\.png$" ' -r
-complete -c dust -s w -l terminal_width -d 'Specify width of output overriding the auto detection of terminal width' -r
-complete -c dust -s h -l help -d 'Print help information'
-complete -c dust -s V -l version -d 'Print version information'
-complete -c dust -s p -l full-paths -d 'Subdirectories will not have their path shortened'
-complete -c dust -s L -l dereference-links -d 'dereference sym links - Treat sym links as directories and go into them'
-complete -c dust -s x -l limit-filesystem -d 'Only count the files and directories on the same filesystem as the supplied directory'
-complete -c dust -s s -l apparent-size -d 'Use file length instead of blocks'
-complete -c dust -s r -l reverse -d 'Print tree upside down (biggest highest)'
-complete -c dust -s c -l no-colors -d 'No colors will be printed (Useful for commands like: watch)'
-complete -c dust -s b -l no-percent-bars -d 'No percent bars or percentages will be displayed'
-complete -c dust -s R -l screen-reader -d 'For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)'
-complete -c dust -l skip-total -d 'No total row will be displayed'
-complete -c dust -s f -l filecount -d 'Directory \'size\' is number of child files/dirs not disk size'
-complete -c dust -s i -l ignore_hidden -d 'Do not display hidden files'
-complete -c dust -s t -l file_types -d 'show only these file types'
-complete -c dust -s H -l si -d 'print sizes in powers of 1000 (e.g., 1.1G)'
-complete -c dust -s P -l no-progress -d 'Disable the progress indication.'
-complete -c dust -s D -l only-dir -d 'Only directories will be displayed.'
-complete -c dust -s F -l only-file -d 'Only files will be displayed. (Finds your largest files)'
--- a/config/config.toml
+++ b/config/config.toml
@@ -1,13 +0,0 @@
-# Sample Config file, works with toml and yaml
-# Place in either:
-#   ~/.config/dust/config.toml
-#   ~/.dust.toml
-
-reverse=true
-display-full-paths=true
-display-apparent-size=true
-no-colors=true
-no-bars=true
-skip-total=true
-ignore-hidden=true
-iso=true
--- a/man-page/dust.1
+++ b/man-page/dust.1
@@ -1,90 +0,0 @@
-.ie \n(.g .ds Aq \(aq
-.el .ds Aq '
-.TH Dust 1  "Dust 0.8.4" 
-.SH NAME
-Dust \- Like du but more intuitive
-.SH SYNOPSIS
-\fBDust\fR [\fB\-h\fR|\fB\-\-help\fR] [\fB\-V\fR|\fB\-\-version\fR] [\fB\-d\fR|\fB\-\-depth\fR] [\fB\-n\fR|\fB\-\-number\-of\-lines\fR] [\fB\-p\fR|\fB\-\-full\-paths\fR] [\fB\-X\fR|\fB\-\-ignore\-directory\fR] [\fB\-L\fR|\fB\-\-dereference\-links\fR] [\fB\-x\fR|\fB\-\-limit\-filesystem\fR] [\fB\-s\fR|\fB\-\-apparent\-size\fR] [\fB\-r\fR|\fB\-\-reverse\fR] [\fB\-c\fR|\fB\-\-no\-colors\fR] [\fB\-b\fR|\fB\-\-no\-percent\-bars\fR] [\fB\-z\fR|\fB\-\-min\-size\fR] [\fB\-R\fR|\fB\-\-screen\-reader\fR] [\fB\-\-skip\-total\fR] [\fB\-f\fR|\fB\-\-filecount\fR] [\fB\-i\fR|\fB\-\-ignore_hidden\fR] [\fB\-v\fR|\fB\-\-invert\-filter\fR] [\fB\-e\fR|\fB\-\-filter\fR] [\fB\-t\fR|\fB\-\-file_types\fR] [\fB\-w\fR|\fB\-\-terminal_width\fR] [\fB\-H\fR|\fB\-\-si\fR] [\fB\-P\fR|\fB\-\-no\-progress\fR] [\fB\-D\fR|\fB\-\-only\-dir\fR] [\fB\-F\fR|\fB\-\-only\-file\fR] [\fIinputs\fR] 
-.SH DESCRIPTION
-Like du but more intuitive
-.SH OPTIONS
-.TP
-\fB\-h\fR, \fB\-\-help\fR
-Print help information
-.TP
-\fB\-V\fR, \fB\-\-version\fR
-Print version information
-.TP
-\fB\-d\fR, \fB\-\-depth\fR
-Depth to show
-.TP
-\fB\-n\fR, \fB\-\-number\-of\-lines\fR
-Number of lines of output to show. (Default is terminal_height \- 10)
-.TP
-\fB\-p\fR, \fB\-\-full\-paths\fR
-Subdirectories will not have their path shortened
-.TP
-\fB\-X\fR, \fB\-\-ignore\-directory\fR
-Exclude any file or directory with this name
-.TP
-\fB\-L\fR, \fB\-\-dereference\-links\fR
-dereference sym links \- Treat sym links as directories and go into them
-.TP
-\fB\-x\fR, \fB\-\-limit\-filesystem\fR
-Only count the files and directories on the same filesystem as the supplied directory
-.TP
-\fB\-s\fR, \fB\-\-apparent\-size\fR
-Use file length instead of blocks
-.TP
-\fB\-r\fR, \fB\-\-reverse\fR
-Print tree upside down (biggest highest)
-.TP
-\fB\-c\fR, \fB\-\-no\-colors\fR
-No colors will be printed (Useful for commands like: watch)
-.TP
-\fB\-b\fR, \fB\-\-no\-percent\-bars\fR
-No percent bars or percentages will be displayed
-.TP
-\fB\-z\fR, \fB\-\-min\-size\fR
-Minimum size file to include in output
-.TP
-\fB\-R\fR, \fB\-\-screen\-reader\fR
-For screen readers. Removes bars. Adds new column: depth level (May want to use \-p too for full path)
-.TP
-\fB\-\-skip\-total\fR
-No total row will be displayed
-.TP
-\fB\-f\fR, \fB\-\-filecount\fR
-Directory \*(Aqsize\*(Aq is number of child files/dirs not disk size
-.TP
-\fB\-i\fR, \fB\-\-ignore_hidden\fR
-Do not display hidden files
-.TP
-\fB\-v\fR, \fB\-\-invert\-filter\fR
-Exclude filepaths matching this regex. To ignore png files type: \-v "\\.png$" 
-.TP
-\fB\-e\fR, \fB\-\-filter\fR
-Only include filepaths matching this regex. For png files type: \-e "\\.png$" 
-.TP
-\fB\-t\fR, \fB\-\-file_types\fR
-show only these file types
-.TP
-\fB\-w\fR, \fB\-\-terminal_width\fR
-Specify width of output overriding the auto detection of terminal width
-.TP
-\fB\-H\fR, \fB\-\-si\fR
-print sizes in powers of 1000 (e.g., 1.1G)
-.TP
-\fB\-P\fR, \fB\-\-no\-progress\fR
-Disable the progress indication.
-.TP
-\fB\-D\fR, \fB\-\-only\-dir\fR
-Only directories will be displayed.
-.TP
-\fB\-F\fR, \fB\-\-only\-file\fR
-Only files will be displayed. (Finds your largest files)
-.TP
-[\fIinputs\fR]
-
-.SH VERSION
-v0.8.4
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -1,172 +0,0 @@
-use clap::{Arg, Command};
-
-// For single thread mode set this variable on your command line:
-// export RAYON_NUM_THREADS=1
-
-pub fn build_cli() -> Command<'static> {
-    Command::new("Dust")
-        .about("Like du but more intuitive")
-        .version(env!("CARGO_PKG_VERSION"))
-        .trailing_var_arg(true)
-        .arg(
-            Arg::new("depth")
-                .short('d')
-                .long("depth")
-                .help("Depth to show")
-                .takes_value(true)
-        )
-        .arg(
-            Arg::new("number_of_lines")
-                .short('n')
-                .long("number-of-lines")
-                .help("Number of lines of output to show. (Default is terminal_height - 10)")
-                .takes_value(true)
-        )
-        .arg(
-            Arg::new("display_full_paths")
-                .short('p')
-                .long("full-paths")
-                .help("Subdirectories will not have their path shortened"),
-        )
-        .arg(
-            Arg::new("ignore_directory")
-                .short('X')
-                .long("ignore-directory")
-                .takes_value(true)
-                .number_of_values(1)
-                .multiple_occurrences(true)
-                .help("Exclude any file or directory with this name"),
-        )
-         .arg(
-            Arg::new("dereference_links")
-                .short('L')
-                .long("dereference-links")
-                .help("dereference sym links - Treat sym links as directories and go into them"),
-        )
-        .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')
-                .long("apparent-size")
-                .help("Use file length instead of blocks"),
-        )
-        .arg(
-            Arg::new("reverse")
-                .short('r')
-                .long("reverse")
-                .help("Print tree upside down (biggest highest)"),
-        )
-        .arg(
-            Arg::new("no_colors")
-                .short('c')
-                .long("no-colors")
-                .help("No colors will be printed (Useful for commands like: watch)"),
-        )
-        .arg(
-            Arg::new("no_bars")
-                .short('b')
-                .long("no-percent-bars")
-                .help("No percent bars or percentages will be displayed"),
-        )
-        .arg(
-            Arg::new("min_size")
-                .short('z')
-                .long("min-size")
-                .takes_value(true)
-                .number_of_values(1)
-                .help("Minimum size file to include in output"),
-        )
-        .arg(
-            Arg::new("screen_reader")
-                .short('R')
-                .long("screen-reader")
-                .help("For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)"),
-        )
-        .arg(
-            Arg::new("skip_total")
-                .long("skip-total")
-                .help("No total row will be displayed"),
-        )
-        .arg(
-            Arg::new("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'
-                .long("ignore_hidden")
-                .help("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")
-                .conflicts_with("only_dir")
-                .help("show only these file types"),
-        )
-        .arg(
-            Arg::new("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("iso")
-                .short('H')
-                .long("si")
-                .help("print sizes in powers of 1000 (e.g., 1.1G)")
-        )
-        .arg(
-            Arg::new("disable_progress")
-                .short('P')
-                .long("no-progress")
-                .help("Disable the progress indication."),
-        )
-        .arg(
-            Arg::new("only_dir")
-                .short('D')
-                .long("only-dir")
-                .conflicts_with("only_file")
-                .conflicts_with("types")
-                .help("Only directories will be displayed."),
-        )
-        .arg(
-            Arg::new("only_file")
-                .short('F')
-                .long("only-file")
-                .conflicts_with("only_dir")
-                .help("Only files will be displayed. (Finds your largest files)"),
-        )
-        .arg(Arg::new("inputs").multiple_occurrences(true))
-}
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,167 +0,0 @@
-use clap::ArgMatches;
-use config_file::FromConfigFile;
-use serde::Deserialize;
-use std::path::Path;
-use std::path::PathBuf;
-
-use crate::display::UNITS;
-
-#[derive(Deserialize, Default)]
-#[serde(rename_all = "kebab-case")]
-#[serde(deny_unknown_fields)]
-pub struct Config {
-    pub display_full_paths: Option<bool>,
-    pub display_apparent_size: Option<bool>,
-    pub reverse: Option<bool>,
-    pub no_colors: Option<bool>,
-    pub no_bars: Option<bool>,
-    pub skip_total: Option<bool>,
-    pub screen_reader: Option<bool>,
-    pub ignore_hidden: Option<bool>,
-    pub iso: Option<bool>,
-    pub min_size: Option<String>,
-    pub only_dir: Option<bool>,
-    pub only_file: Option<bool>,
-    pub disable_progress: Option<bool>,
-}
-
-impl Config {
-    pub fn get_no_colors(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.no_colors || options.is_present("no_colors")
-    }
-    pub fn get_disable_progress(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.disable_progress || options.is_present("disable_progress")
-    }
-    pub fn get_apparent_size(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.display_apparent_size || options.is_present("display_apparent_size")
-    }
-    pub fn get_ignore_hidden(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.ignore_hidden || options.is_present("ignore_hidden")
-    }
-    pub fn get_full_paths(&self, options: &ArgMatches) -> bool {
-        // If we are only showing files, always show full paths
-        Some(true) == self.display_full_paths
-            || options.is_present("display_full_paths")
-            || self.get_only_file(options)
-    }
-    pub fn get_reverse(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.reverse || options.is_present("reverse")
-    }
-    pub fn get_no_bars(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.no_bars || options.is_present("no_bars")
-    }
-    pub fn get_iso(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.iso || options.is_present("iso")
-    }
-    pub fn get_skip_total(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.skip_total || options.is_present("skip_total")
-    }
-    pub fn get_screen_reader(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.screen_reader || options.is_present("screen_reader")
-    }
-    pub fn get_min_size(&self, options: &ArgMatches, iso: bool) -> Option<usize> {
-        let size_from_param = options.value_of("min_size");
-        self._get_min_size(size_from_param, iso)
-    }
-    fn _get_min_size(&self, min_size: Option<&str>, iso: bool) -> Option<usize> {
-        let size_from_param = min_size.and_then(|a| convert_min_size(a, iso));
-
-        if size_from_param.is_none() {
-            self.min_size
-                .as_ref()
-                .and_then(|a| convert_min_size(a.as_ref(), iso))
-        } else {
-            size_from_param
-        }
-    }
-    pub fn get_only_dir(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.only_dir || options.is_present("only_dir")
-    }
-    pub fn get_only_file(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.only_file || options.is_present("only_file")
-    }
-}
-
-fn convert_min_size(input: &str, iso: bool) -> Option<usize> {
-    let chars_as_vec: Vec<char> = input.chars().collect();
-    match chars_as_vec.split_last() {
-        Some((last, start)) => {
-            let mut starts: String = start.iter().collect::<String>();
-
-            for (i, u) in UNITS.iter().rev().enumerate() {
-                if Some(*u) == last.to_uppercase().next() {
-                    return match starts.parse::<usize>() {
-                        Ok(pure) => {
-                            let num: usize = if iso { 1000 } else { 1024 };
-                            let marker = pure * num.pow((i + 1) as u32);
-                            Some(marker)
-                        }
-                        Err(_) => {
-                            eprintln!("Ignoring invalid min-size: {input}");
-                            None
-                        }
-                    };
-                }
-            }
-            starts.push(*last);
-            starts
-                .parse()
-                .map_err(|_| {
-                    eprintln!("Ignoring invalid min-size: {input}");
-                })
-                .ok()
-        }
-        None => None,
-    }
-}
-
-fn get_config_locations(base: &Path) -> Vec<PathBuf> {
-    vec![
-        base.join(".dust.toml"),
-        base.join(".config").join("dust").join("config.toml"),
-    ]
-}
-
-pub fn get_config() -> Config {
-    if let Some(home) = directories::BaseDirs::new() {
-        for path in get_config_locations(home.home_dir()) {
-            if path.exists() {
-                if let Ok(config) = Config::from_config_file(path) {
-                    return config;
-                }
-            }
-        }
-    }
-    Config {
-        ..Default::default()
-    }
-}
-
-mod tests {
-    #[allow(unused_imports)]
-    use super::*;
-
-    #[test]
-    fn test_conversion() {
-        assert_eq!(convert_min_size("55", false), Some(55));
-        assert_eq!(convert_min_size("12344321", false), Some(12344321));
-        assert_eq!(convert_min_size("95RUBBISH", false), None);
-        assert_eq!(convert_min_size("10K", false), Some(10 * 1024));
-        assert_eq!(convert_min_size("10M", false), Some(10 * 1024usize.pow(2)));
-        assert_eq!(convert_min_size("10M", true), Some(10 * 1000usize.pow(2)));
-        assert_eq!(convert_min_size("2G", false), Some(2 * 1024usize.pow(3)));
-    }
-
-    #[test]
-    fn test_min_size_from_config_applied_or_overridden() {
-        let c = Config {
-            min_size: Some("1K".to_owned()),
-            ..Default::default()
-        };
-        assert_eq!(c._get_min_size(None, false), Some(1024));
-        assert_eq!(c._get_min_size(Some("2K"), false), Some(2048));
-
-        assert_eq!(c._get_min_size(None, true), Some(1000));
-        assert_eq!(c._get_min_size(Some("2K"), true), Some(2000));
-    }
-}
--- a/src/dir_walker.rs
+++ b/src/dir_walker.rs
@@ -1,229 +0,0 @@
-use std::fs;
-use std::sync::Arc;
-
-use crate::node::Node;
-use crate::progress::Operation;
-use crate::progress::PAtomicInfo;
-use crate::progress::ORDERING;
-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::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 follow_links: bool,
-    pub progress_data: Arc<PAtomicInfo>,
-}
-
-pub fn walk_it(dirs: HashSet<PathBuf>, walk_data: WalkData) -> Vec<Node> {
-    let mut inodes = HashSet::new();
-    let top_level_nodes: Vec<_> = dirs
-        .into_iter()
-        .filter_map(|d| {
-            let prog_data = &walk_data.progress_data;
-            prog_data.clear_state(&d);
-            let node = walk(d, &walk_data, 0)?;
-
-            prog_data.state.store(Operation::PREPARING, ORDERING);
-
-            clean_inodes(node, &mut inodes, walk_data.use_apparent_size)
-        })
-        .collect();
-    top_level_nodes
-}
-
-// Remove files which have the same inode, we don't want to double count them.
-fn clean_inodes(
-    x: Node,
-    inodes: &mut HashSet<(u64, u64)>,
-    use_apparent_size: bool,
-) -> Option<Node> {
-    if !use_apparent_size {
-        if let Some(id) = x.inode_device {
-            if !inodes.insert(id) {
-                return None;
-            }
-        }
-    }
-
-    // Sort Nodes so iteration order is predictable
-    let mut tmp: Vec<_> = x.children;
-    tmp.sort_by(sort_by_inode);
-    let new_children: Vec<_> = tmp
-        .into_iter()
-        .filter_map(|c| clean_inodes(c, inodes, use_apparent_size))
-        .collect();
-
-    Some(Node {
-        name: x.name,
-        size: x.size + new_children.iter().map(|c| c.size).sum::<u64>(),
-        children: new_children,
-        inode_device: x.inode_device,
-        depth: x.depth,
-    })
-}
-
-fn sort_by_inode(a: &Node, b: &Node) -> std::cmp::Ordering {
-    // Sorting by inode is quicker than by sorting by name/size
-    if let Some(x) = a.inode_device {
-        if let Some(y) = b.inode_device {
-            if x.0 != y.0 {
-                return x.0.cmp(&y.0);
-            } else if x.1 != y.1 {
-                return x.1.cmp(&y.1);
-            }
-        }
-    }
-    a.name.cmp(&b.name)
-}
-
-fn ignore_file(entry: &DirEntry, walk_data: &WalkData) -> 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
-}
-
-fn walk(dir: PathBuf, walk_data: &WalkData, depth: usize) -> Option<Node> {
-    let prog_data = &walk_data.progress_data;
-    let mut children = vec![];
-
-    if let Ok(entries) = fs::read_dir(&dir) {
-        children = entries
-            .into_iter()
-            .par_bridge()
-            .filter_map(|entry| {
-                if let Ok(ref entry) = entry {
-                    // uncommenting the below line gives simpler code but
-                    // rayon doesn't parallelize as well giving a 3X performance drop
-                    // hence we unravel the recursion a bit
-
-                    // return walk(entry.path(), walk_data, depth)
-
-                    if !ignore_file(entry, walk_data) {
-                        if let Ok(data) = entry.file_type() {
-                            if data.is_dir() || (walk_data.follow_links && data.is_symlink()) {
-                                return walk(entry.path(), walk_data, depth + 1);
-                            }
-
-                            let node = 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,
-                            );
-
-                            prog_data.num_files.fetch_add(1, ORDERING);
-                            if let Some(ref file) = node {
-                                prog_data.total_file_size.fetch_add(file.size, ORDERING);
-                            }
-
-                            return node;
-                        }
-                    }
-                } else {
-                    prog_data.no_permissions.store(true, ORDERING)
-                }
-                None
-            })
-            .collect();
-    } else if !dir.is_file() {
-        walk_data.progress_data.no_permissions.store(true, ORDERING)
-    }
-    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,
-    )
-}
-
-mod tests {
-    #[allow(unused_imports)]
-    use super::*;
-
-    #[cfg(test)]
-    fn create_node() -> Node {
-        Node {
-            name: PathBuf::new(),
-            size: 10,
-            children: vec![],
-            inode_device: Some((5, 6)),
-            depth: 0,
-        }
-    }
-
-    #[test]
-    #[allow(clippy::redundant_clone)]
-    fn test_should_ignore_file() {
-        let mut inodes = HashSet::new();
-        let n = create_node();
-
-        // First time we insert the node
-        assert_eq!(clean_inodes(n.clone(), &mut inodes, false), Some(n.clone()));
-
-        // Second time is a duplicate - we ignore it
-        assert_eq!(clean_inodes(n.clone(), &mut inodes, false), None);
-    }
-
-    #[test]
-    #[allow(clippy::redundant_clone)]
-    fn test_should_not_ignore_files_if_using_apparent_size() {
-        let mut inodes = HashSet::new();
-        let n = create_node();
-
-        // If using apparent size we include Nodes, even if duplicate inodes
-        assert_eq!(clean_inodes(n.clone(), &mut inodes, true), Some(n.clone()));
-        assert_eq!(clean_inodes(n.clone(), &mut inodes, true), Some(n.clone()));
-    }
-}
--- a/src/dirwalker.rs
+++ b/src/dirwalker.rs
@@ -0,0 +1,176 @@
+use std::fs;
+
+use crate::node::Node;
+use rayon::iter::ParallelBridge;
+use rayon::prelude::ParallelIterator;
+use std::path::PathBuf;
+
+use std::sync::atomic;
+use std::sync::atomic::AtomicBool;
+
+use std::collections::HashSet;
+
+use crate::node::build_node;
+use std::fs::DirEntry;
+
+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,
+                &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, use_apparent_size)
+                }
+                None => None,
+            }
+        })
+        .collect();
+    (top_level_nodes, permissions_flag.into_inner())
+}
+
+// Remove files which have the same inode, we don't want to double count them.
+fn clean_inodes(
+    x: Node,
+    inodes: &mut HashSet<(u64, u64)>,
+    use_apparent_size: bool,
+) -> Option<Node> {
+    if !use_apparent_size {
+        if let Some(id) = x.inode_device {
+            if inodes.contains(&id) {
+                return None;
+            }
+            inodes.insert(id);
+        }
+    }
+
+    let new_children: Vec<_> = x
+        .children
+        .into_iter()
+        .filter_map(|c| clean_inodes(c, inodes, use_apparent_size))
+        .collect();
+
+    return Some(Node {
+        name: x.name,
+        size: x.size + new_children.iter().map(|c| c.size).sum::<u64>(),
+        children: new_children,
+        inode_device: x.inode_device,
+    });
+}
+
+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 = ignore_directories.contains(&entry.path());
+    (is_dot_file && ignore_hidden) || is_ignored_path
+}
+
+fn walk(
+    dir: PathBuf,
+    permissions_flag: &AtomicBool,
+    ignore_directories: &HashSet<PathBuf>,
+    use_apparent_size: bool,
+    by_filecount: bool,
+    ignore_hidden: bool,
+) -> Option<Node> {
+    let mut children = vec![];
+
+    if let Ok(entries) = fs::read_dir(dir.clone()) {
+        children = entries
+            .into_iter()
+            .par_bridge()
+            .filter_map(|entry| {
+                if let Ok(ref entry) = entry {
+                    // uncommenting the below line gives simpler code but
+                    // 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, use_apparent_size, by_filecount, ignore_hidden);
+
+                    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,
+                                    ignore_directories,
+                                    use_apparent_size,
+                                    by_filecount,
+                                    ignore_hidden,
+                                );
+                            }
+                            return build_node(
+                                entry.path(),
+                                vec![],
+                                use_apparent_size,
+                                by_filecount,
+                            );
+                        }
+                    }
+                } else {
+                    permissions_flag.store(true, atomic::Ordering::Relaxed);
+                }
+                None
+            })
+            .collect();
+    } else {
+        permissions_flag.store(true, atomic::Ordering::Relaxed);
+    }
+    build_node(dir, children, use_apparent_size, by_filecount)
+}
+
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+
+    #[cfg(test)]
+    fn create_node() -> Node {
+        Node {
+            name: PathBuf::new(),
+            size: 10,
+            children: vec![],
+            inode_device: Some((5, 6)),
+        }
+    }
+
+    #[test]
+    fn test_should_ignore_file() {
+        let mut inodes = HashSet::new();
+        let n = create_node();
+
+        // First time we insert the node
+        assert!(clean_inodes(n.clone(), &mut inodes, false) == Some(n.clone()));
+
+        // Second time is a duplicate - we ignore it
+        assert!(clean_inodes(n.clone(), &mut inodes, false) == None);
+    }
+
+    #[test]
+    fn test_should_not_ignore_files_if_using_apparent_size() {
+        let mut inodes = HashSet::new();
+        let n = create_node();
+
+        // If using apparent size we include Nodes, even if duplicate inodes
+        assert!(clean_inodes(n.clone(), &mut inodes, true) == Some(n.clone()));
+        assert!(clean_inodes(n.clone(), &mut inodes, true) == Some(n.clone()));
+    }
+}
--- a/src/display.rs
+++ b/src/display.rs
@@ -1,6 +1,8 @@
+extern crate ansi_term;
+
 use crate::display_node::DisplayNode;

-use ansi_term::Colour::Red;
+use self::ansi_term::Colour::Red;
 use lscolors::{LsColors, Style};

 use unicode_width::UnicodeWidthStr;
@@ -14,7 +16,7 @@ use std::iter::repeat;
 use std::path::Path;
 use thousands::Separable;

-pub static UNITS: [char; 4] = ['T', 'G', 'M', 'K'];
+static UNITS: [char; 4] = ['T', 'G', 'M', 'K'];
 static BLOCKS: [char; 5] = ['█', '▓', '▒', '░', ' '];

 pub struct DisplayData {
@@ -22,12 +24,10 @@ pub struct DisplayData {
    pub is_reversed: bool,
    pub colors_on: bool,
    pub by_filecount: bool,
-    pub is_screen_reader: bool,
    pub num_chars_needed_on_left_most: usize,
    pub base_size: u64,
    pub longest_string_length: usize,
    pub ls_colors: LsColors,
-    pub iso: bool,
 }

 impl DisplayData {
@@ -84,15 +84,12 @@ impl DrawData<'_> {

    // TODO: can we test this?
    fn generate_bar(&self, node: &DisplayNode, level: usize) -> String {
-        if self.display_data.is_screen_reader {
-            return level.to_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 - level.clamp(1, 4);
+        let idx = 5 - min(4, max(1, level));

        for c in self.percent_bar.chars() {
            num_not_my_bar -= 1;
@@ -108,96 +105,61 @@ impl DrawData<'_> {
    }
 }

-// TODO: Push these into one object ?
 #[allow(clippy::too_many_arguments)]
 pub fn draw_it(
+    permission_error: bool,
    use_full_path: bool,
    is_reversed: bool,
    no_colors: bool,
-    no_percent_bars: bool,
+    no_percents: bool,
    terminal_width: usize,
    by_filecount: bool,
-    root_node: &DisplayNode,
-    iso: bool,
-    skip_total: bool,
-    is_screen_reader: bool,
+    option_root_node: Option<DisplayNode>,
 ) {
-    let biggest = match skip_total {
-        false => root_node,
-        true => root_node
-            .get_children_from_node(false)
-            .next()
-            .unwrap_or(root_node),
-    };
+    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 = biggest.size;
+        let max_size = root_node.children.iter().map(|n| n.size).fold(0, max);
        max_size.separate_with_commas().chars().count()
    } else {
-        find_biggest_size_str(root_node, iso)
+        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,
-        is_screen_reader,
-    );
+    let longest_string_length =
+        find_longest_dir_name(&root_node, num_indent_chars, terminal_width, !use_full_path);

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

-    let first_size_bar = repeat(BLOCKS[0]).take(max_bar_length).collect();
+    let first_size_bar = repeat(BLOCKS[0]).take(max_bar_length).collect::<String>();

    let display_data = DisplayData {
        short_paths: !use_full_path,
        is_reversed,
        colors_on: !no_colors,
        by_filecount,
-        is_screen_reader,
        num_chars_needed_on_left_most,
-        base_size: biggest.size,
+        base_size: root_node.size,
        longest_string_length,
        ls_colors: LsColors::from_env().unwrap_or_default(),
-        iso,
    };
    let draw_data = DrawData {
        indent: "".to_string(),
        percent_bar: first_size_bar,
        display_data: &display_data,
    };
-
-    if !skip_total {
-        display_node(root_node, &draw_data, true, true);
-    } else {
-        for (count, c) in root_node
-            .get_children_from_node(draw_data.display_data.is_reversed)
-            .enumerate()
-        {
-            let is_biggest = display_data.is_biggest(count, root_node.num_siblings());
-            let was_i_last = display_data.is_last(count, root_node.num_siblings());
-            display_node(c, &draw_data, is_biggest, was_i_last);
-        }
-    }
-}
-
-fn find_biggest_size_str(node: &DisplayNode, iso: bool) -> usize {
-    let mut mx = human_readable_number(node.size, iso).chars().count();
-    for n in node.children.iter() {
-        mx = max(mx, find_biggest_size_str(n, iso));
-    }
-    mx
+    display_node(root_node, &draw_data, true, true);
 }

 fn find_longest_dir_name(
@@ -205,40 +167,40 @@ fn find_longest_dir_name(
    indent: usize,
    terminal: usize,
    long_paths: bool,
-    is_screen_reader: bool,
 ) -> usize {
    let printable_name = get_printable_name(&node.name, long_paths);
-
-    let longest = if is_screen_reader {
-        UnicodeWidthStr::width(&*printable_name) + 1
-    } else {
-        min(
-            UnicodeWidthStr::width(&*printable_name) + 1 + indent,
-            terminal,
-        )
-    };
+    let longest = min(
+        UnicodeWidthStr::width(&*printable_name) + 1 + indent,
+        terminal,
+    );

    // each none root tree drawing is 2 more chars, hence we increment indent by 2
    node.children
        .iter()
-        .map(|c| find_longest_dir_name(c, indent + 2, terminal, long_paths, is_screen_reader))
+        .map(|c| find_longest_dir_name(c, indent + 2, terminal, long_paths))
        .fold(longest, max)
 }

-fn display_node(node: &DisplayNode, draw_data: &DrawData, is_biggest: bool, is_last: bool) {
+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 level = ((indent.chars().count() - 1) / 2) - 1;
-    let bar_text = draw_data.generate_bar(node, level);
+    let bar_text = draw_data.generate_bar(&node, level);

-    let to_print = format_string(node, &indent, &bar_text, is_biggest, draw_data.display_data);
+    let to_print = format_string(
+        &node,
+        &*indent,
+        &*bar_text,
+        is_biggest,
+        draw_data.display_data,
+    );

    if !draw_data.display_data.is_reversed {
-        println!("{to_print}")
+        println!("{}", to_print)
    }

    let dd = DrawData {
-        indent: clean_indentation_string(&indent),
+        indent: clean_indentation_string(&*indent),
        percent_bar: bar_text,
        display_data: draw_data.display_data,
    };
@@ -255,7 +217,7 @@ fn display_node(node: &DisplayNode, draw_data: &DrawData, is_biggest: bool, is_l
    }

    if draw_data.display_data.is_reversed {
-        println!("{to_print}")
+        println!("{}", to_print)
    }
 }

@@ -276,10 +238,10 @@ fn clean_indentation_string(s: &str) -> String {
    is
 }

-fn get_printable_name<P: AsRef<Path>>(dir_name: &P, short_paths: bool) -> String {
+fn get_printable_name<P: AsRef<Path>>(dir_name: &P, long_paths: bool) -> String {
    let dir_name = dir_name.as_ref();
    let printable_name = {
-        if short_paths {
+        if long_paths {
            match dir_name.parent() {
                Some(prefix) => match dir_name.strip_prefix(prefix) {
                    Ok(base) => base,
@@ -296,33 +258,26 @@ fn get_printable_name<P: AsRef<Path>>(dir_name: &P, short_paths: bool) -> String

 fn pad_or_trim_filename(node: &DisplayNode, indent: &str, display_data: &DisplayData) -> String {
    let name = get_printable_name(&node.name, display_data.short_paths);
-    let indent_and_name = format!("{indent} {name}");
+    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
@@ -332,20 +287,14 @@ fn maybe_trim_filename(name_in: String, indent: &str, display_data: &DisplayData
 pub fn format_string(
    node: &DisplayNode,
    indent: &str,
-    bars: &str,
+    percent_bar: &str,
    is_biggest: bool,
    display_data: &DisplayData,
 ) -> String {
-    let (percent, name_and_padding) = get_name_percent(node, indent, bars, display_data);
+    let (percents, name_and_padding) = get_name_percent(node, indent, percent_bar, display_data);
    let pretty_size = get_pretty_size(node, is_biggest, display_data);
    let pretty_name = get_pretty_name(node, name_and_padding, display_data);
-    // we can clean this and the method below somehow, not sure yet
-    if display_data.is_screen_reader {
-        // if screen_reader then bars is 'depth'
-        format!("{pretty_name} {bars} {pretty_size}{percent}")
-    } else {
-        format!("{pretty_size} {indent} {pretty_name}{percent}")
-    }
+    format!("{} {} {}{}", pretty_size, indent, pretty_name, percents)
 }

 fn get_name_percent(
@@ -354,34 +303,27 @@ fn get_name_percent(
    bar_chart: &str,
    display_data: &DisplayData,
 ) -> (String, String) {
-    if display_data.is_screen_reader {
-        let percent = display_data.percent_size(node) * 100.0;
-        let percent_size_str = format!("{percent:.0}%");
-        let percents = format!(" {percent_size_str:>4}",);
-        let name = pad_or_trim_filename(node, "", display_data);
-        (percents, name)
-    // Bar chart being empty may come from either config or the screen not being wide enough
-    } else if !bar_chart.is_empty() {
-        let percent = display_data.percent_size(node) * 100.0;
-        let percent_size_str = format!("{percent:.0}%");
-        let percents = format!("│{bar_chart} │ {percent_size_str:>4}");
+    if !bar_chart.is_empty() {
+        let percent_size_str = format!("{:.0}%", display_data.percent_size(node) * 100.0);
+        let percents = format!("│{} │ {:>4}", bar_chart, percent_size_str);
        let name_and_padding = pad_or_trim_filename(node, indent, display_data);
        (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)
    }
 }

 fn get_pretty_size(node: &DisplayNode, is_biggest: bool, display_data: &DisplayData) -> String {
    let output = if display_data.by_filecount {
-        node.size.separate_with_commas()
+        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(' ').take(spaces_to_add).collect::<String>()
    } else {
-        human_readable_number(node.size, display_data.iso)
+        format!("{:>5}", human_readable_number(node.size))
    };
-    let spaces_to_add = display_data.num_chars_needed_on_left_most - output.chars().count();
-    let output = " ".repeat(spaces_to_add) + output.as_str();

    if is_biggest && display_data.colors_on {
        format!("{}", Red.paint(output))
@@ -396,24 +338,22 @@ fn get_pretty_name(
    display_data: &DisplayData,
 ) -> String {
    if display_data.colors_on {
-        let meta_result = fs::metadata(&node.name);
+        let meta_result = fs::metadata(node.name.clone());
        let directory_color = display_data
            .ls_colors
-            .style_for_path_with_metadata(&node.name, meta_result.as_ref().ok());
+            .style_for_path_with_metadata(node.name.clone(), meta_result.as_ref().ok());
        let ansi_style = directory_color
            .map(Style::to_ansi_term_style)
            .unwrap_or_default();
-        let out = ansi_style.paint(name_and_padding);
-        format!("{out}")
+        format!("{}", ansi_style.paint(name_and_padding))
    } else {
        name_and_padding
    }
 }

-pub 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);
@@ -422,7 +362,7 @@ pub fn human_readable_number(size: u64, iso: bool) -> String {
            }
        }
    }
-    format!("{size}B")
+    return format!("{}B", size);
 }

 mod tests {
@@ -438,12 +378,10 @@ mod tests {
            is_reversed: false,
            colors_on: false,
            by_filecount: false,
-            is_screen_reader: false,
            num_chars_needed_on_left_most: 5,
-            base_size: 2_u64.pow(12), // 4.0K
+            base_size: 1,
            longest_string_length,
            ls_colors: LsColors::from_env().unwrap_or_default(),
-            iso: false,
        }
    }

@@ -457,9 +395,14 @@ mod tests {
        let indent = "┌─┴";
        let percent_bar = "";
        let is_biggest = false;
-        let data = get_fake_display_data(20);

-        let s = format_string(&n, indent, percent_bar, is_biggest, &data);
+        let s = format_string(
+            &n,
+            indent,
+            percent_bar,
+            is_biggest,
+            &get_fake_display_data(6),
+        );
        assert_eq!(s, " 4.0K ┌─┴ short");
    }

@@ -475,48 +418,25 @@ mod tests {
        let percent_bar = "";
        let is_biggest = false;

-        let data = get_fake_display_data(64);
-        let s = format_string(&n, indent, percent_bar, is_biggest, &data);
+        let dd = get_fake_display_data(64);
+        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_format_str_screen_reader() {
-        let n = DisplayNode {
-            name: PathBuf::from("/short"),
-            size: 2_u64.pow(12), // This is 4.0K
-            children: vec![],
-        };
-        let indent = "";
-        let percent_bar = "3";
-        let is_biggest = false;
-        let mut data = get_fake_display_data(20);
-        data.is_screen_reader = true;
-
-        let s = format_string(&n, indent, percent_bar, is_biggest, &data);
-        assert_eq!(s, "short               3  4.0K 100%");
-    }
-
    #[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
@@ -1,25 +1,46 @@
+use std::cmp::Ordering;
 use std::path::PathBuf;

-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+#[derive(Debug, Eq, Clone)]
 pub struct DisplayNode {
-    // Note: the order of fields in important here, for PartialEq and PartialOrd
+    pub name: PathBuf, //todo: consider moving to a string?
    pub size: u64,
-    pub name: PathBuf,
    pub children: Vec<DisplayNode>,
 }

+impl Ord for DisplayNode {
+    fn cmp(&self, other: &Self) -> Ordering {
+        if self.size == other.size {
+            self.name.cmp(&other.name)
+        } else {
+            self.size.cmp(&other.size)
+        }
+    }
+}
+
+impl PartialOrd for DisplayNode {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl PartialEq for DisplayNode {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name && self.size == other.size && self.children == other.children
+    }
+}
+
 impl DisplayNode {
    pub fn num_siblings(&self) -> u64 {
        self.children.len() as u64
    }

-    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.iter().rev())
+    pub fn get_children_from_node(&self, is_reversed: bool) -> impl Iterator<Item = DisplayNode> {
+        if is_reversed {
+            let children: Vec<DisplayNode> = self.children.clone().into_iter().rev().collect();
+            children.into_iter()
        } else {
-            Box::new(self.children.iter())
-        };
-        out
+            self.children.clone().into_iter()
+        }
    }
 }
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -1,143 +1,104 @@
 use crate::display_node::DisplayNode;
 use crate::node::Node;
 use std::collections::BinaryHeap;
-use std::collections::HashMap;
-use std::path::Path;
+use std::collections::HashSet;
 use std::path::PathBuf;

-pub struct AggregateData {
-    pub min_size: Option<usize>,
-    pub only_dir: bool,
-    pub only_file: bool,
-    pub number_of_lines: usize,
-    pub depth: usize,
-    pub using_a_filter: bool,
-}
-
-pub fn get_biggest(top_level_nodes: Vec<Node>, display_data: AggregateData) -> 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 mut heap = BinaryHeap::new();
-    let number_top_level_nodes = top_level_nodes.len();
-    let root;
-
-    if number_top_level_nodes > 1 {
-        let size = top_level_nodes.iter().map(|node| node.size).sum();
-        root = Node {
-            name: PathBuf::from("(total)"),
-            size,
-            children: top_level_nodes,
-            inode_device: None,
-            depth: 0,
-        };
-        // Always include the base nodes if we add a 'parent' (total) node
-        heap = always_add_children(&display_data, &root, heap);
-    } else {
-        root = top_level_nodes.into_iter().next().unwrap();
-        heap = add_children(&display_data, &root, heap);
-    }
-
-    fill_remaining_lines(heap, &root, display_data)
+    let root = get_new_root(top_level_nodes);
+    Some(build_by_depth(&root, n - 1))
 }

-pub fn fill_remaining_lines<'a>(
-    mut heap: BinaryHeap<&'a Node>,
-    root: &'a Node,
-    display_data: AggregateData,
-) -> Option<DisplayNode> {
-    let mut allowed_nodes = HashMap::new();
+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;
+    }

-    while allowed_nodes.len() < display_data.number_of_lines {
+    let mut heap = BinaryHeap::new();
+    let number_top_level_nodes = top_level_nodes.len();
+    let root = get_new_root(top_level_nodes);
+
+    root.children.iter().for_each(|c| heap.push(c));
+
+    let mut allowed_nodes = HashSet::new();
+    allowed_nodes.insert(&root.name);
+
+    for _ in number_top_level_nodes..n {
        let line = heap.pop();
        match line {
            Some(line) => {
-                if !display_data.only_file || line.children.is_empty() {
-                    allowed_nodes.insert(line.name.as_path(), line);
-                }
-                heap = add_children(&display_data, line, heap);
+                line.children.iter().for_each(|c| heap.push(c));
+                allowed_nodes.insert(&line.name);
            }
            None => break,
        }
    }
-
-    if display_data.only_file {
-        flat_rebuilder(allowed_nodes, root)
-    } else {
-        recursive_rebuilder(&allowed_nodes, root)
-    }
+    recursive_rebuilder(&allowed_nodes, &root)
 }

-fn add_children<'a>(
-    display_data: &AggregateData,
-    file_or_folder: &'a Node,
-    heap: BinaryHeap<&'a Node>,
-) -> BinaryHeap<&'a Node> {
-    if display_data.depth > file_or_folder.depth {
-        always_add_children(display_data, file_or_folder, heap)
-    } else {
-        heap
-    }
-}
+fn build_by_depth(node: &Node, depth: usize) -> DisplayNode {
+    let new_children = {
+        if depth == 0 {
+            vec![]
+        } else {
+            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
+        }
+    };

-fn always_add_children<'a>(
-    display_data: &AggregateData,
-    file_or_folder: &'a Node,
-    mut heap: BinaryHeap<&'a Node>,
-) -> BinaryHeap<&'a Node> {
-    heap.extend(
-        file_or_folder
-            .children
-            .iter()
-            .filter(|c| match display_data.min_size {
-                Some(ms) => c.size > ms as u64,
-                None => !display_data.using_a_filter || c.name.is_file() || c.size > 0,
-            })
-            .filter(|c| {
-                if display_data.only_dir {
-                    c.name.is_dir()
-                } else {
-                    true
-                }
-            }),
-    );
-    heap
-}
-
-// Finds children of current, if in allowed_nodes adds them as children to new DisplayNode
-fn recursive_rebuilder(
-    allowed_nodes: &HashMap<&Path, &Node>,
-    current: &Node,
-) -> Option<DisplayNode> {
-    let new_children: Vec<_> = current
-        .children
-        .iter()
-        .filter(|c| allowed_nodes.contains_key(c.name.as_path()))
-        .filter_map(|c| recursive_rebuilder(allowed_nodes, c))
-        .collect();
-
-    Some(build_node(new_children, current))
-}
-
-// Applies all allowed nodes as children to current node
-fn flat_rebuilder(allowed_nodes: HashMap<&Path, &Node>, current: &Node) -> Option<DisplayNode> {
-    let new_children: Vec<DisplayNode> = allowed_nodes
-        .into_values()
-        .map(|v| DisplayNode {
-            name: v.name.clone(),
-            size: v.size,
-            children: vec![],
-        })
-        .collect::<Vec<DisplayNode>>();
-    Some(build_node(new_children, current))
-}
-
-fn build_node(mut new_children: Vec<DisplayNode>, current: &Node) -> DisplayNode {
-    new_children.sort_by(|lhs, rhs| lhs.cmp(rhs).reverse());
    DisplayNode {
-        name: current.name.clone(),
-        size: current.size,
+        name: node.name.clone(),
+        size: node.size,
        children: new_children,
    }
 }
+
+fn get_new_root(top_level_nodes: Vec<Node>) -> Node {
+    if top_level_nodes.len() > 1 {
+        let total_size = top_level_nodes.iter().map(|node| node.size).sum();
+        Node {
+            name: PathBuf::from("(total)"),
+            size: total_size,
+            children: top_level_nodes,
+            inode_device: None,
+        }
+    } else {
+        top_level_nodes.into_iter().next().unwrap()
+    }
+}
+
+fn recursive_rebuilder<'a>(
+    allowed_nodes: &'a HashSet<&PathBuf>,
+    current: &Node,
+) -> Option<DisplayNode> {
+    let mut new_children: Vec<_> = current
+        .children
+        .iter()
+        .filter_map(|c| {
+            if allowed_nodes.contains(&c.name) {
+                recursive_rebuilder(allowed_nodes, c)
+            } else {
+                None
+            }
+        })
+        .collect();
+    new_children.sort();
+    new_children.reverse();
+    let newnode = DisplayNode {
+        name: current.name.clone(),
+        size: current.size,
+        children: new_children,
+    };
+    Some(newnode)
+}
--- a/src/filter_type.rs
+++ b/src/filter_type.rs
@@ -1,75 +0,0 @@
-use crate::display_node::DisplayNode;
-use crate::node::Node;
-use std::collections::HashMap;
-use std::ffi::OsStr;
-use std::path::PathBuf;
-
-#[derive(PartialEq, Eq, PartialOrd, Ord)]
-struct ExtensionNode<'a> {
-    size: u64,
-    extension: Option<&'a OsStr>,
-}
-
-pub fn get_all_file_types(top_level_nodes: &[Node], n: usize) -> Option<DisplayNode> {
-    let ext_nodes = {
-        let mut extension_cumulative_sizes = HashMap::new();
-        build_by_all_file_types(top_level_nodes, &mut extension_cumulative_sizes);
-
-        let mut extension_cumulative_sizes: Vec<ExtensionNode<'_>> = extension_cumulative_sizes
-            .iter()
-            .map(|(&extension, &size)| ExtensionNode { extension, size })
-            .collect();
-
-        extension_cumulative_sizes.sort_by(|lhs, rhs| lhs.cmp(rhs).reverse());
-
-        extension_cumulative_sizes
-    };
-
-    let mut ext_nodes_iter = ext_nodes.iter();
-
-    // First, collect the first N - 1 nodes...
-    let mut displayed: Vec<DisplayNode> = ext_nodes_iter
-        .by_ref()
-        .take(if n > 1 { n - 1 } else { 1 })
-        .map(|node| DisplayNode {
-            name: PathBuf::from(
-                node.extension
-                    .map(|ext| format!(".{}", ext.to_string_lossy()))
-                    .unwrap_or_else(|| "(no extension)".to_owned()),
-            ),
-            size: node.size,
-            children: vec![],
-        })
-        .collect();
-
-    // ...then, aggregate the remaining nodes (if any) into a single  "(others)" node
-    if ext_nodes_iter.len() > 0 {
-        displayed.push(DisplayNode {
-            name: PathBuf::from("(others)"),
-            size: ext_nodes_iter.map(|node| node.size).sum(),
-            children: vec![],
-        });
-    }
-
-    let result = DisplayNode {
-        name: PathBuf::from("(total)"),
-        size: displayed.iter().map(|node| node.size).sum(),
-        children: displayed,
-    };
-
-    Some(result)
-}
-
-fn build_by_all_file_types<'a>(
-    top_level_nodes: &'a [Node],
-    counter: &mut HashMap<Option<&'a OsStr>, u64>,
-) {
-    for node in top_level_nodes {
-        if node.name.is_file() {
-            let ext = node.name.extension();
-            let cumulative_size = counter.entry(ext).or_default();
-            *cumulative_size += node.size;
-        }
-        build_by_all_file_types(&node.children, counter)
-    }
-}
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,249 +1,227 @@
-mod cli;
-mod config;
-mod dir_walker;
-mod display;
-mod display_node;
-mod filter;
-mod filter_type;
-mod node;
-mod platform;
-mod progress;
-mod utils;
+#[macro_use]
+extern crate clap;
+extern crate rayon;
+extern crate unicode_width;

-use crate::cli::build_cli;
-use dir_walker::WalkData;
-use filter::AggregateData;
-use progress::PIndicator;
-use progress::ORDERING;
 use std::collections::HashSet;
-use std::io::BufRead;
-use std::process;
-use sysinfo::{System, SystemExt};

 use self::display::draw_it;
-use clap::Values;
-use config::get_config;
-use dir_walker::walk_it;
-use filter::get_biggest;
-use filter_type::get_all_file_types;
-use rayon::ThreadPoolBuildError;
-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 dirwalker;
+mod display;
+mod display_node;
+mod filter;
+mod node;
+mod platform;
+mod utils;
+
 static DEFAULT_NUMBER_OF_LINES: usize = 30;
 static DEFAULT_TERMINAL_WIDTH: usize = 80;

+#[cfg(windows)]
 fn init_color(no_color: bool) -> bool {
-    #[cfg(windows)]
-    {
-        // If no color is already set do not print a warning message
-        if no_color {
-            true
-        } else {
-            // Required for windows 10
-            // Fails to resolve for windows 8 so disable color
-            match ansi_term::enable_ansi_support() {
-                Ok(_) => no_color,
-                Err(_) => {
-                    eprintln!(
+    // If no color is already set do not print a warning message
+    if no_color {
+        true
+    } else {
+        // Required for windows 10
+        // Fails to resolve for windows 8 so disable color
+        match ansi_term::enable_ansi_support() {
+            Ok(_) => no_color,
+            Err(_) => {
+                eprintln!(
                    "This version of Windows does not support ANSI colors, setting no_color flag"
                );
-                    true
-                }
+                true
            }
        }
    }
-    #[cfg(not(windows))]
-    {
-        no_color
-    }
+}
+
+#[cfg(not(windows))]
+fn init_color(no_color: bool) -> bool {
+    no_color
 }

 fn get_height_of_terminal() -> usize {
-    // Simplify once https://github.com/eminence/terminal-size/pull/41 is
-    // merged
-    terminal_size()
-        // Windows CI runners detect a terminal height of 0
-        .map(|(_, Height(h))| max(h as usize, DEFAULT_NUMBER_OF_LINES))
-        .unwrap_or(DEFAULT_NUMBER_OF_LINES)
-        - 10
+    // Windows CI runners detect a terminal height of 0
+    if let Some((Width(_w), Height(h))) = terminal_size() {
+        max(h as usize, DEFAULT_NUMBER_OF_LINES) - 10
+    } else {
+        DEFAULT_NUMBER_OF_LINES - 10
+    }
 }

 fn get_width_of_terminal() -> usize {
-    // Simplify once https://github.com/eminence/terminal-size/pull/41 is
-    // merged
-    terminal_size()
-        .map(|(Width(w), _)| match cfg!(windows) {
-            // Windows CI runners detect a very low terminal width
-            true => max(w as usize, DEFAULT_TERMINAL_WIDTH),
-            false => w as usize,
-        })
-        .unwrap_or(DEFAULT_TERMINAL_WIDTH)
-}
-
-fn get_regex_value(maybe_value: Option<Values>) -> Vec<Regex> {
-    maybe_value
-        .unwrap_or_default()
-        .map(|reg| {
-            Regex::new(reg).unwrap_or_else(|err| {
-                eprintln!("Ignoring bad value for regex {err:?}");
-                process::exit(1)
-            })
-        })
-        .collect()
-}
-
-// Returns a list of lines from stdin or `None` if there's nothing to read
-fn get_lines_from_stdin() -> Option<Vec<String>> {
-    atty::isnt(atty::Stream::Stdin).then(|| {
-        std::io::stdin()
-            .lock()
-            .lines()
-            .collect::<Result<_, _>>()
-            .expect("Error reading from stdin")
-    })
+    // Windows CI runners detect a very low terminal width
+    if let Some((Width(w), Height(_h))) = terminal_size() {
+        max(w as usize, DEFAULT_TERMINAL_WIDTH)
+    } else {
+        DEFAULT_TERMINAL_WIDTH
+    }
 }

 fn main() {
-    let options = build_cli().get_matches();
-    let config = get_config();
-    let stdin_lines = get_lines_from_stdin();
+    let default_height = get_height_of_terminal();
+    let def_num_str = default_height.to_string();

-    let target_dirs = match options.values_of("inputs") {
-        Some(values) => values.collect(),
-        None => stdin_lines.as_ref().map_or(vec!["."], |lines| {
-            lines.iter().map(String::as_str).collect()
-        }),
-    };
+    let options = App::new("Dust")
+        .about("Like du but more intuitive")
+        .version(crate_version!())
+        .setting(AppSettings::TrailingVarArg)
+        .arg(
+            Arg::with_name("depth")
+                .short("d")
+                .long("depth")
+                .help("Depth to show")
+                .takes_value(true)
+                .conflicts_with("number_of_lines"),
+        )
+        .arg(
+            Arg::with_name("number_of_lines")
+                .short("n")
+                .long("number-of-lines")
+                .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::with_name("display_full_paths")
+                .short("p")
+                .long("full-paths")
+                .help("Subdirectories will not have their path shortened"),
+        )
+        .arg(
+            Arg::with_name("ignore_directory")
+                .short("X")
+                .long("ignore-directory")
+                .takes_value(true)
+                .number_of_values(1)
+                .multiple(true)
+                .help("Exclude any file or directory with this name"),
+        )
+        .arg(
+            Arg::with_name("display_apparent_size")
+                .short("s")
+                .long("apparent-size")
+                .help("Use file length instead of blocks"),
+        )
+        .arg(
+            Arg::with_name("reverse")
+                .short("r")
+                .long("reverse")
+                .help("Print tree upside down (biggest highest)"),
+        )
+        .arg(
+            Arg::with_name("no_colors")
+                .short("c")
+                .long("no-colors")
+                .help("No colors will be printed (normally largest directories are colored)"),
+        )
+        .arg(
+            Arg::with_name("no_bars")
+                .short("b")
+                .long("no-percent-bars")
+                .help("No percent bars or percentages will be displayed"),
+        )
+        .arg(
+            Arg::with_name("by_filecount")
+                .short("f")
+                .long("filecount")
+                .help("Directory 'size' is number of child files/dirs not disk size"),
+        )
+        .arg(
+            Arg::with_name("ignore_hidden")
+                .short("i") // Do not use 'h' this is used by 'help'
+                .long("ignore_hidden")
+                .help("Obey .git_ignore rules & Do not display hidden files"),
+        )
+        .arg(
+            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::with_name("inputs").multiple(true))
+        .get_matches();

-    let summarize_file_types = options.is_present("types");
-
-    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 = options
-        .value_of_t("width")
-        .unwrap_or_else(|_| get_width_of_terminal());
-
-    let depth = options.value_of_t("depth").unwrap_or(usize::MAX);
-
-    // If depth is set, then 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 = options
-        .value_of("number_of_lines")
-        .and_then(|v| {
-            v.parse()
-                .map_err(|_| eprintln!("Ignoring bad value for number_of_lines"))
-                .ok()
-        })
-        .unwrap_or(default_height);
-
-    let no_colors = init_color(config.get_no_colors(&options));
-
-    let ignore_directories = options
-        .values_of("ignore_directory")
-        .unwrap_or_default()
-        .map(PathBuf::from);
-
-    let by_filecount = options.is_present("by_filecount");
-    let limit_filesystem = options.is_present("limit_filesystem");
-    let follow_links = options.is_present("dereference_links");
-
-    let simplified_dirs = simplify_dir_names(target_dirs);
-    let allowed_filesystems = limit_filesystem
-        .then(|| get_filesystem_devices(simplified_dirs.iter()))
-        .unwrap_or_default();
-
-    let ignored_full_path: HashSet<PathBuf> = ignore_directories
-        .flat_map(|x| simplified_dirs.iter().map(move |d| d.join(&x)))
-        .collect();
-
-    let iso = config.get_iso(&options);
-
-    let ignore_hidden = config.get_ignore_hidden(&options);
-
-    let mut indicator = PIndicator::build_me();
-    if !config.get_disable_progress(&options) {
-        indicator.spawn(iso);
-    }
-
-    let walk_data = WalkData {
-        ignore_directories: ignored_full_path,
-        filter_regex: &filter_regexs,
-        invert_filter_regex: &invert_filter_regexs,
-        allowed_filesystems,
-        use_apparent_size: config.get_apparent_size(&options),
-        by_filecount,
-        ignore_hidden,
-        follow_links,
-        progress_data: indicator.data.clone(),
-    };
-
-    let _rayon = init_rayon();
-
-    let top_level_nodes = walk_it(simplified_dirs, walk_data);
-
-    let tree = match summarize_file_types {
-        true => get_all_file_types(&top_level_nodes, number_of_lines),
-        false => {
-            let agg_data = AggregateData {
-                min_size: config.get_min_size(&options, iso),
-                only_dir: config.get_only_dir(&options),
-                only_file: config.get_only_file(&options),
-                number_of_lines,
-                depth,
-                using_a_filter: options.values_of("filter").is_some()
-                    || options.value_of("invert_filter").is_some(),
-            };
-            get_biggest(top_level_nodes, agg_data)
+    let target_dirs = {
+        match options.values_of("inputs") {
+            None => vec!["."],
+            Some(r) => r.collect(),
        }
    };

-    let failed_permissions = indicator.data.no_permissions.load(ORDERING);
-    indicator.stop();
-    // Must have stopped indicator before we print to stderr
-    if failed_permissions {
-        eprintln!("Did not have permissions for all directories");
-    }
+    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
+        }
+    };

-    if let Some(root_node) = tree {
-        draw_it(
-            config.get_full_paths(&options),
-            !config.get_reverse(&options),
-            no_colors,
-            config.get_no_bars(&options),
-            terminal_width,
-            by_filecount,
-            &root_node,
-            iso,
-            config.get_skip_total(&options),
-            config.get_screen_reader(&options),
-        )
-    }
-}
-
-fn init_rayon() -> Result<(), ThreadPoolBuildError> {
-    let large_stack = usize::pow(1024, 3);
-    let mut s = System::new();
-    s.refresh_memory();
-    let available = s.available_memory();
-
-    if available > large_stack.try_into().unwrap() {
-        // Larger stack size to handle cases with lots of nested directories
-        rayon::ThreadPoolBuilder::new()
-            .stack_size(large_stack)
-            .build_global()
-    } else {
-        Ok(())
-    }
+    let terminal_width = match value_t!(options.value_of("width"), usize) {
+        Ok(v) => v,
+        Err(_) => get_width_of_terminal(),
+    };
+
+    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");
+    let ignore_directories: Vec<PathBuf> = options
+        .values_of("ignore_directory")
+        .map(|i| i.map(PathBuf::from).collect())
+        .unwrap_or_default();
+
+    let by_filecount = options.is_present("by_filecount");
+    let ignore_hidden = options.is_present("ignore_hidden");
+
+    let simplified_dirs = simplify_dir_names(target_dirs);
+
+    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 (nodes, errors) = walk_it(
+        simplified_dirs,
+        ignored_full_path,
+        use_apparent_size,
+        by_filecount,
+        ignore_hidden,
+    );
+
+    let tree = {
+        match depth {
+            None => get_biggest(nodes, number_of_lines),
+            Some(depth) => get_by_depth(nodes, depth),
+        }
+    };
+
+    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,48 +9,26 @@ 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> {
-    get_metadata(&dir, use_apparent_size).map(|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
-        };
-
-        Node {
-            name: dir,
-            size,
-            children,
-            inode_device,
-            depth,
+    match get_metadata(&dir, use_apparent_size) {
+        Some(data) => {
+            let (size, inode_device) = if by_filecount { (1, data.1) } else { data };
+            Some(Node {
+                name: dir,
+                size,
+                children,
+                inode_device,
+            })
        }
-    })
+        None => None,
+    }
 }

 impl PartialEq for Node {
@@ -64,10 +39,11 @@ impl PartialEq for Node {

 impl Ord for Node {
    fn cmp(&self, other: &Self) -> Ordering {
-        self.size
-            .cmp(&other.size)
-            .then_with(|| self.name.cmp(&other.name))
-            .then_with(|| self.children.cmp(&other.children))
+        if self.size == other.size {
+            self.name.cmp(&other.name)
+        } else {
+            self.size.cmp(&other.size)
+        }
    }
 }

--- a/src/platform.rs
+++ b/src/platform.rs
@@ -5,7 +5,7 @@ use std::path::Path;

 #[cfg(target_family = "unix")]
 fn get_block_size() -> u64 {
-    // All os specific implementations of MetadataExt seem to define a block as 512 bytes
+    // All os specific implementations of MetatdataExt seem to define a block as 512 bytes
    // https://doc.rust-lang.org/std/os/linux/fs/trait.MetadataExt.html#tymethod.st_blocks
    512
 }
@@ -105,24 +105,24 @@ pub fn get_metadata(d: &Path, _use_apparent_size: bool) -> Option<(u64, Option<(
    use std::os::windows::fs::MetadataExt;
    match d.metadata() {
        Ok(ref md) => {
-            const FILE_ATTRIBUTE_ARCHIVE: u32 = 0x20;
-            const FILE_ATTRIBUTE_READONLY: u32 = 0x01;
-            const FILE_ATTRIBUTE_HIDDEN: u32 = 0x02;
-            const FILE_ATTRIBUTE_SYSTEM: u32 = 0x04;
-            const FILE_ATTRIBUTE_NORMAL: u32 = 0x80;
-            const FILE_ATTRIBUTE_DIRECTORY: u32 = 0x10;
+            const FILE_ATTRIBUTE_ARCHIVE: u32 = 0x20u32;
+            const FILE_ATTRIBUTE_READONLY: u32 = 0x1u32;
+            const FILE_ATTRIBUTE_HIDDEN: u32 = 0x2u32;
+            const FILE_ATTRIBUTE_SYSTEM: u32 = 0x4u32;
+            const FILE_ATTRIBUTE_NORMAL: u32 = 0x80u32;
+            const FILE_ATTRIBUTE_DIRECTORY: u32 = 0x10u32;

            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/progress.rs
+++ b/src/progress.rs
@@ -1,145 +0,0 @@
-use std::{
-    io::Write,
-    path::Path,
-    sync::{
-        atomic::{AtomicBool, AtomicU64, AtomicU8, AtomicUsize, Ordering},
-        mpsc::{self, RecvTimeoutError, Sender},
-        Arc, RwLock,
-    },
-    thread::JoinHandle,
-    time::Duration,
-};
-
-use crate::display::human_readable_number;
-
-/* -------------------------------------------------------------------------- */
-
-pub const ORDERING: Ordering = Ordering::Relaxed;
-
-const SPINNER_SLEEP_TIME: u64 = 100;
-const PROGRESS_CHARS: [char; 4] = ['-', '\\', '|', '/'];
-const PROGRESS_CHARS_LEN: usize = PROGRESS_CHARS.len();
-
-pub trait ThreadSyncTrait<T> {
-    fn set(&self, val: T);
-    fn get(&self) -> T;
-}
-
-#[derive(Default)]
-pub struct ThreadStringWrapper {
-    inner: RwLock<String>,
-}
-
-impl ThreadSyncTrait<String> for ThreadStringWrapper {
-    fn set(&self, val: String) {
-        *self.inner.write().unwrap() = val;
-    }
-
-    fn get(&self) -> String {
-        (*self.inner.read().unwrap()).clone()
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-// creating an enum this way allows to have simpler syntax compared to a Mutex or a RwLock
-#[allow(non_snake_case)]
-pub mod Operation {
-    pub const INDEXING: u8 = 0;
-    pub const PREPARING: u8 = 1;
-}
-
-#[derive(Default)]
-pub struct PAtomicInfo {
-    pub num_files: AtomicUsize,
-    pub total_file_size: AtomicU64,
-    pub state: AtomicU8,
-    pub current_path: ThreadStringWrapper,
-    pub no_permissions: AtomicBool,
-}
-
-impl PAtomicInfo {
-    pub fn clear_state(&self, dir: &Path) {
-        self.state.store(Operation::INDEXING, ORDERING);
-        let dir_name = dir.to_string_lossy().to_string();
-        self.current_path.set(dir_name);
-        self.total_file_size.store(0, ORDERING);
-        self.num_files.store(0, ORDERING);
-    }
-}
-
-/* -------------------------------------------------------------------------- */
-
-fn format_preparing_str(prog_char: char, data: &PAtomicInfo, is_iso: bool) -> String {
-    let path_in = data.current_path.get();
-    let size = human_readable_number(data.total_file_size.load(ORDERING), is_iso);
-    format!("Preparing: {path_in} {size} ... {prog_char}")
-}
-
-fn format_indexing_str(prog_char: char, data: &PAtomicInfo, is_iso: bool) -> String {
-    let path_in = data.current_path.get();
-    let file_count = data.num_files.load(ORDERING);
-    let size = human_readable_number(data.total_file_size.load(ORDERING), is_iso);
-    let file_str = format!("{file_count} files, {size}");
-    format!("Indexing: {path_in} {file_str} ... {prog_char}")
-}
-
-pub struct PIndicator {
-    pub thread: Option<(Sender<()>, JoinHandle<()>)>,
-    pub data: Arc<PAtomicInfo>,
-}
-
-impl PIndicator {
-    pub fn build_me() -> Self {
-        Self {
-            thread: None,
-            data: Arc::new(PAtomicInfo {
-                ..Default::default()
-            }),
-        }
-    }
-
-    pub fn spawn(&mut self, is_iso: bool) {
-        let data = self.data.clone();
-        let (stop_handler, receiver) = mpsc::channel::<()>();
-
-        let time_info_thread = std::thread::spawn(move || {
-            let mut progress_char_i: usize = 0;
-            let mut stdout = std::io::stdout();
-            let mut msg = "".to_string();
-
-            // While the timeout triggers we go round the loop
-            // If we disconnect or the sender sends its message we exit the while loop
-            while let Err(RecvTimeoutError::Timeout) =
-                receiver.recv_timeout(Duration::from_millis(SPINNER_SLEEP_TIME))
-            {
-                // Clear the text written by 'write!'& Return at the start of line
-                print!("\r{:width$}", " ", width = msg.len());
-                let prog_char = PROGRESS_CHARS[progress_char_i];
-
-                msg = match data.state.load(ORDERING) {
-                    Operation::INDEXING => format_indexing_str(prog_char, &data, is_iso),
-                    Operation::PREPARING => format_preparing_str(prog_char, &data, is_iso),
-                    _ => panic!("Unknown State"),
-                };
-
-                write!(stdout, "\r{msg}").unwrap();
-                stdout.flush().unwrap();
-
-                progress_char_i += 1;
-                progress_char_i %= PROGRESS_CHARS_LEN;
-            }
-            print!("\r{:width$}", " ", width = msg.len());
-            print!("\r");
-            stdout.flush().unwrap();
-        });
-        self.thread = Some((stop_handler, time_info_thread))
-    }
-
-    pub fn stop(self) {
-        if let Some((stop_handler, thread)) = self.thread {
-            stop_handler.send(()).unwrap();
-            thread.join().unwrap();
-        }
-    }
-}
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,17 +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) {
@@ -20,9 +22,9 @@ 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);
        }
@@ -31,17 +33,6 @@ pub fn simplify_dir_names<P: AsRef<Path>>(filenames: Vec<P>) -> HashSet<PathBuf>
    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| match get_metadata(p, false) {
-            Some((_size, Some((_id, dev)))) => Some(dev),
-            _ => None,
-        })
-        .collect()
-}
-
 pub fn normalize_path<P: AsRef<Path>>(path: P) -> PathBuf {
    // normalize path ...
    // 1. removing repeated separators
@@ -49,29 +40,7 @@ pub fn normalize_path<P: AsRef<Path>>(path: P) -> PathBuf {
    // 3. removing trailing extra separators and '.' ("current directory") path segments
    // * `Path.components()` does all the above work; ref: <https://doc.rust-lang.org/std/path/struct.Path.html#method.components>
    // 4. changing to os preferred separator (automatically done by recollecting components back into a PathBuf)
-    path.as_ref().components().collect()
-}
-
-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)
+    path.as_ref().components().collect::<PathBuf>()
 }

 mod tests {
@@ -89,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
@@ -17,23 +18,26 @@ static INIT: Once = Once::new();
 /// Copy to /tmp dir - we assume that the formatting of the /tmp partition
 /// is consistent. If the tests fail your /tmp filesystem probably differs
 fn copy_test_data(dir: &str) {
-    // First remove the existing directory - just in case it is there and has incorrect data
+    // First remove the existing directory - just incase it is there and has incorrect data
    let last_slash = dir.rfind('/').unwrap();
    let last_part_of_dir = dir.chars().skip(last_slash).collect::<String>();
-    let _ = Command::new("rm")
+    match Command::new("rm")
        .arg("-rf")
        .arg("/tmp/".to_owned() + &*last_part_of_dir)
-        .ok();
-
-    let _ = Command::new("cp")
-        .arg("-r")
-        .arg(dir)
-        .arg("/tmp/")
        .ok()
-        .map_err(|err| eprintln!("Error copying directory for test setup\n{:?}", err));
+    {
+        Ok(_) => {}
+        Err(_) => {}
+    };
+    match Command::new("cp").arg("-r").arg(dir).arg("/tmp/").ok() {
+        Ok(_) => {}
+        Err(err) => {
+            eprintln!("Error copying directory {:?}", err);
+        }
+    };
 }

-fn initialize() {
+pub fn initialize() {
    INIT.call_once(|| {
        copy_test_data("tests/test_dir");
        copy_test_data("tests/test_dir2");
@@ -41,168 +45,226 @@ 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 = str::from_utf8(&a.unwrap().stdout).unwrap().to_owned();
-
-    assert!(valid_outputs.iter().any(|i| 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#"
-  0B     ┌── a_file    │░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
-4.0K     ├── hello_file│█████████████████████████████████████████████████ │ 100%
-4.0K   ┌─┴ many        │█████████████████████████████████████████████████ │ 100%
-4.0K ┌─┴ test_dir      │█████████████████████████████████████████████████ │ 100%
-"#
+#[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#"
-  0B     ┌── a_file    │                ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
-4.0K     ├── hello_file│                ░░░░░░░░░░░░░░░░█████████████████ │  33%
-8.0K   ┌─┴ many        │                █████████████████████████████████ │  67%
- 12K ┌─┴ test_dir      │█████████████████████████████████████████████████ │ 100%
+#[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#"
-  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%
+#[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#"
-  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%
+    .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()
 }

-// Check against directories and files whose 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);
-}
-
-fn no_substring_of_names_output() -> Vec<String> {
-    let ubuntu = "
-  0B   ┌── long_dir_name_what_a_very_long_dir_name_what_happens_when_this_goes..
-4.0K   ├── dir_name_clash
-4.0K   │ ┌── hello
-8.0K   ├─┴ dir
-4.0K   │ ┌── hello
-8.0K   ├─┴ dir_substring
- 24K ┌─┴ test_dir2
-    "
-    .trim()
-    .into();
-
-    let mac_and_some_linux = "
-  0B   ┌── long_dir_name_what_a_very_long_dir_name_what_happens_when_this_goes..
-4.0K   │ ┌── hello
-4.0K   ├─┴ dir
-4.0K   ├── dir_name_clash
-4.0K   │ ┌── hello
-4.0K   ├─┴ dir_substring
- 12K ┌─┴ test_dir2
-  "
-    .trim()
-    .into();
-    vec![mac_and_some_linux, ubuntu]
-}
-
-#[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);
-}
-
-fn unicode_dir() -> Vec<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();
-
-    let mac_and_some_linux = "
-0B   ┌── ラウトは難しいです！.japan│                                    █ │   0%
-0B   ├── 👩.unicode                │                                    █ │   0%
-0B ┌─┴ test_dir_unicode            │                                    █ │   0%
-    "
-    .trim()
-    .into();
-    vec![mac_and_some_linux, ubuntu]
+#[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() {
-    let command_args = vec!["-c", "-s", "-b", "/tmp/test_dir"];
-    exact_output_test(apparent_size_output(), command_args);
+    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()));
 }

-fn apparent_size_output() -> Vec<String> {
-    // The apparent directory sizes are too unpredictable and system dependent to try and match
-    let files = r#"
-  0B     ┌── a_file
-  6B     ├── hello_file
- "#
+#[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();
-
-    vec![files]
+    .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() {
+    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()));
+}
+
+#[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
+ 4.0K   │ ┌── hello
+ 8.0K   ├─┴ dir_substring
+  24K ┌─┴ test_dir2
+    "
+    .trim()
+    .into()
+}
+
+#[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
+ 4.0K   │ ┌── hello
+ 4.0K   ├─┴ dir_substring
+  12K ┌─┴ test_dir2
+  "
+    .trim()
+    .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() {
+    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()));
+}
+
+#[cfg(target_os = "linux")]
+fn unicode_dir() -> String {
+    // The way unicode & asian characters are rendered on the terminal should make this line up
+    "
+   0B   ┌── ラウトは難しいです！.japan│                                 █ │   0%
+   0B   ├── 👩.unicode                │                                 █ │   0%
+ 4.0K ┌─┴ test_dir_unicode            │██████████████████████████████████ │ 100%
+    "
+    .trim()
+    .into()
+}
+
+#[cfg(target_os = "macos")]
+fn unicode_dir() -> String {
+    "
+   0B   ┌── ラウトは難しいです！.japan│                                 █ │   0%
+   0B   ├── 👩.unicode                │                                 █ │   0%
+   0B ┌─┴ test_dir_unicode            │                                 █ │   0%
+    "
+    .trim()
+    .into()
+}
+
+#[cfg(target_os = "windows")]
+fn unicode_dir() -> String {
+    "".into()
 }
--- a/tests/test_flags.rs
+++ b/tests/test_flags.rs
@@ -1,29 +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 cmd = &mut Command::cargo_bin("dust").unwrap();
-    for p in command_args {
-        cmd = cmd.arg(p);
-    }
-    let finished = &cmd.unwrap();
-    let stderr = str::from_utf8(&finished.stderr).unwrap();
-    assert_eq!(stderr, "");
-
-    str::from_utf8(&finished.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 "));
@@ -37,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    "));
@@ -45,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"));
@@ -55,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"));
 }

@@ -63,35 +69,64 @@ 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 whose names are substrings of each other
+// 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"));
 }
-// Add test for multiple dirs - with -d 0 and maybe -d 1 check the

 #[test]
 pub fn test_with_bad_param() {
    let mut cmd = Command::cargo_bin("dust").unwrap();
-    let result = cmd.arg("bad_place").unwrap();
-    let stderr = str::from_utf8(&result.stderr).unwrap();
+    let stderr = cmd.arg("-").unwrap().stderr;
+    let stderr = str::from_utf8(&stderr).unwrap();
    assert!(stderr.contains("Did not have permissions for all directories"));
 }

 #[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"));
 }
@@ -99,124 +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]
-#[cfg(target_family = "unix")]
-pub fn test_show_files_only() {
-    let output = build_command(vec!["-c", "-F", "tests/test_dir"]);
-    assert!(output.contains("tests/test_dir/many/a_file"));
-    assert!(output.contains("tests/test_dir/many/hello_file"));
-    assert!(!output.contains("tests/test_dir/many "));
-}
-
-#[test]
-pub fn test_output_skip_total() {
-    let output = build_command(vec![
-        "--skip-total",
-        "tests/test_dir/many/hello_file",
-        "tests/test_dir/many/a_file",
-    ]);
-    assert!(output.contains("hello_file"));
-    assert!(!output.contains("(total)"));
-}
-
-#[test]
-pub fn test_output_screen_reader() {
-    let output = build_command(vec!["--screen-reader", "-c", "tests/test_dir/"]);
-    println!("{}", output);
-    assert!(output.contains("test_dir   0"));
-    assert!(output.contains("many       1"));
-    assert!(output.contains("hello_file 2"));
-    assert!(output.contains("a_file     2"));
-
-    // Verify no 'symbols' reported by screen reader
-    assert!(!output.contains("│"));
-
-    for block in ['█', '▓', '▒', '░'] {
-        assert!(!output.contains(block));
-    }
-}
-
-#[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
@@ -1,15 +1,41 @@
 use assert_cmd::Command;
+use std::cmp::max;
 use std::fs::File;
 use std::io::Write;
 use std::path::PathBuf;
 use std::str;

+use terminal_size::{terminal_size, Height, Width};
+use unicode_width::UnicodeWidthStr;
+
 use tempfile::Builder;
 use tempfile::TempDir;

 // File sizes differ on both platform and on the format of the disk.
 // Windows: `ln` is not usually an available command; creation of symbolic links requires special enhanced permissions

+fn get_width_of_terminal() -> u16 {
+    if let Some((Width(w), Height(_h))) = terminal_size() {
+        max(w, 80)
+    } else {
+        80
+    }
+}
+
+// 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() - 14) as usize;
+    if UnicodeWidthStr::width(&*name) > terminal_plus_buffer {
+        let trimmed_name = name
+            .chars()
+            .take(terminal_plus_buffer - 2)
+            .collect::<String>();
+        trimmed_name + ".."
+    } else {
+        name
+    }
+}
+
 fn build_temp_file(dir: &TempDir) -> PathBuf {
    let file_path = dir.path().join("notes.txt");
    let mut file = File::create(&file_path).unwrap();
@@ -17,18 +43,6 @@ fn build_temp_file(dir: &TempDir) -> PathBuf {
    file_path
 }

-fn link_it(link_path: PathBuf, file_path_s: &str, is_soft: bool) -> String {
-    let link_name_s = link_path.to_str().unwrap();
-    let mut c = Command::new("ln");
-    if is_soft {
-        c.arg("-s");
-    }
-    c.arg(file_path_s);
-    c.arg(link_name_s);
-    assert!(c.output().is_ok());
-    link_name_s.into()
-}
-
 #[cfg_attr(target_os = "windows", ignore)]
 #[test]
 pub fn test_soft_sym_link() {
@@ -38,18 +52,20 @@ pub fn test_soft_sym_link() {
    let file_path_s = file.to_str().unwrap();

    let link_name = dir.path().join("the_link");
-    let link_name_s = link_it(link_name, file_path_s, true);
+    let link_name_s = link_name.to_str().unwrap();
+    let c = Command::new("ln")
+        .arg("-s")
+        .arg(file_path_s)
+        .arg(link_name_s)
+        .output();
+    assert!(c.is_ok());

-    let c = format!(" ├── {}", link_name_s);
-    let b = format!(" ┌── {}", file_path_s);
+    let c = format!(" ├── {}", get_file_name(link_name_s.into()));
+    let b = format!(" ┌── {}", get_file_name(file_path_s.into()));
    let a = format!("─┴ {}", dir_s);

    let mut cmd = Command::cargo_bin("dust").unwrap();
-    // Mac test runners create long filenames in tmp directories
-    let output = cmd
-        .args(["-p", "-c", "-s", "-w", "999", dir_s])
-        .unwrap()
-        .stdout;
+    let output = cmd.arg("-p").arg("-c").arg("-s").arg(dir_s).unwrap().stdout;

    let output = str::from_utf8(&output).unwrap();

@@ -67,48 +83,25 @@ pub fn test_hard_sym_link() {
    let file_path_s = file.to_str().unwrap();

    let link_name = dir.path().join("the_link");
-    link_it(link_name, file_path_s, false);
+    let link_name_s = link_name.to_str().unwrap();
+    let c = Command::new("ln")
+        .arg(file_path_s)
+        .arg(link_name_s)
+        .output();
+    assert!(c.is_ok());

-    let file_output = format!(" ┌── {}", file_path_s);
+    let link_output = format!(" ┌── {}", get_file_name(link_name_s.into()));
+    let file_output = format!(" ┌── {}", get_file_name(file_path_s.into()));
    let dirs_output = format!("─┴ {}", dir_s);

    let mut cmd = Command::cargo_bin("dust").unwrap();
-    // Mac test runners create long filenames in tmp directories
-    let output = cmd.args(["-p", "-c", "-w", "999", dir_s]).unwrap().stdout;
+    let output = cmd.arg("-p").arg("-c").arg(dir_s).unwrap().stdout;

-    // The link should not appear in the output because multiple inodes are now ordered
-    // then filtered.
+    // Because this is a hard link the file and hard link look identical. Therefore
+    // we cannot guarantee which version will appear first.
    let output = str::from_utf8(&output).unwrap();
    assert!(output.contains(dirs_output.as_str()));
-    assert!(output.contains(file_output.as_str()));
-}
-
-#[cfg_attr(target_os = "windows", ignore)]
-#[test]
-pub fn test_hard_sym_link_no_dup_multi_arg() {
-    let dir = Builder::new().tempdir().unwrap();
-    let dir_link = Builder::new().tempdir().unwrap();
-    let file = build_temp_file(&dir);
-    let dir_s = dir.path().to_str().unwrap();
-    let dir_link_s = dir_link.path().to_str().unwrap();
-    let file_path_s = file.to_str().unwrap();
-
-    let link_name = dir_link.path().join("the_link");
-    let link_name_s = link_it(link_name, file_path_s, false);
-
-    let mut cmd = Command::cargo_bin("dust").unwrap();
-
-    // Mac test runners create long filenames in tmp directories
-    let output = cmd
-        .args(["-p", "-c", "-w", "999", "-b", dir_link_s, dir_s])
-        .unwrap()
-        .stdout;
-
-    // The link or the file should appear but not both
-    let output = str::from_utf8(&output).unwrap();
-    let has_file_only = output.contains(file_path_s) && !output.contains(&link_name_s);
-    let has_link_only = !output.contains(file_path_s) && output.contains(&link_name_s);
-    assert!(has_file_only || has_link_only);
+    assert!(output.contains(link_output.as_str()) || output.contains(file_output.as_str()));
 }

 #[cfg_attr(target_os = "windows", ignore)]
@@ -118,10 +111,17 @@ pub fn test_recursive_sym_link() {
    let dir_s = dir.path().to_str().unwrap();

    let link_name = dir.path().join("the_link");
-    let link_name_s = link_it(link_name, dir_s, true);
+    let link_name_s = link_name.to_str().unwrap();
+
+    let c = Command::new("ln")
+        .arg("-s")
+        .arg(dir_s)
+        .arg(link_name_s)
+        .output();
+    assert!(c.is_ok());

    let a = format!("─┬ {}", dir_s);
-    let b = format!(" └── {}", link_name_s);
+    let b = format!(" └── {}", get_file_name(link_name_s.into()));

    let mut cmd = Command::cargo_bin("dust").unwrap();
    let output = cmd
@@ -129,8 +129,6 @@ pub fn test_recursive_sym_link() {
        .arg("-c")
        .arg("-r")
        .arg("-s")
-        .arg("-w")
-        .arg("999")
        .arg(dir_s)
        .unwrap()
        .stdout;
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