GKaszewski/archlens
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: deepen modules, consolidate inference, delete dead code

Browse Source 
- Extract build_graph/load_config/create_renderer in presentation (393→~250 lines)
- Move module inference into ModuleName::from_path(), delete 3 scattered copies
- Move resolve_relationships/filter_external_imports into CodeGraph
- Add LanguageExtractor trait in tree-sitter adapter
- Add CodeGraph::elements_by_module(), replace 6 identical grouping loops
- Delete dead RenderDiagrams query
This commit is contained in:
Gabriel Kaszewski
2026-06-16 16:34:41 +02:00
parent dc8ecd983a
commit d28b00c697
15 changed files with 322 additions and 460 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
crates/application/src/queries/analyze_codebase.rs
View File

@@ -5,7 +5,6 @@ use rayon::prelude::*;
use archlens_domain::{
AnalysisConfig, AnalysisWarning, CodeElement, CodeGraph, DomainError, ModuleName, Relationship,
RelationshipKind,
ports::{FileDiscovery, SourceAnalyzer},
};
@@ -41,7 +40,8 @@ where
.par_iter()
.map(|file| match self.source_analyzer.analyze_file(file) {
Ok(result) => {
let module = infer_module(file.path().as_str(), root, config);
let module =
ModuleName::from_path(file.path().as_str(), root, config.module_mappings());
let elements: Vec<CodeElement> = result
.elements()
.iter()
@@ -85,149 +85,23 @@ where
warnings.extend(warns);
}
let graph = resolve_cross_file_relationships(graph);
let graph = filter_external_imports(graph, root);
let known_dirs: HashSet<String> = std::fs::read_dir(root)
.into_iter()
.flatten()
.filter_map(|e| e.ok())
.filter(|e| e.path().is_dir())
.filter_map(|e| e.file_name().into_string().ok())
.map(|s| s.to_lowercase())
.collect();
let graph = graph
.resolve_relationships()
.filter_external_imports(&known_dirs);
Ok(AnalyzeCodebaseResult { graph, warnings })
}
}
fn resolve_cross_file_relationships(graph: CodeGraph) -> CodeGraph {
use std::collections::HashMap;
let mut file_types: HashMap<String, HashSet<String>> = HashMap::new();
let mut name_modules: HashMap<&str, HashSet<Option<&str>>> = HashMap::new();
let all_type_names: HashSet<&str> = graph.elements().iter().map(|e| e.name()).collect();
for element in graph.elements() {
file_types
.entry(element.file_path().as_str().to_string())
.or_default()
.insert(element.name().to_string());
name_modules
.entry(element.name())
.or_default()
.insert(element.module().map(|m| m.as_str()));
}
let mut resolved = CodeGraph::new();
for element in graph.elements() {
resolved.add_element(element.clone());
}
for rel in graph.relationships() {
match rel.kind() {
RelationshipKind::Import => {
resolved.add_relationship(rel.clone());
}
_ => {
if !all_type_names.contains(rel.source()) || !all_type_names.contains(rel.target())
{
continue;
}
if let Some(src_file) = rel.source_file() {
let file_key = src_file.as_str().to_string();
if let Some(types_in_file) = file_types.get(&file_key)
&& types_in_file.contains(rel.target())
{
resolved.add_relationship(rel.clone());
continue;
}
}
let tgt_modules = &name_modules[rel.target()];
if tgt_modules.len() == 1 {
resolved.add_relationship(rel.clone());
}
}
}
}
resolved
}
fn filter_external_imports(graph: CodeGraph, root: &Path) -> CodeGraph {
let known_dirs: HashSet<String> = std::fs::read_dir(root)
.into_iter()
.flatten()
.filter_map(|e| e.ok())
.filter(|e| e.path().is_dir())
.filter_map(|e| e.file_name().into_string().ok())
.map(|s| s.to_lowercase())
.collect();
let module_names: HashSet<String> = graph
.modules()
.iter()
.map(|m| m.as_str().to_lowercase())
.collect();
let all_known: HashSet<&str> = known_dirs
.iter()
.map(|s| s.as_str())
.chain(module_names.iter().map(|s| s.as_str()))
.collect();
let mut filtered = CodeGraph::new();
for element in graph.elements() {
filtered.add_element(element.clone());
}
for rel in graph.relationships() {
if rel.kind() == RelationshipKind::Import {
let target_top = rel.target().split('.').next().unwrap_or("").to_lowercase();
if !all_known.contains(target_top.as_str()) {
continue;
}
}
filtered.add_relationship(rel.clone());
}
filtered
}
fn infer_module(file_path: &str, root: &Path, config: &AnalysisConfig) -> Option<ModuleName> {
let relative = if let Some(stripped) = file_path.strip_prefix(root.to_str().unwrap_or("")) {
stripped.trim_start_matches('/')
} else {
file_path
};
for (pattern, module_name) in config.module_mappings() {
if relative.starts_with(pattern) {
return ModuleName::new(module_name).ok();
}
}
let parts: Vec<&str> = relative.split('/').collect();
if parts.len() <= 1 {
return None;
}
let module_dir = if parts[0] == "crates" && parts.len() > 2 {
// workspace: crates/<crate-name>/src/...
parts[1]
} else if parts[0] == "src" && parts.len() > 2 {
// single project: src/<module>/...
parts[1]
} else if parts[0] != "src" && parts.len() > 1 {
parts[0]
} else {
return None;
};
let capitalized = module_dir
.split('-')
.map(|seg| {
if seg.is_empty() {
String::new()
} else {
format!("{}{}", seg[..1].to_uppercase(), &seg[1..])
}
})
.collect::<Vec<_>>()
.join("-");
ModuleName::new(&capitalized).ok()
}
pub struct AnalyzeCodebaseResult {
graph: CodeGraph,
warnings: Vec<AnalysisWarning>,

2
crates/application/src/queries/mod.rs
View File

@@ -1,5 +1,3 @@
mod analyze_codebase;
mod render_diagrams;
pub use analyze_codebase::{AnalyzeCodebase, AnalyzeCodebaseResult};
pub use render_diagrams::RenderDiagrams;

45
crates/application/src/queries/render_diagrams.rs
View File

@@ -1,45 +0,0 @@
use archlens_domain::{
CodeGraph, DomainError, OutputConfig,
ports::{DiagramRenderer, OutputWriter},
};
pub struct RenderDiagrams<R, W>
where
R: DiagramRenderer,
W: OutputWriter,
{
renderer: R,
writer: W,
}
impl<R, W> RenderDiagrams<R, W>
where
R: DiagramRenderer,
W: OutputWriter,
{
pub fn new(renderer: R, writer: W) -> Self {
Self { renderer, writer }
}
pub fn execute(&self, graph: &CodeGraph, config: &OutputConfig) -> Result<(), DomainError> {
if config.split_by_module() {
let overview = self.renderer.render(graph)?;
self.writer.write(&overview)?;
for module in graph.modules() {
let subgraph = graph.subgraph_by_module(&module);
let output = self.renderer.render(&subgraph)?;
self.writer.write(&output)?;
}
} else {
let output = self.renderer.render(graph)?;
self.writer.write(&output)?;
}
Ok(())
}
pub fn writer(&self) -> &W {
&self.writer
}
}

78
crates/application/tests/render_diagrams_tests.rs
View File

@@ -1,78 +0,0 @@
mod fakes;
use archlens_application::queries::RenderDiagrams;
use archlens_domain::{
CodeElement, CodeElementKind, CodeGraph, FilePath, ModuleName, OutputConfig,
};
use fakes::{FakeDiagramRenderer, FakeOutputWriter};
fn build_graph() -> CodeGraph {
let mut graph = CodeGraph::new();
graph.add_element(
CodeElement::new(
"OrderService",
CodeElementKind::Class,
FilePath::new("src/service.rs").unwrap(),
1,
)
.unwrap()
.with_module(ModuleName::new("Orders").unwrap()),
);
graph.add_element(
CodeElement::new(
"BillingService",
CodeElementKind::Class,
FilePath::new("src/billing.rs").unwrap(),
1,
)
.unwrap()
.with_module(ModuleName::new("Billing").unwrap()),
);
graph
}
#[test]
fn renders_single_diagram_and_writes_output() {
let renderer = FakeDiagramRenderer::new();
let writer = FakeOutputWriter::new();
let config = OutputConfig::default();
let use_case = RenderDiagrams::new(renderer, writer);
use_case.execute(&build_graph(), &config).unwrap();
let outputs = use_case.writer().written_outputs();
assert_eq!(outputs.len(), 1);
assert_eq!(outputs[0].files().len(), 1);
}
#[test]
fn split_mode_renders_overview_plus_per_module_diagrams() {
let renderer = FakeDiagramRenderer::new();
let writer = FakeOutputWriter::new();
let config = OutputConfig::default().with_split_by_module(true);
let graph = build_graph(); // has 2 modules: Orders, Billing
let use_case = RenderDiagrams::new(renderer, writer);
use_case.execute(&graph, &config).unwrap();
let outputs = use_case.writer().written_outputs();
// 1 overview + 2 module diagrams = 3 writes
assert_eq!(outputs.len(), 3);
}
#[test]
fn empty_graph_still_produces_output() {
let renderer = FakeDiagramRenderer::new();
let writer = FakeOutputWriter::new();
let config = OutputConfig::default();
let graph = CodeGraph::new();
let use_case = RenderDiagrams::new(renderer, writer);
use_case.execute(&graph, &config).unwrap();
let outputs = use_case.writer().written_outputs();
assert_eq!(outputs.len(), 1);
}