fecr 0.0.2

FerrumCrimper - A fast, Rust-powered CLI tool for efficient file management, compression, and archival with support for multiple formats and secure data handling.
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

// Copyright 2024 the FerrumCrimper authors. All rights reserved. GNUv2 license.
//  _
// | |
// | |===( )   //////
// |_|   |||  | o o|
//        ||| ( c  )                  ____
//         ||| \= /                  ||   \_
//          ||||||                   ||     |
//          ||||||                ...||__/|-"
//          ||||||             __|________|__
//            |||             |______________|
//            |||             || ||      || ||
//            |||             || ||      || ||
// -----------|||-------------||-||------||-||-------
//            |__>            || ||      || ||
//       FerrumCrimper's Zip implementation - src/zip/zip_utils.rs
//             See above for our compression implementation.

use std::fs::File;
use std::io::Write;
use std::path::{Path, PathBuf};
use walkdir::WalkDir;
use std::io::Read;
use zip::{write::SimpleFileOptions, CompressionMethod, ZipWriter};

pub fn zip_folder(folder_dir: &Path, file_name: Option<&str>) -> anyhow::Result<PathBuf> {
    // Ensure the folder exists
    if !folder_dir.is_dir() {
        anyhow::bail!("Provided path is not a directory, or does not exist: {:?}", folder_dir);
    }

    // Determine the output ZIP file path
    let zip_path = match file_name {
        Some(name) => folder_dir.parent().unwrap_or_else(|| Path::new(".")).join(name).with_extension("zip"),
        None => folder_dir.with_extension("zip"),
    };

    // Create the ZIP file
    let file = File::create(&zip_path)?;
    let mut zip = ZipWriter::new(file);
    let options = SimpleFileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .unix_permissions(0o755);

    // Buffer for reading files
    let mut buffer = Vec::new();
    for entry in WalkDir::new(folder_dir).into_iter().filter_map(Result::ok) {
        let path = entry.path();
        let name = path.strip_prefix(folder_dir)?;

        // Add files to the ZIP
        if path.is_file() {
            zip.start_file(name.to_string_lossy(), options)?;
            let mut f = File::open(path)?;
            f.read_to_end(&mut buffer)?;
            zip.write_all(&buffer)?;
            buffer.clear();
        } else if path.is_dir() {
            // Add directories to the ZIP
            zip.add_directory(name.to_string_lossy(), options)?;
        }
    }

    zip.finish()?;
    Ok(zip_path)
}

pub fn unzip_folder(zip_file_dir: &Path, file_name: Option<&str>) -> anyhow::Result<PathBuf> {
    // Ensure the file exists and is a valid file
    if !zip_file_dir.is_file() {
        anyhow::bail!("Provided path is not a file, or does not exist: {:?}", zip_file_dir);
    }

    // Determine the base output directory name
    let base_name = match file_name {
        Some(name) => name.to_string(),
        None => zip_file_dir.file_stem().unwrap_or_default().to_string_lossy().into_owned(),
    };

    // Ensure the output directory does not conflict
    let mut output_dir = zip_file_dir.parent().unwrap_or_else(|| Path::new(".")).join(&base_name);
    let mut counter = 1;
    while output_dir.exists() {
        output_dir = zip_file_dir
            .parent()
            .unwrap_or_else(|| Path::new("."))
            .join(format!("{}-{}", base_name, counter));
        counter += 1;
    }

    // Create the output directory
    std::fs::create_dir_all(&output_dir)?;

    // Open the ZIP file
    let file = File::open(zip_file_dir)?;
    let mut archive = zip::ZipArchive::new(file)?;

    // Extract each file in the archive
    for i in 0..archive.len() {
        let mut file = archive.by_index(i)?;
        let out_path = output_dir.join(file.mangled_name());

        if file.is_dir() {
            // Create directories
            std::fs::create_dir_all(&out_path)?;
        } else {
            // Create parent directories if needed
            if let Some(parent) = out_path.parent() {
                std::fs::create_dir_all(parent)?;
            }

            // Write the file
            let mut outfile = File::create(&out_path)?;
            std::io::copy(&mut file, &mut outfile)?;
        }

        // Set permissions if available
        #[cfg(unix)]
        if let Some(mode) = file.unix_mode() {
            use std::os::unix::fs::PermissionsExt;
            std::fs::set_permissions(&out_path, std::fs::Permissions::from_mode(mode))?;
        }
    }

    Ok(output_dir)
}