Increment version

Wrap and ignore these panics.

I can't reproduce this problem but I'm curious to know if this fixes it

.github/workflows/CICD.yml

@@ -22,50 +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}
-    - 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 }} -- -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
@@ -75,161 +81,216 @@ jobs:
       matrix:
         job:
           # { os, target, cargo-options, features, use-cross, toolchain }
-          - { 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      }
+          - {
+              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 }
     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 ;;
-        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_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 }} 
-    - 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 }}
-    - 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 }}
+      - 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 }}
 
   ## fix! [rivy; 2020-22-01] `cargo tarpaulin` is unable to test this repo at the moment; alternate recipe or another testing framework?
   # coverage:

.gitignore

@@ -6,4 +6,7 @@
 **/*.rs.bk
 *.swp
 .vscode/*
-*.idea/*
+*.idea/*
+
+#ignore macos files
+.DS_Store

Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "du-dust"
 description = "A more intuitive version of du"
-version = "0.5.1"
+version = "0.8.5"
 authors = ["bootandy <bootandy@gmail.com>", "nebkor <code@ardent.nebcorp.com>"]
-edition = "2018"
+edition = "2021"
+readme = "README.md"
 
 documentation = "https://github.com/bootandy/dust"
 homepage = "https://github.com/bootandy/dust"
@@ -14,29 +15,70 @@ categories = ["command-line-utilities"]
 license = "Apache-2.0"
 
 [badges]
-travis-ci = {repository = "https://travis-ci.org/bootandy/dust"}
+travis-ci = { repository = "https://travis-ci.org/bootandy/dust" }
 
 [[bin]]
 name = "dust"
 path = "src/main.rs"
 
+[profile.release]
+codegen-units = 1
+lto = true
+strip = true
+
 [dependencies]
-ansi_term = "=0.12"
-clap = "=2.33"
-jwalk = "0.4.0"
-lscolors = "0.6.0"
-num_cpus = "1.12"
-terminal_size = "0.1.10"
-unicode-width = "0.1.7"
+ansi_term = "0.12"
+atty = "0.2.14"
+clap = "3.2.17"
+lscolors = "0.13"
+terminal_size = "0.2"
+unicode-width = "0.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_cli = "=0.6"
+assert_cmd = "2"
 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'.
+"""

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright [2023] [andrew boot]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -1,4 +1,3 @@
-
 [![Build Status](https://travis-ci.org/bootandy/dust.svg?branch=master)](https://travis-ci.org/bootandy/dust)
 
 # Dust
@@ -10,19 +9,41 @@ 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
+#### 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`
+
+#### 🍺 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)
 
 #### 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
 
@@ -30,27 +51,47 @@ 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 <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  <dir>  (only show directories on the same filesystem)
-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)
-```
+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 -F (Show only files - finds your largest files)
+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 -L (dereference-links - Treat sym links as directories and go into them)
+Usage: dust -P (Disable the progress indicator)
+Usage: dust -R (For screen readers. Removes bars/symbols. Adds new column: depth level. (May want to use -p for full path too))
+Usage: dust --skip-total (No total row will be displayed)
+Usage: dust -z 4000000 (Exclude files below size 4MB)
 
+```
 
 ## Alternatives
 
-* [NCDU](https://dev.yorhel.nl/ncdu)
-* [dutree](https://github.com/nachoparker/dutree)
-* 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.

build.rs

@@ -0,0 +1,27 @@
+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(())
+}

ci/how2publish.txt

@@ -1,6 +1,14 @@
 # ----------- To do a release ---------
-# tag a commit and push:
+# 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):
 #   git tag v0.4.5
 #   git push origin v0.4.5
 
-# cargo publish to put it in crates.io
+# cargo publish to put it in crates.io
+
+# To install locally [Do before pushing it]
+#cargo install --path .

completions/_dust

@@ -0,0 +1,77 @@
+#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 "$@"

completions/_dust.ps1

@@ -0,0 +1,79 @@
+
+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
+}

completions/dust.bash

@@ -0,0 +1,94 @@
+_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

completions/dust.elv

@@ -0,0 +1,73 @@
+
+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]
+}

completions/dust.fish

@@ -0,0 +1,25 @@
+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)'

config/config.toml

@@ -0,0 +1,28 @@
+# Sample Config file, works with toml and yaml
+# Place in either:
+#   ~/.config/dust/config.toml
+#   ~/.dust.toml
+
+# Print tree upside down (biggest highest)
+reverse=true
+
+# Subdirectories will not have their path shortened
+display-full-paths=true
+
+# Use file length instead of blocks
+display-apparent-size=true
+
+# No colors will be printed
+no-colors=true
+
+# No percent bars or percentages will be displayed
+no-bars=true
+
+# No total row will be displayed
+skip-total=true
+
+# Do not display hidden files
+ignore-hidden=true
+
+# print sizes in powers of 1000 (e.g., 1.1G)
+iso=true

man-page/dust.1

@@ -0,0 +1,90 @@
+.ie \n(.g .ds Aq \(aq
+.el .ds Aq '
+.TH Dust 1  "Dust 0.8.5" 
+.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.5

src/cli.rs

@@ -0,0 +1,172 @@
+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))
+}

src/config.rs

@@ -0,0 +1,215 @@
+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>,
+    pub depth: Option<usize>,
+}
+
+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_depth(&self, options: &ArgMatches) -> usize {
+        if let Some(v) = options.value_of("depth") {
+            if let Ok(v) = v.parse::<usize>() {
+                return v;
+            }
+        }
+
+        self.depth.unwrap_or(usize::MAX)
+    }
+    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()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+    use clap::{Arg, ArgMatches, Command};
+
+    #[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));
+    }
+
+    #[test]
+    fn test_get_depth() {
+        // No config and no flag.
+        let c = Config::default();
+        let args = get_args(vec![]);
+        assert_eq!(c.get_depth(&args), usize::MAX);
+
+        // Config is not defined and flag is defined.
+        let c = Config::default();
+        let args = get_args(vec!["dust", "--depth", "5"]);
+        assert_eq!(c.get_depth(&args), 5);
+
+        // Config is defined and flag is not defined.
+        let c = Config {
+            depth: Some(3),
+            ..Default::default()
+        };
+        let args = get_args(vec![]);
+        assert_eq!(c.get_depth(&args), 3);
+
+        // Both config and flag are defined.
+        let c = Config {
+            depth: Some(3),
+            ..Default::default()
+        };
+        let args = get_args(vec!["dust", "--depth", "5"]);
+        assert_eq!(c.get_depth(&args), 5);
+    }
+
+    fn get_args(args: Vec<&str>) -> ArgMatches {
+        Command::new("Dust")
+            .trailing_var_arg(true)
+            .arg(Arg::new("depth").long("depth").takes_value(true))
+            .get_matches_from(args)
+    }
+}

src/dir_walker.rs

@@ -0,0 +1,229 @@
+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()));
+    }
+}

src/display.rs

@@ -1,65 +1,55 @@
-extern crate ansi_term;
+use crate::display_node::DisplayNode;
 
-use crate::utils::Node;
-
-use self::ansi_term::Colour::Fixed;
+use ansi_term::Colour::Red;
 use lscolors::{LsColors, Style};
 
-use terminal_size::{terminal_size, Height, Width};
-
 use unicode_width::UnicodeWidthStr;
 
+use stfu8::encode_u8;
+
 use std::cmp::max;
 use std::cmp::min;
 use std::fs;
 use std::iter::repeat;
 use std::path::Path;
+use thousands::Separable;
 
-static UNITS: [char; 4] = ['T', 'G', 'M', 'K'];
+pub static UNITS: [char; 4] = ['T', 'G', 'M', 'K'];
 static BLOCKS: [char; 5] = ['█', '▓', '▒', '░', ' '];
-static DEFAULT_TERMINAL_WIDTH: u16 = 80;
 
-pub struct DisplayData {
+pub struct InitialDisplayData {
     pub short_paths: bool,
     pub is_reversed: bool,
     pub colors_on: bool,
+    pub by_filecount: bool,
+    pub is_screen_reader: bool,
+    pub iso: bool,
+}
+
+pub struct DisplayData {
+    pub initial: InitialDisplayData,
+    pub num_chars_needed_on_left_most: usize,
     pub base_size: u64,
     pub longest_string_length: usize,
     pub ls_colors: LsColors,
 }
 
 impl DisplayData {
-    #[allow(clippy::collapsible_if)]
     fn get_tree_chars(&self, was_i_last: bool, has_children: bool) -> &'static str {
-        if self.is_reversed {
-            if was_i_last {
-                if has_children {
-                    "┌─┴"
-                } else {
-                    "┌──"
-                }
-            } else if has_children {
-                "├─┴"
-            } else {
-                "├──"
-            }
-        } else {
-            if was_i_last {
-                if has_children {
-                    "└─┬"
-                } else {
-                    "└──"
-                }
-            } else if has_children {
-                "├─┬"
-            } else {
-                "├──"
-            }
+        match (self.initial.is_reversed, was_i_last, has_children) {
+            (true, true, true) => "┌─┴",
+            (true, true, false) => "┌──",
+            (true, false, true) => "├─┴",
+            (true, false, false) => "├──",
+            (false, true, true) => "└─┬",
+            (false, true, false) => "└──",
+            (false, false, true) => "├─┬",
+            (false, false, false) => "├──",
         }
     }
 
     fn is_biggest(&self, num_siblings: usize, max_siblings: u64) -> bool {
-        if self.is_reversed {
+        if self.initial.is_reversed {
             num_siblings == (max_siblings - 1) as usize
         } else {
             num_siblings == 0
@@ -67,14 +57,14 @@ impl DisplayData {
     }
 
     fn is_last(&self, num_siblings: usize, max_siblings: u64) -> bool {
-        if self.is_reversed {
+        if self.initial.is_reversed {
             num_siblings == 0
         } else {
             num_siblings == (max_siblings - 1) as usize
         }
     }
 
-    fn percent_size(&self, node: &Node) -> f32 {
+    fn percent_size(&self, node: &DisplayNode) -> f32 {
         let result = node.size as f32 / self.base_size as f32;
         if result.is_normal() {
             result
@@ -84,15 +74,6 @@ impl DisplayData {
     }
 }
 
-fn get_children_from_node(node: Node, is_reversed: bool) -> impl Iterator<Item = Node> {
-    if is_reversed {
-        let n: Vec<Node> = node.children.into_iter().rev().map(|a| a).collect();
-        n.into_iter()
-    } else {
-        node.children.into_iter()
-    }
-}
-
 struct DrawData<'a> {
     indent: String,
     percent_bar: String,
@@ -105,13 +86,17 @@ impl DrawData<'_> {
         self.indent.to_string() + chars
     }
 
-    fn generate_bar(&self, node: &Node, level: usize) -> String {
+    // TODO: can we test this?
+    fn generate_bar(&self, node: &DisplayNode, level: usize) -> String {
+        if self.display_data.initial.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 - min(5, max(1, level));
+        let idx = 5 - level.clamp(1, 4);
 
         for c in self.percent_bar.chars() {
             num_not_my_bar -= 1;
@@ -127,107 +112,136 @@ impl DrawData<'_> {
     }
 }
 
-fn get_width_of_terminal() -> u16 {
-    // Windows CI runners detect a very low terminal width
-    if let Some((Width(w), Height(_h))) = terminal_size() {
-        max(w, DEFAULT_TERMINAL_WIDTH)
-    } else {
-        DEFAULT_TERMINAL_WIDTH
-    }
-}
-
 pub fn draw_it(
-    permissions: bool,
-    use_full_path: bool,
-    is_reversed: bool,
-    no_colors: bool,
-    no_percents: bool,
-    root_node: Node,
+    idd: InitialDisplayData,
+    no_percent_bars: bool,
+    terminal_width: usize,
+    root_node: &DisplayNode,
+    skip_total: bool,
 ) {
-    if !permissions {
-        eprintln!("Did not have permissions for all directories");
-    }
-    let longest_string_length = root_node
-        .children
-        .iter()
-        .map(|c| find_longest_dir_name(&c, "   ", !use_full_path))
-        .fold(0, max);
-    let terminal_width = get_width_of_terminal() - 16;
-
-    let max_bar_length = if no_percents || longest_string_length >= terminal_width as usize {
-        0
-    } else {
-        terminal_width as usize - longest_string_length
+    let biggest = match skip_total {
+        false => root_node,
+        true => root_node
+            .get_children_from_node(false)
+            .next()
+            .unwrap_or(root_node),
     };
 
-    // handle usize error also add do not show fancy output option
-    let bar_text = repeat(BLOCKS[0]).take(max_bar_length).collect::<String>();
+    let num_chars_needed_on_left_most = if idd.by_filecount {
+        let max_size = biggest.size;
+        max_size.separate_with_commas().chars().count()
+    } else {
+        find_biggest_size_str(root_node, idd.iso)
+    };
 
-    for c in get_children_from_node(root_node, is_reversed) {
-        let display_data = DisplayData {
-            short_paths: !use_full_path,
-            is_reversed,
-            colors_on: !no_colors,
-            base_size: c.size,
-            longest_string_length,
-            ls_colors: LsColors::from_env().unwrap_or_default(),
-        };
-        let draw_data = DrawData {
-            indent: "".to_string(),
-            percent_bar: bar_text.clone(),
-            display_data: &display_data,
-        };
-        display_node(c, &draw_data, true, true);
+    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 num_indent_chars = 3;
+    let longest_string_length =
+        find_longest_dir_name(root_node, num_indent_chars, allowed_width, &idd);
+
+    let max_bar_length = if no_percent_bars || longest_string_length + 7 >= allowed_width {
+        0
+    } else {
+        allowed_width - longest_string_length - 7
+    };
+
+    let first_size_bar = repeat(BLOCKS[0]).take(max_bar_length).collect();
+
+    let display_data = DisplayData {
+        initial: idd,
+        num_chars_needed_on_left_most,
+        base_size: biggest.size,
+        longest_string_length,
+        ls_colors: LsColors::from_env().unwrap_or_default(),
+    };
+    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.initial.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);
+        }
     }
 }
 
-// We can probably pass depth instead of indent here.
-// It is ugly to feed in '  ' instead of the actual tree characters but we don't need them yet.
-fn find_longest_dir_name(node: &Node, indent: &str, long_paths: bool) -> usize {
-    let printable_name = get_printable_name(&node.name, long_paths);
-    let longest = get_unicode_width_of_indent_and_name(indent, &printable_name);
+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
+}
 
-    // each none root tree drawing is 2 chars
-    let full_indent: String = indent.to_string() + "  ";
+fn find_longest_dir_name(
+    node: &DisplayNode,
+    indent: usize,
+    terminal: usize,
+    idd: &InitialDisplayData,
+) -> usize {
+    let printable_name = get_printable_name(&node.name, idd.short_paths);
+
+    let longest = if idd.is_screen_reader {
+        UnicodeWidthStr::width(&*printable_name) + 1
+    } else {
+        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, &*full_indent, long_paths))
+        .map(|c| find_longest_dir_name(c, indent + 2, terminal, idd))
         .fold(longest, max)
 }
 
-fn display_node(node: Node, draw_data: &DrawData, is_biggest: bool, is_last: bool) {
-    let indent2 = draw_data.get_new_indent(!node.children.is_empty(), is_last);
+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 level = ((indent2.chars().count() - 1) / 2) - 1;
-    let bar_text = draw_data.generate_bar(&node, level);
+    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 to_print = format_string(
-        &node,
-        &*indent2,
-        &*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)
+    if !draw_data.display_data.initial.is_reversed {
+        println!("{to_print}")
     }
 
     let dd = DrawData {
-        indent: clean_indentation_string(&*indent2),
+        indent: clean_indentation_string(&indent),
         percent_bar: bar_text,
         display_data: draw_data.display_data,
     };
-    let num_siblings = node.children.len() as u64;
 
-    for (count, c) in get_children_from_node(node, draw_data.display_data.is_reversed).enumerate() {
+    let num_siblings = node.num_siblings();
+
+    for (count, c) in node
+        .get_children_from_node(draw_data.display_data.initial.is_reversed)
+        .enumerate()
+    {
         let is_biggest = dd.display_data.is_biggest(count, num_siblings);
         let was_i_last = dd.display_data.is_last(count, num_siblings);
         display_node(c, &dd, is_biggest, was_i_last);
     }
 
-    if draw_data.display_data.is_reversed {
-        println!("{}", to_print)
+    if draw_data.display_data.initial.is_reversed {
+        println!("{to_print}")
     }
 }
 
@@ -248,10 +262,10 @@ fn clean_indentation_string(s: &str) -> String {
     is
 }
 
-fn get_printable_name<P: AsRef<Path>>(dir_name: &P, long_paths: bool) -> String {
+fn get_printable_name<P: AsRef<Path>>(dir_name: &P, short_paths: bool) -> String {
     let dir_name = dir_name.as_ref();
     let printable_name = {
-        if long_paths {
+        if short_paths {
             match dir_name.parent() {
                 Some(prefix) => match dir_name.strip_prefix(prefix) {
                     Ok(base) => base,
@@ -263,64 +277,129 @@ fn get_printable_name<P: AsRef<Path>>(dir_name: &P, long_paths: bool) -> String
             dir_name
         }
     };
-    printable_name.display().to_string()
+    encode_u8(printable_name.display().to_string().as_bytes())
 }
 
-fn get_unicode_width_of_indent_and_name(indent: &str, name: &str) -> usize {
-    let indent_and_name = format!("{} {}", indent, name);
-    UnicodeWidthStr::width(&*indent_and_name)
+fn pad_or_trim_filename(node: &DisplayNode, indent: &str, display_data: &DisplayData) -> String {
+    let name = get_printable_name(&node.name, display_data.initial.short_paths);
+    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"
+    );
+
+    // 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();
+
+    name_and_padding
+}
+
+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>();
+        name + ".."
+    } else {
+        name_in
+    }
 }
 
 pub fn format_string(
-    node: &Node,
+    node: &DisplayNode,
     indent: &str,
-    percent_bar: &str,
+    bars: &str,
     is_biggest: bool,
     display_data: &DisplayData,
 ) -> String {
-    let pretty_size = format!("{:>5}", human_readable_number(node.size));
-
-    let percent_size_str = format!("{:.0}%", display_data.percent_size(node) * 100.0);
-
-    let name = get_printable_name(&node.name, display_data.short_paths);
-    let width = get_unicode_width_of_indent_and_name(indent, &name);
-
-    let name_and_padding = name
-        + &(repeat(" ")
-            .take(display_data.longest_string_length - width)
-            .collect::<String>());
-
-    let percents = if percent_bar != "" {
-        format!("│{} │ {:>4}", percent_bar, percent_size_str)
+    let (percent, name_and_padding) = get_name_percent(node, indent, bars, 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.initial.is_screen_reader {
+        // if screen_reader then bars is 'depth'
+        format!("{pretty_name} {bars} {pretty_size}{percent}")
     } else {
-        "".into()
-    };
+        format!("{pretty_size} {indent} {pretty_name}{percent}")
+    }
+}
 
-    let pretty_size = if is_biggest && display_data.colors_on {
-        format!("{}", Fixed(196).paint(pretty_size))
+fn get_name_percent(
+    node: &DisplayNode,
+    indent: &str,
+    bar_chart: &str,
+    display_data: &DisplayData,
+) -> (String, String) {
+    if display_data.initial.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}");
+        let name_and_padding = pad_or_trim_filename(node, indent, display_data);
+        (percents, name_and_padding)
     } else {
-        pretty_size
-    };
+        let n = get_printable_name(&node.name, display_data.initial.short_paths);
+        let name = maybe_trim_filename(n, indent, display_data);
+        ("".into(), name)
+    }
+}
 
-    let pretty_name = if display_data.colors_on {
-        let meta_result = fs::metadata(node.name.clone());
+fn get_pretty_size(node: &DisplayNode, is_biggest: bool, display_data: &DisplayData) -> String {
+    let output = if display_data.initial.by_filecount {
+        node.size.separate_with_commas()
+    } else {
+        human_readable_number(node.size, display_data.initial.iso)
+    };
+    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.initial.colors_on {
+        format!("{}", Red.paint(output))
+    } else {
+        output
+    }
+}
+
+fn get_pretty_name(
+    node: &DisplayNode,
+    name_and_padding: String,
+    display_data: &DisplayData,
+) -> String {
+    if display_data.initial.colors_on {
+        let meta_result = fs::metadata(&node.name);
         let directory_color = display_data
             .ls_colors
-            .style_for_path_with_metadata(node.name.clone(), meta_result.as_ref().ok());
+            .style_for_path_with_metadata(&node.name, meta_result.as_ref().ok());
         let ansi_style = directory_color
             .map(Style::to_ansi_term_style)
             .unwrap_or_default();
-        format!("{}", ansi_style.paint(name_and_padding))
+        let out = ansi_style.paint(name_and_padding);
+        format!("{out}")
     } else {
         name_and_padding
-    };
-
-    format!("{} {} {}{}", pretty_size, indent, pretty_name, percents)
+    }
 }
 
-fn human_readable_number(size: u64) -> String {
+pub fn human_readable_number(size: u64, iso: bool) -> String {
     for (i, u) in UNITS.iter().enumerate() {
-        let marker = 1024u64.pow((UNITS.len() - i) as u32);
+        let num: u64 = if iso { 1000 } else { 1024 };
+        let marker = num.pow((UNITS.len() - i) as u32);
         if size >= marker {
             if size / marker < 10 {
                 return format!("{:.1}{}", (size as f32 / marker as f32), u);
@@ -329,24 +408,104 @@ fn human_readable_number(size: u64) -> String {
             }
         }
     }
-    return format!("{}B", size);
+    format!("{size}B")
 }
 
 mod tests {
     #[allow(unused_imports)]
     use super::*;
+    #[allow(unused_imports)]
+    use std::path::PathBuf;
+
+    #[cfg(test)]
+    fn get_fake_display_data(longest_string_length: usize) -> DisplayData {
+        let initial = InitialDisplayData {
+            short_paths: true,
+            is_reversed: false,
+            colors_on: false,
+            by_filecount: false,
+            is_screen_reader: false,
+            iso: false,
+        };
+        DisplayData {
+            initial,
+            num_chars_needed_on_left_most: 5,
+            base_size: 2_u64.pow(12), // 4.0K
+            longest_string_length,
+            ls_colors: LsColors::from_env().unwrap_or_default(),
+        }
+    }
+
+    #[test]
+    fn test_format_str() {
+        let n = DisplayNode {
+            name: PathBuf::from("/short"),
+            size: 2_u64.pow(12), // This is 4.0K
+            children: vec![],
+        };
+        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);
+        assert_eq!(s, " 4.0K ┌─┴ short");
+    }
+
+    #[test]
+    fn test_format_str_long_name() {
+        let name = "very_long_name_longer_than_the_eighty_character_limit_very_long_name_this_bit_will_truncate";
+        let n = DisplayNode {
+            name: PathBuf::from(name),
+            size: 2_u64.pow(12), // This is 4.0K
+            children: vec![],
+        };
+        let indent = "┌─┴";
+        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);
+        assert_eq!(
+            s,
+            " 4.0K ┌─┴ very_long_name_longer_than_the_eighty_character_limit_very_.."
+        );
+    }
+
+    #[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.initial.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), "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");
+        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"
+        );
     }
 }

src/display_node.rs

@@ -0,0 +1,25 @@
+use std::path::PathBuf;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+pub struct DisplayNode {
+    // Note: the order of fields in important here, for PartialEq and PartialOrd
+    pub size: u64,
+    pub name: PathBuf,
+    pub children: Vec<DisplayNode>,
+}
+
+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())
+        } else {
+            Box::new(self.children.iter())
+        };
+        out
+    }
+}

src/filter.rs

@@ -0,0 +1,140 @@
+use crate::display_node::DisplayNode;
+use crate::node::Node;
+use std::collections::BinaryHeap;
+use std::collections::HashMap;
+use std::path::Path;
+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> {
+    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);
+    }
+
+    Some(fill_remaining_lines(heap, &root, display_data))
+}
+
+pub fn fill_remaining_lines<'a>(
+    mut heap: BinaryHeap<&'a Node>,
+    root: &'a Node,
+    display_data: AggregateData,
+) -> DisplayNode {
+    let mut allowed_nodes = HashMap::new();
+
+    while allowed_nodes.len() < display_data.number_of_lines {
+        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);
+            }
+            None => break,
+        }
+    }
+
+    if display_data.only_file {
+        flat_rebuilder(allowed_nodes, root)
+    } else {
+        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 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) -> DisplayNode {
+    let new_children: Vec<_> = current
+        .children
+        .iter()
+        .filter(|c| allowed_nodes.contains_key(c.name.as_path()))
+        .map(|c| recursive_rebuilder(allowed_nodes, c))
+        .collect();
+
+    build_node(new_children, current)
+}
+
+// Applies all allowed nodes as children to current node
+fn flat_rebuilder(allowed_nodes: HashMap<&Path, &Node>, current: &Node) -> 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>>();
+    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,
+        children: new_children,
+    }
+}

src/filter_type.rs

@@ -0,0 +1,75 @@
+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)
+    }
+}

src/main.rs

@@ -1,235 +1,257 @@
-#[macro_use]
-extern crate clap;
-extern crate unicode_width;
+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;
+
+use crate::cli::build_cli;
+use dir_walker::WalkData;
+use display::InitialDisplayData;
+use filter::AggregateData;
+use progress::PIndicator;
+use progress::ORDERING;
+use std::collections::HashSet;
+use std::io::BufRead;
+use std::panic;
+use std::process;
+use sysinfo::{System, SystemExt};
 
 use self::display::draw_it;
-use crate::utils::is_a_parent_of;
-use clap::{App, AppSettings, Arg};
+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 std::cmp::max;
 use std::path::PathBuf;
 use terminal_size::{terminal_size, Height, Width};
-use utils::{find_big_ones, get_dir_tree, simplify_dir_names, sort, trim_deep_ones, Node};
-
-mod display;
-mod utils;
+use utils::get_filesystem_devices;
+use utils::simplify_dir_names;
 
 static DEFAULT_NUMBER_OF_LINES: usize = 30;
+static DEFAULT_TERMINAL_WIDTH: usize = 80;
 
-#[cfg(windows)]
 fn init_color(no_color: bool) -> bool {
-    // 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"
-            );
+    #[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!(
+                    "This version of Windows does not support ANSI colors, setting no_color flag"
+                );
+                    true
+                }
+            }
         }
     }
-}
-
-#[cfg(not(windows))]
-fn init_color(no_color: bool) -> bool {
-    no_color
+    #[cfg(not(windows))]
+    {
+        no_color
+    }
 }
 
 fn get_height_of_terminal() -> usize {
-    // 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
-    }
+    // 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
+}
+
+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")
+    })
 }
 
 fn main() {
-    let default_height = get_height_of_terminal();
-    let def_num_str = default_height.to_string();
+    let options = build_cli().get_matches();
+    let config = get_config();
+    let stdin_lines = get_lines_from_stdin();
 
-    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),
-        )
-        .arg(
-            Arg::with_name("threads")
-                .short("t")
-                .long("threads")
-                .help("Number of threads to spawn simultaneously")
-                .takes_value(true),
-        )
-        .arg(
-            Arg::with_name("number_of_lines")
-                .short("n")
-                .long("number-of-lines")
-                .help("Number of lines of output to show")
-                .takes_value(true)
-                .default_value(def_num_str.as_ref()),
-        )
-        .arg(
-            Arg::with_name("display_full_paths")
-                .short("p")
-                .long("full-paths")
-                .help("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("limit_filesystem")
-                .short("x")
-                .long("limit-filesystem")
-                .help("Only count the files and directories on the same filesystem as the supplied directory"),
-        )
-        .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("inputs").multiple(true))
-        .get_matches();
-
-    let target_dirs = {
-        match options.values_of("inputs") {
-            None => vec!["."],
-            Some(r) => r.collect(),
-        }
+    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 number_of_lines = match value_t!(options.value_of("number_of_lines"), usize) {
-        Ok(v) => v,
-        Err(_) => {
-            eprintln!("Ignoring bad value for number_of_lines");
-            default_height
-        }
+    let 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 = config.get_depth(&options);
+
+    // 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 temp_threads = options.value_of("threads").and_then(|threads| {
-        threads
-            .parse::<usize>()
-            .map_err(|_| eprintln!("Ignoring bad value for threads: {:?}", threads))
-            .ok()
-    });
-    // Bug in JWalk
-    // https://github.com/jessegrosjean/jwalk/issues/15
-    // We force it to use 2 threads if there is only 1 cpu
-    // as JWalk breaks if it tries to run on a single cpu
-    let threads = {
-        if temp_threads.is_none() && num_cpus::get() == 1 {
-            Some(2)
-        } else {
-            temp_threads
-        }
-    };
+    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 depth = options.value_of("depth").and_then(|depth| {
-        depth
-            .parse::<u64>()
-            .map(|v| v + 1)
-            .map_err(|_| eprintln!("Ignoring bad value for depth"))
-            .ok()
-    });
-    if options.is_present("depth") && number_of_lines != default_height {
-        eprintln!("Use either -n or -d. Not both");
-        return;
-    }
+    let no_colors = init_color(config.get_no_colors(&options));
 
-    let no_colors = init_color(options.is_present("no_colors"));
-    let use_apparent_size = options.is_present("display_apparent_size");
+    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 ignore_directories = match options.values_of("ignore_directory") {
-        Some(i) => Some(i.map(PathBuf::from).collect()),
-        None => None,
-    };
+    let follow_links = options.is_present("dereference_links");
 
     let simplified_dirs = simplify_dir_names(target_dirs);
-    let (permissions, nodes) = get_dir_tree(
-        &simplified_dirs,
-        &ignore_directories,
-        use_apparent_size,
-        limit_filesystem,
-        threads,
-    );
-    let sorted_data = sort(nodes);
-    let biggest_ones = {
-        match depth {
-            None => find_big_ones(sorted_data, number_of_lines + simplified_dirs.len()),
-            Some(d) => trim_deep_ones(sorted_data, d, &simplified_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 result = panic::catch_unwind(|| init_rayon);
+    if result.is_err() {
+        eprintln!("Problem initializing rayon, try: export RAYON_NUM_THREADS=1")
+    }
+
+    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 tree = build_tree(biggest_ones, depth);
 
-    draw_it(
-        permissions,
-        options.is_present("display_full_paths"),
-        !options.is_present("reverse"),
-        no_colors,
-        options.is_present("no_bars"),
-        tree,
-    );
-}
+    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");
+    }
 
-fn build_tree(biggest_ones: Vec<(PathBuf, u64)>, depth: Option<u64>) -> Node {
-    let mut top_parent = Node::default();
-
-    // assume sorted order
-    for b in biggest_ones {
-        let n = Node {
-            name: b.0,
-            size: b.1,
-            children: Vec::default(),
+    if let Some(root_node) = tree {
+        let idd = InitialDisplayData {
+            short_paths: !config.get_full_paths(&options),
+            is_reversed: !config.get_reverse(&options),
+            colors_on: !no_colors,
+            by_filecount,
+            iso,
+            is_screen_reader: config.get_screen_reader(&options),
         };
-        recursively_build_tree(&mut top_parent, n, depth);
+        draw_it(
+            idd,
+            config.get_no_bars(&options),
+            terminal_width,
+            &root_node,
+            config.get_skip_total(&options),
+        )
     }
-    top_parent
 }
 
-fn recursively_build_tree(parent_node: &mut Node, new_node: Node, depth: Option<u64>) {
-    let new_depth = match depth {
-        None => None,
-        Some(0) => return,
-        Some(d) => Some(d - 1),
-    };
-    if let Some(c) = parent_node
-        .children
-        .iter_mut()
-        .find(|c| is_a_parent_of(&c.name, &new_node.name))
-    {
-        recursively_build_tree(c, new_node, new_depth);
+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 {
-        parent_node.children.push(new_node);
+        rayon::ThreadPoolBuilder::new().build_global()
     }
 }

src/node.rs

@@ -0,0 +1,78 @@
+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;
+
+#[derive(Debug, Eq, Clone)]
+pub struct Node {
+    pub name: PathBuf,
+    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,
+        }
+    })
+}
+
+impl PartialEq for Node {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name && self.size == other.size && self.children == other.children
+    }
+}
+
+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))
+    }
+}
+
+impl PartialOrd for Node {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}

src/platform.rs

@@ -1,30 +1,32 @@
-use jwalk::DirEntry;
 #[allow(unused_imports)]
 use std::fs;
-use std::io;
+
 use std::path::Path;
 
 #[cfg(target_family = "unix")]
 fn get_block_size() -> u64 {
-    // All os specific implementations of MetatdataExt seem to define a block as 512 bytes
+    // All os specific implementations of MetadataExt seem to define a block as 512 bytes
     // https://doc.rust-lang.org/std/os/linux/fs/trait.MetadataExt.html#tymethod.st_blocks
     512
 }
 
 #[cfg(target_family = "unix")]
-pub fn get_metadata(d: &DirEntry, use_apparent_size: bool) -> Option<(u64, Option<(u64, u64)>)> {
+pub fn get_metadata(d: &Path, use_apparent_size: bool) -> Option<(u64, Option<(u64, u64)>)> {
     use std::os::unix::fs::MetadataExt;
-    d.metadata.as_ref().unwrap().as_ref().ok().map(|md| {
-        if use_apparent_size {
-            (md.len(), Some((md.ino(), md.dev())))
-        } else {
-            (md.blocks() * get_block_size(), Some((md.ino(), md.dev())))
+    match d.metadata() {
+        Ok(md) => {
+            if use_apparent_size {
+                Some((md.len(), Some((md.ino(), md.dev()))))
+            } else {
+                Some((md.blocks() * get_block_size(), Some((md.ino(), md.dev()))))
+            }
         }
-    })
+        Err(_e) => None,
+    }
 }
 
 #[cfg(target_family = "windows")]
-pub fn get_metadata(d: &DirEntry, _use_apparent_size: bool) -> Option<(u64, Option<(u64, u64)>)> {
+pub fn get_metadata(d: &Path, _use_apparent_size: bool) -> Option<(u64, Option<(u64, u64)>)> {
     // On windows opening the file to get size, file ID and volume can be very
     // expensive because 1) it causes a few system calls, and more importantly 2) it can cause
     // windows defender to scan the file.
@@ -61,6 +63,7 @@ pub fn get_metadata(d: &DirEntry, _use_apparent_size: bool) -> Option<(u64, Opti
     // Consistently opening the file: 30 minutes.
     // With this optimization:         8 sec.
 
+    use std::io;
     use winapi_util::Handle;
     fn handle_from_path_limited<P: AsRef<Path>>(path: P) -> io::Result<Handle> {
         use std::fs::OpenOptions;
@@ -87,10 +90,10 @@ pub fn get_metadata(d: &DirEntry, _use_apparent_size: bool) -> Option<(u64, Opti
         Ok(Handle::from_file(file))
     }
 
-    fn get_metadata_expensive(d: &DirEntry) -> Option<(u64, Option<(u64, u64)>)> {
+    fn get_metadata_expensive(d: &Path) -> Option<(u64, Option<(u64, u64)>)> {
         use winapi_util::file::information;
 
-        let h = handle_from_path_limited(d.path()).ok()?;
+        let h = handle_from_path_limited(d).ok()?;
         let info = information(&h).ok()?;
 
         Some((
@@ -99,44 +102,27 @@ pub fn get_metadata(d: &DirEntry, _use_apparent_size: bool) -> Option<(u64, Opti
         ))
     }
 
-    match d.metadata {
-        Some(Ok(ref md)) => {
-            use std::os::windows::fs::MetadataExt;
-            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;
+    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;
 
             let attr_filtered = md.file_attributes()
                 & !(FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_SYSTEM);
-            if attr_filtered == FILE_ATTRIBUTE_ARCHIVE
-                || attr_filtered == FILE_ATTRIBUTE_DIRECTORY
+            if (attr_filtered & FILE_ATTRIBUTE_ARCHIVE) != 0
+                || (attr_filtered & FILE_ATTRIBUTE_DIRECTORY) != 0
                 || 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),
     }
 }
-
-#[cfg(target_family = "unix")]
-pub fn get_filesystem<P: AsRef<Path>>(file_path: P) -> Result<u64, io::Error> {
-    use std::os::unix::fs::MetadataExt;
-    let metadata = fs::metadata(file_path)?;
-    Ok(metadata.dev())
-}
-
-#[cfg(target_family = "windows")]
-pub fn get_filesystem<P: AsRef<Path>>(file_path: P) -> Result<u64, io::Error> {
-    use winapi_util::file::information;
-    use winapi_util::Handle;
-
-    let h = Handle::from_path_any(file_path)?;
-    let info = information(&h)?;
-    Ok(info.volume_serial_number())
-}

src/progress.rs

@@ -0,0 +1,145 @@
+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();
+        }
+    }
+}

src/utils.rs

@@ -0,0 +1,158 @@
+use platform::get_metadata;
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+
+use crate::platform;
+use regex::Regex;
+
+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());
+
+    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) {
+                to_remove.push(tt.to_path_buf());
+            } else if is_a_parent_of(tt, &top_level_name) {
+                can_add = false;
+            }
+        }
+        for r in to_remove {
+            top_level_names.remove(&r);
+        }
+        if can_add {
+            top_level_names.insert(top_level_name);
+        }
+    }
+
+    top_level_names
+}
+
+pub fn get_filesystem_devices<'a, P: IntoIterator<Item = &'a PathBuf>>(paths: P) -> HashSet<u64> {
+    // Gets the device ids for the filesystems which are used by the argument paths
+    paths
+        .into_iter()
+        .filter_map(|p| 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
+    // 2. removing interior '.' ("current directory") path segments
+    // 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)
+}
+
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+
+    #[test]
+    fn test_simplify_dir() {
+        let mut correct = HashSet::new();
+        correct.insert(PathBuf::from("a"));
+        assert_eq!(simplify_dir_names(vec!["a"]), correct);
+    }
+
+    #[test]
+    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);
+    }
+
+    #[test]
+    fn test_simplify_dir_duplicates() {
+        let mut correct = HashSet::new();
+        correct.insert(["a", "b"].iter().collect::<PathBuf>());
+        correct.insert(PathBuf::from("c"));
+        assert_eq!(
+            simplify_dir_names(vec![
+                "a/b",
+                "a/b//",
+                "a/././b///",
+                "c",
+                "c/",
+                "c/.",
+                "c/././",
+                "c/././."
+            ]),
+            correct
+        );
+    }
+    #[test]
+    fn test_simplify_dir_rm_subdir_and_not_substrings() {
+        let mut correct = HashSet::new();
+        correct.insert(PathBuf::from("b"));
+        correct.insert(["c", "a", "b"].iter().collect::<PathBuf>());
+        correct.insert(["a", "b"].iter().collect::<PathBuf>());
+        assert_eq!(simplify_dir_names(vec!["a/b", "c/a/b/", "b"]), correct);
+    }
+
+    #[test]
+    fn test_simplify_dir_dots() {
+        let mut correct = HashSet::new();
+        correct.insert(PathBuf::from("src"));
+        assert_eq!(simplify_dir_names(vec!["src/."]), correct);
+    }
+
+    #[test]
+    fn test_simplify_dir_substring_names() {
+        let mut correct = HashSet::new();
+        correct.insert(PathBuf::from("src"));
+        correct.insert(PathBuf::from("src_v2"));
+        assert_eq!(simplify_dir_names(vec!["src/", "src_v2"]), correct);
+    }
+
+    #[test]
+    fn test_is_a_parent_of() {
+        assert!(is_a_parent_of("/usr", "/usr/andy"));
+        assert!(is_a_parent_of("/usr", "/usr/andy/i/am/descendant"));
+        assert!(!is_a_parent_of("/usr", "/usr/."));
+        assert!(!is_a_parent_of("/usr", "/usr/"));
+        assert!(!is_a_parent_of("/usr", "/usr"));
+        assert!(!is_a_parent_of("/usr/", "/usr"));
+        assert!(!is_a_parent_of("/usr/andy", "/usr"));
+        assert!(!is_a_parent_of("/usr/andy", "/usr/sibling"));
+        assert!(!is_a_parent_of("/usr/folder", "/usr/folder_not_a_child"));
+    }
+
+    #[test]
+    fn test_is_a_parent_of_root() {
+        assert!(is_a_parent_of("/", "/usr/andy"));
+        assert!(is_a_parent_of("/", "/usr"));
+        assert!(!is_a_parent_of("/", "/"));
+    }
+}

src/utils/mod.rs

@@ -1,403 +0,0 @@
-use jwalk::DirEntry;
-use std::cmp::Ordering;
-use std::collections::HashMap;
-use std::collections::HashSet;
-use std::path::{Path, PathBuf};
-
-use jwalk::WalkDir;
-
-mod platform;
-use self::platform::*;
-
-#[derive(Debug, Default, Eq)]
-pub struct Node {
-    pub name: PathBuf,
-    pub size: u64,
-    pub children: Vec<Node>,
-}
-
-impl Ord for Node {
-    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 Node {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl PartialEq for Node {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name && self.size == other.size && self.children == other.children
-    }
-}
-
-pub 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;
-
-        for tt in top_level_names.iter() {
-            if is_a_parent_of(&top_level_name, tt) {
-                to_remove.push(tt.to_path_buf());
-            } else if is_a_parent_of(tt, &top_level_name) {
-                can_add = false;
-            }
-        }
-        to_remove.sort_unstable();
-        top_level_names.retain(|tr| to_remove.binary_search(tr).is_err());
-        to_remove.clear();
-        if can_add {
-            top_level_names.insert(top_level_name);
-        }
-    }
-
-    top_level_names
-}
-
-pub fn get_dir_tree<P: AsRef<Path>>(
-    top_level_names: &HashSet<P>,
-    ignore_directories: &Option<Vec<PathBuf>>,
-    apparent_size: bool,
-    limit_filesystem: bool,
-    threads: Option<usize>,
-) -> (bool, HashMap<PathBuf, u64>) {
-    let mut permissions = 0;
-    let mut data: HashMap<PathBuf, u64> = HashMap::new();
-    let restricted_filesystems = if limit_filesystem {
-        get_allowed_filesystems(top_level_names)
-    } else {
-        None
-    };
-
-    let mut examine_dir_args = ExamineDirMutArsg {
-        data: &mut data,
-        file_count_no_permission: &mut permissions,
-    };
-    for b in top_level_names.iter() {
-        examine_dir(
-            b,
-            apparent_size,
-            &restricted_filesystems,
-            ignore_directories,
-            threads,
-            &mut examine_dir_args,
-        );
-    }
-    (permissions == 0, data)
-}
-
-fn get_allowed_filesystems<P: AsRef<Path>>(top_level_names: &HashSet<P>) -> Option<HashSet<u64>> {
-    let mut limit_filesystems: HashSet<u64> = HashSet::new();
-    for file_name in top_level_names.iter() {
-        if let Ok(a) = get_filesystem(file_name) {
-            limit_filesystems.insert(a);
-        }
-    }
-    Some(limit_filesystems)
-}
-
-pub fn normalize_path<P: AsRef<Path>>(path: P) -> PathBuf {
-    // normalize path ...
-    // 1. removing repeated separators
-    // 2. removing interior '.' ("current directory") path segments
-    // 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::<PathBuf>()
-}
-
-struct ExamineDirMutArsg<'a> {
-    data: &'a mut HashMap<PathBuf, u64>,
-    file_count_no_permission: &'a mut u64,
-}
-
-fn examine_dir<P: AsRef<Path>>(
-    top_dir: P,
-    apparent_size: bool,
-    filesystems: &Option<HashSet<u64>>,
-    ignore_directories: &Option<Vec<PathBuf>>,
-    threads: Option<usize>,
-    mut_args: &mut ExamineDirMutArsg,
-) {
-    let top_dir = top_dir.as_ref();
-    let mut inodes: HashSet<(u64, u64)> = HashSet::new();
-    let mut iter = WalkDir::new(top_dir)
-        .preload_metadata(true)
-        .skip_hidden(false);
-    if let Some(threads_to_start) = threads {
-        iter = iter.num_threads(threads_to_start);
-    }
-
-    'entry: for entry in iter {
-        if let Ok(e) = entry {
-            let maybe_size_and_inode = get_metadata(&e, apparent_size);
-
-            if let Some(dirs) = ignore_directories {
-                let path = e.path();
-                let parts = path.components().collect::<Vec<std::path::Component>>();
-                for d in dirs {
-                    let seq = d.components().collect::<Vec<std::path::Component>>();
-                    if parts
-                        .windows(seq.len())
-                        .any(|window| window.iter().collect::<PathBuf>() == *d)
-                    {
-                        continue 'entry;
-                    }
-                }
-            }
-
-            match maybe_size_and_inode {
-                Some(data) => {
-                    let (size, inode_device) = data;
-                    if !should_ignore_file(apparent_size, filesystems, &mut inodes, inode_device) {
-                        process_file_with_size_and_inode(top_dir, mut_args.data, e, size)
-                    }
-                }
-                None => *mut_args.file_count_no_permission += 1,
-            }
-        } else {
-            *mut_args.file_count_no_permission += 1
-        }
-    }
-}
-
-fn should_ignore_file(
-    apparent_size: bool,
-    restricted_filesystems: &Option<HashSet<u64>>,
-    inodes: &mut HashSet<(u64, u64)>,
-    maybe_inode_device: Option<(u64, u64)>,
-) -> bool {
-    match maybe_inode_device {
-        None => false,
-        Some(data) => {
-            let (inode, device) = data;
-            // Ignore files on different devices (if flag applied)
-            if let Some(rs) = restricted_filesystems {
-                if !rs.contains(&device) {
-                    return true;
-                }
-            }
-
-            if !apparent_size {
-                // Ignore files already visited or symlinked
-                if inodes.contains(&(inode, device)) {
-                    return true;
-                }
-                inodes.insert((inode, device));
-            }
-            false
-        }
-    }
-}
-
-fn process_file_with_size_and_inode<P: AsRef<Path>>(
-    top_dir: P,
-    data: &mut HashMap<PathBuf, u64>,
-    e: DirEntry,
-    size: u64,
-) {
-    let top_dir = top_dir.as_ref();
-    // This path and all its parent paths have their counter incremented
-    for path in e.path().ancestors() {
-        // This is required due to bug in Jwalk that adds '/' to all sub dir lists
-        // see: https://github.com/jessegrosjean/jwalk/issues/13
-        if path.to_string_lossy() == "/" && top_dir.to_string_lossy() != "/" {
-            continue;
-        }
-        let s = data.entry(normalize_path(path)).or_insert(0);
-        *s += size;
-        if path.starts_with(top_dir) && top_dir.starts_with(path) {
-            break;
-        }
-    }
-}
-
-pub fn sort_by_size_first_name_second(a: &(PathBuf, u64), b: &(PathBuf, u64)) -> Ordering {
-    let result = b.1.cmp(&a.1);
-    if result == Ordering::Equal {
-        a.0.cmp(&b.0)
-    } else {
-        result
-    }
-}
-
-pub fn sort(data: HashMap<PathBuf, u64>) -> Vec<(PathBuf, u64)> {
-    let mut new_l: Vec<(PathBuf, u64)> = data.iter().map(|(a, b)| (a.clone(), *b)).collect();
-    new_l.sort_unstable_by(sort_by_size_first_name_second);
-    new_l
-}
-
-pub fn find_big_ones(new_l: Vec<(PathBuf, u64)>, max_to_show: usize) -> Vec<(PathBuf, u64)> {
-    if max_to_show > 0 && new_l.len() > max_to_show {
-        new_l[0..max_to_show].to_vec()
-    } else {
-        new_l
-    }
-}
-
-fn depth_of_path(name: &PathBuf) -> usize {
-    // Filter required as paths can have some odd preliminary
-    // ("Prefix") bits (for example, from windows, "\\?\" or "\\UNC\")
-    name.components()
-        .filter(|&c| match c {
-            std::path::Component::Prefix(_) => false,
-            _ => true,
-        })
-        .count()
-}
-
-pub fn trim_deep_ones(
-    input: Vec<(PathBuf, u64)>,
-    max_depth: u64,
-    top_level_names: &HashSet<PathBuf>,
-) -> Vec<(PathBuf, u64)> {
-    let mut result: Vec<(PathBuf, u64)> = Vec::with_capacity(input.len() * top_level_names.len());
-
-    for name in top_level_names {
-        let my_max_depth = depth_of_path(name) + max_depth as usize;
-
-        for &(ref k, ref v) in input.iter() {
-            if k.starts_with(name) && depth_of_path(k) <= my_max_depth {
-                result.push((k.clone(), *v));
-            }
-        }
-    }
-    result
-}
-
-mod tests {
-    #[allow(unused_imports)]
-    use super::*;
-
-    #[test]
-    fn test_simplify_dir() {
-        let mut correct = HashSet::new();
-        correct.insert(PathBuf::from("a"));
-        assert_eq!(simplify_dir_names(vec!["a"]), correct);
-    }
-
-    #[test]
-    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", "a/b/c", "a/b/d/f"]), correct);
-    }
-
-    #[test]
-    fn test_simplify_dir_duplicates() {
-        let mut correct = HashSet::new();
-        correct.insert(["a", "b"].iter().collect::<PathBuf>());
-        correct.insert(PathBuf::from("c"));
-        assert_eq!(
-            simplify_dir_names(vec![
-                "a/b",
-                "a/b//",
-                "a/././b///",
-                "c",
-                "c/",
-                "c/.",
-                "c/././",
-                "c/././."
-            ]),
-            correct
-        );
-    }
-    #[test]
-    fn test_simplify_dir_rm_subdir_and_not_substrings() {
-        let mut correct = HashSet::new();
-        correct.insert(PathBuf::from("b"));
-        correct.insert(["c", "a", "b"].iter().collect::<PathBuf>());
-        correct.insert(["a", "b"].iter().collect::<PathBuf>());
-        assert_eq!(simplify_dir_names(vec!["a/b", "c/a/b/", "b"]), correct);
-    }
-
-    #[test]
-    fn test_simplify_dir_dots() {
-        let mut correct = HashSet::new();
-        correct.insert(PathBuf::from("src"));
-        assert_eq!(simplify_dir_names(vec!["src/."]), correct);
-    }
-
-    #[test]
-    fn test_simplify_dir_substring_names() {
-        let mut correct = HashSet::new();
-        correct.insert(PathBuf::from("src"));
-        correct.insert(PathBuf::from("src_v2"));
-        assert_eq!(simplify_dir_names(vec!["src/", "src_v2"]), correct);
-    }
-
-    #[test]
-    fn test_is_a_parent_of() {
-        assert!(is_a_parent_of("/usr", "/usr/andy"));
-        assert!(is_a_parent_of("/usr", "/usr/andy/i/am/descendant"));
-        assert!(!is_a_parent_of("/usr", "/usr/."));
-        assert!(!is_a_parent_of("/usr", "/usr/"));
-        assert!(!is_a_parent_of("/usr", "/usr"));
-        assert!(!is_a_parent_of("/usr/", "/usr"));
-        assert!(!is_a_parent_of("/usr/andy", "/usr"));
-        assert!(!is_a_parent_of("/usr/andy", "/usr/sibling"));
-        assert!(!is_a_parent_of("/usr/folder", "/usr/folder_not_a_child"));
-    }
-
-    #[test]
-    fn test_is_a_parent_of_root() {
-        assert!(is_a_parent_of("/", "/usr/andy"));
-        assert!(is_a_parent_of("/", "/usr"));
-        assert!(!is_a_parent_of("/", "/"));
-    }
-
-    #[test]
-    fn test_should_ignore_file() {
-        let mut files = HashSet::new();
-        files.insert((10, 20));
-
-        assert!(!should_ignore_file(true, &None, &mut files, Some((0, 0))));
-
-        // New file is not known it will be inserted to the hashmp and should not be ignored
-        assert!(!should_ignore_file(
-            false,
-            &None,
-            &mut files,
-            Some((11, 12))
-        ));
-        assert!(files.contains(&(11, 12)));
-
-        // The same file will be ignored the second time
-        assert!(should_ignore_file(false, &None, &mut files, Some((11, 12))));
-    }
-
-    #[test]
-    fn test_should_ignore_file_on_different_device() {
-        let mut files = HashSet::new();
-        files.insert((10, 20));
-
-        let mut devices = HashSet::new();
-        devices.insert(99);
-        let od = Some(devices);
-
-        // If we are looking at a different device (disk) and the device flag is set
-        // then apparent_size is irrelevant - we ignore files on other devices
-        assert!(should_ignore_file(false, &od, &mut files, Some((11, 12))));
-        assert!(should_ignore_file(true, &od, &mut files, Some((11, 12))));
-
-        // We do not ignore files on the same device
-        assert!(!should_ignore_file(false, &od, &mut files, Some((2, 99))));
-        assert!(!should_ignore_file(true, &od, &mut files, Some((2, 99))));
-    }
-}

tests/test_dir_hidden_entries/.hidden_file

@@ -0,0 +1 @@
+hi

tests/test_exact_output.rs

@@ -0,0 +1,208 @@
+use assert_cmd::Command;
+use std::ffi::OsStr;
+use std::str;
+use std::sync::Once;
+
+static INIT: Once = Once::new();
+
+/**
+ * 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
+ * Windows is ignored here because the results vary by host making exact testing impractical
+ *
+ * Despite the above problems, these tests are good as they are the closest to 'the real thing'.
+ */
+
+//  Warning: File sizes differ on both platform and on the format of the disk.
+/// 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
+    let last_slash = dir.rfind('/').unwrap();
+    let last_part_of_dir = dir.chars().skip(last_slash).collect::<String>();
+    let _ = 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));
+}
+
+fn initialize() {
+    INIT.call_once(|| {
+        copy_test_data("tests/test_dir");
+        copy_test_data("tests/test_dir2");
+        copy_test_data("tests/test_dir_unicode");
+    });
+}
+
+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/"])
+}
+
+#[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);
+}
+
+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%
+"#
+    .trim()
+    .to_string();
+
+    let ubuntu = r#"
+  0B     ┌── a_file    │                ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
+4.0K     ├── hello_file│                ░░░░░░░░░░░░░░░░█████████████████ │  33%
+8.0K   ┌─┴ many        │                █████████████████████████████████ │  67%
+ 12K ┌─┴ test_dir      │█████████████████████████████████████████████████ │ 100%
+  "#
+    .trim()
+    .to_string();
+
+    vec![mac_and_some_linux, ubuntu]
+}
+
+#[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);
+}
+
+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%
+"#
+    .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%
+"#
+    .trim()
+    .to_string();
+    vec![mac_and_some_linux, ubuntu]
+}
+
+// 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_attr(target_os = "windows", ignore)]
+#[test]
+pub fn test_apparent_size() {
+    let command_args = vec!["-c", "-s", "-b", "/tmp/test_dir"];
+    exact_output_test(apparent_size_output(), command_args);
+}
+
+fn apparent_size_output() -> Vec<String> {
+    // The apparent directory sizes are too unpredictable and system dependent to try and match
+    let files = r#"
+  0B     ┌── a_file
+  6B     ├── hello_file
+ "#
+    .trim()
+    .to_string();
+
+    vec![files]
+}

