Merge pull request #56 from sreedevk/feature/add-json-output

Version 0.2.1

.github/workflows/release.yml

@@ -1,41 +1,137 @@
+# CI that:
+#
+# * checks for a Git Tag that looks like a release
+# * creates a Github Release™ and fills in its text
+# * builds artifacts with cargo-dist (executable-zips, installers)
+# * uploads those artifacts to the Github Release™
+#
+# Note that the Github Release™ will be created before the artifacts,
+# so there will be a few minutes where the release has no artifacts
+# and then they will slowly trickle in, possibly failing. To make
+# this more pleasant we mark the release as a "draft" until all
+# artifacts have been successfully uploaded. This allows you to
+# choose what to do with partial successes and avoids spamming
+# anyone with notifications before the release is actually ready.
 name: Release
 
-env:
-  PROJECT_NAME: deduplicator
-  PROJECT_DESC: "Filter, Sort & Delete Duplicate Files Recursively"
-  PROJECT_AUTH: "sreedevk"
+permissions:
+  contents: write
 
+# This task will run whenever you push a git tag that looks like a version
+# like "v1", "v1.2.0", "v0.1.0-prerelease01", "my-app-v1.0.0", etc.
+# The version will be roughly parsed as ({PACKAGE_NAME}-)?v{VERSION}, where
+# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION
+# must be a Cargo-style SemVer Version.
+#
+# If PACKAGE_NAME is specified, then we will create a Github Release™ for that
+# package (erroring out if it doesn't have the given version or isn't cargo-dist-able).
+#
+# If PACKAGE_NAME isn't specified, then we will create a Github Release™ for all
+# (cargo-dist-able) packages in the workspace with that version (this is mode is
+# intended for workspaces with only one dist-able package, or with all dist-able
+# packages versioned/released in lockstep).
+#
+# If you push multiple tags at once, separate instances of this workflow will
+# spin up, creating an independent Github Release™ for each one.
+#
+# If there's a prerelease-style suffix to the version then the Github Release™
+# will be marked as a prerelease.
 on:
   push:
     tags:
-      - "[0-9]+.*"
+      - '*-?v[0-9]+*'
 
 jobs:
+  # Create the Github Release™ so the packages have something to be uploaded to
   create-release:
     runs-on: ubuntu-latest
