Skip to main content

rustfmt_nightly/emitter/
checkstyle.rs

1use self::xml::XmlEscaped;
2use super::*;
3use crate::rustfmt_diff::{DiffLine, Mismatch, make_diff};
4
5mod xml;
6
7#[derive(Debug, Default)]
8pub(crate) struct CheckstyleEmitter;
9
10impl Emitter for CheckstyleEmitter {
11    fn emit_header(&self, output: &mut dyn Write) -> Result<(), io::Error> {
12        writeln!(output, r#"<?xml version="1.0" encoding="utf-8"?>"#)?;
13        write!(output, r#"<checkstyle version="4.3">"#)?;
14        Ok(())
15    }
16
17    fn emit_footer(&self, output: &mut dyn Write) -> Result<(), io::Error> {
18        writeln!(output, "</checkstyle>")
19    }
20
21    fn emit_formatted_file(
22        &mut self,
23        output: &mut dyn Write,
24        FormattedFile {
25            filename,
26            original_text,
27            formatted_text,
28        }: FormattedFile<'_>,
29    ) -> Result<EmitterResult, io::Error> {
30        const CONTEXT_SIZE: usize = 0;
31        let diff = make_diff(original_text, formatted_text, CONTEXT_SIZE);
32        output_checkstyle_file(output, filename, diff)?;
33        Ok(EmitterResult::default())
34    }
35}
36
37pub(crate) fn output_checkstyle_file<T>(
38    mut writer: T,
39    filename: &FileName,
40    diff: Vec<Mismatch>,
41) -> Result<(), io::Error>
42where
43    T: Write,
44{
45    write!(writer, r#"<file name="{filename}">"#)?;
46    for mismatch in diff {
47        let begin_line = mismatch.line_number;
48        let mut current_line;
49        let mut line_counter = 0;
50        for line in mismatch.lines {
51            // Do nothing with `DiffLine::Context` and `DiffLine::Resulting`.
52            if let DiffLine::Expected(message) = line {
53                current_line = begin_line + line_counter;
54                line_counter += 1;
55                write!(
56                    writer,
57                    r#"<error line="{}" severity="warning" message="Should be `{}`" />"#,
58                    current_line,
59                    XmlEscaped(&message)
60                )?;
61            }
62        }
63    }
64    write!(writer, "</file>")?;
65    Ok(())
66}
67
68#[cfg(test)]
69mod tests {
70    use super::*;
71    use indoc::indoc;
72    use std::path::PathBuf;
73
74    #[test]
75    fn emits_empty_record_on_file_with_no_mismatches() {
76        let file_name = "src/well_formatted.rs";
77        let mut writer = Vec::new();
78        let _ = output_checkstyle_file(
79            &mut writer,
80            &FileName::Real(PathBuf::from(file_name)),
81            vec![],
82        );
83        assert_eq!(
84            &writer[..],
85            format!(r#"<file name="{file_name}"></file>"#).as_bytes()
86        );
87    }
88
89    // https://github.com/rust-lang/rustfmt/issues/1636
90    #[test]
91    fn emits_single_xml_tree_containing_all_files() {
92        let bin_file = "src/bin.rs";
93        let bin_original = indoc! {r#"
94            fn main() {
95            println!("Hello, world!");
96            }
97        "#};
98        let bin_formatted = indoc! {r#"
99            fn main() {
100                println!("Hello, world!");
101            }
102        "#};
103        let lib_file = "src/lib.rs";
104        let lib_original = indoc! {r#"
105            fn greet() {
106            println!("Greetings!");
107            }
108        "#};
109        let lib_formatted = indoc! {r#"
110            fn greet() {
111                println!("Greetings!");
112            }
113        "#};
114        let mut writer = Vec::new();
115        let mut emitter = CheckstyleEmitter::default();
116        let _ = emitter.emit_header(&mut writer);
117        let _ = emitter
118            .emit_formatted_file(
119                &mut writer,
120                FormattedFile {
121                    filename: &FileName::Real(PathBuf::from(bin_file)),
122                    original_text: bin_original,
123                    formatted_text: bin_formatted,
124                },
125            )
126            .unwrap();
127        let _ = emitter
128            .emit_formatted_file(
129                &mut writer,
130                FormattedFile {
131                    filename: &FileName::Real(PathBuf::from(lib_file)),
132                    original_text: lib_original,
133                    formatted_text: lib_formatted,
134                },
135            )
136            .unwrap();
137        let _ = emitter.emit_footer(&mut writer);
138        let exp_bin_xml = [
139            format!(r#"<file name="{}">"#, bin_file),
140            format!(
141                r#"<error line="2" severity="warning" message="Should be `{}`" />"#,
142                XmlEscaped(r#"    println!("Hello, world!");"#),
143            ),
144            String::from("</file>"),
145        ];
146        let exp_lib_xml = [
147            format!(r#"<file name="{}">"#, lib_file),
148            format!(
149                r#"<error line="2" severity="warning" message="Should be `{}`" />"#,
150                XmlEscaped(r#"    println!("Greetings!");"#),
151            ),
152            String::from("</file>"),
153        ];
154        assert_eq!(
155            String::from_utf8(writer).unwrap(),
156            [
157                r#"<?xml version="1.0" encoding="utf-8"?>"#,
158                "\n",
159                r#"<checkstyle version="4.3">"#,
160                &format!("{}{}", exp_bin_xml.join(""), exp_lib_xml.join("")),
161                "</checkstyle>\n",
162            ]
163            .join(""),
164        );
165    }
166}