cargo-dist 0.32.0

Shippable application packaging for Rust
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

//! archive config

use super::*;

/// archive config (final)
#[derive(Debug, Clone)]
pub struct ArchiveConfig {
    /// Include the following static files in bundles like archives.
    pub include: Vec<Utf8PathBuf>,
    /// Whether to auto-include files like `README*`, `(UN)LICENSE*`, `RELEASES*`, and `CHANGELOG*`
    pub auto_includes: bool,
    /// The archive format to use for windows builds (defaults .zip)
    pub windows_archive: ZipStyle,
    /// The archive format to use for non-windows builds (defaults .tar.xz)
    pub unix_archive: ZipStyle,
    /// Whether to include built libraries in the release archive
    pub package_libraries: Vec<LibraryStyle>,
    /// Binaries for a given platform
    pub binaries: SortedMap<String, Vec<String>>,
}

/// archive config (raw from config file)
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub struct ArchiveLayer {
    /// Include the following static files in bundles like archives.
    ///
    /// Paths are relative to the Cargo.toml this is defined in.
    ///
    /// Files like `README*`, `(UN)LICENSE*`, `RELEASES*`, and `CHANGELOG*` are already
    /// automatically detected and included (use [`DistMetadata::auto_includes`][] to prevent this).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub include: Option<Vec<Utf8PathBuf>>,

    /// Whether to auto-include files like `README*`, `(UN)LICENSE*`, `RELEASES*`, and `CHANGELOG*`
    ///
    /// Defaults to true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_includes: Option<bool>,

    /// The archive format to use for windows builds (defaults .zip)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub windows_archive: Option<ZipStyle>,

    /// The archive format to use for non-windows builds (defaults .tar.xz)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unix_archive: Option<ZipStyle>,

    /// Whether to include built libraries in the release archive
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(default, with = "opt_string_or_vec")]
    pub package_libraries: Option<Vec<LibraryStyle>>,

    /// Binaries for a given platform
    #[serde(skip_serializing_if = "Option::is_none")]
    pub binaries: Option<SortedMap<String, Vec<String>>>,
}

impl ArchiveConfig {
    /// Get defaults for the given package
    pub fn defaults_for_package(_workspaces: &WorkspaceGraph, _pkg_idx: PackageIdx) -> Self {
        Self {
            include: vec![],
            auto_includes: true,
            windows_archive: ZipStyle::Zip,
            unix_archive: ZipStyle::Tar(CompressionImpl::Xzip),
            package_libraries: vec![],
            binaries: SortedMap::default(),
        }
    }
}

impl ApplyLayer for ArchiveConfig {
    type Layer = ArchiveLayer;
    fn apply_layer(
        &mut self,
        Self::Layer {
            include,
            auto_includes,
            windows_archive,
            unix_archive,
            package_libraries,
            binaries,
        }: Self::Layer,
    ) {
        self.include.apply_val(include);
        self.auto_includes.apply_val(auto_includes);
        self.windows_archive.apply_val(windows_archive);
        self.unix_archive.apply_val(unix_archive);
        self.package_libraries.apply_val(package_libraries);
        self.binaries.apply_val(binaries);
    }
}
impl ApplyLayer for ArchiveLayer {
    type Layer = ArchiveLayer;
    fn apply_layer(
        &mut self,
        Self::Layer {
            include,
            auto_includes,
            windows_archive,
            unix_archive,
            package_libraries,
            binaries,
        }: Self::Layer,
    ) {
        self.include.apply_opt(include);
        self.auto_includes.apply_opt(auto_includes);
        self.windows_archive.apply_opt(windows_archive);
        self.unix_archive.apply_opt(unix_archive);
        self.package_libraries.apply_opt(package_libraries);
        self.binaries.apply_opt(binaries);
    }
}