gx 0.8.5

CLI to manage Github Actions dependencies
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;
use super::action::resolved::ResolvedAction;
use super::action::spec::Spec;
use super::action::specifier::Specifier;
use super::lock::LockEntry;
use super::manifest::overrides::ActionOverride;
use std::path::PathBuf;

/// Describes the changes to apply to a manifest file.
#[derive(Debug, Default)]
#[expect(
    clippy::module_name_repetitions,
    reason = "ManifestDiff is clearer than Manifest when imported"
)]
pub struct ManifestDiff {
    pub added: Vec<(ActionId, Specifier)>,
    pub removed: Vec<ActionId>,
    pub updated: Vec<(ActionId, Specifier)>,
    pub overrides_added: Vec<(ActionId, ActionOverride)>,
    pub overrides_removed: Vec<(ActionId, Vec<ActionOverride>)>,
}

impl ManifestDiff {
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.added.is_empty()
            && self.removed.is_empty()
            && self.updated.is_empty()
            && self.overrides_added.is_empty()
            && self.overrides_removed.is_empty()
    }
}

/// Patch for updating specific fields of a lock entry.
#[derive(Debug)]
pub struct LockEntryPatch {
    pub version: Option<Option<String>>,
    pub comment: Option<String>,
}

/// Describes the changes to apply to a lock file.
#[derive(Debug, Default)]
#[expect(
    clippy::module_name_repetitions,
    reason = "LockDiff is clearer than Lock when imported"
)]
pub struct LockDiff {
    pub added: Vec<(Spec, LockEntry)>,
    pub removed: Vec<Spec>,
    pub updated: Vec<(Spec, LockEntryPatch)>,
}

impl LockDiff {
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.added.is_empty() && self.removed.is_empty() && self.updated.is_empty()
    }
}

/// A set of pin changes for a single workflow file.
#[derive(Debug)]
pub struct WorkflowPatch {
    pub path: PathBuf,
    pub pins: Vec<ResolvedAction>,
}

#[cfg(test)]
mod tests {
    use super::{LockDiff, LockEntry, ManifestDiff};
    use crate::domain::action::identity::{ActionId, CommitDate, CommitSha, Repository, Version};
    use crate::domain::action::resolved::{Commit, ResolvedRef};
    use crate::domain::action::spec::Spec;
    use crate::domain::action::specifier::Specifier;
    use crate::domain::action::uses_ref::RefType;

    #[test]
    fn manifest_diff_is_empty_when_default() {
        let diff = ManifestDiff::default();
        assert!(diff.is_empty());
    }

    #[test]
    fn manifest_diff_is_not_empty_after_adding_entry() {
        let diff = ManifestDiff {
            added: vec![(ActionId::from("actions/checkout"), Specifier::parse("^4"))],
            ..Default::default()
        };
        assert!(!diff.is_empty());
    }

    #[test]
    fn lock_diff_is_empty_when_default() {
        let diff = LockDiff::default();
        assert!(diff.is_empty());
    }

    #[test]
    fn lock_diff_is_not_empty_after_adding_entry() {
        let diff = LockDiff {
            added: vec![(
                Spec::new(ActionId::from("actions/checkout"), Specifier::parse("^4")),
                LockEntry {
                    reference: ResolvedRef::Tag(Version::from("v4")),
                    commit: Commit {
                        sha: CommitSha::from("abc123"),
                        repository: Repository::from("actions/checkout"),
                        ref_type: Some(RefType::Tag),
                        date: CommitDate::from("2026-01-01T00:00:00Z"),
                    },
                },
            )],
            ..Default::default()
        };
        assert!(!diff.is_empty());
    }
}