1use crate::gitlab::{
2 ArtifactConfig, ArtifactWhen, CacheConfig, CacheKey, CachePolicy, DependencySource,
3 EnvironmentAction, EnvironmentConfig, ExternalDependency, ImageConfig, Job, JobDependency,
4 ParallelConfig, ParallelMatrixEntry, ParallelVariable, PipelineDefaults, PipelineFilters,
5 RetryPolicy, ServiceConfig, WorkflowConfig,
6};
7use crate::model::{
8 ArtifactSpec, ArtifactWhenSpec, CacheKeySpec, CachePolicySpec, CacheSpec, DependencySourceSpec,
9 EnvironmentActionSpec, EnvironmentSpec, ExternalDependencySpec, ImageSpec, JobDependencySpec,
10 JobSpec, ParallelConfigSpec, ParallelMatrixEntrySpec, ParallelVariableSpec,
11 PipelineDefaultsSpec, PipelineFilterSpec, RetryPolicySpec, ServiceSpec, WorkflowSpec,
12};
13
14impl From<&JobSpec> for Job {
15 fn from(value: &JobSpec) -> Self {
16 Self {
17 name: value.name.clone(),
18 stage: value.stage.clone(),
19 commands: value.commands.clone(),
20 needs: value.needs.iter().map(JobDependency::from).collect(),
21 explicit_needs: value.explicit_needs,
22 dependencies: value.dependencies.clone(),
23 before_script: value.before_script.clone(),
24 after_script: value.after_script.clone(),
25 inherit_default_image: value.inherit_default_image,
26 inherit_default_before_script: value.inherit_default_before_script,
27 inherit_default_after_script: value.inherit_default_after_script,
28 inherit_default_cache: value.inherit_default_cache,
29 inherit_default_services: value.inherit_default_services,
30 inherit_default_timeout: value.inherit_default_timeout,
31 inherit_default_retry: value.inherit_default_retry,
32 inherit_default_interruptible: value.inherit_default_interruptible,
33 when: value.when.clone(),
34 rules: value.rules.clone(),
35 only: value.only.clone(),
36 except: value.except.clone(),
37 artifacts: ArtifactConfig {
38 name: value.artifacts.name.clone(),
39 paths: value.artifacts.paths.clone(),
40 exclude: value.artifacts.exclude.clone(),
41 untracked: value.artifacts.untracked,
42 when: ArtifactWhen::from(&value.artifacts.when),
43 expire_in: value.artifacts.expire_in,
44 report_dotenv: value.artifacts.report_dotenv.clone(),
45 },
46 cache: value.cache.iter().map(CacheConfig::from).collect(),
47 image: value.image.as_ref().map(ImageConfig::from),
48 variables: value.variables.clone(),
49 services: value.services.iter().map(ServiceConfig::from).collect(),
50 timeout: value.timeout,
51 retry: RetryPolicy::from(&value.retry),
52 interruptible: value.interruptible,
53 resource_group: value.resource_group.clone(),
54 parallel: value.parallel.as_ref().map(ParallelConfig::from),
55 tags: value.tags.clone(),
56 environment: value.environment.as_ref().map(EnvironmentConfig::from),
57 }
58 }
59}
60
61impl From<&Job> for JobSpec {
62 fn from(value: &Job) -> Self {
63 Self {
64 name: value.name.clone(),
65 stage: value.stage.clone(),
66 commands: value.commands.clone(),
67 needs: value.needs.iter().map(JobDependencySpec::from).collect(),
68 explicit_needs: value.explicit_needs,
69 dependencies: value.dependencies.clone(),
70 before_script: value.before_script.clone(),
71 after_script: value.after_script.clone(),
72 inherit_default_image: value.inherit_default_image,
73 inherit_default_before_script: value.inherit_default_before_script,
74 inherit_default_after_script: value.inherit_default_after_script,
75 inherit_default_cache: value.inherit_default_cache,
76 inherit_default_services: value.inherit_default_services,
77 inherit_default_timeout: value.inherit_default_timeout,
78 inherit_default_retry: value.inherit_default_retry,
79 inherit_default_interruptible: value.inherit_default_interruptible,
80 when: value.when.clone(),
81 rules: value.rules.clone(),
82 only: value.only.clone(),
83 except: value.except.clone(),
84 artifacts: ArtifactSpec {
85 name: value.artifacts.name.clone(),
86 paths: value.artifacts.paths.clone(),
87 exclude: value.artifacts.exclude.clone(),
88 untracked: value.artifacts.untracked,
89 when: ArtifactWhenSpec::from(&value.artifacts.when),
90 expire_in: value.artifacts.expire_in,
91 report_dotenv: value.artifacts.report_dotenv.clone(),
92 },
93 cache: value.cache.iter().map(CacheSpec::from).collect(),
94 image: value.image.as_ref().map(ImageSpec::from),
95 variables: value.variables.clone(),
96 services: value.services.iter().map(ServiceSpec::from).collect(),
97 timeout: value.timeout,
98 retry: RetryPolicySpec::from(&value.retry),
99 interruptible: value.interruptible,
100 resource_group: value.resource_group.clone(),
101 parallel: value.parallel.as_ref().map(ParallelConfigSpec::from),
102 tags: value.tags.clone(),
103 environment: value.environment.as_ref().map(EnvironmentSpec::from),
104 }
105 }
106}
107
108impl From<&ArtifactWhen> for ArtifactWhenSpec {
109 fn from(value: &ArtifactWhen) -> Self {
110 match value {
111 ArtifactWhen::OnSuccess => Self::OnSuccess,
112 ArtifactWhen::OnFailure => Self::OnFailure,
113 ArtifactWhen::Always => Self::Always,
114 }
115 }
116}
117
118impl From<&ArtifactWhenSpec> for ArtifactWhen {
119 fn from(value: &ArtifactWhenSpec) -> Self {
120 match value {
121 ArtifactWhenSpec::OnSuccess => Self::OnSuccess,
122 ArtifactWhenSpec::OnFailure => Self::OnFailure,
123 ArtifactWhenSpec::Always => Self::Always,
124 }
125 }
126}
127
128impl From<&PipelineDefaults> for PipelineDefaultsSpec {
129 fn from(value: &PipelineDefaults) -> Self {
130 Self {
131 image: value.image.as_ref().map(ImageSpec::from),
132 before_script: value.before_script.clone(),
133 after_script: value.after_script.clone(),
134 variables: value.variables.clone(),
135 cache: value.cache.iter().map(CacheSpec::from).collect(),
136 services: value.services.iter().map(ServiceSpec::from).collect(),
137 timeout: value.timeout,
138 retry: RetryPolicySpec::from(&value.retry),
139 interruptible: value.interruptible,
140 }
141 }
142}
143
144impl From<&WorkflowConfig> for WorkflowSpec {
145 fn from(value: &WorkflowConfig) -> Self {
146 Self {
147 rules: value.rules.clone(),
148 }
149 }
150}
151
152impl From<&PipelineFilters> for PipelineFilterSpec {
153 fn from(value: &PipelineFilters) -> Self {
154 Self {
155 only: value.only.clone(),
156 except: value.except.clone(),
157 }
158 }
159}
160
161impl From<&JobDependency> for JobDependencySpec {
162 fn from(value: &JobDependency) -> Self {
163 Self {
164 job: value.job.clone(),
165 needs_artifacts: value.needs_artifacts,
166 optional: value.optional,
167 source: DependencySourceSpec::from(&value.source),
168 parallel: value.parallel.clone(),
169 inline_variant: value.inline_variant.clone(),
170 }
171 }
172}
173
174impl From<&JobDependencySpec> for JobDependency {
175 fn from(value: &JobDependencySpec) -> Self {
176 Self {
177 job: value.job.clone(),
178 needs_artifacts: value.needs_artifacts,
179 optional: value.optional,
180 source: DependencySource::from(&value.source),
181 parallel: value.parallel.clone(),
182 inline_variant: value.inline_variant.clone(),
183 }
184 }
185}
186
187impl From<&DependencySource> for DependencySourceSpec {
188 fn from(value: &DependencySource) -> Self {
189 match value {
190 DependencySource::Local => Self::Local,
191 DependencySource::External(ext) => Self::External(ExternalDependencySpec::from(ext)),
192 }
193 }
194}
195
196impl From<&DependencySourceSpec> for DependencySource {
197 fn from(value: &DependencySourceSpec) -> Self {
198 match value {
199 DependencySourceSpec::Local => Self::Local,
200 DependencySourceSpec::External(ext) => Self::External(ExternalDependency::from(ext)),
201 }
202 }
203}
204
205impl From<&ExternalDependency> for ExternalDependencySpec {
206 fn from(value: &ExternalDependency) -> Self {
207 Self {
208 project: value.project.clone(),
209 reference: value.reference.clone(),
210 }
211 }
212}
213
214impl From<&ExternalDependencySpec> for ExternalDependency {
215 fn from(value: &ExternalDependencySpec) -> Self {
216 Self {
217 project: value.project.clone(),
218 reference: value.reference.clone(),
219 }
220 }
221}
222
223impl From<&ServiceConfig> for ServiceSpec {
224 fn from(value: &ServiceConfig) -> Self {
225 Self {
226 image: value.image.clone(),
227 aliases: value.aliases.clone(),
228 docker_platform: value.docker_platform.clone(),
229 docker_user: value.docker_user.clone(),
230 entrypoint: value.entrypoint.clone(),
231 command: value.command.clone(),
232 variables: value.variables.clone(),
233 }
234 }
235}
236
237impl From<&ServiceSpec> for ServiceConfig {
238 fn from(value: &ServiceSpec) -> Self {
239 Self {
240 image: value.image.clone(),
241 aliases: value.aliases.clone(),
242 docker_platform: value.docker_platform.clone(),
243 docker_user: value.docker_user.clone(),
244 entrypoint: value.entrypoint.clone(),
245 command: value.command.clone(),
246 variables: value.variables.clone(),
247 }
248 }
249}
250
251impl From<&ImageConfig> for ImageSpec {
252 fn from(value: &ImageConfig) -> Self {
253 Self {
254 name: value.name.clone(),
255 docker_platform: value.docker_platform.clone(),
256 docker_user: value.docker_user.clone(),
257 entrypoint: value.entrypoint.clone(),
258 }
259 }
260}
261
262impl From<&ImageSpec> for ImageConfig {
263 fn from(value: &ImageSpec) -> Self {
264 Self {
265 name: value.name.clone(),
266 docker_platform: value.docker_platform.clone(),
267 docker_user: value.docker_user.clone(),
268 entrypoint: value.entrypoint.clone(),
269 }
270 }
271}
272
273impl From<&RetryPolicy> for RetryPolicySpec {
274 fn from(value: &RetryPolicy) -> Self {
275 Self {
276 max: value.max,
277 when: value.when.clone(),
278 exit_codes: value.exit_codes.clone(),
279 }
280 }
281}
282
283impl From<&RetryPolicySpec> for RetryPolicy {
284 fn from(value: &RetryPolicySpec) -> Self {
285 Self {
286 max: value.max,
287 when: value.when.clone(),
288 exit_codes: value.exit_codes.clone(),
289 }
290 }
291}
292
293impl From<&ParallelConfig> for ParallelConfigSpec {
294 fn from(value: &ParallelConfig) -> Self {
295 match value {
296 ParallelConfig::Count(count) => Self::Count(*count),
297 ParallelConfig::Matrix(entries) => {
298 Self::Matrix(entries.iter().map(ParallelMatrixEntrySpec::from).collect())
299 }
300 }
301 }
302}
303
304impl From<&ParallelConfigSpec> for ParallelConfig {
305 fn from(value: &ParallelConfigSpec) -> Self {
306 match value {
307 ParallelConfigSpec::Count(count) => Self::Count(*count),
308 ParallelConfigSpec::Matrix(entries) => {
309 Self::Matrix(entries.iter().map(ParallelMatrixEntry::from).collect())
310 }
311 }
312 }
313}
314
315impl From<&ParallelMatrixEntry> for ParallelMatrixEntrySpec {
316 fn from(value: &ParallelMatrixEntry) -> Self {
317 Self {
318 variables: value
319 .variables
320 .iter()
321 .map(ParallelVariableSpec::from)
322 .collect(),
323 }
324 }
325}
326
327impl From<&ParallelMatrixEntrySpec> for ParallelMatrixEntry {
328 fn from(value: &ParallelMatrixEntrySpec) -> Self {
329 Self {
330 variables: value.variables.iter().map(ParallelVariable::from).collect(),
331 }
332 }
333}
334
335impl From<&ParallelVariable> for ParallelVariableSpec {
336 fn from(value: &ParallelVariable) -> Self {
337 Self {
338 name: value.name.clone(),
339 values: value.values.clone(),
340 }
341 }
342}
343
344impl From<&ParallelVariableSpec> for ParallelVariable {
345 fn from(value: &ParallelVariableSpec) -> Self {
346 Self {
347 name: value.name.clone(),
348 values: value.values.clone(),
349 }
350 }
351}
352
353impl From<&EnvironmentConfig> for EnvironmentSpec {
354 fn from(value: &EnvironmentConfig) -> Self {
355 Self {
356 name: value.name.clone(),
357 url: value.url.clone(),
358 on_stop: value.on_stop.clone(),
359 auto_stop_in: value.auto_stop_in,
360 action: EnvironmentActionSpec::from(value.action),
361 }
362 }
363}
364
365impl From<&EnvironmentSpec> for EnvironmentConfig {
366 fn from(value: &EnvironmentSpec) -> Self {
367 Self {
368 name: value.name.clone(),
369 url: value.url.clone(),
370 on_stop: value.on_stop.clone(),
371 auto_stop_in: value.auto_stop_in,
372 action: EnvironmentAction::from(value.action),
373 }
374 }
375}
376
377impl From<EnvironmentAction> for EnvironmentActionSpec {
378 fn from(value: EnvironmentAction) -> Self {
379 match value {
380 EnvironmentAction::Start => Self::Start,
381 EnvironmentAction::Prepare => Self::Prepare,
382 EnvironmentAction::Stop => Self::Stop,
383 EnvironmentAction::Verify => Self::Verify,
384 EnvironmentAction::Access => Self::Access,
385 }
386 }
387}
388
389impl From<EnvironmentActionSpec> for EnvironmentAction {
390 fn from(value: EnvironmentActionSpec) -> Self {
391 match value {
392 EnvironmentActionSpec::Start => Self::Start,
393 EnvironmentActionSpec::Prepare => Self::Prepare,
394 EnvironmentActionSpec::Stop => Self::Stop,
395 EnvironmentActionSpec::Verify => Self::Verify,
396 EnvironmentActionSpec::Access => Self::Access,
397 }
398 }
399}
400
401impl From<&CacheConfig> for CacheSpec {
402 fn from(value: &CacheConfig) -> Self {
403 Self {
404 key: match &value.key {
405 CacheKey::Literal(raw) => CacheKeySpec::Literal(raw.clone()),
406 CacheKey::Files { files, prefix } => CacheKeySpec::Files {
407 files: files.clone(),
408 prefix: prefix.clone(),
409 },
410 },
411 fallback_keys: value.fallback_keys.clone(),
412 paths: value.paths.clone(),
413 policy: CachePolicySpec::from(value.policy),
414 }
415 }
416}
417
418impl From<&CacheSpec> for CacheConfig {
419 fn from(value: &CacheSpec) -> Self {
420 Self {
421 key: match &value.key {
422 CacheKeySpec::Literal(raw) => CacheKey::Literal(raw.clone()),
423 CacheKeySpec::Files { files, prefix } => CacheKey::Files {
424 files: files.clone(),
425 prefix: prefix.clone(),
426 },
427 },
428 fallback_keys: value.fallback_keys.clone(),
429 paths: value.paths.clone(),
430 policy: CachePolicy::from(value.policy),
431 }
432 }
433}
434
435impl From<CachePolicy> for CachePolicySpec {
436 fn from(value: CachePolicy) -> Self {
437 match value {
438 CachePolicy::Pull => Self::Pull,
439 CachePolicy::Push => Self::Push,
440 CachePolicy::PullPush => Self::PullPush,
441 }
442 }
443}
444
445impl From<CachePolicySpec> for CachePolicy {
446 fn from(value: CachePolicySpec) -> Self {
447 match value {
448 CachePolicySpec::Pull => Self::Pull,
449 CachePolicySpec::Push => Self::Push,
450 CachePolicySpec::PullPush => Self::PullPush,
451 }
452 }
453}