easy-archive 0.2.4

easy-archive
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

/// ZIP encoding implementation
use crate::{
    File,
    error::{ArchiveError, Result},
    traits::Encode,
    utils::check_duplicate_files,
};
use std::collections::HashSet;
use std::io::{Cursor, Write};
use time::OffsetDateTime;
use zip::DateTime;

use super::Zip;

impl Encode for Zip {
    fn encode(files: Vec<File>) -> Result<Vec<u8>> {
        // Check for duplicate files before encoding (fail fast)
        check_duplicate_files(&files)?;

        // Pre-allocate output buffer with estimated size
        // ZIP typically achieves 40-60% compression with Zstd
        let estimated_size: usize = files.iter().map(|f| f.buffer.len()).sum::<usize>() / 2;
        let mut output = Vec::with_capacity(estimated_size);
        let cursor = Cursor::new(&mut output);
        let mut zip = zip::ZipWriter::new(cursor);
        let mut dir_set = HashSet::with_capacity(files.len() / 4); // Estimate directory count

        // Helper function to create file options with timestamp
        // Performance: Zstd provides excellent compression speed and ratio
        let create_options = |last_modified: Option<u64>| -> zip::write::FullFileOptions {
            let mut options = zip::write::FullFileOptions::default()
                // Use Zstd for better compression/speed balance (faster than LZMA, better than Deflate)
                .compression_method(zip::CompressionMethod::Zstd);

            if let Some(timestamp) = last_modified
                && let Ok(offset_time) = OffsetDateTime::from_unix_timestamp(timestamp as i64)
                && let Ok(datetime) = DateTime::try_from(
                    time::PrimitiveDateTime::new(offset_time.date(), offset_time.time())
                )
            {
                options = options.last_modified_time(datetime);
            }

            options
        };

        // First pass: Create all explicit directories
        for file in files.iter().filter(|f| f.is_dir) {
            if dir_set.contains(&file.path) {
                continue;
            }

            dir_set.insert(file.path.clone());
            let options = create_options(file.last_modified);

            zip.add_directory(&file.path, options)
                .map_err(|e| ArchiveError::EncodeFailed {
                    format: "zip".to_string(),
                    reason: format!("Failed to add directory '{}': {}", file.path, e),
                })?;
        }

        // Second pass: Create implicit parent directories for files
        for file in files.iter().filter(|f| !f.is_dir) {
            if !file.path.contains('/') {
                continue;
            }

            if let Some(parent) = std::path::Path::new(&file.path).parent() {
                let parent_path = parent.to_string_lossy().to_string();
                if !parent_path.is_empty() && !dir_set.contains(&parent_path) {
                    dir_set.insert(parent_path.clone());
                    let options = create_options(file.last_modified);

                    zip.add_directory(&parent_path, options).map_err(|e| {
                        ArchiveError::EncodeFailed {
                            format: "zip".to_string(),
                            reason: format!(
                                "Failed to add parent directory '{}': {}",
                                parent_path, e
                            ),
                        }
                    })?;
                }
            }
        }

        // Third pass: Add all files
        for file in files.iter().filter(|f| !f.is_dir) {
            let mode = file.mode.unwrap_or(0o755);
            let options = create_options(file.last_modified).unix_permissions(mode);

            zip.start_file(&file.path, options)
                .map_err(|e| ArchiveError::EncodeFailed {
                    format: "zip".to_string(),
                    reason: format!("Failed to start file '{}': {}", file.path, e),
                })?;

            zip.write_all(&file.buffer)
                .map_err(|e| ArchiveError::EncodeFailed {
                    format: "zip".to_string(),
                    reason: format!("Failed to write file '{}': {}", file.path, e),
                })?;
        }

        zip.finish().map_err(|e| ArchiveError::EncodeFailed {
            format: "zip".to_string(),
            reason: format!("Failed to finalize zip archive: {}", e),
        })?;

        Ok(output)
    }
}