+    outputs:
+      has-releases: ${{ steps.create-release.outputs.has-releases }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
       - uses: actions/checkout@v3
-      - uses: taiki-e/create-gh-release-action@v1.6.2
-        with:
-          changelog: CHANGELOG.md
-          token: ${{ secrets.GITHUB_TOKEN }}
-          branch: main
+      - name: Install Rust
+        run: rustup update 1.71.0 --no-self-update && rustup default 1.71.0
+      - name: Install cargo-dist
+        run: curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.0.7/cargo-dist-installer.sh | sh
+      - id: create-release
+        run: |
+          cargo dist plan --tag=${{ github.ref_name }} --output-format=json > dist-manifest.json
+          echo "dist plan ran successfully"
+          cat dist-manifest.json
 
-  upload-assets:
+          # Create the Github Release™ based on what cargo-dist thinks it should be
+          ANNOUNCEMENT_TITLE=$(jq --raw-output ".announcement_title" dist-manifest.json)
+          IS_PRERELEASE=$(jq --raw-output ".announcement_is_prerelease" dist-manifest.json)
+          jq --raw-output ".announcement_github_body" dist-manifest.json > new_dist_announcement.md
+          gh release create ${{ github.ref_name }} --draft --prerelease="$IS_PRERELEASE" --title="$ANNOUNCEMENT_TITLE" --notes-file=new_dist_announcement.md
+          echo "created announcement!"
+
+          # Upload the manifest to the Github Release™
+          gh release upload ${{ github.ref_name }} dist-manifest.json
+          echo "uploaded manifest!"
+
+          # Disable all the upload-artifacts tasks if we have no actual releases
+          HAS_RELEASES=$(jq --raw-output ".releases != null" dist-manifest.json)
+          echo "has-releases=$HAS_RELEASES" >> "$GITHUB_OUTPUT"
+
+  # Build and packages all the things
+  upload-artifacts:
+    # Let the initial task tell us to not run (currently very blunt)
+    needs: create-release
+    if: ${{ needs.create-release.outputs.has-releases == 'true' }}
     strategy:
       matrix:
-        os:
-          - ubuntu-latest
-          - macos-latest
-          - windows-latest
+        # For these target platforms
+        include:
+        - os: macos-11
+          dist-args: --artifacts=local --target=aarch64-apple-darwin --target=x86_64-apple-darwin
+          install-dist: curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.0.7/cargo-dist-installer.sh | sh
+        - os: ubuntu-20.04
+          dist-args: --artifacts=local --target=x86_64-unknown-linux-gnu
+          install-dist: curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.0.7/cargo-dist-installer.sh | sh
+        - os: windows-2019
+          dist-args: --artifacts=local --target=x86_64-pc-windows-msvc
+          install-dist: irm  https://github.com/axodotdev/cargo-dist/releases/download/v0.0.7/cargo-dist-installer.ps1 | iex
+
     runs-on: ${{ matrix.os }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
       - uses: actions/checkout@v3
-      - uses: taiki-e/upload-rust-binary-action@v1
-        with:
-          bin: deduplicator
-          tar: unix
-          zip: windows
-          token: ${{ secrets.GITHUB_TOKEN }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Install Rust
+        run: rustup update 1.71.0 --no-self-update && rustup default 1.71.0
+      - name: Install cargo-dist
+        run: ${{ matrix.install-dist }}
+      - name: Run cargo-dist
+        # This logic is a bit janky because it's trying to be a polyglot between
+        # powershell and bash since this will run on windows, macos, and linux!
+        # The two platforms don't agree on how to talk about env vars but they
+        # do agree on 'cat' and '$()' so we use that to marshal values between commands.
+        run: |
+          # Actually do builds and make zips and whatnot
+          cargo dist build --tag=${{ github.ref_name }} --output-format=json ${{ matrix.dist-args }} > dist-manifest.json
+          echo "dist ran successfully"
+          cat dist-manifest.json
+
+          # Parse out what we just built and upload it to the Github Release™
+          jq --raw-output ".artifacts[]?.path | select( . != null )" dist-manifest.json > uploads.txt
+          echo "uploading..."
+          cat uploads.txt
+          gh release upload ${{ github.ref_name }} $(cat uploads.txt)
+          echo "uploaded!"
+
+  # Mark the Github Release™ as a non-draft now that everything has succeeded!
+  publish-release:
+    # Only run after all the other tasks, but it's ok if upload-artifacts was skipped
+    needs: [create-release, upload-artifacts]
+    if: ${{ always() && needs.create-release.result == 'success' && (needs.upload-artifacts.result == 'skipped' || needs.upload-artifacts.result == 'success') }}
+    runs-on: ubuntu-latest
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: mark release as non-draft
+        run: |
+          gh release edit ${{ github.ref_name }} --draft=false

.gitignore

@@ -1,2 +1,2 @@
 /target
-/test_data
+/Cargo.lock

Cargo.toml

@@ -1,10 +1,15 @@
 [package]
 name = "deduplicator"
-version = "0.1.3"
+version = "0.2.1"
 edition = "2021"
 description = "find,filter,delete Duplicates"
+repository = "https://github.com/sreedevk/deduplicator"
 license = "MIT"
-authors = ["Sreedev Kodichath <sreedevpadmakumar@gmail.com>", "Valentin Bersier <vbersier@gmail.com>", "Dhruva Sagar <dhruva.sagar@gmail.com>"]
+authors = [
+    "Sreedev Kodichath <sreedevpadmakumar@gmail.com>",
+    "Valentin Bersier <vbersier@gmail.com>",
+    "Dhruva Sagar <dhruva.sagar@gmail.com>",
+]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -16,12 +21,27 @@ clap = { version = "4.0.32", features = ["derive"] }
 colored = "2.0.0"
 dashmap = { version = "5.4.0", features = ["rayon"] }
 fxhash = "0.2.1"
-glob = "0.3.0"
-indicatif = { version = "0.17.2", features = ["rayon", "tokio"] }
+globwalk = "0.8.1"
+indicatif = { version = "0.17.2", features = ["rayon"] }
 itertools = "0.10.5"
 memmap2 = "0.5.8"
+pathdiff = "0.2.1"
 prettytable-rs = "0.10.0"
 rayon = "1.6.1"
-thiserror = "1.0.38"
-tokio = { version = "1.23.1", features = ["full"] }
+serde = { version = "1.0.192", features = ["derive"] }
+serde_json = "1.0.108"
 unicode-segmentation = "1.10.0"
+
+[profile.release]
+strip = true
+
+# generated by 'cargo dist init'
+[profile.dist]
+inherits = "release"
+lto = "thin"
+
+[workspace.metadata.dist]
+rust-toolchain-version = "1.71.0"
+ci = ["github"]
+targets = ["x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc", "aarch64-apple-darwin"]
+cargo-dist-version = "0.0.7"

README.md

@@ -4,45 +4,126 @@
   Find, Sort, Filter & Delete duplicate files 
 </p>
 
-<p align="center">
-NOTE: This project is still being developed. At the moment, as shown in the screenshot below, deduplicator is able to scan through and list duplicates with and without caching. Contributions are welcome.
-</p>
-
-<h2 align="center">Usage</h2>
+## Usage
 
 ```bash
-Usage: deduplicator [OPTIONS]
+Usage: deduplicator [OPTIONS] [scan_dir_path]
+
+Arguments:
+  [scan_dir_path]  Run Deduplicator on dir different from pwd (e.g., ~/Pictures )
 
 Options:
-  -t, --types <TYPES>      Filetypes to deduplicate (default = all)
-      --dir <DIR>          Run Deduplicator on dir different from pwd
-  -i, --interactive        Delete files interactively
-  -m, --minsize <MINSIZE>  Minimum filesize of duplicates to scan (e.g., 100B/1K/2M/3G/4T). [default = 0]
-  -h, --help               Print help information
-  -V, --version            Print version information
+  -t, --types <TYPES>          Filetypes to deduplicate [default = all]
+  -i, --interactive            Delete files interactively
+  -s, --min-size <MIN_SIZE>    Minimum filesize of duplicates to scan (e.g., 100B/1K/2M/3G/4T) [default: 1b]
+  -d, --max-depth <MAX_DEPTH>  Max Depth to scan while looking for duplicates
+      --min-depth <MIN_DEPTH>  Min Depth to scan while looking for duplicates
+  -f, --follow-links           Follow links while scanning directories
+  -h, --help                   Print help information
+  -V, --version                Print version information
+      --json                    
+```
+### Examples
+
+```bash
+# Scan for duplicates recursively from the current dir, only look for png, jpg & pdf file types & interactively delete files
+deduplicator -t pdf,jpg,png -i
+
+# Scan for duplicates recursively from the ~/Pictures dir, only look for png, jpeg, jpg & pdf file types & interactively delete files
+deduplicator ~/Pictures/ -t png,jpeg,jpg,pdf -i
+
+# Scan for duplicates in the ~/Pictures without recursing into subdirectories
+deduplicator ~/Pictures --max-depth 0
+
+# look for duplicates in the ~/.config directory while also recursing into symbolic link paths
+deduplicator ~/.config --follow-links
+
+# scan for duplicates that are greater than 100mb in the ~/Media directory
+deduplicator ~/Media --min-size 100mb
 ```
 
-<h2 align="center">Installation</h2>
+## Installation
 
-<p align="center">Currently, deduplicator is only installable via rust's cargo package manager</p>
+### Cargo Install
+
+#### Stable
+
+```bash
+$ cargo install deduplicator
+```
+
+#### Nightly
+
+if you'd like to install with nightly features, you can use
+
+```bash
+$ cargo install --git https://github.com/sreedevk/deduplicator
+```
+Please note that if you use a version manager to install rust (like asdf), you need to reshim (`asdf reshim rust`).
+
+### Linux (Pre-built Binary)
+
+you can download the pre-built binary from the [Releases](https://github.com/sreedevk/deduplicator/releases) page.
+download the `deduplicator-x86_64-unknown-linux-gnu.tar.gz` for linux. Once you have the tarball file with the executable,
+you can follow these steps to install:
+
+```bash
+$ tar -zxvf deduplicator-x86_64-unknown-linux-gnu.tar.gz
+$ sudo mv deduplicator /usr/bin/
+```
+
+### Mac OS (Pre-built Binary)
+
+you can download the pre-build binary from the [Releases](https://github.com/sreedevk/deduplicator/releases) page.
+download the `deduplicator-x86_64-apple-darwin.tar.gz` tarball for mac os. Once you have the tarball file with the executable, you can follow these steps to install:
+
+```bash
+$ tar -zxvf deduplicator-x86_64-unknown-linux-gnu.tar.gz
+$ sudo mv deduplicator /usr/bin/
+```
+
+### Windows (Pre-built Binary)
+
+you can download the pre-build binary from the [Releases](https://github.com/sreedevk/deduplicator/releases) page.
+download the `deduplicator-x86_64-pc-windows-msvc.zip` zip file for windows. unzip the `zip`  file & move the `deduplicator.exe` to a location in the PATH system environment variable.
+
+Note: If you Run into an msvc error, please install MSCV from [here](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170)
+
+## Performance
+
+Deduplicator uses size comparison and fxhash (a non non-cryptographic hashing algo) to quickly scan through large number of files to find duplicates. its also highly parallel (uses rayon and dashmap). I was able to scan through 120GB of files (Videos, PDFs, Images) in ~300ms. checkout the benchmarks
+
+## benchmarks
+
+| Command | Dirsize | Filecount | Mean [ms] | Min [ms] | Max [ms] | Relative |
+|:---|:---|---:|---:|---:|---:|---:|
+| `deduplicator ~/Data/tmp` | (~120G) | 721 files | 33.5 ± 28.6 | 25.3 | 151.5 | 1.87 ± 1.60 |
+| `deduplicator ~/Data/books` | (~8.6G) | 1419 files | 24.5 ± 1.0 | 22.9 | 28.1 | 1.37 ± 0.08 |
+| `deduplicator ~/Data/books --min-size 10M` | (~8.6G) | 1419 files | 17.9 ± 0.7 | 16.8 | 20.0 | 1.00 |
+| `deduplicator ~/Data/ --types pdf,jpg,png,jpeg` | (~290G) | 104222 files | 1207.2 ± 37.0 | 1172.2 | 1287.7 | 67.27 ± 3.33 |
+
+* The last entry is lower because of the number of files deduplicator had to go through (~660895 Files). The average size of the files rarely affect the performance of deduplicator.
+
+These benchmarks were run using [hyperfine](https://github.com/sharkdp/hyperfine). Here are the specs of the machine used to benchmark deduplicator:
 
 ```
-cargo install deduplicator
+OS: Arch Linux x86_64 
+Host: Precision 5540
+Kernel: 5.15.89-1-lts 
+Uptime: 4 hours, 44 mins 
+Shell: zsh 5.9                        
+Terminal: kitty 
+CPU: Intel i9-9880H (16) @ 4.800GHz 
+GPU: NVIDIA Quadro T2000 Mobile / Max-Q 
+GPU: Intel CoffeeLake-H GT2 [UHD Graphics 630] 
+Memory: 31731MiB (~32GiB)
 ```
-<p align="center">
-  note that if you use a version manager to install rust (like asdf), you need to reshim (`asdf reshim rust`).
-</p>
 
-<h2 align="center">Performance</h2>
+## Screenshots
 
-<p align="center">
-  Deduplicator uses fxhash (a non-cryptographic hashing algorithm) which is extremely fast. As a result, deduplicator is able to process huge amounts of data in a <del>couple of seconds.</del> few milliseconds.</p>
+![](https://user-images.githubusercontent.com/36154121/213618143-e5182e39-731e-4817-87dd-1a6a0f38a449.gif)
 
-<p align="center">
-  <del>While testing, Deduplicator was able to go through 8.6GB of pdf files and detect duplicates in 2.9 seconds</del>
-  As of version 0.1.1, on testing locally, deduplicator was able to process and find duplicates in 120GB of files (Videos, PDFs, Images) in ~300ms
-</p>
-
-<h2 align="center">Screenshots</h2>
-
-<img src="https://user-images.githubusercontent.com/36154121/213618143-e5182e39-731e-4817-87dd-1a6a0f38a449.gif" />
+## Roadmap
+    - Tree format output for duplicate file listing
+    - GUI
+    - Packages for different operating system repositories (currently only installable via cargo) 

src/app.rs

@@ -1,18 +0,0 @@
-use crate::output;
-use crate::params::Params;
-use crate::scanner;
-use anyhow::Result;
-
-pub struct App;
-
-impl App {
-    pub fn init(app_args: &Params) -> Result<()> {
-        let duplicates = scanner::duplicates(app_args)?;
-        match app_args.interactive {
-            true => output::interactive(duplicates, app_args),
-            false => output::print(duplicates, app_args),
-        }
-
-        Ok(())
-    }
-}

src/file_manager.rs

@@ -1,20 +0,0 @@
-use anyhow::Result;
-use colored::Colorize;
-
-#[derive(Debug, Clone)]
-pub struct File {
-    pub path: String,
-    pub size: Option<u64>,
-    pub hash: Option<String>,
-}
-
-pub fn delete_files(files: Vec<File>) -> Result<()> {
-    files.into_iter().for_each(|file| {
-        match std::fs::remove_file(file.path.clone()) {
-            Ok(_) => println!("{}: {}", "DELETED".green(), file.path),
-            Err(_) => println!("{}: {}", "FAILED".red(), file.path)
-        }
-    });
-
-    Ok(())
-}

src/fileinfo.rs

@@ -0,0 +1,42 @@
+use anyhow::Result;
+use memmap2::Mmap;
+use std::fs;
+use std::hash::Hasher;
+use std::{fs::Metadata, path::PathBuf};
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct FileInfo {
+    pub path: PathBuf,
+    pub hash: Option<String>,
+    pub size: u64,
+    #[serde(skip)]
+    pub filemeta: Metadata,
+}
+
+impl FileInfo {
+    pub fn hash(&self) -> Result<Self> {
+        let file = fs::File::open(self.path.clone())?;
+        let mapper = unsafe { Mmap::map(&file)? };
+        let mut primhasher = fxhash::FxHasher::default();
+
+        mapper
+            .chunks(1_000_000)
+            .for_each(|chunk| primhasher.write(chunk));
+
+        Ok(Self {
+            hash: Some(primhasher.finish().to_string()),
+            ..self.clone()
+        })
+    }
+
+    pub fn new(path: PathBuf) -> Result<Self> {
+        let filemeta = std::fs::metadata(path.clone())?;
+        Ok(Self {
+            path,
+            filemeta: filemeta.clone(),
+            hash: None,
+            size: filemeta.len(),
+        })
+    }
+}

src/filters.rs

@@ -1,12 +0,0 @@
-use crate::file_manager::File;
-use crate::params::Params;
-
-pub fn is_file_gt_minsize(app_opts: &Params, file: &File) -> bool {
-    match app_opts.get_minsize() {
-        Some(msize) => match file.size {
-            Some(fsize) => fsize >= msize,
-            None => true,
-        },
-        None => true,
-    }
-}

src/formatter.rs

@@ -0,0 +1,134 @@
+pub struct Formatter;
+use crate::fileinfo::FileInfo;
+use crate::params::Params;
+use anyhow::Result;
+use chrono::{DateTime, Utc};
+use colored::Colorize;
+use dashmap::DashMap;
+use indicatif::{
+    ParallelProgressIterator, ProgressBar, ProgressFinish, ProgressIterator, ProgressStyle,
+};
+use pathdiff::diff_paths;
+use prettytable::{format, row, Table};
+use rayon::prelude::*;
+use std::borrow::Cow;
+use std::path::PathBuf;
+use std::time::Duration;
+
+impl Formatter {
+    pub fn human_path(
+        file: &FileInfo,
+        app_args: &Params,
+        min_path_length: usize,
+    ) -> Result<String> {
+        let base_directory: PathBuf = app_args.get_directory()?;
+        let relative_path = diff_paths(file.path.clone(), base_directory).unwrap_or_default();
+
+        let formatted_path = format!(
+            "{:<0width$}",
+            relative_path.to_str().unwrap_or_default().to_string(),
+            width = min_path_length
+        );
+
+        Ok(formatted_path)
+    }
+
+    pub fn human_filesize(file: &FileInfo) -> Result<String> {
+        Ok(format!("{:>12}", bytesize::ByteSize::b(file.size)))
+    }
+
+    pub fn human_mtime(file: &FileInfo) -> Result<String> {
+        let modified_time: DateTime<Utc> = file.filemeta.modified()?.into();
+        Ok(modified_time.format("%Y-%m-%d %H:%M:%S").to_string())
+    }
+
+    pub fn generate_table(raw: Vec<FileInfo>, app_args: &Params) -> Result<Table> {
+        let basepath_length = app_args.get_directory()?.to_str().unwrap_or_default().len();
+        let max_filepath_length = raw
+            .iter()
+            .map(|file| file.path.to_str().unwrap_or_default().len())
+            .max()
+            .unwrap_or_default();
+
+        let min_path_length = if max_filepath_length > basepath_length {
+            max_filepath_length - basepath_length
+        } else {
+            0
+        };
+
+        let progress_style = ProgressStyle::with_template(
+            "[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}",
+        )?;
+        let progress_bar = ProgressBar::new(raw.len() as u64);
+        progress_bar.set_style(progress_style);
+        progress_bar.enable_steady_tick(Duration::from_millis(50));
+        progress_bar.set_message("reconciling data");
+
+        let duplicates_table: DashMap<String, Vec<FileInfo>> = DashMap::new();
+        raw.into_par_iter()
+            .progress_with(progress_bar)
+            .with_finish(ProgressFinish::WithMessage(Cow::from("data reconciled")))
+            .map(|file| file.hash())
+            .filter_map(Result::ok)
+            .for_each(|file| {
+                duplicates_table
+                    .entry(file.hash.clone().unwrap_or_default())
+                    .and_modify(|fileset| fileset.push(file.clone()))
+                    .or_insert_with(|| vec![file]);
+            });
+
+        let mut output_table = Table::new();
+        output_table.set_titles(row!["hash", "duplicates"]);
+
+        let progress_style = ProgressStyle::with_template(
+            "[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}",
+        )?;
+
+        let progress_bar = ProgressBar::new(duplicates_table.len() as u64);
+        progress_bar.set_style(progress_style);
+        progress_bar.enable_steady_tick(Duration::from_millis(50));
+        progress_bar.set_message("generating output");
+
+        duplicates_table
+            .into_iter()
+            .progress_with(progress_bar)
+            .with_finish(ProgressFinish::WithMessage(Cow::from("output generated")))
+            .for_each(|(hash, group)| {
+                let mut inner_table = Table::new();
+                inner_table.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
+                group.iter().for_each(|file| {
+                    inner_table.add_row(row![
+                        Self::human_path(file, app_args, min_path_length)
+                            .unwrap_or_default()
+                            .blue(),
+                        Self::human_filesize(file).unwrap_or_default().red(),
+                        Self::human_mtime(file).unwrap_or_default().yellow()
+                    ]);
+                });
+
+                output_table.add_row(row![hash.green(), inner_table]);
+            });
+
+        Ok(output_table)
+    }
+
+    pub fn print(raw: Vec<FileInfo>, app_args: &Params) -> Result<()> {
+        if raw.is_empty() {
+            println!(
+                "\n\n{}\n",
+                "No duplicates found matching your search criteria.".green()
+            );
+            return Ok(());
+        }
+
+        if app_args.json {
+            let output_json = serde_json::to_string_pretty(&raw)?;
+            println!("{}", output_json);
+        } else {
+            let output_table = Self::generate_table(raw, app_args)?;
+            output_table.printstd();
+        }
+
+        Ok(())
+    }
+}

src/interactive.rs

@@ -0,0 +1,154 @@
+use crate::formatter::Formatter;
+use crate::{fileinfo::FileInfo, params::Params};
+use anyhow::Result;
+use colored::Colorize;
+use dashmap::DashMap;
+use indicatif::{ParallelProgressIterator, ProgressBar, ProgressFinish, ProgressStyle};
+use prettytable::{format, row, Table};
+use rayon::prelude::*;
+use std::{
+    borrow::Cow,
+    io::{self, Write},
+    time::Duration,
+};
+
+pub fn scan_group_confirmation() -> Result<bool> {
+    print!("\nconfirm? [y/N]: ");
+    std::io::stdout().flush()?;
+    let mut user_input = String::new();
+    io::stdin().read_line(&mut user_input)?;
+
+    match user_input.trim() {
+        "Y" | "y" => Ok(true),
+        _ => Ok(false),
+    }
+}
+
+pub fn scan_group_instruction() -> Result<String> {
+    println!("\nEnter the indices of the files you want to delete.");
+    println!("You can enter multiple files using commas to seperate file indices.");
+    println!("example: 1,2");
+    print!("\n> ");
+    std::io::stdout().flush()?;
+    let mut user_input = String::new();
+    io::stdin().read_line(&mut user_input)?;
+
+    Ok(user_input)
+}
+
+pub fn init(result: Vec<FileInfo>, app_args: &Params) -> Result<()> {
+    let basepath_length = app_args.get_directory()?.to_str().unwrap_or_default().len();
+    let max_filepath_length = result
+        .iter()
+        .map(|file| file.path.to_str().unwrap_or_default().len())
+        .max()
+        .unwrap_or_default();
+
+    let min_path_length = if max_filepath_length > basepath_length {
+        max_filepath_length - basepath_length
+    } else {
+        0
+    };
+
+    let progress_style = ProgressStyle::with_template(
+        "[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}",
+    )?;
+    let progress_bar = ProgressBar::new(result.len() as u64);
+    progress_bar.set_style(progress_style);
+    progress_bar.enable_steady_tick(Duration::from_millis(50));
+    progress_bar.set_message("reconciling data");
+
+    let duplicates: DashMap<String, Vec<FileInfo>> = DashMap::new();
+    result
+        .into_par_iter()
+        .progress_with(progress_bar)
+        .with_finish(ProgressFinish::WithMessage(Cow::from("data reconciled")))
+        .map(|file| file.hash())
+        .filter_map(Result::ok)
+        .for_each(|file| {
+            duplicates
+                .entry(file.hash.clone().unwrap_or_default())
+                .and_modify(|fileset| fileset.push(file.clone()))
+                .or_insert_with(|| vec![file]);
+        });
+
+    duplicates
+        .clone()
+        .into_iter()
+        .enumerate()
+        .for_each(|(gindex, (_, group))| {
+            let mut itable = Table::new();
+            itable.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
+            itable.set_titles(row!["index", "filename", "size", "updated_at"]);
+            group.iter().enumerate().for_each(|(index, file)| {
+                itable.add_row(row![
+                    index,
+                    Formatter::human_path(file, app_args, min_path_length)
+                        .unwrap_or_default()
+                        .blue(),
+                    Formatter::human_filesize(file).unwrap_or_default().red(),
+                    Formatter::human_mtime(file).unwrap_or_default().yellow()
+                ]);
+            });
+
+            process_group_action(&group, gindex, duplicates.len(), itable);
+        });
+
+    Ok(())
+}
+
+pub fn process_group_action(
+    duplicates: &Vec<FileInfo>,
+    dup_index: usize,
+    dup_size: usize,
+    table: Table,
+) {
+    println!("\nDuplicate Set {} of {}\n", dup_index + 1, dup_size);
+    table.printstd();
+    let files_to_delete = scan_group_instruction().unwrap_or_default();
+    let parsed_file_indices = files_to_delete
+        .trim()
+        .split(',')
+        .filter(|element| !element.is_empty())
+        .map(|index| index.parse::<usize>().unwrap_or_default())
+        .collect::<Vec<usize>>();
+
+    if parsed_file_indices
+        .clone()
+        .into_iter()
+        .any(|index| index > (duplicates.len() - 1))
+    {
+        println!("{}", "Err: File Index Out of Bounds!".red());
+        return process_group_action(duplicates, dup_index, dup_size, table);
+    }
+
+    print!("{esc}[2J{esc}[1;1H", esc = 27 as char);
+
+    if parsed_file_indices.is_empty() {
+        return;
+    }
+
+    let files_to_delete = parsed_file_indices
+        .into_iter()
+        .map(|index| duplicates[index].clone());
+
+    println!("\n{}", "The following files will be deleted:".red());
+    files_to_delete
+        .clone()
+        .enumerate()
+        .for_each(|(index, file)| {
+            println!("{}: {}", index.to_string().blue(), file.path.display());
+        });
+
+    match scan_group_confirmation().unwrap() {
+        true => {
+            files_to_delete.into_iter().for_each(|file| {
+                match std::fs::remove_file(file.path.clone()) {
+                    Ok(_) => println!("{}: {}", "DELETED".green(), file.path.display()),
+                    Err(_) => println!("{}: {}", "FAILED".red(), file.path.display()),
+                }
+            });
+        }
+        false => println!("{}", "\nCancelled Delete Operation.".red()),
+    }
+}

src/main.rs

@@ -1,15 +1,31 @@
-mod app;
-mod file_manager;
-mod output;
+mod fileinfo;
+mod formatter;
+mod interactive;
 mod params;
+mod processor;
 mod scanner;
-mod filters;
 
 use anyhow::Result;
-use app::App;
 use clap::Parser;
+use formatter::Formatter;
+use params::Params;
+use processor::Processor;
+use scanner::Scanner;
 
-#[tokio::main]
-async fn main() -> Result<()> {
-    App::init(&params::Params::parse())
+fn main() -> Result<()> {
+    let app_args = Params::parse();
+    let scan_results = Scanner::build(&app_args)?.scan()?;
+    let processor = Processor::new(scan_results);
+    let results = processor.sizewise()?.hashwise()?;
+
+    match app_args.interactive {
+        false => {
+            Formatter::print(results.files, &app_args)?;
+        }
+        true => {
+            interactive::init(results.files, &app_args)?;
+        }
+    }
+
+    Ok(())
 }

src/output.rs

@@ -1,174 +0,0 @@
-use crate::file_manager::{self, File};
-use crate::params::Params;
-use anyhow::Result;
-use chrono::offset::Utc;
-use chrono::DateTime;
-use colored::Colorize;
-use dashmap::DashMap;
-use itertools::Itertools;
-use prettytable::{format, row, Table};
-use std::io::Write;
-use std::{fs, io};
-use unicode_segmentation::UnicodeSegmentation;
-
-fn format_path(path: &str, opts: &Params) -> Result<String> {
-    let display_path = path.replace(&opts.get_directory()?, "");
-    let display_range = if display_path.chars().count() > 32 {
-        display_path
-            .graphemes(true)
-            .collect::<Vec<&str>>()
-            .into_iter()
-            .rev()
-            .take(32)
-            .rev()
-            .collect()
-    } else {
-        display_path
-    };
-
-    Ok(format!("...{:<32}", display_range))
-}
-
-fn file_size(file: &File) -> Result<String> {
-    Ok(format!("{:>12}", bytesize::ByteSize::b(file.size.unwrap())))
-}
-
-fn modified_time(path: &String) -> Result<String> {
-    let mdata = fs::metadata(path)?;
-    let modified_time: DateTime<Utc> = mdata.modified()?.into();
-
-    Ok(modified_time.format("%Y-%m-%d %H:%M:%S").to_string())
-}
-
-fn scan_group_instruction() -> Result<String> {
-    println!("\nEnter the indices of the files you want to delete.");
-    println!("You can enter multiple files using commas to seperate file indices.");
-    println!("example: 1,2");
-    print!("\n> ");
-    std::io::stdout().flush()?;
-    let mut user_input = String::new();
-    io::stdin().read_line(&mut user_input)?;
-
-    Ok(user_input)
-}
-
-fn scan_group_confirmation() -> Result<bool> {
-    print!("\nconfirm? [y/N]: ");
-    std::io::stdout().flush()?;
-    let mut user_input = String::new();
-    io::stdin().read_line(&mut user_input)?;
-
-    match user_input.trim() {
-        "Y" | "y" => Ok(true),
-        _ => Ok(false),
-    }
-}
-
-fn process_group_action(duplicates: &Vec<File>, dup_index: usize, dup_size: usize, table: Table) {
-    println!("\nDuplicate Set {} of {}\n", dup_index + 1, dup_size);
-    table.printstd();
-    let files_to_delete = scan_group_instruction().unwrap_or_default();
-    let parsed_file_indices = files_to_delete
-        .trim()
-        .split(',')
-        .filter(|element| !element.is_empty())
-        .map(|index| index.parse::<usize>().unwrap_or_default())
-        .collect_vec();
-
-    if parsed_file_indices
-        .clone()
-        .into_iter()
-        .any(|index| index > (duplicates.len() - 1))
-    {
-        println!("{}", "Err: File Index Out of Bounds!".red());
-        return process_group_action(duplicates, dup_index, dup_size, table);
-    }
-
-    print!("{esc}[2J{esc}[1;1H", esc = 27 as char);
-
-    if parsed_file_indices.is_empty() {
-        return;
-    }
-
-    let files_to_delete = parsed_file_indices
-        .into_iter()
-        .map(|index| duplicates[index].clone());
-
-    println!("\n{}", "The following files will be deleted:".red());
-    files_to_delete
-        .clone()
-        .enumerate()
-        .for_each(|(index, file)| {
-            println!("{}: {}", index.to_string().blue(), file.path);
-        });
-
-    match scan_group_confirmation().unwrap() {
-        true => {
-            file_manager::delete_files(files_to_delete.collect_vec()).ok();
-        }
-        false => println!("{}", "\nCancelled Delete Operation.".red()),
-    }
-}
-
-pub fn interactive(duplicates: DashMap<String, Vec<File>>, opts: &Params) {
-    if duplicates.is_empty() {
-        println!(
-            "\n{}",
-            "No duplicates found matching your search criteria.".green()
-        );
-        return;
-    }
-
-    duplicates
-        .clone()
-        .into_iter()
-        .sorted_unstable_by_key(|(_, f)| {
-            -(f.first().and_then(|ff| ff.size).unwrap_or_default() as i64)
-        }) // sort by descending file size in interactive mode
-        .enumerate()
-        .for_each(|(gindex, (_, group))| {
-            let mut itable = Table::new();
-            itable.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
-            itable.set_titles(row!["index", "filename", "size", "updated_at"]);
-            group.iter().enumerate().for_each(|(index, file)| {
-                itable.add_row(row![
-                    index,
-                    format_path(&file.path, opts).unwrap_or_default().blue(),
-                    file_size(file).unwrap_or_default().red(),
-                    modified_time(&file.path).unwrap_or_default().yellow()
-                ]);
-            });
-
-            process_group_action(&group, gindex, duplicates.len(), itable);
-        });
-}
-
-pub fn print(duplicates: DashMap<String, Vec<File>>, opts: &Params) {
-    if duplicates.is_empty() {
-        println!(
-            "\n{}",
-            "No duplicates found matching your search criteria.".green()
-        );
-        return;
-    }
-
-    let mut output_table = Table::new();
-    output_table.set_titles(row!["hash", "duplicates"]);
-    duplicates
-        .into_iter()
-        .sorted_unstable_by_key(|(_, f)| f.first().and_then(|ff| ff.size).unwrap_or_default())
-        .for_each(|(hash, group)| {
-            let mut inner_table = Table::new();
-            inner_table.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
-            group.iter().for_each(|file| {
-                inner_table.add_row(row![
-                    format_path(&file.path, opts).unwrap_or_default().blue(),
-                    file_size(file).unwrap_or_default().red(),
-                    modified_time(&file.path).unwrap_or_default().yellow()
-                ]);
-            });
-            output_table.add_row(row![hash.green(), inner_table]);
-        });
-
-    output_table.printstd();
-}

src/params.rs

@@ -1,27 +1,40 @@
-use anyhow::{anyhow, Result};
-use clap::{Parser, ValueHint};
 use std::{fs, path::PathBuf};
 
-#[derive(Parser, Debug)]
+use anyhow::Result;
+use clap::{Parser, ValueHint};
+
+#[derive(Parser, Debug, Clone)]
 #[command(author, version, about, long_about = None)]
 pub struct Params {
-    /// Filetypes to deduplicate (default = all)
+    /// Filetypes to deduplicate [default = all]
     #[arg(short, long)]
     pub types: Option<String>,
-    /// Run Deduplicator on dir different from pwd
-    #[arg(long, value_hint = ValueHint::DirPath)]
+    /// Run Deduplicator on dir different from pwd (e.g., ~/Pictures )
+    #[arg(value_hint = ValueHint::DirPath, value_name = "scan_dir_path")]
     pub dir: Option<PathBuf>,
     /// Delete files interactively
     #[arg(long, short)]
     pub interactive: bool,
-    /// Minimum filesize of duplicates to scan (e.g., 100B/1K/2M/3G/4T). [default = 0]
+    /// Minimum filesize of duplicates to scan (e.g., 100B/1K/2M/3G/4T).
+    #[arg(long, short = 's', default_value = "1b")]
+    pub min_size: Option<String>,
+    /// Max Depth to scan while looking for duplicates
+    #[arg(long, short = 'd')]
+    pub max_depth: Option<usize>,
+    /// Min Depth to scan while looking for duplicates
+    #[arg(long)]
+    pub min_depth: Option<usize>,
+    /// Follow links while scanning directories
     #[arg(long, short)]
-    pub minsize: Option<String>,
+    pub follow_links: bool,
+    /// print json output
+    #[arg(long)]
+    pub json: bool,
 }
 
 impl Params {
-    pub fn get_minsize(&self) -> Option<u64> {
-        match &self.minsize {
+    pub fn get_min_size(&self) -> Option<u64> {
+        match &self.min_size {
             Some(msize) => match msize.parse::<bytesize::ByteSize>() {
                 Ok(units) => Some(units.0),
                 Err(_) => None,
@@ -30,35 +43,14 @@ impl Params {
         }
     }
 
-    pub fn get_directory(&self) -> Result<String> {
-        let dir_pathbuf: PathBuf = self
-            .dir
-            .as_ref()
-            .unwrap_or(&std::env::current_dir()?)
-            .as_os_str()
-            .into();
-
-        let dir = fs::canonicalize(dir_pathbuf)?
-            .as_os_str()
-            .to_str()
-            .ok_or_else(|| anyhow!("Invalid directory"))?
-            .to_string();
-
+    pub fn get_directory(&self) -> Result<PathBuf> {
+        let current_dir = std::env::current_dir()?;
+        let dir_path = self.dir.as_ref().unwrap_or(&current_dir).as_path();
+        let dir = fs::canonicalize(dir_path)?;
         Ok(dir)
     }
 
-    pub fn get_glob_patterns(&self) -> PathBuf {
-        match self.types.as_ref() {
-            Some(filetypes) => vec![
-                self.get_directory().unwrap(),
-                String::from("**"),
-                format!("{{{}}}", filetypes),
-            ]
-            .iter()
-            .collect::<PathBuf>(),
-            None => vec![self.get_directory().unwrap().as_str(), "**", "*"]
-                .iter()
-                .collect::<PathBuf>(),
-        }
+    pub fn get_types(&self) -> Option<String> {
+        self.types.clone()
     }
 }

src/processor.rs

@@ -0,0 +1,107 @@
+use anyhow::Result;
+use dashmap::DashMap;
+use indicatif::{ParallelProgressIterator, ProgressBar, ProgressStyle, ProgressFinish};
+use rayon::prelude::{IntoParallelIterator, ParallelIterator};
+use std::{time::Duration, borrow::Cow};
+
+use crate::fileinfo::FileInfo;
+
+#[derive(Debug, Clone)]
+pub enum State {
+    Initial,
+    SizeWise,
+    HashWise,
+}
+
+#[derive(Debug, Clone)]
+pub struct Processor {
+    pub files: Vec<FileInfo>,
+    pub state: State,
+}
+
+impl Processor {
+    pub fn new(files: Vec<FileInfo>) -> Self {
+        Self {
+            files,
+            state: State::Initial,
+        }
+    }
+
+    pub fn hashwise(&self) -> Result<Self> {
+        if self.files.is_empty() {
+            return Ok(self.clone());
+        }
+
+        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}")?;
+        let progress_bar = ProgressBar::new(self.files.len() as u64);
+        progress_bar.set_style(progress_style);
+        progress_bar.enable_steady_tick(Duration::from_millis(50));
+        progress_bar.set_message("indexing file hashes");
+
+        let duplicates_table: DashMap<String, Vec<FileInfo>> = DashMap::new();
+        self.files
+            .clone()
+            .into_par_iter()
+            .progress_with(progress_bar)
+            .with_finish(ProgressFinish::WithMessage(Cow::from("indexed files hashes")))
+            .map(|file| file.hash())
+            .filter_map(Result::ok)
+            .for_each(|file| {
+                duplicates_table
+                    .entry(file.hash.clone().unwrap_or_default())
+                    .and_modify(|fileset| fileset.push(file.clone()))
+                    .or_insert_with(|| vec![file]);
+            });
+
+        let files = duplicates_table
+            .into_read_only()
+            .values()
+            .cloned()
+            .filter(|subfiles| subfiles.len() > 1)
+            .flatten()
+            .collect::<Vec<FileInfo>>();
+
+        Ok(Self {
+            files,
+            state: State::HashWise,
+        })
+    }
+
+    pub fn sizewise(&self) -> Result<Self> {
+        if self.files.is_empty() {
+            return Ok(self.clone());
+        }
+
+        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {bar:40.cyan/blue} {pos:>7}/{len:7} {msg}")?;
+        let progress_bar = ProgressBar::new(self.files.len() as u64);
+        progress_bar.set_style(progress_style);
+        progress_bar.enable_steady_tick(Duration::from_millis(50));
+        progress_bar.set_message("indexing file sizes");
+
+        let duplicates_table: DashMap<u64, Vec<FileInfo>> = DashMap::new();
+        self.files
+            .clone()
+            .into_par_iter()
+            .progress_with(progress_bar)
+            .with_finish(ProgressFinish::WithMessage(Cow::from("indexed files sizes")))
+            .for_each(|file| {
+                duplicates_table
+                    .entry(file.size)
+                    .and_modify(|fileset| fileset.push(file.clone()))
+                    .or_insert_with(|| vec![file]);
+            });
+
+        let files = duplicates_table
+            .into_read_only()
+            .values()
+            .cloned()
+            .filter(|subfiles| subfiles.len() > 1)
+            .flatten()
+            .collect::<Vec<FileInfo>>();
+
+        Ok(Self {
+            files,
+            state: State::SizeWise,
+        })
+    }
+}

src/scanner.rs

@@ -1,127 +1,173 @@
-use crate::{file_manager::File, filters, params::Params};
+#![allow(unused)]
+use crate::{fileinfo::FileInfo, params::Params};
 use anyhow::Result;
-use dashmap::DashMap;
-use fxhash::hash64 as hasher;
-use glob::glob;
-use indicatif::{ParallelProgressIterator, ProgressStyle};
-use memmap2::Mmap;
-use rayon::prelude::*;
-use std::hash::Hasher;
-use std::{fs, path::PathBuf};
+use indicatif::{ProgressBar, ProgressStyle};
+use std::{fs, path::PathBuf, time::Duration};
 
-#[derive(Clone, Copy)]
-enum IndexCritera {
-    Size,
-    Hash,
+use globwalk::{GlobWalker, GlobWalkerBuilder};
+
+#[derive(Debug, Clone)]
+pub struct Scanner {
+    pub directory: Option<PathBuf>,
+    pub filetypes: Option<String>,
+    pub min_depth: Option<usize>,
+    pub max_depth: Option<usize>,
+    pub min_size: Option<u64>,
+    pub follow_links: bool,
 }
 
-pub fn duplicates(app_opts: &Params) -> Result<DashMap<String, Vec<File>>> {
-    let scan_results = scan(app_opts)?;
-    let size_index_store = index_files(scan_results, IndexCritera::Size)?;
-
-    let sizewize_duplicate_files = size_index_store
-        .into_par_iter()
-        .filter(|(_, files)| files.len() > 1)
-        .map(|(_, files)| files)
-        .flatten()
-        .collect::<Vec<File>>();
-
-    if sizewize_duplicate_files.len() > 1 {
-        let hash_index_store = index_files(sizewize_duplicate_files, IndexCritera::Hash)?;
-        let duplicate_files = hash_index_store
-            .into_par_iter()
-            .filter(|(_, files)| files.len() > 1)
-            .collect();
-
-        Ok(duplicate_files)
-    } else {
-        Ok(DashMap::new())
+impl Scanner {
+    pub fn new() -> Self {
+        Self {
+            directory: None,
+            filetypes: None,
+            min_depth: None,
+            max_depth: None,
+            min_size: None,
+            follow_links: true,
+        }
     }
-}
 
-fn scan(app_opts: &Params) -> Result<Vec<File>> {
-    let glob_patterns = app_opts.get_glob_patterns().display().to_string();
-    let glob_iter = glob(&glob_patterns)?;
-    let files = glob_iter
-        .filter(Result::is_ok)
-        .map(|file| file.unwrap())
-        .filter(|fpath| fpath.is_file())
-        .collect::<Vec<PathBuf>>()
-        .into_par_iter()
-        .progress_with_style(ProgressStyle::with_template(
-            "{spinner:.green} [processing scan results] [{wide_bar:.cyan/blue}] {pos}/{len} files",
-        )?)
-        .map(|fpath| fpath.display().to_string())
-        .map(|fpath| File {
-            path: fpath.clone(),
-            hash: None,
-            size: Some(fs::metadata(fpath).unwrap().len()),
+    pub fn build(app_args: &Params) -> Result<Self> {
+        let scan_directory = app_args.get_directory()?;
+        Ok(Scanner::new())
+            .map(|scanner| scanner.directory(scan_directory))
+            .map(|scanner| match app_args.get_min_size() {
+                Some(min_size) => scanner.min_size(min_size),
+                None => scanner,
+            })
+            .map(|scanner| match app_args.get_types() {
+                Some(ftypes) => scanner.filetypes(ftypes),
+                None => scanner,
+            })
+            .map(|scanner| match app_args.min_depth {
+                Some(min_depth) => scanner.min_depth(min_depth),
+                None => scanner,
+            })
+            .map(|scanner| match app_args.max_depth {
+                Some(max_depth) => scanner.max_depth(max_depth),
+                None => scanner,
+            })
+    }
+
+    pub fn min_size(&self, min_size: u64) -> Self {
+        Self {
+            min_size: Some(min_size),
+            ..self.clone()
+        }
+    }
+
+    pub fn min_depth(&self, min_depth: usize) -> Self {
+        Self {
+            min_depth: Some(min_depth),
+            ..self.clone()
+        }
+    }
+
+    pub fn max_depth(&self, max_depth: usize) -> Self {
+        Self {
+            max_depth: Some(max_depth),
+            ..self.clone()
+        }
+    }
+
+    pub fn directory(&self, dir: PathBuf) -> Self {
+        Self {
+            directory: Some(dir),
+            ..self.clone()
+        }
+    }
+
+    pub fn filetypes(&self, patterns: String) -> Self {
+        Self {
+            filetypes: Some(patterns),
+            ..self.clone()
+        }
+    }
+
+    pub fn ignore_links(&self) -> Self {
+        Self {
+            follow_links: false,
+            ..self.clone()
+        }
+    }
+
+    pub fn follow_links(&self) -> Self {
+        Self {
+            follow_links: true,
+            ..self.clone()
+        }
+    }
+
+    fn scan_patterns(&self) -> Result<String> {
+        Ok(match self.filetypes.clone() {
+            Some(ftypes) => format!("**/*{{{ftypes}}}"),
+            None => "**/*".to_string(),
         })
-        .filter(|file| filters::is_file_gt_minsize(app_opts, file))
-        .collect();
+    }
 
-    Ok(files)
-}
+    fn scan_dir(&self) -> Result<PathBuf> {
+        let scan_dir = match self.directory.clone() {
+            Some(path) => path,
+            None => std::env::current_dir()?,
+        };
 
-fn process_file_index(
-    mut file: File,
-    store: &DashMap<String, Vec<File>>,
-    index_criteria: IndexCritera,
-) {
-    match index_criteria {
-        IndexCritera::Size => {
-            store
-                .entry(file.size.unwrap_or_default().to_string())
-                .and_modify(|fileset| fileset.push(file.clone()))
-                .or_insert_with(|| vec![file]);
-        }
-        IndexCritera::Hash => {
-            file.hash = Some(hash_file(&file.path).unwrap_or_default());
-            store
-                .entry(file.clone().hash.unwrap())
-                .and_modify(|fileset| fileset.push(file.clone()))
-                .or_insert_with(|| vec![file]);
+        Ok(fs::canonicalize(scan_dir)?)
+    }
+
+    fn attach_link_opts(&self, walker: GlobWalkerBuilder) -> Result<GlobWalkerBuilder> {
+        Ok(walker.follow_links(self.follow_links))
+    }
+
+    fn attach_walker_min_depth(&self, walker: GlobWalkerBuilder) -> Result<GlobWalkerBuilder> {
+        match self.min_depth {
+            Some(min_depth) => Ok(walker.min_depth(min_depth)),
+            None => Ok(walker),
         }
     }
-}
 
-fn index_files(
-    files: Vec<File>,
-    index_criteria: IndexCritera,
-) -> Result<DashMap<String, Vec<File>>> {
-    let store: DashMap<String, Vec<File>> = DashMap::new();
-    files
-        .into_par_iter()
-        .progress_with_style(ProgressStyle::with_template(
-            "{spinner:.green} [indexing files] [{wide_bar:.cyan/blue}] {pos}/{len} files",
-        )?)
-        .for_each(|file| process_file_index(file, &store, index_criteria));
+    fn attach_walker_max_depth(&self, walker: GlobWalkerBuilder) -> Result<GlobWalkerBuilder> {
+        match self.max_depth {
+            Some(max_depth) => Ok(walker.max_depth(max_depth)),
+            None => Ok(walker),
+        }
+    }
+    fn build_walker(&self) -> Result<GlobWalker> {
+        let walker = Ok(GlobWalkerBuilder::from_patterns(
+            self.scan_dir()?,
+            &[self.scan_patterns()?],
+        ))
+        .and_then(|walker| self.attach_walker_min_depth(walker))
+        .and_then(|walker| self.attach_walker_max_depth(walker))
+        .and_then(|walker| self.attach_link_opts(walker))?;
 
-    Ok(store)
-}
+        Ok(walker.build()?)
+    }
 
-fn incremental_hashing(filepath: &str) -> Result<String> {
-    let file = fs::File::open(filepath)?;
-    let fmap = unsafe { Mmap::map(&file)? };
-    let mut inchasher = fxhash::FxHasher::default();
+    pub fn scan(&self) -> Result<Vec<FileInfo>> {
+        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {pos:>7} {msg}")?;
+        let progress_bar = ProgressBar::new_spinner();
+        progress_bar.set_style(progress_style);
+        progress_bar.enable_steady_tick(Duration::from_millis(50));
+        progress_bar.set_message("paths mapped");
+        let min_size = self.min_size.unwrap_or_default();
 
-    fmap.chunks(1_000_000)
-        .for_each(|mega| inchasher.write(mega));
+        let results = self
+            .build_walker()?
+            .filter_map(Result::ok)
+            .map(|entity| entity.into_path())
+            .map(|path| {
+                progress_bar.inc(1);
+                path
+            })
+            .filter(|path| path.is_file())
+            .map(FileInfo::new)
+            .filter_map(Result::ok)
+            .filter(|file| file.size > min_size)
+            .collect::<Vec<FileInfo>>();
 
-    Ok(format!("{}", inchasher.finish()))
-}
+        progress_bar.finish_with_message("paths mapped");
 
-fn standard_hashing(filepath: &str) -> Result<String> {
-    let file = fs::read(filepath)?;
-    Ok(hasher(&*file).to_string())
-}
-
-fn hash_file(filepath: &str) -> Result<String> {
-    let filemeta = fs::metadata(filepath)?;
-
-    // NOTE: USE INCREMENTAL HASHING ONLY FOR FILES > 100MB
-    match filemeta.len() < 100_000_000 {
-        true => standard_hashing(filepath),
-        false => incremental_hashing(filepath),
+        Ok(results)
     }
 }