jutty/en
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Make edge modulation steps more consistent

Browse source
This commit is contained in:
Juno Takano 2026-01-12 14:34:55 -03:00
commit bd5d46a5d4
8 changed files with 227 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

58
src/graph.rs
View file

@ -3,6 +3,7 @@ use std::collections::HashMap;
use serde::{Serialize, Deserialize};
use crate::syntax::content;
use crate::prelude::*;
pub use {
node::Node,
edge::Edge,
@ -25,10 +26,23 @@ pub struct Graph {
pub meta: Meta,
}
#[derive(Clone)]
#[derive(Clone, Default, Debug)]
pub struct QueryResult {
pub node: Option<Node>,
pub redirect: bool,
pub exact: bool,
}
impl std::fmt::Display for QueryResult {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let meta = if self.redirect { "[redirect] " } else { "" };
let node = if let Some(n) = &self.node {
n.id.clone()
} else {
String::from("No Match")
};
write!(f, "QueryResult: {meta}{node}")
}
}
impl Graph {
@ -46,36 +60,62 @@ impl Graph {
}
}
pub fn map_lowercase_keys(&mut self) {
for key in self.nodes.keys() {
self.lowercase_keymap
.insert(key.clone().to_lowercase(), key.clone());
}
}
pub fn find_node(&self, query: &str) -> QueryResult {
let collapsed_query = query.trim().replace(" ", "");
if query == collapsed_query {
log!("Chasing candidate for query {query}");
} else {
log!(
"Chasing candidate for query {query}, collapsed {collapsed_query}"
);
}
let candidate = if let Some(exact_match) = self.nodes.get(query) {
log!("Elected exact match {exact_match}");
QueryResult {
node: Some(exact_match.clone()),
exact: true,
redirect: false,
}
} else if let Some(lower_key) =
self.lowercase_keymap.get(&collapsed_query.to_lowercase())
{
log!("Elected non-exact match through lower key {lower_key}");
QueryResult {
node: self.nodes.get(lower_key).cloned(),
redirect: true,
}
} else {
QueryResult {
node: None,
exact: false,
redirect: false,
}
} else {
log!("No candidate found");
QueryResult::default()
};
if let Some(candidate_node) = &candidate.node
&& !candidate_node.redirect.is_empty()
{
QueryResult {
node: self.find_node(&candidate_node.redirect).node,
redirect: true,
log!("Recursing: candidate is a redirect");
if let Some(recursive_match) =
self.find_node(&candidate_node.redirect).node
{
QueryResult {
node: Some(recursive_match),
exact: false,
redirect: true,
}
} else {
QueryResult::default()
}
} else {
log!("Returning candidate {candidate}");
candidate
}
}

2
src/graph/edge.rs
View file

@ -4,8 +4,6 @@ use serde::{Serialize, Deserialize};
pub struct Edge {
pub to: String,
#[serde(default)]
pub anchor: String,
#[serde(default)]
pub from: String,
#[serde(default)]
pub detached: bool,

38
src/graph/node.rs
View file

@ -1,3 +1,5 @@
use std::collections::HashMap;
use serde::{Serialize, Deserialize};
use super::edge::Edge;
@ -20,7 +22,7 @@ pub struct Node {
pub hidden: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub connections: Option<Vec<Edge>>,
pub connections: Option<HashMap<String, Edge>>,
}
impl Node {
@ -41,6 +43,40 @@ impl Node {
}
}
impl std::fmt::Display for Node {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
let mut meta = String::default();
if self.title.is_empty() {
meta.push_str("title:none");
} else {
meta.push_str(&format!("title:'{}'", self.title));
}
if self.text.is_empty() {
meta.push_str(" text:none");
} else {
meta.push_str(&format!(" text:{}l", self.text.len()));
}
if self.summary.is_empty() {
meta.push_str(" summary:none");
} else {
meta.push_str(&format!(" summary:{}", self.summary.len()));
}
if self.redirect.is_empty() {
meta.push_str(" redirect:none");
} else {
meta.push_str(&format!(" redirect:{}", self.redirect));
}
let links = self.links.len();
if links > 0 {
meta.push_str(&format!(" links:{links}"));
}
if self.hidden {
meta.push_str(" hidden");
}
write!(f, "Node: ID '{}' {meta}", self.id)
}
}
#[cfg(test)]
mod tests {
use super::*;

13
src/router/handlers/graph.rs
View file

@ -1,11 +1,13 @@
use axum::response::IntoResponse as _;
use axum::{body::Body, extract::Path, http::Response, response::Redirect};
use crate::graph::Edge;
use crate::{syntax::serial::populate_graph, router::handlers, graph::Node};
pub async fn node(Path(id): Path<String>) -> Response<Body> {
let graph = populate_graph();
let result = graph.find_node(&id);
let found = result.node.is_some();
let nodes: Vec<Node> = graph.nodes.clone().into_values().collect();
let not_found = result.node.is_none();
let node = result
@ -19,7 +21,7 @@ pub async fn node(Path(id): Path<String>) -> Response<Body> {
.into_response();
}
if result.redirect {
if found && !result.exact {
return Redirect::permanent(format!("/node/{}", node.id).as_str())
.into_response();
}
@ -27,6 +29,15 @@ pub async fn node(Path(id): Path<String>) -> Response<Body> {
let mut context = tera::Context::default();
context.insert("node", &node);
context.insert("nodes", &nodes);
context.insert(
"connections",
&node
.connections
.clone()
.unwrap_or_default()
.values()
.collect::<Vec<&Edge>>(),
);
context.insert("incoming", &graph.incoming.get(&id));
context.insert("config", &graph.meta.config);

125
src/syntax/serial.rs
View file

@ -18,18 +18,18 @@ pub fn populate_graph() -> Graph {
Err(e) => format!("Error: {e}"),
};
let graph = deserialize_graph(&Format::TOML, &toml_source);
modulate_graph(&graph)
let mut graph = deserialize_graph(&Format::TOML, &toml_source);
modulate_graph(&mut graph)
}
fn modulate_graph(in_graph: &Graph) -> Graph {
fn modulate_graph(in_graph: &mut Graph) -> Graph {
in_graph.map_lowercase_keys();
let nodes = modulate_nodes(in_graph);
let mut graph = Graph {
incoming: make_incoming(&nodes),
lowercase_keymap: map_lowercase_keys(&nodes),
nodes,
..in_graph.to_owned()
..in_graph.clone()
};
graph.parse();
@ -37,65 +37,42 @@ fn modulate_graph(in_graph: &Graph) -> Graph {
}
fn modulate_nodes(graph: &Graph) -> HashMap<String, Node> {
let old_nodes = graph.nodes.clone();
let mut nodes: HashMap<String, Node> = HashMap::default();
let in_nodes = graph.nodes.clone();
for (key, node) in old_nodes.clone() {
let mut first_pass_nodes: HashMap<String, Node> = HashMap::default();
for (key, node) in in_nodes.clone() {
let connections = node.connections.clone().unwrap_or_default();
let mut new_edges = connections.clone();
// Parse node text
let (text, tokens) = content::rich_parse(&node.text, graph);
// Modulate connections
for (i, edge) in connections.iter().enumerate() {
for (connection_key, edge) in connections {
let mut new_edge = edge.clone();
// Populate empty "from" IDs in edges with node's ID
if edge.from.is_empty() {
new_edge.from.clone_from(&key);
new_edge.from.clone_from(&connection_key);
}
// Flag detached edges
if !old_nodes.contains_key(&edge.to) {
if !in_nodes.contains_key(&edge.to) {
new_edge.detached = true;
}
if let Some(e) = new_edges.get_mut(i) {
if let Some(e) = new_edges.get_mut(&connection_key) {
*e = new_edge;
}
}
// Create connections for each link
for link in &node.links {
new_edges.push(Edge {
from: key.clone(),
to: link.clone(),
anchor: String::default(),
detached: !old_nodes.clone().contains_key(link),
});
}
// Create connections for each anchor
let parsed_anchors =
tokens.iter().filter(|t| matches!(t, Token::Anchor(_)));
let mut anchors: Vec<Anchor> = vec![];
for anchor in parsed_anchors {
if let Token::Anchor(a) = anchor {
anchors.push(*a.clone());
}
}
for anchor in anchors {
if let Some(anchor_node) = anchor.node() {
new_edges.push(Edge {
new_edges.insert(
link.clone(),
Edge {
from: key.clone(),
to: anchor_node.id,
anchor: anchor.text(),
detached: false,
});
}
to: link.clone(),
detached: !in_nodes.clone().contains_key(link),
},
);
}
// Populate empty titles with IDs
@ -131,19 +108,64 @@ fn modulate_nodes(graph: &Graph) -> HashMap<String, Node> {
node.summary.clone()
};
// Assemble new node
let new_node = Node {
id: key.clone(),
title: new_title,
summary: flatten(&summary, graph),
connections: Some(new_edges),
..node.clone()
};
first_pass_nodes.insert(key.clone(), new_node);
}
let mut second_pass_nodes: HashMap<String, Node> = HashMap::default();
for (key, node) in first_pass_nodes.clone() {
let first_pass_graph = Graph {
nodes: first_pass_nodes.clone(),
..graph.clone()
};
// Parse node text
let (text, tokens) = content::rich_parse(&node.text, &first_pass_graph);
// Create connections for each anchor
let parsed_anchors =
tokens.iter().filter(|t| matches!(t, Token::Anchor(_)));
let mut anchors: Vec<Anchor> = vec![];
for anchor in parsed_anchors {
if let Token::Anchor(a) = anchor {
anchors.push(*a.clone());
}
}
let mut new_edges = node.connections.clone().unwrap_or_default();
for anchor in anchors {
if let Some(anchor_node) = anchor.node() {
new_edges.insert(
anchor_node.id.clone(),
Edge {
from: key.clone(),
to: anchor_node.id,
detached: false,
},
);
}
}
// Assemble new node
let new_node = Node {
connections: Some(new_edges),
text,
..node.clone()
};
nodes.insert(key.clone(), new_node);
second_pass_nodes.insert(key.clone(), new_node);
}
nodes
second_pass_nodes
}
pub enum Format {
@ -183,7 +205,7 @@ fn make_incoming(nodes: &HashMap<String, Node>) -> HashMap<String, Vec<Edge>> {
for node in nodes.clone().into_values() {
let empty_vec: Vec<Edge> = vec![];
for edge in &node.connections.clone().unwrap_or_default() {
for edge in node.connections.clone().unwrap_or_default().values() {
let mut edges =
incoming.get(&edge.to.clone()).unwrap_or(&empty_vec).clone();
edges.extend_from_slice(std::slice::from_ref(edge));
@ -194,17 +216,6 @@ fn make_incoming(nodes: &HashMap<String, Node>) -> HashMap<String, Vec<Edge>> {
incoming
}
fn map_lowercase_keys(
source_map: &HashMap<String, Node>,
) -> HashMap<String, String> {
let mut out_map: HashMap<String, String> = HashMap::default();
let keys = source_map.keys();
for key in keys {
out_map.insert(key.clone().to_lowercase(), key.clone());
}
out_map
}
#[cfg(test)]
mod tests {
use super::*;
@ -220,7 +231,7 @@ mod tests {
"links": [],
"id": "JSON",
"hidden": false,
"connections": []
"connections": {}
}
},
"root_node": "JSON"