Version: New version

Fix: Warn if configuring threads fails
User reported this unwrap could fail, so log an error instead of using a naked unwrap.
2025-12-05 20:40:11 -08:00 · 2022-08-25 10:18:18 +01:00 · 2022-08-25 08:59:15 +01:00 · 2022-08-24 08:59:30 +01:00 · 2022-08-24 08:55:00 +01:00 · 2022-08-23 12:26:08 +01:00
25 changed files with 1809 additions and 1052 deletions
--- a/.github/workflows/CICD.yml
+++ b/.github/workflows/CICD.yml
@@ -22,56 +22,56 @@ jobs:
          - { os: macos-latest }
          - { os: windows-latest }
    steps:
-    - uses: actions/checkout@v1
-    - name: Initialize workflow variables
-      id: vars
-      shell: bash
-      run: |
-        # 'windows-latest' `cargo fmt` is bugged for this project (see reasons @ GH:rust-lang/rustfmt #3324, #3590, #3688 ; waiting for repair)
-        JOB_DO_FORMAT_TESTING="true"
-        case ${{ matrix.job.os }} in windows-latest) unset JOB_DO_FORMAT_TESTING ;; esac;
-        echo set-output name=JOB_DO_FORMAT_TESTING::${JOB_DO_FORMAT_TESTING:-<empty>/false}
-        echo ::set-output name=JOB_DO_FORMAT_TESTING::${JOB_DO_FORMAT_TESTING}
-        # target-specific options
-        # * CARGO_FEATURES_OPTION
-        CARGO_FEATURES_OPTION='' ;
-        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
-        echo set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
-        echo ::set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
-    - name: Install `rust` toolchain
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: stable
-        override: true
-        profile: minimal # minimal component installation (ie, no documentation)
-        components: rustfmt, clippy
-    - name: "`fmt` testing"
-      if: steps.vars.outputs.JOB_DO_FORMAT_TESTING
-      uses: actions-rs/cargo@v1
-      with:
-        command: fmt
-        args: --all -- --check
-    - name: "`clippy` testing"
-      if: success() || failure() # run regardless of prior step ("`fmt` testing") success/failure
-      uses: actions-rs/cargo@v1
-      with:
-        command: clippy
-        args: ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -- -D warnings
+      - uses: actions/checkout@v1
+      - name: Initialize workflow variables
+        id: vars
+        shell: bash
+        run: |
+          # 'windows-latest' `cargo fmt` is bugged for this project (see reasons @ GH:rust-lang/rustfmt #3324, #3590, #3688 ; waiting for repair)
+          JOB_DO_FORMAT_TESTING="true"
+          case ${{ matrix.job.os }} in windows-latest) unset JOB_DO_FORMAT_TESTING ;; esac;
+          echo set-output name=JOB_DO_FORMAT_TESTING::${JOB_DO_FORMAT_TESTING:-<empty>/false}
+          echo ::set-output name=JOB_DO_FORMAT_TESTING::${JOB_DO_FORMAT_TESTING}
+          # target-specific options
+          # * CARGO_FEATURES_OPTION
+          CARGO_FEATURES_OPTION='' ;
+          if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
+          echo set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
+          echo ::set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
+      - name: Install `rust` toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+          profile: minimal # minimal component installation (ie, no documentation)
+          components: rustfmt, clippy
+      - name: "`fmt` testing"
+        if: steps.vars.outputs.JOB_DO_FORMAT_TESTING
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+      - name: "`clippy` testing"
+        if: success() || failure() # run regardless of prior step ("`fmt` testing") success/failure
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }} -- -D warnings

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

  build:
    name: Build
