Skip to main content

rustfmt_nightly/emitter/
json.rs

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}