use std::collections::HashMap;
use crate::NamespaceMetadata;
pub fn build_namespace_map() -> HashMap<&'static str, &'static str> {
let mut namespace_map = HashMap::new();
for ns in inventory::iter::<NamespaceMetadata> {
namespace_map.insert(ns.module_path, ns.prefix);
}
namespace_map
}
pub fn resolve_namespace_path(
handler_module_path: &str,
handler_path: &str,
namespace_map: &HashMap<&'static str, &'static str>,
) -> String {
let module_parts: Vec<&str> = handler_module_path.split("::").collect();
for i in (0..=module_parts.len()).rev() {
let parent_path = module_parts[..i].join("::");
if let Some(prefix) = namespace_map.get(parent_path.as_str()) {
return format!("{}{}", prefix, handler_path);
}
}
handler_path.to_string()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn resolve_with_exact_module_match() {
let mut map = HashMap::new();
map.insert("myapp::api::users", "/api");
let result = resolve_namespace_path("myapp::api::users", "/create", &map);
assert_eq!(result, "/api/create");
}
#[test]
fn resolve_with_parent_module_match() {
let mut map = HashMap::new();
map.insert("myapp::api", "/api");
let result = resolve_namespace_path("myapp::api::users", "/create", &map);
assert_eq!(result, "/api/create");
}
#[test]
fn resolve_without_match_returns_original() {
let map = HashMap::new();
let result = resolve_namespace_path("myapp::other", "/create", &map);
assert_eq!(result, "/create");
}
#[test]
fn resolve_prefers_most_specific_match() {
let mut map = HashMap::new();
map.insert("myapp", "/root");
map.insert("myapp::api", "/api");
let result = resolve_namespace_path("myapp::api::users", "/create", &map);
assert_eq!(result, "/api/create");
}
}
pub fn module_path_to_ts_name(module_path: &str, type_name: &str) -> String {
let parts: Vec<&str> = module_path.split("::").collect();
let middle: Vec<&str> = parts
.iter()
.skip(1) .copied()
.filter(|p| *p != type_name) .collect();
if middle.is_empty() {
let crate_root = parts.first().copied().unwrap_or("");
let pascal_crate = crate_root
.split('_')
.map(|word| {
let mut c = word.chars();
match c.next() {
None => String::new(),
Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
}
})
.collect::<String>();
return format!("{}{}", pascal_crate, type_name);
}
let mut name_parts: Vec<String> = middle
.iter()
.map(|p| {
let mut c = p.chars();
match c.next() {
None => String::new(),
Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
}
})
.collect();
name_parts.push(type_name.to_string());
name_parts.join("")
}
pub fn resolve_type_ref(
type_ref: &str,
referencing_module: &str,
candidates_by_name: &HashMap<&'static str, Vec<(String, &'static str)>>,
) -> Option<String> {
let candidates = candidates_by_name.get(type_ref)?;
if candidates.len() == 1 {
return Some(candidates[0].0.clone());
}
fn shared_prefix_len(a: &str, b: &str) -> usize {
a.split("::")
.zip(b.split("::"))
.take_while(|(x, y)| x == y)
.count()
}
candidates
.iter()
.max_by_key(|(_, mod_path)| {
(
shared_prefix_len(referencing_module, mod_path),
mod_path.to_string(),
)
})
.map(|(ts_name, _)| ts_name.clone())
}
#[cfg(test)]
mod schema_resolution_tests {
use super::*;
#[test]
fn module_path_to_ts_name_with_middle_segments() {
assert_eq!(
module_path_to_ts_name("myapp::entities::user", "User"),
"EntitiesUser"
);
assert_eq!(
module_path_to_ts_name("myapp::types::user", "User"),
"TypesUser"
);
}
#[test]
fn module_path_to_ts_name_without_middle_segments() {
assert_eq!(module_path_to_ts_name("myapp::User", "User"), "MyappUser");
assert_eq!(module_path_to_ts_name("my_app::User", "User"), "MyAppUser");
}
#[test]
fn resolve_type_ref_with_single_candidate() {
let mut candidates = HashMap::new();
candidates.insert("User", vec![("UserSchema".to_string(), "myapp::types")]);
let result = resolve_type_ref("User", "myapp::api", &candidates);
assert_eq!(result, Some("UserSchema".to_string()));
}
#[test]
fn resolve_type_ref_prefers_same_module() {
let mut candidates = HashMap::new();
candidates.insert(
"User",
vec![
("TypesUserSchema".to_string(), "myapp::types"),
("EntitiesUserSchema".to_string(), "myapp::entities"),
],
);
let result = resolve_type_ref("User", "myapp::entities::profile", &candidates);
assert_eq!(result, Some("EntitiesUserSchema".to_string()));
}
#[test]
fn resolve_type_ref_returns_none_for_unknown() {
let candidates = HashMap::new();
let result = resolve_type_ref("Unknown", "myapp::api", &candidates);
assert_eq!(result, None);
}
}