use-archive 0.1.0

Feature-gated facade crate for RustUse archive primitives
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

use use_archive::{
    ArchiveEncoding, ArchiveEntry, ArchiveEntryKind, ArchiveFormat, ArchiveManifest, ArchivePolicy,
    Bzip2Level, CabCompressionMethod, CompressionFormat, CompressionIntent, CompressionLevel,
    CompressionSettings, CpioFormat, MtreeKeyword, RarVolumeKind, SevenZipFormat, WarcRecordKind,
    ZipCompressionMethod, is_bzip2_filename, is_safe_relative_archive_path,
    prelude::{ArchivePolicy as PreludeArchivePolicy, SevenZipFormat as PreludeSevenZipFormat},
};

#[test]
fn facade_root_reexports_common_archive_workflow() {
    let encoding = ArchiveEncoding::from_extension("release.tar.zst");
    let entry = ArchiveEntry::new("docs/readme.md", ArchiveEntryKind::File).with_size(128);
    let manifest = ArchiveManifest::new(encoding).with_entries(vec![entry]);
    let policy = ArchivePolicy::strict();
    let settings = CompressionSettings::new(CompressionLevel::Balanced, CompressionIntent::Size);

    assert_eq!(encoding.archive, ArchiveFormat::Tar);
    assert_eq!(encoding.compression, CompressionFormat::Zstd);
    assert_eq!(manifest.file_count(), 1);
    assert_eq!(manifest.total_size(), 128);
    assert!(policy.allows_entries(manifest.entries()));
    assert!(is_safe_relative_archive_path("docs/readme.md"));
    assert_eq!(settings.intent, CompressionIntent::Size);
}

#[test]
fn facade_namespaces_and_prelude_are_available() {
    let encoding = use_archive::format::ArchiveEncoding::from_extension("bundle.zip");
    let prelude_policy: PreludeArchivePolicy = PreludeArchivePolicy::strict();
    let method = use_archive::zip::ZipCompressionMethod::from_code(8);

    assert_eq!(encoding.archive, ArchiveFormat::Zip);
    assert_eq!(method, ZipCompressionMethod::Deflated);
    assert!(!prelude_policy.allow_symlinks);
    assert_eq!(
        use_archive::tar::TarEntryType::from_typeflag(b'5').as_str(),
        "directory"
    );
    assert_eq!(use_archive::gzip::GZIP_ENCODING_LABEL, "gzip");
    assert_eq!(use_archive::xz::XZ_EXTENSION, "xz");
    assert_eq!(use_archive::zstd::ZSTD_EXTENSION, "zst");
}

#[test]
fn facade_reexports_second_wave_archive_primitives() {
    let cpio_encoding = ArchiveEncoding::from_extension("initramfs.cpio.gz");
    let warc_encoding = ArchiveEncoding::from_extension("crawl.arc.gz");

    assert_eq!(cpio_encoding.archive, ArchiveFormat::Cpio);
    assert_eq!(cpio_encoding.compression, CompressionFormat::Gzip);
    assert_eq!(warc_encoding.archive, ArchiveFormat::Warc);
    assert!(is_bzip2_filename("release.tar.bz2"));
    assert_eq!(Bzip2Level::Best.as_str(), "best");
    assert_eq!(CpioFormat::NewAscii.as_str(), "new-ascii");
    assert_eq!(CabCompressionMethod::Lzx.as_str(), "lzx");
    assert_eq!(SevenZipFormat::SevenZip.as_str(), "7z");
    assert_eq!(PreludeSevenZipFormat::SplitVolume.as_str(), "7z-volume");
    assert_eq!(RarVolumeKind::MultiPart.as_str(), "multi-part");
    assert_eq!(WarcRecordKind::Response.as_str(), "response");
    assert_eq!(MtreeKeyword::Sha256Digest.as_str(), "sha256digest");
}

#[test]
fn facade_reexports_second_wave_namespaces() {
    assert!(use_archive::seven_zip::is_7z_filename("bundle.7z.001"));
    assert!(use_archive::rar::is_rar_filename("backup.part1.rar"));
    assert!(use_archive::warc::is_warc_filename("crawl.warc.gz"));
    assert!(use_archive::mtree::is_mtree_filename("manifest.mtree.gz"));
    assert_eq!(
        use_archive::ar::ArEntryKind::SymbolTable.as_str(),
        "symbol-table"
    );
    assert_eq!(
        use_archive::iso::IsoVolumeKind::Bootable.as_str(),
        "bootable"
    );
    assert_eq!(use_archive::compression::bzip2::BZIP2_EXTENSION, "bz2");
    assert_eq!(use_archive::brotli::BROTLI_EXTENSION, "br");
    assert_eq!(use_archive::lz4::LZ4_EXTENSION, "lz4");
}