devclean 0.1.2

A tool to clean up your development environment
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use clap::{Parser, Subcommand};
use color_eyre::owo_colors::OwoColorize;
use color_eyre::Result;
use colored::*;
use devclean::cleaner::Cleaner;
use devclean::{
    results::AnalyzeTargets,
    scanner::{get_dirty_git_repo_scanner, get_project_garbage_scanner},
};
use dialoguer::{theme::ColorfulTheme, MultiSelect};
use human_bytes::human_bytes;
use std::path::PathBuf;

/// Simple program to greet a person
#[derive(Parser, Debug)]
#[command(version, about, long_about = "A simple program to clean up project directories.")]
struct Args {
    #[command(subcommand)]
    command: Option<Commands>,

    #[arg(short, long, help = "Depth Limit", default_value = "10")]
    depth: u16,

    path: Option<PathBuf>,

    #[arg(long, help = "Dry Run", default_value = "false")]
    dry_run: bool,

    #[arg(short, long, help = "Select All by Default", default_value = "false")]
    all: bool,

    #[arg(short, long, help = "No Need to Confirm", default_value = "false")]
    yes: bool,

    #[arg(long, help = "Display Relative Path", default_value = "true")]
    relative: bool,

    #[arg(short, long, help = "Display Time", default_value = "false")]
    time: bool,
}

#[derive(Subcommand, Clone, Debug)]
enum Commands {
    /// Adds files to myapp
    FindDirtyGit {
        path: Option<PathBuf>,
        #[arg(short, long, help = "Depth Limit", default_value = "10")]
        depth: u16,
    },
}

fn main() -> Result<()> {
    color_eyre::install()?;
    let args = Args::parse();
    match args.command {
        Some(Commands::FindDirtyGit { path, depth }) => {
            let path = path.unwrap_or_else(|| PathBuf::from("."));
            let path = std::fs::canonicalize(path)?;
            let scanner = get_dirty_git_repo_scanner(depth, true);
            let found = scanner.scan_parallel(&path, 0);
            AnalyzeTargets(found).to_table().printstd();
        }
        None => {
            let mut path = args.path.unwrap_or_else(|| PathBuf::from("."));
            if !args.relative {
                path = std::fs::canonicalize(path)?;
            }
            let removable_scanner = get_project_garbage_scanner(args.depth, true);
            let start_time = std::time::Instant::now();
            let mut target_paths = removable_scanner.scan_parallel(&path, 0);
            if args.time {
                println!(
                    "\n{} {:?}\n",
                    "\nScan Time: ".blue().bold(),
                    start_time.elapsed().green()
                );
            }
            target_paths.sort_by(|a, b| b.cmp(a));
            let to_clean = if args.yes {
                target_paths.clone()
            } else {
                let default_selection = if args.all {
                    // Select all by default
                    vec![true; target_paths.len()]
                } else {
                    // Select No by default
                    vec![false; target_paths.len()]
                };
                let mut prompt = "Pick directories to clean".to_string();
                if args.all {
                    prompt += " (All Selected by Default)";
                }
                if args.dry_run {
                    prompt += " (Dry Run)";
                }

                let selections = MultiSelect::with_theme(&ColorfulTheme::default())
                    .with_prompt(prompt)
                    .items(&target_paths)
                    .defaults(&default_selection[..])
                    .interact()?;
                let mut to_clean = vec![];
                for select in selections {
                    to_clean.push(target_paths[select].clone());
                }
                to_clean
            };
            let mut cleaner = Cleaner::new(args.dry_run, args.all);
            let start_time = std::time::Instant::now();
            cleaner.clean_all(&to_clean)?;
            if args.time {
                println!("Clean Time: {:?}", start_time.elapsed());
            }
            AnalyzeTargets(to_clean).to_table().printstd();
            println!(
                "\n\n{} {}\n\n",
                "Total Bytes Cleaned:".blue().bold(),
                human_bytes(cleaner.bytes_cleaned as f64).green()
            );
        }
    }
    Ok(())
}