source_mesh_core/
application.rs1use std::fs;
2use std::io::Write;
3use std::num::NonZeroUsize;
4use std::path::PathBuf;
5
6use anyhow::Context as _;
7use anyhow::Result;
8use anyhow::ensure;
9use bon::Builder;
10use derive_new::new;
11
12use crate::analyzer_options::Options as AnalyzerOptions;
13use crate::backend::IndexSource;
14use crate::backend::RustAnalyzer;
15use crate::backend::ScipFile;
16use crate::cycle_report::file_report;
17use crate::cycle_report::folder_report;
18use crate::cycles::analyze_files;
19use crate::cycles::analyze_folders;
20use crate::export::Format;
21use crate::export::Options as ExportOptions;
22use crate::output_paths::validate_output_paths;
23use crate::scip_backend::parse_scip;
24
25pub const DEFAULT_CYCLE_LIMIT: NonZeroUsize = match NonZeroUsize::new(10_000) {
27 Some(limit) => limit,
28 None => unreachable!(),
29};
30
31#[derive(new)]
33pub struct Project {
34 path: PathBuf,
35 configuration: Option<PathBuf>,
36}
37
38pub enum Input {
40 Project(Project),
41 ScipFile(PathBuf),
42}
43
44#[derive(Builder)]
46pub struct CycleOptions {
47 #[builder(default)]
48 highlight_cycles: bool,
49 #[builder(default)]
50 fail_on_cycles: bool,
51 cycles_output: Option<PathBuf>,
52 file_cycles_output: Option<PathBuf>,
53 #[builder(default = DEFAULT_CYCLE_LIMIT)]
54 cycle_limit: NonZeroUsize,
55}
56
57#[derive(Builder)]
59pub struct Request {
60 input: Input,
61 #[builder(default = PathBuf::from("."))]
62 root: PathBuf,
63 #[builder(default = Format::Dot)]
64 format: Format,
65 output: Option<PathBuf>,
66 depth: Option<usize>,
67 #[builder(default)]
68 include_self: bool,
69 #[builder(default)]
70 group_folders: bool,
71 #[builder(default)]
72 exclude_tests: bool,
73 #[builder(default = CycleOptions::builder().build())]
74 cycles: CycleOptions,
75 save_scip: Option<PathBuf>,
76 #[builder(default = AnalyzerOptions::new(false))]
77 analyzer: AnalyzerOptions,
78}
79
80pub fn run(request: &Request, diagram_output: &mut dyn Write) -> Result<()> {
89 ensure!(
90 !matches!(request.input, Input::ScipFile(_)) || request.save_scip.is_none(),
91 "Cannot save analysis when replaying a SCIP file"
92 );
93 let input_path = match request.input {
94 Input::Project(ref project) => project.configuration.as_deref(),
95 Input::ScipFile(ref path) => Some(path.as_path()),
96 };
97 validate_output_paths(
98 &[
99 request.output.as_deref(),
100 request.save_scip.as_deref(),
101 request.cycles.cycles_output.as_deref(),
102 request.cycles.file_cycles_output.as_deref(),
103 ]
104 .into_iter()
105 .flatten()
106 .collect::<Vec<_>>(),
107 &input_path.into_iter().collect::<Vec<_>>(),
108 )?;
109 let index_source: Box<dyn IndexSource + '_> = match request.input {
110 Input::ScipFile(ref path) => Box::new(ScipFile::new(path.clone())),
111 Input::Project(ref project) => Box::new(RustAnalyzer::new(
112 &project.path,
113 project.configuration.as_deref(),
114 &request.analyzer,
115 )),
116 };
117 let index_bytes = index_source.index()?;
118 let file_graph = parse_scip(&index_bytes)?;
119 let file_graph = if request.exclude_tests {
120 file_graph.without_test_dependencies()
121 } else {
122 file_graph
123 };
124 let file_graph = file_graph.within_root(&request.root)?;
125 let folder_graph = file_graph.folders(&request.root, request.depth, request.include_self)?;
126 ensure!(
127 !folder_graph.nodes().is_empty(),
128 "No indexed Rust files under root {}",
129 request.root.display()
130 );
131 let folder_cycle_analysis = if request.cycles.highlight_cycles
132 || request.cycles.cycles_output.is_some()
133 || request.cycles.fail_on_cycles
134 {
135 Some(analyze_folders(&folder_graph)?)
136 } else {
137 None
138 };
139 let folder_report_content = request
140 .cycles
141 .cycles_output
142 .as_ref()
143 .map(|_| {
144 folder_report(
145 folder_cycle_analysis
146 .as_ref()
147 .context("Folder cycle analysis is missing")?,
148 request.cycles.cycle_limit,
149 )
150 })
151 .transpose()?;
152 let file_cycle_analysis =
153 if request.cycles.file_cycles_output.is_some() || request.cycles.fail_on_cycles {
154 Some(analyze_files(&file_graph)?)
155 } else {
156 None
157 };
158 let file_report_content = request
159 .cycles
160 .file_cycles_output
161 .as_ref()
162 .map(|_| {
163 file_report(
164 file_cycle_analysis
165 .as_ref()
166 .context("File cycle analysis is missing")?,
167 request.cycles.cycle_limit,
168 )
169 })
170 .transpose()?;
171 let mut diagram_bytes = Vec::new();
172 let exporter = request.format.exporter();
173 exporter.write_with_options(
174 &folder_graph,
175 &ExportOptions::new(
176 request.group_folders,
177 folder_cycle_analysis
178 .as_ref()
179 .filter(|_| request.cycles.highlight_cycles),
180 ),
181 &mut diagram_bytes,
182 )?;
183 if let Some(path) = request.save_scip.as_deref() {
184 fs::write(path, index_bytes)
185 .with_context(|| format!("Cannot save analysis to {}", path.display()))?;
186 }
187 if let (Some(path), Some(report)) = (request.cycles.cycles_output.as_deref(), folder_report_content) {
188 fs::write(path, report)
189 .with_context(|| format!("Cannot write folder cycle report {}", path.display()))?;
190 }
191 if let (Some(path), Some(report)) = (request.cycles.file_cycles_output.as_deref(), file_report_content) {
192 fs::write(path, report)
193 .with_context(|| format!("Cannot write file cycle report {}", path.display()))?;
194 }
195 match request.output.as_deref() {
196 Some(path) => fs::write(path, diagram_bytes)
197 .with_context(|| format!("Cannot write {}", path.display()))?,
198 None => diagram_output.write_all(&diagram_bytes)?,
199 }
200 if request.cycles.fail_on_cycles {
201 let folder_cycle_group_count = folder_cycle_analysis
202 .as_ref()
203 .context("Folder cycle analysis is missing")?
204 .group_count();
205 let file_cycle_group_count = file_cycle_analysis
206 .as_ref()
207 .context("File cycle analysis is missing")?
208 .group_count();
209 ensure!(
210 folder_cycle_group_count == 0 && file_cycle_group_count == 0,
211 "Dependency cycles found: {folder_cycle_group_count} folder cycle group(s), {file_cycle_group_count} file cycle group(s)"
212 );
213 }
214 Ok(())
215}