src/cli/format.rs at main · andymccall/oxygen

◆ main oxygen / src / cli / format.rs

7.3 KiB · Rust · last changed submodule remove --delete; agent commits say awaiting seal (closes #164, closes #165) 1 day ago source blame history raw

//! Shared presentation helpers.

use super::ui;
use anyhow::Result;
use oxy_core::hash::{ChangeHash, KeyId};
use oxy_core::objects::Change;
use oxy_core::repo::{Repo, SignatureStatus};
use oxy_core::state::ChangeMeta;

pub fn short_id(c: &Change) -> String {
    c.change_id.short(8)
}

/// `n head` / `n heads`.
pub fn plural(n: usize, word: &str) -> String {
    format!("{n} {word}{}", if n == 1 { "" } else { "s" })
}

/// Milliseconds since the Unix epoch as `YYYY-MM-DD HH:MM:SSZ`.
pub fn when(ms: u64) -> String {
    let secs = (ms / 1000) as i64;
    let days = secs.div_euclid(86_400);
    let rem = secs.rem_euclid(86_400);
    // Civil-from-days (Howard Hinnant), UTC.
    let z = days + 719_468;
    let era = z.div_euclid(146_097);
    let doe = z - era * 146_097;
    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
    let y = yoe + era * 400;
    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    let mp = (5 * doy + 2) / 153;
    let d = doy - (153 * mp + 2) / 5 + 1;
    let m = if mp < 10 { mp + 3 } else { mp - 9 };
    let y = if m <= 2 { y + 1 } else { y };
    format!(
        "{y:04}-{m:02}-{d:02} {:02}:{:02}:{:02}Z",
        rem / 3600,
        (rem % 3600) / 60,
        rem % 60
    )
}

/// One line describing how a change is authenticated.
pub fn signature_line(repo: &Repo, h: &ChangeHash) -> Result<String> {
    let status = repo.authenticate_change(h)?;
    let awaiting = repo
        .store()
        .get_change(h)
        .is_ok_and(|c| awaits_seal(repo, &status, &c.author));
    Ok(match status {
        SignatureStatus::Unsigned if awaiting => {
            "awaiting seal (the next push seals it under the agent's grant)".to_string()
        }
        SignatureStatus::Unsigned => "unsigned".to_string(),
        SignatureStatus::Valid {
            key,
            name,
            email,
            sealed,
            revoked,
        } => {
            format!(
                "{} by {name} <{email}> key {}{}",
                if sealed { "sealed" } else { "signed" },
                key.short(12),
                if revoked { " (KEY REVOKED)" } else { "" }
            )
        }
        SignatureStatus::Invalid(why) => format!("INVALID signature: {why}"),
    })
}

/// Who signed for the author when it was not the author: a delegate such
/// as an agent (`author.signer`), with the delegation that let it.
#[derive(Clone, Debug)]
pub struct Via {
    pub name: String,
    pub email: String,
    pub key: KeyId,
    /// The delegation as the author's identity lists it, if it still does.
    pub scope: Option<String>,
    pub expires: Option<u64>,
    pub revoked: bool,
}

impl Via {
    /// `↳ Antigravity <[email protected]> · delegate for changes, until … · key 3195…`
    pub fn line(&self) -> String {
        let delegation = match (&self.scope, self.revoked) {
            (_, true) => ui::err("delegation revoked"),
            (Some(scope), false) => ui::dim(format!(
                "delegate for {scope}{}",
                self.expires
                    .map(|e| format!(", until {}", when(e)))
                    .unwrap_or_default()
            )),
            (None, false) => ui::warn("not a delegate of the author now"),
        };
        format!(
            "{} {} <{}> · {} · key {}",
            ui::glyph("↳", "->"),
            ui::author(&self.name),
            self.email,
            delegation,
            ui::hash(self.key.short(12))
        )
    }
}

/// The delegate that signed for `author`, when one did. `None` when the
/// author signed, or nothing valid did.
pub fn via(repo: &Repo, status: &SignatureStatus, author: &KeyId) -> Option<Via> {
    match status {
        SignatureStatus::Valid {
            key,
            name,
            email,
            revoked,
            ..
        } if !author.is_zero() && key != author => {
            let entry = repo
                .identity(author)
                .ok()
                .and_then(|a| a.delegate(key).copied());
            // A short-lived key acting under the author's grant (§14.7)
            // is no delegate, and not a revoked one either.
            let certified = entry.is_none() && repo.certified_subject(key).is_some();
            Some(Via {
                name: name.clone(),
                email: email.clone(),
                key: *key,
                scope: entry.map(|d| d.scope.to_string()),
                expires: entry.and_then(|d| d.expires),
                revoked: *revoked || (entry.is_none() && !certified),
            })
        }
        _ => None,
    }
}

/// Whether an unsigned change is one the next push will seal: this
/// checkout signs keyless (an agent under a grant) and the change is its
/// configured author's (oxygen#165). Read cold, "unsigned" looks like an
/// error; it is not one until the push.
pub fn awaits_seal(repo: &Repo, status: &SignatureStatus, author: &oxy_core::hash::KeyId) -> bool {
    matches!(status, SignatureStatus::Unsigned)
        && repo.config.signer_keyless
        && repo.config.author_key == Some(*author)
}

/// A compact, styled authentication marker for log lines, from a status
/// already in hand (the caller also reads who signed, see [`via`]);
/// `awaiting` from [`awaits_seal`].
pub fn signature_mark_of(status: &SignatureStatus, awaiting: bool) -> String {
    match status {
        SignatureStatus::Unsigned if awaiting => {
            ui::dim(format!("{} awaiting seal", ui::glyph("◌", "o")))
        }
        SignatureStatus::Unsigned => ui::dim(format!("{} unsigned", ui::glyph("·", "-"))),
        SignatureStatus::Valid {
            sealed,
            revoked: true,
            ..
        } => ui::warn(format!(
            "{} {} (key revoked)",
            ui::glyph("⚠", "!"),
            if *sealed { "sealed" } else { "signed" }
        )),
        SignatureStatus::Valid { sealed, .. } => ui::ok(format!(
            "{} {}",
            ui::glyph("✔", "v"),
            if *sealed { "sealed" } else { "signed" }
        )),
        SignatureStatus::Invalid(why) => ui::err(format!("{} INVALID: {why}", ui::glyph("✖", "x"))),
    }
}

/// The author's display name: the identity's name, or a Git-Author trailer
/// for imported changes, or a shortened key.
pub fn author_name(repo: &Repo, c: &ChangeMeta) -> String {
    if !c.author.is_zero() {
        if let Ok(id) = repo.identity(&c.author) {
            return id.name;
        }
        return c.author.short(12);
    }
    c.message
        .lines()
        .rev()
        .find_map(|l| l.strip_prefix("Git-Author: "))
        .map(|a| a.split('<').next().unwrap_or(a).trim().to_string())
        .unwrap_or_else(|| "unknown".into())
}

/// The first line of a message, or a placeholder.
pub fn subject_of(message: &str) -> &str {
    match message.lines().next() {
        Some(l) if !l.trim().is_empty() => l,
        _ => "(no description)",
    }
}

pub fn deps_line(c: &Change) -> String {
    deps_of(&c.deps)
}

pub fn deps_of(deps: &[oxy_core::hash::ChangeHash]) -> String {
    deps.iter()
        .map(|d| format!("#{}", d.short(12)))
        .collect::<Vec<_>>()
        .join(" ")
}

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

    #[test]
    fn dates() {
        assert_eq!(when(0), "1970-01-01 00:00:00Z");
        assert_eq!(when(1_700_000_000_000), "2023-11-14 22:13:20Z");
        assert_eq!(plural(1, "head"), "1 head");
        assert_eq!(plural(2, "head"), "2 heads");
    }
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1	//! Shared presentation helpers.
2
3	use super::ui;
4	use anyhow::Result;
5	use oxy_core::hash::{ChangeHash, KeyId};
6	use oxy_core::objects::Change;
7	use oxy_core::repo::{Repo, SignatureStatus};
8	use oxy_core::state::ChangeMeta;
9
10	pub fn short_id(c: &Change) -> String {
11	c.change_id.short(8)
12	}
13
14	/// `n head` / `n heads`.
15	pub fn plural(n: usize, word: &str) -> String {
16	format!("{n} {word}{}", if n == 1 { "" } else { "s" })
17	}
18
19	/// Milliseconds since the Unix epoch as `YYYY-MM-DD HH:MM:SSZ`.
20	pub fn when(ms: u64) -> String {
21	let secs = (ms / 1000) as i64;
22	let days = secs.div_euclid(86_400);
23	let rem = secs.rem_euclid(86_400);
24	// Civil-from-days (Howard Hinnant), UTC.
25	let z = days + 719_468;
26	let era = z.div_euclid(146_097);
27	let doe = z - era * 146_097;
28	let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
29	let y = yoe + era * 400;
30	let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
31	let mp = (5 * doy + 2) / 153;
32	let d = doy - (153 * mp + 2) / 5 + 1;
33	let m = if mp < 10 { mp + 3 } else { mp - 9 };
34	let y = if m <= 2 { y + 1 } else { y };
35	format!(
36	"{y:04}-{m:02}-{d:02} {:02}:{:02}:{:02}Z",
37	rem / 3600,
38	(rem % 3600) / 60,
39	rem % 60
40	)
41	}
42
43	/// One line describing how a change is authenticated.
44	pub fn signature_line(repo: &Repo, h: &ChangeHash) -> Result<String> {
45	let status = repo.authenticate_change(h)?;
46	let awaiting = repo
47	.store()
48	.get_change(h)
49	.is_ok_and(\|c\| awaits_seal(repo, &status, &c.author));
50	Ok(match status {
51	SignatureStatus::Unsigned if awaiting => {
52	"awaiting seal (the next push seals it under the agent's grant)".to_string()
53	}
54	SignatureStatus::Unsigned => "unsigned".to_string(),
55	SignatureStatus::Valid {
56	key,
57	name,
58	email,
59	sealed,
60	revoked,
61	} => {
62	format!(
63	"{} by {name} <{email}> key {}{}",
64	if sealed { "sealed" } else { "signed" },
65	key.short(12),
66	if revoked { " (KEY REVOKED)" } else { "" }
67	)
68	}
69	SignatureStatus::Invalid(why) => format!("INVALID signature: {why}"),
70	})
71	}
72
73	/// Who signed for the author when it was not the author: a delegate such
74	/// as an agent (`author.signer`), with the delegation that let it.
75	#[derive(Clone, Debug)]
76	pub struct Via {
77	pub name: String,
78	pub email: String,
79	pub key: KeyId,
80	/// The delegation as the author's identity lists it, if it still does.
81	pub scope: Option<String>,
82	pub expires: Option<u64>,
83	pub revoked: bool,
84	}
85
86	impl Via {
87	/// `↳ Antigravity <[email protected]> · delegate for changes, until … · key 3195…`
88	pub fn line(&self) -> String {
89	let delegation = match (&self.scope, self.revoked) {
90	(_, true) => ui::err("delegation revoked"),
91	(Some(scope), false) => ui::dim(format!(
92	"delegate for {scope}{}",
93	self.expires
94	.map(\|e\| format!(", until {}", when(e)))
95	.unwrap_or_default()
96	)),
97	(None, false) => ui::warn("not a delegate of the author now"),
98	};
99	format!(
100	"{} {} <{}> · {} · key {}",
101	ui::glyph("↳", "->"),
102	ui::author(&self.name),
103	self.email,
104	delegation,
105	ui::hash(self.key.short(12))
106	)
107	}
108	}
109
110	/// The delegate that signed for `author`, when one did. `None` when the
111	/// author signed, or nothing valid did.
112	pub fn via(repo: &Repo, status: &SignatureStatus, author: &KeyId) -> Option<Via> {
113	match status {
114	SignatureStatus::Valid {
115	key,
116	name,
117	email,
118	revoked,
119	..
120	} if !author.is_zero() && key != author => {
121	let entry = repo
122	.identity(author)
123	.ok()
124	.and_then(\|a\| a.delegate(key).copied());
125	// A short-lived key acting under the author's grant (§14.7)
126	// is no delegate, and not a revoked one either.
127	let certified = entry.is_none() && repo.certified_subject(key).is_some();
128	Some(Via {
129	name: name.clone(),
130	email: email.clone(),
131	key: *key,
132	scope: entry.map(\|d\| d.scope.to_string()),
133	expires: entry.and_then(\|d\| d.expires),
134	revoked: *revoked \|\| (entry.is_none() && !certified),
135	})
136	}
137	_ => None,
138	}
139	}
140
141	/// Whether an unsigned change is one the next push will seal: this
142	/// checkout signs keyless (an agent under a grant) and the change is its
143	/// configured author's (oxygen#165). Read cold, "unsigned" looks like an
144	/// error; it is not one until the push.
145	pub fn awaits_seal(repo: &Repo, status: &SignatureStatus, author: &oxy_core::hash::KeyId) -> bool {
146	matches!(status, SignatureStatus::Unsigned)
147	&& repo.config.signer_keyless
148	&& repo.config.author_key == Some(*author)
149	}
150
151	/// A compact, styled authentication marker for log lines, from a status
152	/// already in hand (the caller also reads who signed, see [`via`]);
153	/// `awaiting` from [`awaits_seal`].
154	pub fn signature_mark_of(status: &SignatureStatus, awaiting: bool) -> String {
155	match status {
156	SignatureStatus::Unsigned if awaiting => {
157	ui::dim(format!("{} awaiting seal", ui::glyph("◌", "o")))
158	}
159	SignatureStatus::Unsigned => ui::dim(format!("{} unsigned", ui::glyph("·", "-"))),
160	SignatureStatus::Valid {
161	sealed,
162	revoked: true,
163	..
164	} => ui::warn(format!(
165	"{} {} (key revoked)",
166	ui::glyph("⚠", "!"),
167	if *sealed { "sealed" } else { "signed" }
168	)),
169	SignatureStatus::Valid { sealed, .. } => ui::ok(format!(
170	"{} {}",
171	ui::glyph("✔", "v"),
172	if *sealed { "sealed" } else { "signed" }
173	)),
174	SignatureStatus::Invalid(why) => ui::err(format!("{} INVALID: {why}", ui::glyph("✖", "x"))),
175	}
176	}
177
178	/// The author's display name: the identity's name, or a Git-Author trailer
179	/// for imported changes, or a shortened key.
180	pub fn author_name(repo: &Repo, c: &ChangeMeta) -> String {
181	if !c.author.is_zero() {
182	if let Ok(id) = repo.identity(&c.author) {
183	return id.name;
184	}
185	return c.author.short(12);
186	}
187	c.message
188	.lines()
189	.rev()
190	.find_map(\|l\| l.strip_prefix("Git-Author: "))
191	.map(\|a\| a.split('<').next().unwrap_or(a).trim().to_string())
192	.unwrap_or_else(\|\| "unknown".into())
193	}
194
195	/// The first line of a message, or a placeholder.
196	pub fn subject_of(message: &str) -> &str {
197	match message.lines().next() {
198	Some(l) if !l.trim().is_empty() => l,
199	_ => "(no description)",
200	}
201	}
202
203	pub fn deps_line(c: &Change) -> String {
204	deps_of(&c.deps)
205	}
206
207	pub fn deps_of(deps: &[oxy_core::hash::ChangeHash]) -> String {
208	deps.iter()
209	.map(\|d\| format!("#{}", d.short(12)))
210	.collect::<Vec<_>>()
211	.join(" ")
212	}
213
214	#[cfg(test)]
215	mod tests {
216	use super::*;
217
218	#[test]
219	fn dates() {
220	assert_eq!(when(0), "1970-01-01 00:00:00Z");
221	assert_eq!(when(1_700_000_000_000), "2023-11-14 22:13:20Z");
222	assert_eq!(plural(1, "head"), "1 head");
223	assert_eq!(plural(2, "head"), "2 heads");
224	}
225	}

Keyboard