1use super::*;
2use crate::rustfmt_diff::{DiffLine, Mismatch, make_diff};
3use serde::Serialize;
4use serde_json::to_writer as to_json_writer;
5
6#[derive(Debug, Default)]
7pub(crate) struct JsonEmitter {
8 mismatched_files: Vec<MismatchedFile>,
9}
10
11#[derive(Debug, Default, PartialEq, Serialize)]
12struct MismatchedBlock {
13 original_begin_line: u32,
14 original_end_line: u32,
15 expected_begin_line: u32,
16 expected_end_line: u32,
17 original: String,
18 expected: String,
19}
20
21#[derive(Debug, Default, PartialEq, Serialize)]
22struct MismatchedFile {
23 name: String,
24 mismatches: Vec<MismatchedBlock>,
25}
26
27impl Emitter for JsonEmitter {
28 fn emit_footer(&self, output: &mut dyn Write) -> Result<(), io::Error> {
29 to_json_writer(&mut *output, &self.mismatched_files)?;
30 writeln!(output)
31 }
32
33 fn emit_formatted_file(
34 &mut self,
35 _output: &mut dyn Write,
36 FormattedFile {
37 filename,
38 original_text,
39 formatted_text,
40 }: FormattedFile<'_>,
41 ) -> Result<EmitterResult, io::Error> {
42 const CONTEXT_SIZE: usize = 0;
43 let diff = make_diff(original_text, formatted_text, CONTEXT_SIZE);
44 let has_diff = !diff.is_empty();
45
46 if has_diff {
47 self.add_misformatted_file(filename, diff)?;
48 }
49
50 Ok(EmitterResult { has_diff })
51 }
52}
53
54impl JsonEmitter {
55 fn add_misformatted_file(
56 &mut self,
57 filename: &FileName,
58 diff: Vec<Mismatch>,
59 ) -> Result<(), io::Error> {
60 let mut mismatches = Vec::with_capacity(diff.len());
61 for mismatch in diff {
62 let original_begin_line = mismatch.line_number_orig;
63 let expected_begin_line = mismatch.line_number;
64 let mut original_end_line = original_begin_line;
65 let mut expected_end_line = expected_begin_line;
66 let mut original_line_counter = 0;
67 let mut expected_line_counter = 0;
68 let mut original = String::new();
69 let mut expected = String::new();
70
71 for line in mismatch.lines {
72 match line {
73 DiffLine::Expected(msg) => {
74 expected_end_line = expected_begin_line + expected_line_counter;
75 expected_line_counter += 1;
76 expected.push_str(&msg);
77 expected.push('\n');
78 }
79 DiffLine::Resulting(msg) => {
80 original_end_line = original_begin_line + original_line_counter;
81 original_line_counter += 1;
82 original.push_str(&msg);
83 original.push('\n');
84 }
85 DiffLine::Context(_) => continue,
86 }
87 }
88
89 mismatches.push(MismatchedBlock {
90 original_begin_line,
91 original_end_line,
92 expected_begin_line,
93 expected_end_line,
94 original,
95 expected,
96 });
97 }
98 self.mismatched_files.push(MismatchedFile {
99 name: format!("{filename}"),
100 mismatches,
101 });
102 Ok(())
103 }
104}
105
106#[cfg(test)]
107mod tests {
108 use super::*;
109 use indoc::indoc;
110 use std::path::PathBuf;
111
112 #[test]
113 fn expected_line_range_correct_when_single_line_split() {
114 let mut emitter = JsonEmitter {
115 mismatched_files: vec![],
116 };
117 let file = "foo/bar.rs";
118 let mismatched_file = MismatchedFile {
119 name: String::from(file),
120 mismatches: vec![MismatchedBlock {
121 original_begin_line: 79,
122 original_end_line: 79,
123 expected_begin_line: 79,
124 expected_end_line: 82,
125 original: String::from("fn Foo<T>() where T: Bar {\n"),
126 expected: String::from(indoc! {"
127 fn Foo<T>()
128 where
129 T: Bar,
130 {
131 "}),
132 }],
133 };
134 let mismatch = Mismatch {
135 line_number: 79,
136 line_number_orig: 79,
137 lines: vec![
138 DiffLine::Resulting(String::from("fn Foo<T>() where T: Bar {")),
139 DiffLine::Expected(String::from("fn Foo<T>()")),
140 DiffLine::Expected(String::from("where")),
141 DiffLine::Expected(String::from(" T: Bar,")),
142 DiffLine::Expected(String::from("{")),
143 ],
144 };
145
146 let _ = emitter
147 .add_misformatted_file(&FileName::Real(PathBuf::from(file)), vec![mismatch])
148 .unwrap();
149
150 assert_eq!(emitter.mismatched_files.len(), 1);
151 assert_eq!(emitter.mismatched_files[0], mismatched_file);
152 }
153
154 #[test]
155 fn context_lines_ignored() {
156 let mut emitter = JsonEmitter {
157 mismatched_files: vec![],
158 };
159 let file = "src/lib.rs";
160 let mismatched_file = MismatchedFile {
161 name: String::from(file),
162 mismatches: vec![MismatchedBlock {
163 original_begin_line: 5,
164 original_end_line: 5,
165 expected_begin_line: 5,
166 expected_end_line: 5,
167 original: String::from(
168 "fn foo(_x: &u64) -> Option<&(dyn::std::error::Error + 'static)> {\n",
169 ),
170 expected: String::from(
171 "fn foo(_x: &u64) -> Option<&(dyn ::std::error::Error + 'static)> {\n",
172 ),
173 }],
174 };
175 let mismatch = Mismatch {
176 line_number: 5,
177 line_number_orig: 5,
178 lines: vec![
179 DiffLine::Context(String::new()),
180 DiffLine::Resulting(String::from(
181 "fn foo(_x: &u64) -> Option<&(dyn::std::error::Error + 'static)> {",
182 )),
183 DiffLine::Context(String::new()),
184 DiffLine::Expected(String::from(
185 "fn foo(_x: &u64) -> Option<&(dyn ::std::error::Error + 'static)> {",
186 )),
187 DiffLine::Context(String::new()),
188 ],
189 };
190
191 let _ = emitter
192 .add_misformatted_file(&FileName::Real(PathBuf::from(file)), vec![mismatch])
193 .unwrap();
194
195 assert_eq!(emitter.mismatched_files.len(), 1);
196 assert_eq!(emitter.mismatched_files[0], mismatched_file);
197 }
198
199 #[test]
200 fn emits_empty_array_on_no_diffs() {
201 let mut writer = Vec::new();
202 let mut emitter = JsonEmitter::default();
203 let _ = emitter.emit_header(&mut writer);
204 let result = emitter
205 .emit_formatted_file(
206 &mut writer,
207 FormattedFile {
208 filename: &FileName::Real(PathBuf::from("src/lib.rs")),
209 original_text: "fn empty() {}\n",
210 formatted_text: "fn empty() {}\n",
211 },
212 )
213 .unwrap();
214 let _ = emitter.emit_footer(&mut writer);
215 assert_eq!(result.has_diff, false);
216 assert_eq!(&writer[..], "[]\n".as_bytes());
217 }
218
219 #[test]
220 fn emits_array_with_files_with_diffs() {
221 let file_name = "src/bin.rs";
222 let original = indoc! {r#"
223 fn main() {
224 println!("Hello, world!");
225 }
226
227 #[cfg(test)]
228 mod tests {
229 #[test]
230 fn it_works() {
231 assert_eq!(2 + 2, 4);
232 }
233 }
234 "#};
235 let formatted = indoc! {r#"
236 fn main() {
237 println!("Hello, world!");
238 }
239
240 #[cfg(test)]
241 mod tests {
242 #[test]
243 fn it_works() {
244 assert_eq!(2 + 2, 4);
245 }
246 }
247 "#};
248 let mut writer = Vec::new();
249 let mut emitter = JsonEmitter::default();
250 let _ = emitter.emit_header(&mut writer);
251 let result = emitter
252 .emit_formatted_file(
253 &mut writer,
254 FormattedFile {
255 filename: &FileName::Real(PathBuf::from(file_name)),
256 original_text: original,
257 formatted_text: formatted,
258 },
259 )
260 .unwrap();
261 let _ = emitter.emit_footer(&mut writer);
262 let exp_json = serde_json::to_string(&vec![MismatchedFile {
263 name: String::from(file_name),
264 mismatches: vec![
265 MismatchedBlock {
266 original_begin_line: 2,
267 original_end_line: 2,
268 expected_begin_line: 2,
269 expected_end_line: 2,
270 original: String::from("println!(\"Hello, world!\");\n"),
271 expected: String::from(" println!(\"Hello, world!\");\n"),
272 },
273 MismatchedBlock {
274 original_begin_line: 7,
275 original_end_line: 10,
276 expected_begin_line: 7,
277 expected_end_line: 10,
278 original: String::from(indoc! {"
279 #[test]
280 fn it_works() {
281 assert_eq!(2 + 2, 4);
282 }
283 "}),
284 expected: String::from(
285 " #[test]\n fn it_works() {\n assert_eq!(2 + 2, 4);\n }\n",
286 ),
287 },
288 ],
289 }])
290 .unwrap();
291 assert_eq!(result.has_diff, true);
292 assert_eq!(&writer[..], format!("{exp_json}\n").as_bytes());
293 }
294
295 #[test]
296 fn emits_valid_json_with_multiple_files() {
297 let bin_file = "src/bin.rs";
298 let bin_original = indoc! {r#"
299 fn main() {
300 println!("Hello, world!");
301 }
302 "#};
303 let bin_formatted = indoc! {r#"
304 fn main() {
305 println!("Hello, world!");
306 }
307 "#};
308 let lib_file = "src/lib.rs";
309 let lib_original = indoc! {r#"
310 fn greet() {
311 println!("Greetings!");
312 }
313 "#};
314 let lib_formatted = indoc! {r#"
315 fn greet() {
316 println!("Greetings!");
317 }
318 "#};
319 let mut writer = Vec::new();
320 let mut emitter = JsonEmitter::default();
321 let _ = emitter.emit_header(&mut writer);
322 let _ = emitter
323 .emit_formatted_file(
324 &mut writer,
325 FormattedFile {
326 filename: &FileName::Real(PathBuf::from(bin_file)),
327 original_text: bin_original,
328 formatted_text: bin_formatted,
329 },
330 )
331 .unwrap();
332 let _ = emitter
333 .emit_formatted_file(
334 &mut writer,
335 FormattedFile {
336 filename: &FileName::Real(PathBuf::from(lib_file)),
337 original_text: lib_original,
338 formatted_text: lib_formatted,
339 },
340 )
341 .unwrap();
342 let _ = emitter.emit_footer(&mut writer);
343 let exp_bin = MismatchedFile {
344 name: String::from(bin_file),
345 mismatches: vec![MismatchedBlock {
346 original_begin_line: 2,
347 original_end_line: 2,
348 expected_begin_line: 2,
349 expected_end_line: 2,
350 original: String::from("println!(\"Hello, world!\");\n"),
351 expected: String::from(" println!(\"Hello, world!\");\n"),
352 }],
353 };
354
355 let exp_lib = MismatchedFile {
356 name: String::from(lib_file),
357 mismatches: vec![MismatchedBlock {
358 original_begin_line: 2,
359 original_end_line: 2,
360 expected_begin_line: 2,
361 expected_end_line: 2,
362 original: String::from("println!(\"Greetings!\");\n"),
363 expected: String::from(" println!(\"Greetings!\");\n"),
364 }],
365 };
366
367 let exp_json = serde_json::to_string(&vec![exp_bin, exp_lib]).unwrap();
368 assert_eq!(&writer[..], format!("{exp_json}\n").as_bytes());
369 }
370}