typo fix

reduce memuse: fileinfo does not store full metadata

.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+rustflags = ["-C", "target-feature=+aes,+sse2"]

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,30 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[Bug] Title"
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+** Runtime Info **
+App Arguments: [e.g. `-i --nocache`] 
+Install Type: [e.g. `cargo install`]
+App Version: [e.g. v0.0.7]
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Platform Details (please complete the following information):**
+ - OS: [e.g. Arch Linux]
+ - Terminal Emulator: [e.g Alacritty]
+ - Shell [e.g. Zshell]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature-request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[Feature] Title"
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/release.yml

@@ -0,0 +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
+
+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:
+      - '*-?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
+      - 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
+
+          # 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:
+        # 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
+      - 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,4 @@
 /target
-/test_data
+/Cargo.lock
+/result-bin
+/.bacon-locations

CONTRIBUTING.md

@@ -0,0 +1,28 @@
+## How to contribute to Deduplicator
+
+#### **Did you find a bug?**
+
+* **Ensure the bug was not already reported** by searching on GitHub under [Issues](https://github.com/sreedevk/deduplicator/issues).
+
+* If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/sreedevk/deduplicator/issues/new). Be sure to include a **title and clear description**, as much relevant information as possible, and a **code sample** or an **executable test case** demonstrating the expected behavior that is not occurring.
+
+* If possible, use the [bug report template](https://github.com/sreedevk/deduplicator/blob/main/.github/ISSUE_TEMPLATE/bug_report.md) to create the issue.
+
+#### **Would you like to write a fix for the bug?**
+* Assign the Issue to yourself (if unassigned) before you start working in order to avoid any conficts. 
+* Open a new GitHub pull request with the patch.
+* Ensure the PR description clearly describes the problem and solution. Include the relevant issue number.
+* Make sure that the PR points to the development branch.
+
+#### **Did you fix whitespace, format code, or make a purely cosmetic patch?**
+
+Changes that are cosmetic in nature and do not add anything substantial to the stability, functionality, or testability of Deduplicator will generally not be accepted/
+
+#### **Do you intend to add a new feature or change an existing one?**
+
+* First open an issue with the sugggestion using the [feature request template](https://github.com/sreedevk/deduplicator/blob/main/.github/ISSUE_TEMPLATE/feature-request.md)
+* Do not create a PR before one of the core contributors has conveyed acceptance for a feature request.
+
+#### **Do you have questions about the source code?**
+
+* If you have a question, raise an issue in the repository with a "question" label.

Cargo.toml

@@ -1,24 +1,58 @@
 [package]
 name = "deduplicator"
-version = "0.0.3"
+version = "0.3.0"
 edition = "2021"
-description = "find,filter,delete Duplicates"
+description = "find,filter and delete duplicate files"
+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>",
+]
+
+[[bin]]
+name = "deduplicator"
+path = "src/main.rs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 anyhow = "1.0.68"
+bytesize = "1.1.0"
 chrono = "0.4.23"
 clap = { version = "4.0.32", features = ["derive"] }
-colored = "2.0.0"
-crossterm = "0.25.0"
-fxhash = "0.2.1"
-glob = "0.3.0"
-humansize = "2.1.2"
-itertools = "0.10.5"
+dashmap = { version = "5.4.0", features = ["rayon"] }
+globwalk = "0.8.1"
+gxhash = { version = "3.4.1", default-features = false }
+indicatif = { version = "0.17.2", features = ["rayon"] }
+memmap2 = "0.5.8"
+pathdiff = "0.2.1"
+prettytable-rs = "0.10.0"
+rand = "0.9.1"
 rayon = "1.6.1"
-sqlite = "0.30.3"
-thiserror = "1.0.38"
-tokio = { version = "1.23.0", features = ["full"] }
-tui = "0.19.0"
+threadpool = "1.8.1"
+
+[profile.release]
+strip = true
+opt-level = 3
+lto = "thin"
+debug = false
+codegen-units = 1
+
+# generated by 'cargo dist init'
+[profile.dist]
+inherits = "release"
+
+[workspace.metadata.dist]
+rust-toolchain-version = "1.87.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"
+
+[dev-dependencies]
+tempfile = "3.20.0"

README.md

@@ -4,42 +4,159 @@
   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]
+find,filter and delete duplicate files
+
+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
-  -n, --nocache        Don't use cache for indexing files (default = true)
-  -h, --help           Print help information
-  -V, --version        Print version information
+  -t, --types <TYPES>          Filetypes to deduplicate [default = all]
+  -i, --interactive            Delete files interactively
+  -m, --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
+  -d, --min-depth <MIN_DEPTH>  Min Depth to scan while looking for duplicates
+  -f, --follow-links           Follow links while scanning directories
+  -s, --strict                 Guarantees that two files are duplicate (performs a full hash)
+  -p, --progress               Show Progress spinners & metrics
+  -h, --help                   Print help
+  -V, --version                Print version
+```
+### 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>
+## Demo
+![record](https://github.com/user-attachments/assets/fcfdd9bf-4d05-41b6-a82e-367634eeaa73)
 
-<p align="center">Currently, deduplicator is only installable via rust's cargo package manager</p>
 
+
+## Installation
+Currently, you can only install deduplicator using cargo package manager.
+
+### Cargo
+> GxHash relies on aes hardware acceleration, so please set `RUSTFLAGS` to `"-C target-feature=+aes"` or `"-C target-cpu=native"` before
+> installing.
+
+#### install from crates.io
+```bash
+$ RUSTFLAGS="-C target-cpu=native" cargo install deduplicator
 ```
-cargo install deduplicator
+
+#### install from git
+```bash
+$ RUSTFLAGS="-C target-cpu=native" cargo install deduplicator --git https://github.com/sreedevk/deduplicator
 ```
-<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>
+## Performance
+Deduplicator uses size comparison and [GxHash](https://docs.rs/gxhash/latest/gxhash/) to quickly check a large number of files to find duplicates. its also heavily parallelized. The default behavior of deduplicator is to only hash the first page (4K) of the file. This is to ensure that performance is the default priority. You can modify this behavior by using the `--strict` flag which will hash the whole file and ensure that 2 files are indeed duplicates. I'll add benchmarks in future versions.
 
-<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 couple of seconds.</p>
+### Benchmarks
+I've used hyperfine to run deduplicator on files generated by the rake file at `rakelib/benchmark.rake`. The Benchmarking accuracy can further be improved by isolating runs inside restricted docker containers. I'll include that in the future. For now, here's the hyperfine output on my i7-12800H laptop with 32G of RAM.
 
-  <p align="center">
-    While testing, Deduplicator was able to go through 8.6GB of pdf files and detect duplicates in 2.9 seconds
-  </p>
-<h2 align="center">Screenshots</h2>
+#### Fewer Large Files
+```
+# hyperfine -N --warmup 80 './target/release/deduplicator bench_artifacts'
+Benchmark 1: ./target/release/deduplicator bench_artifacts
+  Time (mean ± σ):       2.5 ms ±   0.4 ms    [User: 2.2 ms, System: 4.8 ms]
+  Range (min … max):     1.9 ms …   6.8 ms    1322 runs
 