@@ -81,184 +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-20.04   , target: i686-unknown-linux-gnu      , use-cross: use-cross }
-          - { os: ubuntu-20.04   , target: i686-unknown-linux-musl     , use-cross: use-cross }
-          - { os: ubuntu-20.04   , target: x86_64-unknown-linux-gnu    , use-cross: use-cross }
-          - { os: ubuntu-20.04   , target: x86_64-unknown-linux-musl   , use-cross: use-cross }
-          - { os: ubuntu-18.04   , target: 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_FEATURES_OPTION
-        CARGO_FEATURES_OPTION='' ;
-        if [ -n "${{ matrix.job.features }}" ]; then CARGO_FEATURES_OPTION='--features "${{ matrix.job.features }}"' ; fi
-        echo set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
-        echo ::set-output name=CARGO_FEATURES_OPTION::${CARGO_FEATURES_OPTION}
-        # * CARGO_USE_CROSS (truthy)
-        CARGO_USE_CROSS='true' ; case '${{ matrix.job.use-cross }}' in ''|0|f|false|n|no) unset CARGO_USE_CROSS ;; esac;
-        echo set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS:-<empty>/false}
-        echo ::set-output name=CARGO_USE_CROSS::${CARGO_USE_CROSS}
-        # # * `arm` cannot be tested on ubuntu-* hosts (b/c testing is currently primarily done via comparison of target outputs with built-in outputs and the `arm` target is not executable on the host)
-        JOB_DO_TESTING="true"
-        case ${{ matrix.job.target }} in arm-*) unset JOB_DO_TESTING ;; esac;
-        echo set-output name=JOB_DO_TESTING::${JOB_DO_TESTING:-<empty>/false}
-        echo ::set-output name=JOB_DO_TESTING::${JOB_DO_TESTING}
-        # # * test only binary for arm-type targets
-        unset CARGO_TEST_OPTIONS
-        unset CARGO_TEST_OPTIONS ; case ${{ matrix.job.target }} in arm-*) CARGO_TEST_OPTIONS="--bin ${PROJECT_NAME}" ;; esac;
-        echo set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
-        echo ::set-output name=CARGO_TEST_OPTIONS::${CARGO_TEST_OPTIONS}
-        # * strip executable?
-        STRIP="strip" ; case ${{ matrix.job.target }} in arm-unknown-linux-gnueabihf) STRIP="arm-linux-gnueabihf-strip" ;; *-pc-windows-msvc) STRIP="" ;; esac;
-        echo set-output name=STRIP::${STRIP}
-        echo ::set-output name=STRIP::${STRIP}
-    - name: Create all needed build/work directories
-      shell: bash
-      run: |
-        mkdir -p '${{ steps.vars.outputs.STAGING }}'
-        mkdir -p '${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_BASENAME }}'
-    - name: rust toolchain ~ install
-      uses: actions-rs/toolchain@v1
-      with:
-        toolchain: ${{ steps.vars.outputs.TOOLCHAIN }}
-        target: ${{ matrix.job.target }}
-        override: true
-        profile: minimal # minimal component installation (ie, no documentation)
-    - name: Info
-      shell: bash
-      run: |
-        gcc --version || true
-        rustup -V
-        rustup toolchain list
-        rustup default
-        cargo -V
-        rustc -V
-    - name: Build
-      uses: actions-rs/cargo@v1
-      with:
-        use-cross: ${{ steps.vars.outputs.CARGO_USE_CROSS }}
-        command: build
-        args: --release --target=${{ matrix.job.target }} ${{ matrix.job.cargo-options }} ${{ steps.vars.outputs.CARGO_FEATURES_OPTION }}
-    - name: Install cargo-deb
-      uses: actions-rs/cargo@v1
-      with:
+      - 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: ${{ contains(matrix.job.target, 'musl') }}
-    - name: Build deb
-      uses: actions-rs/cargo@v1
-      with:
+        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: ${{ contains(matrix.job.target, '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: ${{ contains(matrix.job.target, '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:
-        data: |
-          ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_NAME }}
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        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:
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11,15 +11,6 @@ dependencies = [
 "memchr",
 ]

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

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

 [[package]]
 name = "bitflags"
@@ -68,9 +59,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

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

 [[package]]
 name = "clap"
-version = "2.33.3"
+version = "3.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
+checksum = "29e724a68d9319343bb3328c9cc2dfde263f4b3142ee1059a9980580171c954b"
 dependencies = [
- "ansi_term 0.11.0",
 "atty",
 "bitflags",
+ "clap_lex",
+ "indexmap",
 "strsim",
- "term_size",
+ "termcolor",
 "textwrap",
- "unicode-width",
- "vec_map",
+]
+
+[[package]]
+name = "clap_complete"
+version = "3.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4179da71abd56c26b54dd0c248cc081c1f43b0a1a7e8448e28e57a29baa993d"
+dependencies = [
+ "clap",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+dependencies = [
+ "os_str_bytes",
+]
+
+[[package]]
+name = "config-file"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df51e72c150781d2c7d4cbcb0b803277caaa80476786994a62961a8f1010dafb"
+dependencies = [
+ "serde",
+ "thiserror",
+ "toml",
 ]

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

 [[package]]
 name = "crossbeam-deque"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
+checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
 dependencies = [
 "cfg-if",
 "crossbeam-epoch",
@@ -122,25 +141,26 @@ dependencies = [

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

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

 [[package]]
@@ -149,6 +169,26 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"

+[[package]]
+name = "directories"
+version = "4.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f51c5d4ddabd36886dd3e1438cb358cdcb0d7c499cb99cb4ac2e38e18b5cb210"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
 [[package]]
 name = "doc-comment"
 version = "0.3.3"
@@ -157,14 +197,18 @@ checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"

 [[package]]
 name = "du-dust"
-version = "0.7.0"
+version = "0.8.3"
 dependencies = [
- "ansi_term 0.12.1",
+ "ansi_term",
 "assert_cmd",
 "clap",
+ "clap_complete",
+ "config-file",
+ "directories",
 "lscolors",
 "rayon",
 "regex",
+ "serde",
 "stfu8",
 "tempfile",
 "terminal_size",
@@ -175,21 +219,36 @@ dependencies = [

 [[package]]
 name = "either"
-version = "1.6.1"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
+checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
+
+[[package]]
+name = "fastrand"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
+dependencies = [
+ "instant",
+]

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

+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
@@ -200,10 +259,29 @@ dependencies = [
 ]

 [[package]]
-name = "itertools"
-version = "0.10.1"
+name = "indexmap"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69ddb889f9d0d08a67338271fa9b62996bc788c7796a5c18cf057420aaed5eaf"
+checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
 dependencies = [
 "either",
 ]
@@ -216,9 +294,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.101"
+version = "0.2.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cb00336871be5ed2c8ed44b60ae9959dc5b9f08539422ed43f09e34ecaeba21"
+checksum = "8371e4e5341c3a96db127eb2465ac681ced4c433e01dd0e938adbef26ba93ba5"

 [[package]]
 name = "lscolors"
@@ -226,45 +304,51 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d24b894c45c9da468621cdd615a5a79ee5e5523dd4f75c76ebc03d458940c16e"
 dependencies = [
- "ansi_term 0.12.1",
+ "ansi_term",
 ]

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

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

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

 [[package]]
-name = "ppv-lite86"
-version = "0.2.10"
+name = "once_cell"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
+checksum = "074864da206b4973b84eb91683020dbefd6a8c3f0f38e054d93954e891935e4e"
+
+[[package]]
+name = "os_str_bytes"
+version = "6.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ff7415e9ae3fff1225851df9e0d9e4e5479f947619774677a63572e55e80eff"

 [[package]]
 name = "predicates"
-version = "2.0.2"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c143348f141cc87aab5b950021bac6145d0e5ae754b0591de23244cee42c9308"
+checksum = "a5aab5be6e4732b473071984b3164dbbfb7a3674d30ea5ff44410b6bcd960c3c"
 dependencies = [
 "difflib",
 "itertools",
@@ -273,65 +357,43 @@ dependencies = [

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

 [[package]]
 name = "predicates-tree"
-version = "1.0.3"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7dd0fd014130206c9352efbdc92be592751b2b9274dff685348341082c6ea3d"
+checksum = "4d86de6de25020a36c6d3643a86d9a6a9f552107c0559c60ea03551b5e16c032"
 dependencies = [
 "predicates-core",
- "treeline",
+ "termtree",
 ]

 [[package]]
-name = "rand"
-version = "0.8.4"
+name = "proc-macro2"
+version = "1.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
+checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab"
 dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
- "rand_hc",
+ "unicode-ident",
 ]

 [[package]]
-name = "rand_chacha"
-version = "0.3.1"
+name = "quote"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
 dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rand_hc"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
-dependencies = [
- "rand_core",
+ "proc-macro2",
 ]

 [[package]]
 name = "rayon"
-version = "1.5.1"
+version = "1.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
+checksum = "bd99e5772ead8baa5215278c9b15bf92087709e9c1b2d1f97cdb5a183c933a7d"
 dependencies = [
 "autocfg",
 "crossbeam-deque",
@@ -341,31 +403,41 @@ dependencies = [

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

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

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

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

 [[package]]
 name = "remove_dir_all"
@@ -400,10 +472,30 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"

 [[package]]
-name = "stfu8"
-version = "0.2.4"
+name = "serde"
+version = "1.0.143"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bf70433e3300a3c395d06606a700cdf4205f4f14dbae2c6833127c6bb22db77"
+checksum = "53e8e5d5b70924f74ff5c6d64d9a5acd91422117c60f48c4e07855238a254553"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.143"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3d8e8de557aee63c26b85b947f5e59b690d0454c753f3adeb5cd7835ab88391"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "stfu8"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "019f0c664fd85d5a87dcfb62b40b691055392a35a6e59f4df83d4b770db7e876"
 dependencies = [
 "lazy_static",
 "regex",
@@ -411,32 +503,42 @@ dependencies = [

 [[package]]
 name = "strsim"
-version = "0.8.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "syn"
+version = "1.0.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]

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

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

 [[package]]
@@ -450,13 +552,35 @@ dependencies = [
 ]

 [[package]]
-name = "textwrap"
-version = "0.11.0"
+name = "termtree"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+checksum = "507e9898683b6c43a9aa55b64259b721b52ba226e0f3779137e50ad114a4c90b"
+
+[[package]]
+name = "textwrap"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+
+[[package]]
+name = "thiserror"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5f6586b7f764adc0231f4c79be7b920e766bb2f3e51b3661cdb263828f19994"
 dependencies = [
- "term_size",
- "unicode-width",
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12bafc5b54507e0149cdf1b145a5d80ab80a90bcd9275df43d4fff68460f6c21"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]

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

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

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

 [[package]]
 name = "wait-timeout"
@@ -494,9 +621,9 @@ dependencies = [

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

 [[package]]
 name = "winapi"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "du-dust"
 description = "A more intuitive version of du"
-version = "0.7.0"
+version = "0.8.3"
 authors = ["bootandy <bootandy@gmail.com>", "nebkor <code@ardent.nebcorp.com>"]
-edition = "2018"
+edition = "2021"
 readme = "README.md"

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

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

 [target.'cfg(windows)'.dependencies]
 winapi-util = "0.1"
@@ -39,6 +47,10 @@ winapi-util = "0.1"
 assert_cmd = "1"
 tempfile = "=3"

+[build-dependencies]
+clap = "3.2.17"
+clap_complete = "3.2.4"
+
 [[test]]
 name = "integration"
 path = "tests/tests.rs"
@@ -46,9 +58,21 @@ 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"],
+  [
+    "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
--- a/README.md
+++ b/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,27 +9,37 @@ du + rust = dust. Like du but more intuitive.
 Because I want an easy way to see where my disk is being used.

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

 ## Install

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

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

 #### 🍺 Homebrew (Mac OS)

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

 #### 🍺 Homebrew (Linux)

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

 #### Download

-* Download Linux/Mac binary from [Releases](https://github.com/bootandy/dust/releases)
-* 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

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

+```

 ## Alternatives

-* [NCDU](https://dev.yorhel.nl/ncdu)
-* [dutree](https://github.com/nachoparker/dutree)
-* [dua](https://github.com/Byron/dua-cli/)
-* [pdu](https://github.com/KSXGitHub/parallel-disk-usage)
-* [dirstat-rs](https://github.com/scullionw/dirstat-rs)
-* du -d 1 -h | sort -h
+- [NCDU](https://dev.yorhel.nl/ncdu)
+- [dutree](https://github.com/nachoparker/dutree)
+- [dua](https://github.com/Byron/dua-cli/)
+- [pdu](https://github.com/KSXGitHub/parallel-disk-usage)
+- [dirstat-rs](https://github.com/scullionw/dirstat-rs)
+- du -d 1 -h | sort -h

 Note: Apparent-size is calculated slightly differently in dust to gdu. In dust each hard link is counted as using file_length space. In gdu only the first entry is counted.
--- a/build.rs
+++ b/build.rs
@@ -0,0 +1,18 @@
+use clap_complete::{generate_to, shells::*};
+use std::io::Error;
+
+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)?;
+
+    Ok(())
+}
--- a/completions/_dust
+++ b/completions/_dust
@@ -0,0 +1,67 @@
+#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]' \
+'-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]' \
+'--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)-t[show only these file types]' \
+'(-d --depth)--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)]' \
+'*::inputs:' \
+&& ret=0
+}
+
+(( $+functions[_dust_commands] )) ||
+_dust_commands() {
+    local commands; commands=()
+    _describe -t commands 'dust commands' commands "$@"
+}
+
+_dust "$@"
--- a/completions/_dust.ps1
+++ b/completions/_dust.ps1
@@ -0,0 +1,69 @@
+
+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('-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('--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)')
+            break
+        }
+    })
+
+    $completions.Where{ $_.CompletionText -like "$wordToComplete*" } |
+        Sort-Object -Property ListItemText
+}
--- a/completions/dust.bash
+++ b/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 -x -s -r -c -b -z -f -i -v -e -t -w -H --help --version --depth --number-of-lines --full-paths --ignore-directory --limit-filesystem --apparent-size --reverse --no-colors --no-percent-bars --min-size --skip-total --filecount --ignore_hidden --invert-filter --filter --file_types --terminal_width --si <inputs>..."
+            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
+                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+                return 0
+            fi
+            case "${prev}" in
+                --depth)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                -d)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                --number-of-lines)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                -n)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                --ignore-directory)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                -X)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                --min-size)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                -z)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                --invert-filter)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                -v)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                --filter)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                -e)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                --terminal_width)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                -w)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                *)
+                    COMPREPLY=()
+                    ;;
+            esac
+            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
+            return 0
+            ;;
+    esac
+}
+
+complete -F _dust -o bashdefault -o default dust
--- a/completions/dust.elv
+++ b/completions/dust.elv
@@ -0,0 +1,63 @@
+
+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 -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 --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)'
+        }
+    ]
+    $completions[$command]
+}
--- a/completions/dust.fish
+++ b/completions/dust.fish
@@ -0,0 +1,20 @@
+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 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 -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)'
--- a/config/config.toml
+++ b/config/config.toml
@@ -0,0 +1,13 @@
+# Sample Config file, works with toml and yaml
+# Place in either:
+#   ~/.config/dust/config.toml
+#   ~/.dust.toml
+
+reverse=true
+display-full-paths=true
+display-apparent-size=true
+no-colors=true
+no-bars=true
+skip-total=true
+ignore-hidden=true
+iso=true
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -0,0 +1,135 @@
+use clap::{Arg, Command};
+
+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("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("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")
+                .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("inputs").multiple_occurrences(true).default_value("."))
+}
--- a/src/config.rs
+++ b/src/config.rs
@@ -0,0 +1,148 @@
+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 ignore_hidden: Option<bool>,
+    pub iso: Option<bool>,
+    pub min_size: Option<String>,
+}
+
+impl Config {
+    pub fn get_no_colors(&self, options: &ArgMatches) -> bool {
+        Some(true) == self.no_colors || options.is_present("no_colors")
+    }
+    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 {
+        Some(true) == self.display_full_paths || options.is_present("display_full_paths")
+    }
+    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_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
+        }
+    }
+}
+
+fn convert_min_size(input: &str, iso: bool) -> Option<usize> {
+    let chars_as_vec: Vec<char> = input.chars().collect();
+    match chars_as_vec.split_last() {
+        Some((last, start)) => {
+            let mut starts: String = start.iter().collect::<String>();
+
+            for (i, u) in UNITS.iter().rev().enumerate() {
+                if Some(*u) == last.to_uppercase().next() {
+                    return match starts.parse::<usize>() {
+                        Ok(pure) => {
+                            let num: usize = if iso { 1000 } else { 1024 };
+                            let marker = pure * num.pow((i + 1) as u32);
+                            Some(marker)
+                        }
+                        Err(_) => {
+                            eprintln!("Ignoring invalid min-size: {}", input);
+                            None
+                        }
+                    };
+                }
+            }
+            starts.push(*last);
+            starts
+                .parse()
+                .map_err(|_| {
+                    eprintln!("Ignoring invalid min-size: {}", input);
+                })
+                .ok()
+        }
+        None => None,
+    }
+}
+
+fn get_config_locations(base: &Path) -> Vec<PathBuf> {
+    vec![
+        base.join(".dust.toml"),
+        base.join(".config").join("dust").join("config.toml"),
+    ]
+}
+
+pub fn get_config() -> Config {
+    if let Some(home) = directories::BaseDirs::new() {
+        for path in get_config_locations(home.home_dir()) {
+            if path.exists() {
+                if let Ok(config) = Config::from_config_file(path) {
+                    return config;
+                }
+            }
+        }
+    }
+    Config {
+        ..Default::default()
+    }
+}
+
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+
+    #[test]
+    fn test_conversion() {
+        assert_eq!(convert_min_size("55", false), Some(55));
+        assert_eq!(convert_min_size("12344321", false), Some(12344321));
+        assert_eq!(convert_min_size("95RUBBISH", false), None);
+        assert_eq!(convert_min_size("10K", false), Some(10 * 1024));
+        assert_eq!(convert_min_size("10M", false), Some(10 * 1024usize.pow(2)));
+        assert_eq!(convert_min_size("10M", true), Some(10 * 1000usize.pow(2)));
+        assert_eq!(convert_min_size("2G", false), Some(2 * 1024usize.pow(3)));
+    }
+
+    #[test]
+    fn test_min_size_from_config_applied_or_overridden() {
+        let c = Config {
+            min_size: Some("1K".to_owned()),
+            ..Default::default()
+        };
+        assert_eq!(c._get_min_size(None, false), Some(1024));
+        assert_eq!(c._get_min_size(Some("2K"), false), Some(2048));
+
+        assert_eq!(c._get_min_size(None, true), Some(1000));
+        assert_eq!(c._get_min_size(Some("2K"), true), Some(2000));
+    }
+}
--- a/src/dir_walker.rs
+++ b/src/dir_walker.rs
@@ -18,10 +18,10 @@ use std::fs::DirEntry;

 use crate::platform::get_metadata;

-pub struct WalkData {
+pub struct WalkData<'a> {
    pub ignore_directories: HashSet<PathBuf>,
-    pub filter_regex: Option<Regex>,
-    pub invert_filter_regex: Option<Regex>,
+    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,
@@ -34,14 +34,11 @@ pub fn walk_it(dirs: HashSet<PathBuf>, walk_data: WalkData) -> (Vec<Node>, bool)
    let top_level_nodes: Vec<_> = dirs
        .into_iter()
        .filter_map(|d| {
-            let n = walk(d, &permissions_flag, &walk_data);
-            match n {
-                Some(n) => {
-                    let mut inodes: HashSet<(u64, u64)> = HashSet::new();
-                    clean_inodes(n, &mut inodes, walk_data.use_apparent_size)
-                }
-                None => None,
-            }
+            clean_inodes(
+                walk(d, &permissions_flag, &walk_data, 0)?,
+                &mut HashSet::new(),
+                walk_data.use_apparent_size,
+            )
        })
        .collect();
    (top_level_nodes, permissions_flag.into_inner())
@@ -55,25 +52,41 @@ fn clean_inodes(
 ) -> Option<Node> {
    if !use_apparent_size {
        if let Some(id) = x.inode_device {
-            if inodes.contains(&id) {
+            if !inodes.insert(id) {
                return None;
            }
-            inodes.insert(id);
        }
    }

-    let new_children: Vec<_> = x
-        .children
+    // 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();

-    return Some(Node {
+    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 {
@@ -90,17 +103,17 @@ fn ignore_file(entry: &DirEntry, walk_data: &WalkData) -> bool {
        }
    }

-    // Keeping `walk_data.filter_regex.is_some()` is important for performance reasons, it stops unnecessary work
-    if walk_data.filter_regex.is_some()
+    // 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())
+        && is_filtered_out_due_to_regex(walk_data.filter_regex, &entry.path())
    {
        return true;
    }

-    if walk_data.invert_filter_regex.is_some()
+    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())
+        && is_filtered_out_due_to_invert_regex(walk_data.invert_filter_regex, &entry.path())
    {
        return true;
    }
@@ -108,36 +121,43 @@ fn ignore_file(entry: &DirEntry, walk_data: &WalkData) -> bool {
    (is_dot_file && walk_data.ignore_hidden) || is_ignored_path
 }

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

-    if let Ok(entries) = fs::read_dir(dir.clone()) {
+    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 parallelise as well giving a 3X performance drop
+                    // rayon doesn't parallelize as well giving a 3X performance drop
                    // hence we unravel the recursion a bit

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

                    if !ignore_file(entry, walk_data) {
                        if let Ok(data) = entry.file_type() {
-                            if data.is_dir() && !data.is_symlink() {
-                                return walk(entry.path(), permissions_flag, walk_data);
-                            }
-                            return build_node(
-                                entry.path(),
-                                vec![],
-                                &walk_data.filter_regex,
-                                &walk_data.invert_filter_regex,
-                                walk_data.use_apparent_size,
-                                data.is_symlink(),
-                                data.is_file(),
-                                walk_data.by_filecount,
-                            );
+                            return if data.is_dir() && !data.is_symlink() {
+                                walk(entry.path(), permissions_flag, walk_data, depth + 1)
+                            } else {
+                                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,
+                                )
+                            };
                        }
                    }
                } else {
@@ -147,17 +167,21 @@ fn walk(dir: PathBuf, permissions_flag: &AtomicBool, walk_data: &WalkData) -> Op
            })
            .collect();
    } else {
-        permissions_flag.store(true, atomic::Ordering::Relaxed);
+        // Handle edge case where dust is called with a file instead of a directory
+        if !dir.exists() {
+            permissions_flag.store(true, atomic::Ordering::Relaxed);
+        }
    }
    build_node(
        dir,
        children,
-        &walk_data.filter_regex,
-        &walk_data.invert_filter_regex,
+        walk_data.filter_regex,
+        walk_data.invert_filter_regex,
        walk_data.use_apparent_size,
        false,
        false,
        walk_data.by_filecount,
+        depth,
    )
 }

@@ -172,28 +196,31 @@ mod tests {
            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!(clean_inodes(n.clone(), &mut inodes, false) == Some(n.clone()));
+        assert_eq!(clean_inodes(n.clone(), &mut inodes, false), Some(n.clone()));

        // Second time is a duplicate - we ignore it
-        assert!(clean_inodes(n.clone(), &mut inodes, false) == None);
+        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!(clean_inodes(n.clone(), &mut inodes, true) == Some(n.clone()));
-        assert!(clean_inodes(n.clone(), &mut inodes, true) == Some(n.clone()));
+        assert_eq!(clean_inodes(n.clone(), &mut inodes, true), Some(n.clone()));
+        assert_eq!(clean_inodes(n.clone(), &mut inodes, true), Some(n.clone()));
    }
 }
--- a/src/display.rs
+++ b/src/display.rs
@@ -1,8 +1,6 @@
-extern crate ansi_term;
-
 use crate::display_node::DisplayNode;

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

 use unicode_width::UnicodeWidthStr;
@@ -16,7 +14,7 @@ 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] = ['█', '▓', '▒', '░', ' '];

 pub struct DisplayData {
@@ -28,6 +26,7 @@ pub struct DisplayData {
    pub base_size: u64,
    pub longest_string_length: usize,
    pub ls_colors: LsColors,
+    pub iso: bool,
 }

 impl DisplayData {
@@ -110,35 +109,45 @@ pub fn draw_it(
    use_full_path: bool,
    is_reversed: bool,
    no_colors: bool,
-    no_percents: bool,
+    no_percent_bars: bool,
    terminal_width: usize,
    by_filecount: bool,
-    option_root_node: Option<DisplayNode>,
+    root_node: &DisplayNode,
+    iso: bool,
+    skip_total: bool,
 ) {
-    if option_root_node.is_none() {
-        return;
-    }
-    let root_node = option_root_node.unwrap();
+    let biggest = match skip_total {
+        false => root_node,
+        true => root_node
+            .get_children_from_node(false)
+            .next()
+            .unwrap_or(root_node),
+    };

    let num_chars_needed_on_left_most = if by_filecount {
-        let max_size = root_node.size;
+        let max_size = biggest.size;
        max_size.separate_with_commas().chars().count()
    } else {
-        5 // Under normal usage we need 5 chars to display the size of a directory
+        find_biggest_size_str(root_node, iso)
    };

-    let terminal_width = terminal_width - 9 - num_chars_needed_on_left_most;
+    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, terminal_width, !use_full_path);
+        find_longest_dir_name(root_node, num_indent_chars, allowed_width, !use_full_path);

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

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

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

 fn find_longest_dir_name(
@@ -177,26 +207,20 @@ fn find_longest_dir_name(
        .fold(longest, max)
 }

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

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

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

    let dd = DrawData {
-        indent: clean_indentation_string(&*indent),
+        indent: clean_indentation_string(&indent),
        percent_bar: bar_text,
        display_data: draw_data.display_data,
    };
@@ -257,7 +281,10 @@ fn pad_or_trim_filename(node: &DisplayNode, indent: &str, display_data: &Display
    let indent_and_name = format!("{} {}", indent, name);
    let width = UnicodeWidthStr::width(&*indent_and_name);

-    assert!(display_data.longest_string_length >= width);
+    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
@@ -265,15 +292,19 @@ fn pad_or_trim_filename(node: &DisplayNode, indent: &str, display_data: &Display
            .repeat(display_data.longest_string_length - width)
            .as_str();

-    maybe_trim_filename(name_and_padding, display_data)
+    name_and_padding
 }

-fn maybe_trim_filename(name_in: String, display_data: &DisplayData) -> String {
-    if UnicodeWidthStr::width(&*name_in) > display_data.longest_string_length {
-        let name = name_in
-            .chars()
-            .take(display_data.longest_string_length - 2)
-            .collect::<String>();
+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
@@ -306,20 +337,19 @@ fn get_name_percent(
        (percents, name_and_padding)
    } else {
        let n = get_printable_name(&node.name, display_data.short_paths);
-        let name = maybe_trim_filename(n, display_data);
+        let name = maybe_trim_filename(n, indent, display_data);
        ("".into(), name)
    }
 }

 fn get_pretty_size(node: &DisplayNode, is_biggest: bool, display_data: &DisplayData) -> String {
    let output = if display_data.by_filecount {
-        let size_as_str = node.size.separate_with_commas();
-        let spaces_to_add =
-            display_data.num_chars_needed_on_left_most - size_as_str.chars().count();
-        size_as_str + " ".repeat(spaces_to_add).as_str()
+        node.size.separate_with_commas()
    } else {
-        format!("{:>5}", human_readable_number(node.size))
+        human_readable_number(node.size, display_data.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.colors_on {
        format!("{}", Red.paint(output))
@@ -334,10 +364,10 @@ fn get_pretty_name(
    display_data: &DisplayData,
 ) -> String {
    if display_data.colors_on {
-        let meta_result = fs::metadata(node.name.clone());
+        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();
@@ -347,9 +377,10 @@ fn get_pretty_name(
    }
 }

-fn human_readable_number(size: u64) -> String {
+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);
@@ -358,7 +389,7 @@ fn human_readable_number(size: u64) -> String {
            }
        }
    }
-    return format!("{}B", size);
+    format!("{}B", size)
 }

 mod tests {
@@ -378,6 +409,7 @@ mod tests {
            base_size: 1,
            longest_string_length,
            ls_colors: LsColors::from_env().unwrap_or_default(),
+            iso: false,
        }
    }

@@ -397,7 +429,7 @@ mod tests {
            indent,
            percent_bar,
            is_biggest,
-            &get_fake_display_data(6),
+            &get_fake_display_data(20),
        );
        assert_eq!(s, " 4.0K ┌─┴ short");
    }
@@ -418,21 +450,27 @@ mod tests {
        let s = format_string(&n, indent, percent_bar, is_biggest, &dd);
        assert_eq!(
            s,
-            " 4.0K ┌─┴ very_long_name_longer_than_the_eighty_character_limit_very_lon.."
+            " 4.0K ┌─┴ very_long_name_longer_than_the_eighty_character_limit_very_.."
        );
    }

    #[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"
+        );
    }
 }
--- a/src/display_node.rs
+++ b/src/display_node.rs
@@ -1,46 +1,24 @@
-use std::cmp::Ordering;
 use std::path::PathBuf;

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

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

-    pub fn get_children_from_node(&self, is_reversed: bool) -> impl Iterator<Item = DisplayNode> {
+    pub fn get_children_from_node(&self, is_reversed: bool) -> impl Iterator<Item = &DisplayNode> {
        // we box to avoid the clippy lint warning
-        let out: Box<dyn Iterator<Item = DisplayNode>> = if is_reversed {
-            Box::new(self.children.clone().into_iter().rev())
+        let out: Box<dyn Iterator<Item = &DisplayNode>> = if is_reversed {
+            Box::new(self.children.iter().rev())
        } else {
-            Box::new(self.children.clone().into_iter())
+            Box::new(self.children.iter())
        };
        out
    }
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -1,22 +1,15 @@
 use crate::display_node::DisplayNode;
 use crate::node::Node;
 use std::collections::BinaryHeap;
-use std::collections::HashMap;
 use std::collections::HashSet;
+use std::path::Path;
 use std::path::PathBuf;

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

-    allowed_nodes.insert(&root.name);
-    heap = add_children(using_a_filter, &root, heap);
+    allowed_nodes.insert(root.name.as_path());
+    heap = add_children(using_a_filter, min_size, &root, depth, heap);

    for _ in number_top_level_nodes..n {
        let line = heap.pop();
        match line {
            Some(line) => {
-                allowed_nodes.insert(&line.name);
-                heap = add_children(using_a_filter, line, heap);
+                allowed_nodes.insert(line.name.as_path());
+                heap = add_children(using_a_filter, min_size, line, depth, heap);
            }
            None => break,
        }
@@ -45,130 +38,50 @@ pub fn get_biggest(
    recursive_rebuilder(&allowed_nodes, &root)
 }

-pub fn get_all_file_types(top_level_nodes: Vec<Node>, n: usize) -> Option<DisplayNode> {
-    let mut map: HashMap<String, DisplayNode> = HashMap::new();
-    build_by_all_file_types(top_level_nodes, &mut map);
-    let mut by_types: Vec<DisplayNode> = map.into_iter().map(|(_k, v)| v).collect();
-    by_types.sort();
-    by_types.reverse();
-
-    let displayed = if by_types.len() <= n {
-        by_types
-    } else {
-        let (displayed, rest) = by_types.split_at(if n > 1 { n - 1 } else { 1 });
-        let remaining = DisplayNode {
-            name: PathBuf::from("(others)"),
-            size: rest.iter().map(|a| a.size).sum(),
-            children: vec![],
-        };
-
-        let mut displayed = displayed.to_vec();
-        displayed.push(remaining);
-        displayed
-    };
-
-    let result = DisplayNode {
-        name: PathBuf::from("(total)"),
-        size: displayed.iter().map(|a| a.size).sum(),
-        children: displayed,
-    };
-    Some(result)
-}
-
 fn add_children<'a>(
    using_a_filter: bool,
-    line: &'a Node,
+    min_size: Option<usize>,
+    file_or_folder: &'a Node,
+    depth: usize,
    mut heap: BinaryHeap<&'a Node>,
 ) -> BinaryHeap<&'a Node> {
-    if using_a_filter {
-        line.children.iter().for_each(|c| {
-            if c.name.is_file() || c.size > 0 {
-                heap.push(c)
-            }
-        });
-    } else {
-        line.children.iter().for_each(|c| heap.push(c));
+    if depth > file_or_folder.depth {
+        heap.extend(file_or_folder.children.iter().filter(|c| match min_size {
+            Some(ms) => c.size > ms as u64,
+            None => !using_a_filter || c.name.is_file() || c.size > 0,
+        }))
    }
    heap
 }

-fn build_by_all_file_types(top_level_nodes: Vec<Node>, counter: &mut HashMap<String, DisplayNode>) {
-    for node in top_level_nodes {
-        if node.name.is_file() {
-            let ext = node.name.extension();
-            let key: String = match ext {
-                Some(e) => ".".to_string() + &e.to_string_lossy(),
-                None => "(no extension)".into(),
-            };
-            let mut display_node = counter.entry(key.clone()).or_insert(DisplayNode {
-                name: PathBuf::from(key),
-                size: 0,
-                children: vec![],
-            });
-            display_node.size += node.size;
-        }
-        build_by_all_file_types(node.children, counter)
-    }
-}
-
-fn build_by_depth(node: &Node, depth: usize) -> DisplayNode {
-    let new_children = {
-        if depth == 0 {
-            vec![]
-        } else {
-            let mut new_children: Vec<_> = node
-                .children
-                .iter()
-                .map(|c| build_by_depth(c, depth - 1))
-                .collect();
-            new_children.sort();
-            new_children.reverse();
-            new_children
-        }
-    };
-
-    DisplayNode {
-        name: node.name.clone(),
-        size: node.size,
-        children: new_children,
-    }
-}
-
 fn get_new_root(top_level_nodes: Vec<Node>) -> Node {
-    if top_level_nodes.len() > 1 {
-        let total_size = top_level_nodes.iter().map(|node| node.size).sum();
+    if top_level_nodes.len() != 1 {
+        let size = top_level_nodes.iter().map(|node| node.size).sum();
        Node {
            name: PathBuf::from("(total)"),
-            size: total_size,
+            size,
            children: top_level_nodes,
            inode_device: None,
+            depth: 0,
        }
    } else {
        top_level_nodes.into_iter().next().unwrap()
    }
 }

-fn recursive_rebuilder<'a>(
-    allowed_nodes: &'a HashSet<&PathBuf>,
-    current: &Node,
-) -> Option<DisplayNode> {
+fn recursive_rebuilder(allowed_nodes: &HashSet<&Path>, current: &Node) -> Option<DisplayNode> {
    let mut new_children: Vec<_> = current
        .children
        .iter()
-        .filter_map(|c| {
-            if allowed_nodes.contains(&c.name) {
-                recursive_rebuilder(allowed_nodes, c)
-            } else {
-                None
-            }
-        })
+        .filter(|c| allowed_nodes.contains(c.name.as_path()))
+        .filter_map(|c| recursive_rebuilder(allowed_nodes, c))
        .collect();
-    new_children.sort();
-    new_children.reverse();
-    let newnode = DisplayNode {
+
+    new_children.sort_by(|lhs, rhs| lhs.cmp(rhs).reverse());
+
+    Some(DisplayNode {
        name: current.name.clone(),
        size: current.size,
        children: new_children,
-    };
-    Some(newnode)
+    })
 }
--- a/src/filter_type.rs
+++ b/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)
+    }
+}
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,17 +1,24 @@
-#[macro_use]
-extern crate clap;
-extern crate rayon;
-extern crate regex;
-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 utils;

+use crate::cli::build_cli;
 use std::collections::HashSet;
 use std::process;

 use self::display::draw_it;
-use clap::{App, AppSettings, Arg};
-use dir_walker::walk_it;
-use dir_walker::WalkData;
-use filter::{get_all_file_types, get_biggest, get_by_depth};
+use clap::Values;
+use config::get_config;
+use dir_walker::{walk_it, WalkData};
+use filter::get_biggest;
+use filter_type::get_all_file_types;
 use regex::Regex;
 use std::cmp::max;
 use std::path::PathBuf;
@@ -19,204 +26,72 @@ use terminal_size::{terminal_size, Height, Width};
 use utils::get_filesystem_devices;
 use utils::simplify_dir_names;

-mod dir_walker;
-mod display;
-mod display_node;
-mod filter;
-mod node;
-mod platform;
-mod utils;
-
 static DEFAULT_NUMBER_OF_LINES: usize = 30;
 static DEFAULT_TERMINAL_WIDTH: usize = 80;

-#[cfg(windows)]
 fn init_color(no_color: bool) -> bool {
-    // 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!(
+    #[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
+                    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
 }

-#[cfg(windows)]
 fn get_width_of_terminal() -> usize {
-    // Windows CI runners detect a very low terminal width
-    if let Some((Width(w), Height(_h))) = terminal_size() {
-        max(w as usize, DEFAULT_TERMINAL_WIDTH)
-    } else {
-        DEFAULT_TERMINAL_WIDTH
-    }
+    // 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)
 }

-#[cfg(not(windows))]
-fn get_width_of_terminal() -> usize {
-    if let Some((Width(w), Height(_h))) = terminal_size() {
-        w as usize
-    } else {
-        DEFAULT_TERMINAL_WIDTH
-    }
-}
-
-fn get_regex_value(maybe_value: Option<&str>) -> Option<Regex> {
-    match maybe_value {
-        Some(v) => match Regex::new(v) {
-            Ok(r) => Some(r),
-            Err(e) => {
-                eprintln!("Ignoring bad value for regex {:?}", e);
-                process::exit(1);
-            }
-        },
-        None => None,
-    }
+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()
 }

 fn main() {
-    let default_height = get_height_of_terminal();
-    let def_num_str = default_height.to_string();
-
-    let options = App::new("Dust")
-        .about("Like du but more intuitive")
-        .version(crate_version!())
-        .setting(AppSettings::TrailingVarArg)
-        .arg(
-            Arg::with_name("depth")
-                .short("d")
-                .long("depth")
-                .help("Depth to show")
-                .takes_value(true)
-                .conflicts_with("number_of_lines"),
-        )
-        .arg(
-            Arg::with_name("number_of_lines")
-                .short("n")
-                .long("number-of-lines")
-                .help("Number of lines of output to show. This is Height, (but h is help)")
-                .takes_value(true)
-                .default_value(def_num_str.as_ref()),
-        )
-        .arg(
-            Arg::with_name("display_full_paths")
-                .short("p")
-                .long("full-paths")
-                .help("Subdirectories will not have their path shortened"),
-        )
-        .arg(
-            Arg::with_name("ignore_directory")
-                .short("X")
-                .long("ignore-directory")
-                .takes_value(true)
-                .number_of_values(1)
-                .multiple(true)
-                .help("Exclude any file or directory with this name"),
-        )
-        .arg(
-            Arg::with_name("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("by_filecount")
-                .short("f")
-                .long("filecount")
-                .help("Directory 'size' is number of child files/dirs not disk size"),
-        )
-        .arg(
-            Arg::with_name("ignore_hidden")
-                .short("i") // Do not use 'h' this is used by 'help'
-                .long("ignore_hidden") //TODO: fix change - -> _
-                .help("Do not display hidden files"),
-        )
-        .arg(
-            Arg::with_name("invert_filter")
-                .short("v")
-                .long("invert-filter")
-                .takes_value(true)
-                .number_of_values(1)
-                .multiple(true)
-                .conflicts_with("filter")
-                .conflicts_with("types")
-                .conflicts_with("depth")
-                .help("Exclude files matching this regex. To ignore png files type: -v \"\\.png$\" "),
-        )
-        .arg(
-            Arg::with_name("filter")
-                .short("e")
-                .long("filter")
-                .takes_value(true)
-                .number_of_values(1)
-                .multiple(true)
-                .conflicts_with("types")
-                .conflicts_with("depth")
-                .help("Only include files matching this regex. For png files type: -e \"\\.png$\" "),
-        )
-        .arg(
-            Arg::with_name("types")
-                .short("t")
-                .long("file_types")
-                .conflicts_with("depth")
-                .help("show only these file types"),
-        )
-        .arg(
-            Arg::with_name("width")
-                .short("w")
-                .long("terminal_width")
-                .takes_value(true)
-                .number_of_values(1)
-                .help("Specify width of output overriding the auto detection of terminal width"),
-        )
-        .arg(Arg::with_name("inputs").multiple(true).default_value("."))
-        .get_matches();
+    let options = build_cli().get_matches();
+    let config = get_config();

    let target_dirs = options
        .values_of("inputs")
@@ -225,93 +100,94 @@ fn main() {

    let summarize_file_types = options.is_present("types");

-    let maybe_filter = get_regex_value(options.value_of("filter"));
-    let maybe_invert_filter = get_regex_value(options.value_of("invert_filter"));
+    let filter_regexs = get_regex_value(options.values_of("filter"));
+    let invert_filter_regexs = get_regex_value(options.values_of("invert_filter"));

-    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 terminal_width = options
+        .value_of_t("width")
+        .unwrap_or_else(|_| get_width_of_terminal());
+
+    let depth = options.value_of_t("depth").unwrap_or(usize::MAX);
+
+    // If depth is set, then we set the default number_of_lines to be max
+    // instead of screen height
+    let default_height = if depth != usize::MAX {
+        usize::MAX
+    } else {
+        get_height_of_terminal()
    };

-    let terminal_width = match value_t!(options.value_of("width"), usize) {
-        Ok(v) => v,
-        Err(_) => get_width_of_terminal(),
-    };
+    let number_of_lines = options
+        .value_of("number_of_lines")
+        .and_then(|v| {
+            v.parse()
+                .map_err(|_| eprintln!("Ignoring bad value for number_of_lines"))
+                .ok()
+        })
+        .unwrap_or(default_height);

-    let depth = options.value_of("depth").and_then(|depth| {
-        depth
-            .parse::<usize>()
-            .map(|v| v + 1)
-            .map_err(|_| eprintln!("Ignoring bad value for depth"))
-            .ok()
-    });
+    let no_colors = init_color(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: Vec<PathBuf> = options
+    let ignore_directories = options
        .values_of("ignore_directory")
-        .map(|i| i.map(PathBuf::from).collect())
-        .unwrap_or_default();
+        .unwrap_or_default()
+        .map(PathBuf::from);

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

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

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

    let walk_data = WalkData {
        ignore_directories: ignored_full_path,
-        filter_regex: maybe_filter,
-        invert_filter_regex: maybe_invert_filter,
+        filter_regex: &filter_regexs,
+        invert_filter_regex: &invert_filter_regexs,
        allowed_filesystems,
-        use_apparent_size,
+        use_apparent_size: config.get_apparent_size(&options),
        by_filecount,
-        ignore_hidden,
+        ignore_hidden: config.get_ignore_hidden(&options),
    };
+    // Larger stack size to handle cases with lots of nested directories
+    rayon::ThreadPoolBuilder::new()
+        .stack_size(usize::pow(1024, 3))
+        .build_global()
+        .unwrap_or_else(|e| eprintln!("Warning: Could not configure threads {:?}", e));

+    let iso = config.get_iso(&options);
    let (top_level_nodes, has_errors) = walk_it(simplified_dirs, walk_data);

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

-    if options.is_present("filter") {
-        println!("Filtering by: {}", options.value_of("filter").unwrap());
-    }
    if has_errors {
        eprintln!("Did not have permissions for all directories");
    }
-    draw_it(
-        options.is_present("display_full_paths"),
-        !options.is_present("reverse"),
-        no_colors,
-        options.is_present("no_bars"),
-        terminal_width,
-        by_filecount,
-        tree,
-    );
+    if let Some(root_node) = tree {
+        draw_it(
+            config.get_full_paths(&options),
+            !config.get_reverse(&options),
+            no_colors,
+            config.get_no_bars(&options),
+            terminal_width,
+            by_filecount,
+            &root_node,
+            iso,
+            config.get_skip_total(&options),
+        )
+    }
 }
--- a/src/node.rs
+++ b/src/node.rs
@@ -12,48 +12,48 @@ pub struct Node {
    pub size: u64,
    pub children: Vec<Node>,
    pub inode_device: Option<(u64, u64)>,
+    pub depth: usize,
 }

 #[allow(clippy::too_many_arguments)]
 pub fn build_node(
    dir: PathBuf,
    children: Vec<Node>,
-    filter_regex: &Option<Regex>,
-    invert_filter_regex: &Option<Regex>,
+    filter_regex: &[Regex],
+    invert_filter_regex: &[Regex],
    use_apparent_size: bool,
    is_symlink: bool,
    is_file: bool,
    by_filecount: bool,
+    depth: usize,
 ) -> Option<Node> {
-    match get_metadata(&dir, use_apparent_size) {
-        Some(data) => {
-            let inode_device = if is_symlink && !use_apparent_size {
-                None
-            } else {
-                data.1
-            };
+    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
-            };
+        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
+        };

-            Some(Node {
-                name: dir,
-                size,
-                children,
-                inode_device,
-            })
+        Node {
+            name: dir,
+            size,
+            children,
+            inode_device,
+            depth,
        }
-        None => None,
-    }
+    })
 }

 impl PartialEq for Node {
@@ -64,11 +64,10 @@ impl PartialEq for 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)
-        }
+        self.size
+            .cmp(&other.size)
+            .then_with(|| self.name.cmp(&other.name))
+            .then_with(|| self.children.cmp(&other.children))
    }
 }

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

 #[cfg(target_family = "unix")]
 fn get_block_size() -> u64 {
-    // All os specific implementations of 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
 }
@@ -105,17 +105,17 @@ pub fn get_metadata(d: &Path, _use_apparent_size: bool) -> Option<(u64, Option<(
    use std::os::windows::fs::MetadataExt;
    match d.metadata() {
        Ok(ref md) => {
-            const FILE_ATTRIBUTE_ARCHIVE: u32 = 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;
+            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))
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -7,11 +7,11 @@ 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());
-    let mut to_remove: Vec<PathBuf> = Vec::with_capacity(filenames.len());

    for t in filenames {
        let top_level_name = normalize_path(t);
        let mut can_add = true;
+        let mut to_remove: Vec<PathBuf> = Vec::new();

        for tt in top_level_names.iter() {
            if is_a_parent_of(&top_level_name, tt) {
@@ -20,9 +20,9 @@ pub fn simplify_dir_names<P: AsRef<Path>>(filenames: Vec<P>) -> HashSet<PathBuf>
                can_add = false;
            }
        }
-        to_remove.sort_unstable();
-        top_level_names.retain(|tr| to_remove.binary_search(tr).is_err());
-        to_remove.clear();
+        for r in to_remove {
+            top_level_names.remove(&r);
+        }
        if can_add {
            top_level_names.insert(top_level_name);
        }
@@ -35,14 +35,9 @@ pub fn get_filesystem_devices<'a, P: IntoIterator<Item = &'a PathBuf>>(paths: P)
    // Gets the device ids for the filesystems which are used by the argument paths
    paths
        .into_iter()
-        .filter_map(|p| {
-            let meta = get_metadata(p, false);
-
-            if let Some((_size, Some((_id, dev)))) = meta {
-                Some(dev)
-            } else {
-                None
-            }
+        .filter_map(|p| match get_metadata(p, false) {
+            Some((_size, Some((_id, dev)))) => Some(dev),
+            _ => None,
        })
        .collect()
 }
@@ -54,21 +49,23 @@ pub fn normalize_path<P: AsRef<Path>>(path: P) -> PathBuf {
    // 3. removing trailing extra separators and '.' ("current directory") path segments
    // * `Path.components()` does all the above work; ref: <https://doc.rust-lang.org/std/path/struct.Path.html#method.components>
    // 4. changing to os preferred separator (automatically done by recollecting components back into a PathBuf)
-    path.as_ref().components().collect::<PathBuf>()
+    path.as_ref().components().collect()
 }

-pub fn is_filtered_out_due_to_regex(filter_regex: &Option<Regex>, dir: &Path) -> bool {
-    match filter_regex {
-        Some(fr) => !fr.is_match(&dir.as_os_str().to_string_lossy()),
-        None => false,
+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: &Option<Regex>, dir: &Path) -> bool {
-    match filter_regex {
-        Some(fr) => fr.is_match(&dir.as_os_str().to_string_lossy()),
-        None => false,
-    }
+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 {
@@ -92,6 +89,7 @@ mod tests {
    fn test_simplify_dir_rm_subdir() {
        let mut correct = HashSet::new();
        correct.insert(["a", "b"].iter().collect::<PathBuf>());
+        assert_eq!(simplify_dir_names(vec!["a/b/c", "a/b", "a/b/d/f"]), correct);
        assert_eq!(simplify_dir_names(vec!["a/b", "a/b/c", "a/b/d/f"]), correct);
    }

--- a/tests/test_exact_output.rs
+++ b/tests/test_exact_output.rs
@@ -5,8 +5,6 @@ use std::sync::Once;

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

-mod tests_symlinks;
-
 /**
 * This file contains tests that verify the exact output of the command.
 * This output differs on Linux / Mac so the tests are harder to write and debug
@@ -19,23 +17,20 @@ mod tests_symlinks;
 /// 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 incase it is there and has incorrect data
+    // 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>();
-    match Command::new("rm")
+    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()
-    {
-        Ok(_) => {}
-        Err(_) => {}
-    };
-    match Command::new("cp").arg("-r").arg(dir).arg("/tmp/").ok() {
-        Ok(_) => {}
-        Err(err) => {
-            eprintln!("Error copying directory {:?}", err);
-        }
-    };
+        .map_err(|err| eprintln!("Error copying directory for test setup\n{:?}", err));
 }

 fn initialize() {
@@ -50,14 +45,14 @@ fn exact_output_test<T: AsRef<OsStr>>(valid_outputs: Vec<String>, command_args:
    initialize();

    let mut a = &mut Command::cargo_bin("dust").unwrap();
+
    for p in command_args {
        a = a.arg(p);
    }
-    let output: String = str::from_utf8(&a.unwrap().stdout).unwrap().into();

-    assert!(valid_outputs
-        .iter()
-        .fold(false, |sum, i| sum || output.contains(i)));
+    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
@@ -84,19 +79,19 @@ 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%
- "#
+  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%
+  0B     ┌── a_file    │                ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
+4.0K     ├── hello_file│                ░░░░░░░░░░░░░░░░█████████████████ │  33%
+8.0K   ┌─┴ many        │                █████████████████████████████████ │  67%
+ 12K ┌─┴ test_dir      │█████████████████████████████████████████████████ │ 100%
  "#
    .trim()
    .to_string();
@@ -113,25 +108,25 @@ pub fn test_main_long_paths() {

 fn main_output_long_paths() -> Vec<String> {
    let mac_and_some_linux = r#"
-   0B     ┌── /tmp/test_dir/many/a_file    │░░░░░░░░░░░░░░░░░░░░░░░░░░░░█ │   0%
- 4.0K     ├── /tmp/test_dir/many/hello_file│█████████████████████████████ │ 100%
- 4.0K   ┌─┴ /tmp/test_dir/many             │█████████████████████████████ │ 100%
- 4.0K ┌─┴ /tmp/test_dir                    │█████████████████████████████ │ 100%
+  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%
+  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 whos names are substrings of each other
+// 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() {
@@ -141,25 +136,25 @@ pub fn test_substring_of_names_and_long_names() {

 fn no_substring_of_names_output() -> Vec<String> {
    let ubuntu = "
-   0B   ┌── long_dir_name_what_a_very_long_dir_name_what_happens_when_this_g..
- 4.0K   ├── dir_name_clash
- 4.0K   │ ┌── hello
- 8.0K   ├─┴ dir
- 4.0K   │ ┌── hello
- 8.0K   ├─┴ dir_substring
-  24K ┌─┴ test_dir2
+  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_g..
- 4.0K   │ ┌── hello
- 4.0K   ├─┴ dir
- 4.0K   ├── dir_name_clash
- 4.0K   │ ┌── hello
- 4.0K   ├─┴ dir_substring
-  12K ┌─┴ test_dir2
+  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();
@@ -176,19 +171,38 @@ pub fn test_unicode_directories() {
 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%
+  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%
+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]
+}
--- a/tests/test_flags.rs
+++ b/tests/test_flags.rs
@@ -9,11 +9,15 @@ use std::str;
 */

 fn build_command<T: AsRef<OsStr>>(command_args: Vec<T>) -> String {
-    let mut a = &mut Command::cargo_bin("dust").unwrap();
+    let mut cmd = &mut Command::cargo_bin("dust").unwrap();
    for p in command_args {
-        a = a.arg(p);
+        cmd = cmd.arg(p);
    }
-    str::from_utf8(&a.unwrap().stdout).unwrap().into()
+    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
@@ -63,7 +67,7 @@ pub fn test_d_flag_works_and_still_recurses_down() {
    assert!(output.contains("4 ┌─┴ test_dir2"));
 }

-// Check against directories and files whos names are substrings of each other
+// 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/"]);
@@ -73,8 +77,8 @@ pub fn test_ignore_dir() {
 #[test]
 pub fn test_with_bad_param() {
    let mut cmd = Command::cargo_bin("dust").unwrap();
-    let stderr = cmd.arg("-").unwrap().stderr;
-    let stderr = str::from_utf8(&stderr).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"));
 }

@@ -101,22 +105,6 @@ pub fn test_number_of_files() {
    assert!(output.contains("2 ┌─┴ test_dir"));
 }

-#[cfg_attr(target_os = "windows", ignore)]
-#[test]
-pub fn test_apparent_size() {
-    // Check the '-s' Flag gives us byte sizes and that it doesn't round up to a block
-    let command_args = vec!["-c", "-s", "/tmp/test_dir"];
-    let output = build_command(command_args);
-
-    let apparent_size1 = "6B     ├── hello_file│";
-    let apparent_size2 = "0B     ┌── a_file";
-    assert!(output.contains(apparent_size1));
-    assert!(output.contains(apparent_size2));
-
-    let incorrect_apparent_size = "4.0K     ├── hello_file";
-    assert!(!output.contains(incorrect_apparent_size));
-}
-
 #[test]
 pub fn test_show_files_by_type() {
    // Check we can list files by type
@@ -129,18 +117,49 @@ pub fn test_show_files_by_type() {
 }

 #[test]
-pub fn test_show_files_by_regex() {
+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_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"]);
@@ -155,3 +174,22 @@ pub fn test_show_files_by_invert_regex() {
    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"));
+}
--- a/tests/tests_symlinks.rs
+++ b/tests/tests_symlinks.rs
@@ -1,41 +1,15 @@
 use assert_cmd::Command;
-use std::cmp::max;
 use std::fs::File;
 use std::io::Write;
 use std::path::PathBuf;
 use std::str;

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

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

-fn get_width_of_terminal() -> u16 {
-    if let Some((Width(w), Height(_h))) = terminal_size() {
-        max(w, 80)
-    } else {
-        80
-    }
-}
-
-// Mac test runners create tmp files with very long names, hence it may be shortened in the output
-fn get_file_name(name: String) -> String {
-    let terminal_plus_buffer = (get_width_of_terminal() - 14) as usize;
-    if UnicodeWidthStr::width(&*name) > terminal_plus_buffer {
-        let trimmed_name = name
-            .chars()
-            .take(terminal_plus_buffer - 2)
-            .collect::<String>();
-        trimmed_name + ".."
-    } else {
-        name
-    }
-}
-
 fn build_temp_file(dir: &TempDir) -> PathBuf {
    let file_path = dir.path().join("notes.txt");
    let mut file = File::create(&file_path).unwrap();
@@ -60,12 +34,16 @@ pub fn test_soft_sym_link() {
        .output();
    assert!(c.is_ok());

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

    let mut cmd = Command::cargo_bin("dust").unwrap();
-    let output = cmd.arg("-p").arg("-c").arg("-s").arg(dir_s).unwrap().stdout;
+    // 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();

@@ -90,18 +68,18 @@ pub fn test_hard_sym_link() {
        .output();
    assert!(c.is_ok());

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

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

-    // Because this is a hard link the file and hard link look identical. Therefore
-    // we cannot guarantee which version will appear first.
+    // 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(link_output.as_str()) || output.contains(file_output.as_str()));
+    assert!(output.contains(file_output.as_str()));
 }

 #[cfg_attr(target_os = "windows", ignore)]
@@ -121,7 +99,7 @@ pub fn test_recursive_sym_link() {
    assert!(c.is_ok());

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

    let mut cmd = Command::cargo_bin("dust").unwrap();
    let output = cmd
@@ -129,6 +107,7 @@ pub fn test_recursive_sym_link() {
        .arg("-c")
        .arg("-r")
        .arg("-s")
+        .arg("-w 999")
        .arg(dir_s)
        .unwrap()
        .stdout;
Author	SHA1	Message	Date
andy.boot	0d0206a5a5	Version: New version	2022-08-25 10:18:18 +01:00
andy.boot	dfce0eec66	Fix: Warn if configuring threads fails User reported this unwrap could fail, so log an error instead of using a naked unwrap.	2022-08-25 08:59:15 +01:00
Kian-Meng Ang	c148cd9044	Prettify md/yaml file Resolved via `prettier --write .`	2022-08-24 08:59:30 +01:00
Kian-Meng Ang	2893f73f47	Fix typos Found via `codespell -L crate`.	2022-08-24 08:55:00 +01:00
andy.boot	5103ebe0d8	Version: Increment version	2022-08-23 12:26:08 +01:00
andy.boot	40acc8f868	README: Update readme to include max-size	2022-08-23 11:47:18 +01:00
andy.boot	eebd9daf2a	Feature: Add error message on bad min-size Log to stderr if the min-size from either parameter or config is invalid	2022-08-23 11:47:18 +01:00
andy.boot	9bc1a6d625	Refactor: Tidy up use of UNITS: k,m,g,t	2022-08-23 11:47:18 +01:00
andy.boot	d6f9bb3c47	Feature: Add min-size parameter Add often requested feature. '--min-size 50000' will only include files above a size of 50kB	2022-08-23 11:47:18 +01:00
andy.boot	f70f4b7e12	CI: Only run against latest ubuntu builds Copying lsd's CI which only builds against latest ubuntu releases.	2022-08-23 09:30:01 +01:00
andy.boot	b9b2aee760	Cleanup: Clean previous commit. Dislike the idea of passing a string into build_cli. By removing a call to default_value we can side-step the problem. Downside is we lose the error log if a user provides a bad depth	2022-08-23 09:12:07 +01:00
Jedsek	f60184ecbb	Fix the hard code of max depth	2022-08-23 09:11:13 +01:00
Jedsek	81d52e6e3a	Support for completions	2022-08-23 09:11:13 +01:00
andy.boot	5980858b39	Feature: Config file Read flags for several params from config file. This was a popular requested feature (many people want to run with -r on by default).	2022-08-22 12:05:04 +01:00
andy.boot	ed6a8d0462	Revert tests Revert symlink tests to their old form - No mix of arg and args & a comment explaining why we need a large width.	2022-08-20 11:09:56 +01:00
andy.boot	4cef6aaa84	Refactor: init_color function Refactor function so windows & linux are forced to have same signature instead of 2 different functions	2022-08-20 11:09:56 +01:00
andy.boot	d477145694	Tests refactor: Neaten test	2022-08-20 11:09:56 +01:00
andy.boot	dc5b7b2c2e	Comment: Update comment text	2022-08-20 11:09:56 +01:00
andy.boot	cf5ebd76fe	Refactor: Reintroduce local variable	2022-08-20 11:09:56 +01:00
andy.boot	fc548919c5	Refactor: Move filter by file type to new file	2022-08-20 11:09:56 +01:00
andy.boot	4b4bca52d9	Rename variable Better name, this represents the percent bars just 'percent' is vague	2022-08-20 11:09:56 +01:00
andy.boot	2a9d545c3c	Style: Remove ColorState enum, revert init_color Booleans are simpler and easier to work with. Revert init_color to its earlier state as it is easier to understand	2022-08-20 11:09:56 +01:00
andy.boot	20cc5cf7e0	Clippy: Fix clippy	2022-08-20 11:09:56 +01:00
Nathan West	5fcc45efbe	Use correct error code type	2022-08-20 10:50:46 +01:00
Nathan West	282f6d314d	`get_new_root` no longer panics if there are 0 nodes	2022-08-20 10:50:46 +01:00
Nathan West	c36ca33fe9	Lots of code cleanup - Try to use iterator adapters and collect in various places, where possible. This especially benefits draw_it. - Try to use `.map` and other similar methods on Options and Results, where possible - Replaced nearly all clones with reference-based equivalents - Summarizing nodes by file extension is now much more efficient - PartialOrd and PartialEq implementations now agree - Replace #[cfg(...)] function definitions with simpler if cfg!(...) equivelents - Simplify CLI Values handling by taking advantage of Values::default - Various spelling corrections in comments - Add `ColorState` enum to replace bool, for clarity - Fix tests that break under some detected terminal widths when paths are long - Use sort_by instead of (sort, reverse) - Use new `ExtensionNode` struct internally to simplify extension aggregation code	2022-08-20 10:50:46 +01:00
andy.boot	34ba99af2a	Tests: Check stderr is empty in test_flags For each test_flag test using the build_command helper method, check that stderr is empty	2022-08-19 10:43:24 +01:00
andy.boot	2713445ad0	Fix: Permissions Stop incorrect reporting of "Did not have permissions" this would happen where dust is called with a file instead of a directory. https://github.com/bootandy/dust/issues/241 todo: add test	2022-08-19 10:43:24 +01:00
andy.boot	b62f35291d	Fix: Remove first space char Before we assumed 5 chars for printing the size of a node. This change allows us to check if we need 5 chars or if we can manage with 4 which may save us a character. (1023B = 5 chars, 1.2K = 4 chars) Note: Mac test runners create very long filenames in tmp directories. To fix this we must either 1) Tell the terminal it has a very wide width 2) Duplicate the code to reduce the size of the filename (add .. at the end). This commit changes from (2) to (1)	2022-08-19 10:41:59 +01:00
andy.boot	a7fbcb8156	Refactor: Simplify get_pretty_size Remove the constant '5' used in format. Now all paths use num_chars_needed_on_left_most instead.	2022-08-19 10:41:59 +01:00
andy.boot	a7120b949c	Tests: Add test to verify skip-total flag	2022-08-18 15:22:10 +01:00
andy.boot	812e1e3c53	Feature: Add skip-total flag Flag to not include the last line containing totals of the output tree	2022-08-18 15:22:10 +01:00
andy.boot	4eb3f29565	Tests: Predictable iteration order allows stricter Now files are iterated thru in a preditermined order we can tighten the boundaries of the test_hard_sym_link test. Link will not be displayed, only the file name	2022-08-18 13:39:01 +01:00
andy.boot	d64092d8a1	Fix: Predictable iteration order Sort the Node objects so that duplicate inodes appear in a predictable order. Include new sort_by_inode method because this is notably quicker than sorting by size & name as defined in the nodes.rs file.	2022-08-18 13:16:09 +01:00
andy.boot	77750c8149	Update README.md	2022-08-18 13:15:05 +01:00
andy.boot	b9386cd39e	Fix: Increase Stack size Low stack size could result in a stack overflow exception if traversing very highly nested directories. This makes core-dumps less likely but will not completely remove the risk example for creating directories: mkdir -p $(for i in {1..5000}; do echo -n "qwe/"; done) original issue: https://github.com/bootandy/dust/issues/197	2022-08-15 14:05:24 +01:00
andy.boot	17112b09cc	Clippy: Remove un-needed return	2022-08-15 12:26:47 +01:00
andy.boot	c5adff5348	Clippy: Remove un-needed return	2022-08-15 12:26:47 +01:00
somehowchris	ad2e52e211	perf: use lto, strip and codegen profile settings for perf opt	2022-08-15 11:56:46 +01:00
andy.boot	164bec71a3	Update libs	2022-07-14 09:42:45 +01:00
andy.boot	11b5c7227f	New Version	2022-07-14 08:53:45 +01:00
andy.boot	fc70f9ba30	Rename variable	2022-07-13 09:38:21 +01:00
andy.boot	a00d1f0719	Fix: Allow -n to be used with -d Allow -n for number_of_lines to be used with -d 'max depth' Remove depth specific functions, the job is now handled by the mainline Add depth as a field onto the Node object.	2022-07-13 09:38:21 +01:00
andy.boot	c4ea7815f8	Refactor: tweak utils function Refactor simplify_dir_names to make it more readable	2022-07-01 12:04:31 +01:00
dependabot[bot]	afc36a633f	Bump regex from 1.5.4 to 1.5.5 Bumps [regex](https://github.com/rust-lang/regex) from 1.5.4 to 1.5.5. - [Release notes](https://github.com/rust-lang/regex/releases) - [Changelog](https://github.com/rust-lang/regex/blob/master/CHANGELOG.md) - [Commits](https://github.com/rust-lang/regex/compare/1.5.4...1.5.5) --- updated-dependencies: - dependency-name: regex dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2022-06-07 09:00:43 +01:00
unknown	7275b273d4	Fix archive/directory check in platform.rs	2022-05-02 12:11:22 +01:00
andy.boot	a3e59f9c25	Update README.md	2022-03-05 22:02:09 +00:00
Adam Stephens	48bf656123	add aarch64 gnu and musl cross targets	2022-02-27 10:09:38 +00:00
andy.boot	fabb27908d	Increment version	2022-02-26 11:47:06 +00:00
andy.boot	52aeeebe1f	Improve help text	2022-02-26 11:47:06 +00:00
andy.boot	1e27288ec2	Fix test: Remove unwanted mod This line caused the test_symlinks files to be run twice.	2022-02-26 11:10:26 +00:00
andy.boot	9f4a5daee6	Update library: Clap Required several changes to main.rs as v3 had breaking changes.	2022-02-26 11:10:26 +00:00
andy.boot	27f0a015ef	Update cargo packages	2022-02-26 11:10:26 +00:00
andy.boot	20d89bef91	Neaten code	2022-02-26 09:58:47 +00:00
andy.boot	469e6d0a69	Fix: Bug: names may be shortened unnecessarily The code calculating the width of a row to use vs the width of the terminal wasn't quite right. If we had 2 long filepaths one at the top of the dir tree and one at the bottom the old code would shorten both equally. This doesn't make sense as the one at the shallowest part of the tree would have used less screen real estate and so should show a longer part of the filepath.	2022-02-26 09:58:47 +00:00
andy.boot	2d58609d54	Fix: Add assert for low terminal width If terminal is not wide enought to print text, then print an error message https://github.com/bootandy/dust/issues/204	2022-01-02 22:41:02 +00:00
andy.boot	109a0b90d4	Update help text: number_of_lines Remove note about 'height' and '-h being help' because it confused people. Add text to explain default height is terminal height - 10 https://github.com/bootandy/dust/issues/201	2022-01-02 22:41:02 +00:00
andy.boot	ab67c1a50e	Update help text: Add note for -c about watch Issue was raised about using dust with watch. The solution is to use watch --color dust or watch dust -c https://github.com/bootandy/dust/issues/205	2022-01-02 22:41:02 +00:00
Sourajyoti Basak	6a34b52d15	docs(readme): add pacstall installation method	2021-12-21 10:07:28 +00:00
Gustavobb	f708305190	Feature: Implement ISO output	2021-11-20 12:13:30 +00:00
andy.boot	2749f56b7a	Tests: Fix test on mac (hack) For some unknown reason mac takes offence to searching for 'test_dir_unicode'. 'test_dir_hidden' seems to work fine. This isn't a proper fix as I've just hacked round the problem. Ideally I'd need a mac user to do some investigation.	2021-11-20 12:05:48 +00:00
andy.boot	d983175189	Cleanup: Vec -> &[]. Remove println.	2021-10-24 14:05:14 +01:00
andy.boot	4b3dc3988d	Tests: Move test apparent size to exact_output Because apparent_size uses the test files created in /tmp it needs to be in the test_exact_output where those files are copied. Otherwise the files may not be there when the test is run.	2021-10-24 14:05:14 +01:00
andy.boot	fa4405b58b	Cleanup: Remove unused comment This was fixed a few commits ago	2021-10-24 14:05:14 +01:00
andy.boot	abb08f8e1a	Tests: Add tests for multi regex support	2021-10-24 14:05:14 +01:00
andy.boot	9f91d446c1	Feature/Bugfix: Allow multiple regexs to be used The -e and -v flags allow multiple values. Before values after the first were ignored. This change allows the user to specify multiple regexs and have them all applied.	2021-10-24 14:05:14 +01:00
andy.boot	1b07c3c4f3	Update README.md add note from https://github.com/bootandy/dust/issues/191	2021-10-24 09:33:02 +01:00
andy.boot	e55b917c96	Add .deb files to release procedure	2021-10-11 18:33:27 +01:00
andy.boot	0301c7a058	Increment version (skipped several due to build difficulties)	2021-09-19 13:50:10 +01:00
andy.boot	bbed8d7478	Revert "Fix ci: Github actions: Publish step" This reverts commit `5116c1c8a1`.	2021-09-19 13:50:10 +01:00