worked on the functionality to check the files to be updated

Author: ibilalkayy

Cargo.lock

@@ -10,7 +10,7 @@ walkdir = "2.5.0"
 [workspace.package]
 edition = "2024"
 repository = "https://github.com/ibilalkayy/cover"
-version = "0.1.2"
+version = "0.1.3"
 license = "Apache-2.0"
 readme = "README.md"
 categories = ["command-line-utilities"]

Cargo.toml

@@ -1,4 +1,8 @@
-use std::{path::PathBuf, time::SystemTime};
+use std::{
+    path::PathBuf,
+    time::{SystemTime, UNIX_EPOCH},
+};
+use time::{OffsetDateTime, macros::format_description};
 use walkdir::{DirEntry, WalkDir};
 
 pub struct SyncData {
@@ -11,99 +15,117 @@ pub struct SyncData {
     pub hash: Option<bool>,
 }
 
-fn file_types(source_entry: DirEntry) {
+fn file_size(source_entry: DirEntry) -> (f64, &'static str) {
     if let Ok(metadata) = source_entry.metadata() {
         let size = metadata.len();
-        let file_size = if size < 1024 {
-            format!("{} B", size)
+        if size < 1024 {
+            return (size as f64, "B");
         } else if size < 1024 * 1024 {
-            format!("{:.2} KB", size as f64 / 1024.0)
+            return (size as f64 / 1024.0, "KB");
         } else if size < 1024 * 1024 * 1024 {
-            format!("{:.2} MB", size as f64 / (1024.0 * 1024.0))
+            return (size as f64 / (1024.0 * 1024.0), "MB");
         } else {
-            format!("{:.2} GB", size as f64 / (1024.0 * 1024.0 * 1024.0))
+            return (size as f64 / (1024.0 * 1024.0 * 1024.0), "GB");
         };
-        println!("Size: {:?}", file_size);
     }
+    (0.0, "")
 }
 
-fn pretty_time(t: SystemTime) {
-    let utc = time::OffsetDateTime::UNIX_EPOCH
-        + time::Duration::try_from(t.duration_since(std::time::UNIX_EPOCH).unwrap()).unwrap();
+fn pretty_time(t: SystemTime) -> String {
+    let utc = OffsetDateTime::UNIX_EPOCH
+        + time::Duration::try_from(t.duration_since(UNIX_EPOCH).unwrap()).unwrap();
     let local = utc.to_offset(time::UtcOffset::local_offset_at(utc).unwrap());
     local
-        .format_into(
-            &mut std::io::stdout().lock(),
-            time::macros::format_description!(
-                "[day]-[month repr:short]-[year] [hour]:[minute]:[second]\n"
-            ),
-        )
-        .unwrap();
+        .format(&format_description!(
+            "[day]-[month repr:short]-[year] [hour repr:12]:[minute]:[second] [period case:upper]\n"
+        ))
+        .unwrap()
 }
 
-fn file_last_modified(source_entry: DirEntry) {
-    if let Ok(time) = source_entry.metadata() {
-        let last_modified = time
-            .modified()
-            .expect("Err: failed to get the last modified time");
-        pretty_time(last_modified);
+fn file_last_modified(source_entry: DirEntry) -> Option<(i64, String)> {
+    if let Ok(metadata) = source_entry.metadata() {
+        if let Ok(modified) = metadata.modified() {
+            let numeric = modified.duration_since(UNIX_EPOCH).unwrap().as_secs() as i64;
+            let pretty = pretty_time(modified);
+            return Some((numeric, pretty));
+        }
     }
+    None
 }
 
 impl SyncData {
     pub fn sync_output(&self) {
-        let mut source_files: Vec<PathBuf> = Vec::new();
+        let mut files_to_be_copied = Vec::new();
+        let mut files_to_be_updated = Vec::new();
+        let mut source_files: Vec<(PathBuf, i64)> = Vec::new();
+        let mut destination_files: Vec<(PathBuf, i64)> = Vec::new();
+
         for entry in WalkDir::new(&self.source) {
             let entry = entry.expect("Err: failed to get the source entry");
             if entry.file_type().is_file() {
-                source_files.push(entry.path().to_path_buf());
-                // file_types(source_entry.clone());
-                // file_last_modified(source_entry);
+                let path = entry.path().to_path_buf();
+                println!("File: {}", entry.file_name().display());
+                let (size, size_type) = file_size(entry.clone());
+                println!("Size: {} {}", size, size_type);
+                if let Some((num, pretty)) = file_last_modified(entry) {
+                    source_files.push((path, num));
+                    println!("Last Modified: {}", pretty);
+                }
             }
         }
 
-        let mut destination_files: Vec<PathBuf> = Vec::new();
         for entry in WalkDir::new(&self.destination) {
             let entry = entry.expect("Err: failed to get the destination entry");
             if entry.file_type().is_file() {
-                destination_files.push(entry.path().to_path_buf());
-                // file_types(entry.clone());
-                // file_last_modified(entry);
+                let path = entry.path().to_path_buf();
+                if let Some((num, _)) = file_last_modified(entry) {
+                    destination_files.push((path, num));
+                }
             }
         }
 
-        let mut copied_files = Vec::new();
-        for src in &source_files {
-            let src_file_name = src.file_name().expect("Err: failed to get the file name");
-
+        // Compare source and destination files
+        for (src_path, src_modified) in &source_files {
+            let src_file_name = src_path
+                .file_name()
+                .expect("Err: failed to get the file name");
             let mut dest_path = self.destination.clone();
             dest_path.push(src_file_name);
 
             let mut found = false;
-            for dest in &destination_files {
-                let dest_file_name = dest.file_name().expect("Err: failed to get the file name");
+            let mut needs_update = false;
+
+            for (dest_path, dest_modified) in &destination_files {
+                let dest_file_name = dest_path
+                    .file_name()
+                    .expect("Err: failed to get the file name");
                 if src_file_name == dest_file_name {
                     found = true;
+                    if src_modified > dest_modified {
+                        needs_update = true;
+                    }
+                    break;
                 }
             }
 
             if !found {
-                std::fs::copy(src, dest_path).unwrap();
-                copied_files.push(src_file_name.to_owned());
+                std::fs::copy(src_path, &dest_path).expect("Err: failed to copy file");
+                files_to_be_copied.push(src_file_name.to_owned());
+            } else if needs_update {
+                std::fs::copy(src_path, &dest_path).expect("Err: failed to update file");
+                files_to_be_updated.push(src_file_name.to_owned());
             }
         }
 
-        if !copied_files.is_empty() {
-            println!("Missing files are copied successfully");
-        } else {
-            eprintln!("No missing files to copy. Destination is up-to-date.");
+        if !files_to_be_copied.is_empty() {
+            println!("Missing files copied: {:?}", files_to_be_copied);
+        }
+        if !files_to_be_updated.is_empty() {
+            println!("Files updated: {:?}", files_to_be_updated);
+        }
+        if files_to_be_copied.is_empty() && files_to_be_updated.is_empty() {
+            eprintln!("No missing or outdated files. Destination is up-to-date.");
         }
-
-        // println!("{}", self.incremental.unwrap());
-        // println!("{}", self.delete.unwrap());
-        // println!("{}", self.dry_run.unwrap());
-        // println!("{}", self.verbose.unwrap());
-        // println!("{}", self.hash.unwrap());
     }
 
     pub fn sync_options(&self) {