tests/test_flags.rs

@@ -0,0 +1,222 @@
+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/"]);
+
+    assert!(output.contains(" ┌─┴ "));
+    assert!(output.contains("test_dir "));
+    assert!(output.contains("  ┌─┴ "));
+    assert!(output.contains("many "));
+    assert!(output.contains("    ├── "));
+    assert!(output.contains("hello_file"));
+    assert!(output.contains("     ┌── "));
+    assert!(output.contains("a_file "));
+}
+
+#[test]
+pub fn test_output_no_bars_means_no_excess_spaces() {
+    let output = build_command(vec!["-b", "tests/test_dir/"]);
+    // If bars are not being shown we don't need to pad the output with spaces
+    assert!(output.contains("many"));
+    assert!(!output.contains("many    "));
+}
+
+#[test]
+pub fn test_reverse_flag() {
+    let output = build_command(vec!["-r", "-c", "tests/test_dir/"]);
+    assert!(output.contains(" └─┬ test_dir "));
+    assert!(output.contains("  └─┬ many "));
+    assert!(output.contains("    ├── hello_file"));
+    assert!(output.contains("    └── a_file "));
+}
+
+#[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/"]);
+    assert!(!output.contains("hello_file"));
+}
+
+#[test]
+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"));
+}
+
+// Check against directories and files whose names are substrings of each other
+#[test]
+pub fn test_ignore_dir() {
+    let output = build_command(vec!["-c", "-X", "dir_substring", "tests/test_dir2/"]);
+    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();
+    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/"]);
+    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/"]);
+    assert!(!output.contains(".hidden_file"));
+    assert!(output.contains("┌── test_dir_hidden_entries"));
+}
+
+#[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"]);
+    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"));
+}

