hadris-cd 1.2.0

Hybrid ISO+UDF optical disc image creation (UDF Bridge 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
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
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Configuration options for hybrid CD/DVD image creation

use hadris_iso::boot::options::BootOptions;
use hadris_iso::joliet::JolietLevel;
use hadris_iso::rrip::RripOptions;
use hadris_iso::write::options::{BaseIsoLevel, HybridBootOptions};
use hadris_udf::UdfRevision;

/// Options for creating a hybrid ISO+UDF image
#[derive(Debug, Clone)]
pub struct CdOptions {
    /// Volume identifier (used by both ISO and UDF)
    pub volume_id: String,
    /// Sector size (almost always 2048)
    pub sector_size: usize,
    /// ISO 9660 options
    pub iso: IsoOptions,
    /// UDF options
    pub udf: UdfOptions,
    /// El-Torito boot options
    pub boot: Option<BootOptions>,
    /// Hybrid boot options (MBR/GPT for USB booting)
    pub hybrid_boot: Option<HybridBootOptions>,
}

impl Default for CdOptions {
    fn default() -> Self {
        Self {
            volume_id: String::from("CDROM"),
            sector_size: 2048,
            iso: IsoOptions::default(),
            udf: UdfOptions::default(),
            boot: None,
            hybrid_boot: None,
        }
    }
}

impl CdOptions {
    /// Create options with a volume ID
    pub fn with_volume_id(volume_id: impl Into<String>) -> Self {
        Self {
            volume_id: volume_id.into(),
            ..Default::default()
        }
    }

    /// Set the volume ID
    pub fn volume_id(mut self, id: impl Into<String>) -> Self {
        self.volume_id = id.into();
        self
    }

    /// Enable Joliet support (Windows long filenames)
    pub fn with_joliet(mut self) -> Self {
        self.iso.joliet = Some(JolietLevel::Level3);
        self
    }

    /// Enable Rock Ridge support (POSIX filenames and permissions)
    pub fn with_rock_ridge(mut self) -> Self {
        self.iso.rock_ridge = Some(RripOptions::default());
        self
    }

    /// Set boot options
    pub fn with_boot(mut self, boot: BootOptions) -> Self {
        self.boot = Some(boot);
        self
    }

    /// Set hybrid boot options (for USB booting)
    pub fn with_hybrid_boot(mut self, hybrid: HybridBootOptions) -> Self {
        self.hybrid_boot = Some(hybrid);
        self
    }

    /// Disable UDF (create ISO-only image)
    pub fn iso_only(mut self) -> Self {
        self.udf.enabled = false;
        self
    }

    /// Disable ISO (create UDF-only image)
    pub fn udf_only(mut self) -> Self {
        self.iso.enabled = false;
        self
    }
}

/// ISO 9660 specific options
#[derive(Debug, Clone)]
pub struct IsoOptions {
    /// Enable ISO 9660 (default: true)
    pub enabled: bool,
    /// Base ISO level (L1 = 8.3, L2 = 30 chars)
    pub level: BaseIsoLevel,
    /// Enable ISO 9660:1999 (Level 3, long filenames)
    pub long_filenames: bool,
    /// Joliet extension (Windows long filenames)
    pub joliet: Option<JolietLevel>,
    /// Rock Ridge extension (POSIX attributes)
    pub rock_ridge: Option<RripOptions>,
}

impl Default for IsoOptions {
    fn default() -> Self {
        Self {
            enabled: true,
            level: BaseIsoLevel::Level2 {
                supports_lowercase: false,
                supports_rrip: false,
            },
            long_filenames: true,
            joliet: Some(JolietLevel::Level3),
            rock_ridge: None,
        }
    }
}

/// UDF specific options
#[derive(Debug, Clone)]
pub struct UdfOptions {
    /// Enable UDF (default: true)
    pub enabled: bool,
    /// UDF revision
    pub revision: UdfRevision,
}

impl Default for UdfOptions {
    fn default() -> Self {
        Self {
            enabled: true,
            revision: UdfRevision::V1_02,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_default_options() {
        let opts = CdOptions::default();
        assert_eq!(opts.volume_id, "CDROM");
        assert_eq!(opts.sector_size, 2048);
        assert!(opts.iso.enabled);
        assert!(opts.udf.enabled);
    }

    #[test]
    fn test_builder_pattern() {
        let opts = CdOptions::with_volume_id("MY_DISC")
            .with_joliet()
            .with_rock_ridge();

        assert_eq!(opts.volume_id, "MY_DISC");
        assert!(opts.iso.joliet.is_some());
        assert!(opts.iso.rock_ridge.is_some());
    }
}