use crate::graph::Graph;
use crate::graph::identity::NodeKey;
use crate::types::ClassificationScheme;
const BNODE_PREFIX: &str = "urn:mere:bnode:";
impl Graph {
pub fn node_display_label(&self, key: NodeKey) -> String {
let Some(node) = self.get_node(key) else {
return String::new();
};
let url = node.url();
let title = node.title.trim();
if !title.is_empty() && title != url && host_of(url).as_deref() != Some(title) {
return title.to_string();
}
if let Some(stripped) = url.strip_prefix(BNODE_PREFIX) {
self.incoming_role(key)
.or_else(|| first_type_term(self, key))
.unwrap_or_else(|| short_blank_id(stripped))
} else {
url_filename(url)
.or_else(|| first_type_term(self, key))
.unwrap_or_else(|| scheme_stripped(url))
}
}
pub fn node_display_caption(&self, key: NodeKey) -> String {
let label = self.node_display_label(key);
let host = self.get_node(key).and_then(|node| host_of(node.url()));
match host {
Some(host) if !label.contains(&host) => format!("{label} \u{00b7} {host}"),
_ => label,
}
}
fn incoming_role(&self, key: NodeKey) -> Option<String> {
for (_, _, payload) in self.projected_incoming_relations(key) {
let Some(sem) = payload.semantic_data() else {
continue;
};
let iri = sem
.statements()
.iter()
.map(|statement| statement.predicate.clone())
.next()
.or_else(|| {
sem.predicate.clone().or_else(|| {
sem.sub_kinds
.iter()
.next()
.map(|&sk| super::predicate_iri(sk).to_string())
})
})?;
let term = iri_term(&iri);
if term.is_empty() || term == "hyperlink" || term == "references" {
continue;
}
return Some(humanize_term(term));
}
None
}
}
fn first_type_term(graph: &Graph, key: NodeKey) -> Option<String> {
graph
.node_classifications(key)?
.iter()
.find(|c| {
c.status.is_affirmative()
&& matches!(&c.scheme, ClassificationScheme::Custom(s) if s == "rdf:type")
})
.map(|c| humanize_term(iri_term(&c.value)))
.filter(|t| !t.is_empty())
}
fn iri_term(iri: &str) -> &str {
iri.rsplit(['#', '/']).next().unwrap_or(iri)
}
fn humanize_term(term: &str) -> String {
let mut out = String::with_capacity(term.len() + 4);
let mut prev_alnum = false;
for ch in term.chars() {
if ch == '-' || ch == '_' {
if prev_alnum {
out.push(' ');
}
prev_alnum = false;
continue;
}
if ch.is_uppercase() && prev_alnum && !out.ends_with(' ') {
out.push(' ');
}
out.push(ch);
prev_alnum = ch.is_alphanumeric() && !ch.is_uppercase();
}
out.trim().to_string()
}
fn url_filename(url: &str) -> Option<String> {
let parsed = url::Url::parse(url).ok()?;
let last = parsed
.path_segments()?
.filter(|s| !s.is_empty())
.next_back()?;
let dot = last.rfind('.')?;
if dot > 0 && dot + 1 < last.len() {
Some(last.to_string())
} else {
None
}
}
fn host_of(url: &str) -> Option<String> {
url::Url::parse(url).ok()?.host_str().map(str::to_string)
}
fn short_blank_id(stripped: &str) -> String {
let label = stripped
.split_once(':')
.map(|(_, rest)| rest)
.unwrap_or(stripped);
format!("node {label}")
}
fn scheme_stripped(url: &str) -> String {
let body = url.split_once("://").map(|(_, rest)| rest).unwrap_or(url);
body.chars().take(48).collect()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::{
ClassificationProvenance, ClassificationScheme, ClassificationStatus, NodeClassification,
};
use euclid::default::Point2D;
use uuid::Uuid;
fn rdf_type(iri: &str) -> NodeClassification {
NodeClassification {
scheme: ClassificationScheme::Custom("rdf:type".to_string()),
value: iri.to_string(),
label: None,
confidence: 1.0,
provenance: ClassificationProvenance::Imported,
status: ClassificationStatus::Imported,
primary: false,
}
}
fn add(graph: &mut Graph, url: &str) -> NodeKey {
graph.add_node_with_id(
Graph::node_namespace_id(url),
url.to_string(),
Point2D::zero(),
)
}
#[test]
fn real_title_wins_for_any_node() {
let mut g = Graph::new();
let page = add(&mut g, "https://ex.test/article");
g.get_node_mut(page).unwrap().title = "Rust (programming language)".to_string();
assert_eq!(g.node_display_label(page), "Rust (programming language)");
}
#[test]
fn anonymous_entity_falls_to_incoming_role_then_type() {
let mut g = Graph::new();
let page = add(&mut g, "https://ex.test/article");
let publisher = add(&mut g, "urn:mere:bnode:deadbeefdeadbeef:_:b0");
g.add_node_classification(publisher, rdf_type("https://schema.org/Organization"));
g.assert_semantic_predicate(page, publisher, "https://schema.org/publisher".to_string());
assert_eq!(g.node_display_label(publisher), "publisher");
let author = add(&mut g, "urn:mere:bnode:deadbeefdeadbeef:_:b1");
g.add_node_classification(author, rdf_type("https://schema.org/ImageObject"));
assert_eq!(g.node_display_label(author), "Image Object");
}
#[test]
fn anonymous_entity_with_a_name_uses_the_name() {
let mut g = Graph::new();
let page = add(&mut g, "https://ex.test/article");
let publisher = add(&mut g, "urn:mere:bnode:deadbeefdeadbeef:_:b0");
g.get_node_mut(publisher).unwrap().title = "Wikimedia Foundation".to_string();
g.assert_semantic_predicate(page, publisher, "https://schema.org/publisher".to_string());
assert_eq!(g.node_display_label(publisher), "Wikimedia Foundation");
}
#[test]
fn type_display_uses_affirmative_statuses_and_retains_review_records() {
for (status, displayed) in [
(ClassificationStatus::Accepted, true),
(ClassificationStatus::Verified, true),
(ClassificationStatus::Imported, true),
(ClassificationStatus::Suggested, false),
(ClassificationStatus::Rejected, false),
] {
let mut graph = Graph::new();
let key = add(&mut graph, "urn:mere:bnode:deadbeefdeadbeef:_:b0");
let mut record = rdf_type("https://schema.org/ImageObject");
record.status = status;
assert!(graph.add_node_classification(key, record.clone()));
assert_eq!(
graph.node_display_label(key),
if displayed {
"Image Object"
} else {
"node _:b0"
},
"{record:?}"
);
assert_eq!(graph.node_classifications(key).unwrap(), vec![record]);
}
}
#[test]
fn image_resource_uses_its_filename() {
let mut g = Graph::new();
let img = add(&mut g, "https://upload.example.test/wiki/Rust_logo.svg");
assert_eq!(g.node_display_label(img), "Rust_logo.svg");
}
#[test]
fn untitled_page_is_named_by_its_address_not_its_host() {
let mut g = Graph::new();
let url = "https://en.wikipedia.org/wiki/Rust";
let page = add(&mut g, url);
assert_eq!(
g.node_display_label(page),
"en.wikipedia.org/wiki/Rust"
);
g.get_node_mut(page).unwrap().title = "en.wikipedia.org".to_string();
assert_eq!(
g.node_display_label(page),
"en.wikipedia.org/wiki/Rust"
);
}
#[test]
fn caption_adds_the_host_only_when_the_label_lacks_it() {
let mut g = Graph::new();
let page = add(&mut g, "https://ex.test/article");
g.get_node_mut(page).unwrap().title = "Article".to_string();
assert_eq!(g.node_display_caption(page), "Article \u{00b7} ex.test");
let bare = add(&mut g, "https://ex.test/other");
assert_eq!(g.node_display_caption(bare), g.node_display_label(bare));
}
#[test]
fn anonymous_with_nothing_known_gets_a_short_id() {
let mut g = Graph::new();
let blank = add(&mut g, "urn:mere:bnode:deadbeefdeadbeef:_:b7");
assert_eq!(g.node_display_label(blank), "node _:b7");
}
}