feat: directed graph component

This is super naive in placement and drawing of
the splines. It hints that you can select things,
but you can't do that yet either.

Author: grampelberg

src/cli/dev/graph.rs

@@ -1,44 +1,112 @@
 use cata::{Command, Container};
 use clap::Parser;
 use eyre::Result;
-use k8s_openapi::api::core::v1::Pod;
+use futures::stream::{StreamExt, TryStreamExt};
+use k8s_openapi::api::core::v1::{ObjectReference, Pod};
 use kube::{api::ListParams, Api};
-use petgraph::dot::{Config, Dot};
+use petgraph::graph::Graph;
+use ratatui::{
+    layout::Constraint,
+    text::Text,
+    widgets::{block::Title, Borders, Paragraph},
+    Frame,
+};
+use tokio::io::AsyncReadExt;
 
-use crate::resources::ResourceGraph;
+use crate::{
+    events::{Event, Keypress},
+    resources::ResourceGraph,
+    widget::graph,
+};
 
 #[derive(Parser, Container)]
 pub struct Cmd {}
 
 #[async_trait::async_trait]
 impl Command for Cmd {
     async fn run(&self) -> Result<()> {
+        let mut term = ratatui::init();
+
         let client = kube::Client::try_default().await?;
 
         let pods = Api::<Pod>::all(client.clone())
             .list(&ListParams::default())
             .await?;
 
-        for pod in pods.items {
-            let g = pod.graph(&client).await?;
-
-            let ng = g.map(
-                |_, n| {
-                    format!(
-                        "{}/{}",
-                        n.kind
-                            .as_ref()
-                            .unwrap_or(&"unknown".to_string())
-                            .to_lowercase(),
-                        n.name.as_ref().unwrap_or(&"unknown".to_string())
-                    )
-                },
-                |_, e| e,
-            );
-
-            println!("{:#?}", Dot::with_config(&ng, &[Config::EdgeNoLabel]));
+        let graphs = futures::stream::iter(pods.items)
+            .then(|pod| {
+                let client = client.clone();
+                async move { pod.graph(&client).await }
+            })
+            .try_collect::<Vec<_>>()
+            .await?;
+
+        let mut interval = tokio::time::interval(tokio::time::Duration::from_micros(100));
+        let mut stdin = tokio::io::stdin();
+        let mut buf = Vec::new();
+        let mut i: usize = 0;
+
+        loop {
+            tokio::select! {
+                _ = stdin.read_buf(&mut buf) => {
+                    let ev = Event::from(buf.as_slice());
+                    buf.clear();
+
+                    let Some(key) = ev.key() else {
+                        continue;
+                    };
+
+                    tracing::info!("key: {:?}", key);
+
+                    match key {
+                        Keypress::Escape => break,
+                        Keypress::CursorLeft => i = i.saturating_sub(1),
+                        Keypress::CursorRight => i = i.saturating_add(1),
+                        _ => {}
+                    }
+                }
+                _ = interval.tick() => {
+                    let g = &graphs.get(i % graphs.len()).unwrap();
+
+                    term.draw(|frame| draw(frame, i, g))?;
+                }
+            }
         }
 
         Ok(())
     }
 }
+
+fn draw(frame: &mut Frame, i: usize, graph: &Graph<ObjectReference, ()>) {
+    frame.render_widget(Paragraph::new(format!("{i}")), frame.area());
+
+    let ng = graph.map(
+        |_, o| {
+            graph::Node::builder()
+                .text(Text::from(o.name.clone().unwrap_or("unknown".to_string())))
+                .borders(Borders::ALL)
+                .titles(vec![Title::default().content(
+                    o.kind
+                        .clone()
+                        .unwrap_or("unknown".to_string().to_lowercase()),
+                )])
+                .maybe_constraint(if o.kind == Some("Pod".to_string()) {
+                    Some(Constraint::Fill(0))
+                } else {
+                    None
+                })
+                .build()
+        },
+        |_, ()| 0,
+    );
+
+    let widget = graph::Directed::builder().graph(ng).build();
+
+    frame.render_stateful_widget_ref(widget, frame.area(), &mut graph::State::default());
+}
+
+impl Drop for Cmd {
+    fn drop(&mut self) {
+        ratatui::restore();
+    }
+}

src/widget.rs

@@ -1,6 +1,7 @@
 pub mod apex;
 pub mod debug;
 pub mod error;
+pub mod graph;
 pub mod input;
 pub mod loading;
 pub mod log;

src/widget/graph.rs

@@ -0,0 +1,105 @@
+mod line;
+mod node;
+mod placement;
+
+use std::collections::BTreeMap;
+
+use bon::Builder;
+use line::Line;
+pub use node::Node;
+use petgraph::graph::{Graph, NodeIndex};
+use ratatui::{
+    buffer::Buffer,
+    layout::{Position, Rect},
+    widgets::{StatefulWidgetRef, Widget, WidgetRef},
+};
+
+static PADDING: Rect = Rect {
+    x: 0,
+    y: 0,
+    width: 2,
+    height: 3,
+};
+
+type NodeTree = BTreeMap<NodeIndex, Placement>;
+
+#[derive(Debug, Builder)]
+struct Placement {
+    idx: NodeIndex,
+    rank: u16,
+    #[builder(default)]
+    pos: Rect,
+    #[builder(default)]
+    edges: Vec<Edge>,
+}
+
+#[derive(Debug)]
+struct Edge {
+    from: Position,
+    to: Position,
+}
+
+#[allow(dead_code)]
+#[derive(Default)]
+pub struct State {
+    selected: Option<NodeIndex>,
+}
+
+pub struct Directed<'a> {
+    graph: Graph<node::Node<'a>, u16>,
+    nodes: NodeTree,
+}
+
+#[bon::bon]
+impl<'a> Directed<'a> {
+    #[builder]
+    pub fn new(graph: Graph<node::Node<'a>, u16>) -> Self {
+        let mut nodes = placement::rank(&graph);
+        placement::node(&graph, PADDING, &mut nodes);
+        placement::edge(&graph, &mut nodes);
+
+        Self { graph, nodes }
+    }
+}
+
+impl Directed<'_> {
+    fn node(&self, area: Rect, buffer: &mut Buffer, _: &mut State, node: &Placement) {
+        let widget = &self.graph.raw_nodes()[node.idx.index()].weight;
+
+        let mut subview = node.pos;
+        subview.x += area.x;
+        subview.y += area.y;
+
+        if subview.x > area.width || subview.y > area.height {
+            return;
+        }
+
+        widget.render(subview, buffer);
+    }
+}
+
+impl StatefulWidgetRef for Directed<'_> {
+    type State = State;
+
+    fn render_ref(&self, area: Rect, buffer: &mut Buffer, state: &mut Self::State) {
+        self.nodes.iter().for_each(|(_, node)| {
+            self.node(area, buffer, state, node);
+        });
+
+        // The edges need to be drawn after nodes so that they can draw the connectors
+        // correctly.
+        self.nodes.iter().for_each(|(_, node)| {
+            draw_edges(area, buffer, state, node);
+        });
+    }
+}
+
+fn draw_edges(area: Rect, buffer: &mut Buffer, _: &mut State, node: &Placement) {
+    for edge in &node.edges {
+        Line::builder()
+            .from(edge.from)
+            .to(edge.to)
+            .build()
+            .render_ref(area, buffer);
+    }
+}