containerization-framework 0.4.0

Rust bindings for Apple's Containerization framework: Linux containers in lightweight VMs, in-process and without a daemon.
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

//! `ArchiveWriterConfiguration`, as Swift reads it.

use crate::bridge::ffi;
use crate::containerization_archive;
use crate::containerization_archive::options;

impl containerization_archive::ArchiveWriterConfiguration {
  pub(crate) fn format(&self) -> &str {
    self.format.raw_value()
  }

  pub(crate) fn filter(&self) -> &str {
    self.filter.raw_value()
  }

  pub(crate) fn options_len(&self) -> usize {
    self.options.len()
  }

  pub(crate) fn option_kind_at(&self, index: usize) -> ffi::ArchiveOptionKind {
    match self.options[index] {
      containerization_archive::Options::CompressionLevel(_) => ffi::ArchiveOptionKind::CompressionLevel,
      containerization_archive::Options::Compression(options::Compression::Store) => {
        ffi::ArchiveOptionKind::CompressionStore
      }
      containerization_archive::Options::Compression(options::Compression::Deflate) => {
        ffi::ArchiveOptionKind::CompressionDeflate
      }
      containerization_archive::Options::Xattrformat(_) => ffi::ArchiveOptionKind::Xattrformat,
    }
  }

  pub(crate) fn option_compression_level_at(&self, index: usize) -> u32 {
    match self.options[index] {
      containerization_archive::Options::CompressionLevel(level) => level,
      _ => unreachable!("Swift asks for a level only of a compression level"),
    }
  }

  pub(crate) fn option_xattr_format_at(&self, index: usize) -> &str {
    match self.options[index] {
      containerization_archive::Options::Xattrformat(format) => format.raw_value(),
      _ => unreachable!("Swift asks for a format only of an extended attribute format"),
    }
  }

  pub(crate) fn locales_len(&self) -> usize {
    self.locales.len()
  }

  pub(crate) fn locales_at(&self, index: usize) -> &str {
    &self.locales[index]
  }
}

#[cfg(test)]
mod tests {
  use crate::bridge::ffi;
  use crate::containerization_archive;
  use crate::containerization_archive::options;

  /// Each enum's raw values, in Rust's order, against Swift's.
  #[test]
  fn copies_swifts_raw_values() {
    fn raw_values<T: Copy>(all: &[T], raw_value: fn(T) -> &'static str) -> Vec<&'static str> {
      all.iter().map(|case| raw_value(*case)).collect()
    }

    let copies = [
      (
        "Format",
        raw_values(
          containerization_archive::Format::ALL,
          containerization_archive::Format::raw_value,
        ),
      ),
      (
        "Filter",
        raw_values(
          containerization_archive::Filter::ALL,
          containerization_archive::Filter::raw_value,
        ),
      ),
      (
        "XattrFormat",
        raw_values(options::XattrFormat::ALL, options::XattrFormat::raw_value),
      ),
      (
        "URLFileResourceType",
        raw_values(
          containerization_archive::URLFileResourceType::ALL,
          containerization_archive::URLFileResourceType::raw_value,
        ),
      ),
    ];

    for (name, copy) in copies {
      assert_eq!(ffi::cz_archive_raw_values(name), copy, "{name}");
    }
  }

  #[test]
  fn copies_swifts_default_locales() {
    assert_eq!(
      ffi::cz_archive_default_locales(),
      containerization_archive::ArchiveWriterConfiguration::DEFAULT_LOCALES
    );
  }
}