gx 0.8.3

CLI to manage Github Actions dependencies
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

use super::action::identity::{ActionId, Version};
use super::action::spec::Spec;
use std::fmt;

/// Observable transitions produced by domain operations (manifest sync, lock sync, etc.).
///
/// Domain methods return `Vec<Event>` instead of accepting `on_progress` callbacks,
/// keeping them pure and presentation-free. Command orchestrators iterate events and
/// call `on_progress(&event.to_string())` for each.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Event {
    /// A new action was added to the manifest.
    ActionAdded(Spec),
    /// An action was removed from the manifest.
    ActionRemoved(ActionId),
    /// A SHA version in the manifest was upgraded to the best matching tag.
    ShaUpgraded { id: ActionId, tag: Version },
    /// A pinned SHA's tag was outside the manifest range, so it was re-resolved within range.
    PinOutOfRange {
        spec: Spec,
        rejected: Version,
        resolved: Version,
    },
    /// A lock resolution was skipped due to a recoverable error.
    ResolutionSkipped { spec: Spec, reason: String },
    /// Multiple actions were skipped due to recoverable errors.
    RecoverableWarning { count: usize },
}

impl fmt::Display for Event {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Event::ActionAdded(spec) => write!(f, "+ {spec}"),
            Event::ActionRemoved(id) => write!(f, "- {id}"),
            Event::ShaUpgraded { id, tag } => write!(f, "~ {id} SHA upgraded to {tag}"),
            Event::PinOutOfRange {
                spec,
                rejected,
                resolved,
            } => write!(
                f,
                "{spec}: pinned {rejected} is outside the range; re-resolved to {resolved}"
            ),
            Event::ResolutionSkipped { spec, reason } => {
                write!(f, "Skipping {spec}: {reason}")
            }
            Event::RecoverableWarning { count } => write!(
                f,
                "{count} action(s) skipped due to recoverable errors — run `gx tidy` again to retry."
            ),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::Event;
    use crate::domain::action::identity::{ActionId, Version};
    use crate::domain::action::spec::Spec;
    use crate::domain::action::specifier::Specifier;

    #[test]
    fn display_action_added() {
        let spec = Spec::new(ActionId::from("actions/checkout"), Specifier::parse("^4"));
        let event = Event::ActionAdded(spec);
        assert_eq!(event.to_string(), "+ actions/checkout@^4");
    }

    #[test]
    fn display_action_removed() {
        let event = Event::ActionRemoved(ActionId::from("actions/old-action"));
        assert!(event.to_string().contains("actions/old-action"));
    }

    #[test]
    fn display_sha_upgraded() {
        let event = Event::ShaUpgraded {
            id: ActionId::from("actions/checkout"),
            tag: Version::from("v4.1.0"),
        };
        assert_eq!(
            event.to_string(),
            "~ actions/checkout SHA upgraded to v4.1.0"
        );
    }

    #[test]
    fn display_resolution_skipped() {
        let spec = Spec::new(ActionId::from("actions/checkout"), Specifier::parse("^4"));
        let event = Event::ResolutionSkipped {
            spec,
            reason: "rate limited".to_owned(),
        };
        assert!(event.to_string().contains("Skipping"));
        assert!(event.to_string().contains("rate limited"));
    }

    #[test]
    fn display_recoverable_warning() {
        let event = Event::RecoverableWarning { count: 3 };
        assert!(event.to_string().contains("3 action(s) skipped"));
    }

    #[test]
    fn display_pin_out_of_range() {
        let event = Event::PinOutOfRange {
            spec: Spec::new(ActionId::from("actions/checkout"), Specifier::parse("^5")),
            rejected: Version::from("v6.0.2"),
            resolved: Version::from("v5"),
        };
        let s = event.to_string();
        assert!(s.contains("actions/checkout@^5"));
        assert!(s.contains("v6.0.2"));
        assert!(s.contains("v5"));
    }
}