//! The Genome map: Empryo's ranked map of the open thread's checkout, read
//! from the `.empryo/genome.db` Empryo keeps there, or for a thread on
//! another device, read there and sent over. A surface of the right panel
//! that the sidebar offers while the thread runs on Empryo. The graph shows
//! the highest ranked files and which import which; the list below ranks
//! them, and a file opens to what it exports.
use std::path::PathBuf;
use std::rc::Rc;
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use gpui_kit::component::{Icon, IconName, h_flex, v_flex};
use gpui_kit::prelude::FluentBuilder as _;
use gpui_kit::*;
use super::Workspace;
use super::surfaces::Surface;
use crate::genome::{self, Genome, GenomeFile};
use crate::models::Provider;
use crate::remote::GenomeAnswer;
use crate::ui::icons::Lucide;
use crate::ui::metal::{self, MetalButton, MetalStyled as _, Palette};
pub(super) const GENOME_PANEL_WIDTH: f32 = 440.;
/// The graph's size inside the panel.
const MAP_WIDTH: f32 = GENOME_PANEL_WIDTH - 12. - 12. - 16.;
const MAP_HEIGHT: f32 = 300.;
/// How often an open map looks for Empryo's updates.
const WATCH_EVERY: Duration = Duration::from_secs(3);
/// How long another device gets to send its Genome.
const REMOTE_TIMEOUT: Duration = Duration::from_secs(20);
/// How many files the map labels by name.
const LABELED: usize = 6;
/// An import line in the map: from, to, and whether it's lit.
type MapLine = ((f32, f32), (f32, f32), bool);
/// Where the checkout a map shows is.
#[derive(Clone, Debug, PartialEq)]
enum GenomeSource {
Local(PathBuf),
/// On another device, by its connection's id: a thread's checkout there,
/// or the project's for a thread not created yet.
Remote { env: String, thread: Option<String>, project: PathBuf },
}
/// What the Genome map shows for a checkout.
enum GenomeLoad {
Loading,
/// Empryo hasn't mapped this checkout yet.
Missing,
Failed(String),
Ready(Arc<Genome>),
}
pub(super) struct GenomePanel {
source: GenomeSource,
load: GenomeLoad,
/// When the database was last written, in milliseconds since the epoch,
/// as of the last read.
read_at: Option<u64>,
reading: bool,
/// The file opened in the list, by path, so it stays open across reloads.
selected: Option<String>,
hovered: Option<usize>,
_watch: Task<()>,
}
impl Workspace {
/// Whether the open thread (or the new thread's draft) runs on Empryo,
/// here or on another device.
pub(super) fn genome_available(&self, cx: &App) -> bool {
let provider = match &self.active {
Some(session) => session.read(cx).provider,
None => self.current_settings(cx).provider,
};
provider == Provider::Empryo && self.genome_source(cx).is_some()
}
/// The checkout the open thread works in, and where it is.
fn genome_source(&self, cx: &App) -> Option<GenomeSource> {
match &self.active {
Some(session) => {
let session = session.read(cx);
Some(match &session.remote {
Some(link) => GenomeSource::Remote {
env: link.env.clone(),
thread: link.thread.clone(),
project: session.project.clone(),
},
None => GenomeSource::Local(session.cwd.clone()),
})
}
None => {
let project = self.active_project()?;
Some(match &project.environment {
Some(env) => GenomeSource::Remote { env: env.clone(), thread: None, project: project.path.clone() },
None => GenomeSource::Local(project.path.clone()),
})
}
}
}
/// Keeps the map on the open thread's checkout while it shows: a thread
/// in another checkout loads that one's.
pub(super) fn sync_genome(&mut self, cx: &mut Context<Self>) {
if !self.surface_open(Surface::Genome) || self.settings_open {
return;
}
let Some(source) = self.genome_source(cx) else { return };
if self.genome.as_ref().is_some_and(|panel| panel.source == source) {
return;
}
let watch = cx.spawn(async move |this, cx| {
loop {
cx.background_executor().timer(WATCH_EVERY).await;
let alive = this.update(cx, |this, cx| {
let Some(panel) = this.genome.as_ref() else { return };
if panel.reading || !this.surface_open(Surface::Genome) {
return;
}
// Another device answers with what changed, if anything.
let changed = match &panel.source {
GenomeSource::Local(cwd) => genome::written_at(cwd) != panel.read_at,
GenomeSource::Remote { .. } => true,
};
if changed {
this.read_genome(cx);
}
});
if alive.is_err() {
return;
}
}
});
self.genome = Some(GenomePanel {
source,
load: GenomeLoad::Loading,
read_at: None,
reading: false,
selected: None,
hovered: None,
_watch: watch,
});
self.read_genome(cx);
}
/// Reads the Genome again, in the background, or asks the device it's on.
fn read_genome(&mut self, cx: &mut Context<Self>) {
let Some(panel) = self.genome.as_ref() else { return };
let source = panel.source.clone();
let since = panel.read_at;
match source.clone() {
GenomeSource::Local(cwd) => {
let read = cx.background_executor().spawn(async move {
let written = genome::written_at(&cwd);
match genome::load(&cwd) {
Ok(genome) => GenomeAnswer { written, genome: genome.map(Box::new), ..GenomeAnswer::default() },
Err(err) => GenomeAnswer { written, error: Some(format!("{err:#}")), ..GenomeAnswer::default() },
}
});
cx.spawn(async move |this, cx| {
let answer = read.await;
let _ = this.update(cx, |this, cx| this.show_genome(&source, answer, cx));
})
.detach();
}
GenomeSource::Remote { env, thread, project } => {
let Some(client) = self.connected_client(&env) else {
// It reads again once the device is back.
if let Some(panel) = self.genome.as_mut().filter(|panel| !matches!(panel.load, GenomeLoad::Ready(_))) {
panel.load = GenomeLoad::Failed("The device this thread runs on isn't connected.".into());
cx.notify();
}
return;
};
let (request, reply) = client.request_genome(thread, project, since);
let timeout = cx.background_executor().timer(REMOTE_TIMEOUT);
cx.spawn(async move |this, cx| {
let answer = smol::future::or(async { reply.recv().await.ok() }, async {
timeout.await;
None
})
.await;
let answer = answer.unwrap_or_else(|| {
client.forget_genome(request);
GenomeAnswer {
written: since,
error: Some(
"The device didn't send its Genome. Its Vectrum Code may be too old to; update it from the sidebar's corner."
.into(),
),
..GenomeAnswer::default()
}
});
let _ = this.update(cx, |this, cx| this.show_genome(&source, answer, cx));
})
.detach();
}
}
if let Some(panel) = self.genome.as_mut() {
panel.reading = true;
}
cx.notify();
}
/// Shows what a read of `source`'s Genome found, if the map still shows it.
fn show_genome(&mut self, source: &GenomeSource, answer: GenomeAnswer, cx: &mut Context<Self>) {
let Some(panel) = self.genome.as_mut().filter(|panel| &panel.source == source) else { return };
panel.reading = false;
panel.read_at = answer.written;
if answer.unchanged {
return;
}
panel.hovered = None;
panel.load = match (answer.error, answer.genome) {
(Some(error), _) => GenomeLoad::Failed(error),
(None, Some(genome)) => GenomeLoad::Ready(Arc::new(*genome)),
(None, None) => GenomeLoad::Missing,
};
cx.notify();
}
/// Opens the Genome map in the right panel, or closes it.
pub(super) fn toggle_genome(&mut self, window: &mut Window, cx: &mut Context<Self>) {
self.toggle_surface(Surface::Genome, window, cx);
}
fn select_genome_file(&mut self, path: String, cx: &mut Context<Self>) {
if let Some(panel) = self.genome.as_mut() {
panel.selected = if panel.selected.as_deref() == Some(path.as_str()) { None } else { Some(path) };
cx.notify();
}
}
pub(super) fn render_genome_panel(&self, cx: &mut Context<Self>) -> impl IntoElement {
let p = metal::palette(cx);
let panel = self.genome.as_ref();
let reading = panel.is_some_and(|panel| panel.reading);
let genome = panel.and_then(|panel| match &panel.load {
GenomeLoad::Ready(genome) => Some(genome.clone()),
_ => None,
});
let header = h_flex()
.h(px(36.))
.pl(px(10.))
.gap(px(10.))
.child(Icon::new(Lucide::Dna).size(px(16.)).text_color(p.icon))
.child(div().flex_1().text_size(px(13.5)).font_weight(FontWeight::MEDIUM).child("Genome"))
.when_some(genome.as_ref(), |this, genome| {
this.child(metal::tag(format!("{} files · {} symbols", genome.total_files, genome.total_symbols), p))
})
.child(
MetalButton::new("reload-genome")
.ghost()
.mini()
.icon(Lucide::RotateCcw)
.tooltip(if reading { "Reading the Genome…" } else { "Read the Genome again" })
.on_click(cx.listener(|this, _, _, cx| this.read_genome(cx))),
)
.child(
MetalButton::new("close-genome")
.ghost()
.mini()
.icon(IconName::Close)
.tooltip("Close the Genome map")
.on_click(cx.listener(|this, _, _, cx| {
this.set_right_panel(None);
cx.notify();
})),
);
let body: AnyElement = match (panel.map(|panel| &panel.load), &genome) {
(_, Some(genome)) => self.render_genome(genome.clone(), p, cx).into_any_element(),
(Some(GenomeLoad::Failed(error)), _) => {
genome_message("Couldn't read the Genome", error.clone(), p).into_any_element()
}
(Some(GenomeLoad::Missing), _) => genome_message(
"No Genome here yet",
"Empryo maps a checkout when a thread starts in it. Send this thread a message and the map appears here."
.to_string(),
p,
)
.into_any_element(),
_ => genome_message("Reading the Genome…", String::new(), p).into_any_element(),
};
v_flex()
.w(px(GENOME_PANEL_WIDTH))
.flex_none()
.h_full()
.p(px(12.))
.pl(px(0.))
.child(
v_flex()
.size_full()
.p(px(6.))
.rounded(px(18.))
.raised(p)
.child(header)
.child(div().px(px(8.)).py(px(4.)).child(metal::rule(p)))
.child(body),
)
}
fn render_genome(&self, genome: Arc<Genome>, p: &Palette, cx: &mut Context<Self>) -> impl IntoElement {
let panel = self.genome.as_ref();
let selected = panel.and_then(|panel| panel.selected.clone());
let selected_ix = selected.as_ref().and_then(|path| genome.files.iter().position(|file| &file.path == path));
let hovered = panel.and_then(|panel| panel.hovered);
let focus = hovered.or(selected_ix);
let updated = panel
.and_then(|panel| panel.read_at)
.map(|millis| crate::clock::when(SystemTime::UNIX_EPOCH + Duration::from_millis(millis)));
let rows: Vec<AnyElement> = genome
.files
.iter()
.enumerate()
.map(|(ix, file)| self.render_genome_row(ix, file, selected_ix == Some(ix), p, cx).into_any_element())
.collect();
v_flex()
.flex_1()
.min_h_0()
.gap(px(6.))
.child(div().px(px(2.)).child(self.render_genome_map(genome.clone(), focus, p, cx)))
.child(
h_flex()
.px(px(10.))
.gap(px(8.))
.text_size(px(11.5))
.text_color(p.ink3)
.child(div().flex_1().child(format!(
"Top {} of {} files by rank · {} imports",
genome.files.len(),
genome.total_files,
genome.total_edges
)))
.when_some(updated, |this, updated| this.child(format!("updated {updated}"))),
)
.child(div().px(px(8.)).child(metal::rule(p)))
.child(v_flex().id("genome-files").flex_1().min_h_0().overflow_y_scroll().gap(px(1.)).children(rows))
}
/// The import graph of the top files: a dot per file, sized by rank and
/// colored by folder, with a line for each import. The file under the
/// pointer, or the one open in the list, lights up with its neighbors.
fn render_genome_map(&self, genome: Arc<Genome>, focus: Option<usize>, p: &Palette, cx: &mut Context<Self>) -> impl IntoElement {
let max_rank = genome.files.iter().map(|file| file.rank).fold(0., f64::max).max(f64::EPSILON);
let radius = |file: &GenomeFile| 4. + 10. * (file.rank / max_rank).sqrt() as f32;
let inset = 18.;
let spot = |ix: usize| {
let (x, y) = genome.layout[ix];
(inset + x * (MAP_WIDTH - 2. * inset), inset + y * (MAP_HEIGHT - 2. * inset))
};
let neighbors: Vec<usize> = focus
.map(|focus| {
genome
.edges
.iter()
.filter_map(|edge| match (edge.from == focus, edge.to == focus) {
(true, _) => Some(edge.to),
(_, true) => Some(edge.from),
_ => None,
})
.collect()
})
.unwrap_or_default();
// The import lines, painted under the dots.
let lines: Rc<Vec<MapLine>> = Rc::new(
genome
.edges
.iter()
.map(|edge| (spot(edge.from), spot(edge.to), focus.is_some_and(|focus| edge.from == focus || edge.to == focus)))
.collect(),
);
let (dim, lit) = (p.ink3.opacity(0.28), p.tints[2].opacity(0.9));
let edges = canvas(
|_, _, _| {},
move |bounds, _, window, _| {
for ((x1, y1), (x2, y2), on) in lines.iter() {
let mut path = PathBuilder::stroke(px(if *on { 1.6 } else { 1. }));
let from = bounds.origin + point(px(*x1), px(*y1));
let to = bounds.origin + point(px(*x2), px(*y2));
// A slight bend tells crossing lines apart.
let mid = point((from.x + to.x) / 2. + (to.y - from.y) * 0.12, (from.y + to.y) / 2. - (to.x - from.x) * 0.12);
path.move_to(from);
path.curve_to(to, mid);
if let Ok(path) = path.build() {
window.paint_path(path, if *on { lit } else { dim });
}
}
},
)
.absolute()
.size_full();
let dots = genome.files.iter().enumerate().map(|(ix, file)| {
let (x, y) = spot(ix);
let r = radius(file);
let color = folder_color(&file.path, p);
let on = focus == Some(ix);
let near = neighbors.contains(&ix);
let faded = focus.is_some() && !on && !near;
let path = file.path.clone();
div()
.id(SharedString::from(format!("genome-dot-{ix}")))
.absolute()
.left(px(x - r))
.top(px(y - r))
.size(px(r * 2.))
.rounded_full()
.bg(if faded { color.opacity(0.3) } else { color })
.when(on, |this| this.border_2().border_color(p.ink))
.when(near && !on, |this| this.border_1().border_color(p.tints[2]))
.cursor_pointer()
.on_hover(cx.listener(move |this, hovered: &bool, _, cx| {
if let Some(panel) = this.genome.as_mut() {
if *hovered {
panel.hovered = Some(ix);
} else if panel.hovered == Some(ix) {
panel.hovered = None;
}
cx.notify();
}
}))
.on_click(cx.listener(move |this, _, _, cx| this.select_genome_file(path.clone(), cx)))
});
// Names for the top files, and for the one in focus.
let labeled: Vec<usize> = (0..genome.files.len().min(LABELED)).chain(focus).collect();
let labels = labeled.into_iter().enumerate().filter(|(n, ix)| *n < LABELED || !(0..LABELED).contains(ix)).map(|(_, ix)| {
let file = &genome.files[ix];
let (x, y) = spot(ix);
let r = radius(file);
let name = file_name(&file.path);
let width = (name.chars().count() as f32 * 6.2 + 10.).min(160.);
// Labels stay inside the map.
let left = (x - width / 2.).clamp(2., MAP_WIDTH - width - 2.);
let below = y + r + 18. < MAP_HEIGHT;
div()
.absolute()
.left(px(left))
.top(px(if below { y + r + 2. } else { y - r - 17. }))
.w(px(width))
.flex()
.justify_center()
.child(
div()
.px(px(4.))
.rounded(px(4.))
.bg(p.page.opacity(0.75))
.text_size(px(10.5))
.font_family(metal::MONO)
.text_color(if focus == Some(ix) { p.ink } else { p.ink2 })
.truncate()
.child(name),
)
});
div()
.relative()
.w(px(MAP_WIDTH))
.h(px(MAP_HEIGHT))
.mx(px(6.))
.rounded(px(12.))
.well(p)
.overflow_hidden()
.child(edges)
.children(dots)
.children(labels)
}
fn render_genome_row(&self, ix: usize, file: &GenomeFile, open: bool, p: &Palette, cx: &mut Context<Self>) -> impl IntoElement {
let path = file.path.clone();
let (dir, name) = match file.path.rsplit_once('/') {
Some((dir, name)) => (format!("{dir}/"), name.to_string()),
None => (String::new(), file.path.clone()),
};
let row = h_flex()
.id(SharedString::from(format!("genome-file-{ix}")))
.h(px(28.))
.px(px(10.))
.gap(px(8.))
.rounded(px(8.))
.cursor_pointer()
.hover(|style| style.bg(p.row_hover))
.when(open, |this| this.bg(p.row_hover))
.on_hover(cx.listener(move |this, hovered: &bool, _, cx| {
if let Some(panel) = this.genome.as_mut() {
if *hovered {
panel.hovered = Some(ix);
} else if panel.hovered == Some(ix) {
panel.hovered = None;
}
cx.notify();
}
}))
.on_click(cx.listener(move |this, _, _, cx| this.select_genome_file(path.clone(), cx)))
.child(
div()
.w(px(18.))
.flex_none()
.text_size(px(10.5))
.font_family(metal::MONO)
.text_color(p.ink3)
.child(format!("{}", ix + 1)),
)
.child(div().size(px(8.)).flex_none().rounded_full().bg(folder_color(&file.path, p)))
.child(
h_flex()
.flex_1()
.min_w_0()
.text_size(px(12.5))
.child(div().flex_shrink(1.).min_w_0().truncate().text_color(p.ink3).child(dir))
.child(div().flex_none().text_color(p.ink).child(name)),
)
.when(file.recent, |this| this.child(metal::tag("new", p)))
.when(file.dependents > 0, |this| {
this.child(
div()
.flex_none()
.text_size(px(11.))
.font_family(metal::MONO)
.text_color(p.ink2)
.child(format!("→{}", file.dependents)),
)
});
v_flex().child(row).when(open, |this| {
this.child(
v_flex()
.pl(px(44.))
.pr(px(10.))
.pb(px(6.))
.gap(px(2.))
.child(
div().text_size(px(11.5)).text_color(p.ink3).child(format!(
"{} · {} lines · imported by {} · imports {}",
file.language, file.lines, file.dependents, file.dependencies
)),
)
.when(file.symbols.is_empty(), |this| {
this.child(div().text_size(px(12.)).text_color(p.ink3).child("No symbols"))
})
.children(file.symbols.iter().map(|symbol| {
let signature = symbol
.signature
.as_deref()
.map(|signature| signature.lines().next().unwrap_or_default().trim().to_string())
.filter(|signature| !signature.is_empty())
.unwrap_or_else(|| format!("{} {}", symbol.kind, symbol.name));
h_flex()
.gap(px(6.))
.text_size(px(11.5))
.font_family(metal::MONO)
.child(
div()
.w(px(10.))
.flex_none()
.text_color(if symbol.exported { p.green_ink } else { p.ink3 })
.child(if symbol.exported { "+" } else { " " }),
)
.child(div().flex_1().min_w_0().truncate().text_color(p.ink2).child(signature))
.child(div().flex_none().text_color(p.ink3).child(format!(":{}", symbol.line)))
}))
.when(file.symbol_count as usize > file.symbols.len(), |this| {
this.child(
div()
.text_size(px(11.5))
.text_color(p.ink3)
.child(format!("… {} more", file.symbol_count as usize - file.symbols.len())),
)
}),
)
})
}
}
fn file_name(path: &str) -> String {
path.rsplit('/').next().unwrap_or(path).to_string()
}
/// A file's color in the map: one of the palette's tints, the same for
/// every file in a folder.
fn folder_color(path: &str, p: &Palette) -> Hsla {
let folder = path.rsplit_once('/').map_or("", |(folder, _)| folder);
let hash = folder.bytes().fold(7u32, |hash, byte| hash.wrapping_mul(31).wrapping_add(byte as u32));
p.tints[hash as usize % p.tints.len()]
}
fn genome_message(title: &str, detail: String, p: &Palette) -> impl IntoElement {
v_flex()
.px(px(10.))
.py(px(10.))
.gap(px(4.))
.child(div().text_size(px(13.)).text_color(p.ink2).child(title.to_string()))
.when(!detail.is_empty(), |this| this.child(div().text_size(px(12.)).text_color(p.ink3).child(detail)))
}