smolkik_adm/deduplicator
1
0
Fork 0
mirror of https://github.com/sreedevk/deduplicator.git synced 2026-08-31 20:45:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into interactive-mode

Browse Source
This commit is contained in:
sreedev
2023-01-09 22:55:14 -05:00
parent 0f33b4d6b5 2c75a017ce
commit 99b87cf7fa
10 changed files with 250 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/app/event_handler.rs
View File

@@ -1,7 +1,8 @@
use std::time::Duration;
use crossterm::event::{self, KeyCode, KeyEvent};
use anyhow::Result;
use crossterm::event::{self, KeyCode, KeyEvent};
use super::events;
pub struct EventHandler;
@@ -21,8 +22,7 @@ impl EventHandler {
fn handle_keypress(keyevent: KeyEvent) -> Result<events::Event> {
match keyevent.code {
KeyCode::Char('q') => Ok(events::Event::Exit),
_ => Ok(events::Event::Noop)
_ => Ok(events::Event::Noop),
}
}
}

2
src/app/events.rs
View File

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

24
src/app/mod.rs
View File

@@ -1,18 +1,13 @@
mod event_handler;
mod events;
mod ui;
mod formatter;
mod ui;
use std::{io, thread, time::Duration};
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},
@@ -20,19 +15,24 @@ use tui::{
};
use ui::Ui;
use crate::database;
use crate::output;
use crate::params::Params;
use crate::scanner;
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)?;
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 */
output::print(duplicates, app_args); /* TODO: APP TUI INIT FUNCTION */
Ok(())
}
@@ -56,6 +56,8 @@ impl App {
}
fn init_render_loop(term: &mut Terminal<CrosstermBackend<io::Stdout>>) -> Result<()> {
// this could be simplified with a `while Self::render_cycle(term).is_ok() {}` in the current state, but maybe
// it's good to keep it to handle errors in the future
loop {
match Self::render_cycle(term) {
Ok(_) => continue,

3
src/app/ui.rs
View File

@@ -1,5 +1,6 @@
use anyhow::Result;
use std::io;
use anyhow::Result;
use tui::{
backend::{Backend, CrosstermBackend},
layout::{Constraint, Direction, Layout, Rect},

88
src/database.rs
View File

@@ -1,4 +1,7 @@
use std::env::temp_dir;
use anyhow::Result;
use crate::params::Params;
#[derive(Debug, Clone)]
@@ -7,13 +10,18 @@ pub struct File {
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:"
};
fn db_connection_url(args: &Params) -> String {
match args.nocache {
true => String::from(":memory:"),
false => {
let temp_dir_path = temp_dir();
format!("{}/deduplicator.db", temp_dir_path.display())
}
}
}
sqlite::open(connection_url).and_then(|conn| {
pub fn get_connection(args: &Params) -> Result<sqlite::Connection, sqlite::Error> {
sqlite::open(db_connection_url(args)).and_then(|conn| {
setup(&conn).ok();
Ok(conn)
})
@@ -30,48 +38,46 @@ pub fn put(file: &File, connection: &sqlite::Connection) -> Result<()> {
"INSERT INTO files (file_identifier, hash) VALUES (\"{}\", \"{}\")",
file.path, file.hash
);
let result = connection.execute(query)?;
Ok(result)
connection.execute(query)?;
Ok(())
}
pub fn indexed_paths(connection: &sqlite::Connection) -> Result<Vec<File>> {
let query = format!(
"SELECT * FROM files"
);
let query = "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())
.filter_map(|row_result| row_result.ok())
.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: &str) -> 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()
.filter_map(|row_result| row_result.ok())
.map(|row| {
let path = row.read::<&str, _>("file_identifier").to_string();
let hash = row.read::<i64, _>("hash").to_string();

7
src/main.rs
View File

@@ -1,12 +1,13 @@
mod params;
#![allow(unused)] // TODO: remove this once TUI is implemented
mod app;
mod database;
mod output;
mod params;
mod scanner;
mod app;
use anyhow::Result;
use clap::Parser;
use app::App;
use clap::Parser;
#[tokio::main]
async fn main() -> Result<()> {

59
src/output.rs
View File

@@ -8,6 +8,7 @@ use humansize::{format_size, DECIMAL};
use crate::database::File;
use crate::params::Params;
use prettytable::{row, Cell, Row, format, Table};
fn format_path(path: &str, opts: &Params) -> Result<String> {
let display_path = path.replace(&opts.get_directory()?, "");
@@ -21,12 +22,12 @@ fn format_path(path: &str, opts: &Params) -> Result<String> {
display_path
};
Ok(format!("...{}", display_range))
Ok(format!("...{:<32}", display_range))
}
fn file_size(path: &String) -> Result<String> {
let mdata = fs::metadata(path)?;
let formatted_size = format_size(mdata.len(), DECIMAL);
let formatted_size = format!("{:>12}", format_size(mdata.len(), DECIMAL));
Ok(formatted_size)
}
@@ -37,37 +38,37 @@ fn modified_time(path: &String) -> Result<String> {
Ok(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();
fn group_duplicates(duplicates: Vec<File>) -> HashMap<String, Vec<File>> {
let mut duplicate_mapper: HashMap<String, Vec<File>> = HashMap::new();
duplicates.into_iter().for_each(|file| {
dup_index
duplicate_mapper
.entry(file.hash.clone())
.and_modify(|value| value.push(file.clone()))
.or_insert_with(|| vec![file]);
});
dup_index.iter().for_each(|(_, group)| {
group.iter().for_each(|file| {
println!(
"| {0: <16} | {1: <35} | {2: <16} | {3: <32} |",
file.hash.red(),
format_path(&file.path, opts).unwrap_or_default().yellow(),
file_size(&file.path).unwrap_or_default().blue(),
modified_time(&file.path).unwrap_or_default().blue()
);
});
print_divider();
});
duplicate_mapper
}
pub fn print(duplicates: Vec<File>, opts: &Params) {
let mut output_table = Table::new();
let grouped_duplicates: HashMap<String, Vec<File>> = group_duplicates(duplicates);
output_table.set_titles(row!["hash", "duplicates"]);
grouped_duplicates.iter().for_each(|(hash, group)| {
let mut inner_table = Table::new();
// inner_table.set_format(inner_table_format);
inner_table.set_format(*format::consts::FORMAT_NO_BORDER_LINE_SEPARATOR);
//inner_table.set_titles(row!["filename", "size", "updated_at"]);
group.iter().for_each(|file| {
inner_table.add_row(row![
format_path(&file.path, opts).unwrap_or_default().blue(),
file_size(&file.path).unwrap_or_default().red(),
modified_time(&file.path).unwrap_or_default().yellow()
]);
});
output_table.add_row(row![hash.green(), inner_table]);
});
output_table.printstd();
}

17
src/params.rs
View File

@@ -1,7 +1,7 @@
use std::path::PathBuf;
use std::{fs, path::PathBuf};
use anyhow::{anyhow, Result};
use clap::Parser;
use anyhow::Result;
use std::fs;
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
@@ -22,20 +22,17 @@ pub struct Params {
impl Params {
pub fn get_directory(&self) -> Result<String> {
let dir_string: String = self
let dir_pathbuf: PathBuf = self
.dir
.clone()
.unwrap_or(std::env::current_dir()?)
.as_os_str()
.to_str()
.unwrap()
.to_string();
.into();
let dir_pathbuf = PathBuf::from(&dir_string);
let dir = fs::canonicalize(&dir_pathbuf)?
let dir = fs::canonicalize(dir_pathbuf)?
.as_os_str()
.to_str()
.unwrap()
.ok_or_else(|| anyhow!("Invalid directory"))?
.to_string();
Ok(dir)