1use indexmap::IndexMap;
2use serde::{Deserialize, Serialize};
3
4use crate::slackpkg;
5
6use super::{apk, apt, brew, dnf, emerge, pacman, yum, zypper};
7
8#[derive(Serialize, Deserialize, Debug, Clone, Default)]
9pub struct InstallConfiguration {
10 #[serde(skip_serializing_if = "Option::is_none")]
11 pub packages: Option<Vec<String>>,
12
13 #[serde(serialize_with = "hcl::ser::labeled_block")]
14 pub pkg: IndexMap<String, Package>,
15}
16
17#[derive(Serialize, Deserialize, Debug, Clone, Default)]
18pub struct Package {
19 #[serde(skip_serializing, skip_deserializing)]
20 pub name: String,
21
22 #[serde(skip_serializing_if = "Option::is_none")]
23 pub url: Option<String>,
24
25 #[serde(skip_serializing_if = "Option::is_none")]
26 pub gpg_key: Option<String>,
27
28 #[serde(skip_serializing_if = "Option::is_none")]
29 pub gpg_path: Option<String>,
30
31 #[serde(skip_serializing_if = "Option::is_none")]
32 pub setup_repository: Option<String>,
33
34 #[serde(skip_serializing_if = "Option::is_none")]
35 pub apt_update: Option<bool>,
36
37 #[serde(skip_serializing_if = "Option::is_none")]
38 pub packages: Option<Vec<String>>,
39
40 #[serde(skip_serializing_if = "Option::is_none")]
41 pub depends_on: Option<Vec<String>>,
42
43 #[serde(skip_serializing_if = "Option::is_none")]
44 pub preinstall: Option<String>,
45
46 #[serde(skip_serializing_if = "Option::is_none")]
47 pub postinstall: Option<String>,
48
49 #[serde(skip_serializing_if = "Option::is_none")]
50 pub version_check: Option<String>,
51
52 #[serde(skip_serializing_if = "Option::is_none")]
53 pub non_interactive: Option<bool>,
54
55 #[serde(skip_serializing_if = "Option::is_none")]
56 pub interactive: Option<bool>,
57
58 #[serde(skip_serializing_if = "Option::is_none")]
59 pub ask: Option<bool>,
60
61 #[serde(skip_serializing_if = "Option::is_none")]
62 pub verbose: Option<bool>,
63
64 #[serde(
65 skip_serializing_if = "Option::is_none",
66 serialize_with = "hcl::ser::block"
67 )]
68 pub apk: Option<apk::Package>,
69
70 #[serde(
71 skip_serializing_if = "Option::is_none",
72 serialize_with = "hcl::ser::block"
73 )]
74 pub apt: Option<apt::Package>,
75
76 #[serde(
77 skip_serializing_if = "Option::is_none",
78 serialize_with = "hcl::ser::block"
79 )]
80 pub brew: Option<brew::Package>,
81
82 #[serde(
83 skip_serializing_if = "Option::is_none",
84 serialize_with = "hcl::ser::block"
85 )]
86 pub dnf: Option<dnf::Package>,
87
88 #[serde(
89 skip_serializing_if = "Option::is_none",
90 serialize_with = "hcl::ser::block"
91 )]
92 pub emerge: Option<emerge::Package>,
93
94 #[serde(
95 skip_serializing_if = "Option::is_none",
96 serialize_with = "hcl::ser::block"
97 )]
98 pub pacman: Option<pacman::Package>,
99
100 #[serde(
101 skip_serializing_if = "Option::is_none",
102 serialize_with = "hcl::ser::block"
103 )]
104 pub yum: Option<yum::Package>,
105
106 #[serde(
107 skip_serializing_if = "Option::is_none",
108 serialize_with = "hcl::ser::block"
109 )]
110 pub zypper: Option<zypper::Package>,
111
112 #[serde(
113 skip_serializing_if = "Option::is_none",
114 serialize_with = "hcl::ser::block"
115 )]
116 pub slackpkg: Option<slackpkg::Package>,
117
118 #[serde(skip_serializing_if = "Option::is_none")]
119 pub cask: Option<bool>,
120}
121
122impl Into<brew::BrewConfiguration> for InstallConfiguration {
123 fn into(self) -> brew::BrewConfiguration {
124 let pkg = Some(
125 self.pkg
126 .into_iter()
127 .map(|(name, pkg)| match pkg.brew {
128 Some(brew) => (name.clone(), brew),
129 None => (name.clone(), brew::Package { name, ..pkg.into() }),
130 })
131 .collect(),
132 );
133 brew::BrewConfiguration {
134 pkgs: self.packages,
135 pkg,
136 }
137 }
138}
139
140impl Into<apk::ApkConfiguration> for InstallConfiguration {
141 fn into(self) -> apk::ApkConfiguration {
142 let pkg = self
143 .pkg
144 .into_iter()
145 .map(|(name, pkg)| match pkg.apk {
146 Some(apk) => (name.clone(), apk),
147 None => (name.clone(), apk::Package { name, ..pkg.into() }),
148 })
149 .collect();
150 apk::ApkConfiguration { pkg }
151 }
152}
153
154impl Into<apt::AptConfiguration> for InstallConfiguration {
155 fn into(self) -> apt::AptConfiguration {
156 let pkg = self
157 .pkg
158 .into_iter()
159 .map(|(name, pkg)| match pkg.apt {
160 Some(apt) => (name.clone(), apt),
161 None => (name.clone(), apt::Package { name, ..pkg.into() }),
162 })
163 .collect();
164 apt::AptConfiguration { pkg }
165 }
166}
167
168impl Into<dnf::DnfConfiguration> for InstallConfiguration {
169 fn into(self) -> dnf::DnfConfiguration {
170 let pkg = self
171 .pkg
172 .into_iter()
173 .map(|(name, pkg)| match pkg.dnf {
174 Some(dnf) => (name.clone(), dnf),
175 None => (name.clone(), dnf::Package { name, ..pkg.into() }),
176 })
177 .collect();
178 dnf::DnfConfiguration { pkg }
179 }
180}
181
182impl Into<emerge::EmergeConfiguration> for InstallConfiguration {
183 fn into(self) -> emerge::EmergeConfiguration {
184 let pkg = self
185 .pkg
186 .into_iter()
187 .map(|(name, pkg)| match pkg.emerge {
188 Some(emerge) => (name.clone(), emerge),
189 None => (name.clone(), emerge::Package { name, ..pkg.into() }),
190 })
191 .collect();
192 emerge::EmergeConfiguration { pkg }
193 }
194}
195
196impl Into<pacman::PacmanConfiguration> for InstallConfiguration {
197 fn into(self) -> pacman::PacmanConfiguration {
198 let pkg = self
199 .pkg
200 .into_iter()
201 .map(|(name, pkg)| match pkg.pacman {
202 Some(pacman) => (name.clone(), pacman),
203 None => (name.clone(), pacman::Package { name, ..pkg.into() }),
204 })
205 .collect();
206 pacman::PacmanConfiguration { pkg }
207 }
208}
209
210impl Into<yum::YumConfiguration> for InstallConfiguration {
211 fn into(self) -> yum::YumConfiguration {
212 let pkg = self
213 .pkg
214 .into_iter()
215 .map(|(name, pkg)| match pkg.yum {
216 Some(yum) => (name.clone(), yum),
217 None => (name.clone(), yum::Package { name, ..pkg.into() }),
218 })
219 .collect();
220 yum::YumConfiguration { pkg }
221 }
222}
223
224impl Into<zypper::ZypperConfiguration> for InstallConfiguration {
225 fn into(self) -> zypper::ZypperConfiguration {
226 let pkg = self
227 .pkg
228 .into_iter()
229 .map(|(name, pkg)| match pkg.zypper {
230 Some(zypper) => (name.clone(), zypper),
231 None => (name.clone(), zypper::Package { name, ..pkg.into() }),
232 })
233 .collect();
234 zypper::ZypperConfiguration { pkg }
235 }
236}
237
238impl Into<slackpkg::SlackpkgConfiguration> for InstallConfiguration {
239 fn into(self) -> slackpkg::SlackpkgConfiguration {
240 let pkg = self
241 .pkg
242 .into_iter()
243 .map(|(name, pkg)| match pkg.slackpkg {
244 Some(slackpkg) => (name.clone(), slackpkg),
245 None => (name.clone(), slackpkg::Package { name, ..pkg.into() }),
246 })
247 .collect();
248 slackpkg::SlackpkgConfiguration { pkg }
249 }
250}
251
252impl Into<apk::Package> for Package {
253 fn into(self) -> apk::Package {
254 apk::Package {
255 name: self.name,
256 packages: self.packages,
257 depends_on: self.depends_on,
258 postinstall: self.postinstall,
259 version_check: self.version_check,
260 interactive: self.interactive,
261 }
262 }
263}
264
265impl Into<apt::Package> for Package {
266 fn into(self) -> apt::Package {
267 apt::Package {
268 name: self.name,
269 url: self.url,
270 gpg_key: self.gpg_key,
271 gpg_path: self.gpg_path,
272 setup_repository: self.setup_repository,
273 apt_update: self.apt_update,
274 packages: self.packages,
275 depends_on: self.depends_on,
276 postinstall: self.postinstall,
277 version_check: self.version_check,
278 }
279 }
280}
281
282impl Into<dnf::Package> for Package {
283 fn into(self) -> dnf::Package {
284 dnf::Package {
285 name: self.name,
286 packages: self.packages,
287 depends_on: self.depends_on,
288 postinstall: self.postinstall,
289 version_check: self.version_check,
290 }
291 }
292}
293
294impl Into<emerge::Package> for Package {
295 fn into(self) -> emerge::Package {
296 emerge::Package {
297 name: self.name,
298 packages: self.packages,
299 depends_on: self.depends_on,
300 postinstall: self.postinstall,
301 version_check: self.version_check,
302 ask: self.ask,
303 verbose: self.verbose,
304 }
305 }
306}
307
308impl Into<pacman::Package> for Package {
309 fn into(self) -> pacman::Package {
310 pacman::Package {
311 name: self.name,
312 packages: self.packages,
313 depends_on: self.depends_on,
314 postinstall: self.postinstall,
315 version_check: self.version_check,
316 }
317 }
318}
319
320impl Into<yum::Package> for Package {
321 fn into(self) -> yum::Package {
322 yum::Package {
323 name: self.name,
324 packages: self.packages,
325 depends_on: self.depends_on,
326 postinstall: self.postinstall,
327 version_check: self.version_check,
328 }
329 }
330}
331
332impl Into<zypper::Package> for Package {
333 fn into(self) -> zypper::Package {
334 zypper::Package {
335 name: self.name,
336 packages: self.packages,
337 depends_on: self.depends_on,
338 postinstall: self.postinstall,
339 version_check: self.version_check,
340 non_interactive: self.non_interactive,
341 }
342 }
343}
344
345impl Into<brew::Package> for Package {
346 fn into(self) -> brew::Package {
347 brew::Package {
348 name: self.name,
349 preinstall: self.preinstall,
350 postinstall: self.postinstall,
351 version_check: self.version_check,
352 cask: self.cask,
353 }
354 }
355}
356
357impl Into<slackpkg::Package> for Package {
358 fn into(self) -> slackpkg::Package {
359 slackpkg::Package {
360 name: self.name,
361 packages: self.packages,
362 depends_on: self.depends_on,
363 postinstall: self.postinstall,
364 version_check: self.version_check,
365 }
366 }
367}