spec_driven_docs/self_depend/
status.rs1use camino::{Utf8Path, Utf8PathBuf};
7use semver::Version;
8use serde::Serialize;
9
10use crate::domain::paths::{CI_VAR, SELF_DEPEND_OFF_VAR, UserEnv, variable};
11use crate::self_depend::cache::{self, Entry};
12use crate::self_depend::leftovers::{self, Leftover};
13use crate::self_depend::manager::{self, Detected, Manager};
14use crate::self_depend::pin;
15use crate::self_depend::venue::Venue;
16use crate::self_depend::{CHECK_LINE, ENVRC, OLD_SYNC_LINE, SYNC_COMMAND};
17
18pub const SCHEMA: &str = "sdd.self-depend-status/2";
20
21#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
23#[serde(rename_all = "kebab-case")]
24pub enum Presence {
25 Present,
27 Absent,
29}
30
31impl Presence {
32 const fn of(present: bool) -> Self {
33 if present { Self::Present } else { Self::Absent }
34 }
35}
36
37#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
39#[serde(rename_all = "kebab-case")]
40pub enum Freshness {
41 Current,
43 Behind,
45 Ahead,
47}
48
49#[derive(Debug, Clone, Serialize)]
51pub struct ManagerEntry {
52 pub manager: Manager,
54 pub present: Presence,
56 #[serde(skip_serializing_if = "Option::is_none")]
58 pub file: Option<Utf8PathBuf>,
59 pub pinned: bool,
61 #[serde(skip_serializing_if = "Option::is_none")]
63 pub version: Option<String>,
64 #[serde(skip_serializing_if = "Option::is_none")]
66 pub venue: Option<Venue>,
67 #[serde(skip_serializing_if = "Option::is_none")]
69 pub pin_lines: Option<usize>,
70 #[serde(skip_serializing_if = "Option::is_none")]
72 pub freshness: Option<Freshness>,
73 #[serde(skip_serializing_if = "Option::is_none")]
75 pub lock: Option<Presence>,
76 #[serde(skip_serializing_if = "Option::is_none")]
78 pub locked_rev: Option<String>,
79}
80
81#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
83#[serde(rename_all = "kebab-case")]
84pub enum State {
85 Ready,
87 Unwired,
89 LineAbsent,
91 OldLine,
93 Ambiguous,
95 Leftovers,
97 Host,
100}
101
102#[derive(Debug, Clone, Serialize)]
104pub struct Host {
105 pub nix: bool,
107 pub direnv: bool,
109}
110
111#[derive(Debug, Clone, Serialize)]
113pub struct Report {
114 pub schema: &'static str,
116 pub target: Utf8PathBuf,
118 pub state: State,
120 pub wired: Option<Manager>,
122 pub acquisition: Option<crate::domain::instance_config::Acquisition>,
125 pub managers: Vec<ManagerEntry>,
127 pub envrc: Presence,
129 pub envrc_check: bool,
131 pub envrc_old_line: bool,
133 pub check: Option<Entry>,
136 pub off: bool,
138 pub host: Host,
140 pub leftovers: Vec<Leftover>,
142 pub next: Vec<String>,
144}
145
146#[must_use]
149pub fn switched_off() -> bool {
150 variable(CI_VAR).is_some() || variable(SELF_DEPEND_OFF_VAR).is_some()
151}
152
153fn on_path(program: &str) -> bool {
155 std::env::var_os("PATH")
156 .is_some_and(|path| std::env::split_paths(&path).any(|dir| dir.join(program).is_file()))
157}
158
159#[must_use]
163pub fn report(target: &Utf8Path, env: &UserEnv, this: &Version) -> Report {
164 let detected = manager::detect(target);
165 let managers = detected
166 .iter()
167 .map(|held| entry(target, held, this))
168 .collect();
169 let wired = manager::wired(&detected);
170 let envrc_text = std::fs::read_to_string(target.join(ENVRC)).ok();
171 let envrc_check = envrc_text
172 .as_deref()
173 .is_some_and(leftovers::carries_check_line);
174 let envrc_old_line = envrc_text
175 .as_deref()
176 .is_some_and(leftovers::carries_old_line);
177 let leftovers = leftovers::find(target, &[]);
178 let check = env
179 .cache_root()
180 .map(|root| cache::path(&root.path, target))
181 .and_then(|path| cache::read(&path));
182 let acquisition = crate::domain::instance_config::InstanceConfig::read(target)
185 .ok()
186 .and_then(|declaration| declaration.acquisition);
187 let state = match (wired.len(), envrc_check, leftovers.is_empty()) {
188 (0, _, _) if acquisition.is_some() => State::Host,
190 (0, _, _) => State::Unwired,
191 (1, _, _) if envrc_old_line => State::OldLine,
193 (1, true, true) => State::Ready,
194 (1, true, false) => State::Leftovers,
195 (1, false, _) => State::LineAbsent,
196 (_, _, _) => State::Ambiguous,
197 };
198 let next = next_lines(state, &wired, target, acquisition.as_ref());
199 Report {
200 schema: SCHEMA,
201 target: target.to_owned(),
202 state,
203 wired: (wired.len() == 1).then(|| wired[0].manager),
204 acquisition,
205 managers,
206 envrc: Presence::of(envrc_text.is_some()),
207 envrc_check,
208 envrc_old_line,
209 check,
210 off: switched_off(),
211 host: Host {
212 nix: on_path("nix"),
213 direnv: on_path("direnv"),
214 },
215 leftovers,
216 next,
217 }
218}
219
220fn entry(target: &Utf8Path, held: &Detected, this: &Version) -> ManagerEntry {
221 let lock = held.manager.lock_file().map(|lock| {
222 let path = target.join(lock);
223 (
224 Presence::of(path.is_file()),
225 std::fs::read_to_string(&path)
226 .ok()
227 .and_then(|text| pin::locked_rev(&text)),
228 )
229 });
230 ManagerEntry {
231 manager: held.manager,
232 present: Presence::of(held.file.is_some()),
233 file: held.file.clone(),
234 pinned: held.pin.is_some(),
235 version: held.pin.as_ref().map(|pin| pin.spelled.clone()),
236 venue: held.pin.as_ref().and_then(|pin| pin.venue),
237 pin_lines: held.pin.as_ref().map(|pin| pin.lines),
238 freshness: held.pin.as_ref().map(|pin| match pin.version.cmp(this) {
239 std::cmp::Ordering::Less => Freshness::Behind,
240 std::cmp::Ordering::Equal => Freshness::Current,
241 std::cmp::Ordering::Greater => Freshness::Ahead,
242 }),
243 lock: lock.as_ref().map(|(presence, _)| *presence),
244 locked_rev: lock.and_then(|(_, rev)| rev),
245 }
246}
247
248fn next_lines(
249 state: State,
250 wired: &[&Detected],
251 target: &Utf8Path,
252 acquisition: Option<&crate::domain::instance_config::Acquisition>,
253) -> Vec<String> {
254 match state {
255 State::Host => vec![format!(
256 "each host installs sdd {} or newer itself; sdd self-depend add --target {target} --manager <manager> moves the project onto a pin",
257 acquisition.map_or("", |decision| decision.minimum.as_str())
258 )],
259 State::Ready => vec![format!(
260 "{SYNC_COMMAND} --target {target} moves the pin when a newer release is out"
261 )],
262 State::Unwired => vec![format!(
263 "sdd self-depend add --target {target} serves the fragments for the manager this project runs"
264 )],
265 State::LineAbsent => vec![format!(
266 "add `{CHECK_LINE}` to {ENVRC}; sdd self-depend add --target {target} prints it with its placement"
267 )],
268 State::OldLine => vec![format!(
269 "{ENVRC} still runs `{OLD_SYNC_LINE}`: move the pin first with {SYNC_COMMAND} --target {target}, then sdd self-depend clean --target {target} --apply swaps the line for `{CHECK_LINE}`"
270 )],
271 State::Ambiguous => {
272 let names: Vec<&str> = wired.iter().map(|held| held.manager.as_str()).collect();
273 vec![format!(
274 "one target runs one mechanism; keep one of {} and remove the others' pins",
275 names.join(", ")
276 )]
277 }
278 State::Leftovers => vec![format!(
279 "sdd self-depend clean --target {target} --apply removes what the predecessor left"
280 )],
281 }
282}