use std::collections::{HashMap, HashSet};
use treebank::node_types::NodeTypes;
use treebank::roles::RolesManifest;
use crate::role::{Role, RoleSet};
#[derive(Debug, Clone, Default)]
pub struct RoleTable {
by_kind: HashMap<String, RoleSet>,
unknown_terms: Vec<String>,
}
impl RoleTable {
pub fn from_manifests(node_types: &str, roles: &str) -> Result<RoleTable, String> {
let node_types =
NodeTypes::parse(node_types).map_err(|error| format!("node-types.json: {error}"))?;
let roles = RolesManifest::parse(roles).map_err(|error| format!("roles.json: {error}"))?;
let mut table = RoleTable::default();
let mut unknown = HashSet::new();
for supertype in node_types.supertypes.keys() {
let Some(role) = Role::from_term(supertype) else {
unknown.insert(supertype.clone());
continue;
};
for kind in node_types.closure(supertype) {
if kind == *supertype {
continue;
}
table.merge(&kind, RoleSet::of(role));
}
}
for (term, members) in &roles.facets {
let Some(role) = Role::from_term(term) else {
unknown.insert(term.clone());
continue;
};
for kind in members {
table.merge(kind, RoleSet::of(role));
}
}
table.unknown_terms = unknown.into_iter().collect();
table.unknown_terms.sort();
Ok(table)
}
fn merge(&mut self, kind: &str, roles: RoleSet) {
let entry = self.by_kind.entry(kind.to_string()).or_default();
for role in roles.iter() {
*entry = entry.with(role);
}
}
pub fn roles(&self, kind: &str) -> RoleSet {
self.by_kind.get(kind).copied().unwrap_or_default()
}
pub fn unknown_terms(&self) -> &[String] {
&self.unknown_terms
}
pub fn len(&self) -> usize {
self.by_kind.len()
}
pub fn is_empty(&self) -> bool {
self.by_kind.is_empty()
}
}
#[cfg(test)]
mod tests {
use super::RoleTable;
use crate::role::Role;
const UNNAMED_SUBTYPE: &str = r#"[
{"type": "_member", "named": true, "subtypes": [
{"type": "field_declaration", "named": true},
{"type": ";", "named": false}
]},
{"type": "field_declaration", "named": true},
{"type": ";", "named": false}
]"#;
const NO_FACETS: &str = r#"{"vocabulary": "test", "facets": {}}"#;
#[test]
fn an_unnamed_subtype_is_not_a_member() {
let table = RoleTable::from_manifests(UNNAMED_SUBTYPE, NO_FACETS).expect("manifests parse");
assert!(
table.roles(";").is_empty(),
"an anonymous token carries no role"
);
assert!(table.roles("field_declaration").contains(Role::Member));
}
const NESTED: &str = r#"[
{"type": "_statement", "named": true, "subtypes": [{"type": "_loop", "named": true}]},
{"type": "_loop", "named": true, "subtypes": [{"type": "while_statement", "named": true}]},
{"type": "while_statement", "named": true}
]"#;
#[test]
fn membership_is_transitive_through_nested_supertypes() {
let table = RoleTable::from_manifests(NESTED, NO_FACETS).expect("manifests parse");
let roles = table.roles("while_statement");
assert!(roles.contains(Role::Loop));
assert!(roles.contains(Role::Statement));
}
#[test]
fn an_abstract_supertype_is_not_a_kind_of_its_own() {
let table = RoleTable::from_manifests(NESTED, NO_FACETS).expect("manifests parse");
assert!(table.roles("_statement").is_empty());
assert!(table.roles("_loop").contains(Role::Statement));
}
#[test]
fn a_term_the_vocabulary_does_not_know_is_reported() {
let unknown = r#"[
{"type": "_nonsense", "named": true, "subtypes": [{"type": "x", "named": true}]},
{"type": "x", "named": true}
]"#;
let table = RoleTable::from_manifests(unknown, NO_FACETS).expect("manifests parse");
assert_eq!(table.unknown_terms(), &["_nonsense".to_string()]);
assert!(table.roles("x").is_empty());
}
#[test]
fn facet_membership_arrives_from_the_roles_manifest() {
let facets = r#"{"vocabulary": "test", "facets": {"_callable": ["lambda"]}}"#;
let table = RoleTable::from_manifests(NESTED, facets).expect("manifests parse");
assert!(table.roles("lambda").contains(Role::Callable));
}
}