style: fix clippy

deps: cargo update
fix: number-of-lines option in config file is ignored (#528 )
2025-12-05 20:40:11 -08:00 · 2025-10-06 20:31:20 +01:00 · 2025-10-06 20:28:41 +01:00 · 2025-10-06 20:22:35 +01:00 · 2025-10-06 20:11:01 +01:00 · 2025-10-06 20:01:04 +01:00
32 changed files with 2045 additions and 1110 deletions
--- a/.github/workflows/CICD.yml
+++ b/.github/workflows/CICD.yml
@@ -45,6 +45,11 @@ jobs:
          override: true
          profile: minimal # minimal component installation (ie, no documentation)
          components: rustfmt, clippy
+      - name: Install wget for Windows
+        if: matrix.job.os == 'windows-latest'
+        run: choco install wget --no-progress
+      - name: typos-action
+        uses: crate-ci/typos@v1.28.4
      - name: "`fmt` testing"
        if: steps.vars.outputs.JOB_DO_FORMAT_TESTING
        uses: actions-rs/cargo@v1
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,11 @@
+repos:
+  - repo: https://github.com/doublify/pre-commit-rust
+    rev: v1.0
+    hooks:
+      - id: cargo-check
+        stages: [commit]
+      - id: fmt
+        stages: [commit]
+      - id: clippy
+        args: [--all-targets, --all-features]
+        stages: [commit]
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "du-dust"
 description = "A more intuitive version of du"
-version = "1.1.1"
+version = "1.2.3"
 authors = ["bootandy <bootandy@gmail.com>", "nebkor <code@ardent.nebcorp.com>"]
-edition = "2021"
+edition = "2024"
 readme = "README.md"

 documentation = "https://github.com/bootandy/dust"
@@ -28,7 +28,7 @@ strip = true

 [dependencies]
 ansi_term = "0.12"
-clap = "4.4"
+clap = { version = "4.4", features = ["derive"] }
 lscolors = "0.13"
 terminal_size = "0.2"
 unicode-width = "0.1"
@@ -44,6 +44,9 @@ sysinfo = "0.27"
 ctrlc = "3.4"
 chrono = "0.4"

+[target.'cfg(not(target_has_atomic = "64"))'.dependencies]
+portable-atomic = "1.4"
+
 [target.'cfg(windows)'.dependencies]
 winapi-util = "0.1"
 filesize = "0.2.0"
@@ -53,7 +56,7 @@ assert_cmd = "2"
 tempfile = "=3"

 [build-dependencies]
-clap = "4.4"
+clap = { version = "4.4", features = ["derive"] }
 clap_complete = "4.4"
 clap_mangen = "0.2"

@@ -83,6 +86,16 @@ assets = [
    "usr/share/doc/du-dust/README",
    "644",
  ],
+  [
+    "man-page/dust.1",
+    "usr/share/man/man1/dust.1",
+    "644",
+  ],
+  [
+    "completions/dust.bash",
+    "usr/share/bash-completion/completions/dust",
+    "644",
+  ],
 ]
 extended-description = """\
 Dust is meant to give you an instant overview of which directories are using
--- a/README.md
+++ b/README.md
@@ -27,11 +27,17 @@ Because I want an easy way to see where my disk is being used.

 - `brew install dust`

+#### [Snap](https://ubuntu.com/core/services/guide/snaps-intro) Ubuntu and [supported systems](https://snapcraft.io/docs/installing-snapd)
+
+- `snap install dust`
+
+Note: `dust` installed through `snap` can only access files stored in the `/home` directory. See daniejstriata/dust-snap#2 for more information.
+
 #### [Pacstall](https://github.com/pacstall/pacstall) (Debian/Ubuntu)

 - `pacstall -I dust-bin`

-### Anaconda (conda-forge)
+#### Anaconda (conda-forge)

 - `conda install -c conda-forge dust`

@@ -39,6 +45,10 @@ Because I want an easy way to see where my disk is being used.

 - `deb-get install du-dust`

+#### [x-cmd](https://www.x-cmd.com/pkg/#VPContent)
+
+- `x env use dust`
+
 #### Windows:

 - `scoop install dust`
@@ -80,7 +90,7 @@ Usage: dust -B (--bars-on-right - Percent bars moved to right side of screen)
 Usage: dust -i (Do not show hidden files)
 Usage: dust -c (No colors [monochrome])
 Usage: dust -C (Force colors)
-Usage: dust -f (Count files instead of diskspace)
+Usage: dust -f (Count files instead of diskspace [Counts by inode, to include duplicate inodes use dust -f -s])
 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))
@@ -92,7 +102,9 @@ Usage: dust -S (Custom Stack size - Use if you see: 'fatal runtime error: stack
 Usage: dust --skip-total (No total row will be displayed)
 Usage: dust -z 40000/30MB/20kib (Exclude output files/directories below size 40000 bytes / 30MB / 20KiB)
 Usage: dust -j (Prints JSON representation of directories, try: dust -j  | jq)
-Usage: dust --files0-from=FILE (Reads null-terminated file paths from FILE); If FILE is - then read from stdin
+Usage: dust --files0-from=FILE (Read NUL-terminated file paths from FILE; if FILE is '-', read from stdin)
+Usage: dust --files-from=FILE (Read newline-terminated file paths from FILE; if FILE is '-', read from stdin)
+Usage: dust --collapse=node-modules will keep the node-modules folder collapsed in display instead of recursively opening it
 ```

 ## Config file
@@ -111,6 +123,6 @@ reverse=true
 - [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
+- `du -d 1 -h | sort -h`

 Note: Apparent-size is calculated slightly differently in dust to gdu. In dust each hard link is counted as using file_length space. In gdu only the first entry is counted.
--- a/build.rs
+++ b/build.rs
@@ -1,3 +1,4 @@
+use clap::CommandFactory;
 use clap_complete::{generate_to, shells::*};
 use clap_mangen::Man;
 use std::fs::File;
@@ -9,7 +10,7 @@ include!("src/cli.rs");
 fn main() -> Result<(), Error> {
    let outdir = "completions";
    let app_name = "dust";
-    let mut cmd = build_cli();
+    let mut cmd = Cli::command();

    generate_to(Bash, &mut cmd, app_name, outdir)?;
    generate_to(Zsh, &mut cmd, app_name, outdir)?;
--- a/completions/_dust
+++ b/completions/_dust
@@ -14,36 +14,63 @@ _dust() {
    fi

    local context curcontext="$curcontext" state line
-    _arguments "${_arguments_options[@]}" \
-'-d+[Depth to show]:DEPTH: ' \
-'--depth=[Depth to show]:DEPTH: ' \
-'-T+[Number of threads to use]: : ' \
-'--threads=[Number of threads to use]: : ' \
-'-n+[Number of lines of output to show. (Default is terminal_height - 10)]:NUMBER: ' \
-'--number-of-lines=[Number of lines of output to show. (Default is terminal_height - 10)]:NUMBER: ' \
-'*-X+[Exclude any file or directory with this name]:PATH:_files' \
-'*--ignore-directory=[Exclude any file or directory with this name]:PATH:_files' \
+    _arguments "${_arguments_options[@]}" : \
+'-d+[Depth to show]:DEPTH:_default' \
+'--depth=[Depth to show]:DEPTH:_default' \
+'-T+[Number of threads to use]:THREADS:_default' \
+'--threads=[Number of threads to use]:THREADS:_default' \
+'--config=[Specify a config file to use]:FILE:_files' \
+'-n+[Number of lines of output to show. (Default is terminal_height - 10)]:NUMBER:_default' \
+'--number-of-lines=[Number of lines of output to show. (Default is terminal_height - 10)]:NUMBER:_default' \
+'*-X+[Exclude any file or directory with this path]:PATH:_files' \
+'*--ignore-directory=[Exclude any file or directory with this path]:PATH:_files' \
 '-I+[Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by --invert_filter]:FILE:_files' \
 '--ignore-all-in-file=[Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by --invert_filter]:FILE:_files' \
-'-z+[Minimum size file to include in output]:MIN_SIZE: ' \
-'--min-size=[Minimum size file to include in output]:MIN_SIZE: ' \
-'(-e --filter -t --file_types)*-v+[Exclude filepaths matching this regex. To ignore png files type\: -v "\\.png\$" ]:REGEX: ' \
-'(-e --filter -t --file_types)*--invert-filter=[Exclude filepaths matching this regex. To ignore png files type\: -v "\\.png\$" ]:REGEX: ' \
-'(-t --file_types)*-e+[Only include filepaths matching this regex. For png files type\: -e "\\.png\$" ]:REGEX: ' \
-'(-t --file_types)*--filter=[Only include filepaths matching this regex. For png files type\: -e "\\.png\$" ]:REGEX: ' \
-'-w+[Specify width of output overriding the auto detection of terminal width]:WIDTH: ' \
-'--terminal_width=[Specify width of output overriding the auto detection of terminal width]:WIDTH: ' \
-'-o+[Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size.]:FORMAT:(si b k m g t kb mb gb tb)' \
-'--output-format=[Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size.]:FORMAT:(si b k m g t kb mb gb tb)' \
-'-S+[Specify memory to use as stack size - use if you see\: '\''fatal runtime error\: stack overflow'\'' (default low memory=1048576, high memory=1073741824)]:STACK_SIZE: ' \
-'--stack-size=[Specify memory to use as stack size - use if you see\: '\''fatal runtime error\: stack overflow'\'' (default low memory=1048576, high memory=1073741824)]:STACK_SIZE: ' \
-'-M+[+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => \[curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)]: : ' \
-'--mtime=[+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => \[curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)]: : ' \
-'-A+[just like -mtime, but based on file access time]: : ' \
-'--atime=[just like -mtime, but based on file access time]: : ' \
-'-y+[just like -mtime, but based on file change time]: : ' \
-'--ctime=[just like -mtime, but based on file change time]: : ' \
-'--files0-from=[run dust on NUL-terminated file names specified in file; if argument is -, then read names from standard input]: :_files' \
+'-z+[Minimum size file to include in output]:MIN_SIZE:_default' \
+'--min-size=[Minimum size file to include in output]:MIN_SIZE:_default' \
+'(-e --filter -t --file-types)*-v+[Exclude filepaths matching this regex. To ignore png files type\: -v "\\.png\$"]:REGEX:_default' \
+'(-e --filter -t --file-types)*--invert-filter=[Exclude filepaths matching this regex. To ignore png files type\: -v "\\.png\$"]:REGEX:_default' \
+'(-t --file-types)*-e+[Only include filepaths matching this regex. For png files type\: -e "\\.png\$"]:REGEX:_default' \
+'(-t --file-types)*--filter=[Only include filepaths matching this regex. For png files type\: -e "\\.png\$"]:REGEX:_default' \
+'-w+[Specify width of output overriding the auto detection of terminal width]:WIDTH:_default' \
+'--terminal-width=[Specify width of output overriding the auto detection of terminal width]:WIDTH:_default' \
+'-o+[Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size]:FORMAT:((si\:"SI prefix (powers of 1000)"
+b\:"byte (B)"
+k\:"kibibyte (KiB)"
+m\:"mebibyte (MiB)"
+g\:"gibibyte (GiB)"
+t\:"tebibyte (TiB)"
+kb\:"kilobyte (kB)"
+mb\:"megabyte (MB)"
+gb\:"gigabyte (GB)"
+tb\:"terabyte (TB)"))' \
+'--output-format=[Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size]:FORMAT:((si\:"SI prefix (powers of 1000)"
+b\:"byte (B)"
+k\:"kibibyte (KiB)"
+m\:"mebibyte (MiB)"
+g\:"gibibyte (GiB)"
+t\:"tebibyte (TiB)"
+kb\:"kilobyte (kB)"
+mb\:"megabyte (MB)"
+gb\:"gigabyte (GB)"
+tb\:"terabyte (TB)"))' \
+'-S+[Specify memory to use as stack size - use if you see\: '\''fatal runtime error\: stack overflow'\'' (default low memory=1048576, high memory=1073741824)]:STACK_SIZE:_default' \
+'--stack-size=[Specify memory to use as stack size - use if you see\: '\''fatal runtime error\: stack overflow'\'' (default low memory=1048576, high memory=1073741824)]:STACK_SIZE:_default' \
+'-M+[+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => \[curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)]:MTIME:_default' \
+'--mtime=[+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => \[curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)]:MTIME:_default' \
+'-A+[just like -mtime, but based on file access time]:ATIME:_default' \
+'--atime=[just like -mtime, but based on file access time]:ATIME:_default' \
+'-y+[just like -mtime, but based on file change time]:CTIME:_default' \
+'--ctime=[just like -mtime, but based on file change time]:CTIME:_default' \
+'(--files-from)--files0-from=[Read NUL-terminated paths from FILE (use \`-\` for stdin)]:FILES0_FROM:_files' \
+'(--files0-from)--files-from=[Read newline-terminated paths from FILE (use \`-\` for stdin)]:FILES_FROM:_files' \
+'*--collapse=[Keep these directories collapsed]:COLLAPSE:_files' \
+'-m+[Directory '\''size'\'' is max filetime of child files instead of disk size. while a/c/m for last accessed/changed/modified time]:FILETIME:((a\:"last accessed time"
+c\:"last changed time"
+m\:"last modified time"))' \
+'--filetime=[Directory '\''size'\'' is max filetime of child files instead of disk size. while a/c/m for last accessed/changed/modified time]:FILETIME:((a\:"last accessed time"
+c\:"last changed time"
+m\:"last modified time"))' \
 '-p[Subdirectories will not have their path shortened]' \
 '--full-paths[Subdirectories will not have their path shortened]' \
 '-L[dereference sym links - Treat sym links as directories and go into them]' \
@@ -68,23 +95,23 @@ _dust() {
 '-f[Directory '\''size'\'' is number of child files instead of disk size]' \
 '--filecount[Directory '\''size'\'' is number of child files instead of disk size]' \
 '-i[Do not display hidden files]' \
-'--ignore_hidden[Do not display hidden files]' \
+'--ignore-hidden[Do not display hidden files]' \
 '(-d --depth -D --only-dir)-t[show only these file types]' \
-'(-d --depth -D --only-dir)--file_types[show only these file types]' \
-'-P[Disable the progress indication.]' \
-'--no-progress[Disable the progress indication.]' \
-'--print-errors[Print path with errors.]' \
-'(-F --only-file -t --file_types)-D[Only directories will be displayed.]' \
-'(-F --only-file -t --file_types)--only-dir[Only directories will be displayed.]' \
+'(-d --depth -D --only-dir)--file-types[show only these file types]' \
+'-P[Disable the progress indication]' \
+'--no-progress[Disable the progress indication]' \
+'--print-errors[Print path with errors]' \
+'(-F --only-file -t --file-types)-D[Only directories will be displayed]' \
+'(-F --only-file -t --file-types)--only-dir[Only directories will be displayed]' \
 '(-D --only-dir)-F[Only files will be displayed. (Finds your largest files)]' \
 '(-D --only-dir)--only-file[Only files will be displayed. (Finds your largest files)]' \
 '-j[Output the directory tree as json to the current directory]' \
 '--output-json[Output the directory tree as json to the current directory]' \
-'-h[Print help]' \
-'--help[Print help]' \
+'-h[Print help (see more with '\''--help'\'')]' \
+'--help[Print help (see more with '\''--help'\'')]' \
 '-V[Print version]' \
 '--version[Print version]' \
-'*::params:_files' \
+'*::params -- Input files or directories:_files' \
 && ret=0
 }

--- a/completions/_dust.ps1
+++ b/completions/_dust.ps1
@@ -21,75 +21,80 @@ Register-ArgumentCompleter -Native -CommandName 'dust' -ScriptBlock {

    $completions = @(switch ($command) {
        'dust' {
-            [CompletionResult]::new('-d', 'd', [CompletionResultType]::ParameterName, 'Depth to show')
-            [CompletionResult]::new('--depth', 'depth', [CompletionResultType]::ParameterName, 'Depth to show')
-            [CompletionResult]::new('-T', 'T ', [CompletionResultType]::ParameterName, 'Number of threads to use')
-            [CompletionResult]::new('--threads', 'threads', [CompletionResultType]::ParameterName, 'Number of threads to use')
-            [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('-I', 'I ', [CompletionResultType]::ParameterName, 'Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by --invert_filter')
-            [CompletionResult]::new('--ignore-all-in-file', 'ignore-all-in-file', [CompletionResultType]::ParameterName, 'Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by --invert_filter')
-            [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('-o', 'o', [CompletionResultType]::ParameterName, 'Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size.')
-            [CompletionResult]::new('--output-format', 'output-format', [CompletionResultType]::ParameterName, 'Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size.')
-            [CompletionResult]::new('-S', 'S ', [CompletionResultType]::ParameterName, 'Specify memory to use as stack size - use if you see: ''fatal runtime error: stack overflow'' (default low memory=1048576, high memory=1073741824)')
-            [CompletionResult]::new('--stack-size', 'stack-size', [CompletionResultType]::ParameterName, 'Specify memory to use as stack size - use if you see: ''fatal runtime error: stack overflow'' (default low memory=1048576, high memory=1073741824)')
-            [CompletionResult]::new('-M', 'M ', [CompletionResultType]::ParameterName, '+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => [curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)')
-            [CompletionResult]::new('--mtime', 'mtime', [CompletionResultType]::ParameterName, '+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => [curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)')
-            [CompletionResult]::new('-A', 'A ', [CompletionResultType]::ParameterName, 'just like -mtime, but based on file access time')
-            [CompletionResult]::new('--atime', 'atime', [CompletionResultType]::ParameterName, 'just like -mtime, but based on file access time')
-            [CompletionResult]::new('-y', 'y', [CompletionResultType]::ParameterName, 'just like -mtime, but based on file change time')
-            [CompletionResult]::new('--ctime', 'ctime', [CompletionResultType]::ParameterName, 'just like -mtime, but based on file change time')
-            [CompletionResult]::new('--files0-from', 'files0-from', [CompletionResultType]::ParameterName, 'run dust on NUL-terminated file names specified in file; if argument is -, then read names from standard input')
-            [CompletionResult]::new('-p', 'p', [CompletionResultType]::ParameterName, 'Subdirectories will not have their path shortened')
-            [CompletionResult]::new('--full-paths', 'full-paths', [CompletionResultType]::ParameterName, 'Subdirectories will not have their path shortened')
-            [CompletionResult]::new('-L', 'L ', [CompletionResultType]::ParameterName, 'dereference sym links - Treat sym links as directories and go into them')
-            [CompletionResult]::new('--dereference-links', 'dereference-links', [CompletionResultType]::ParameterName, 'dereference sym links - Treat sym links as directories and go into them')
-            [CompletionResult]::new('-x', 'x', [CompletionResultType]::ParameterName, 'Only count the files and directories on the same filesystem as the supplied directory')
-            [CompletionResult]::new('--limit-filesystem', 'limit-filesystem', [CompletionResultType]::ParameterName, 'Only count the files and directories on the same filesystem as the supplied directory')
-            [CompletionResult]::new('-s', 's', [CompletionResultType]::ParameterName, 'Use file length instead of blocks')
-            [CompletionResult]::new('--apparent-size', 'apparent-size', [CompletionResultType]::ParameterName, 'Use file length instead of blocks')
-            [CompletionResult]::new('-r', 'r', [CompletionResultType]::ParameterName, 'Print tree upside down (biggest highest)')
-            [CompletionResult]::new('--reverse', 'reverse', [CompletionResultType]::ParameterName, 'Print tree upside down (biggest highest)')
-            [CompletionResult]::new('-c', 'c', [CompletionResultType]::ParameterName, 'No colors will be printed (Useful for commands like: watch)')
-            [CompletionResult]::new('--no-colors', 'no-colors', [CompletionResultType]::ParameterName, 'No colors will be printed (Useful for commands like: watch)')
-            [CompletionResult]::new('-C', 'C ', [CompletionResultType]::ParameterName, 'Force colors print')
-            [CompletionResult]::new('--force-colors', 'force-colors', [CompletionResultType]::ParameterName, 'Force colors print')
-            [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('-B', 'B ', [CompletionResultType]::ParameterName, 'percent bars moved to right side of screen')
-            [CompletionResult]::new('--bars-on-right', 'bars-on-right', [CompletionResultType]::ParameterName, 'percent bars moved to right side of screen')
-            [CompletionResult]::new('-R', 'R ', [CompletionResultType]::ParameterName, 'For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)')
-            [CompletionResult]::new('--screen-reader', 'screen-reader', [CompletionResultType]::ParameterName, 'For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)')
-            [CompletionResult]::new('--skip-total', 'skip-total', [CompletionResultType]::ParameterName, 'No total row will be displayed')
-            [CompletionResult]::new('-f', 'f', [CompletionResultType]::ParameterName, 'Directory ''size'' is number of child files instead of disk size')
-            [CompletionResult]::new('--filecount', 'filecount', [CompletionResultType]::ParameterName, 'Directory ''size'' is number of child files instead of 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('-P', 'P ', [CompletionResultType]::ParameterName, 'Disable the progress indication.')
-            [CompletionResult]::new('--no-progress', 'no-progress', [CompletionResultType]::ParameterName, 'Disable the progress indication.')
-            [CompletionResult]::new('--print-errors', 'print-errors', [CompletionResultType]::ParameterName, 'Print path with errors.')
-            [CompletionResult]::new('-D', 'D ', [CompletionResultType]::ParameterName, 'Only directories will be displayed.')
-            [CompletionResult]::new('--only-dir', 'only-dir', [CompletionResultType]::ParameterName, 'Only directories will be displayed.')
-            [CompletionResult]::new('-F', 'F ', [CompletionResultType]::ParameterName, 'Only files will be displayed. (Finds your largest files)')
-            [CompletionResult]::new('--only-file', 'only-file', [CompletionResultType]::ParameterName, 'Only files will be displayed. (Finds your largest files)')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'Output the directory tree as json to the current directory')
-            [CompletionResult]::new('--output-json', 'output-json', [CompletionResultType]::ParameterName, 'Output the directory tree as json to the current directory')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help')
-            [CompletionResult]::new('-V', 'V ', [CompletionResultType]::ParameterName, 'Print version')
-            [CompletionResult]::new('--version', 'version', [CompletionResultType]::ParameterName, 'Print version')
+            [CompletionResult]::new('-d', '-d', [CompletionResultType]::ParameterName, 'Depth to show')
+            [CompletionResult]::new('--depth', '--depth', [CompletionResultType]::ParameterName, 'Depth to show')
+            [CompletionResult]::new('-T', '-T ', [CompletionResultType]::ParameterName, 'Number of threads to use')
+            [CompletionResult]::new('--threads', '--threads', [CompletionResultType]::ParameterName, 'Number of threads to use')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'Specify a config file to use')
+            [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 path')
+            [CompletionResult]::new('--ignore-directory', '--ignore-directory', [CompletionResultType]::ParameterName, 'Exclude any file or directory with this path')
+            [CompletionResult]::new('-I', '-I ', [CompletionResultType]::ParameterName, 'Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by --invert_filter')
+            [CompletionResult]::new('--ignore-all-in-file', '--ignore-all-in-file', [CompletionResultType]::ParameterName, 'Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by --invert_filter')
+            [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('-o', '-o', [CompletionResultType]::ParameterName, 'Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size')
+            [CompletionResult]::new('--output-format', '--output-format', [CompletionResultType]::ParameterName, 'Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size')
+            [CompletionResult]::new('-S', '-S ', [CompletionResultType]::ParameterName, 'Specify memory to use as stack size - use if you see: ''fatal runtime error: stack overflow'' (default low memory=1048576, high memory=1073741824)')
+            [CompletionResult]::new('--stack-size', '--stack-size', [CompletionResultType]::ParameterName, 'Specify memory to use as stack size - use if you see: ''fatal runtime error: stack overflow'' (default low memory=1048576, high memory=1073741824)')
+            [CompletionResult]::new('-M', '-M ', [CompletionResultType]::ParameterName, '+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => [curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)')
+            [CompletionResult]::new('--mtime', '--mtime', [CompletionResultType]::ParameterName, '+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => [curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)')
+            [CompletionResult]::new('-A', '-A ', [CompletionResultType]::ParameterName, 'just like -mtime, but based on file access time')
+            [CompletionResult]::new('--atime', '--atime', [CompletionResultType]::ParameterName, 'just like -mtime, but based on file access time')
+            [CompletionResult]::new('-y', '-y', [CompletionResultType]::ParameterName, 'just like -mtime, but based on file change time')
+            [CompletionResult]::new('--ctime', '--ctime', [CompletionResultType]::ParameterName, 'just like -mtime, but based on file change time')
+            [CompletionResult]::new('--files0-from', '--files0-from', [CompletionResultType]::ParameterName, 'Read NUL-terminated paths from FILE (use `-` for stdin)')
+            [CompletionResult]::new('--files-from', '--files-from', [CompletionResultType]::ParameterName, 'Read newline-terminated paths from FILE (use `-` for stdin)')
+            [CompletionResult]::new('--collapse', '--collapse', [CompletionResultType]::ParameterName, 'Keep these directories collapsed')
+            [CompletionResult]::new('-m', '-m', [CompletionResultType]::ParameterName, 'Directory ''size'' is max filetime of child files instead of disk size. while a/c/m for last accessed/changed/modified time')
+            [CompletionResult]::new('--filetime', '--filetime', [CompletionResultType]::ParameterName, 'Directory ''size'' is max filetime of child files instead of disk size. while a/c/m for last accessed/changed/modified time')
+            [CompletionResult]::new('-p', '-p', [CompletionResultType]::ParameterName, 'Subdirectories will not have their path shortened')
+            [CompletionResult]::new('--full-paths', '--full-paths', [CompletionResultType]::ParameterName, 'Subdirectories will not have their path shortened')
+            [CompletionResult]::new('-L', '-L ', [CompletionResultType]::ParameterName, 'dereference sym links - Treat sym links as directories and go into them')
+            [CompletionResult]::new('--dereference-links', '--dereference-links', [CompletionResultType]::ParameterName, 'dereference sym links - Treat sym links as directories and go into them')
+            [CompletionResult]::new('-x', '-x', [CompletionResultType]::ParameterName, 'Only count the files and directories on the same filesystem as the supplied directory')
+            [CompletionResult]::new('--limit-filesystem', '--limit-filesystem', [CompletionResultType]::ParameterName, 'Only count the files and directories on the same filesystem as the supplied directory')
+            [CompletionResult]::new('-s', '-s', [CompletionResultType]::ParameterName, 'Use file length instead of blocks')
+            [CompletionResult]::new('--apparent-size', '--apparent-size', [CompletionResultType]::ParameterName, 'Use file length instead of blocks')
+            [CompletionResult]::new('-r', '-r', [CompletionResultType]::ParameterName, 'Print tree upside down (biggest highest)')
+            [CompletionResult]::new('--reverse', '--reverse', [CompletionResultType]::ParameterName, 'Print tree upside down (biggest highest)')
+            [CompletionResult]::new('-c', '-c', [CompletionResultType]::ParameterName, 'No colors will be printed (Useful for commands like: watch)')
+            [CompletionResult]::new('--no-colors', '--no-colors', [CompletionResultType]::ParameterName, 'No colors will be printed (Useful for commands like: watch)')
+            [CompletionResult]::new('-C', '-C ', [CompletionResultType]::ParameterName, 'Force colors print')
+            [CompletionResult]::new('--force-colors', '--force-colors', [CompletionResultType]::ParameterName, 'Force colors print')
+            [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('-B', '-B ', [CompletionResultType]::ParameterName, 'percent bars moved to right side of screen')
+            [CompletionResult]::new('--bars-on-right', '--bars-on-right', [CompletionResultType]::ParameterName, 'percent bars moved to right side of screen')
+            [CompletionResult]::new('-R', '-R ', [CompletionResultType]::ParameterName, 'For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)')
+            [CompletionResult]::new('--screen-reader', '--screen-reader', [CompletionResultType]::ParameterName, 'For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)')
+            [CompletionResult]::new('--skip-total', '--skip-total', [CompletionResultType]::ParameterName, 'No total row will be displayed')
+            [CompletionResult]::new('-f', '-f', [CompletionResultType]::ParameterName, 'Directory ''size'' is number of child files instead of disk size')
+            [CompletionResult]::new('--filecount', '--filecount', [CompletionResultType]::ParameterName, 'Directory ''size'' is number of child files instead of 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('-P', '-P ', [CompletionResultType]::ParameterName, 'Disable the progress indication')
+            [CompletionResult]::new('--no-progress', '--no-progress', [CompletionResultType]::ParameterName, 'Disable the progress indication')
+            [CompletionResult]::new('--print-errors', '--print-errors', [CompletionResultType]::ParameterName, 'Print path with errors')
+            [CompletionResult]::new('-D', '-D ', [CompletionResultType]::ParameterName, 'Only directories will be displayed')
+            [CompletionResult]::new('--only-dir', '--only-dir', [CompletionResultType]::ParameterName, 'Only directories will be displayed')
+            [CompletionResult]::new('-F', '-F ', [CompletionResultType]::ParameterName, 'Only files will be displayed. (Finds your largest files)')
+            [CompletionResult]::new('--only-file', '--only-file', [CompletionResultType]::ParameterName, 'Only files will be displayed. (Finds your largest files)')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'Output the directory tree as json to the current directory')
+            [CompletionResult]::new('--output-json', '--output-json', [CompletionResultType]::ParameterName, 'Output the directory tree as json to the current directory')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('-V', '-V ', [CompletionResultType]::ParameterName, 'Print version')
+            [CompletionResult]::new('--version', '--version', [CompletionResultType]::ParameterName, 'Print version')
            break
        }
    })
--- a/completions/dust.bash
+++ b/completions/dust.bash
@@ -1,12 +1,16 @@
 _dust() {
    local i cur prev opts cmd
    COMPREPLY=()
-    cur="${COMP_WORDS[COMP_CWORD]}"
-    prev="${COMP_WORDS[COMP_CWORD-1]}"
+    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+        cur="$2"
+    else
+        cur="${COMP_WORDS[COMP_CWORD]}"
+    fi
+    prev="$3"
    cmd=""
    opts=""

-    for i in ${COMP_WORDS[@]}
+    for i in "${COMP_WORDS[@]:0:COMP_CWORD}"
    do
        case "${cmd},${i}" in
            ",$1")
@@ -19,7 +23,7 @@ _dust() {

    case "${cmd}" in
        dust)
-            opts="-d -T -n -p -X -I -L -x -s -r -c -C -b -B -z -R -f -i -v -e -t -w -P -D -F -o -S -j -M -A -y -h -V --depth --threads --number-of-lines --full-paths --ignore-directory --ignore-all-in-file --dereference-links --limit-filesystem --apparent-size --reverse --no-colors --force-colors --no-percent-bars --bars-on-right --min-size --screen-reader --skip-total --filecount --ignore_hidden --invert-filter --filter --file_types --terminal_width --no-progress --print-errors --only-dir --only-file --output-format --stack-size --output-json --mtime --atime --ctime --files0-from --help --version [PATH]..."
+            opts="-d -T -n -p -X -I -L -x -s -r -c -C -b -B -z -R -f -i -v -e -t -w -P -D -F -o -S -j -M -A -y -m -h -V --depth --threads --config --number-of-lines --full-paths --ignore-directory --ignore-all-in-file --dereference-links --limit-filesystem --apparent-size --reverse --no-colors --force-colors --no-percent-bars --bars-on-right --min-size --screen-reader --skip-total --filecount --ignore-hidden --invert-filter --filter --file-types --terminal-width --no-progress --print-errors --only-dir --only-file --output-format --stack-size --output-json --mtime --atime --ctime --files0-from --files-from --collapse --filetime --help --version [PATH]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
@@ -41,6 +45,21 @@ _dust() {
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
+                --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
+                    return 0
+                    ;;
                --number-of-lines)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
@@ -59,12 +78,12 @@ _dust() {
                    ;;
                --ignore-all-in-file)
                    local oldifs
-                    if [[ -v IFS ]]; then
+                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
-                    if [[ -v oldifs ]]; then
+                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
@@ -74,12 +93,12 @@ _dust() {
                    ;;
                -I)
                    local oldifs
-                    if [[ -v IFS ]]; then
+                    if [ -n "${IFS+x}" ]; then
                        oldifs="$IFS"
                    fi
                    IFS=$'\n'
                    COMPREPLY=($(compgen -f "${cur}"))
-                    if [[ -v oldifs ]]; then
+                    if [ -n "${oldifs+x}" ]; then
                        IFS="$oldifs"
                    fi
                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
@@ -111,7 +130,7 @@ _dust() {
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
-                --terminal_width)
+                --terminal-width)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
@@ -163,6 +182,22 @@ _dust() {
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
+                --files-from)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                --collapse)
+                    COMPREPLY=($(compgen -f "${cur}"))
+                    return 0
+                    ;;
+                --filetime)
+                    COMPREPLY=($(compgen -W "a c m" -- "${cur}"))
+                    return 0
+                    ;;
+                -m)
+                    COMPREPLY=($(compgen -W "a c m" -- "${cur}"))
+                    return 0
+                    ;;
                *)
                    COMPREPLY=()
                    ;;
--- a/completions/dust.elv
+++ b/completions/dust.elv
@@ -22,22 +22,23 @@ set edit:completion:arg-completer[dust] = {|@words|
            cand --depth 'Depth to show'
            cand -T 'Number of threads to use'
            cand --threads 'Number of threads to use'
+            cand --config 'Specify a config file to use'
            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 -X 'Exclude any file or directory with this path'
+            cand --ignore-directory 'Exclude any file or directory with this path'
            cand -I 'Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by --invert_filter'
            cand --ignore-all-in-file 'Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by --invert_filter'
            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 -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 -o 'Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size.'
-            cand --output-format 'Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size.'
+            cand --terminal-width 'Specify width of output overriding the auto detection of terminal width'
+            cand -o 'Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size'
+            cand --output-format 'Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size'
            cand -S 'Specify memory to use as stack size - use if you see: ''fatal runtime error: stack overflow'' (default low memory=1048576, high memory=1073741824)'
            cand --stack-size 'Specify memory to use as stack size - use if you see: ''fatal runtime error: stack overflow'' (default low memory=1048576, high memory=1073741824)'
            cand -M '+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => [curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)'
@@ -46,7 +47,11 @@ set edit:completion:arg-completer[dust] = {|@words|
            cand --atime 'just like -mtime, but based on file access time'
            cand -y 'just like -mtime, but based on file change time'
            cand --ctime 'just like -mtime, but based on file change time'
-            cand --files0-from 'run dust on NUL-terminated file names specified in file; if argument is -, then read names from standard input'
+            cand --files0-from 'Read NUL-terminated paths from FILE (use `-` for stdin)'
+            cand --files-from 'Read newline-terminated paths from FILE (use `-` for stdin)'
+            cand --collapse 'Keep these directories collapsed'
+            cand -m 'Directory ''size'' is max filetime of child files instead of disk size. while a/c/m for last accessed/changed/modified time'
+            cand --filetime 'Directory ''size'' is max filetime of child files instead of disk size. while a/c/m for last accessed/changed/modified time'
            cand -p 'Subdirectories will not have their path shortened'
            cand --full-paths 'Subdirectories will not have their path shortened'
            cand -L 'dereference sym links - Treat sym links as directories and go into them'
@@ -71,20 +76,20 @@ set edit:completion:arg-completer[dust] = {|@words|
            cand -f 'Directory ''size'' is number of child files instead of disk size'
            cand --filecount 'Directory ''size'' is number of child files instead of disk size'
            cand -i 'Do not display hidden files'
-            cand --ignore_hidden '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 -P 'Disable the progress indication.'
-            cand --no-progress 'Disable the progress indication.'
-            cand --print-errors 'Print path with errors.'
-            cand -D 'Only directories will be displayed.'
-            cand --only-dir 'Only directories will be displayed.'
+            cand --file-types 'show only these file types'
+            cand -P 'Disable the progress indication'
+            cand --no-progress 'Disable the progress indication'
+            cand --print-errors 'Print path with errors'
+            cand -D 'Only directories will be displayed'
+            cand --only-dir 'Only directories will be displayed'
            cand -F 'Only files will be displayed. (Finds your largest files)'
            cand --only-file 'Only files will be displayed. (Finds your largest files)'
            cand -j 'Output the directory tree as json to the current directory'
            cand --output-json 'Output the directory tree as json to the current directory'
-            cand -h 'Print help'
-            cand --help 'Print help'
+            cand -h 'Print help (see more with ''--help'')'
+            cand --help 'Print help (see more with ''--help'')'
            cand -V 'Print version'
            cand --version 'Print version'
        }
--- a/completions/dust.fish
+++ b/completions/dust.fish
@@ -1,18 +1,33 @@
 complete -c dust -s d -l depth -d 'Depth to show' -r
 complete -c dust -s T -l threads -d 'Number of threads to use' -r
+complete -c dust -l config -d 'Specify a config file to use' -r -F
 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 -F
+complete -c dust -s X -l ignore-directory -d 'Exclude any file or directory with this path' -r -F
 complete -c dust -s I -l ignore-all-in-file -d 'Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by --invert_filter' -r -F
 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 o -l output-format -d 'Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size.' -r -f -a "{si	'',b	'',k	'',m	'',g	'',t	'',kb	'',mb	'',gb	'',tb	''}"
+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 o -l output-format -d 'Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size' -r -f -a "si\t'SI prefix (powers of 1000)'
+b\t'byte (B)'
+k\t'kibibyte (KiB)'
+m\t'mebibyte (MiB)'
+g\t'gibibyte (GiB)'
+t\t'tebibyte (TiB)'
+kb\t'kilobyte (kB)'
+mb\t'megabyte (MB)'
+gb\t'gigabyte (GB)'
+tb\t'terabyte (TB)'"
 complete -c dust -s S -l stack-size -d 'Specify memory to use as stack size - use if you see: \'fatal runtime error: stack overflow\' (default low memory=1048576, high memory=1073741824)' -r
 complete -c dust -s M -l mtime -d '+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => [curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)' -r
 complete -c dust -s A -l atime -d 'just like -mtime, but based on file access time' -r
 complete -c dust -s y -l ctime -d 'just like -mtime, but based on file change time' -r
-complete -c dust -l files0-from -d 'run dust on NUL-terminated file names specified in file; if argument is -, then read names from standard input' -r -F
+complete -c dust -l files0-from -d 'Read NUL-terminated paths from FILE (use `-` for stdin)' -r -F
+complete -c dust -l files-from -d 'Read newline-terminated paths from FILE (use `-` for stdin)' -r -F
+complete -c dust -l collapse -d 'Keep these directories collapsed' -r -F
+complete -c dust -s m -l filetime -d 'Directory \'size\' is max filetime of child files instead of disk size. while a/c/m for last accessed/changed/modified time' -r -f -a "a\t'last accessed time'
+c\t'last changed time'
+m\t'last modified time'"
 complete -c dust -s p -l full-paths -d 'Subdirectories will not have their path shortened'
 complete -c dust -s L -l dereference-links -d 'dereference sym links - Treat sym links as directories and go into them'
 complete -c dust -s x -l limit-filesystem -d 'Only count the files and directories on the same filesystem as the supplied directory'
@@ -25,12 +40,12 @@ complete -c dust -s B -l bars-on-right -d 'percent bars moved to right side of s
 complete -c dust -s R -l screen-reader -d 'For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)'
 complete -c dust -l skip-total -d 'No total row will be displayed'
 complete -c dust -s f -l filecount -d 'Directory \'size\' is number of child files instead of 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 P -l no-progress -d 'Disable the progress indication.'
-complete -c dust -l print-errors -d 'Print path with errors.'
-complete -c dust -s D -l only-dir -d 'Only directories will be displayed.'
+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 P -l no-progress -d 'Disable the progress indication'
+complete -c dust -l print-errors -d 'Print path with errors'
+complete -c dust -s D -l only-dir -d 'Only directories will be displayed'
 complete -c dust -s F -l only-file -d 'Only files will be displayed. (Finds your largest files)'
 complete -c dust -s j -l output-json -d 'Output the directory tree as json to the current directory'
-complete -c dust -s h -l help -d 'Print help'
+complete -c dust -s h -l help -d 'Print help (see more with \'--help\')'
 complete -c dust -s V -l version -d 'Print version'
--- a/config/config.toml
+++ b/config/config.toml
@@ -25,4 +25,6 @@ skip-total=true
 ignore-hidden=true

 # print sizes in powers of 1000 (e.g., 1.1G)
-iso=true
+output-format="si"
+
+number-of-lines=5   
--- a/man-page/dust.1
+++ b/man-page/dust.1
@@ -1,30 +1,33 @@
 .ie \n(.g .ds Aq \(aq
 .el .ds Aq '
-.TH Dust 1  "Dust 1.1.1" 
+.TH Dust 1  "Dust 1.2.3" 
 .SH NAME
 Dust \- Like du but more intuitive
 .SH SYNOPSIS
-\fBdust\fR [\fB\-d\fR|\fB\-\-depth\fR] [\fB\-T\fR|\fB\-\-threads\fR] [\fB\-n\fR|\fB\-\-number\-of\-lines\fR] [\fB\-p\fR|\fB\-\-full\-paths\fR] [\fB\-X\fR|\fB\-\-ignore\-directory\fR] [\fB\-I\fR|\fB\-\-ignore\-all\-in\-file\fR] [\fB\-L\fR|\fB\-\-dereference\-links\fR] [\fB\-x\fR|\fB\-\-limit\-filesystem\fR] [\fB\-s\fR|\fB\-\-apparent\-size\fR] [\fB\-r\fR|\fB\-\-reverse\fR] [\fB\-c\fR|\fB\-\-no\-colors\fR] [\fB\-C\fR|\fB\-\-force\-colors\fR] [\fB\-b\fR|\fB\-\-no\-percent\-bars\fR] [\fB\-B\fR|\fB\-\-bars\-on\-right\fR] [\fB\-z\fR|\fB\-\-min\-size\fR] [\fB\-R\fR|\fB\-\-screen\-reader\fR] [\fB\-\-skip\-total\fR] [\fB\-f\fR|\fB\-\-filecount\fR] [\fB\-i\fR|\fB\-\-ignore_hidden\fR] [\fB\-v\fR|\fB\-\-invert\-filter\fR] [\fB\-e\fR|\fB\-\-filter\fR] [\fB\-t\fR|\fB\-\-file_types\fR] [\fB\-w\fR|\fB\-\-terminal_width\fR] [\fB\-P\fR|\fB\-\-no\-progress\fR] [\fB\-\-print\-errors\fR] [\fB\-D\fR|\fB\-\-only\-dir\fR] [\fB\-F\fR|\fB\-\-only\-file\fR] [\fB\-o\fR|\fB\-\-output\-format\fR] [\fB\-S\fR|\fB\-\-stack\-size\fR] [\fB\-j\fR|\fB\-\-output\-json\fR] [\fB\-M\fR|\fB\-\-mtime\fR] [\fB\-A\fR|\fB\-\-atime\fR] [\fB\-y\fR|\fB\-\-ctime\fR] [\fB\-\-files0\-from\fR] [\fB\-h\fR|\fB\-\-help\fR] [\fB\-V\fR|\fB\-\-version\fR] [\fIPATH\fR] 
+\fBdust\fR [\fB\-d\fR|\fB\-\-depth\fR] [\fB\-T\fR|\fB\-\-threads\fR] [\fB\-\-config\fR] [\fB\-n\fR|\fB\-\-number\-of\-lines\fR] [\fB\-p\fR|\fB\-\-full\-paths\fR] [\fB\-X\fR|\fB\-\-ignore\-directory\fR] [\fB\-I\fR|\fB\-\-ignore\-all\-in\-file\fR] [\fB\-L\fR|\fB\-\-dereference\-links\fR] [\fB\-x\fR|\fB\-\-limit\-filesystem\fR] [\fB\-s\fR|\fB\-\-apparent\-size\fR] [\fB\-r\fR|\fB\-\-reverse\fR] [\fB\-c\fR|\fB\-\-no\-colors\fR] [\fB\-C\fR|\fB\-\-force\-colors\fR] [\fB\-b\fR|\fB\-\-no\-percent\-bars\fR] [\fB\-B\fR|\fB\-\-bars\-on\-right\fR] [\fB\-z\fR|\fB\-\-min\-size\fR] [\fB\-R\fR|\fB\-\-screen\-reader\fR] [\fB\-\-skip\-total\fR] [\fB\-f\fR|\fB\-\-filecount\fR] [\fB\-i\fR|\fB\-\-ignore\-hidden\fR] [\fB\-v\fR|\fB\-\-invert\-filter\fR] [\fB\-e\fR|\fB\-\-filter\fR] [\fB\-t\fR|\fB\-\-file\-types\fR] [\fB\-w\fR|\fB\-\-terminal\-width\fR] [\fB\-P\fR|\fB\-\-no\-progress\fR] [\fB\-\-print\-errors\fR] [\fB\-D\fR|\fB\-\-only\-dir\fR] [\fB\-F\fR|\fB\-\-only\-file\fR] [\fB\-o\fR|\fB\-\-output\-format\fR] [\fB\-S\fR|\fB\-\-stack\-size\fR] [\fB\-j\fR|\fB\-\-output\-json\fR] [\fB\-M\fR|\fB\-\-mtime\fR] [\fB\-A\fR|\fB\-\-atime\fR] [\fB\-y\fR|\fB\-\-ctime\fR] [\fB\-\-files0\-from\fR] [\fB\-\-files\-from\fR] [\fB\-\-collapse\fR] [\fB\-m\fR|\fB\-\-filetime\fR] [\fB\-h\fR|\fB\-\-help\fR] [\fB\-V\fR|\fB\-\-version\fR] [\fIPATH\fR] 
 .SH DESCRIPTION
 Like du but more intuitive
 .SH OPTIONS
 .TP
-\fB\-d\fR, \fB\-\-depth\fR=\fIDEPTH\fR
+\fB\-d\fR, \fB\-\-depth\fR \fI<DEPTH>\fR
 Depth to show
 .TP
-\fB\-T\fR, \fB\-\-threads\fR
+\fB\-T\fR, \fB\-\-threads\fR \fI<THREADS>\fR
 Number of threads to use
 .TP
-\fB\-n\fR, \fB\-\-number\-of\-lines\fR=\fINUMBER\fR
+\fB\-\-config\fR \fI<FILE>\fR
+Specify a config file to use
+.TP
+\fB\-n\fR, \fB\-\-number\-of\-lines\fR \fI<NUMBER>\fR
 Number of lines of output to show. (Default is terminal_height \- 10)
 .TP
 \fB\-p\fR, \fB\-\-full\-paths\fR
 Subdirectories will not have their path shortened
 .TP
-\fB\-X\fR, \fB\-\-ignore\-directory\fR=\fIPATH\fR
-Exclude any file or directory with this name
+\fB\-X\fR, \fB\-\-ignore\-directory\fR \fI<PATH>\fR
+Exclude any file or directory with this path
 .TP
-\fB\-I\fR, \fB\-\-ignore\-all\-in\-file\fR=\fIFILE\fR
+\fB\-I\fR, \fB\-\-ignore\-all\-in\-file\fR \fI<FILE>\fR
 Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by \-\-invert_filter
 .TP
 \fB\-L\fR, \fB\-\-dereference\-links\fR
@@ -51,7 +54,7 @@ No percent bars or percentages will be displayed
 \fB\-B\fR, \fB\-\-bars\-on\-right\fR
 percent bars moved to right side of screen
 .TP
-\fB\-z\fR, \fB\-\-min\-size\fR=\fIMIN_SIZE\fR
+\fB\-z\fR, \fB\-\-min\-size\fR \fI<MIN_SIZE>\fR
 Minimum size file to include in output
 .TP
 \fB\-R\fR, \fB\-\-screen\-reader\fR
@@ -63,65 +66,108 @@ No total row will be displayed
 \fB\-f\fR, \fB\-\-filecount\fR
 Directory \*(Aqsize\*(Aq is number of child files instead of disk size
 .TP
-\fB\-i\fR, \fB\-\-ignore_hidden\fR
+\fB\-i\fR, \fB\-\-ignore\-hidden\fR
 Do not display hidden files
 .TP
-\fB\-v\fR, \fB\-\-invert\-filter\fR=\fIREGEX\fR
-Exclude filepaths matching this regex. To ignore png files type: \-v "\\.png$" 
+\fB\-v\fR, \fB\-\-invert\-filter\fR \fI<REGEX>\fR
+Exclude filepaths matching this regex. To ignore png files type: \-v "\\.png$"
 .TP
-\fB\-e\fR, \fB\-\-filter\fR=\fIREGEX\fR
-Only include filepaths matching this regex. For png files type: \-e "\\.png$" 
+\fB\-e\fR, \fB\-\-filter\fR \fI<REGEX>\fR
+Only include filepaths matching this regex. For png files type: \-e "\\.png$"
 .TP
-\fB\-t\fR, \fB\-\-file_types\fR
+\fB\-t\fR, \fB\-\-file\-types\fR
 show only these file types
 .TP
-\fB\-w\fR, \fB\-\-terminal_width\fR=\fIWIDTH\fR
+\fB\-w\fR, \fB\-\-terminal\-width\fR \fI<WIDTH>\fR
 Specify width of output overriding the auto detection of terminal width
 .TP
 \fB\-P\fR, \fB\-\-no\-progress\fR
-Disable the progress indication.
+Disable the progress indication
 .TP
 \fB\-\-print\-errors\fR
-Print path with errors.
+Print path with errors
 .TP
 \fB\-D\fR, \fB\-\-only\-dir\fR
-Only directories will be displayed.
+Only directories will be displayed
 .TP
 \fB\-F\fR, \fB\-\-only\-file\fR
 Only files will be displayed. (Finds your largest files)
 .TP
-\fB\-o\fR, \fB\-\-output\-format\fR=\fIFORMAT\fR
-Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size.
+\fB\-o\fR, \fB\-\-output\-format\fR \fI<FORMAT>\fR
+Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size
 .br

 .br
-[\fIpossible values: \fRsi, b, k, m, g, t, kb, mb, gb, tb]
+\fIPossible values:\fR
+.RS 14
+.IP \(bu 2
+si: SI prefix (powers of 1000)
+.IP \(bu 2
+b: byte (B)
+.IP \(bu 2
+k: kibibyte (KiB)
+.IP \(bu 2
+m: mebibyte (MiB)
+.IP \(bu 2
+g: gibibyte (GiB)
+.IP \(bu 2
+t: tebibyte (TiB)
+.IP \(bu 2
+kb: kilobyte (kB)
+.IP \(bu 2
+mb: megabyte (MB)
+.IP \(bu 2
+gb: gigabyte (GB)
+.IP \(bu 2
+tb: terabyte (TB)
+.RE
 .TP
-\fB\-S\fR, \fB\-\-stack\-size\fR=\fISTACK_SIZE\fR
+\fB\-S\fR, \fB\-\-stack\-size\fR \fI<STACK_SIZE>\fR
 Specify memory to use as stack size \- use if you see: \*(Aqfatal runtime error: stack overflow\*(Aq (default low memory=1048576, high memory=1073741824)
 .TP
 \fB\-j\fR, \fB\-\-output\-json\fR
 Output the directory tree as json to the current directory
 .TP
-\fB\-M\fR, \fB\-\-mtime\fR
+\fB\-M\fR, \fB\-\-mtime\fR \fI<MTIME>\fR
 +/\-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => [curr−(n+1), curr−n), and \-n => (𝑐𝑢𝑟𝑟−𝑛, +∞)
 .TP
-\fB\-A\fR, \fB\-\-atime\fR
+\fB\-A\fR, \fB\-\-atime\fR \fI<ATIME>\fR
 just like \-mtime, but based on file access time
 .TP
-\fB\-y\fR, \fB\-\-ctime\fR
+\fB\-y\fR, \fB\-\-ctime\fR \fI<CTIME>\fR
 just like \-mtime, but based on file change time
 .TP
-\fB\-\-files0\-from\fR
-run dust on NUL\-terminated file names specified in file; if argument is \-, then read names from standard input
+\fB\-\-files0\-from\fR \fI<FILES0_FROM>\fR
+Read NUL\-terminated paths from FILE (use `\-` for stdin)
+.TP
+\fB\-\-files\-from\fR \fI<FILES_FROM>\fR
+Read newline\-terminated paths from FILE (use `\-` for stdin)
+.TP
+\fB\-\-collapse\fR \fI<COLLAPSE>\fR
+Keep these directories collapsed
+.TP
+\fB\-m\fR, \fB\-\-filetime\fR \fI<FILETIME>\fR
+Directory \*(Aqsize\*(Aq is max filetime of child files instead of disk size. while a/c/m for last accessed/changed/modified time
+.br
+
+.br
+\fIPossible values:\fR
+.RS 14
+.IP \(bu 2
+a: last accessed time
+.IP \(bu 2
+c: last changed time
+.IP \(bu 2
+m: last modified time
+.RE
 .TP
 \fB\-h\fR, \fB\-\-help\fR
-Print help
+Print help (see a summary with \*(Aq\-h\*(Aq)
 .TP
 \fB\-V\fR, \fB\-\-version\fR
 Print version
 .TP
 [\fIPATH\fR]
-
+Input files or directories
 .SH VERSION
-v1.1.1
+v1.2.3
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -1,297 +1,261 @@
-use clap::{builder::PossibleValue, value_parser, Arg, Command};
+use std::fmt;
+
+use clap::{Parser, ValueEnum, ValueHint};

 // For single thread mode set this variable on your command line:
 // export RAYON_NUM_THREADS=1

-pub fn build_cli() -> Command {
-    Command::new("Dust")
-        .about("Like du but more intuitive")
-        .version(env!("CARGO_PKG_VERSION"))
-        .arg(
-            Arg::new("depth")
-                .short('d')
-                .long("depth")
-                .value_name("DEPTH")
-                .value_parser(value_parser!(usize))
-                .help("Depth to show")
-                .num_args(1)
-        )
-        .arg(
-            Arg::new("threads")
-                .short('T')
-                .long("threads")
-                .value_parser(value_parser!(usize))
-                .help("Number of threads to use")
-                .num_args(1)
-        )
-        .arg(
-            Arg::new("number_of_lines")
-                .short('n')
-                .long("number-of-lines")
-                .value_name("NUMBER")
-                .value_parser(value_parser!(usize))
-                .help("Number of lines of output to show. (Default is terminal_height - 10)")
-                .num_args(1)
-        )
-        .arg(
-            Arg::new("display_full_paths")
-                .short('p')
-                .long("full-paths")
-                .action(clap::ArgAction::SetTrue)
-                .help("Subdirectories will not have their path shortened"),
-        )
-        .arg(
-            Arg::new("ignore_directory")
-                .short('X')
-                .long("ignore-directory")
-                .value_name("PATH")
-                .value_hint(clap::ValueHint::AnyPath)
-                .action(clap::ArgAction::Append)
-                .help("Exclude any file or directory with this name"),
-        )
-        .arg(
-            Arg::new("ignore_all_in_file")
-                .short('I')
-                .long("ignore-all-in-file")
-                .value_name("FILE")
-                .value_hint(clap::ValueHint::FilePath)
-                .value_parser(value_parser!(String))
-                .help("Exclude any file or directory with a regex matching that listed in this file, the file entries will be added to the ignore regexs provided by --invert_filter"),
-        )
-         .arg(
-            Arg::new("dereference_links")
-                .short('L')
-                .long("dereference-links")
-                .action(clap::ArgAction::SetTrue)
-                .help("dereference sym links - Treat sym links as directories and go into them"),
-        )
-        .arg(
-            Arg::new("limit_filesystem")
-                .short('x')
-                .long("limit-filesystem")
-                .action(clap::ArgAction::SetTrue)
-                .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")
-                .action(clap::ArgAction::SetTrue)
-                .help("Use file length instead of blocks"),
-        )
-        .arg(
-            Arg::new("reverse")
-                .short('r')
-                .long("reverse")
-                .action(clap::ArgAction::SetTrue)
-                .help("Print tree upside down (biggest highest)"),
-        )
-        .arg(
-            Arg::new("no_colors")
-                .short('c')
-                .long("no-colors")
-                .action(clap::ArgAction::SetTrue)
-                .help("No colors will be printed (Useful for commands like: watch)"),
-        )
-        .arg(
-            Arg::new("force_colors")
-                .short('C')
-                .long("force-colors")
-                .action(clap::ArgAction::SetTrue)
-                .help("Force colors print"),
-        )
-        .arg(
-            Arg::new("no_bars")
-                .short('b')
-                .long("no-percent-bars")
-                .action(clap::ArgAction::SetTrue)
-                .help("No percent bars or percentages will be displayed"),
-        )
-        .arg(
-            Arg::new("bars_on_right")
-                .short('B')
-                .long("bars-on-right")
-                .action(clap::ArgAction::SetTrue)
-                .help("percent bars moved to right side of screen"),
-        )
-        .arg(
-            Arg::new("min_size")
-                .short('z')
-                .long("min-size")
-                .value_name("MIN_SIZE")
-                .num_args(1)
-                .help("Minimum size file to include in output"),
-        )
-        .arg(
-            Arg::new("screen_reader")
-                .short('R')
-                .long("screen-reader")
-                .action(clap::ArgAction::SetTrue)
-                .help("For screen readers. Removes bars. Adds new column: depth level (May want to use -p too for full path)"),
-        )
-        .arg(
-            Arg::new("skip_total")
-                .long("skip-total")
-                .action(clap::ArgAction::SetTrue)
-                .help("No total row will be displayed"),
-        )
-        .arg(
-            Arg::new("by_filecount")
-                .short('f')
-                .long("filecount")
-                .action(clap::ArgAction::SetTrue)
-                .help("Directory 'size' is number of child files instead of disk size"),
-        )
-        .arg(
-            Arg::new("ignore_hidden")
-                .short('i') // Do not use 'h' this is used by 'help'
-                .long("ignore_hidden")
-                .action(clap::ArgAction::SetTrue)
-                .help("Do not display hidden files"),
-        )
-        .arg(
-            Arg::new("invert_filter")
-                .short('v')
-                .long("invert-filter")
-                .value_name("REGEX")
-                .action(clap::ArgAction::Append)
-                .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")
-                .value_name("REGEX")
-                .action(clap::ArgAction::Append)
-                .conflicts_with("types")
-                .help("Only include filepaths matching this regex. For png files type: -e \"\\.png$\" "),
-        )
-        .arg(
-            Arg::new("types")
-                .short('t')
-                .long("file_types")
-                .conflicts_with("depth")
-                .conflicts_with("only_dir")
-                .action(clap::ArgAction::SetTrue)
-                .help("show only these file types"),
-        )
-        .arg(
-            Arg::new("width")
-                .short('w')
-                .long("terminal_width")
-                .value_name("WIDTH")
-                .value_parser(value_parser!(usize))
-                .num_args(1)
-                .help("Specify width of output overriding the auto detection of terminal width"),
-        )
-        .arg(
-            Arg::new("disable_progress")
-                .short('P')
-                .long("no-progress")
-                .action(clap::ArgAction::SetTrue)
-                .help("Disable the progress indication."),
-        )
-        .arg(
-            Arg::new("print_errors")
-                .long("print-errors")
-                .action(clap::ArgAction::SetTrue)
-                .help("Print path with errors."),
-        )
-        .arg(
-            Arg::new("only_dir")
-                .short('D')
-                .long("only-dir")
-                .conflicts_with("only_file")
-                .conflicts_with("types")
-                .action(clap::ArgAction::SetTrue)
-                .help("Only directories will be displayed."),
-        )
-        .arg(
-            Arg::new("only_file")
-                .short('F')
-                .long("only-file")
-                .conflicts_with("only_dir")
-                .action(clap::ArgAction::SetTrue)
-                .help("Only files will be displayed. (Finds your largest files)"),
-        )
-        .arg(
-            Arg::new("output_format")
-                .short('o')
-                .long("output-format")
-                .value_name("FORMAT")
-                .value_parser([
-                    PossibleValue::new("si"),
-                    PossibleValue::new("b"),
-                    PossibleValue::new("k").alias("kib"),
-                    PossibleValue::new("m").alias("mib"),
-                    PossibleValue::new("g").alias("gib"),
-                    PossibleValue::new("t").alias("tib"),
-                    PossibleValue::new("kb"),
-                    PossibleValue::new("mb"),
-                    PossibleValue::new("gb"),
-                    PossibleValue::new("tb"),
-                ])
-                .ignore_case(true)
-                .help("Changes output display size. si will print sizes in powers of 1000. b k m g t kb mb gb tb will print the whole tree in that size.")
-        )
-        .arg(
-            Arg::new("stack_size")
-                .short('S')
-                .long("stack-size")
-                .value_name("STACK_SIZE")
-                .value_parser(value_parser!(usize))
-                .num_args(1)
-                .help("Specify memory to use as stack size - use if you see: 'fatal runtime error: stack overflow' (default low memory=1048576, high memory=1073741824)"),
-        )
-        .arg(
-            Arg::new("params")
-                .value_name("PATH")
-                .value_hint(clap::ValueHint::AnyPath)
-                .value_parser(value_parser!(String))
-                .num_args(1..)
-        )
-        .arg(
-            Arg::new("output_json")
-                .short('j')
-                .long("output-json")
-                .action(clap::ArgAction::SetTrue)
-                .help("Output the directory tree as json to the current directory"),
-        )
-        .arg(
-            Arg::new("mtime")
-            .short('M')
-            .long("mtime")
-            .num_args(1)
-            .allow_hyphen_values(true)
-            .value_parser(value_parser!(String))
-            .help("+/-n matches files modified more/less than n days ago , and n matches files modified exactly n days ago, days are rounded down.That is +n => (−∞, curr−(n+1)), n => [curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)")
-        )
-        .arg(
-            Arg::new("atime")
-            .short('A')
-            .long("atime")
-            .num_args(1)
-            .allow_hyphen_values(true)
-            .value_parser(value_parser!(String))
-            .help("just like -mtime, but based on file access time")
-        )
-        .arg(
-            Arg::new("ctime")
-            .short('y')
-            .long("ctime")
-            .num_args(1)
-            .allow_hyphen_values(true)
-            .value_parser(value_parser!(String))
-            .help("just like -mtime, but based on file change time")
-        )
-        .arg(
-            Arg::new("files0_from")
-                .long("files0-from")
-                .value_hint(clap::ValueHint::AnyPath)
-                .value_parser(value_parser!(String))
-                .num_args(1)
-                .help("run dust on NUL-terminated file names specified in file; if argument is -, then read names from standard input"),
-        )
+/// Like du but more intuitive
+#[derive(Debug, Parser)]
+#[command(name("Dust"), version)]
+pub struct Cli {
+    /// Depth to show
+    #[arg(short, long)]
+    pub depth: Option<usize>,
+
+    /// Number of threads to use
+    #[arg(short('T'), long)]
+    pub threads: Option<usize>,
+
+    /// Specify a config file to use
+    #[arg(long, value_name("FILE"), value_hint(ValueHint::FilePath))]
+    pub config: Option<String>,
+
+    /// Number of lines of output to show. (Default is terminal_height - 10)
+    #[arg(short, long, value_name("NUMBER"))]
+    pub number_of_lines: Option<usize>,
+
+    /// Subdirectories will not have their path shortened
+    #[arg(short('p'), long)]
+    pub full_paths: bool,
+
+    /// Exclude any file or directory with this path
+    #[arg(short('X'), long, value_name("PATH"), value_hint(ValueHint::AnyPath))]
+    pub ignore_directory: Option<Vec<String>>,
+
+    /// Exclude any file or directory with a regex matching that listed in this
+    /// file, the file entries will be added to the ignore regexs provided by
+    /// --invert_filter
+    #[arg(short('I'), long, value_name("FILE"), value_hint(ValueHint::FilePath))]
+    pub ignore_all_in_file: Option<String>,
+
+    /// dereference sym links - Treat sym links as directories and go into them
+    #[arg(short('L'), long)]
+    pub dereference_links: bool,
+
+    /// Only count the files and directories on the same filesystem as the
+    /// supplied directory
+    #[arg(short('x'), long)]
+    pub limit_filesystem: bool,
+
+    /// Use file length instead of blocks
+    #[arg(short('s'), long)]
+    pub apparent_size: bool,
+
+    /// Print tree upside down (biggest highest)
+    #[arg(short, long)]
+    pub reverse: bool,
+
+    /// No colors will be printed (Useful for commands like: watch)
+    #[arg(short('c'), long)]
+    pub no_colors: bool,
+
+    /// Force colors print
+    #[arg(short('C'), long)]
+    pub force_colors: bool,
+
+    /// No percent bars or percentages will be displayed
+    #[arg(short('b'), long)]
+    pub no_percent_bars: bool,
+
+    /// percent bars moved to right side of screen
+    #[arg(short('B'), long)]
+    pub bars_on_right: bool,
+
+    /// Minimum size file to include in output
+    #[arg(short('z'), long)]
+    pub min_size: Option<String>,
+
+    /// For screen readers. Removes bars. Adds new column: depth level (May want
+    /// to use -p too for full path)
+    #[arg(short('R'), long)]
+    pub screen_reader: bool,
+
+    /// No total row will be displayed
+    #[arg(long)]
+    pub skip_total: bool,
+
+    /// Directory 'size' is number of child files instead of disk size
+    #[arg(short, long)]
+    pub filecount: bool,
+
+    /// Do not display hidden files
+    // Do not use 'h' this is used by 'help'
+    #[arg(short, long)]
+    pub ignore_hidden: bool,
+
+    /// Exclude filepaths matching this regex. To ignore png files type: -v
+    /// "\.png$"
+    #[arg(
+        short('v'),
+        long,
+        value_name("REGEX"),
+        conflicts_with("filter"),
+        conflicts_with("file_types")
+    )]
+    pub invert_filter: Option<Vec<String>>,
+
+    /// Only include filepaths matching this regex. For png files type: -e
+    /// "\.png$"
+    #[arg(short('e'), long, value_name("REGEX"), conflicts_with("file_types"))]
+    pub filter: Option<Vec<String>>,
+
+    /// show only these file types
+    #[arg(short('t'), long, conflicts_with("depth"), conflicts_with("only_dir"))]
+    pub file_types: bool,
+
+    /// Specify width of output overriding the auto detection of terminal width
+    #[arg(short('w'), long, value_name("WIDTH"))]
+    pub terminal_width: Option<usize>,
+
+    /// Disable the progress indication.
+    #[arg(short('P'), long)]
+    pub no_progress: bool,
+
+    /// Print path with errors.
+    #[arg(long)]
+    pub print_errors: bool,
+
+    /// Only directories will be displayed.
+    #[arg(
+        short('D'),
+        long,
+        conflicts_with("only_file"),
+        conflicts_with("file_types")
+    )]
+    pub only_dir: bool,
+
+    /// Only files will be displayed. (Finds your largest files)
+    #[arg(short('F'), long, conflicts_with("only_dir"))]
+    pub only_file: bool,
+
+    /// Changes output display size. si will print sizes in powers of 1000. b k
+    /// m g t kb mb gb tb will print the whole tree in that size.
+    #[arg(short, long, value_enum, value_name("FORMAT"), ignore_case(true))]
+    pub output_format: Option<OutputFormat>,
+
+    /// Specify memory to use as stack size - use if you see: 'fatal runtime
+    /// error: stack overflow' (default low memory=1048576, high
+    /// memory=1073741824)
+    #[arg(short('S'), long)]
+    pub stack_size: Option<usize>,
+
+    /// Input files or directories.
+    #[arg(value_name("PATH"), value_hint(ValueHint::AnyPath))]
+    pub params: Option<Vec<String>>,
+
+    /// Output the directory tree as json to the current directory
+    #[arg(short('j'), long)]
+    pub output_json: bool,
+
+    /// +/-n matches files modified more/less than n days ago , and n matches
+    /// files modified exactly n days ago, days are rounded down.That is +n =>
+    /// (−∞, curr−(n+1)), n => [curr−(n+1), curr−n), and -n => (𝑐𝑢𝑟𝑟−𝑛, +∞)
+    #[arg(short('M'), long, allow_hyphen_values(true))]
+    pub mtime: Option<String>,
+
+    /// just like -mtime, but based on file access time
+    #[arg(short('A'), long, allow_hyphen_values(true))]
+    pub atime: Option<String>,
+
+    /// just like -mtime, but based on file change time
+    #[arg(short('y'), long, allow_hyphen_values(true))]
+    pub ctime: Option<String>,
+
+    /// Read NUL-terminated paths from FILE (use `-` for stdin).
+    #[arg(long, value_hint(ValueHint::AnyPath), conflicts_with("files_from"))]
+    pub files0_from: Option<String>,
+
+    /// Read newline-terminated paths from FILE (use `-` for stdin).
+    #[arg(long, value_hint(ValueHint::AnyPath), conflicts_with("files0_from"))]
+    pub files_from: Option<String>,
+
+    /// Keep these directories collapsed
+    #[arg(long, value_hint(ValueHint::AnyPath))]
+    pub collapse: Option<Vec<String>>,
+
+    /// Directory 'size' is max filetime of child files instead of disk size.
+    /// while a/c/m for last accessed/changed/modified time
+    #[arg(short('m'), long, value_enum)]
+    pub filetime: Option<FileTime>,
+}
+
+#[derive(Clone, Copy, Debug, ValueEnum)]
+#[value(rename_all = "lower")]
+pub enum OutputFormat {
+    /// SI prefix (powers of 1000)
+    SI,
+
+    /// byte (B)
+    B,
+
+    /// kibibyte (KiB)
+    #[value(name = "k", alias("kib"))]
+    KiB,
+
+    /// mebibyte (MiB)
+    #[value(name = "m", alias("mib"))]
+    MiB,
+
+    /// gibibyte (GiB)
+    #[value(name = "g", alias("gib"))]
+    GiB,
+
+    /// tebibyte (TiB)
+    #[value(name = "t", alias("tib"))]
+    TiB,
+
+    /// kilobyte (kB)
+    KB,
+
+    /// megabyte (MB)
+    MB,
+
+    /// gigabyte (GB)
+    GB,
+
+    /// terabyte (TB)
+    TB,
+}
+
+impl fmt::Display for OutputFormat {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::SI => write!(f, "si"),
+            Self::B => write!(f, "b"),
+            Self::KiB => write!(f, "k"),
+            Self::MiB => write!(f, "m"),
+            Self::GiB => write!(f, "g"),
+            Self::TiB => write!(f, "t"),
+            Self::KB => write!(f, "kb"),
+            Self::MB => write!(f, "mb"),
+            Self::GB => write!(f, "gb"),
+            Self::TB => write!(f, "tb"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, ValueEnum)]
+pub enum FileTime {
+    /// last accessed time
+    #[value(name = "a", alias("accessed"))]
+    Accessed,
+
+    /// last changed time
+    #[value(name = "c", alias("changed"))]
+    Changed,
+
+    /// last modified time
+    #[value(name = "m", alias("modified"))]
+    Modified,
 }
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,20 +1,19 @@
+use crate::node::FileTime;
 use chrono::{Local, TimeZone};
-use clap::ArgMatches;
 use config_file::FromConfigFile;
 use regex::Regex;
 use serde::Deserialize;
-use std::io::IsTerminal;
 use std::path::Path;
 use std::path::PathBuf;

-use crate::dir_walker::Operater;
+use crate::cli::Cli;
+use crate::dir_walker::Operator;
 use crate::display::get_number_format;

 pub static DAY_SECONDS: i64 = 24 * 60 * 60;

 #[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>,
@@ -37,68 +36,81 @@ pub struct Config {
    pub output_json: Option<bool>,
    pub print_errors: Option<bool>,
    pub files0_from: Option<String>,
+    pub number_of_lines: Option<usize>,
+    pub files_from: Option<String>,
 }

 impl Config {
-    pub fn get_files_from(&self, options: &ArgMatches) -> Option<String> {
-        let from_file = options.get_one::<String>("files0_from");
+    pub fn get_files0_from(&self, options: &Cli) -> Option<String> {
+        let from_file = &options.files0_from;
        match from_file {
            None => self.files0_from.as_ref().map(|x| x.to_string()),
            Some(x) => Some(x.to_string()),
        }
    }
-    pub fn get_no_colors(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.no_colors || options.get_flag("no_colors")
+
+    pub fn get_files_from(&self, options: &Cli) -> Option<String> {
+        let from_file = &options.files_from;
+        match from_file {
+            None => self.files_from.as_ref().map(|x| x.to_string()),
+            Some(x) => Some(x.to_string()),
+        }
    }
-    pub fn get_force_colors(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.force_colors || options.get_flag("force_colors")
+    pub fn get_no_colors(&self, options: &Cli) -> bool {
+        Some(true) == self.no_colors || options.no_colors
    }
-    pub fn get_disable_progress(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.disable_progress
-            || options.get_flag("disable_progress")
-            || !std::io::stdout().is_terminal()
+    pub fn get_force_colors(&self, options: &Cli) -> bool {
+        Some(true) == self.force_colors || options.force_colors
    }
-    pub fn get_apparent_size(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.display_apparent_size || options.get_flag("display_apparent_size")
+    pub fn get_disable_progress(&self, options: &Cli) -> bool {
+        Some(true) == self.disable_progress || options.no_progress
    }
-    pub fn get_ignore_hidden(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.ignore_hidden || options.get_flag("ignore_hidden")
+    pub fn get_apparent_size(&self, options: &Cli) -> bool {
+        Some(true) == self.display_apparent_size || options.apparent_size
    }
-    pub fn get_full_paths(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.display_full_paths || options.get_flag("display_full_paths")
+    pub fn get_ignore_hidden(&self, options: &Cli) -> bool {
+        Some(true) == self.ignore_hidden || options.ignore_hidden
    }
-    pub fn get_reverse(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.reverse || options.get_flag("reverse")
+    pub fn get_full_paths(&self, options: &Cli) -> bool {
+        Some(true) == self.display_full_paths || options.full_paths
    }
-    pub fn get_no_bars(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.no_bars || options.get_flag("no_bars")
+    pub fn get_reverse(&self, options: &Cli) -> bool {
+        Some(true) == self.reverse || options.reverse
    }
-    pub fn get_output_format(&self, options: &ArgMatches) -> String {
-        let out_fmt = options.get_one::<String>("output_format");
+    pub fn get_no_bars(&self, options: &Cli) -> bool {
+        Some(true) == self.no_bars || options.no_percent_bars
+    }
+    pub fn get_output_format(&self, options: &Cli) -> String {
+        let out_fmt = options.output_format;
        (match out_fmt {
            None => match &self.output_format {
                None => "".to_string(),
                Some(x) => x.to_string(),
            },
-            Some(x) => x.into(),
+            Some(x) => x.to_string(),
        })
        .to_lowercase()
    }
-    pub fn get_skip_total(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.skip_total || options.get_flag("skip_total")
+
+    pub fn get_filetime(&self, options: &Cli) -> Option<FileTime> {
+        options.filetime.map(FileTime::from)
    }
-    pub fn get_screen_reader(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.screen_reader || options.get_flag("screen_reader")
+
+    pub fn get_skip_total(&self, options: &Cli) -> bool {
+        Some(true) == self.skip_total || options.skip_total
    }
-    pub fn get_depth(&self, options: &ArgMatches) -> usize {
-        if let Some(v) = options.get_one::<usize>("depth") {
-            return *v;
+    pub fn get_screen_reader(&self, options: &Cli) -> bool {
+        Some(true) == self.screen_reader || options.screen_reader
+    }
+    pub fn get_depth(&self, options: &Cli) -> usize {
+        if let Some(v) = options.depth {
+            return v;
        }

        self.depth.unwrap_or(usize::MAX)
    }
-    pub fn get_min_size(&self, options: &ArgMatches) -> Option<usize> {
-        let size_from_param = options.get_one::<String>("min_size");
+    pub fn get_min_size(&self, options: &Cli) -> Option<usize> {
+        let size_from_param = options.min_size.as_ref();
        self._get_min_size(size_from_param)
    }
    fn _get_min_size(&self, min_size: Option<&String>) -> Option<usize> {
@@ -112,63 +124,63 @@ impl Config {
            size_from_param
        }
    }
-    pub fn get_only_dir(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.only_dir || options.get_flag("only_dir")
+    pub fn get_only_dir(&self, options: &Cli) -> bool {
+        Some(true) == self.only_dir || options.only_dir
    }

-    pub fn get_print_errors(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.print_errors || options.get_flag("print_errors")
+    pub fn get_print_errors(&self, options: &Cli) -> bool {
+        Some(true) == self.print_errors || options.print_errors
    }
-    pub fn get_only_file(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.only_file || options.get_flag("only_file")
+    pub fn get_only_file(&self, options: &Cli) -> bool {
+        Some(true) == self.only_file || options.only_file
    }
-    pub fn get_bars_on_right(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.bars_on_right || options.get_flag("bars_on_right")
+    pub fn get_bars_on_right(&self, options: &Cli) -> bool {
+        Some(true) == self.bars_on_right || options.bars_on_right
    }
-    pub fn get_custom_stack_size(&self, options: &ArgMatches) -> Option<usize> {
-        let from_cmd_line = options.get_one::<usize>("stack_size");
+    pub fn get_custom_stack_size(&self, options: &Cli) -> Option<usize> {
+        let from_cmd_line = options.stack_size;
        if from_cmd_line.is_none() {
            self.stack_size
        } else {
-            from_cmd_line.copied()
+            from_cmd_line
        }
    }
-    pub fn get_threads(&self, options: &ArgMatches) -> Option<usize> {
-        let from_cmd_line = options.get_one::<usize>("threads");
+    pub fn get_threads(&self, options: &Cli) -> Option<usize> {
+        let from_cmd_line = options.threads;
        if from_cmd_line.is_none() {
            self.threads
        } else {
-            from_cmd_line.copied()
+            from_cmd_line
        }
    }
-    pub fn get_output_json(&self, options: &ArgMatches) -> bool {
-        Some(true) == self.output_json || options.get_flag("output_json")
+    pub fn get_output_json(&self, options: &Cli) -> bool {
+        Some(true) == self.output_json || options.output_json
    }

-    pub fn get_modified_time_operator(&self, options: &ArgMatches) -> Option<(Operater, i64)> {
-        get_filter_time_operator(
-            options.get_one::<String>("mtime"),
-            get_current_date_epoch_seconds(),
-        )
+    pub fn get_number_of_lines(&self, options: &Cli) -> Option<usize> {
+        let from_cmd_line = options.number_of_lines;
+        if from_cmd_line.is_none() {
+            self.number_of_lines
+        } else {
+            from_cmd_line
+        }
    }

-    pub fn get_accessed_time_operator(&self, options: &ArgMatches) -> Option<(Operater, i64)> {
-        get_filter_time_operator(
-            options.get_one::<String>("atime"),
-            get_current_date_epoch_seconds(),
-        )
+    pub fn get_modified_time_operator(&self, options: &Cli) -> Option<(Operator, i64)> {
+        get_filter_time_operator(options.mtime.as_ref(), get_current_date_epoch_seconds())
    }

-    pub fn get_created_time_operator(&self, options: &ArgMatches) -> Option<(Operater, i64)> {
-        get_filter_time_operator(
-            options.get_one::<String>("ctime"),
-            get_current_date_epoch_seconds(),
-        )
+    pub fn get_accessed_time_operator(&self, options: &Cli) -> Option<(Operator, i64)> {
+        get_filter_time_operator(options.atime.as_ref(), get_current_date_epoch_seconds())
+    }
+
+    pub fn get_changed_time_operator(&self, options: &Cli) -> Option<(Operator, i64)> {
+        get_filter_time_operator(options.ctime.as_ref(), get_current_date_epoch_seconds())
    }
 }

 fn get_current_date_epoch_seconds() -> i64 {
-    // calcurate current date epoch seconds
+    // calculate current date epoch seconds
    let now = Local::now();
    let current_date = now.date_naive();

@@ -182,7 +194,7 @@ fn get_current_date_epoch_seconds() -> i64 {
 fn get_filter_time_operator(
    option_value: Option<&String>,
    current_date_epoch_seconds: i64,
-) -> Option<(Operater, i64)> {
+) -> Option<(Operator, i64)> {
    match option_value {
        Some(val) => {
            let time = current_date_epoch_seconds
@@ -192,9 +204,9 @@ fn get_filter_time_operator(
                    .abs()
                    * DAY_SECONDS;
            match val.chars().next().expect("Value should not be empty") {
-                '+' => Some((Operater::LessThan, time - DAY_SECONDS)),
-                '-' => Some((Operater::GreaterThan, time)),
-                _ => Some((Operater::Equal, time - DAY_SECONDS)),
+                '+' => Some((Operator::LessThan, time - DAY_SECONDS)),
+                '-' => Some((Operator::GreaterThan, time)),
+                _ => Some((Operator::Equal, time - DAY_SECONDS)),
            }
        }
        None => None,
@@ -216,7 +228,7 @@ fn convert_min_size(input: &str) -> Option<usize> {
                match number_format {
                    Some((multiple, _)) => Some(parsed_digits * (multiple as usize)),
                    None => {
-                        if letters.eq("") {
+                        if letters.is_empty() {
                            Some(parsed_digits)
                        } else {
                            eprintln!("Ignoring invalid min-size: {input}");
@@ -239,12 +251,29 @@ fn get_config_locations(base: &Path) -> Vec<PathBuf> {
    ]
 }

-pub fn get_config() -> Config {
-    if let Some(home) = directories::BaseDirs::new() {
-        for path in get_config_locations(home.home_dir()) {
+pub fn get_config(conf_path: Option<&String>) -> Config {
+    match conf_path {
+        Some(path_str) => {
+            let path = Path::new(path_str);
            if path.exists() {
-                if let Ok(config) = Config::from_config_file(path) {
-                    return config;
+                match Config::from_config_file(path) {
+                    Ok(config) => return config,
+                    Err(e) => {
+                        eprintln!("Ignoring invalid config file '{}': {}", &path.display(), e)
+                    }
+                }
+            } else {
+                eprintln!("Config file {:?} doesn't exists", &path.display());
+            }
+        }
+        None => {
+            if let Some(home) = directories::BaseDirs::new() {
+                for path in get_config_locations(home.home_dir()) {
+                    if path.exists()
+                        && let Ok(config) = Config::from_config_file(&path)
+                    {
+                        return config;
+                    }
                }
            }
        }
@@ -259,7 +288,7 @@ mod tests {
    #[allow(unused_imports)]
    use super::*;
    use chrono::{Datelike, Timelike};
-    use clap::{value_parser, Arg, ArgMatches, Command};
+    use clap::Parser;

    #[test]
    fn test_get_current_date_epoch_seconds() {
@@ -328,14 +357,75 @@ mod tests {
        assert_eq!(c.get_depth(&args), 5);
    }

-    fn get_args(args: Vec<&str>) -> ArgMatches {
-        Command::new("Dust")
-            .arg(
-                Arg::new("depth")
-                    .long("depth")
-                    .num_args(1)
-                    .value_parser(value_parser!(usize)),
-            )
-            .get_matches_from(args)
+    fn get_args(args: Vec<&str>) -> Cli {
+        Cli::parse_from(args)
+    }
+
+    #[test]
+    fn test_get_filetime() {
+        // No config and no flag.
+        let c = Config::default();
+        let args = get_filetime_args(vec!["dust"]);
+        assert_eq!(c.get_filetime(&args), None);
+
+        // Config is not defined and flag is defined as access time
+        let c = Config::default();
+        let args = get_filetime_args(vec!["dust", "--filetime", "a"]);
+        assert_eq!(c.get_filetime(&args), Some(FileTime::Accessed));
+
+        let c = Config::default();
+        let args = get_filetime_args(vec!["dust", "--filetime", "accessed"]);
+        assert_eq!(c.get_filetime(&args), Some(FileTime::Accessed));
+
+        // Config is not defined and flag is defined as modified time
+        let c = Config::default();
+        let args = get_filetime_args(vec!["dust", "--filetime", "m"]);
+        assert_eq!(c.get_filetime(&args), Some(FileTime::Modified));
+
+        let c = Config::default();
+        let args = get_filetime_args(vec!["dust", "--filetime", "modified"]);
+        assert_eq!(c.get_filetime(&args), Some(FileTime::Modified));
+
+        // Config is not defined and flag is defined as changed time
+        let c = Config::default();
+        let args = get_filetime_args(vec!["dust", "--filetime", "c"]);
+        assert_eq!(c.get_filetime(&args), Some(FileTime::Changed));
+
+        let c = Config::default();
+        let args = get_filetime_args(vec!["dust", "--filetime", "changed"]);
+        assert_eq!(c.get_filetime(&args), Some(FileTime::Changed));
+    }
+
+    fn get_filetime_args(args: Vec<&str>) -> Cli {
+        Cli::parse_from(args)
+    }
+
+    #[test]
+    fn test_get_number_of_lines() {
+        // No config and no flag.
+        let c = Config::default();
+        let args = get_args(vec![]);
+        assert_eq!(c.get_number_of_lines(&args), None);
+
+        // Config is not defined and flag is defined.
+        let c = Config::default();
+        let args = get_args(vec!["dust", "--number-of-lines", "5"]);
+        assert_eq!(c.get_number_of_lines(&args), Some(5));
+
+        // Config is defined and flag is not defined.
+        let c = Config {
+            number_of_lines: Some(3),
+            ..Default::default()
+        };
+        let args = get_args(vec![]);
+        assert_eq!(c.get_number_of_lines(&args), Some(3));
+
+        // Both config and flag are defined.
+        let c = Config {
+            number_of_lines: Some(3),
+            ..Default::default()
+        };
+        let args = get_args(vec!["dust", "--number-of-lines", "5"]);
+        assert_eq!(c.get_number_of_lines(&args), Some(5));
    }
 }
--- a/src/dir_walker.rs
+++ b/src/dir_walker.rs
@@ -1,19 +1,21 @@
 use std::cmp::Ordering;
 use std::fs;
+use std::io::Error;
 use std::sync::Arc;
 use std::sync::Mutex;

 use crate::node::Node;
+use crate::progress::ORDERING;
 use crate::progress::Operation;
 use crate::progress::PAtomicInfo;
 use crate::progress::RuntimeErrors;
-use crate::progress::ORDERING;
 use crate::utils::is_filtered_out_due_to_file_time;
 use crate::utils::is_filtered_out_due_to_invert_regex;
 use crate::utils::is_filtered_out_due_to_regex;
 use rayon::iter::ParallelBridge;
 use rayon::prelude::ParallelIterator;
 use regex::Regex;
+use std::path::Path;
 use std::path::PathBuf;

 use std::collections::HashSet;
@@ -21,10 +23,11 @@ use std::collections::HashSet;
 use crate::node::build_node;
 use std::fs::DirEntry;

+use crate::node::FileTime;
 use crate::platform::get_metadata;

 #[derive(Debug)]
-pub enum Operater {
+pub enum Operator {
    Equal = 0,
    LessThan = 1,
    GreaterThan = 2,
@@ -35,11 +38,12 @@ pub struct WalkData<'a> {
    pub filter_regex: &'a [Regex],
    pub invert_filter_regex: &'a [Regex],
    pub allowed_filesystems: HashSet<u64>,
-    pub filter_modified_time: Option<(Operater, i64)>,
-    pub filter_accessed_time: Option<(Operater, i64)>,
-    pub filter_changed_time: Option<(Operater, i64)>,
+    pub filter_modified_time: Option<(Operator, i64)>,
+    pub filter_accessed_time: Option<(Operator, i64)>,
+    pub filter_changed_time: Option<(Operator, i64)>,
    pub use_apparent_size: bool,
    pub by_filecount: bool,
+    pub by_filetime: &'a Option<FileTime>,
    pub ignore_hidden: bool,
    pub follow_links: bool,
    pub progress_data: Arc<PAtomicInfo>,
@@ -57,24 +61,19 @@ pub fn walk_it(dirs: HashSet<PathBuf>, walk_data: &WalkData) -> Vec<Node> {

            prog_data.state.store(Operation::PREPARING, ORDERING);

-            clean_inodes(node, &mut inodes, walk_data.use_apparent_size)
+            clean_inodes(node, &mut inodes, walk_data)
        })
        .collect();
    top_level_nodes
 }

 // Remove files which have the same inode, we don't want to double count them.
-fn clean_inodes(
-    x: Node,
-    inodes: &mut HashSet<(u64, u64)>,
-    use_apparent_size: bool,
-) -> Option<Node> {
-    if !use_apparent_size {
-        if let Some(id) = x.inode_device {
-            if !inodes.insert(id) {
-                return None;
-            }
-        }
+fn clean_inodes(x: Node, inodes: &mut HashSet<(u64, u64)>, walk_data: &WalkData) -> Option<Node> {
+    if !walk_data.use_apparent_size
+        && let Some(id) = x.inode_device
+        && !inodes.insert(id)
+    {
+        return None;
    }

    // Sort Nodes so iteration order is predictable
@@ -82,12 +81,25 @@ fn clean_inodes(
    tmp.sort_by(sort_by_inode);
    let new_children: Vec<_> = tmp
        .into_iter()
-        .filter_map(|c| clean_inodes(c, inodes, use_apparent_size))
+        .filter_map(|c| clean_inodes(c, inodes, walk_data))
        .collect();

+    let actual_size = if walk_data.by_filetime.is_some() {
+        // If by_filetime is Some, directory 'size' is the maximum filetime among child files instead of disk size
+        new_children
+            .iter()
+            .map(|c| c.size)
+            .chain(std::iter::once(x.size))
+            .max()
+            .unwrap_or(0)
+    } else {
+        // If by_filetime is None, directory 'size' is the sum of disk sizes or file counts of child files
+        x.size + new_children.iter().map(|c| c.size).sum::<u64>()
+    };
+
    Some(Node {
        name: x.name,
-        size: x.size + new_children.iter().map(|c| c.size).sum::<u64>(),
+        size: actual_size,
        children: new_children,
        inode_device: x.inode_device,
        depth: x.depth,
@@ -112,37 +124,61 @@ fn sort_by_inode(a: &Node, b: &Node) -> std::cmp::Ordering {
    }
 }

+// Check if `path` is inside ignored directory
+fn is_ignored_path(path: &Path, walk_data: &WalkData) -> bool {
+    if walk_data.ignore_directories.contains(path) {
+        return true;
+    }
+
+    // Entry is inside an ignored absolute path
+    // Absolute paths should be canonicalized before being added to `WalkData.ignore_directories`
+    for ignored_path in walk_data.ignore_directories.iter() {
+        if !ignored_path.is_absolute() {
+            continue;
+        }
+        let absolute_entry_path = std::fs::canonicalize(path).unwrap_or_default();
+        if absolute_entry_path.starts_with(ignored_path) {
+            return true;
+        }
+    }
+
+    false
+}
+
 fn ignore_file(entry: &DirEntry, walk_data: &WalkData) -> bool {
+    if is_ignored_path(&entry.path(), walk_data) {
+        return true;
+    }
+
    let is_dot_file = entry.file_name().to_str().unwrap_or("").starts_with('.');
-    let is_ignored_path = walk_data.ignore_directories.contains(&entry.path());
+    let follow_links = walk_data.follow_links && entry.file_type().is_ok_and(|ft| ft.is_symlink());

    if !walk_data.allowed_filesystems.is_empty() {
-        let size_inode_device = get_metadata(entry.path(), false);
-        if let Some((_size, Some((_id, dev)), _gunk)) = size_inode_device {
-            if !walk_data.allowed_filesystems.contains(&dev) {
-                return true;
-            }
+        let size_inode_device = get_metadata(entry.path(), false, follow_links);
+        if let Some((_size, Some((_id, dev)), _gunk)) = size_inode_device
+            && !walk_data.allowed_filesystems.contains(&dev)
+        {
+            return true;
        }
    }
    if walk_data.filter_accessed_time.is_some()
        || walk_data.filter_modified_time.is_some()
        || walk_data.filter_changed_time.is_some()
    {
-        let size_inode_device = get_metadata(entry.path(), false);
-        if let Some((_, _, (modified_time, accessed_time, changed_time))) = size_inode_device {
-            if entry.path().is_file()
-                && [
-                    (&walk_data.filter_modified_time, modified_time),
-                    (&walk_data.filter_accessed_time, accessed_time),
-                    (&walk_data.filter_changed_time, changed_time),
-                ]
-                .iter()
-                .any(|(filter_time, actual_time)| {
-                    is_filtered_out_due_to_file_time(filter_time, *actual_time)
-                })
-            {
-                return true;
-            }
+        let size_inode_device = get_metadata(entry.path(), false, follow_links);
+        if let Some((_, _, (modified_time, accessed_time, changed_time))) = size_inode_device
+            && entry.path().is_file()
+            && [
+                (&walk_data.filter_modified_time, modified_time),
+                (&walk_data.filter_accessed_time, accessed_time),
+                (&walk_data.filter_changed_time, changed_time),
+            ]
+            .iter()
+            .any(|(filter_time, actual_time)| {
+                is_filtered_out_due_to_file_time(filter_time, *actual_time)
+            })
+        {
+            return true;
        }
    }

@@ -161,17 +197,13 @@ fn ignore_file(entry: &DirEntry, walk_data: &WalkData) -> bool {
        return true;
    }

-    (is_dot_file && walk_data.ignore_hidden) || is_ignored_path
+    is_dot_file && walk_data.ignore_hidden
 }

 fn walk(dir: PathBuf, walk_data: &WalkData, depth: usize) -> Option<Node> {
    let prog_data = &walk_data.progress_data;
    let errors = &walk_data.errors;

-    if errors.lock().unwrap().abort {
-        return None;
-    }
-
    let children = if dir.is_dir() {
        let read_dir = fs::read_dir(&dir);
        match read_dir {
@@ -188,37 +220,36 @@ fn walk(dir: PathBuf, walk_data: &WalkData, depth: usize) -> Option<Node> {

                                // return walk(entry.path(), walk_data, depth)

-                                if !ignore_file(entry, walk_data) {
-                                    if let Ok(data) = entry.file_type() {
-                                        if data.is_dir()
-                                            || (walk_data.follow_links && data.is_symlink())
-                                        {
-                                            return walk(entry.path(), walk_data, depth + 1);
-                                        }
-
-                                        let node = build_node(
-                                            entry.path(),
-                                            vec![],
-                                            data.is_symlink(),
-                                            data.is_file(),
-                                            depth,
-                                            walk_data,
-                                        );
-
-                                        prog_data.num_files.fetch_add(1, ORDERING);
-                                        if let Some(ref file) = node {
-                                            prog_data
-                                                .total_file_size
-                                                .fetch_add(file.size, ORDERING);
-                                        }
-
-                                        return node;
+                                if !ignore_file(entry, walk_data)
+                                    && let Ok(data) = entry.file_type()
+                                {
+                                    if data.is_dir()
+                                        || (walk_data.follow_links && data.is_symlink())
+                                    {
+                                        return walk(entry.path(), walk_data, depth + 1);
                                    }
+
+                                    let node = build_node(
+                                        entry.path(),
+                                        vec![],
+                                        data.is_symlink(),
+                                        data.is_file(),
+                                        depth,
+                                        walk_data,
+                                    );
+
+                                    prog_data.num_files.fetch_add(1, ORDERING);
+                                    if let Some(ref file) = node {
+                                        prog_data.total_file_size.fetch_add(file.size, ORDERING);
+                                    }
+
+                                    return node;
                                }
                            }
                            Err(ref failed) => {
-                                let mut editable_error = errors.lock().unwrap();
-                                editable_error.no_permissions.insert(failed.to_string());
+                                if handle_error_and_retry(failed, &dir, walk_data) {
+                                    return walk(dir.clone(), walk_data, depth);
+                                }
                            }
                        }
                        None
@@ -226,21 +257,11 @@ fn walk(dir: PathBuf, walk_data: &WalkData, depth: usize) -> Option<Node> {
                    .collect()
            }
            Err(failed) => {
-                let mut editable_error = errors.lock().unwrap();
-                match failed.kind() {
-                    std::io::ErrorKind::PermissionDenied => {
-                        editable_error
-                            .no_permissions
-                            .insert(dir.to_string_lossy().into());
-                    }
-                    std::io::ErrorKind::NotFound => {
-                        editable_error.file_not_found.insert(failed.to_string());
-                    }
-                    _ => {
-                        editable_error.unknown_error.insert(failed.to_string());
-                    }
+                if handle_error_and_retry(&failed, &dir, walk_data) {
+                    return walk(dir, walk_data, depth);
+                } else {
+                    vec![]
                }
-                vec![]
            }
        }
    } else {
@@ -251,7 +272,48 @@ fn walk(dir: PathBuf, walk_data: &WalkData, depth: usize) -> Option<Node> {
        }
        vec![]
    };
-    build_node(dir, children, false, false, depth, walk_data)
+    let is_symlink = if walk_data.follow_links {
+        match fs::symlink_metadata(&dir) {
+            Ok(metadata) => metadata.file_type().is_symlink(),
+            Err(_) => false,
+        }
+    } else {
+        false
+    };
+    build_node(dir, children, is_symlink, false, depth, walk_data)
+}
+
+fn handle_error_and_retry(failed: &Error, dir: &Path, walk_data: &WalkData) -> bool {
+    let mut editable_error = walk_data.errors.lock().unwrap();
+    match failed.kind() {
+        std::io::ErrorKind::PermissionDenied => {
+            editable_error
+                .no_permissions
+                .insert(dir.to_string_lossy().into());
+        }
+        std::io::ErrorKind::InvalidInput => {
+            editable_error
+                .no_permissions
+                .insert(dir.to_string_lossy().into());
+        }
+        std::io::ErrorKind::NotFound => {
+            editable_error.file_not_found.insert(failed.to_string());
+        }
+        std::io::ErrorKind::Interrupted => {
+            editable_error.interrupted_error += 1;
+            // This does happen on some systems. It was set to 3 but sometimes dust runs would exceed this
+            // However, if there is no limit this results in infinite retrys and dust never finishes
+            if editable_error.interrupted_error > 999 {
+                panic!("Multiple Interrupted Errors occurred while scanning filesystem. Aborting");
+            } else {
+                return true;
+            }
+        }
+        _ => {
+            editable_error.unknown_error.insert(failed.to_string());
+        }
+    }
+    false
 }

 mod tests {
@@ -270,17 +332,43 @@ mod tests {
        }
    }

+    #[cfg(test)]
+    fn create_walker<'a>(use_apparent_size: bool) -> WalkData<'a> {
+        use crate::PIndicator;
+        let indicator = PIndicator::build_me();
+        WalkData {
+            ignore_directories: HashSet::new(),
+            filter_regex: &[],
+            invert_filter_regex: &[],
+            allowed_filesystems: HashSet::new(),
+            filter_modified_time: Some((Operator::GreaterThan, 0)),
+            filter_accessed_time: Some((Operator::GreaterThan, 0)),
+            filter_changed_time: Some((Operator::GreaterThan, 0)),
+            use_apparent_size,
+            by_filecount: false,
+            by_filetime: &None,
+            ignore_hidden: false,
+            follow_links: false,
+            progress_data: indicator.data.clone(),
+            errors: Arc::new(Mutex::new(RuntimeErrors::default())),
+        }
+    }
+
    #[test]
    #[allow(clippy::redundant_clone)]
    fn test_should_ignore_file() {
        let mut inodes = HashSet::new();
        let n = create_node();
+        let walkdata = create_walker(false);

        // First time we insert the node
-        assert_eq!(clean_inodes(n.clone(), &mut inodes, false), Some(n.clone()));
+        assert_eq!(
+            clean_inodes(n.clone(), &mut inodes, &walkdata),
+            Some(n.clone())
+        );

        // Second time is a duplicate - we ignore it
-        assert_eq!(clean_inodes(n.clone(), &mut inodes, false), None);
+        assert_eq!(clean_inodes(n.clone(), &mut inodes, &walkdata), None);
    }

    #[test]
@@ -288,10 +376,17 @@ mod tests {
    fn test_should_not_ignore_files_if_using_apparent_size() {
        let mut inodes = HashSet::new();
        let n = create_node();
+        let walkdata = create_walker(true);

        // If using apparent size we include Nodes, even if duplicate inodes
-        assert_eq!(clean_inodes(n.clone(), &mut inodes, true), Some(n.clone()));
-        assert_eq!(clean_inodes(n.clone(), &mut inodes, true), Some(n.clone()));
+        assert_eq!(
+            clean_inodes(n.clone(), &mut inodes, &walkdata),
+            Some(n.clone())
+        );
+        assert_eq!(
+            clean_inodes(n.clone(), &mut inodes, &walkdata),
+            Some(n.clone())
+        );
    }

    #[test]
--- a/src/display.rs
+++ b/src/display.rs
@@ -1,4 +1,5 @@
 use crate::display_node::DisplayNode;
+use crate::node::FileTime;

 use ansi_term::Colour::Red;
 use lscolors::{LsColors, Style};
@@ -7,21 +8,24 @@ use unicode_width::UnicodeWidthStr;

 use stfu8::encode_u8;

+use chrono::{DateTime, Local, TimeZone, Utc};
 use std::cmp::max;
 use std::cmp::min;
 use std::fs;
-use std::iter::repeat;
+use std::iter::repeat_n;
 use std::path::Path;
 use thousands::Separable;

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

 pub struct InitialDisplayData {
    pub short_paths: bool,
    pub is_reversed: bool,
    pub colors_on: bool,
    pub by_filecount: bool,
+    pub by_filetime: Option<FileTime>,
    pub is_screen_reader: bool,
    pub output_format: String,
    pub bars_on_right: bool,
@@ -67,11 +71,7 @@ impl DisplayData {

    fn percent_size(&self, node: &DisplayNode) -> f32 {
        let result = node.size as f32 / self.base_size as f32;
-        if result.is_normal() {
-            result
-        } else {
-            0.0
-        }
+        if result.is_normal() { result } else { 0.0 }
    }
 }

@@ -125,22 +125,16 @@ impl DrawData<'_> {

 pub fn draw_it(
    idd: InitialDisplayData,
+    root_node: &DisplayNode,
    no_percent_bars: bool,
    terminal_width: usize,
-    root_node: &DisplayNode,
    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 idd.by_filecount {
-        let max_size = biggest.size;
+        let max_size = root_node.size;
        max_size.separate_with_commas().chars().count()
+    } else if idd.by_filetime.is_some() {
+        FILETIME_SHOW_LENGTH
    } else {
        find_biggest_size_str(root_node, &idd.output_format)
    };
@@ -161,12 +155,12 @@ pub fn draw_it(
        allowed_width - longest_string_length - 7
    };

-    let first_size_bar = repeat(BLOCKS[0]).take(max_bar_length).collect();
+    let first_size_bar = repeat_n(BLOCKS[0], max_bar_length).collect();

    let display_data = DisplayData {
        initial: idd,
        num_chars_needed_on_left_most,
-        base_size: biggest.size,
+        base_size: root_node.size,
        longest_string_length,
        ls_colors: LsColors::from_env().unwrap_or_default(),
    };
@@ -275,7 +269,7 @@ fn clean_indentation_string(s: &str) -> String {
    is
 }

-fn get_printable_name<P: AsRef<Path>>(dir_name: &P, short_paths: bool) -> String {
+pub fn get_printable_name<P: AsRef<Path>>(dir_name: &P, short_paths: bool) -> String {
    let dir_name = dir_name.as_ref();
    let printable_name = {
        if short_paths {
@@ -304,12 +298,9 @@ fn pad_or_trim_filename(node: &DisplayNode, indent: &str, display_data: &Display
    );

    // Add spaces after the filename so we can draw the % used bar chart.
-    let name_and_padding = name
-        + " "
-            .repeat(display_data.longest_string_length - width)
-            .as_str();
-
-    name_and_padding
+    name + " "
+        .repeat(display_data.longest_string_length - width)
+        .as_str()
 }

 fn maybe_trim_filename(name_in: String, indent: &str, display_data: &DisplayData) -> String {
@@ -342,6 +333,8 @@ pub fn format_string(
    if display_data.initial.is_screen_reader {
        // if screen_reader then bars is 'depth'
        format!("{pretty_name} {bars} {pretty_size}{percent}")
+    } else if display_data.initial.by_filetime.is_some() {
+        format!("{pretty_size} {indent}{pretty_name}")
    } else {
        format!("{pretty_size} {indent} {pretty_name}{percent}")
    }
@@ -376,6 +369,8 @@ fn get_name_percent(
 fn get_pretty_size(node: &DisplayNode, is_biggest: bool, display_data: &DisplayData) -> String {
    let output = if display_data.initial.by_filecount {
        node.size.separate_with_commas()
+    } else if display_data.initial.by_filetime.is_some() {
+        get_pretty_file_modified_time(node.size as i64)
    } else {
        human_readable_number(node.size, &display_data.initial.output_format)
    };
@@ -389,6 +384,14 @@ fn get_pretty_size(node: &DisplayNode, is_biggest: bool, display_data: &DisplayD
    }
 }

+fn get_pretty_file_modified_time(timestamp: i64) -> String {
+    let datetime: DateTime<Utc> = Utc.timestamp_opt(timestamp, 0).unwrap();
+
+    let local_datetime = datetime.with_timezone(&Local);
+
+    local_datetime.format("%Y-%m-%dT%H:%M:%S").to_string()
+}
+
 fn get_pretty_name(
    node: &DisplayNode,
    name_and_padding: String,
@@ -469,6 +472,7 @@ mod tests {
            is_reversed: false,
            colors_on: false,
            by_filecount: false,
+            by_filetime: None,
            is_screen_reader: false,
            output_format: "".into(),
            bars_on_right: false,
@@ -547,6 +551,14 @@ mod tests {
        assert_eq!(human_readable_number(1024 * 1024 * 1024 - 1, ""), "1023M");
        assert_eq!(human_readable_number(1024 * 1024 * 1024 * 20, ""), "20G");
        assert_eq!(human_readable_number(1024 * 1024 * 1024 * 1024, ""), "1.0T");
+        assert_eq!(
+            human_readable_number(1024 * 1024 * 1024 * 1024 * 234, ""),
+            "234T"
+        );
+        assert_eq!(
+            human_readable_number(1024 * 1024 * 1024 * 1024 * 1024, ""),
+            "1.0P"
+        );
    }

    #[test]
@@ -579,7 +591,7 @@ mod tests {
            size: 2_u64.pow(size),
            children: vec![],
        };
-        let first_size_bar = repeat(BLOCKS[0]).take(13).collect();
+        let first_size_bar = repeat_n(BLOCKS[0], 13).collect();
        let dd = DrawData {
            indent: "".into(),
            percent_bar: first_size_bar,
@@ -625,4 +637,37 @@ mod tests {
        let bar = dd.generate_bar(&n, 5);
        assert_eq!(bar, "████▓▓▓▓▓▓▓▓▓");
    }
+
+    #[test]
+    fn test_get_pretty_file_modified_time() {
+        // Create a timestamp for 2023-07-12 00:00:00 in local time
+        let local_dt = Local.with_ymd_and_hms(2023, 7, 12, 0, 0, 0).unwrap();
+        let timestamp = local_dt.timestamp();
+
+        // Format expected output
+        let expected_output = local_dt.format("%Y-%m-%dT%H:%M:%S").to_string();
+
+        assert_eq!(get_pretty_file_modified_time(timestamp), expected_output);
+
+        // Test another timestamp
+        let local_dt = Local.with_ymd_and_hms(2020, 1, 1, 12, 0, 0).unwrap();
+        let timestamp = local_dt.timestamp();
+        let expected_output = local_dt.format("%Y-%m-%dT%H:%M:%S").to_string();
+
+        assert_eq!(get_pretty_file_modified_time(timestamp), expected_output);
+
+        // Test timestamp for epoch start (1970-01-01T00:00:00)
+        let local_dt = Local.with_ymd_and_hms(1970, 1, 1, 0, 0, 0).unwrap();
+        let timestamp = local_dt.timestamp();
+        let expected_output = local_dt.format("%Y-%m-%dT%H:%M:%S").to_string();
+
+        assert_eq!(get_pretty_file_modified_time(timestamp), expected_output);
+
+        // Test a future timestamp
+        let local_dt = Local.with_ymd_and_hms(2030, 12, 25, 6, 30, 0).unwrap();
+        let timestamp = local_dt.timestamp();
+        let expected_output = local_dt.format("%Y-%m-%dT%H:%M:%S").to_string();
+
+        assert_eq!(get_pretty_file_modified_time(timestamp), expected_output);
+    }
 }
--- a/src/display_node.rs
+++ b/src/display_node.rs
@@ -1,8 +1,12 @@
+use std::cell::RefCell;
 use std::path::PathBuf;

-use serde::Serialize;
+use serde::ser::SerializeStruct;
+use serde::{Serialize, Serializer};

-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Serialize)]
+use crate::display::human_readable_number;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
 pub struct DisplayNode {
    // Note: the order of fields in important here, for PartialEq and PartialOrd
    pub size: u64,
@@ -25,3 +29,30 @@ impl DisplayNode {
        out
    }
 }
+
+// Only used for -j 'json' flag combined with -o 'output_type' flag
+// Used to pass the output_type into the custom Serde serializer
+thread_local! {
+    pub static OUTPUT_TYPE: RefCell<String> = const { RefCell::new(String::new()) };
+}
+
+/*
+We need the custom Serialize incase someone uses the -o flag to pass a custom output type in
+(show size in Mb / Gb etc).
+Sadly this also necessitates a global variable OUTPUT_TYPE as we can not pass the output_type flag
+into the serialize method
+ */
+impl Serialize for DisplayNode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let readable_size = OUTPUT_TYPE
+            .with(|output_type| human_readable_number(self.size, output_type.borrow().as_str()));
+        let mut state = serializer.serialize_struct("DisplayNode", 2)?;
+        state.serialize_field("size", &(readable_size))?;
+        state.serialize_field("name", &self.name)?;
+        state.serialize_field("children", &self.children)?;
+        state.end()
+    }
+}
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -1,7 +1,12 @@
+use stfu8::encode_u8;
+
+use crate::display::get_printable_name;
 use crate::display_node::DisplayNode;
+use crate::node::FileTime;
 use crate::node::Node;
 use std::collections::BinaryHeap;
 use std::collections::HashMap;
+use std::collections::HashSet;
 use std::path::Path;
 use std::path::PathBuf;

@@ -12,40 +17,58 @@ pub struct AggregateData {
    pub number_of_lines: usize,
    pub depth: usize,
    pub using_a_filter: bool,
+    pub short_paths: bool,
 }

-pub fn get_biggest(top_level_nodes: Vec<Node>, display_data: AggregateData) -> Option<DisplayNode> {
-    if top_level_nodes.is_empty() {
-        // perhaps change this, bring back Error object?
-        return None;
-    }
+pub fn get_biggest(
+    top_level_nodes: Vec<Node>,
+    display_data: AggregateData,
+    by_filetime: &Option<FileTime>,
+    keep_collapsed: HashSet<PathBuf>,
+) -> DisplayNode {
    let mut heap = BinaryHeap::new();
    let number_top_level_nodes = top_level_nodes.len();
    let root;

-    if number_top_level_nodes > 1 {
-        let size = top_level_nodes.iter().map(|node| node.size).sum();
-        root = Node {
-            name: PathBuf::from("(total)"),
-            size,
-            children: top_level_nodes,
-            inode_device: None,
-            depth: 0,
+    if number_top_level_nodes == 0 {
+        root = total_node_builder(0, vec![])
+    } else if number_top_level_nodes > 1 {
+        let size = if by_filetime.is_some() {
+            top_level_nodes
+                .iter()
+                .map(|node| node.size)
+                .max()
+                .unwrap_or(0)
+        } else {
+            top_level_nodes.iter().map(|node| node.size).sum()
        };
-        // Always include the base nodes if we add a 'parent' (total) node
+
+        let nodes = handle_duplicate_top_level_names(top_level_nodes, display_data.short_paths);
+        root = total_node_builder(size, nodes);
        heap = always_add_children(&display_data, &root, heap);
    } else {
        root = top_level_nodes.into_iter().next().unwrap();
        heap = add_children(&display_data, &root, heap);
    }

-    Some(fill_remaining_lines(heap, &root, display_data))
+    fill_remaining_lines(heap, &root, display_data, keep_collapsed)
+}
+
+fn total_node_builder(size: u64, children: Vec<Node>) -> Node {
+    Node {
+        name: PathBuf::from("(total)"),
+        size,
+        children,
+        inode_device: None,
+        depth: 0,
+    }
 }

 pub fn fill_remaining_lines<'a>(
    mut heap: BinaryHeap<&'a Node>,
    root: &'a Node,
    display_data: AggregateData,
+    keep_collapsed: HashSet<PathBuf>,
 ) -> DisplayNode {
    let mut allowed_nodes = HashMap::new();

@@ -53,10 +76,14 @@ pub fn fill_remaining_lines<'a>(
        let line = heap.pop();
        match line {
            Some(line) => {
+                // If we are not doing only_file OR if we are doing
+                // only_file and it has no children (ie is a file not a dir)
                if !display_data.only_file || line.children.is_empty() {
                    allowed_nodes.insert(line.name.as_path(), line);
                }
-                heap = add_children(&display_data, line, heap);
+                if !keep_collapsed.contains(&line.name) {
+                    heap = add_children(&display_data, line, heap);
+                }
            }
            None => break,
        }
@@ -138,3 +165,57 @@ fn build_display_node(mut new_children: Vec<DisplayNode>, current: &Node) -> Dis
        children: new_children,
    }
 }
+
+fn names_have_dup(top_level_nodes: &Vec<Node>) -> bool {
+    let mut stored = HashSet::new();
+    for node in top_level_nodes {
+        let name = get_printable_name(&node.name, true);
+        if stored.contains(&name) {
+            return true;
+        }
+        stored.insert(name);
+    }
+    false
+}
+
+fn handle_duplicate_top_level_names(top_level_nodes: Vec<Node>, short_paths: bool) -> Vec<Node> {
+    // If we have top level names that are the same - we need to tweak them:
+    if short_paths && names_have_dup(&top_level_nodes) {
+        let mut new_top_nodes = top_level_nodes.clone();
+        let mut dir_walk_up_count = 0;
+
+        while names_have_dup(&new_top_nodes) && dir_walk_up_count < 10 {
+            dir_walk_up_count += 1;
+            let mut newer = vec![];
+
+            for node in new_top_nodes.iter() {
+                let mut folders = node.name.iter().rev();
+                // Get parent folder (if second time round get grandparent and so on)
+                for _ in 0..dir_walk_up_count {
+                    folders.next();
+                }
+                match folders.next() {
+                    // Add (parent_name) to path of Node
+                    Some(data) => {
+                        let parent = encode_u8(data.as_encoded_bytes());
+                        let current_node = node.name.display();
+                        let n = Node {
+                            name: PathBuf::from(format!("{current_node}({parent})")),
+                            size: node.size,
+                            children: node.children.clone(),
+                            inode_device: node.inode_device,
+                            depth: node.depth,
+                        };
+                        newer.push(n)
+                    }
+                    // Node does not have a parent
+                    None => newer.push(node.clone()),
+                }
+            }
+            new_top_nodes = newer;
+        }
+        new_top_nodes
+    } else {
+        top_level_nodes
+    }
+}
--- a/src/filter_type.rs
+++ b/src/filter_type.rs
@@ -1,4 +1,5 @@
 use crate::display_node::DisplayNode;
+use crate::node::FileTime;
 use crate::node::Node;
 use std::collections::HashMap;
 use std::ffi::OsStr;
@@ -10,7 +11,11 @@ struct ExtensionNode<'a> {
    extension: Option<&'a OsStr>,
 }

-pub fn get_all_file_types(top_level_nodes: &[Node], n: usize) -> Option<DisplayNode> {
+pub fn get_all_file_types(
+    top_level_nodes: &[Node],
+    n: usize,
+    by_filetime: &Option<FileTime>,
+) -> DisplayNode {
    let ext_nodes = {
        let mut extension_cumulative_sizes = HashMap::new();
        build_by_all_file_types(top_level_nodes, &mut extension_cumulative_sizes);
@@ -44,20 +49,29 @@ pub fn get_all_file_types(top_level_nodes: &[Node], n: usize) -> Option<DisplayN

    // ...then, aggregate the remaining nodes (if any) into a single  "(others)" node
    if ext_nodes_iter.len() > 0 {
+        let actual_size = if by_filetime.is_some() {
+            ext_nodes_iter.map(|node| node.size).max().unwrap_or(0)
+        } else {
+            ext_nodes_iter.map(|node| node.size).sum()
+        };
        displayed.push(DisplayNode {
            name: PathBuf::from("(others)"),
-            size: ext_nodes_iter.map(|node| node.size).sum(),
+            size: actual_size,
            children: vec![],
        });
    }

-    let result = DisplayNode {
-        name: PathBuf::from("(total)"),
-        size: displayed.iter().map(|node| node.size).sum(),
-        children: displayed,
+    let actual_size: u64 = if by_filetime.is_some() {
+        displayed.iter().map(|node| node.size).max().unwrap_or(0)
+    } else {
+        displayed.iter().map(|node| node.size).sum()
    };

-    Some(result)
+    DisplayNode {
+        name: PathBuf::from("(total)"),
+        size: actual_size,
+        children: displayed,
+    }
 }

 fn build_by_all_file_types<'a>(
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,9 +10,11 @@ mod platform;
 mod progress;
 mod utils;

-use crate::cli::build_cli;
+use crate::cli::Cli;
+use crate::config::Config;
+use crate::display_node::DisplayNode;
 use crate::progress::RuntimeErrors;
-use clap::parser::ValuesRef;
+use clap::Parser;
 use dir_walker::WalkData;
 use display::InitialDisplayData;
 use filter::AggregateData;
@@ -20,25 +22,26 @@ use progress::PIndicator;
 use regex::Error;
 use std::collections::HashSet;
 use std::env;
-use std::fs::read_to_string;
+use std::fs::{read, read_to_string};
 use std::io;
+use std::io::Read;
 use std::panic;
 use std::process;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::Mutex;
 use sysinfo::{System, SystemExt};
+use utils::canonicalize_absolute_path;

 use self::display::draw_it;
 use config::get_config;
 use dir_walker::walk_it;
+use display_node::OUTPUT_TYPE;
 use filter::get_biggest;
 use filter_type::get_all_file_types;
 use regex::Regex;
 use std::cmp::max;
 use std::path::PathBuf;
-use terminal_size::{terminal_size, Height, Width};
+use terminal_size::{Height, Width, terminal_size};
 use utils::get_filesystem_devices;
 use utils::simplify_dir_names;

@@ -81,30 +84,27 @@ fn should_init_color(no_color: bool, force_color: bool) -> bool {
 }

 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))
+        .map(|(_, Height(h))| max(h.into(), 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,
+            true => max(w.into(), DEFAULT_TERMINAL_WIDTH),
+            false => w.into(),
        })
        .unwrap_or(DEFAULT_TERMINAL_WIDTH)
 }

-fn get_regex_value(maybe_value: Option<ValuesRef<String>>) -> Vec<Regex> {
+fn get_regex_value(maybe_value: Option<&Vec<String>>) -> Vec<Regex> {
    maybe_value
-        .unwrap_or_default()
+        .unwrap_or(&Vec::new())
+        .iter()
        .map(|reg| {
            Regex::new(reg).unwrap_or_else(|err| {
                eprintln!("Ignoring bad value for regex {err:?}");
@@ -115,64 +115,37 @@ fn get_regex_value(maybe_value: Option<ValuesRef<String>>) -> Vec<Regex> {
 }

 fn main() {
-    let options = build_cli().get_matches();
-    let config = get_config();
+    let options = Cli::parse();
+    let config = get_config(options.config.as_ref());

    let errors = RuntimeErrors::default();
    let error_listen_for_ctrlc = Arc::new(Mutex::new(errors));
    let errors_for_rayon = error_listen_for_ctrlc.clone();
-    let errors_final = error_listen_for_ctrlc.clone();
-    let is_in_listing = Arc::new(AtomicBool::new(false));
-    let cloned_is_in_listing = Arc::clone(&is_in_listing);

    ctrlc::set_handler(move || {
-        error_listen_for_ctrlc.lock().unwrap().abort = true;
        println!("\nAborting");
-        if cloned_is_in_listing.load(Ordering::Relaxed) {
-            process::exit(1);
-        }
+        process::exit(1);
    })
    .expect("Error setting Ctrl-C handler");

-    is_in_listing.store(true, Ordering::Relaxed);
-    let target_dirs = match config.get_files_from(&options) {
-        Some(path) => {
-            if path == "-" {
-                let mut targets_to_add = io::stdin()
-                    .lines()
-                    .map_while(Result::ok)
-                    .collect::<Vec<String>>();
-
-                if targets_to_add.is_empty() {
-                    eprintln!("No input provided, defaulting to current directory");
-                    targets_to_add.push(".".to_owned());
-                }
-                targets_to_add
-            } else {
-                // read file
-                match read_to_string(path) {
-                    Ok(file_content) => file_content.lines().map(|x| x.to_string()).collect(),
-                    Err(e) => {
-                        eprintln!("Error reading file: {e}");
-                        vec![".".to_owned()]
-                    }
-                }
-            }
-        }
-        None => match options.get_many::<String>("params") {
-            Some(values) => values.cloned().collect(),
+    let target_dirs = if let Some(path) = config.get_files0_from(&options) {
+        read_paths_from_source(&path, true)
+    } else if let Some(path) = config.get_files_from(&options) {
+        read_paths_from_source(&path, false)
+    } else {
+        match options.params {
+            Some(ref values) => values.clone(),
            None => vec![".".to_owned()],
-        },
+        }
    };
-    is_in_listing.store(false, Ordering::Relaxed);

-    let summarize_file_types = options.get_flag("types");
+    let summarize_file_types = options.file_types;

-    let filter_regexs = get_regex_value(options.get_many("filter"));
-    let invert_filter_regexs = get_regex_value(options.get_many("invert_filter"));
+    let filter_regexs = get_regex_value(options.filter.as_ref());
+    let invert_filter_regexs = get_regex_value(options.invert_filter.as_ref());

-    let terminal_width: usize = match options.get_one::<usize>("width") {
-        Some(&val) => val,
+    let terminal_width: usize = match options.terminal_width {
+        Some(val) => val,
        None => get_width_of_terminal(),
    };

@@ -181,8 +154,8 @@ fn main() {
    // If depth is set, then we set the default number_of_lines to be max
    // instead of screen height

-    let number_of_lines = match options.get_one::<usize>("number_of_lines") {
-        Some(&val) => val,
+    let number_of_lines = match config.get_number_of_lines(&options) {
+        Some(val) => val,
        None => {
            if depth != usize::MAX {
                usize::MAX
@@ -197,16 +170,17 @@ fn main() {
        config.get_force_colors(&options),
    );

-    let ignore_directories = match options.get_many::<String>("ignore_directory") {
-        Some(values) => values
-            .map(|v| v.as_str())
+    let ignore_directories = match options.ignore_directory {
+        Some(ref values) => values
+            .iter()
            .map(PathBuf::from)
+            .map(canonicalize_absolute_path)
            .collect::<Vec<PathBuf>>(),
        None => vec![],
    };

-    let ignore_from_file_result = match options.get_one::<String>("ignore_all_in_file") {
-        Some(val) => read_to_string(val)
+    let ignore_from_file_result = match options.ignore_all_in_file {
+        Some(ref val) => read_to_string(val)
            .unwrap()
            .lines()
            .map(Regex::new)
@@ -223,13 +197,17 @@ fn main() {
        .chain(ignore_from_file)
        .collect::<Vec<Regex>>();

-    let by_filecount = options.get_flag("by_filecount");
-    let limit_filesystem = options.get_flag("limit_filesystem");
-    let follow_links = options.get_flag("dereference_links");
+    let by_filecount = options.filecount;
+    let by_filetime = config.get_filetime(&options);
+    let limit_filesystem = options.limit_filesystem;
+    let follow_links = options.dereference_links;
+
+    let allowed_filesystems = if limit_filesystem {
+        get_filesystem_devices(&target_dirs, follow_links)
+    } else {
+        Default::default()
+    };

-    let allowed_filesystems = limit_filesystem
-        .then(|| get_filesystem_devices(&target_dirs))
-        .unwrap_or_default();
    let simplified_dirs = simplify_dir_names(&target_dirs);

    let ignored_full_path: HashSet<PathBuf> = ignore_directories
@@ -246,9 +224,22 @@ fn main() {
        indicator.spawn(output_format.clone())
    }

+    let keep_collapsed: HashSet<PathBuf> = match options.collapse {
+        Some(ref collapse) => {
+            let mut combined_dirs = HashSet::new();
+            for collapse_dir in collapse {
+                for target_dir in target_dirs.iter() {
+                    combined_dirs.insert(PathBuf::from(target_dir).join(collapse_dir));
+                }
+            }
+            combined_dirs
+        }
+        None => HashSet::new(),
+    };
+
    let filter_modified_time = config.get_modified_time_operator(&options);
    let filter_accessed_time = config.get_accessed_time_operator(&options);
-    let filter_changed_time = config.get_created_time_operator(&options);
+    let filter_changed_time = config.get_changed_time_operator(&options);

    let walk_data = WalkData {
        ignore_directories: ignored_full_path,
@@ -260,40 +251,100 @@ fn main() {
        filter_changed_time,
        use_apparent_size: config.get_apparent_size(&options),
        by_filecount,
+        by_filetime: &by_filetime,
        ignore_hidden,
        follow_links,
        progress_data: indicator.data.clone(),
        errors: errors_for_rayon,
    };
+
    let threads_to_use = config.get_threads(&options);
    let stack_size = config.get_custom_stack_size(&options);
-    init_rayon(&stack_size, &threads_to_use);

-    let top_level_nodes = walk_it(simplified_dirs, &walk_data);
+    init_rayon(&stack_size, &threads_to_use).install(|| {
+        let top_level_nodes = walk_it(simplified_dirs, &walk_data);

-    let tree = match summarize_file_types {
-        true => get_all_file_types(&top_level_nodes, number_of_lines),
-        false => {
-            let agg_data = AggregateData {
-                min_size: config.get_min_size(&options),
-                only_dir: config.get_only_dir(&options),
-                only_file: config.get_only_file(&options),
-                number_of_lines,
-                depth,
-                using_a_filter: !filter_regexs.is_empty() || !invert_filter_regexs.is_empty(),
-            };
-            get_biggest(top_level_nodes, agg_data)
+        let tree = match summarize_file_types {
+            true => get_all_file_types(&top_level_nodes, number_of_lines, walk_data.by_filetime),
+            false => {
+                let agg_data = AggregateData {
+                    min_size: config.get_min_size(&options),
+                    only_dir: config.get_only_dir(&options),
+                    only_file: config.get_only_file(&options),
+                    number_of_lines,
+                    depth,
+                    using_a_filter: !filter_regexs.is_empty() || !invert_filter_regexs.is_empty(),
+                    short_paths: !config.get_full_paths(&options),
+                };
+                get_biggest(
+                    top_level_nodes,
+                    agg_data,
+                    walk_data.by_filetime,
+                    keep_collapsed,
+                )
+            }
+        };
+
+        // Must have stopped indicator before we print to stderr
+        indicator.stop();
+
+        let print_errors = config.get_print_errors(&options);
+        let final_errors = walk_data.errors.lock().unwrap();
+        print_any_errors(print_errors, &final_errors);
+
+        if tree.children.is_empty() && !final_errors.file_not_found.is_empty() {
+            std::process::exit(1)
+        } else {
+            print_output(
+                config,
+                options,
+                tree,
+                walk_data.by_filecount,
+                is_colors,
+                terminal_width,
+            )
        }
-    };
+    });
+}

-    // Must have stopped indicator before we print to stderr
-    indicator.stop();
+fn print_output(
+    config: Config,
+    options: Cli,
+    tree: DisplayNode,
+    by_filecount: bool,
+    is_colors: bool,
+    terminal_width: usize,
+) {
+    let output_format = config.get_output_format(&options);

-    if errors_final.lock().unwrap().abort {
-        return;
+    if config.get_output_json(&options) {
+        OUTPUT_TYPE.with(|wrapped| {
+            wrapped.replace(output_format);
+        });
+        println!("{}", serde_json::to_string(&tree).unwrap());
+    } else {
+        let idd = InitialDisplayData {
+            short_paths: !config.get_full_paths(&options),
+            is_reversed: !config.get_reverse(&options),
+            colors_on: is_colors,
+            by_filecount,
+            by_filetime: config.get_filetime(&options),
+            is_screen_reader: config.get_screen_reader(&options),
+            output_format,
+            bars_on_right: config.get_bars_on_right(&options),
+        };
+
+        draw_it(
+            idd,
+            &tree,
+            config.get_no_bars(&options),
+            terminal_width,
+            config.get_skip_total(&options),
+        )
    }
+}

-    let final_errors = walk_data.errors.lock().unwrap();
+fn print_any_errors(print_errors: bool, final_errors: &RuntimeErrors) {
    if !final_errors.file_not_found.is_empty() {
        let err = final_errors
            .file_not_found
@@ -301,17 +352,17 @@ fn main() {
            .map(|a| a.as_ref())
            .collect::<Vec<&str>>()
            .join(", ");
-        eprintln!("No such file or directory: {}", err);
+        eprintln!("No such file or directory: {err}");
    }
    if !final_errors.no_permissions.is_empty() {
-        if config.get_print_errors(&options) {
+        if print_errors {
            let err = final_errors
                .no_permissions
                .iter()
                .map(|a| a.as_ref())
                .collect::<Vec<&str>>()
                .join(", ");
-            eprintln!("Did not have permissions for directories: {}", err);
+            eprintln!("Did not have permissions for directories: {err}");
        } else {
            eprintln!(
                "Did not have permissions for all directories (add --print-errors to see errors)"
@@ -325,72 +376,105 @@ fn main() {
            .map(|a| a.as_ref())
            .collect::<Vec<&str>>()
            .join(", ");
-        eprintln!("Unknown Error: {}", err);
+        eprintln!("Unknown Error: {err}");
    }
+}

-    if let Some(root_node) = tree {
-        let idd = InitialDisplayData {
-            short_paths: !config.get_full_paths(&options),
-            is_reversed: !config.get_reverse(&options),
-            colors_on: is_colors,
-            by_filecount,
-            is_screen_reader: config.get_screen_reader(&options),
-            output_format,
-            bars_on_right: config.get_bars_on_right(&options),
+fn read_paths_from_source(path: &str, null_terminated: bool) -> Vec<String> {
+    let from_stdin = path == "-";
+
+    let result: Result<Vec<String>, Option<String>> = (|| {
+        // 1) read bytes
+        let bytes = if from_stdin {
+            let mut b = Vec::new();
+            io::stdin().lock().read_to_end(&mut b).map_err(|_| None)?;
+            b
+        } else {
+            read(path).map_err(|e| Some(e.to_string()))?
        };

-        if config.get_output_json(&options) {
-            println!("{}", serde_json::to_string(&root_node).unwrap());
+        let text = std::str::from_utf8(&bytes).map_err(|e| {
+            if from_stdin {
+                None
+            } else {
+                Some(e.to_string())
+            }
+        })?;
+        let items: Vec<String> = if null_terminated {
+            text.split('\0')
+                .filter(|s| !s.is_empty())
+                .map(str::to_owned)
+                .collect()
        } else {
-            draw_it(
-                idd,
-                config.get_no_bars(&options),
-                terminal_width,
-                &root_node,
-                config.get_skip_total(&options),
-            )
+            text.lines().map(str::to_owned).collect()
+        };
+        if from_stdin && items.is_empty() {
+            return Err(None);
+        }
+        Ok(items)
+    })();
+
+    match result {
+        Ok(v) => v,
+        Err(None) => {
+            eprintln!("No files provided, defaulting to current directory");
+            vec![".".to_owned()]
+        }
+        Err(Some(msg)) => {
+            eprintln!("Failed to read file: {msg}");
+            vec![".".to_owned()]
        }
    }
 }

-fn init_rayon(stack_size: &Option<usize>, threads: &Option<usize>) {
-    // Rayon seems to raise this error on 32-bit builds
-    // The global thread pool has not been initialized.: ThreadPoolBuildError { kind: GlobalPoolAlreadyInitialized }
-    if cfg!(target_pointer_width = "64") {
-        let result = panic::catch_unwind(|| build_thread_pool(*stack_size, *threads));
-        if result.is_err() {
-            eprintln!("Problem initializing rayon, try: export RAYON_NUM_THREADS=1")
+fn init_rayon(stack: &Option<usize>, threads: &Option<usize>) -> rayon::ThreadPool {
+    let stack_size = match stack {
+        Some(s) => Some(*s),
+        None => {
+            // Do not increase the stack size on a 32 bit system, it will fail
+            if cfg!(target_pointer_width = "32") {
+                None
+            } else {
+                let large_stack = usize::pow(1024, 3);
+                let mut s = System::new();
+                s.refresh_memory();
+                // Larger stack size if possible to handle cases with lots of nested directories
+                let available = s.available_memory();
+                if available > (large_stack * threads.unwrap_or(1)).try_into().unwrap() {
+                    Some(large_stack)
+                } else {
+                    None
+                }
+            }
+        }
+    };
+
+    match build_thread_pool(stack_size, threads) {
+        Ok(pool) => pool,
+        Err(err) => {
+            eprintln!("Problem initializing rayon, try: export RAYON_NUM_THREADS=1");
+            if stack.is_none() && stack_size.is_some() {
+                // stack parameter was none, try with default stack size
+                if let Ok(pool) = build_thread_pool(None, threads) {
+                    eprintln!("WARNING: not using large stack size, got error: {err}");
+                    return pool;
+                }
+            }
+            panic!("{err}");
        }
    }
 }

 fn build_thread_pool(
-    stack: Option<usize>,
-    threads: Option<usize>,
-) -> Result<(), rayon::ThreadPoolBuildError> {
-    let mut pool = rayon::ThreadPoolBuilder::new();
-
-    if let Some(thread_count) = threads {
-        pool = pool.num_threads(thread_count);
-    }
-
-    let stack_size = match stack {
-        Some(s) => Some(s),
-        None => {
-            let large_stack = usize::pow(1024, 3);
-            let mut s = System::new();
-            s.refresh_memory();
-            // Larger stack size if possible to handle cases with lots of nested directories
-            let available = s.available_memory();
-            if available > large_stack.try_into().unwrap() {
-                Some(large_stack)
-            } else {
-                None
-            }
-        }
-    };
+    stack_size: Option<usize>,
+    threads: &Option<usize>,
+) -> Result<rayon::ThreadPool, rayon::ThreadPoolBuildError> {
+    let mut pool_builder = rayon::ThreadPoolBuilder::new();
    if let Some(stack_size_param) = stack_size {
-        pool = pool.stack_size(stack_size_param);
+        pool_builder = pool_builder.stack_size(stack_size_param);
    }
-    pool.build_global()
+    if let Some(thread_count) = threads {
+        pool_builder = pool_builder.num_threads(*thread_count);
+    }
+    pool_builder.build()
 }
--- a/src/node.rs
+++ b/src/node.rs
@@ -16,6 +16,23 @@ pub struct Node {
    pub depth: usize,
 }

+#[derive(Debug, PartialEq)]
+pub enum FileTime {
+    Modified,
+    Accessed,
+    Changed,
+}
+
+impl From<crate::cli::FileTime> for FileTime {
+    fn from(time: crate::cli::FileTime) -> Self {
+        match time {
+            crate::cli::FileTime::Modified => Self::Modified,
+            crate::cli::FileTime::Accessed => Self::Accessed,
+            crate::cli::FileTime::Changed => Self::Changed,
+        }
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 pub fn build_node(
    dir: PathBuf,
@@ -27,22 +44,23 @@ pub fn build_node(
 ) -> Option<Node> {
    let use_apparent_size = walk_data.use_apparent_size;
    let by_filecount = walk_data.by_filecount;
+    let by_filetime = &walk_data.by_filetime;

-    get_metadata(&dir, use_apparent_size).map(|data| {
-        let inode_device = if is_symlink && !use_apparent_size {
-            None
-        } else {
-            data.1
-        };
+    get_metadata(
+        &dir,
+        use_apparent_size,
+        walk_data.follow_links && is_symlink,
+    )
+    .map(|data| {
+        let inode_device = data.1;

        let size = if is_filtered_out_due_to_regex(walk_data.filter_regex, &dir)
            || is_filtered_out_due_to_invert_regex(walk_data.invert_filter_regex, &dir)
-            || (is_symlink && !use_apparent_size)
            || by_filecount && !is_file
            || [
-                (&walk_data.filter_modified_time, data.2 .0),
-                (&walk_data.filter_accessed_time, data.2 .1),
-                (&walk_data.filter_changed_time, data.2 .2),
+                (&walk_data.filter_modified_time, data.2.0),
+                (&walk_data.filter_accessed_time, data.2.1),
+                (&walk_data.filter_changed_time, data.2.2),
            ]
            .iter()
            .any(|(filter_time, actual_time)| {
@@ -51,6 +69,13 @@ pub fn build_node(
            0
        } else if by_filecount {
            1
+        } else if by_filetime.is_some() {
+            match by_filetime {
+                Some(FileTime::Modified) => data.2.0.unsigned_abs(),
+                Some(FileTime::Accessed) => data.2.1.unsigned_abs(),
+                Some(FileTime::Changed) => data.2.2.unsigned_abs(),
+                None => unreachable!(),
+            }
        } else {
            data.0
        };
--- a/src/platform.rs
+++ b/src/platform.rs
@@ -17,19 +17,42 @@ type FileTime = (i64, i64, i64);
 pub fn get_metadata<P: AsRef<Path>>(
    path: P,
    use_apparent_size: bool,
+    follow_links: bool,
 ) -> Option<(u64, Option<InodeAndDevice>, FileTime)> {
    use std::os::unix::fs::MetadataExt;
-    match path.as_ref().metadata() {
+    let metadata = if follow_links {
+        path.as_ref().metadata()
+    } else {
+        path.as_ref().symlink_metadata()
+    };
+    match metadata {
        Ok(md) => {
+            let file_size = md.len();
            if use_apparent_size {
                Some((
-                    md.len(),
+                    file_size,
                    Some((md.ino(), md.dev())),
                    (md.mtime(), md.atime(), md.ctime()),
                ))
            } else {
+                // On NTFS mounts, the reported block count can be unexpectedly large.
+                // To avoid overestimating disk usage, cap the allocated size to what the
+                // file should occupy based on the file system I/O block size (blksize).
+                // Related: https://github.com/bootandy/dust/issues/295
+                let blksize = md.blksize();
+                let target_size = file_size.div_ceil(blksize) * blksize;
+                let reported_size = md.blocks() * get_block_size();
+
+                // File systems can pre-allocate more space for a file than what would be necessary
+                let pre_allocation_buffer = blksize * 65536;
+                let max_size = target_size + pre_allocation_buffer;
+                let allocated_size = if reported_size > max_size {
+                    target_size
+                } else {
+                    reported_size
+                };
                Some((
-                    md.blocks() * get_block_size(),
+                    allocated_size,
                    Some((md.ino(), md.dev())),
                    (md.mtime(), md.atime(), md.ctime()),
                ))
@@ -43,6 +66,7 @@ pub fn get_metadata<P: AsRef<Path>>(
 pub fn get_metadata<P: AsRef<Path>>(
    path: P,
    use_apparent_size: bool,
+    follow_links: bool,
 ) -> Option<(u64, Option<InodeAndDevice>, FileTime)> {
    // On windows opening the file to get size, file ID and volume can be very
    // expensive because 1) it causes a few system calls, and more importantly 2) it can cause
@@ -142,7 +166,12 @@ pub fn get_metadata<P: AsRef<Path>>(

    use std::os::windows::fs::MetadataExt;
    let path = path.as_ref();
-    match path.metadata() {
+    let metadata = if follow_links {
+        path.metadata()
+    } else {
+        path.symlink_metadata()
+    };
+    match metadata {
        Ok(ref md) => {
            const FILE_ATTRIBUTE_ARCHIVE: u32 = 0x20;
            const FILE_ATTRIBUTE_READONLY: u32 = 0x01;
--- a/src/progress.rs
+++ b/src/progress.rs
@@ -3,14 +3,19 @@ use std::{
    io::Write,
    path::Path,
    sync::{
-        atomic::{AtomicU64, AtomicU8, AtomicUsize, Ordering},
-        mpsc::{self, RecvTimeoutError, Sender},
        Arc, RwLock,
+        atomic::{AtomicU8, AtomicUsize, Ordering},
+        mpsc::{self, RecvTimeoutError, Sender},
    },
    thread::JoinHandle,
    time::Duration,
 };

+#[cfg(not(target_has_atomic = "64"))]
+use portable_atomic::AtomicU64;
+#[cfg(target_has_atomic = "64")]
+use std::sync::atomic::AtomicU64;
+
 use crate::display::human_readable_number;

 /* -------------------------------------------------------------------------- */
@@ -73,7 +78,7 @@ pub struct RuntimeErrors {
    pub no_permissions: HashSet<String>,
    pub file_not_found: HashSet<String>,
    pub unknown_error: HashSet<String>,
-    pub abort: bool,
+    pub interrupted_error: i32,
 }

 /* -------------------------------------------------------------------------- */
@@ -113,7 +118,7 @@ impl PIndicator {

        let time_info_thread = std::thread::spawn(move || {
            let mut progress_char_i: usize = 0;
-            let mut stdout = std::io::stdout();
+            let mut stderr = std::io::stderr();
            let mut msg = "".to_string();

            // While the timeout triggers we go round the loop
@@ -122,7 +127,8 @@ impl PIndicator {
                receiver.recv_timeout(Duration::from_millis(SPINNER_SLEEP_TIME))
            {
                // Clear the text written by 'write!'& Return at the start of line
-                print!("\r{:width$}", " ", width = msg.len());
+                let clear = format!("\r{:width$}", " ", width = msg.len());
+                write!(stderr, "{clear}").unwrap();
                let prog_char = PROGRESS_CHARS[progress_char_i];

                msg = match data.state.load(ORDERING) {
@@ -131,15 +137,17 @@ impl PIndicator {
                    _ => panic!("Unknown State"),
                };

-                write!(stdout, "\r{msg}").unwrap();
-                stdout.flush().unwrap();
+                write!(stderr, "\r{msg}").unwrap();
+                stderr.flush().unwrap();

                progress_char_i += 1;
                progress_char_i %= PROGRESS_CHARS_LEN;
            }
-            print!("\r{:width$}", " ", width = msg.len());
-            print!("\r");
-            stdout.flush().unwrap();
+
+            let clear = format!("\r{:width$}", " ", width = msg.len());
+            write!(stderr, "{clear}").unwrap();
+            write!(stderr, "\r").unwrap();
+            stderr.flush().unwrap();
        });
        self.thread = Some((stop_handler, time_info_thread))
    }
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};

 use crate::config::DAY_SECONDS;

-use crate::dir_walker::Operater;
+use crate::dir_walker::Operator;
 use crate::platform;
 use regex::Regex;

@@ -34,13 +34,25 @@ pub fn simplify_dir_names<P: AsRef<Path>>(dirs: &[P]) -> HashSet<PathBuf> {
    top_level_names
 }

-pub fn get_filesystem_devices<P: AsRef<Path>>(paths: &[P]) -> HashSet<u64> {
+pub fn get_filesystem_devices<P: AsRef<Path>>(paths: &[P], follow_links: bool) -> HashSet<u64> {
+    use std::fs;
    // Gets the device ids for the filesystems which are used by the argument paths
    paths
        .iter()
-        .filter_map(|p| match get_metadata(p, false) {
-            Some((_size, Some((_id, dev)), _time)) => Some(dev),
-            _ => None,
+        .filter_map(|p| {
+            let follow_links = if follow_links {
+                // slow path: If dereference-links is set, then we check if the file is a symbolic link
+                match fs::symlink_metadata(p) {
+                    Ok(metadata) => metadata.file_type().is_symlink(),
+                    Err(_) => false,
+                }
+            } else {
+                false
+            };
+            match get_metadata(p, false, follow_links) {
+                Some((_size, Some((_id, dev)), _time)) => Some(dev),
+                _ => None,
+            }
        })
        .collect()
 }
@@ -55,6 +67,17 @@ pub fn normalize_path<P: AsRef<Path>>(path: P) -> PathBuf {
    path.as_ref().components().collect()
 }

+// Canonicalize the path only if it is an absolute path
+pub fn canonicalize_absolute_path(path: PathBuf) -> PathBuf {
+    if !path.is_absolute() {
+        return path;
+    }
+    match std::fs::canonicalize(&path) {
+        Ok(canonicalized_path) => canonicalized_path,
+        Err(_) => path,
+    }
+}
+
 pub fn is_filtered_out_due_to_regex(filter_regex: &[Regex], dir: &Path) -> bool {
    if filter_regex.is_empty() {
        false
@@ -66,16 +89,16 @@ pub fn is_filtered_out_due_to_regex(filter_regex: &[Regex], dir: &Path) -> bool
 }

 pub fn is_filtered_out_due_to_file_time(
-    filter_time: &Option<(Operater, i64)>,
+    filter_time: &Option<(Operator, i64)>,
    actual_time: i64,
 ) -> bool {
    match filter_time {
        None => false,
-        Some((Operater::Equal, bound_time)) => {
+        Some((Operator::Equal, bound_time)) => {
            !(actual_time >= *bound_time && actual_time < *bound_time + DAY_SECONDS)
        }
-        Some((Operater::GreaterThan, bound_time)) => actual_time < *bound_time,
-        Some((Operater::LessThan, bound_time)) => actual_time > *bound_time,
+        Some((Operator::GreaterThan, bound_time)) => actual_time < *bound_time,
+        Some((Operator::LessThan, bound_time)) => actual_time > *bound_time,
    }
 }

--- a/tests/test_dir_files_from/a_file
+++ b/tests/test_dir_files_from/a_file
--- a/tests/test_dir_files_from/files0_from.txt
+++ b/tests/test_dir_files_from/files0_from.txt
--- a/tests/test_dir_files_from/files_from.txt
+++ b/tests/test_dir_files_from/files_from.txt
@@ -0,0 +1,2 @@
+tests/test_dir_files_from/a_file
+tests/test_dir_files_from/hello_file
--- a/tests/test_dir_files_from/hello_file
+++ b/tests/test_dir_files_from/hello_file
@@ -0,0 +1 @@
+hello
--- a/tests/test_dir_matching/andy/dup_name/hello
+++ b/tests/test_dir_matching/andy/dup_name/hello
--- a/tests/test_dir_matching/dave/dup_name/hello
+++ b/tests/test_dir_matching/dave/dup_name/hello
--- a/tests/test_flags.rs
+++ b/tests/test_flags.rs
@@ -10,6 +10,9 @@ use std::str;

 fn build_command<T: AsRef<OsStr>>(command_args: Vec<T>) -> String {
    let mut cmd = &mut Command::cargo_bin("dust").unwrap();
+    // Hide progress bar
+    cmd = cmd.arg("-P");
+
    for p in command_args {
        cmd = cmd.arg(p);
    }
@@ -59,6 +62,14 @@ pub fn test_d_flag_works() {
    assert!(!output.contains("hello_file"));
 }

+#[test]
+pub fn test_d0_works_on_multiple() {
+    // We should see the top level directory but not the sub dirs / files:
+    let output = build_command(vec!["-d", "0", "tests/test_dir/", "tests/test_dir2"]);
+    assert!(output.contains("test_dir "));
+    assert!(output.contains("test_dir2"));
+}
+
 #[test]
 pub fn test_threads_flag_works() {
    let output = build_command(vec!["-T", "1", "tests/test_dir/"]);
@@ -93,10 +104,60 @@ pub fn test_ignore_all_in_file() {
    assert!(!output.contains(".secret"));
 }

+#[test]
+pub fn test_files_from_flag_file() {
+    let output = build_command(vec![
+        "--files-from",
+        "tests/test_dir_files_from/files_from.txt",
+    ]);
+    assert!(output.contains("a_file"));
+    assert!(output.contains("hello_file"));
+}
+
+#[test]
+pub fn test_files0_from_flag_file() {
+    let output = build_command(vec![
+        "--files0-from",
+        "tests/test_dir_files_from/files0_from.txt",
+    ]);
+    assert!(output.contains("a_file"));
+    assert!(output.contains("hello_file"));
+}
+
+#[test]
+pub fn test_files_from_flag_stdin() {
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    cmd.arg("-P").arg("--files-from").arg("-");
+    let input = b"tests/test_dir_files_from/a_file\ntests/test_dir_files_from/hello_file\n";
+    cmd.write_stdin(input.as_ref());
+    let finished = &cmd.unwrap();
+    let stderr = std::str::from_utf8(&finished.stderr).unwrap();
+    assert_eq!(stderr, "");
+    let output = std::str::from_utf8(&finished.stdout).unwrap();
+    assert!(output.contains("a_file"));
+    assert!(output.contains("hello_file"));
+}
+
+#[test]
+pub fn test_files0_from_flag_stdin() {
+    let mut cmd = Command::cargo_bin("dust").unwrap();
+    cmd.arg("-P").arg("--files0-from").arg("-");
+    let input = b"tests/test_dir_files_from/a_file\0tests/test_dir_files_from/hello_file\0";
+    cmd.write_stdin(input.as_ref());
+    let finished = &cmd.unwrap();
+    let stderr = std::str::from_utf8(&finished.stderr).unwrap();
+    assert_eq!(stderr, "");
+    let output = std::str::from_utf8(&finished.stdout).unwrap();
+    assert!(output.contains("a_file"));
+    assert!(output.contains("hello_file"));
+}
+
 #[test]
 pub fn test_with_bad_param() {
    let mut cmd = Command::cargo_bin("dust").unwrap();
-    let result = cmd.arg("bad_place").unwrap();
+    cmd.arg("-P").arg("bad_place");
+    let output_error = cmd.unwrap_err();
+    let result = output_error.as_output().unwrap();
    let stderr = str::from_utf8(&result.stderr).unwrap();
    assert!(stderr.contains("No such file or directory"));
 }
@@ -254,3 +315,26 @@ pub fn test_force_color() {
    assert!(output.contains("\x1B[31m"));
    assert!(output.contains("\x1B[0m"));
 }
+
+#[test]
+pub fn test_collapse() {
+    let output = build_command(vec!["--collapse", "many", "tests/test_dir/"]);
+    assert!(output.contains("many"));
+    assert!(!output.contains("hello_file"));
+}
+
+#[test]
+pub fn test_handle_duplicate_names() {
+    // Check that even if we run on a multiple directories with the same name
+    // we still show the distinct parent dir in the output
+    let output = build_command(vec![
+        "tests/test_dir_matching/dave/dup_name",
+        "tests/test_dir_matching/andy/dup_name",
+        "ci",
+    ]);
+    assert!(output.contains("andy"));
+    assert!(output.contains("dave"));
+    assert!(output.contains("ci"));
+    assert!(output.contains("dup_name"));
+    assert!(!output.contains("test_dir_matching"));
+}
Author	SHA1	Message	Date
andy.boot	d00519085a	style: fix clippy	2025-10-06 20:31:20 +01:00
andy.boot	04b80b474c	deps: cargo update	2025-10-06 20:28:41 +01:00
Vaso Putica	96e04fe168	fix: number-of-lines option in config file is ignored (#528 ) Co-authored-by: andy.boot <bootandy@gmail.com>	2025-10-06 20:22:35 +01:00
Junghyeon Park	7974e2eaf0	feat: support --files-from/--files0-from Read NUL- or newline-terminated paths from FILE or stdin. Wire options through `config` and `main`. Add tests and update the man page, README, and completion scripts.	2025-10-06 20:11:01 +01:00
dustin fletcher	14efddfd05	Update README.md wrap one-liner in Alternatives section with backticks (`) for code formatting	2025-10-06 20:01:04 +01:00
andy.boot	4e83421da6	version: increment version	2025-07-31 22:33:44 +01:00
andy.boot	901bc3895a	feat: Return 1 if no dirs are found A better error code	2025-07-31 22:33:44 +01:00
andy.boot	3cce61f854	tests: add test for d0 Test to stop bug in previous commit occuring Also cargo clippy	2025-07-28 22:35:40 +01:00
Yip Coekjan	222cd83ff3	Fix multi-paths output when `depth` is `0`	2025-07-28 22:15:34 +01:00
andy.boot	76b9f32859	release: increment version	2025-07-06 09:46:33 +01:00
andy.boot	17662e8ff1	refactor: ThreadPool use build not build_global (#512 ) Dangerous: Change how threadpool initialized	2025-07-06 09:42:02 +01:00
andy.boot	9cc557cada	docs: update readme Improve description of -f, by default this counts by inode, Use -f -s to count files and include duplicate inodes.	2025-07-05 15:34:08 +01:00
andy.boot	81722b695d	fix: dir_walker interrupted error (#507 ) * fix: dir_walker interrupted error Ignore and continue if we get many interrupted errors instead of panicing on 3. This is from user feedback who reported occasional panics from too many interrupted errors https://github.com/bootandy/dust/issues/495#issuecomment-3026673312 * Revert "fix: dir_walker interrupted error" This reverts commit `84fa0ea9a4`. * fix: interrupted error, set limit to 999 instead.	2025-07-05 10:01:10 +01:00
andy.boot	51dc167345	deps: cargo update (#510 ) * hack * Revert "hack" This reverts commit d51c5b890439ec5ea46a10454801f9ca3593afca. * deps: upgrade	2025-07-05 09:42:26 +01:00
andy.boot	9b5f6d6c5a	style: fix clippy	2025-07-02 18:53:24 +01:00
andy.boot	74ffd78901	refactor: pull out more methods, remove unused Option	2025-06-06 20:44:00 +01:00
andy.boot	9b2dc4655d	refactor: extract function	2025-06-04 20:57:57 +01:00
andy.boot	29441eda19	version: increment version	2025-06-04 20:07:23 +01:00
andy.boot	e6f90362a7	fix: bug: Remove bad error handling This may be causing dust to lock up as we were accidentally creating a second editable_error causing threads to lock. https://github.com/bootandy/dust/issues/495	2025-06-04 19:55:50 +01:00
Shun Sakai	702f0f0fe9	chore(cli): Migrate to Derive API Change the definition of CLI from the Builder API to the Derive API.	2025-05-16 22:09:27 +01:00
andy.boot	6a14d7e8b3	style: Fix clippy New clippy has new standards. Clean up get_metadata by removing unused return	2025-04-20 19:55:36 +01:00
Teemu Pätsi	4e2d93f362	refactor: Fix clippy warnings (#488 ) * refactor: Use `repeat_n` instead of `repeat` and `take` Fixes `clippy::manual_repeat_n` * refactor: Remove unnecessary let binding	2025-04-20 18:48:11 +01:00
Teemu Pätsi	b616378ba0	Fix: miscalculation of NTFS mount file sizes inside WSL (#487 ) * fix: Limit file size based on the file system I/O block size * fix: Take possible file pre-allocation into account * refactor: Reduce indenting with early return * refactor: Fix clippy::manual_div_ceil * fix: Use target_size instead of max_size * fix: Take possible pre-allocation for a file into account https://github.com/bootandy/dust/pull/487#issuecomment-2816885444	2025-04-20 08:50:09 +01:00
andy.boot	646cdd976d	release: increment version (#485 )	2025-04-01 23:19:59 +01:00
andy.boot	9a49221ac1	fix: status mesages go to stderr not stdout (#483 ) Progress spinner and status line are written to stderr instead of stdout. No longer any need to detect if stdout is being redirected.	2025-04-01 23:19:36 +01:00
andy.boot	1b4116e39d	fix: all arguments now use '-' instead of '_' (#484 ) * cli: unify long arguments (dashes instead of underscores) * completions: autoregen completions --------- Co-authored-by: Pavel Kulyov <kulyov.pavel@gmail.com>	2025-04-01 23:18:49 +01:00
Aidan Beggs	733abb2a3f	feat: Abort immedietly when ^C is received. (#478 ) Previously, we attempted to perform a clean shutdown, which could take a significant period of time on slow filesystems. This commit changes the shutdown logic to abort immedietly when ^C is received by the program.	2025-03-30 17:35:28 +01:00
andy.boot	dd799706fb	deps: cargo update (#474 ) * deps: cargo update * deps: Update edition 2024 and run cargo update	2025-03-11 00:38:38 +00:00
Teemu Pätsi	b219981c52	rewrite: Reduce indentation with guard clause	2025-03-10 21:25:13 +00:00
Teemu Pätsi	c31468b199	perf: Canonicalize ignored absolute path only once	2025-03-10 21:25:13 +00:00
Teemu Pätsi	28d409ea27	refactor: Extract is_ignored_path function	2025-03-10 21:25:13 +00:00
Teemu Pätsi	aa319e3599	perf: Do not canonicalize non-absolute ignored path	2025-03-10 21:25:13 +00:00
Teemu Pätsi	c2a4c4573a	fix: Ignoring absolute path with `-X` option	2025-03-10 21:25:13 +00:00
andy.boot	d876cc28a7	release: Increment version	2025-02-27 22:08:38 +00:00
andy.boot	137e366eca	feat: Handle duplicate dir names better If we run `dust /usr/*/Trash` We see several 'Trash' directories in the output but do not know which user they belong to. This fix means if we see duplicate names in a directory we will display the parent directory name as well	2025-02-20 22:08:06 +00:00
andy.boot	a962b80eec	deps: cargo update	2025-02-06 00:30:39 +00:00
andy.boot	01c0aaeade	feat: New --collapse flag --collapse will keep that directory collapsed and will not expand it.	2025-01-27 22:00:08 +00:00
andy.boot	6cbd736e11	fix: Bars in --skip-total flag Before we calculated the % by taking the longest bar. If you use --skip-total the longest bar is not the total. We need to sum up all the children of root to work out what the largest size is.	2025-01-26 11:22:37 +00:00
andy.boot	8e087e09da	fix: Handle Interrupted Error Rust may throw Interrupted errors while scanning filesystem. These may be retried: https://doc.rust-lang.org/std/io/enum.ErrorKind.html#variant.Interrupted	2025-01-26 11:22:04 +00:00
andy.boot	9ba0b6d1d0	feat: Support -o flag for JSON output requested in: https://github.com/bootandy/dust/issues/450	2025-01-17 20:48:56 +00:00
andy.boot	775d841840	style: clippy	2025-01-15 21:37:29 +00:00
n4n5	609fc1e760	clippy	2025-01-15 19:14:00 +00:00
n4n5	eeb686562d	push config option	2025-01-15 19:14:00 +00:00
n4n5	e0eaeccc0b	add wget install	2025-01-15 19:08:18 +00:00
n4n5	2e56a261e0	clippy	2025-01-15 19:08:18 +00:00
n4n5	bfe7323b20	fix typo Operator	2025-01-15 19:08:18 +00:00
janbridley	1372815007	Format src/display.rs	2024-11-08 22:50:03 +00:00
janbridley	7c9e2f1833	Enable pretty format for petabyte data	2024-11-08 22:50:03 +00:00
Camille Louédoc-Eyriès	1d40ca0870	docs(readme): warn about snap-dust limitations	2024-10-17 23:03:35 +01:00
Yukai Chou	86b2bd944c	refactor: simplify `get_height_of_terminal()` and `get_width...`	2024-09-16 22:01:10 +01:00
andy.boot	b63608604a	docs: Update README.md	2024-09-03 21:57:36 +01:00
andy.boot	b24fab720d	deps: cargo update	2024-09-03 21:54:20 +01:00
wugeer	d81b9065a1	fix: man-page and completions missing in debian package	2024-09-03 21:49:23 +01:00
andy.boot	38c4d23732	docs: Update README.md include snap	2024-08-21 18:53:55 +01:00
wugeer	99bf0fc041	docs: update sample config.toml	2024-08-21 18:47:15 +01:00
wugeer	75d0566949	feat: use pre-commit hooks to standardize commit messages	2024-08-21 18:46:20 +01:00
NoisyCoil	489d9ada44	fix: 64-bit atomics for platforms with no 64-bit atomics Closes: #423	2024-08-09 19:28:20 +01:00
wugeer	f48fcc790a	feat: support Dust tree by age	2024-08-07 19:31:22 +01:00
wugeer	733117d0f6	fix: retrieve metadata for symbolic links without following them Previously, the function get_metadata in platform.rs used `fs::metadata` which follows symbolic links and returns metadata for the target file. This caused issues #421: du / dust disagreement when trying to determine properties of the symbolic link itself	2024-07-31 00:16:59 +01:00