tests/tests.rs

@@ -1,267 +1 @@
-mod tests_symlinks;
 
-// File sizes differ on both platform and on the format of the disk.
-// We can at least test the file names are there
-#[test]
-pub fn test_basic_output() {
-    assert_cli::Assert::main_binary()
-        .with_args(&["src/test_dir/"])
-        .stdout()
-        .contains(" ┌─┴ ")
-        .stdout()
-        .contains("test_dir ")
-        .stdout()
-        .contains("  ┌─┴ ")
-        .stdout()
-        .contains("many ")
-        .stdout()
-        .contains("    ├── ")
-        .stdout()
-        .contains("hello_file")
-        .stdout()
-        .contains("     ┌── ")
-        .stdout()
-        .contains("a_file ")
-        .unwrap();
-}
-
-// fix! [rivy; 2020-22-01] "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
-    assert_cli::Assert::main_binary()
-        .with_args(&["-c", "src/test_dir"])
-        .stdout()
-        .is(main_output().as_str())
-        .unwrap();
-}
-
-// fix! [rivy; 2020-22-01] "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_multi_arg() {
-    assert_cli::Assert::main_binary()
-        .with_args(&["-c", "src/test_dir/many/", "src/test_dir/", "src/test_dir"])
-        .stdout()
-        .is(main_output().as_str())
-        .unwrap();
-}
-
-#[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%
- "#
-    .to_string()
-}
-
-#[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%
-    "#
-    .to_string()
-}
-
-#[cfg(target_os = "windows")]
-fn main_output() -> String {
-    "PRs welcome".to_string()
-}
-
-// fix! [rivy; 2020-22-01] "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_long_paths() {
-    assert_cli::Assert::main_binary()
-        .with_args(&["-c", "-p", "src/test_dir"])
-        .stdout()
-        .is(main_output_long_paths().as_str())
-        .unwrap();
-}
-
-#[cfg(target_os = "macos")]
-fn main_output_long_paths() -> String {
-    r#"
-   0B     ┌── src/test_dir/many/a_file    │░░░░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
- 4.0K     ├── src/test_dir/many/hello_file│████████████████████████████ │ 100%
- 4.0K   ┌─┴ src/test_dir/many             │████████████████████████████ │ 100%
- 4.0K ┌─┴ src/test_dir                    │████████████████████████████ │ 100% 
- "#
-    .to_string()
-}
-
-#[cfg(target_os = "linux")]
-fn main_output_long_paths() -> String {
-    r#"   
-   0B     ┌── src/test_dir/many/a_file    │         ░░░░░░░░░░░░░░░░░░█ │   0%
- 4.0K     ├── src/test_dir/many/hello_file│         ░░░░░░░░░██████████ │  33%
- 8.0K   ┌─┴ src/test_dir/many             │         ███████████████████ │  67%
-  12K ┌─┴ src/test_dir                    │████████████████████████████ │ 100% 
-    "#
-    .to_string()
-}
-
-#[cfg(target_os = "windows")]
-fn main_output_long_paths() -> String {
-    "PRs welcome".to_string()
-}
-
-// fix! [rivy; 2020-22-01] "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_apparent_size() {
-    assert_cli::Assert::main_binary()
-        .with_args(&["-c", "-s", "src/test_dir"])
-        .stdout()
-        .is(output_apparent_size().as_str())
-        .unwrap();
-}
-
-#[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%     
-    "#
-    .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%
-    "#
-    .to_string()
-}
-
-#[cfg(target_os = "windows")]
-fn output_apparent_size() -> String {
-    "".to_string()
-}
-
-#[test]
-pub fn test_reverse_flag() {
-    assert_cli::Assert::main_binary()
-        .with_args(&["-c", "-r", "src/test_dir/"])
-        .stdout()
-        .contains(" └─┬ test_dir ")
-        .stdout()
-        .contains("  └─┬ many ")
-        .stdout()
-        .contains("    ├── hello_file")
-        .stdout()
-        .contains("    └── a_file ")
-        .unwrap();
-}
-
-#[test]
-pub fn test_d_flag_works() {
-    // We should see the top level directory but not the sub dirs / files:
-    assert_cli::Assert::main_binary()
-        .with_args(&["-d", "1", "-s", "src/test_dir"])
-        .stdout()
-        .doesnt_contain("hello_file")
-        .unwrap();
-}
-
-// Check against directories and files whos names are substrings of each other
-// fix! [rivy; 2020-22-01] "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_substring_of_names() {
-    assert_cli::Assert::main_binary()
-        .with_args(&["-c", "src/test_dir2"])
-        .stdout()
-        .is(no_substring_of_names_output().as_str())
-        .unwrap();
-}
-
-#[cfg(target_os = "linux")]
-fn no_substring_of_names_output() -> String {
-    "
- 4.0K   ┌── dir_name_clash│                                    ████████ │  17%
- 4.0K   │ ┌── hello       │                             ░░░░░░░████████ │  17%
- 8.0K   ├─┴ dir_substring │                             ███████████████ │  33%
- 4.0K   │ ┌── hello       │                             ░░░░░░░████████ │  17%
- 8.0K   ├─┴ dir           │                             ███████████████ │  33%
-  24K ┌─┴ test_dir2       │████████████████████████████████████████████ │ 100% 
-    "
-    .into()
-}
-
-#[cfg(target_os = "macos")]
-fn no_substring_of_names_output() -> String {
-    "
- 4.0K     ┌── hello       │                             ███████████████ │  33%
- 4.0K   ┌─┴ dir_substring │                             ███████████████ │  33%
- 4.0K   ├── dir_name_clash│                             ███████████████ │  33%
- 4.0K   │ ┌── hello       │                             ███████████████ │  33%
- 4.0K   ├─┴ dir           │                             ███████████████ │  33%
-  12K ┌─┴ test_dir2       │████████████████████████████████████████████ │ 100% 
-  "
-    .into()
-}
-
-#[cfg(target_os = "windows")]
-fn no_substring_of_names_output() -> String {
-    "PRs".into()
-}
-
-// fix! [rivy; 2020-22-01] "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_unicode_directories() {
-    assert_cli::Assert::main_binary()
-        .with_args(&["-c", "src/test_dir3"])
-        .stdout()
-        .is(unicode_dir().as_str())
-        .unwrap();
-}
-
-#[cfg(target_os = "linux")]
-fn unicode_dir() -> String {
-    // The way unicode & asian characters are rendered on the terminal should make this line up
-    "
-   0B   ┌── 👩.unicode                │                               █ │   0%
-   0B   ├── ラウトは難しいです！.japan│                               █ │   0%
- 4.0K ┌─┴ test_dir3                   │████████████████████████████████ │ 100%
-    "
-    .into()
-}
-
-#[cfg(target_os = "macos")]
-fn unicode_dir() -> String {
-    "
-   0B   ┌── 👩.unicode                │                               █ │   0%
-   0B   ├── ラウトは難しいです！.japan│                               █ │   0%
-   0B ┌─┴ test_dir3                   │                               █ │   0%
-    "
-    .into()
-}
-
-#[cfg(target_os = "windows")]
-fn unicode_dir() -> String {
-    "".into()
-}
-
-// Check against directories and files whos names are substrings of each other
-#[test]
-pub fn test_ignore_dir() {
-    assert_cli::Assert::main_binary()
-        .with_args(&["-c", "-X", "dir_substring", "src/test_dir2"])
-        .stdout()
-        .doesnt_contain("dir_substring")
-        .unwrap();
-}

