Skip to main content

source_mesh_core/
application.rs

1use 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
25/// Maximum number of simple cycles in each report by default.
26pub const DEFAULT_CYCLE_LIMIT: NonZeroUsize = match NonZeroUsize::new(10_000) {
27    Some(limit) => limit,
28    None => unreachable!(),
29};
30
31/// A Rust project and its optional rust-analyzer JSON configuration.
32#[derive(new)]
33pub struct Project {
34    path: PathBuf,
35    configuration: Option<PathBuf>,
36}
37
38/// Analyze a project or replay an existing SCIP index.
39pub enum Input {
40    Project(Project),
41    ScipFile(PathBuf),
42}
43
44/// Cycle highlighting, reports, and failure policy.
45#[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/// An analysis and export operation. Boolean options are disabled by default.
58#[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
80/**
81Analyze and export dependencies, writing the diagram to the supplied writer
82unless the request selects an output file.
83
84Validation, analysis, and serialization finish before any output is written.
85Cycle gating fails only after outputs have been written. File-system or writer
86failures during output can leave earlier outputs written.
87*/
88pub 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}