Include organize type root

Reduce redundancy and create a base dir for backup

Author: dormant-user

.gitignore

@@ -20,5 +20,6 @@ Cargo.lock
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 .idea/
 
+.DS_Store
 ios
 extracted/

src/fileio.rs

@@ -3,7 +3,6 @@ use crate::{constant, squire};
 use plist::Value;
 use rusqlite::{Connection, Result};
 use std::fs::{create_dir_all, File};
-use std::io::copy;
 use std::path::{Path, PathBuf};
 use std::sync::mpsc::channel;
 use std::sync::{Arc, Mutex};
@@ -86,7 +85,9 @@ pub fn parse_manifest_db(
         match file {
             Ok((file_id, relative_path)) => {
                 let backup_cloned = backup.path.clone();
-                let output_dir_cloned = arguments.output_dir.clone();
+                let output_dir_cloned = arguments
+                    .output_dir
+                    .join(format!("{} - {}", backup.device_name, backup.serial_number));
                 let sender_cloned = sender.clone();
                 let organize_cloned = arguments.organize;
                 let progress_bar = Arc::clone(&progress_bar_base);
@@ -95,7 +96,7 @@ pub fn parse_manifest_db(
                         &backup_cloned,
                         &output_dir_cloned,
                         file_id,
-                        relative_path,
+                        &PathBuf::from(relative_path),
                         organize_cloned,
                     );
                     sender_cloned.send(result).expect("Failed to send result");
@@ -126,7 +127,7 @@ pub fn parse_manifest_db(
 ///
 /// * `backup_path` - The path to the backup directory
 /// * `output_path` - The path to the output directory
-/// * `file_id` - The file ID
+/// * `file_id` - The file ID to extract
 /// * `relative_path` - The relative path of the file
 ///
 /// # Returns
@@ -137,38 +138,42 @@ fn extract_files(
     backup_path: &Path,
     output_path: &Path,
     file_id: String,
-    relative_path: String,
+    relative_path: &PathBuf,
     organize: parser::Organizer,
 ) -> std::io::Result<()> {
     let src_path = backup_path.join(&file_id[..2]).join(file_id);
+    if !src_path.exists() {
+        let msg = format!("Path {} doesn't exist", src_path.display());
+        log::debug!("{}", msg);
+        return Err(std::io::Error::new(std::io::ErrorKind::NotFound, msg))
+    }
+    let filename = relative_path
+        .file_name()
+        .unwrap_or_default()
+        .to_string_lossy()
+        .to_string();
     let dest_path = match organize {
-        parser::Organizer::Type => {
-            output_path.join(squire::file_type(&PathBuf::from(relative_path)))
-        }
-        parser::Organizer::Size => output_path.join(squire::file_size(
-            &PathBuf::from(&src_path),
-            &PathBuf::from(relative_path),
-        )),
-        parser::Organizer::Auto => output_path.join(&relative_path),
+        parser::Organizer::Type => output_path.join(squire::file_type(relative_path, &filename)),
+        parser::Organizer::Size => output_path.join(squire::file_size(&src_path, &filename)),
+        parser::Organizer::Root => output_path.join(filename).to_owned(),
+        parser::Organizer::Auto => output_path.join(relative_path),
     };
     if let Some(parent) = dest_path.parent() {
         match create_dir_all(parent) {
             Ok(_) => (),
             Err(err) => return Err(err),
         }
     }
-    if src_path.exists() {
-        let mut src_file = File::open(&src_path)?;
-        let mut dest_file = File::create(&dest_path)?;
-        match copy(&mut src_file, &mut dest_file) {
-            Ok(_) => (),
-            Err(err) => return Err(err),
-        }
-        log::debug!(
-            "Extracted: {} -> {}",
-            src_path.display(),
-            dest_path.display()
-        );
+    let mut src_file = File::open(&src_path)?;
+    let mut dest_file = File::create(&dest_path)?;
+    match std::io::copy(&mut src_file, &mut dest_file) {
+        Ok(_) => (),
+        Err(err) => return Err(err),
     }
+    log::debug!(
+        "Extracted: {} -> {}",
+        src_path.display(),
+        dest_path.display()
+    );
     Ok(())
 }

src/parser.rs

@@ -6,6 +6,7 @@ use std::path::PathBuf;
 pub enum Organizer {
     Type,
     Size,
+    Root,
     Auto,
 }
 
@@ -127,9 +128,10 @@ pub fn arguments(metadata: &constant::MetaData) -> ArgConfig {
                     match args[i].as_str() {
                         "type" => organize = Organizer::Type,
                         "size" => organize = Organizer::Size,
+                        "root" => organize = Organizer::Root,
                         "auto" => organize = Organizer::Auto,
                         _ => {
-                            println!("ERROR: '--organize' can only be 'type', 'size' or 'auto'");
+                            println!("ERROR: '--organize' can only be 'type', 'size', 'root' or 'auto' (default)");
                             std::process::exit(1)
                         }
                     }
@@ -171,7 +173,10 @@ pub fn arguments(metadata: &constant::MetaData) -> ArgConfig {
         if tmp.exists() {
             tmp
         } else {
-            println!("Backup directory '{}' does not exist!", tmp.display());
+            println!(
+                "ERROR: Backup directory '{}' does not exist!",
+                tmp.display()
+            );
             std::process::exit(1)
         }
     };

src/squire.rs

@@ -126,15 +126,22 @@ pub fn size_converter(byte_size: u64) -> String {
 }
 
 /// Returns the default number of worker threads (logical cores)
-/// If the number of logical cores cannot be determined, it defaults to 8
+/// If the number of logical cores cannot be determined, it defaults to 1
 ///
 /// # Returns
 ///
 /// A `usize` containing the number of worker threads
 pub fn default_workers() -> usize {
     let logical_cores = thread::available_parallelism();
     match logical_cores {
-        Ok(cores) => cores.get(),
+        Ok(cores) => {
+            let workers = cores.get();
+            if workers > 1 {
+                workers / 2
+            } else {
+                workers
+            }
+        }
         Err(err) => {
             log::error!("{}", err);
             1
@@ -191,26 +198,22 @@ pub fn media_filter() -> String {
 /// # Arguments
 ///
 /// * `relative_path` - The path to the file
+/// * `filename` - Name of the file
 ///
 /// # Returns
 ///
-/// A `String` with the file extension in upperacase
-pub fn file_type(relative_path: &PathBuf) -> PathBuf {
+/// A `String` with the file extension in uppercase
+pub fn file_type(relative_path: &PathBuf, filename: &String) -> PathBuf {
     // I basically want the file extension in upper case
     let file_extension = &relative_path
         .extension()
         .unwrap_or_default()
         .to_string_lossy()
         .to_uppercase();
-    let file_name = &relative_path
-        .file_name()
-        .unwrap_or_default()
-        .to_string_lossy()
-        .to_string();
     if file_extension.is_empty() {
         return relative_path.to_owned();
     }
-    PathBuf::from(&file_extension).join(file_name).to_owned()
+    PathBuf::from(&file_extension).join(filename).to_owned()
 }
 
 /// Classifies size into less than 1 MB, 10 MB, 100 MB, 1 GB, and the rest as unclassified.
@@ -238,23 +241,18 @@ fn classify_size(byte_size: usize) -> String {
     }
 }
 
-/// Function to get the size of a file or directory
+/// Creates a file path categorized by its size
 ///
 /// # Arguments
 ///
-/// * `relative_path` - The path to the file or directory
+/// * `src_path` - The path to the file or directory
+/// * `filename` - Name of the file
 ///
 /// # Returns
 ///
 /// A `String` with human-readable format of the file/directory size
-pub fn file_size(src_path: &Path, relative_path: &Path) -> PathBuf {
-    let raw_size = get_size(src_path);
-    let file_name = &relative_path
-        .file_name()
-        .unwrap_or_default()
-        .to_string_lossy()
-        .to_string();
-    PathBuf::from(&classify_size(raw_size as usize))
-        .join(file_name)
+pub fn file_size(src_path: &Path, filename: &String) -> PathBuf {
+    PathBuf::from(&classify_size(get_size(src_path) as usize))
+        .join(filename)
         .to_owned()
 }