tests/tests_symlinks.rs

@@ -1,8 +1,9 @@
+use assert_cmd::Command;
 use std::fs::File;
 use std::io::Write;
-use std::panic;
 use std::path::PathBuf;
-use std::process::Command;
+use std::str;
+
 use tempfile::Builder;
 use tempfile::TempDir;
 
@@ -16,6 +17,18 @@ 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() {
@@ -25,27 +38,24 @@ 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_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 link_name_s = link_it(link_name, file_path_s, true);
 
-    let c = format!(" ┌── {}", link_name_s);
-    let b = format!(" ├── {}", file_path_s);
+    let c = format!(" ├── {}", link_name_s);
+    let b = format!(" ┌── {}", file_path_s);
     let a = format!("─┴ {}", dir_s);
 
-    assert_cli::Assert::main_binary()
-        .with_args(&["-p", "-c", &dir_s])
-        .stdout()
-        .contains(a.as_str())
-        .stdout()
-        .contains(b.as_str())
-        .stdout()
-        .contains(c.as_str())
-        .unwrap();
+    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 = str::from_utf8(&output).unwrap();
+
+    assert!(output.contains(a.as_str()));
+    assert!(output.contains(b.as_str()));
+    assert!(output.contains(c.as_str()));
 }
 
 #[cfg_attr(target_os = "windows", ignore)]
