Fix: Only create large stack size if enough memory

Small boxes do not have enough memory to create a large stack Conversely we want a large stack size for large boxes with a very highly nested directory structure. Version: New version
Prettify md/yaml file
2025-12-05 20:40:11 -08:00 · 2022-08-29 17:39:39 +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 · 2022-08-23 11:47:18 +01:00
25 changed files with 1691 additions and 919 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,186 +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:
-        files: |
-          ${{ steps.vars.outputs.STAGING }}/${{ steps.vars.outputs.PKG_NAME }}
-          target/${{ matrix.job.target }}/debian/*.deb
+        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 }}
+        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
@@ -68,6 +68,12 @@ dependencies = [
 "regex-automata",
 ]

+[[package]]
+name = "cc"
+version = "1.0.73"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -76,25 +82,59 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

 [[package]]
 name = "clap"
-version = "3.1.2"
+version = "3.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5177fac1ab67102d8989464efd043c6ff44191b1557ec1ddd489b4f7e1447e77"
+checksum = "29e724a68d9319343bb3328c9cc2dfde263f4b3142ee1059a9980580171c954b"
 dependencies = [
 "atty",
 "bitflags",
+ "clap_lex",
 "indexmap",
- "lazy_static",
- "os_str_bytes",
 "strsim",
 "termcolor",
 "textwrap",
 ]

 [[package]]
-name = "crossbeam-channel"
-version = "0.5.2"
+name = "clap_complete"
+version = "3.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e54ea8bc3fb1ee042f5aace6e3c6e025d3874866da222930f70ce62aceba0bfa"
+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 = "core-foundation-sys"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
 dependencies = [
 "cfg-if",
 "crossbeam-utils",
@@ -102,9 +142,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",
@@ -113,25 +153,26 @@ dependencies = [

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

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

 [[package]]
@@ -140,6 +181,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"
@@ -148,15 +209,20 @@ checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"

 [[package]]
 name = "du-dust"
-version = "0.7.5"
+version = "0.8.3"
 dependencies = [
 "ansi_term",
 "assert_cmd",
 "clap",
+ "clap_complete",
+ "config-file",
+ "directories",
 "lscolors",
 "rayon",
 "regex",
+ "serde",
 "stfu8",
+ "sysinfo",
 "tempfile",
 "terminal_size",
 "thousands",
@@ -166,24 +232,35 @@ 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.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3fcf0cee53519c866c09b5de1f6c56ff9d647101f81c1964fa632e148896cdf"
+checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
 dependencies = [
 "instant",
 ]

 [[package]]
-name = "hashbrown"
-version = "0.11.2"
+name = "getrandom"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+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"
@@ -196,9 +273,9 @@ dependencies = [

 [[package]]
 name = "indexmap"
-version = "1.8.0"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282a6247722caba404c065016bbfa522806e51714c34f5dfc3e4a3a46fcb4223"
+checksum = "10a35a97730320ffe8e2d410b5d3b69279b98d2c14bdb8b70ea89ecf7888d41e"
 dependencies = [
 "autocfg",
 "hashbrown",
@@ -230,9 +307,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

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

 [[package]]
 name = "lscolors"
@@ -245,9 +322,9 @@ dependencies = [

 [[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"
@@ -258,6 +335,15 @@ dependencies = [
 "autocfg",
 ]

+[[package]]
+name = "ntapi"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28774a7fd2fbb4f0babd8237ce554b73af68021b5f695a3cebd6c59bac0980f"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "num_cpus"
 version = "1.13.1"
@@ -269,13 +355,16 @@ dependencies = [
 ]

 [[package]]
-name = "os_str_bytes"
-version = "6.0.0"
+name = "once_cell"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
-dependencies = [
- "memchr",
-]
+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"
@@ -305,10 +394,28 @@ dependencies = [
 ]

 [[package]]
-name = "rayon"
-version = "1.5.1"
+name = "proc-macro2"
+version = "1.0.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
+checksum = "0a2ca2c61bc9f3d74d2886294ab7b9853abd9c1ad903a3ac7815c58989bb7bab"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbe448f377a7d6961e30f5955f9b8d106c3f5e449d493ee1b125c1d43c2b5179"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rayon"
+version = "1.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd99e5772ead8baa5215278c9b15bf92087709e9c1b2d1f97cdb5a183c933a7d"
 dependencies = [
 "autocfg",
 "crossbeam-deque",
@@ -318,31 +425,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",
@@ -357,9 +474,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"
@@ -376,6 +493,26 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"

+[[package]]
+name = "serde"
+version = "1.0.143"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e8e5d5b70924f74ff5c6d64d9a5acd91422117c60f48c4e07855238a254553"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.143"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3d8e8de557aee63c26b85b947f5e59b690d0454c753f3adeb5cd7835ab88391"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "stfu8"
 version = "0.2.5"
@@ -392,6 +529,34 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"

+[[package]]
+name = "syn"
+version = "1.0.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58dbef6ec655055e20b86b15a8cc6d439cca19b667537ac6a1369572d151ab13"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sysinfo"
+version = "0.15.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de94457a09609f33fec5e7fceaf907488967c6c7c75d64da6a7ce6ffdb8b5abd"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "core-foundation-sys",
+ "doc-comment",
+ "libc",
+ "ntapi",
+ "once_cell",
+ "rayon",
+ "winapi",
+]
+
 [[package]]
 name = "tempfile"
 version = "3.3.0"
@@ -408,9 +573,9 @@ dependencies = [

 [[package]]
 name = "termcolor"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
+checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
 dependencies = [
 "winapi-util",
 ]
@@ -433,9 +598,29 @@ checksum = "507e9898683b6c43a9aa55b64259b721b52ba226e0f3779137e50ad114a4c90b"

 [[package]]
 name = "textwrap"
-version = "0.14.2"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0066c8d12af8b5acd21e00547c3797fde4e8677254a7ee429176ccebbe93dd80"
+checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"
+
+[[package]]
+name = "thiserror"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5f6586b7f764adc0231f4c79be7b920e766bb2f3e51b3661cdb263828f19994"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12bafc5b54507e0149cdf1b145a5d80ab80a90bcd9275df43d4fff68460f6c21"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]

 [[package]]
 name = "thousands"
@@ -443,6 +628,21 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3bf63baf9f5039dadc247375c29eb13706706cfde997d0330d05aa63a77d8820"

+[[package]]
+name = "toml"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4f5b37a154999a8f3f98cc23a628d850e154479cd94decf3414696e12e31aaf"
+
 [[package]]
 name = "unicode-width"
 version = "0.1.9"
@@ -458,6 +658,12 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "du-dust"
 description = "A more intuitive version of du"
-version = "0.7.5"
+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,25 @@ 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 = "=3", features=["cargo"] }
+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"
+sysinfo = "0.15"

 [target.'cfg(windows)'.dependencies]
 winapi-util = "0.1"
@@ -39,6 +48,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 +59,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,35 +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`
+- `pacstall -I dust-bin`

 #### Windows:
-* Windows GNU version - works
-* Windows MSVC - requires: VCRUNTIME140.dll
+
+- 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

@@ -56,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
@@ -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 {
@@ -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,7 +167,10 @@ 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,
@@ -158,6 +181,7 @@ fn walk(dir: PathBuf, permissions_flag: &AtomicBool, walk_data: &WalkData) -> Op
        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 {
@@ -111,17 +109,26 @@ 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,
-    root_node: DisplayNode,
+    root_node: &DisplayNode,
    iso: bool,
+    skip_total: bool,
 ) {
+    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)
    };

    assert!(
@@ -132,15 +139,15 @@ pub fn draw_it(
    let allowed_width = terminal_width - num_chars_needed_on_left_most - 2;
    let num_indent_chars = 3;
    let longest_string_length =
-        find_longest_dir_name(&root_node, num_indent_chars, allowed_width, !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 + 7 >= allowed_width as usize {
+    let max_bar_length = if no_percent_bars || longest_string_length + 7 >= allowed_width as usize {
        0
    } else {
        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,
@@ -148,7 +155,7 @@ 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,
@@ -158,7 +165,27 @@ pub fn draw_it(
        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(
@@ -180,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,
    };
@@ -323,13 +344,12 @@ fn get_name_percent(

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

 mod tests {
--- 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,16 +1,26 @@
-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 sysinfo::{System, SystemExt};

 use self::display::draw_it;
-use clap::{crate_version, Arg};
-use clap::{Command, Values};
+use clap::Values;
+use config::get_config;
 use dir_walker::{walk_it, WalkData};
-use filter::{get_all_file_types, get_biggest, get_by_depth};
+use filter::get_biggest;
+use filter_type::get_all_file_types;
+use rayon::ThreadPoolBuildError;
 use regex::Regex;
 use std::cmp::max;
 use std::path::PathBuf;
@@ -18,213 +28,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
-            }
-        }
-    }
-}
-
-#[cfg(not(windows))]
-fn init_color(no_color: bool) -> bool {
-    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
-    }
-}
-
-#[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
-    }
-}
-
-#[cfg(not(windows))]
-fn get_width_of_terminal() -> usize {
-    if let Some((Width(w), Height(_h))) = terminal_size() {
-        w as usize
-    } else {
-        DEFAULT_TERMINAL_WIDTH
-    }
-}
-
-fn get_regex_value(maybe_value: Option<Values>) -> Vec<Regex> {
-    let mut result = vec![];
-    if let Some(v) = maybe_value {
-        for reg in v {
-            match Regex::new(reg) {
-                Ok(r) => result.push(r),
-                Err(e) => {
-                    eprintln!("Ignoring bad value for regex {:?}", e);
-                    process::exit(1);
+                    true
                }
            }
        }
    }
-    result
+    #[cfg(not(windows))]
+    {
+        no_color
+    }
+}
+
+fn get_height_of_terminal() -> usize {
+    // Simplify once https://github.com/eminence/terminal-size/pull/41 is
+    // merged
+    terminal_size()
+        // Windows CI runners detect a terminal height of 0
+        .map(|(_, Height(h))| max(h as usize, DEFAULT_NUMBER_OF_LINES))
+        .unwrap_or(DEFAULT_NUMBER_OF_LINES)
+        - 10
+}
+
+fn get_width_of_terminal() -> usize {
+    // Simplify once https://github.com/eminence/terminal-size/pull/41 is
+    // merged
+    terminal_size()
+        .map(|(Width(w), _)| match cfg!(windows) {
+            // Windows CI runners detect a very low terminal width
+            true => max(w as usize, DEFAULT_TERMINAL_WIDTH),
+            false => w as usize,
+        })
+        .unwrap_or(DEFAULT_TERMINAL_WIDTH)
+}
+
+fn get_regex_value(maybe_value: Option<Values>) -> Vec<Regex> {
+    maybe_value
+        .unwrap_or_default()
+        .map(|reg| {
+            Regex::new(reg).unwrap_or_else(|err| {
+                eprintln!("Ignoring bad value for regex {:?}", err);
+                process::exit(1)
+            })
+        })
+        .collect()
 }

 fn main() {
-    let default_height = get_height_of_terminal();
-    let def_num_str = default_height.to_string();
-
-    let options = Command::new("Dust")
-        .about("Like du but more intuitive")
-        .version(crate_version!())
-        .trailing_var_arg(true)
-        .arg(
-            Arg::new("depth")
-                .short('d')
-                .long("depth")
-                .help("Depth to show")
-                .takes_value(true)
-                .conflicts_with("number_of_lines"),
-        )
-        .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)
-                .default_value(def_num_str.as_ref()),
-        )
-        .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("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")
-                .conflicts_with("depth")
-                .help("Exclude files 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")
-                .conflicts_with("depth")
-                .help("Only include files 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("inputs").multiple_occurrences(true).default_value("."))
-        .arg(
-            Arg::new("iso")
-                .short('H')
-                .long("si")
-                .help("print sizes in powers of 1000 (e.g., 1.1G)")
-        )
-        .get_matches();
+    let options = build_cli().get_matches();
+    let config = get_config();

    let target_dirs = options
        .values_of("inputs")
@@ -236,50 +105,46 @@ fn main() {
    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 options.value_of_t("number_of_lines") {
-        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 options.value_of_t("width") {
-        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 {
@@ -287,40 +152,56 @@ fn main() {
        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),
    };
+    let _rayon = init_rayon();

+    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 has_errors {
        eprintln!("Did not have permissions for all directories");
    }
-    match tree {
-        None => {}
-        Some(root_node) => draw_it(
-            options.is_present("display_full_paths"),
-            !options.is_present("reverse"),
+    if let Some(root_node) = tree {
+        draw_it(
+            config.get_full_paths(&options),
+            !config.get_reverse(&options),
            no_colors,
-            options.is_present("no_bars"),
+            config.get_no_bars(&options),
            terminal_width,
            by_filecount,
-            root_node,
-            options.is_present("iso"),
-        ),
+            &root_node,
+            iso,
+            config.get_skip_total(&options),
+        )
+    }
+}
+
+fn init_rayon() -> Result<(), ThreadPoolBuildError> {
+    let large_stack = usize::pow(1024, 3);
+    // Warning: Creating System is slow, takes ~ 100ms
+    let s = System::new();
+    let available = s.get_available_memory() * 1024;
+
+    if available > large_stack.try_into().unwrap() {
+        // Larger stack size to handle cases with lots of nested directories
+        rayon::ThreadPoolBuilder::new()
+            .stack_size(large_stack)
+            .build_global()
+    } else {
+        Ok(())
    }
 }
--- a/src/node.rs
+++ b/src/node.rs
@@ -12,6 +12,7 @@ pub struct Node {
    pub size: u64,
    pub children: Vec<Node>,
    pub inode_device: Option<(u64, u64)>,
+    pub depth: usize,
 }

 #[allow(clippy::too_many_arguments)]
@@ -24,36 +25,35 @@ pub fn build_node(
    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,7 +49,7 @@ pub fn normalize_path<P: AsRef<Path>>(path: P) -> PathBuf {
    // 3. removing trailing extra separators and '.' ("current directory") path segments
    // * `Path.components()` does all the above work; ref: <https://doc.rust-lang.org/std/path/struct.Path.html#method.components>
    // 4. changing to os preferred separator (automatically done by recollecting components back into a PathBuf)
-    path.as_ref().components().collect::<PathBuf>()
+    path.as_ref().components().collect()
 }

 pub fn is_filtered_out_due_to_regex(filter_regex: &[Regex], dir: &Path) -> bool {
@@ -94,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
@@ -17,23 +17,20 @@ static INIT: Once = Once::new();
 /// Copy to /tmp dir - we assume that the formatting of the /tmp partition
 /// is consistent. If the tests fail your /tmp filesystem probably differs
 fn copy_test_data(dir: &str) {
-    // First remove the existing directory - just 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() {
@@ -48,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
@@ -82,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();
@@ -111,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() {
@@ -139,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_goe..
- 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_goe..
- 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();
@@ -174,17 +171,17 @@ 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();
@@ -199,10 +196,10 @@ pub fn test_apparent_size() {
 }

 fn apparent_size_output() -> Vec<String> {
-    // The apparent directory sizes are too unpredictable and system dependant to try and match
+    // The apparent directory sizes are too unpredictable and system dependent to try and match
    let files = r#"
-   0B     ┌── a_file
-   6B     ├── hello_file
+  0B     ┌── a_file
+  6B     ├── hello_file
 "#
    .trim()
    .to_string();
--- 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"));
 }

@@ -112,6 +116,17 @@ pub fn test_show_files_by_type() {
    assert!(output.contains("┌─┴ (total)"));
 }

+#[test]
+pub fn test_output_skip_total() {
+    let output = build_command(vec![
+        "--skip-total",
+        "tests/test_dir/many/hello_file",
+        "tests/test_dir/many/a_file",
+    ]);
+    assert!(output.contains("hello_file"));
+    assert!(!output.contains("(total)"));
+}
+
 #[test]
 pub fn test_show_files_by_regex_match_lots() {
    // Check we can see '.rs' files in the tests directory
--- 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() - 12) 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	2231e2d966	Fix: Only create large stack size if enough memory Small boxes do not have enough memory to create a large stack Conversely we want a large stack size for large boxes with a very highly nested directory structure. Version: New version	2022-08-29 17:39:39 +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