fallow_cli/report/
json.rs

1use std::process::ExitCode;
2use std::time::Duration;
3
4use fallow_core::duplicates::DuplicationReport;
5use fallow_core::results::AnalysisResults;
6
7pub(super) fn print_json(results: &AnalysisResults, elapsed: Duration) -> ExitCode {
8    match build_json(results, elapsed) {
9        Ok(output) => match serde_json::to_string_pretty(&output) {
10            Ok(json) => {
11                println!("{json}");
12                ExitCode::SUCCESS
13            }
14            Err(e) => {
15                eprintln!("Error: failed to serialize JSON output: {e}");
16                ExitCode::from(2)
17            }
18        },
19        Err(e) => {
20            eprintln!("Error: failed to serialize results: {e}");
21            ExitCode::from(2)
22        }
23    }
24}
25
26/// JSON output schema version as an integer (independent of tool version).
27///
28/// Bump this when the structure of the JSON output changes in a
29/// backwards-incompatible way (removing/renaming fields, changing types).
30/// Adding new fields is always backwards-compatible and does not require a bump.
31const SCHEMA_VERSION: u32 = 1;
32
33/// Build the JSON output value for analysis results.
34///
35/// Metadata fields (`schema_version`, `version`, `elapsed_ms`, `total_issues`)
36/// appear first in the output for readability.
37pub fn build_json(
38    results: &AnalysisResults,
39    elapsed: Duration,
40) -> Result<serde_json::Value, serde_json::Error> {
41    let results_value = serde_json::to_value(results)?;
42
43    let mut map = serde_json::Map::new();
44    map.insert(
45        "schema_version".to_string(),
46        serde_json::json!(SCHEMA_VERSION),
47    );
48    map.insert(
49        "version".to_string(),
50        serde_json::json!(env!("CARGO_PKG_VERSION")),
51    );
52    map.insert(
53        "elapsed_ms".to_string(),
54        serde_json::json!(elapsed.as_millis()),
55    );
56    map.insert(
57        "total_issues".to_string(),
58        serde_json::json!(results.total_issues()),
59    );
60
61    if let serde_json::Value::Object(results_map) = results_value {
62        for (key, value) in results_map {
63            map.insert(key, value);
64        }
65    }
66
67    Ok(serde_json::Value::Object(map))
68}
69
70pub(super) fn print_duplication_json(report: &DuplicationReport, elapsed: Duration) -> ExitCode {
71    let report_value = match serde_json::to_value(report) {
72        Ok(v) => v,
73        Err(e) => {
74            eprintln!("Error: failed to serialize duplication report: {e}");
75            return ExitCode::from(2);
76        }
77    };
78
79    // Metadata fields first, then report data
80    let mut map = serde_json::Map::new();
81    map.insert(
82        "schema_version".to_string(),
83        serde_json::json!(SCHEMA_VERSION),
84    );
85    map.insert(
86        "version".to_string(),
87        serde_json::json!(env!("CARGO_PKG_VERSION")),
88    );
89    map.insert(
90        "elapsed_ms".to_string(),
91        serde_json::json!(elapsed.as_millis()),
92    );
93    if let serde_json::Value::Object(report_map) = report_value {
94        for (key, value) in report_map {
95            map.insert(key, value);
96        }
97    }
98    let output = serde_json::Value::Object(map);
99
100    match serde_json::to_string_pretty(&output) {
101        Ok(json) => {
102            println!("{json}");
103            ExitCode::SUCCESS
104        }
105        Err(e) => {
106            eprintln!("Error: failed to serialize JSON output: {e}");
107            ExitCode::from(2)
108        }
109    }
110}
111
112pub(super) fn print_trace_json<T: serde::Serialize>(value: &T) {
113    match serde_json::to_string_pretty(value) {
114        Ok(json) => println!("{json}"),
115        Err(e) => {
116            eprintln!("Error: failed to serialize trace output: {e}");
117            std::process::exit(2);
118        }
119    }
120}
121
122#[cfg(test)]
123mod tests {
124    use super::*;
125    use fallow_core::extract::MemberKind;
126    use fallow_core::results::*;
127    use std::path::{Path, PathBuf};
128    use std::time::Duration;
129
130    /// Helper: build an `AnalysisResults` populated with one issue of every type.
131    fn sample_results(root: &Path) -> AnalysisResults {
132        let mut r = AnalysisResults::default();
133
134        r.unused_files.push(UnusedFile {
135            path: root.join("src/dead.ts"),
136        });
137        r.unused_exports.push(UnusedExport {
138            path: root.join("src/utils.ts"),
139            export_name: "helperFn".to_string(),
140            is_type_only: false,
141            line: 10,
142            col: 4,
143            span_start: 120,
144            is_re_export: false,
145        });
146        r.unused_types.push(UnusedExport {
147            path: root.join("src/types.ts"),
148            export_name: "OldType".to_string(),
149            is_type_only: true,
150            line: 5,
151            col: 0,
152            span_start: 60,
153            is_re_export: false,
154        });
155        r.unused_dependencies.push(UnusedDependency {
156            package_name: "lodash".to_string(),
157            location: DependencyLocation::Dependencies,
158            path: root.join("package.json"),
159        });
160        r.unused_dev_dependencies.push(UnusedDependency {
161            package_name: "jest".to_string(),
162            location: DependencyLocation::DevDependencies,
163            path: root.join("package.json"),
164        });
165        r.unused_enum_members.push(UnusedMember {
166            path: root.join("src/enums.ts"),
167            parent_name: "Status".to_string(),
168            member_name: "Deprecated".to_string(),
169            kind: MemberKind::EnumMember,
170            line: 8,
171            col: 2,
172        });
173        r.unused_class_members.push(UnusedMember {
174            path: root.join("src/service.ts"),
175            parent_name: "UserService".to_string(),
176            member_name: "legacyMethod".to_string(),
177            kind: MemberKind::ClassMethod,
178            line: 42,
179            col: 4,
180        });
181        r.unresolved_imports.push(UnresolvedImport {
182            path: root.join("src/app.ts"),
183            specifier: "./missing-module".to_string(),
184            line: 3,
185            col: 0,
186        });
187        r.unlisted_dependencies.push(UnlistedDependency {
188            package_name: "chalk".to_string(),
189            imported_from: vec![root.join("src/cli.ts")],
190        });
191        r.duplicate_exports.push(DuplicateExport {
192            export_name: "Config".to_string(),
193            locations: vec![root.join("src/config.ts"), root.join("src/types.ts")],
194        });
195        r.circular_dependencies.push(CircularDependency {
196            files: vec![root.join("src/a.ts"), root.join("src/b.ts")],
197            length: 2,
198        });
199
200        r
201    }
202
203    #[test]
204    fn json_output_has_metadata_fields() {
205        let results = AnalysisResults::default();
206        let elapsed = Duration::from_millis(123);
207        let output = build_json(&results, elapsed).expect("should serialize");
208
209        assert_eq!(output["schema_version"], 1);
210        assert!(output["version"].is_string());
211        assert_eq!(output["elapsed_ms"], 123);
212        assert_eq!(output["total_issues"], 0);
213    }
214
215    #[test]
216    fn json_output_includes_issue_arrays() {
217        let root = PathBuf::from("/project");
218        let results = sample_results(&root);
219        let elapsed = Duration::from_millis(50);
220        let output = build_json(&results, elapsed).expect("should serialize");
221
222        assert!(output["unused_files"].is_array());
223        assert!(output["unused_exports"].is_array());
224        assert!(output["unused_types"].is_array());
225        assert!(output["unused_dependencies"].is_array());
226        assert!(output["unused_dev_dependencies"].is_array());
227        assert!(output["unused_enum_members"].is_array());
228        assert!(output["unused_class_members"].is_array());
229        assert!(output["unresolved_imports"].is_array());
230        assert!(output["unlisted_dependencies"].is_array());
231        assert!(output["duplicate_exports"].is_array());
232        assert!(output["type_only_dependencies"].is_array());
233    }
234
235    #[test]
236    fn json_metadata_fields_appear_first() {
237        let results = AnalysisResults::default();
238        let elapsed = Duration::from_millis(0);
239        let output = build_json(&results, elapsed).expect("should serialize");
240        let keys: Vec<&String> = output.as_object().unwrap().keys().collect();
241        assert_eq!(keys[0], "schema_version");
242        assert_eq!(keys[1], "version");
243        assert_eq!(keys[2], "elapsed_ms");
244        assert_eq!(keys[3], "total_issues");
245    }
246
247    #[test]
248    fn json_total_issues_matches_results() {
249        let root = PathBuf::from("/project");
250        let results = sample_results(&root);
251        let total = results.total_issues();
252        let elapsed = Duration::from_millis(0);
253        let output = build_json(&results, elapsed).expect("should serialize");
254
255        assert_eq!(output["total_issues"], total);
256    }
257
258    #[test]
259    fn json_unused_export_contains_expected_fields() {
260        let mut results = AnalysisResults::default();
261        results.unused_exports.push(UnusedExport {
262            path: PathBuf::from("/project/src/utils.ts"),
263            export_name: "helperFn".to_string(),
264            is_type_only: false,
265            line: 10,
266            col: 4,
267            span_start: 120,
268            is_re_export: false,
269        });
270        let elapsed = Duration::from_millis(0);
271        let output = build_json(&results, elapsed).expect("should serialize");
272
273        let export = &output["unused_exports"][0];
274        assert_eq!(export["export_name"], "helperFn");
275        assert_eq!(export["line"], 10);
276        assert_eq!(export["col"], 4);
277        assert_eq!(export["is_type_only"], false);
278        assert_eq!(export["span_start"], 120);
279        assert_eq!(export["is_re_export"], false);
280    }
281
282    #[test]
283    fn json_serializes_to_valid_json() {
284        let root = PathBuf::from("/project");
285        let results = sample_results(&root);
286        let elapsed = Duration::from_millis(42);
287        let output = build_json(&results, elapsed).expect("should serialize");
288
289        let json_str = serde_json::to_string_pretty(&output).expect("should stringify");
290        let reparsed: serde_json::Value =
291            serde_json::from_str(&json_str).expect("JSON output should be valid JSON");
292        assert_eq!(reparsed, output);
293    }
294}
fallow_cli/report/json.rs

fallow_cli/report/
json.rs