@@ -57,37 +67,48 @@ pub fn test_hard_sym_link() {
     let file_path_s = file.to_str().unwrap();
 
     let link_name = dir.path().join("the_link");
-    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());
+    link_it(link_name, file_path_s, false);
 
-    let a = format!("─┴ {}", dir_s);
-    let b = format!(" ┌── {}", link_name_s);
-    let b2 = format!(" ┌── {}", file_path_s);
+    let file_output = format!(" ┌── {}", file_path_s);
+    let dirs_output = format!("─┴ {}", dir_s);
 
-    // Because this is a hard link the file and hard link look identical. Therefore
-    // we cannot guarantee which version will appear first.
-    let result = panic::catch_unwind(|| {
-        assert_cli::Assert::main_binary()
-            .with_args(&["-p", "-c", dir_s])
-            .stdout()
-            .contains(a.as_str())
-            .stdout()
-            .contains(b.as_str())
-            .unwrap();
-    });
-    if result.is_err() {
-        assert_cli::Assert::main_binary()
-            .with_args(&["-p", "-c", dir_s])
-            .stdout()
-            .contains(a.as_str())
-            .stdout()
-            .contains(b2.as_str())
-            .unwrap();
-    }
+    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;
+
+    // The link should not appear in the output because multiple inodes are now ordered
+    // then filtered.
+    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);
 }
 
 #[cfg_attr(target_os = "windows", ignore)]
@@ -97,23 +118,24 @@ 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_name.to_str().unwrap();
-
-    let c = Command::new("ln")
-        .arg("-s")
-        .arg(dir_s)
-        .arg(link_name_s)
-        .output();
-    assert!(c.is_ok());
+    let link_name_s = link_it(link_name, dir_s, true);
 
     let a = format!("─┬ {}", dir_s);
-    let b = format!("  └── {}", link_name_s);
+    let b = format!(" └── {}", link_name_s);
 
-    assert_cli::Assert::main_binary()
-        .with_args(&["-c", "-r", "-p", dir_s])
-        .stdout()
-        .contains(a.as_str())
-        .stdout()
-        .contains(b.as_str())
-        .unwrap();
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    let output = cmd
+        .arg("-p")
+        .arg("-c")
+        .arg("-r")
+        .arg("-s")
+        .arg("-w")
+        .arg("999")
+        .arg(dir_s)
+        .unwrap()
+        .stdout;
+    let output = str::from_utf8(&output).unwrap();
+
+    assert!(output.contains(a.as_str()));
+    assert!(output.contains(b.as_str()));
 }