Add support for dotenv files

Load CLI args from `.env` files
Rename entrypoint to `extractor`

Author: dormant-user

.gitignore

@@ -21,5 +21,6 @@ Cargo.lock
 .idea/
 
 .DS_Store
+.env
 ios
 extracted/

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ios"
-version = "0.0.2-alpha"
+version = "0.2.1"
 description = "Light-weight CLI tool to extract iOS backup"
 edition = "2021"
 authors = ["Vignesh Rao"]
@@ -35,3 +35,4 @@ threadpool = "1.8.1"
 log = "0.4.25"
 chrono = "0.4.39"
 tqdm = "0.7.0"
+dotenv = "0.15.0"

README.md

@@ -23,7 +23,7 @@ cargo add ios
 use ios;
 
 fn main() {
-    match ios::retriever() {
+    match ios::extractor() {
         Ok(res) => {
             println!("{}", res);
         }

src/fileio.rs

@@ -145,7 +145,7 @@ fn extract_files(
     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))
+        return Err(std::io::Error::new(std::io::ErrorKind::NotFound, msg));
     }
     let filename = relative_path
         .file_name()

src/lib.rs

@@ -24,7 +24,7 @@ use rusqlite::Result;
 ///
 /// * `Ok` - If the function completes successfully
 /// * `Err` - If the function encounters an error
-pub fn retriever() -> Result<String, String> {
+pub fn extractor() -> Result<String, String> {
     let metadata = constant::build_info();
     let arguments = parser::arguments(&metadata);
     let empty_serial = arguments.serial_numbers.is_empty();

src/main.rs

@@ -1,5 +1,5 @@
 fn main() {
-    match ios::retriever() {
+    match ios::extractor() {
         Ok(res) => {
             println!("{}", res);
         }

src/parser.rs

@@ -38,6 +38,13 @@ fn missing_value(key: &str) {
 ///
 /// A `PathBuf` containing the default backup directory path
 fn default_ios_backup_directory() -> PathBuf {
+    let backup_dir = PathBuf::from(
+        squire::env_var("backup_dir", Some(vec!["source_dir", "source", "src"]))
+            .unwrap_or_default(),
+    );
+    if backup_dir.exists() {
+        return backup_dir;
+    }
     let home = dirs::home_dir().expect("Could not determine home directory");
     if cfg!(target_os = "windows") {
         home.join("AppData/Roaming/Apple Computer/MobileSync/Backup")
@@ -46,6 +53,23 @@ fn default_ios_backup_directory() -> PathBuf {
     }
 }
 
+/// Default output directory
+///
+/// # Returns
+///
+/// A `PathBuf` containing the default output directory path
+fn default_output_directory() -> PathBuf {
+    let output_str = squire::env_var(
+        "output_dir",
+        Some(vec!["destination_dir", "destination", "dst"]),
+    )
+    .unwrap_or_default();
+    if output_str.is_empty() {
+        return PathBuf::from("extracted");
+    }
+    PathBuf::from(output_str)
+}
+
 /// Helper function to print the command-line arguments.
 ///
 /// # Returns
@@ -82,6 +106,7 @@ pub fn arguments(metadata: &constant::MetaData) -> ArgConfig {
     let mut debug = false;
     let mut serial = String::new();
     let mut workers = String::new();
+    let mut env_file = String::new();
     let mut backup_dir = String::new();
     let mut output_dir = String::new();
     let mut organize = Organizer::Auto;
@@ -122,6 +147,14 @@ pub fn arguments(metadata: &constant::MetaData) -> ArgConfig {
                     missing_value(&args[i - 1]);
                 }
             }
+            "--env" | "--env-file" => {
+                i += 1; // Move to the next argument.
+                if i < args.len() {
+                    env_file = args[i].clone();
+                } else {
+                    missing_value(&args[i - 1]);
+                }
+            }
             "--organize" => {
                 i += 1; // Move to the next argument.
                 if i < args.len() {
@@ -166,6 +199,12 @@ pub fn arguments(metadata: &constant::MetaData) -> ArgConfig {
         println!("{} {}", &metadata.pkg_name, &metadata.pkg_version);
         std::process::exit(0)
     }
+
+    if env_file.is_empty() {
+        env_file = squire::env_var("env_file", None).unwrap_or(".env".to_string())
+    }
+    let _ = dotenv::from_path(env_file);
+
     let backup_dir_final = if backup_dir.is_empty() {
         default_ios_backup_directory()
     } else {
@@ -181,7 +220,7 @@ pub fn arguments(metadata: &constant::MetaData) -> ArgConfig {
         }
     };
     let output_dir_final = if output_dir.is_empty() {
-        PathBuf::from("extracted")
+        default_output_directory()
     } else {
         PathBuf::from(output_dir)
     };
@@ -190,11 +229,18 @@ pub fn arguments(metadata: &constant::MetaData) -> ArgConfig {
     } else {
         workers.parse::<usize>().unwrap()
     };
+    if serial.is_empty() {
+        serial = squire::env_var("serial", None).unwrap_or_default()
+    }
     let serial_numbers: Vec<String> = serial
         .split(",")
         .filter(|s| !s.is_empty())
         .map(String::from)
         .collect();
+    // todo: implement env var check for all CLI arguments
+    // todo: remove the debug step
+    println!("{:?}", backup_dir_final);
+    println!("{:?}", output_dir_final);
     ArgConfig {
         list,
         all,

src/squire.rs

@@ -1,7 +1,7 @@
 use std::fs::metadata;
 use std::path::{Path, PathBuf};
 use std::time::{SystemTime, UNIX_EPOCH};
-use std::{fs, thread};
+use std::{env, fs, thread};
 
 /// Function to convert seconds to human-readable format
 ///
@@ -256,3 +256,32 @@ pub fn file_size(src_path: &Path, filename: &String) -> PathBuf {
         .join(filename)
         .to_owned()
 }
+
+/// Loads an environment variable by looking for both upper/lower case of the key
+///
+/// # Arguments
+///
+/// * `key` - Takes the key for env var as an argument
+///
+/// # Returns
+///
+/// A `String` with the response value from the environment variable
+pub fn env_var(env_key: &'static str, alias: Option<Vec<&'static str>>) -> Option<String> {
+    let mut alias_list = match alias {
+        Some(v) => v,
+        None => vec![env_key],
+    };
+    if !alias_list.contains(&env_key) {
+        alias_list.push(env_key);
+    }
+    for key in alias_list {
+        return match env::var(key.to_uppercase()) {
+            Ok(val) => Some(val),
+            Err(_) => match env::var(key.to_lowercase()) {
+                Ok(val) => Some(val),
+                Err(_) => continue,
+            },
+        };
+    }
+    None
+}