read the file chunk by chunk to check the modification of files

Author: ibilalkayy

Cargo.lock

@@ -4,13 +4,14 @@ members = ["cli", "crates/*"]
 
 [workspace.dependencies]
 clap = { version = "4.5.47", features = ["derive"] }
+zip = { version = "7.0.0", default-features = false }
 walkdir = "2.5.0"
 
 [workspace.package]
 description = "A simple Rust tool for syncing directories with change detection"
 edition = "2024"
 repository = "https://github.com/ibilalkayy/cover"
-version = "0.1.22"
+version = "0.1.23"
 license = "Apache-2.0"
 readme = "README.md"
 keywords = ["backup", "sync", "filesystem"]

Cargo.toml

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use clap::Parser;
 
 /// It takes the required information for archiving the data
@@ -11,6 +13,7 @@ use clap::Parser;
 /// use my_crate::ArchiveData;
 ///
 /// let archive = ArchiveData {
+///     source: PathBuf::from("source_directory"),
 ///     zip: true,
 ///     tar: false,
 ///     encrypt: false,
@@ -19,6 +22,10 @@ use clap::Parser;
 /// ```
 #[derive(Debug, Parser)]
 pub struct ArchiveData {
+    /// Source folder to take the file from
+    #[clap(short, long)]
+    pub source: PathBuf,
+
     /// Save the file as .zip
     #[clap(long)]
     pub zip: bool,

cli/src/flags/archive.rs

@@ -38,6 +38,7 @@ fn handle_commands() {
         }
         Command::Archive(a) => {
             let archive_data = ArchiveData {
+                source: a.source,
                 zip: a.zip,
                 tar: a.tar,
                 encrypt: a.encrypt,

cli/src/main.rs

@@ -9,3 +9,4 @@ categories.workspace = true
 
 [dependencies]
 walkdir.workspace = true
+zip.workspace = true

crates/cover_files/Cargo.toml

@@ -1,4 +1,7 @@
+use std::path::PathBuf;
+
 pub struct ArchiveData {
+    pub source: PathBuf,
     pub zip: bool,
     pub tar: bool,
     pub encrypt: bool,

crates/cover_files/src/archive/archive.rs

@@ -1,8 +1,47 @@
 use super::sync::SyncData;
-use std::{fs::read_to_string, path::PathBuf};
+use std::{
+    fs::File,
+    io::{BufReader, Read},
+    path::PathBuf,
+};
+
+const CHUNK_SIZE: usize = 8 * 1024;
 
 /// Implementation of the source and destination files that are created or modified.
 impl SyncData {
+    pub fn files_are_equal(&self, src_file: &PathBuf, dest_file: &PathBuf) -> bool {
+        let src_open = File::open(src_file).expect("[ERROR]: failed to open the source file");
+        let dest_open =
+            File::open(dest_file).expect("[ERROR]: failed to open the destination file");
+
+        let mut src_reader = BufReader::new(src_open);
+        let mut dest_reader = BufReader::new(dest_open);
+
+        let mut buf_src = [0u8; CHUNK_SIZE];
+        let mut buf_dest = [0u8; CHUNK_SIZE];
+
+        loop {
+            let src_content = src_reader
+                .read(&mut buf_src)
+                .expect("[ERROR]: failed to read the file");
+            let dest_content = dest_reader
+                .read(&mut buf_dest)
+                .expect("[ERROR]: failed to read the file");
+
+            if src_content != dest_content {
+                return false;
+            }
+
+            if src_content == 0 {
+                return true;
+            }
+
+            if buf_src[..src_content] != buf_dest[..dest_content] {
+                return false;
+            }
+        }
+    }
+
     /// Checks whether the source file is created or not.
     ///
     /// Resturns:
@@ -115,12 +154,7 @@ impl SyncData {
                         let src_path = self.source.join(path);
                         let dest_path = self.destination.join(path);
 
-                        let src_content =
-                            read_to_string(src_path).expect("[ERROR]: failed to read the file");
-                        let dest_content =
-                            read_to_string(dest_path).expect("[ERROR]: failed to read the file");
-
-                        if src_content != dest_content {
+                        if !self.files_are_equal(&src_path, &dest_path) {
                             modified_files.push(path.clone());
                         }
                     }
@@ -245,12 +279,7 @@ impl SyncData {
                         let src_path = self.source.join(path);
                         let dest_path = self.destination.join(path);
 
-                        let src_content =
-                            read_to_string(src_path).expect("[ERROR]: failed to read the file");
-                        let dest_content =
-                            read_to_string(dest_path).expect("[ERROR]: failed to read the file");
-
-                        if src_content != dest_content {
+                        if !self.files_are_equal(&src_path, &dest_path) {
                             modified_files.push(path.clone());
                         }
                     }

crates/cover_files/src/sync/changes.rs

@@ -0,0 +1,83 @@
+// use cover_files::archive::archive::ArchiveData;
+// use std::{
+//     env,
+//     fs::{create_dir_all, remove_dir_all},
+//     path::PathBuf,
+// };
+
+// #[test]
+// fn test_src_dir_present() {
+//     let home_dir = env::var("HOME").expect("[ERROR]: failed to get the home directory");
+//     let src_parent_dir = PathBuf::from(&home_dir).join("tmpsrc_present");
+
+//     if src_parent_dir.exists() {
+//         remove_dir_all(&src_parent_dir).ok();
+//     }
+//     create_dir_all(&src_parent_dir).expect("[ERROR]: failed to create a source directory");
+
+//     let archive = ArchiveData {
+//         source: src_parent_dir.clone(),
+//         zip: true,
+//         tar: false,
+//         encrypt: false,
+//         timestamp: false,
+//     };
+
+//     assert!(
+//         archive.src_dir_present(),
+//         "[ERROR]: source directory not detected"
+//     );
+
+//     remove_dir_all(&src_parent_dir).ok();
+// }
+
+// #[test]
+// fn test_single_flag_provided() {
+//     let home_dir = env::var("HOME").expect("[ERROR]: failed to get the home directory");
+//     let src_parent_dir = PathBuf::from(&home_dir).join("tmpsrc_zip_flag");
+
+//     if src_parent_dir.exists() {
+//         remove_dir_all(&src_parent_dir).ok();
+//     }
+
+//     create_dir_all(&src_parent_dir).expect("[ERROR]: failed to create a source directory");
+
+//     let archive = ArchiveData {
+//         source: src_parent_dir.clone(),
+//         zip: true,
+//         tar: false,
+//         encrypt: false,
+//         timestamp: false,
+//     };
+
+//     assert!(
+//         archive.single_flag_provided(),
+//         "[ERROR]: expected one flag, but multiple are reported"
+//     );
+
+//     remove_dir_all(&src_parent_dir).ok();
+// }
+
+// #[test]
+// fn test_src_file_zipped() {
+//     let home_dir = env::var("HOME").expect("[ERROR]: failed to get the home directory");
+//     let src_parent_dir = PathBuf::from(&home_dir).join("tmpsrc_zip");
+
+//     if src_parent_dir.exists() {
+//         remove_dir_all(&src_parent_dir).ok();
+//     }
+
+//     create_dir_all(&src_parent_dir).expect("[ERROR]: failed to create a source directory");
+
+//     let archive = ArchiveData {
+//         source: src_parent_dir.clone(),
+//         zip: true,
+//         tar: false,
+//         encrypt: false,
+//         timestamp: false,
+//     };
+
+//     assert!(archive.src_file_zipped(), "[ERROR]: failed to zip the file");
+
+//     remove_dir_all(src_parent_dir).ok();
+// }

crates/cover_files/tests/archive_test.rs

@@ -16,7 +16,7 @@ use walkdir::WalkDir;
 
 #[test]
 fn test_src_dest_dir_present() {
-    let home_dir = env::var("HOME").expect("HOME env variable not set");
+    let home_dir = env::var("HOME").expect("[ERROR]: failed to get the home directory");
 
     let src_parent_dir = PathBuf::from(&home_dir).join("tmpsrc_present");
     let dest_parent_dir = PathBuf::from(&home_dir).join("tmpdest_present");
@@ -1066,7 +1066,7 @@ fn test_src_dir_present() {
 
 #[test]
 fn test_dest_dir_present() {
-    let home_dir = env::var("HOME").expect("HOME env variable not set");
+    let home_dir = env::var("HOME").expect("[ERROR]: failed to get the home directory");
     let dest_parent_dir = PathBuf::from(&home_dir).join("tmpdest_presence");
 
     if dest_parent_dir.exists() {