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
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

//! publisher config

pub mod homebrew;
pub mod npm;
pub mod user;

use super::*;

use homebrew::*;
use npm::*;
use user::*;

/// the final publisher config
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct PublisherConfig {
    /// homebrew publisher
    pub homebrew: Option<HomebrewPublisherConfig>,
    /// npm publisher
    pub npm: Option<NpmPublisherConfig>,
    /// user specified publisher
    pub user: Option<UserPublisherConfig>,
}

/// the publisher config
///
/// but with inheritance not yet folded in
#[derive(Debug, Clone)]
pub struct PublisherConfigInheritable {
    /// common fields that each publisher inherits
    pub common: CommonPublisherConfig,
    /// homebrew publisher
    pub homebrew: Option<HomebrewPublisherLayer>,
    /// npm publisher
    pub npm: Option<NpmPublisherLayer>,
    /// user specified publisher
    pub user: Option<UserPublisherLayer>,
}

/// "raw" publisher config from presum
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PublisherLayer {
    /// common fields that each publisher inherits
    #[serde(flatten)]
    pub common: CommonPublisherLayer,
    /// homebrew publisher
    pub homebrew: Option<BoolOr<HomebrewPublisherLayer>>,
    /// npm publisher
    pub npm: Option<BoolOr<NpmPublisherLayer>>,
    /// user-specified publisher
    pub user: Option<BoolOr<UserPublisherLayer>>,
}
impl PublisherConfigInheritable {
    /// get the defaults for a given package
    pub fn defaults_for_package(workspaces: &WorkspaceGraph, pkg_idx: PackageIdx) -> Self {
        Self {
            common: CommonPublisherConfig::defaults_for_package(workspaces, pkg_idx),
            homebrew: None,
            npm: None,
            user: None,
        }
    }
    /// fold the inherited fields in to get the final publisher config
    pub fn apply_inheritance_for_package(
        self,
        workspaces: &WorkspaceGraph,
        pkg_idx: PackageIdx,
    ) -> PublisherConfig {
        let Self {
            common,
            homebrew,
            npm,
            user,
        } = self;
        let homebrew = homebrew.map(|homebrew| {
            let mut default =
                HomebrewPublisherConfig::defaults_for_package(workspaces, pkg_idx, &common);
            default.apply_layer(homebrew);
            default
        });
        let npm = npm.map(|npm| {
            let mut default =
                NpmPublisherConfig::defaults_for_package(workspaces, pkg_idx, &common);
            default.apply_layer(npm);
            default
        });
        let user = user.map(|user| {
            let mut default =
                UserPublisherConfig::defaults_for_package(workspaces, pkg_idx, &common);
            default.apply_layer(user);
            default
        });
        PublisherConfig {
            homebrew,
            npm,
            user,
        }
    }
}
impl ApplyLayer for PublisherConfigInheritable {
    type Layer = PublisherLayer;
    fn apply_layer(
        &mut self,
        Self::Layer {
            common,
            homebrew,
            npm,
            user,
        }: Self::Layer,
    ) {
        self.common.apply_layer(common);
        self.homebrew.apply_bool_layer(homebrew);
        self.npm.apply_bool_layer(npm);
        self.user.apply_bool_layer(user);
    }
}

/// fields that each publisher inherits (raw)
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CommonPublisherLayer {
    /// Whether to publish prereleases (defaults to false)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prereleases: Option<bool>,
}
/// fields that each publisher inherits (final)
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct CommonPublisherConfig {
    /// Whether to publish prereleases (defaults to false)
    pub prereleases: bool,
}
impl CommonPublisherConfig {
    /// get the defaults for a given package
    pub fn defaults_for_package(_workspaces: &WorkspaceGraph, _pkg_idx: PackageIdx) -> Self {
        Self { prereleases: false }
    }
}
impl ApplyLayer for CommonPublisherConfig {
    type Layer = CommonPublisherLayer;
    fn apply_layer(&mut self, Self::Layer { prereleases }: Self::Layer) {
        self.prereleases.apply_val(prereleases);
    }
}
impl ApplyLayer for CommonPublisherLayer {
    type Layer = CommonPublisherLayer;
    fn apply_layer(&mut self, Self::Layer { prereleases }: Self::Layer) {
        self.prereleases.apply_opt(prereleases);
    }
}