jubako 0.4.0

The reference implementation of the Jubako container format
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

use crate::creator::Compression;
use std::fmt;

/// List available compressions
pub fn list_compressions() {
    println!("Available compressions :");
    println!(" - None");
    #[cfg(feature = "lz4")]
    println!(" - lz4 (level 0->15)");
    #[cfg(feature = "lzma")]
    println!(" - lzma (level 0->9)");
    #[cfg(feature = "zstd")]
    println!(" - zstd (level -22->22)")
}

/// Parse the compression given in command line in to a jbk::creator::Compression
pub fn compression_arg_parser(s: &str) -> Result<Compression, InvalidCompression> {
    let mut iter = s.splitn(2, '=');
    let compression = iter.next().unwrap().to_ascii_lowercase();
    let level = iter.next();
    Ok(match compression.as_str() {
        "none" => Compression::None,
        #[cfg(feature = "lz4")]
        "lz4" => match level {
            None => Compression::lz4(),
            Some(l) => Compression::Lz4(match l.parse() {
                Ok(l) => l,
                Err(e) => return Err(InvalidCompression::Level(e.to_string())),
            }),
        },
        #[cfg(feature = "lzma")]
        "lzma" => match level {
            None => Compression::lzma(),
            Some(l) => Compression::Lzma(match l.parse() {
                Ok(l) => l,
                Err(e) => return Err(InvalidCompression::Level(e.to_string())),
            }),
        },
        #[cfg(feature = "zstd")]
        "zstd" => match level {
            None => Compression::zstd(),
            Some(l) => Compression::Zstd(match l.parse() {
                Ok(l) => l,
                Err(e) => return Err(InvalidCompression::Level(e.to_string())),
            }),
        },
        _ => return Err(InvalidCompression::Algorithm(compression)),
    })
}

#[derive(Debug)]
pub enum InvalidCompression {
    Level(String),
    Algorithm(String),
}

impl fmt::Display for InvalidCompression {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Level(e) => write!(f, "Invalid compression level: {}", e),
            Self::Algorithm(e) => write!(f, "Invalid compression algorithm: {}", e),
        }
    }
}
impl std::error::Error for InvalidCompression {}

/// Parse different flags to select the concat mode
#[derive(clap::Args, Debug, Copy, Clone)]
#[group(required = false, multiple = false)]
pub struct ConcatMode {
    #[arg(
        short = '1',
        long,
        required = false,
        default_value_t = false,
        action,
        help_heading = "Advanced options"
    )]
    /// Create only one file (default)
    one_file: bool,

    #[arg(
        short = '2',
        long,
        required = false,
        default_value_t = false,
        action,
        help_heading = "Advanced options"
    )]
    /// Create two files (a content pack and other)
    two_files: bool,

    #[arg(
        short = 'N',
        long,
        required = false,
        default_value_t = false,
        action,
        help_heading = "Advanced options"
    )]
    /// Create mulitples files (one per pack)
    multiple_files: bool,
}

impl From<ConcatMode> for crate::creator::ConcatMode {
    fn from(opt: ConcatMode) -> Self {
        {
            let (one, two, multiple) = (opt.one_file, opt.two_files, opt.multiple_files);
            match (one, two, multiple) {
                (true, _, _) => crate::creator::ConcatMode::OneFile,
                (_, true, _) => crate::creator::ConcatMode::TwoFiles,
                (_, _, true) => crate::creator::ConcatMode::NoConcat,
                _ => unreachable!(),
            }
        }
    }
}