format.rs 68.0%

85 of 125 lines run, 16 of 37 functions · run #366 on main · run missed

//! 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> {
    Ok(match repo.authenticate_change(h)? {
        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,
    }
}

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

Coverage / src/cli/format.rs 68.0%

Keyboard