gx 0.8.2

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

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),
    /// An action's version was corrected from a SHA to the tag it points to.
    VersionCorrected {
        id: ActionId,
        corrected: Version,
        sha_points_to: Version,
    },
    /// A SHA version in the manifest was upgraded to the best matching tag.
    ShaUpgraded { id: ActionId, tag: 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::VersionCorrected {
                id,
                corrected,
                sha_points_to,
            } => write!(
                f,
                "Corrected {id} version to {corrected} (SHA {sha_points_to} points to {corrected})"
            ),
            Event::ShaUpgraded { id, tag } => write!(f, "~ {id} SHA upgraded to {tag}"),
            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_version_corrected() {
        let event = Event::VersionCorrected {
            id: ActionId::from("actions/checkout"),
            corrected: Version::from("v4"),
            sha_points_to: Version::from("v4"),
        };
        assert!(event.to_string().contains("Corrected"));
        assert!(event.to_string().contains("actions/checkout"));
    }
}