zzz-arc 0.4.0

A fast compression multitool supporting zst, tgz, txz, zip, and 7z formats with optional encryption
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! compression orchestration

use crate::filter::FileFilter;
use crate::formats::{
    gz::GzipFormat, rar::RarFormat, sevenz::SevenZFormat, xz::XzFormat, zip::ZipFormat,
    zstd::ZstdFormat, CompressionFormat, CompressionOptions, CompressionStats, Format,
};
use crate::progress::Progress;
use crate::Result;
use anyhow::Context;
use std::path::{Path, PathBuf};

/// compress a file or directory using specified or auto-detected format
pub fn compress(
    input_path: &Path,
    output_path: &Path,
    options: CompressionOptions,
    filter: FileFilter,
    show_progress: bool,
    verbose: bool,
    format_override: Option<Format>,
) -> Result<CompressionStats> {
    if verbose {
        println!(
            "compressing {} to {}",
            input_path.display(),
            output_path.display()
        );
    }

    // Use format override or detect from output path
    let format = format_override
        .map(Ok)
        .unwrap_or_else(|| detect_output_format(output_path))?;

    ensure_output_outside_input(input_path, output_path)?;

    if verbose {
        println!("using {} format", format.name());
    }

    // calculate total size for progress tracking
    let total_size = crate::utils::calculate_directory_size(
        input_path,
        &filter,
        options.follow_symlinks,
        options.allow_symlink_escape,
    )?;
    let progress = Progress::new(show_progress, total_size, verbose);

    // dispatch to appropriate format implementation
    let stats = match format {
        Format::Zstd => {
            ZstdFormat::compress(input_path, output_path, &options, &filter, Some(&progress))?
        }
        Format::Gzip => {
            GzipFormat::compress(input_path, output_path, &options, &filter, Some(&progress))?
        }
        Format::Xz => {
            XzFormat::compress(input_path, output_path, &options, &filter, Some(&progress))?
        }
        Format::Zip => {
            ZipFormat::compress(input_path, output_path, &options, &filter, Some(&progress))?
        }
        Format::SevenZ => {
            SevenZFormat::compress(input_path, output_path, &options, &filter, Some(&progress))?
        }
        Format::Rar => {
            RarFormat::compress(input_path, output_path, &options, &filter, Some(&progress))?
        }
    };

    progress.finish();

    if verbose {
        println!(
            "compressed {} ({}) -> {} ({}) ratio {:.2}",
            input_path.display(),
            crate::utils::format_bytes(stats.input_size),
            output_path.display(),
            crate::utils::format_bytes(stats.output_size),
            stats.compression_ratio
        );
    }

    Ok(stats)
}

fn ensure_output_outside_input(input_path: &Path, output_path: &Path) -> Result<()> {
    let input_abs = std::fs::canonicalize(input_path)
        .with_context(|| format!("Failed to resolve input path '{}'", input_path.display()))?;
    let output_abs = resolve_absolute_path(output_path)?;
    let output_resolved = canonicalize_with_fallback(&output_abs);

    if input_path.is_file() {
        if output_resolved == input_abs {
            return Err(anyhow::anyhow!(
                "output path '{}' resolves to input file '{}'",
                output_path.display(),
                input_path.display()
            ));
        }
        return Ok(());
    }

    if output_resolved.starts_with(&input_abs) {
        return Err(anyhow::anyhow!(
            "output path '{}' is inside input directory '{}'; choose an output path outside the input tree",
            output_path.display(),
            input_path.display()
        ));
    }

    Ok(())
}

fn resolve_absolute_path(path: &Path) -> Result<PathBuf> {
    if path.is_absolute() {
        Ok(path.to_path_buf())
    } else {
        let cwd = std::env::current_dir().context("Failed to resolve current directory")?;
        Ok(cwd.join(path))
    }
}

fn canonicalize_with_fallback(path: &Path) -> PathBuf {
    std::fs::canonicalize(path).unwrap_or_else(|_| {
        if let Some(parent) = path.parent() {
            if let Ok(parent_canon) = std::fs::canonicalize(parent) {
                if let Some(name) = path.file_name() {
                    return parent_canon.join(name);
                }
                return parent_canon;
            }
        }
        path.to_path_buf()
    })
}

/// Detect compression format from output file extension
fn detect_output_format(output_path: &Path) -> Result<Format> {
    Format::from_extension(output_path).ok_or_else(|| {
        anyhow::anyhow!(
            "cannot determine compression format from extension: {}",
            output_path.display()
        )
    })
}