cicd-mel 0.9.1

Mélodium CI/CD library
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

use melodium_core::{executive::*, *};
use melodium_macro::{mel_data, mel_function};

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum State {
    Pending,
    Running,
    Success,
    Failed,
    Canceled,
    Skipped,
}

impl std::fmt::Display for State {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            State::Pending => write!(f, "pending"),
            State::Running => write!(f, "running"),
            State::Success => write!(f, "success"),
            State::Failed => write!(f, "failed"),
            State::Canceled => write!(f, "canceled"),
            State::Skipped => write!(f, "skipped"),
        }
    }
}

#[mel_data(
    traits (PartialEquality Serialize Deserialize Display ToString)
)]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct StepState(pub State);

impl ToString for StepState {
    fn to_string(&self) -> String {
        format!("{}", self.0)
    }
}

impl Display for StepState {
    fn display(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
        write!(f, "{}", self.0)
    }
}

#[mel_function]
pub fn pending() -> StepState {
    StepState(State::Pending)
}

#[mel_function]
pub fn running() -> StepState {
    StepState(State::Running)
}

#[mel_function]
pub fn success() -> StepState {
    StepState(State::Success)
}

#[mel_function]
pub fn failed() -> StepState {
    StepState(State::Failed)
}

#[mel_function]
pub fn canceled() -> StepState {
    StepState(State::Canceled)
}

#[mel_function]
pub fn skipped() -> StepState {
    StepState(State::Skipped)
}