-![_039](https://user-images.githubusercontent.com/36154121/210031222-d8b79143-5a1e-47ca-926e-8855d5bbab60.png)
+# dust 'bench_artifacts'
+ 37M   ┌── file_1_fwds.bin   │██                                                                                                                              │   1%
+201M   ├── file_0_fwds.bin   │██████████                                                                                                                      │   8%
+390M   ├── file_0_fwdcbss.bin│████████████████████                                                                                                            │  15%
+390M   ├── file_0_fwscas.bin │████████████████████                                                                                                            │  15%
+390M   ├── file_0_fwss.bin   │████████████████████                                                                                                            │  15%
+390M   ├── file_1_fwdcbss.bin│████████████████████                                                                                                            │  15%
+390M   ├── file_1_fwscas.bin │████████████████████                                                                                                            │  15%
+390M   ├── file_1_fwss.bin   │████████████████████                                                                                                            │  15%
+2.5G ┌─┴ bench_artifacts     │███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ │ 100%
+```
+
+#### Many Small Files
+```
+# hyperfine --warmup 20 './target/release/deduplicator bench_artifacts'
+Benchmark 1: ./target/release/deduplicator bench_artifacts
+  Time (mean ± σ):      22.3 ms ±   1.7 ms    [User: 35.8 ms, System: 46.3 ms]
+  Range (min … max):    18.9 ms …  27.2 ms    112 runs
+
+# dust 'bench_artifacts'
+3.9M   ┌── file_992_fwss.bin   │█                                                                                                                                             │   0%
+3.9M   ├── file_993_fwdcbss.bin│█                                                                                                                                             │   0%
+3.9M   ├── file_993_fwscas.bin │█                                                                                                                                             │   0%
+3.9M   ├── file_993_fwss.bin   │█                                                                                                                                             │   0%
+3.9M   ├── file_994_fwdcbss.bin│█                                                                                                                                             │   0%
+3.9M   ├── file_994_fwscas.bin │█                                                                                                                                             │   0%
+3.9M   ├── file_994_fwss.bin   │█                                                                                                                                             │   0%
+3.9M   ├── file_995_fwdcbss.bin│█                                                                                                                                             │   0%
+3.9M   ├── file_995_fwscas.bin │█                                                                                                                                             │   0%
+3.9M   ├── file_995_fwss.bin   │█                                                                                                                                             │   0%
+3.9M   ├── file_996_fwdcbss.bin│█                                                                                                                                             │   0%
+3.9M   ├── file_996_fwscas.bin │█                                                                                                                                             │   0%
+3.9M   ├── file_996_fwss.bin   │█                                                                                                                                             │   0%
+3.9M   ├── file_997_fwdcbss.bin│█                                                                                                                                             │   0%
+3.9M   ├── file_997_fwscas.bin │█                                                                                                                                             │   0%
+3.9M   ├── file_997_fwss.bin   │█                                                                                                                                             │   0%
+3.9M   ├── file_998_fwdcbss.bin│█                                                                                                                                             │   0%
+3.9M   ├── file_998_fwscas.bin │█                                                                                                                                             │   0%
+3.9M   ├── file_998_fwss.bin   │█                                                                                                                                             │   0%
+3.9M   ├── file_999_fwdcbss.bin│█                                                                                                                                             │   0%
+3.9M   ├── file_999_fwscas.bin │█                                                                                                                                             │   0%
+3.9M   ├── file_999_fwss.bin   │█                                                                                                                                             │   0%
+3.9M   ├── file_99_fwdcbss.bin │█                                                                                                                                             │   0%
+3.9M   ├── file_99_fwscas.bin  │█                                                                                                                                             │   0%
+3.9M   ├── file_99_fwss.bin    │█                                                                                                                                             │   0%
+3.9M   ├── file_9_fwdcbss.bin  │█                                                                                                                                             │   0%
+3.9M   ├── file_9_fwscas.bin   │█                                                                                                                                             │   0%
+3.9M   ├── file_9_fwss.bin     │█                                                                                                                                             │   0%
+ 11G ┌─┴ bench_artifacts       │█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████ │ 100%
+```
+
+## proposed
+- [ ] parallelization
+    - [ ] (scanning + processing sw + processing hw) & formatting & printing
+    - [ ] scanning + processing sw + processing hw + formatting + printing
+- [ ] max file path size should use the last set of duplicates
+- [ ] add more unit tests
+    - [ ] test against different filesystems
+    - [ ] test against different file name encodings
+- [ ] restore json output (was removed in 0.3)
+- [ ] fix memory leak on very large filesystems
+    - [ ] maybe use a bloom filter
+    - [ ] reduce FileInfo size
+- [ ] output in a tree format
+- [ ] tui
+- [ ] change the default hashing method to include the first & last page of a file (8K)
+
+## v0.3
+- [x] parallelization
+    - [x] (scanning) + (processing sw & processing hw & formatting & printing)
+- [x] reduce cloning values on the heap
+- [x] add a partial hashing mode (--strict)
+- [x] add unit tests
+- [x] add silent mode
+- [x] update documentation
+- [x] remove color output
+- [x] progress bar improvements
+    - [x] use progress bar groups
+- [x] remove broken json rendering
+- [x] add benchmarks

Rakefile

@@ -0,0 +1 @@
+# tasks are contained in the `rakelib` directory

rakelib/benchmark.rake

@@ -0,0 +1,93 @@
+require 'tempfile'
+require 'fileutils'
+require 'securerandom'
+
+namespace :benchmark do
+  file 'target/release/deduplicator' do
+    sh "cargo build --release"
+  end
+
+  task :few_large_files => 'target/release/deduplicator' do
+    # Benchmark 1: ./target/release/deduplicator bench_artifacts
+    # Time (mean ± σ):       2.5 ms ±   0.6 ms    [User: 2.4 ms, System: 4.8 ms]
+    # Range (min … max):     1.8 ms …   9.7 ms    1474 runs
+
+    root = "bench_artifacts"
+    Dir.mkdir(root)
+
+    # files with same size
+    2.times.map do |i|
+      File.open(File.join(root, "file_#{i}_fwss.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * 100_000))
+      end
+    end
+
+    # files with different sizes
+    2.times.map do |i|
+      File.open(File.join(root, "file_#{i}_fwds.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * (rand * 100_000).ceil))
+      end
+    end
+
+    # files with same content & size
+    2.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwscas.bin"), 'wb') do |f|
+        f.write("\0" * (4096 * 100_000))
+      end
+    end
+
+    # files with different content but same size
+    2.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwdcbss.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * 100_000))
+      end
+    end
+
+    sh("hyperfine -N --warmup 80 './target/release/deduplicator #{root}'")
+    sh("dust '#{root}'")
+
+    FileUtils.rm_rf(root)
+  end
+
+  task :many_small_files => 'target/release/deduplicator' do
+    # Benchmark 1: ./target/release/deduplicator bench_artifacts
+    # Time (mean ± σ):      10.6 ms ±   1.0 ms    [User: 20.0 ms, System: 22.5 ms]
+    # Range (min … max):     8.4 ms …  14.2 ms    235 runs
+
+    root = "bench_artifacts"
+    Dir.mkdir(root)
+
+    # files with same size
+    1000.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwss.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * 1000))
+      end
+    end
+
+    # files with different sizes
+    1000.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwds.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * (rand * 100).ceil))
+      end
+    end
+
+    # files with same content & size
+    1000.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwscas.bin"), 'wb') do |f|
+        f.write("\0" * (4096 * 1000))
+      end
+    end
+
+    # files with different content but same size
+    1000.times.each do |i|
+      File.open(File.join(root, "file_#{i}_fwdcbss.bin"), 'wb') do |f|
+        f.write(SecureRandom.bytes(4096 * 1000))
+      end
+    end
+
+    sh("hyperfine --warmup 20 './target/release/deduplicator #{root}'")
+    sh("dust '#{root}'")
+
+    FileUtils.rm_rf(root)
+  end
+end

src/app/event_handler.rs

@@ -1,28 +0,0 @@
-use std::time::Duration;
-
-use crossterm::event::{self, KeyCode, KeyEvent};
-use anyhow::Result;
-use super::events;
-
-pub struct EventHandler;
-
-impl EventHandler {
-    pub fn init() -> Result<events::Event> {
-        if crossterm::event::poll(Duration::from_millis(10))? {
-            match event::read()? {
-                event::Event::Key(keycode) => Self::handle_keypress(keycode),
-                _ => Ok(events::Event::Noop),
-            }
-        } else {
-            Ok(events::Event::Noop)
-        }
-    }
-
-    fn handle_keypress(keyevent: KeyEvent) -> Result<events::Event> {
-        match keyevent.code {
-            KeyCode::Char('q') => Ok(events::Event::Exit),
-            _ => Ok(events::Event::Noop)
-        }
-    }
-}
-

src/app/events.rs

@@ -1,4 +0,0 @@
-pub enum Event {
-    Exit,
-    Noop
-}

src/app/mod.rs

@@ -1,80 +0,0 @@
-mod event_handler;
-mod events;
-mod ui;
-mod formatter;
-
-use crate::database;
-use crate::output;
-use crate::params::Params;
-use crate::scanner;
-use anyhow::{anyhow, Result};
-use crossterm::{event, execute, terminal};
-use event_handler::EventHandler;
-use std::io;
-use std::thread;
-use std::time::Duration;
-use tui::{
-    backend::CrosstermBackend,
-    widgets::{Block, Borders, Widget},
-    Terminal,
-};
-use ui::Ui;
-
-pub struct App;
-
-impl App {
-    pub fn init(app_args: &Params) -> Result<()> {
-        // let mut term = Self::init_terminal()?;
-
-        let connection = database::get_connection(&app_args)?;
-        let duplicates = scanner::duplicates(&app_args, &connection)?;
-
-        // Self::init_render_loop(&mut term)?;
-        // Self::cleanup(&mut term)?;
-
-        output::print(duplicates, &app_args); /* TODO: APP TUI INIT FUNCTION */
-        Ok(())
-    }
-
-    fn cleanup(term: &mut Terminal<CrosstermBackend<io::Stdout>>) -> Result<()> {
-        terminal::disable_raw_mode()?;
-        execute!(
-            term.backend_mut(),
-            terminal::LeaveAlternateScreen,
-            event::DisableMouseCapture
-        )?;
-
-        term.show_cursor()?;
-        Ok(())
-    }
-
-    fn render_cycle(term: &mut Terminal<CrosstermBackend<io::Stdout>>) -> Result<()> {
-        match EventHandler::init()? {
-            events::Event::Noop => Ui::render_frame(term),
-            events::Event::Exit => Err(anyhow!("Exit")),
-        }
-    }
-
-    fn init_render_loop(term: &mut Terminal<CrosstermBackend<io::Stdout>>) -> Result<()> {
-        loop {
-            match Self::render_cycle(term) {
-                Ok(_) => continue,
-                Err(_) => break,
-            }
-        }
-
-        Ok(())
-    }
-
-    fn init_terminal() -> Result<Terminal<CrosstermBackend<io::Stdout>>> {
-        terminal::enable_raw_mode()?;
-        let mut stdout = io::stdout();
-        execute!(
-            stdout,
-            terminal::EnterAlternateScreen,
-            event::EnableMouseCapture
-        )?;
-        let backend = CrosstermBackend::new(stdout);
-        Ok(Terminal::new(backend)?)
-    }
-}

src/app/ui.rs

@@ -1,53 +0,0 @@
-use anyhow::Result;
-use std::io;
-use tui::{
-    backend::{Backend, CrosstermBackend},
-    layout::{Constraint, Direction, Layout, Rect},
-    style::{Modifier, Style},
-    text::{Span, Spans},
-    widgets::{Block, Borders, List, ListItem, Widget},
-    Frame, Terminal,
-};
-
-pub struct Ui;
-
-impl Ui {
-    fn generate_file_list() -> impl Widget {
-        let tasks: Vec<ListItem> = vec!["Sreedev"; 100]
-            .into_iter()
-            .map(|item| ListItem::new(vec![Spans::from(Span::raw(item))]))
-            .collect();
-
-        List::new(tasks)
-            .block(Block::default().borders(Borders::ALL).title("List"))
-            .highlight_style(Style::default().add_modifier(Modifier::BOLD))
-            .highlight_symbol("> ")
-    }
-
-    fn generate_info_bar() -> impl Widget {
-        Block::default().title("Description").borders(Borders::ALL)
-    }
-
-    fn generate_file_desc() -> impl Widget {
-        Block::default().title("Description").borders(Borders::ALL)
-    }
-
-    pub fn render_frame(term: &mut Terminal<CrosstermBackend<io::Stdout>>) -> Result<()> {
-        term.draw(|f| {
-            let windows = Layout::default()
-                .direction(Direction::Vertical)
-                .constraints([Constraint::Ratio(2, 16), Constraint::Ratio(14, 16)].as_ref())
-                .split(f.size());
-
-            let subwindows = Layout::default()
-                .direction(Direction::Horizontal)
-                .constraints([Constraint::Ratio(1, 4), Constraint::Ratio(3, 4)].as_ref())
-                .split(windows[1]);
-
-            f.render_widget(Self::generate_info_bar(), windows[0]);
-            f.render_widget(Self::generate_file_list(), subwindows[0]);
-            f.render_widget(Self::generate_file_desc(), subwindows[1]);
-        })?;
-        Ok(())
-    }
-}

src/database.rs

@@ -1,83 +0,0 @@
-use anyhow::Result;
-use crate::params::Params;
-
-#[derive(Debug, Clone)]
-pub struct File {
-    pub path: String,
-    pub hash: String,
-}
-
-pub fn get_connection(args: &Params) -> Result<sqlite::Connection, sqlite::Error> {
-    let connection_url = match args.nocache {
-        false => "/tmp/deduplicator.db",
-        true => ":memory:"
-    };
-
-    sqlite::open(connection_url).and_then(|conn| {
-        setup(&conn).ok();
-        Ok(conn)
-    })
-}
-
-pub fn setup(connection: &sqlite::Connection) -> Result<()> {
-    let query = "CREATE TABLE files (file_identifier STRING, hash STRING)";
-    connection.execute(query).ok();
-    Ok(())
-}
-
-pub fn put(file: &File, connection: &sqlite::Connection) -> Result<()> {
-    let query = format!(
-        "INSERT INTO files (file_identifier, hash) VALUES (\"{}\", \"{}\")",
-        file.path, file.hash
-    );
-    let result = connection.execute(query)?;
-
-    Ok(result)
-}
-
-pub fn indexed_paths(connection: &sqlite::Connection) -> Result<Vec<File>> {
-    let query = format!(
-        "SELECT * FROM files"
-        );
-
-    let result: Vec<File> = connection
-        .prepare(query)?
-        .into_iter()
-        .map(|row_result| row_result.unwrap())
-        .map(|row| {
-            let path = row.read::<&str, _>("file_identifier").to_string();
-            let hash = row.read::<i64, _>("hash").to_string();
-            File { path, hash }
-        })
-    .collect();
-
-    Ok(result)
-}
-
-pub fn duplicate_hashes(connection: &sqlite::Connection, path: &String) -> Result<Vec<File>> {
-    let query = format!(
-        " 
-            SELECT a.* FROM files a
-            JOIN (SELECT file_identifier, hash, COUNT(*)
-            FROM files 
-            GROUP BY hash
-            HAVING count(*) > 1 ) b
-            ON a.hash = b.hash
-            WHERE a.file_identifier LIKE \"{}%\"
-            ORDER BY a.file_identifier
-        ", path
-    );
-
-    let result: Vec<File> = connection
-        .prepare(query)?
-        .into_iter()
-        .map(|row_result| row_result.unwrap())
-        .map(|row| {
-            let path = row.read::<&str, _>("file_identifier").to_string();
-            let hash = row.read::<i64, _>("hash").to_string();
-            File { path, hash }
-        })
-        .collect();
-
-    Ok(result)
-}

src/fileinfo.rs

@@ -0,0 +1,45 @@
+use anyhow::Result;
+use gxhash::gxhash128;
+use memmap2::Mmap;
+use std::{
+    fs,
+    io::Read,
+    path::{Path, PathBuf},
+    time::SystemTime,
+};
+
+#[derive(Debug, Clone)]
+pub struct FileInfo {
+    pub path: Box<Path>,
+    pub size: u64,
+    pub modified: SystemTime,
+}
+
+impl FileInfo {
+    pub fn hash(&self, seed: i64) -> Result<u128> {
+        let file = fs::File::open(&self.path)?;
+        let mapper = unsafe { Mmap::map(&file)? };
+        let final_hash = mapper.chunks(4096).fold(0u128, |acc, chunk: &[u8]| {
+            acc.wrapping_add(gxhash128(chunk, seed))
+        });
+
+        Ok(final_hash)
+    }
+
+    pub fn initial_page_hash(&self, seed: i64) -> Result<u128> {
+        let mut file = fs::File::open(&self.path)?;
+        let mut buffer = [0; 4096];
+        let bytes_read = file.read(&mut buffer)?;
+
+        Ok(gxhash128(&buffer[..bytes_read], seed))
+    }
+
+    pub fn new(path: PathBuf) -> Result<Self> {
+        let filemeta = std::fs::metadata(&path)?;
+        Ok(Self {
+            path: path.into_boxed_path(),
+            size: filemeta.len(),
+            modified: filemeta.modified()?,
+        })
+    }
+}

src/formatter.rs

@@ -0,0 +1,101 @@
+use crate::{fileinfo::FileInfo, params::Params};
+use anyhow::Result;
+use chrono::{DateTime, Utc};
+use dashmap::DashMap;
+use indicatif::{ParallelProgressIterator, ProgressBar, ProgressFinish, ProgressStyle};
+use pathdiff::diff_paths;
+use prettytable::{format, row, Row, Table};
+use rayon::prelude::*;
+use std::{borrow::Cow, path::PathBuf, sync::Arc, time::Duration};
+
+pub struct Formatter;
+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, 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.modified.into();
+        Ok(modified_time.format("%Y-%m-%d %H:%M:%S").to_string())
+    }
+
+    pub fn gen_sub_tbl(items: Vec<FileInfo>, app_args: &Params, max_path_len: u64) -> Table {
+        let mut inner_table = Table::new();
+        inner_table.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
+        items.iter().for_each(|file| {
+            inner_table.add_row(row![
+                Self::human_path(file, app_args, max_path_len as usize).unwrap_or_default(),
+                Self::human_filesize(file).unwrap_or_default(),
+                Self::human_mtime(file).unwrap_or_default()
+            ]);
+        });
+        inner_table
+    }
+
+    pub fn generate_table(
+        raw: Arc<DashMap<u128, Vec<FileInfo>>>,
+        mpath_len: u64,
+        args: &Params,
+    ) -> Result<Table> {
+        let progress_bar = match args.progress {
+            true => ProgressBar::new_spinner(),
+            false => ProgressBar::hidden(),
+        };
+
+        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {pos:>7} {msg}")?;
+        progress_bar.set_style(progress_style);
+        progress_bar.enable_steady_tick(Duration::from_millis(50));
+        progress_bar.set_message("generating output");
+
+        let rows = raw
+            .par_iter_mut()
+            .progress_with(progress_bar)
+            .with_finish(ProgressFinish::WithMessage(Cow::from("output generated")))
+            .filter(|i| i.value().len() > 1)
+            .map(|i| {
+                row![
+                    i.key(),
+                    Self::gen_sub_tbl(i.value().to_vec(), args, mpath_len)
+                ]
+            })
+            .collect::<Vec<Row>>();
+
+        let mut output_table = Table::new();
+        output_table.set_titles(row!["hash", "duplicates"]);
+        output_table.extend(rows);
+        Ok(output_table)
+    }
+
+    pub fn print(
+        raw: Arc<DashMap<u128, Vec<FileInfo>>>,
+        max_path_len: u64,
+        app_args: &Params,
+    ) -> Result<()> {
+        if raw.is_empty() {
+            println!("\n\nNo duplicates found matching your search criteria.\n");
+            return Ok(());
+        }
+
+        let output_table = Self::generate_table(raw, max_path_len, app_args)?;
+        output_table.printstd();
+
+        Ok(())
+    }
+}

src/interactive.rs

@@ -0,0 +1,125 @@
+use crate::{fileinfo::FileInfo, formatter::Formatter, params::Params};
+use anyhow::Result;
+use dashmap::DashMap;
+use prettytable::{format, row, Table};
+use std::{
+    io::{self, Write},
+    sync::Arc,
+};
+
+pub struct Interactive;
+
+impl Interactive {
+    pub fn init(result: Arc<DashMap<u128, Vec<FileInfo>>>, app_args: &Params) -> Result<()> {
+        result
+            .clone()
+            .iter()
+            .filter(|i| i.value().len() > 1)
+            .enumerate()
+            .for_each(|(gindex, i)| {
+                let group = i.value();
+                let mut itable = Table::new();
+                itable.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
+                itable.set_titles(row!["index", "filename", "size", "updated_at"]);
+
+                let max_path_size = group
+                    .iter()
+                    .map(|f| f.path.iter().count())
+                    .max()
+                    .unwrap_or_default();
+
+                group.iter().enumerate().for_each(|(index, file)| {
+                    itable.add_row(row![
+                        index,
+                        Formatter::human_path(file, app_args, max_path_size).unwrap_or_default(),
+                        Formatter::human_filesize(file).unwrap_or_default(),
+                        Formatter::human_mtime(file).unwrap_or_default()
+                    ]);
+                });
+
+                Self::process_group_action(group, gindex, result.len(), itable);
+            });
+
+        Ok(())
+    }
+
+    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 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 = Self::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!");
+            return Self::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!("\nThe following files will be deleted:");
+        files_to_delete
+            .clone()
+            .enumerate()
+            .for_each(|(index, file)| {
+                println!("{}: {}", index, file.path.display());
+            });
+
+        match Self::scan_group_confirmation().unwrap() {
+            true => {
+                files_to_delete.into_iter().for_each(|file| {
+                    match std::fs::remove_file(file.path.clone()) {
+                        Ok(_) => println!("DELETED: {}", file.path.display()),
+                        Err(_) => println!("FAILED: {}", file.path.display()),
+                    }
+                });
+            }
+            false => println!("\nCancelled Delete Operation."),
+        }
+    }
+}

src/main.rs

@@ -1,14 +1,35 @@
+mod fileinfo;
+mod formatter;
+mod interactive;
 mod params;
-mod database;
-mod output;
+mod processor;
 mod scanner;
-mod app;
+mod server;
 
+use self::{formatter::Formatter, interactive::Interactive, server::Server};
 use anyhow::Result;
 use clap::Parser;
-use app::App;
+use params::Params;
+use std::sync::atomic::Ordering;
 
-#[tokio::main]
-async fn main() -> Result<()> {
-    App::init(&params::Params::parse())
+fn main() -> Result<()> {
+    let app_args = Params::parse();
+    let server = Server::new(app_args.clone());
+
+    server.start()?;
+
+    match app_args.interactive {
+        false => {
+            Formatter::print(
+                server.hw_duplicate_set,
+                server.max_file_path_len.load(Ordering::Acquire),
+                &app_args,
+            )?;
+        }
+        true => {
+            Interactive::init(server.hw_duplicate_set, &app_args)?;
+        }
+    };
+
+    Ok(())
 }

src/output.rs

@@ -1,68 +0,0 @@
-use crate::database::File;
-use chrono::offset::Utc;
-use chrono::DateTime;
-use colored::Colorize;
-use humansize::{format_size, DECIMAL};
-use std::{collections::HashMap, fs};
-use crate::params::Params;
-
-fn format_path(path: &String, opts: &Params) -> String {
-    let display_path = path.replace(&opts.get_directory().unwrap(), "");
-    let text_vec = display_path.chars().collect::<Vec<_>>();
-
-    let display_range = if text_vec.len() > 32 {
-            text_vec[(display_path.len() - 32)..].into_iter().collect::<String>()
-    } else {
-        display_path
-    };
-    
-    format!("...{}", display_range)
-}
-
-fn file_size(path: &String) -> String {
-    let mdata = fs::metadata(path).unwrap();
-    let formatted_size = format_size(mdata.len(), DECIMAL);
-    format!("{}", formatted_size)
-}
-
-fn modified_time(path: &String) -> String {
-    let mdata = fs::metadata(path).unwrap();
-    let modified_time: DateTime<Utc> = mdata.modified().unwrap().into();
-
-    modified_time.format("%Y-%m-%d %H:%M:%S").to_string()
-}
-
-fn print_divider() {
-    println!("-------------------+-------------------------------------+------------------+----------------------------------+");
-}
-
-pub fn print(duplicates: Vec<File>, opts: &Params) {
-    print_divider();
-    println!(
-        "| {0: <16} | {1: <35} | {2: <16} | {3: <32} |",
-        "hash", "filename", "size", "updated_at"
-    );
-    print_divider();
-
-    let mut dup_index: HashMap<String, Vec<File>> = HashMap::new();
-
-    duplicates.into_iter().for_each(|file| {
-        dup_index
-            .entry(file.hash.clone())
-            .and_modify(|value| value.push(file.clone()))
-            .or_insert(vec![file]);
-    });
-
-    dup_index.into_iter().for_each(|(_, group)| {
-        group.into_iter().for_each(|file| {
-            println!(
-                "| {0: <16} | {1: <35} | {2: <16} | {3: <32} |",
-                file.hash.red(),
-                format_path(&file.path, opts).yellow(),
-                file_size(&file.path).blue(),
-                modified_time(&file.path).blue()
-            );
-        });
-        print_divider();
-    });
-}

src/params.rs

@@ -1,40 +1,59 @@
-use std::path::PathBuf;
-use clap::Parser;
-use anyhow::Result;
-use std::fs;
+use std::{fs, path::PathBuf};
 
-#[derive(Parser, Debug)]
+use anyhow::Result;
+use clap::{Parser, ValueHint};
+
+#[derive(Parser, Debug, Default, 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)]
+    /// Run Deduplicator on dir different from pwd (e.g., ~/Pictures )
+    #[arg(value_hint = ValueHint::DirPath, value_name = "scan_dir_path")]
     pub dir: Option<PathBuf>,
-    /// Don't use cache for indexing files (default = true)
+    /// Delete files interactively
     #[arg(long, short)]
-    pub nocache: bool,
+    pub interactive: bool,
+    /// Minimum filesize of duplicates to scan (e.g., 100B/1K/2M/3G/4T).
+    #[arg(long, short = 'm', 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, short = 'd')]
+    pub min_depth: Option<usize>,
+    /// Follow links while scanning directories
+    #[arg(long, short)]
+    pub follow_links: bool,
+    /// Guarantees that two files are duplicate (performs a full hash)
+    #[arg(long, short = 's', default_value = "false")]
+    pub strict: bool,
+    /// Show Progress spinners & metrics
+    #[arg(long, short = 'p', default_value = "false")]
+    pub progress: bool,
 }
 
 impl Params {
-    pub fn get_directory(&self) -> Result<String> {
-        let dir_string: String = self
-            .dir
-            .clone()
-            .unwrap_or(std::env::current_dir()?)
-            .as_os_str()
-            .to_str()
-            .unwrap()
-            .to_string();
-
-        let dir_pathbuf = PathBuf::from(&dir_string);
-        let dir = fs::canonicalize(&dir_pathbuf)?
-            .as_os_str()
-            .to_str()
-            .unwrap()
-            .to_string();
+    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,
+            },
+            None => None,
+        }
+    }
 
+    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_types(&self) -> Option<String> {
+        self.types.clone()
+    }
 }

src/processor.rs

@@ -0,0 +1,369 @@
+use anyhow::Result;
+use dashmap::DashMap;
+use indicatif::{
+    MultiProgress, ParallelProgressIterator, ProgressBar, ProgressFinish, ProgressStyle,
+};
+use rayon::prelude::{IntoParallelIterator, ParallelIterator};
+use std::borrow::Cow;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use std::sync::{Arc, Mutex, TryLockError, TryLockResult};
+use std::time::Duration;
+
+use crate::fileinfo::FileInfo;
+use crate::params::Params;
+
+pub struct Processor {}
+
+impl Processor {
+    pub fn hashwise(
+        app_args: Arc<Params>,
+        sw_store: Arc<DashMap<u64, Vec<FileInfo>>>,
+        hw_store: Arc<DashMap<u128, Vec<FileInfo>>>,
+        progress_bar_box: Arc<MultiProgress>,
+        max_file_size: Arc<AtomicU64>,
+        seed: i64,
+    ) -> Result<()> {
+        let progress_bar = match app_args.progress {
+            true => progress_bar_box.add(ProgressBar::new_spinner()),
+            false => ProgressBar::hidden(),
+        };
+
+        let keys: Vec<u64> = sw_store.clone().iter().map(|i| *i.key()).collect();
+
+        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {pos:>7} {msg}")?;
+        progress_bar.set_style(progress_style);
+        progress_bar.enable_steady_tick(Duration::from_millis(50));
+        progress_bar.set_message("files grouped by hash.");
+
+        keys.into_par_iter()
+            .progress_with(progress_bar)
+            .with_finish(ProgressFinish::WithMessage(Cow::from(
+                "files grouped by hash.",
+            )))
+            .for_each(|key| {
+                let group: Vec<FileInfo> = sw_store.get(&key).unwrap().to_vec();
+                if group.len() > 1 {
+                    group.into_par_iter().for_each(|file| {
+                        let fhash = if app_args.strict {
+                            file.hash(seed).expect("hashing file failed.")
+                        } else {
+                            file.initial_page_hash(seed).expect("hashing file failed.")
+                        };
+
+                        Self::compare_and_update_max_path_len(
+                            max_file_size.clone(),
+                            file.path.to_string_lossy().len() as u64,
+                        )
+                        .unwrap();
+
+                        hw_store
+                            .entry(fhash)
+                            .and_modify(|fileset| fileset.push(file.clone()))
+                            .or_insert_with(|| vec![file]);
+                    });
+                }
+            });
+
+        Ok(())
+    }
+
+    pub fn compare_and_update_max_path_len(current: Arc<AtomicU64>, next: u64) -> Result<()> {
+        if current.load(Ordering::Relaxed) < next {
+            current.store(next, Ordering::Release);
+        }
+
+        Ok(())
+    }
+
+    pub fn sizewise(
+        app_args: Arc<Params>,
+        scanner_finished: Arc<AtomicBool>,
+        store: Arc<DashMap<u64, Vec<FileInfo>>>,
+        files: Arc<Mutex<Vec<FileInfo>>>,
+        progress_bar_box: Arc<MultiProgress>,
+    ) -> Result<()> {
+        let progress_bar = match app_args.progress {
+            true => progress_bar_box.add(ProgressBar::new_spinner()),
+            false => ProgressBar::hidden(),
+        };
+
+        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {pos:>7} {msg}")?;
+        progress_bar.set_style(progress_style);
+        progress_bar.enable_steady_tick(Duration::from_millis(50));
+        progress_bar.set_message("files grouped by size");
+
+        loop {
+            let fileopt: Option<FileInfo> = {
+                match files.try_lock() {
+                    Ok(mut flist) => flist.pop(),
+                    TryLockResult::Err(TryLockError::WouldBlock) => None,
+                    _ => None,
+                }
+            };
+
+            match fileopt {
+                Some(file) => {
+                    progress_bar.inc(1);
+                    store
+                        .entry(file.size)
+                        .and_modify(|fileset| fileset.push(file.clone()))
+                        .or_insert_with(|| vec![file]);
+                    continue;
+                }
+                None => match scanner_finished.load(std::sync::atomic::Ordering::Relaxed) {
+                    true => {
+                        progress_bar.finish_with_message("files grouped by size");
+                        break Ok(());
+                    }
+                    false => continue,
+                },
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::Result;
+    use dashmap::DashMap;
+    use indicatif::MultiProgress;
+    use rand::Rng;
+    use std::fs::File;
+    use std::io::Write;
+    use std::sync::atomic::{AtomicBool, AtomicU64};
+    use std::sync::{Arc, Mutex};
+    use tempfile::TempDir;
+
+    use crate::{fileinfo::FileInfo, params::Params};
+
+    use super::Processor;
+
+    fn generate_bytes(size: usize) -> Vec<u8> {
+        let mut rng = rand::rng();
+        (0..size).map(|_| rng.random::<u8>()).collect::<Vec<u8>>()
+    }
+
+    #[test]
+    fn hashwise_sorting_two_files_with_identical_init_page_only_strict_mode() -> Result<()> {
+        let root = TempDir::new()?;
+        let content = generate_bytes(4096);
+
+        let mut content_x = content.clone();
+        let mut content_y = content.clone();
+
+        content_x.extend(generate_bytes(1720320));
+        content_y.extend(generate_bytes(1720320));
+
+        let files = [
+            (root.path().join("fileone.bin"), content_x),
+            (root.path().join("filetwo.bin"), content_y),
+        ];
+
+        for (fpath, content) in files.iter() {
+            let mut f = File::create_new(fpath)?;
+            f.write_all(content)?;
+        }
+
+        let dupstore = Arc::new(DashMap::new());
+        let file_queue = Arc::new(Mutex::new(
+            files
+                .iter()
+                .map(|f| FileInfo::new(f.0.clone()).unwrap())
+                .collect::<Vec<FileInfo>>(),
+        ));
+
+        let hw_dupstore = Arc::new(DashMap::new());
+        Processor::sizewise(
+            Arc::new(Params::default()),
+            Arc::new(AtomicBool::new(true)),
+            dupstore.clone(),
+            file_queue,
+            Arc::new(MultiProgress::new()),
+        )?;
+
+        let args = Params {
+            strict: true,
+            ..Default::default()
+        };
+
+        Processor::hashwise(
+            Arc::new(args),
+            dupstore.clone(),
+            hw_dupstore.clone(),
+            Arc::new(MultiProgress::new()),
+            Arc::new(AtomicU64::new(32)),
+            300,
+        )?;
+
+        assert_eq!(hw_dupstore.len(), 2);
+
+        Ok(())
+    }
+
+    #[test]
+    fn hashwise_sorting_two_files_with_identical_init_page_only_fast_mode() -> Result<()> {
+        let root = TempDir::new()?;
+        let content = generate_bytes(4096);
+
+        let mut content_x = content.clone();
+        let mut content_y = content.clone();
+
+        content_x.extend(generate_bytes(1720320));
+        content_y.extend(generate_bytes(1720320));
+
+        let files = [
+            (root.path().join("fileone.bin"), content_x),
+            (root.path().join("filetwo.bin"), content_y),
+        ];
+
+        for (fpath, content) in files.iter() {
+            let mut f = File::create_new(fpath)?;
+            f.write_all(content)?;
+        }
+
+        let dupstore = Arc::new(DashMap::new());
+        let file_queue = Arc::new(Mutex::new(
+            files
+                .iter()
+                .map(|f| FileInfo::new(f.0.clone()).unwrap())
+                .collect::<Vec<FileInfo>>(),
+        ));
+
+        let hw_dupstore = Arc::new(DashMap::new());
+        Processor::sizewise(
+            Arc::new(Params::default()),
+            Arc::new(AtomicBool::new(true)),
+            dupstore.clone(),
+            file_queue,
+            Arc::new(MultiProgress::new()),
+        )?;
+
+        Processor::hashwise(
+            Arc::new(Params::default()),
+            dupstore.clone(),
+            hw_dupstore.clone(),
+            Arc::new(MultiProgress::new()),
+            Arc::new(AtomicU64::new(32)),
+            300,
+        )?;
+
+        assert_eq!(hw_dupstore.len(), 1);
+
+        Ok(())
+    }
+
+    #[test]
+    fn hashwise_sorting_two_files_with_identical_data() -> Result<()> {
+        let root = TempDir::new()?;
+        let content = generate_bytes(282624);
+        let files = [
+            (root.path().join("fileone.bin"), content.clone()),
+            (root.path().join("filetwo.bin"), content.clone()),
+        ];
+
+        for (fpath, content) in files.iter() {
+            let mut f = File::create_new(fpath)?;
+            f.write_all(content)?;
+        }
+
+        let dupstore = Arc::new(DashMap::new());
+        let file_queue = Arc::new(Mutex::new(
+            files
+                .iter()
+                .map(|f| FileInfo::new(f.0.clone()).unwrap())
+                .collect::<Vec<FileInfo>>(),
+        ));
+
+        let hw_dupstore = Arc::new(DashMap::new());
+        Processor::sizewise(
+            Arc::new(Params::default()),
+            Arc::new(AtomicBool::new(true)),
+            dupstore.clone(),
+            file_queue,
+            Arc::new(MultiProgress::new()),
+        )?;
+
+        Processor::hashwise(
+            Arc::new(Params::default()),
+            dupstore.clone(),
+            hw_dupstore.clone(),
+            Arc::new(MultiProgress::new()),
+            Arc::new(AtomicU64::new(32)),
+            300,
+        )?;
+
+        assert_eq!(hw_dupstore.len(), 1);
+
+        Ok(())
+    }
+
+    #[test]
+    fn sizewise_sorting_two_files_of_different_sizes() -> Result<()> {
+        let root = TempDir::new()?;
+        let files = [
+            (root.path().join("fileone.bin"), generate_bytes(282624)),
+            (root.path().join("filetwo.bin"), generate_bytes(1720320)),
+        ];
+
+        for (fpath, content) in files.iter() {
+            let mut f = File::create_new(fpath)?;
+            f.write_all(content)?;
+        }
+
+        let file_queue = Arc::new(Mutex::new(
+            files
+                .iter()
+                .map(|f| FileInfo::new(f.0.clone()).unwrap())
+                .collect::<Vec<FileInfo>>(),
+        ));
+
+        let dupstore = Arc::new(DashMap::new());
+
+        Processor::sizewise(
+            Arc::new(Params::default()),
+            Arc::new(AtomicBool::new(true)),
+            dupstore.clone(),
+            file_queue,
+            Arc::new(MultiProgress::new()),
+        )?;
+
+        assert_eq!(dupstore.len(), 2);
+
+        Ok(())
+    }
+
+    #[test]
+    fn sizewise_sorting_two_files_of_same_size() -> Result<()> {
+        let root = TempDir::new()?;
+        let files = [
+            (root.path().join("fileone.bin"), generate_bytes(282624)),
+            (root.path().join("filetwo.bin"), generate_bytes(282624)),
+        ];
+
+        for (fpath, content) in files.iter() {
+            let mut f = File::create_new(fpath)?;
+            f.write_all(content)?;
+        }
+
+        let file_queue = Arc::new(Mutex::new(
+            files
+                .iter()
+                .map(|f| FileInfo::new(f.0.clone()).unwrap())
+                .collect::<Vec<FileInfo>>(),
+        ));
+
+        let dupstore = Arc::new(DashMap::new());
+
+        Processor::sizewise(
+            Arc::new(Params::default()),
+            Arc::new(AtomicBool::new(true)),
+            dupstore.clone(),
+            file_queue,
+            Arc::new(MultiProgress::new()),
+        )?;
+
+        assert_eq!(dupstore.len(), 1);
+
+        Ok(())
+    }
+}

src/scanner.rs

@@ -1,79 +1,100 @@
-use crate::database;
-use crate::{params::Params, database::File};
+use crate::{fileinfo::FileInfo, params::Params};
 use anyhow::Result;
-use glob::glob;
-use itertools::Itertools;
-use rayon::prelude::*;
-use std::fs;
-use std::path::PathBuf;
-use fxhash::hash32 as hasher;
+use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use std::sync::{Arc, Mutex};
+use std::{path::Path, time::Duration};
 
-pub fn duplicates(app_opts: &Params, connection: &sqlite::Connection) -> Result<Vec<File>> {
-    let scan_results = scan(app_opts, connection)?;
-    let base_path = app_opts.get_directory()?;
+use globwalk::{GlobWalker, GlobWalkerBuilder};
 
-    index_files(scan_results, connection);
-    database::duplicate_hashes(connection, &base_path)
+pub struct Scanner {
+    pub directory: Box<Path>,
+    pub filetypes: Option<String>,
+    pub min_depth: Option<usize>,
+    pub max_depth: Option<usize>,
+    pub min_size: Option<u64>,
+    pub follow_links: bool,
+    pub progress: bool,
 }
 
-fn get_glob_patterns(opts: &Params, directory: &String) -> Vec<PathBuf> {
-    opts.types
-        .clone()
-        .unwrap_or(String::from("*"))
-        .split(",")
-        .map(|filetype| format!("*.{}", filetype))
-        .map(|filetype| {
-            vec![directory.clone(), String::from("**"), filetype]
-                .iter()
-                .collect()
+impl Scanner {
+    pub fn new(app_args: Arc<Params>) -> Result<Self> {
+        Ok(Self {
+            directory: app_args.get_directory()?.into_boxed_path(),
+            filetypes: app_args.get_types(),
+            min_depth: app_args.min_depth,
+            max_depth: app_args.max_depth,
+            min_size: app_args.get_min_size(),
+            follow_links: app_args.follow_links,
+            progress: app_args.progress,
         })
-        .collect()
-}
+    }
 
-fn is_indexed_file(path: &String, indexed: &Vec<File>) -> bool {
-    indexed
-        .into_iter()
-        .map(|file| file.path.clone())
-        .contains(path)
-}
-
-fn scan(app_opts: &Params, connection: &sqlite::Connection) -> Result<Vec<String>> {
-    let directory = app_opts.get_directory()?;
-    let glob_patterns: Vec<PathBuf> = get_glob_patterns(&app_opts, &directory);
-    let indexed_paths = database::indexed_paths(connection)?;
-    let files: Vec<String> = glob_patterns
-        .into_par_iter()
-        .map(|glob_pattern| glob(&glob_pattern.as_os_str().to_str().unwrap()))
-        .map(|glob_result| glob_result.unwrap())
-        .flat_map(|file_vec| {
-            file_vec
-                .map(|x| x.unwrap().as_os_str().to_str().unwrap().to_string())
-                .filter(|fpath| !is_indexed_file(fpath, &indexed_paths))
-                .filter(|glob_result| fs::metadata(glob_result).unwrap().is_file())
-                .collect::<Vec<String>>()
+    fn scan_patterns(&self) -> Result<String> {
+        Ok(match &self.filetypes {
+            Some(ftypes) => format!("**/*{{{ftypes}}}"),
+            None => "**/*".to_string(),
         })
-        .collect();
+    }
 
-    Ok(files)
-}
+    fn attach_link_opts(&self, walker: GlobWalkerBuilder) -> Result<GlobWalkerBuilder> {
+        Ok(walker.follow_links(self.follow_links))
+    }
 
-fn index_files(files: Vec<String>, connection: &sqlite::Connection) {
-    let hashed: Vec<File> = files
-        .into_par_iter()
-        .map(|file| {
-            let hash = hash_file(&file).unwrap();
-            database::File { path: file, hash }
-        })
-        .collect();
+    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),
+        }
+    }
 
-    hashed.into_iter().for_each(|file| {
-        database::put(&file, connection).unwrap();
-    });
-}
+    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.directory.clone(),
+            &[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))?;
 
-pub fn hash_file(filepath: &str) -> Result<String> {
-    let file = fs::read(filepath)?;
-    let hash = hasher(&*file).to_string();
+        Ok(walker.build()?)
+    }
 
-    Ok(hash)
+    pub fn scan(
+        &self,
+        files: Arc<Mutex<Vec<FileInfo>>>,
+        progress_bar_box: Arc<MultiProgress>,
+    ) -> Result<()> {
+        let progress_bar = match self.progress {
+            true => progress_bar_box.add(ProgressBar::new_spinner()),
+            false => ProgressBar::hidden(),
+        };
+
+        let progress_style = ProgressStyle::with_template("[{elapsed_precise}] {pos:>7} {msg}")?;
+        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();
+
+        self.build_walker()?
+            .filter_map(Result::ok)
+            .map(|entity| entity.into_path())
+            .inspect(|_path| progress_bar.inc(1))
+            .filter(|path| path.is_file())
+            .map(FileInfo::new)
+            .filter_map(Result::ok)
+            .filter(|file| file.size > min_size)
+            .for_each(|file| {
+                let mut flock = files.lock().unwrap();
+                flock.push(file);
+            });
+
+        progress_bar.finish_with_message("paths mapped");
+        Ok(())
+    }
 }

src/server.rs

@@ -0,0 +1,99 @@
+use std::sync::atomic::{AtomicBool, AtomicU64};
+use std::sync::{Arc, Mutex};
+
+use crate::processor::Processor;
+use crate::scanner::Scanner;
+use anyhow::Result;
+use dashmap::DashMap;
+use indicatif::{MultiProgress, ProgressDrawTarget};
+use rand::Rng;
+use threadpool::ThreadPool;
+
+use crate::fileinfo::FileInfo;
+use crate::params::Params;
+
+pub struct Server {
+    filequeue: Arc<Mutex<Vec<FileInfo>>>,
+    sw_duplicate_set: Arc<DashMap<u64, Vec<FileInfo>>>,
+    pub hw_duplicate_set: Arc<DashMap<u128, Vec<FileInfo>>>,
+    threadpool: ThreadPool,
+    app_args: Arc<Params>,
+    pub max_file_path_len: Arc<AtomicU64>,
+}
+
+impl Server {
+    pub fn new(opts: Params) -> Self {
+        Self {
+            filequeue: Arc::new(Mutex::new(Vec::new())),
+            sw_duplicate_set: Arc::new(DashMap::new()),
+            hw_duplicate_set: Arc::new(DashMap::new()),
+            threadpool: ThreadPool::new(4),
+            app_args: Arc::new(opts),
+            max_file_path_len: Arc::new(AtomicU64::new(0)),
+        }
+    }
+
+    pub fn start(&self) -> Result<()> {
+        let progbarbox = Arc::new(MultiProgress::new());
+        let mut rng = rand::rng();
+        let seed: i64 = rng.random();
+
+        if !self.app_args.progress {
+            progbarbox.set_draw_target(ProgressDrawTarget::hidden());
+        }
+
+        let app_args_clone_for_sc = self.app_args.clone();
+        let app_args_clone_for_pr = self.app_args.clone();
+        let file_queue_clone_sc = self.filequeue.clone();
+        let file_queue_clone_pr = self.filequeue.clone();
+        let scanner_finished = Arc::new(AtomicBool::new(false));
+
+        let sfin_sc_tr_cl = scanner_finished.clone();
+        let sfin_pr_tr_cl = scanner_finished.clone();
+
+        let store_dupl_sw_for_sw = self.sw_duplicate_set.clone();
+        let store_dupl_sw_for_hw = self.sw_duplicate_set.clone();
+        let store_dupl_hw = self.hw_duplicate_set.clone();
+        let max_file_path_len_clone = self.max_file_path_len.clone();
+
+        let progbarbox_sc_clone = progbarbox.clone();
+
+        self.threadpool.execute(move || {
+            Scanner::new(app_args_clone_for_sc)
+                .unwrap()
+                .scan(file_queue_clone_sc, progbarbox_sc_clone)
+                .unwrap();
+
+            sfin_sc_tr_cl.store(true, std::sync::atomic::Ordering::Relaxed);
+        });
+
+        let progbarbox_pr_clone = progbarbox.clone();
+
+        self.threadpool.execute(move || {
+            Processor::sizewise(
+                app_args_clone_for_pr.clone(),
+                sfin_pr_tr_cl,
+                store_dupl_sw_for_sw,
+                file_queue_clone_pr,
+                progbarbox_pr_clone.clone(),
+            )
+            .unwrap();
+
+            Processor::hashwise(
+                app_args_clone_for_pr,
+                store_dupl_sw_for_hw,
+                store_dupl_hw,
+                progbarbox_pr_clone,
+                max_file_path_len_clone,
+                seed,
+            )
+            .unwrap();
+        });
+
+        progbarbox.clear()?;
+
+        self.threadpool.join();
+
+        Ok(())
+    }
+}