systemg 0.57.4

An agent-friendly general process composer.
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Resolving `status`'s selectors into one exhaustive plan.
//!
//! Like the other command plans, this separates *what to report on* (resolved
//! from the selectors alone) from *how to fetch and render it*. `status` is
//! read-only, so its plan carries no side effect — but the same exhaustive enum
//! keeps selector handling honest and shares the one selector resolver, so a
//! `-p`/`-s` combination can never silently mean something different here than
//! it does for start, stop, or restart.

use std::path::PathBuf;

use crate::selector::{ProjectMismatch, Target, resolve_target};

/// What a `status` invocation reports on, resolved from its selectors.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StatusPlan {
    /// Report on everything the resolved config declares.
    Everything {
        /// The resolved config path (scopes which projects are shown).
        config: PathBuf,
    },
    /// Report on a single project.
    Project {
        /// The resolved config path.
        config: PathBuf,
        /// The project id to report on.
        project: String,
    },
    /// Report on a single service, optionally qualified by its project.
    Service {
        /// The resolved config path.
        config: PathBuf,
        /// The service name (never carries a `project/` prefix).
        service: String,
        /// The project the service belongs to, when known from `-p` or a
        /// `project/service` selector. `None` means "match across all projects".
        project: Option<String>,
    },
}

impl StatusPlan {
    /// The config path every plan variant carries.
    pub fn config(&self) -> &PathBuf {
        match self {
            StatusPlan::Everything { config }
            | StatusPlan::Project { config, .. }
            | StatusPlan::Service { config, .. } => config,
        }
    }
}

/// Resolves the selectors into a [`StatusPlan`]. `config` is the already-resolved
/// config path.
///
/// A `-p` flag that disagrees with a `project/service` selector prefix is a
/// mismatch and returns `Err`; the caller renders SG0201.
pub fn resolve_plan(
    config: PathBuf,
    service: Option<&str>,
    project: Option<&str>,
) -> Result<StatusPlan, ProjectMismatch> {
    Ok(match resolve_target(service, project)? {
        Target::Everything => StatusPlan::Everything { config },
        Target::Project { project } => StatusPlan::Project { config, project },
        Target::Service { service, project } => StatusPlan::Service {
            config,
            service,
            project,
        },
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    fn cfg() -> PathBuf {
        PathBuf::from("/x/systemg.yaml")
    }

    #[test]
    fn no_selectors_reports_everything() {
        assert_eq!(
            resolve_plan(cfg(), None, None).unwrap(),
            StatusPlan::Everything { config: cfg() }
        );
    }

    #[test]
    fn project_flag_reports_one_project() {
        assert_eq!(
            resolve_plan(cfg(), None, Some("alpha")).unwrap(),
            StatusPlan::Project {
                config: cfg(),
                project: "alpha".into()
            }
        );
    }

    #[test]
    fn bare_service_matches_across_projects() {
        assert_eq!(
            resolve_plan(cfg(), Some("worker"), None).unwrap(),
            StatusPlan::Service {
                config: cfg(),
                service: "worker".into(),
                project: None
            }
        );
    }

    #[test]
    fn qualified_selector_splits_project_and_service() {
        assert_eq!(
            resolve_plan(cfg(), Some("alpha/worker"), None).unwrap(),
            StatusPlan::Service {
                config: cfg(),
                service: "worker".into(),
                project: Some("alpha".into())
            }
        );
    }

    #[test]
    fn project_flag_conflicting_with_selector_is_a_mismatch() {
        let err = resolve_plan(cfg(), Some("beta/worker"), Some("alpha")).unwrap_err();
        assert_eq!(err.flag, "alpha");
        assert_eq!(err.selector, "beta");
    }
}