use serde_json::json;
pub fn format_search_results(context: &serde_json::Value) -> String {
let mut output = String::from("# Search Results\n\n");
if let Some(entities) = context.as_array() {
for entity in entities {
output.push_str(&format_entity(entity));
}
} else if let Some(obj) = context.as_object() {
output.push_str(&format_entity(&json!(obj)));
}
if output.is_empty() || output == "# Search Results\n\n" {
output.push_str("No results found.");
}
output
}
pub(crate) fn format_entity(entity: &serde_json::Value) -> String {
let mut output = String::new();
if let Some(name) = entity.get("name").and_then(|v| v.as_str()) {
let repo_suffix = entity
.get("repo_name")
.and_then(|v| v.as_str())
.map(|r| format!(" (repo: {r})"))
.unwrap_or_default();
if let Some(kind) = entity.get("kind").and_then(|v| v.as_str()) {
output.push_str(&format!("## `{}` ({}){}\n\n", name, kind, repo_suffix));
} else {
output.push_str(&format!("## `{}`{}\n\n", name, repo_suffix));
}
}
if let Some(file_path) = entity.get("file_path").and_then(|v| v.as_str()) {
output.push_str(&format!("**File:** `{}`\n\n", file_path));
}
if let Some(fqn) = entity.get("fqn").and_then(|v| v.as_str()) {
let name = entity.get("name").and_then(|v| v.as_str()).unwrap_or("");
if fqn != name && !fqn.is_empty() {
output.push_str(&format!("**FQN:** `{}`\n\n", fqn));
}
}
if let Some(signature) = entity.get("signature").and_then(|v| v.as_str()) {
output.push_str(&format!("**Signature:**\n```\n{}\n```\n\n", signature));
}
if let Some(docstring) = entity
.get("docstring")
.and_then(|v| v.as_str())
.filter(|s| !s.trim().is_empty())
{
output.push_str(&format!("**Documentation:**\n{}\n\n", docstring));
}
output.push_str(&format_string_list(
entity,
"subclasses",
"**Subclasses (extends):**",
));
output.push_str(&format_string_list(
entity,
"implementers",
"**Implementers:**",
));
append_count_summary(
entity,
("type_usage_count", "type_usage_samples"),
"**Type Usage:** Referenced in",
"Sample usages",
&mut output,
);
append_count_summary(
entity,
("caller_count", "caller_samples"),
"**Called by:**",
"Sample callers",
&mut output,
);
append_count_summary(
entity,
("dispatched_caller_count", "dispatched_caller_samples"),
"**Called via dispatch:**",
"Sample dispatched callers",
&mut output,
);
output.push_str(&format_string_list(entity, "dependencies", "**Calls:**"));
output
}
fn format_string_list(entity: &serde_json::Value, key: &str, title: &str) -> String {
let Some(items) = entity
.get(key)
.and_then(|v| v.as_array())
.filter(|d| !d.is_empty())
else {
return String::new();
};
let mut section = format!("{title}\n");
for item in items {
if let Some(name) = item.as_str() {
section.push_str(&format!("- `{name}`\n"));
}
}
section.push('\n');
section
}
fn append_count_summary(
entity: &serde_json::Value,
keys: (&str, &str),
title: &str,
samples_header: &str,
output: &mut String,
) {
let (count_key, samples_key) = keys;
let Some(count) = entity.get(count_key).and_then(|v| v.as_i64()) else {
return;
};
output.push_str(&format!("{title} {count} location(s)\n"));
append_samples(entity, samples_key, samples_header, count, output);
output.push('\n');
}
fn append_samples(
entity: &serde_json::Value,
key: &str,
header: &str,
total: i64,
output: &mut String,
) {
let Some(samples) = entity
.get(key)
.and_then(|v| v.as_array())
.filter(|s| !s.is_empty())
else {
return;
};
let shown = samples.len() as i64;
if shown < total {
output.push_str(&format!(
"{header} — showing {shown} of {total} (truncated):\n"
));
} else {
output.push_str(&format!("{header}:\n"));
}
for sample in samples {
if let Some(s) = sample.as_str() {
output.push_str(&format!("- {s}\n"));
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_format_search_results_empty_array() {
let results = json!([]);
let formatted = format_search_results(&results);
assert!(formatted.contains("No results found"));
}
#[test]
fn test_format_search_results_empty_string() {
let results = json!("# Search Results\n\n");
let formatted = format_search_results(&results);
assert!(formatted.contains("No results found"));
}
#[test]
fn test_format_entity_with_name_and_kind() {
let entity = json!({
"name": "MyClass",
"kind": "class"
});
let formatted = format_entity(&entity);
assert!(formatted.contains("MyClass"));
assert!(formatted.contains("class"));
}
#[test]
fn test_format_entity_with_file_path() {
let entity = json!({
"name": "MyClass",
"kind": "class",
"file_path": "src/main/MyClass.java"
});
let formatted = format_entity(&entity);
assert!(formatted.contains("src/main/MyClass.java"));
assert!(formatted.contains("**File:**"));
}
#[test]
fn test_format_entity_with_signature() {
let entity = json!({
"name": "myMethod",
"kind": "method",
"signature": "public void myMethod(String param)"
});
let formatted = format_entity(&entity);
assert!(formatted.contains("public void myMethod(String param)"));
assert!(formatted.contains("**Signature:**"));
}
#[test]
fn test_format_entity_with_docstring() {
let entity = json!({
"name": "MyClass",
"kind": "class",
"docstring": "This is a test class\nwith multiple lines"
});
let formatted = format_entity(&entity);
assert!(formatted.contains("This is a test class"));
assert!(formatted.contains("**Documentation:**"));
}
#[test]
fn test_format_entity_ignores_empty_docstring() {
let entity = json!({
"name": "MyClass",
"kind": "class",
"docstring": " \n "
});
let formatted = format_entity(&entity);
assert!(!formatted.contains("**Documentation:**"));
}
#[test]
fn test_format_entity_with_subclasses() {
let entity = json!({
"name": "BaseClass",
"kind": "class",
"subclasses": ["ChildClass1", "ChildClass2"]
});
let formatted = format_entity(&entity);
assert!(formatted.contains("**Subclasses (extends):**"));
assert!(formatted.contains("ChildClass1"));
assert!(formatted.contains("ChildClass2"));
}
#[test]
fn test_format_entity_ignores_empty_subclasses() {
let entity = json!({
"name": "BaseClass",
"kind": "class",
"subclasses": []
});
let formatted = format_entity(&entity);
assert!(!formatted.contains("**Subclasses"));
}
#[test]
fn test_format_entity_with_implementers() {
let entity = json!({
"name": "MyInterface",
"kind": "interface",
"implementers": ["Impl1", "Impl2", "Impl3"]
});
let formatted = format_entity(&entity);
assert!(formatted.contains("**Implementers:**"));
assert!(formatted.contains("Impl1"));
assert!(formatted.contains("Impl2"));
assert!(formatted.contains("Impl3"));
}
#[test]
fn test_format_entity_with_type_usage() {
let entity = json!({
"name": "MyClass",
"kind": "class",
"type_usage_count": 5,
"type_usage_samples": ["usage1 in file1.java", "usage2 in file2.java"]
});
let formatted = format_entity(&entity);
assert!(formatted.contains("**Type Usage:** Referenced in 5 location(s)"));
assert!(formatted.contains("Sample usages — showing 2 of 5 (truncated):"));
assert!(formatted.contains("usage1 in file1.java"));
}
#[test]
fn test_format_entity_ignores_empty_usage_samples() {
let entity = json!({
"name": "MyClass",
"kind": "class",
"type_usage_count": 5,
"type_usage_samples": []
});
let formatted = format_entity(&entity);
assert!(formatted.contains("**Type Usage:** Referenced in 5 location(s)"));
assert!(!formatted.contains("Sample usages:"));
}
#[test]
fn test_format_entity_with_callers() {
let entity = json!({
"name": "myMethod",
"kind": "method",
"caller_count": 3,
"caller_samples": ["caller1 in file1.java", "caller2 in file2.java"]
});
let formatted = format_entity(&entity);
assert!(formatted.contains("**Called by:** 3 location(s)"));
assert!(formatted.contains("Sample callers — showing 2 of 3 (truncated):"));
assert!(formatted.contains("caller1 in file1.java"));
}
#[test]
fn test_format_entity_with_dispatched_callers() {
let entity = json!({
"name": "persist",
"kind": "method",
"dispatched_caller_count": 1,
"dispatched_caller_samples": ["archiveViaConcreteType in ReceiptClient.java"]
});
let formatted = format_entity(&entity);
assert!(formatted.contains("**Called via dispatch:** 1 location(s)"));
assert!(formatted.contains("Sample dispatched callers:"));
assert!(formatted.contains("archiveViaConcreteType in ReceiptClient.java"));
assert!(!formatted.contains("**Called by:**"));
}
#[test]
fn test_format_entity_caller_sample_covering_everything_has_no_notice() {
let entity = json!({
"name": "myMethod",
"kind": "method",
"caller_count": 2,
"caller_samples": ["caller1 in file1.java", "caller2 in file2.java"]
});
let formatted = format_entity(&entity);
assert!(formatted.contains("Sample callers:"));
assert!(!formatted.contains("truncated"));
}
#[test]
fn test_format_entity_many_callers_quantifies_sample() {
let entity = json!({
"name": "delete",
"kind": "method",
"caller_count": 21,
"caller_samples": [
"caller1 in a.java", "caller2 in b.java", "caller3 in c.java"
]
});
let formatted = format_entity(&entity);
assert!(formatted.contains("**Called by:** 21 location(s)"));
assert!(formatted.contains("Sample callers — showing 3 of 21 (truncated):"));
}
#[test]
fn test_format_entity_type_usage_quantifies_sample() {
let entity = json!({
"name": "MyClass",
"kind": "class",
"type_usage_count": 21,
"type_usage_samples": ["u1 in f1.java"]
});
let formatted = format_entity(&entity);
assert!(formatted.contains("Sample usages — showing 1 of 21 (truncated):"));
}
#[test]
fn test_format_entity_with_dependencies() {
let entity = json!({
"name": "myMethod",
"kind": "method",
"dependencies": ["dep1", "dep2", "dep3"]
});
let formatted = format_entity(&entity);
assert!(formatted.contains("**Calls:**"));
assert!(formatted.contains("dep1"));
assert!(formatted.contains("dep2"));
}
#[test]
fn test_format_entity_ignores_empty_dependencies() {
let entity = json!({
"name": "myMethod",
"kind": "method",
"dependencies": []
});
let formatted = format_entity(&entity);
assert!(!formatted.contains("**Calls:**"));
}
#[test]
fn test_format_search_results_multiple_entities() {
let results = json!([
{"name": "Class1", "kind": "class", "file_path": "file1.java"},
{"name": "Class2", "kind": "class", "file_path": "file2.java"}
]);
let formatted = format_search_results(&results);
assert!(formatted.contains("Class1"));
assert!(formatted.contains("Class2"));
assert!(formatted.contains("file1.java"));
assert!(formatted.contains("file2.java"));
}
#[test]
fn test_format_entity_without_kind() {
let entity = json!({
"name": "UnknownEntity"
});
let formatted = format_entity(&entity);
assert!(formatted.contains("UnknownEntity"));
assert!(!formatted.contains("UnknownEntity ()"));
}
}