msy 0.4.2

Modern musl rsync alternative - Fast, parallel file synchronization
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

#[allow(dead_code)] // Public API and hasher infrastructure
use crate::error::Result;
use std::fs::File;
use std::io::Read;
use std::path::Path;

/// Wrapper around BLAKE3 hasher
pub struct Blake3Hasher;

#[allow(dead_code)] // Public API with tested methods
impl Blake3Hasher {
    /// Compute BLAKE3 hash of a file
    ///
    /// This reads the entire file and computes its hash.
    /// For large files, this may use significant memory.
    pub fn hash_file(path: &Path) -> Result<blake3::Hash> {
        let mut file = File::open(path)?;
        let mut hasher = blake3::Hasher::new();

        // Read and hash in chunks to avoid loading entire file into memory
        let mut buffer = vec![0u8; 1024 * 1024]; // 1MB chunks
        loop {
            let bytes_read = file.read(&mut buffer)?;
            if bytes_read == 0 {
                break;
            }
            hasher.update(&buffer[..bytes_read]);
        }

        Ok(hasher.finalize())
    }

    /// Compute BLAKE3 hash of data in memory
    pub fn hash_data(data: &[u8]) -> blake3::Hash {
        blake3::hash(data)
    }

    /// Compute BLAKE3 hash incrementally (for streaming)
    pub fn new_hasher() -> blake3::Hasher {
        blake3::Hasher::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use tempfile::TempDir;

    #[test]
    fn test_hash_data() {
        let data = b"Hello, BLAKE3!";
        let hash = Blake3Hasher::hash_data(data);
        assert_eq!(hash.as_bytes().len(), 32); // BLAKE3 produces 32-byte hashes
    }

    #[test]
    fn test_hash_data_deterministic() {
        let data = b"Test data";
        let hash1 = Blake3Hasher::hash_data(data);
        let hash2 = Blake3Hasher::hash_data(data);
        assert_eq!(hash1, hash2);
    }

    #[test]
    fn test_hash_data_different() {
        let hash1 = Blake3Hasher::hash_data(b"Data 1");
        let hash2 = Blake3Hasher::hash_data(b"Data 2");
        assert_ne!(hash1, hash2);
    }

    #[test]
    fn test_hash_file() {
        let temp_dir = TempDir::new().unwrap();
        let file_path = temp_dir.path().join("test.txt");
        let content = b"File content for BLAKE3";
        fs::write(&file_path, content).unwrap();

        let hash = Blake3Hasher::hash_file(&file_path).unwrap();
        assert_eq!(hash.as_bytes().len(), 32);

        // Should match hash of raw data
        let data_hash = Blake3Hasher::hash_data(content);
        assert_eq!(hash, data_hash);
    }

    #[test]
    fn test_hash_large_file() {
        let temp_dir = TempDir::new().unwrap();
        let file_path = temp_dir.path().join("large.txt");

        // Create 10MB file
        let chunk = vec![0x42u8; 1024 * 1024]; // 1MB
        let mut file = File::create(&file_path).unwrap();
        use std::io::Write;
        for _ in 0..10 {
            file.write_all(&chunk).unwrap();
        }
        drop(file);

        // Hash it
        let hash = Blake3Hasher::hash_file(&file_path).unwrap();
        assert_eq!(hash.as_bytes().len(), 32);
    }

    #[test]
    fn test_incremental_hasher() {
        let mut hasher = Blake3Hasher::new_hasher();
        hasher.update(b"Hello, ");
        hasher.update(b"world!");
        let hash1 = hasher.finalize();

        let hash2 = Blake3Hasher::hash_data(b"Hello, world!");
        assert_eq!(hash1, hash2);
    }

    #[test]
    fn test_empty_data() {
        let hash = Blake3Hasher::hash_data(b"");
        assert_eq!(hash.as_bytes().len(), 32);
    }

    #[test]
    fn test_empty_file() {
        let temp_dir = TempDir::new().unwrap();
        let file_path = temp_dir.path().join("empty.txt");
        fs::write(&file_path, b"").unwrap();

        let file_hash = Blake3Hasher::hash_file(&file_path).unwrap();
        let data_hash = Blake3Hasher::hash_data(b"");
        assert_eq!(file_hash, data_hash);
    }
}