src/emitter/json.rs

use super::*;
use crate::rustfmt_diff::{make_diff, DiffLine, Mismatch};
use serde::Serialize;
use serde_json::to_string as to_json_string;
use std::io::{self, Write};
use std::path::Path;

#[derive(Debug, Default)]
pub(crate) struct JsonEmitter {
    num_files: u32,
}

#[derive(Debug, Default, Serialize)]
struct MismatchedBlock {
    original_begin_line: u32,
    original_end_line: u32,
    expected_begin_line: u32,
    expected_end_line: u32,
    original: String,
    expected: String,
}

#[derive(Debug, Default, Serialize)]
struct MismatchedFile {
    name: String,
    mismatches: Vec<MismatchedBlock>,
}

impl Emitter for JsonEmitter {
    fn emit_header(&self, output: &mut dyn Write) -> Result<(), io::Error> {
        write!(output, "[")?;
        Ok(())
    }

    fn emit_footer(&self, output: &mut dyn Write) -> Result<(), io::Error> {
        write!(output, "]")?;
        Ok(())
    }

    fn emit_formatted_file(
        &mut self,
        output: &mut dyn Write,
        FormattedFile {
            filename,
            original_text,
            formatted_text,
        }: FormattedFile<'_>,
    ) -> Result<EmitterResult, io::Error> {
        const CONTEXT_SIZE: usize = 0;
        let filename = ensure_real_path(filename);
        let diff = make_diff(original_text, formatted_text, CONTEXT_SIZE);
        let has_diff = !diff.is_empty();

        if has_diff {
            output_json_file(output, filename, diff, self.num_files)?;
            self.num_files += 1;
        }

        Ok(EmitterResult { has_diff })
    }
}

fn output_json_file<T>(
    mut writer: T,
    filename: &Path,
    diff: Vec<Mismatch>,
    num_emitted_files: u32,
) -> Result<(), io::Error>
where
    T: Write,
{
    let mut mismatches = vec![];
    for mismatch in diff {
        let original_begin_line = mismatch.line_number_orig;
        let expected_begin_line = mismatch.line_number;
        let mut original_end_line = original_begin_line;
        let mut expected_end_line = expected_begin_line;
        let mut original_line_counter = 0;
        let mut expected_line_counter = 0;
        let mut original_lines = vec![];
        let mut expected_lines = vec![];

        for line in mismatch.lines {
            match line {
                DiffLine::Expected(msg) => {
                    expected_end_line = expected_begin_line + expected_line_counter;
                    expected_line_counter += 1;
                    expected_lines.push(msg)
                }
                DiffLine::Resulting(msg) => {
                    original_end_line = original_begin_line + original_line_counter;
                    original_line_counter += 1;
                    original_lines.push(msg)
                }
                DiffLine::Context(_) => continue,
            }
        }

        mismatches.push(MismatchedBlock {
            original_begin_line,
            original_end_line,
            expected_begin_line,
            expected_end_line,
            original: original_lines.join("\n"),
            expected: expected_lines.join("\n"),
        });
    }
    let json = to_json_string(&MismatchedFile {
        name: String::from(filename.to_str().unwrap()),
        mismatches,
    })?;
    let prefix = if num_emitted_files > 0 { "," } else { "" };
    write!(writer, "{}{}", prefix, &json)?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::FileName;
    use std::path::PathBuf;

    #[test]
    fn expected_line_range_correct_when_single_line_split() {
        let file = "foo/bar.rs";
        let mismatched_file = MismatchedFile {
            name: String::from(file),
            mismatches: vec![MismatchedBlock {
                original_begin_line: 79,
                original_end_line: 79,
                expected_begin_line: 79,
                expected_end_line: 82,
                original: String::from("fn Foo<T>() where T: Bar {"),
                expected: String::from("fn Foo<T>()\nwhere\n    T: Bar,\n{"),
            }],
        };
        let mismatch = Mismatch {
            line_number: 79,
            line_number_orig: 79,
            lines: vec![
                DiffLine::Resulting(String::from("fn Foo<T>() where T: Bar {")),
                DiffLine::Expected(String::from("fn Foo<T>()")),
                DiffLine::Expected(String::from("where")),
                DiffLine::Expected(String::from("    T: Bar,")),
                DiffLine::Expected(String::from("{")),
            ],
        };

        let mut writer = Vec::new();
        let exp_json = to_json_string(&mismatched_file).unwrap();
        let _ = output_json_file(&mut writer, &PathBuf::from(file), vec![mismatch], 0);
        assert_eq!(&writer[..], format!("{}", exp_json).as_bytes());
    }

    #[test]
    fn context_lines_ignored() {
        let file = "src/lib.rs";
        let mismatched_file = MismatchedFile {
            name: String::from(file),
            mismatches: vec![MismatchedBlock {
                original_begin_line: 5,
                original_end_line: 5,
                expected_begin_line: 5,
                expected_end_line: 5,
                original: String::from(
                    "fn foo(_x: &u64) -> Option<&(dyn::std::error::Error + 'static)> {",
                ),
                expected: String::from(
                    "fn foo(_x: &u64) -> Option<&(dyn ::std::error::Error + 'static)> {",
                ),
            }],
        };
        let mismatch = Mismatch {
            line_number: 5,
            line_number_orig: 5,
            lines: vec![
                DiffLine::Context(String::new()),
                DiffLine::Resulting(String::from(
                    "fn foo(_x: &u64) -> Option<&(dyn::std::error::Error + 'static)> {",
                )),
                DiffLine::Context(String::new()),
                DiffLine::Expected(String::from(
                    "fn foo(_x: &u64) -> Option<&(dyn ::std::error::Error + 'static)> {",
                )),
                DiffLine::Context(String::new()),
            ],
        };

        let mut writer = Vec::new();
        let exp_json = to_json_string(&mismatched_file).unwrap();
        let _ = output_json_file(&mut writer, &PathBuf::from(file), vec![mismatch], 0);
        assert_eq!(&writer[..], format!("{}", exp_json).as_bytes());
    }

    #[test]
    fn emits_empty_array_on_no_diffs() {
        let mut writer = Vec::new();
        let mut emitter = JsonEmitter::default();
        let _ = emitter.emit_header(&mut writer);
        let result = emitter
            .emit_formatted_file(
                &mut writer,
                FormattedFile {
                    filename: &FileName::Real(PathBuf::from("src/lib.rs")),
                    original_text: "fn empty() {}\n",
                    formatted_text: "fn empty() {}\n",
                },
            )
            .unwrap();
        let _ = emitter.emit_footer(&mut writer);
        assert_eq!(result.has_diff, false);
        assert_eq!(&writer[..], "[]".as_bytes());
    }

    #[test]
    fn emits_array_with_files_with_diffs() {
        let file_name = "src/bin.rs";
        let original = vec![
            "fn main() {",
            "println!(\"Hello, world!\");",
            "}",
            "",
            "#[cfg(test)]",
            "mod tests {",
            "#[test]",
            "fn it_works() {",
            "    assert_eq!(2 + 2, 4);",
            "}",
            "}",
        ];
        let formatted = vec![
            "fn main() {",
            "    println!(\"Hello, world!\");",
            "}",
            "",
            "#[cfg(test)]",
            "mod tests {",
            "    #[test]",
            "    fn it_works() {",
            "        assert_eq!(2 + 2, 4);",
            "    }",
            "}",
        ];
        let mut writer = Vec::new();
        let mut emitter = JsonEmitter::default();
        let _ = emitter.emit_header(&mut writer);
        let result = emitter
            .emit_formatted_file(
                &mut writer,
                FormattedFile {
                    filename: &FileName::Real(PathBuf::from(file_name)),
                    original_text: &original.join("\n"),
                    formatted_text: &formatted.join("\n"),
                },
            )
            .unwrap();
        let _ = emitter.emit_footer(&mut writer);
        let exp_json = to_json_string(&MismatchedFile {
            name: String::from(file_name),
            mismatches: vec![
                MismatchedBlock {
                    original_begin_line: 2,
                    original_end_line: 2,
                    expected_begin_line: 2,
                    expected_end_line: 2,
                    original: String::from("println!(\"Hello, world!\");"),
                    expected: String::from("    println!(\"Hello, world!\");"),
                },
                MismatchedBlock {
                    original_begin_line: 7,
                    original_end_line: 10,
                    expected_begin_line: 7,
                    expected_end_line: 10,
                    original: String::from(
                        "#[test]\nfn it_works() {\n    assert_eq!(2 + 2, 4);\n}",
                    ),
                    expected: String::from(
                        "    #[test]\n    fn it_works() {\n        assert_eq!(2 + 2, 4);\n    }",
                    ),
                },
            ],
        })
        .unwrap();
        assert_eq!(result.has_diff, true);
        assert_eq!(&writer[..], format!("[{}]", exp_json).as_bytes());
    }

    #[test]
    fn emits_valid_json_with_multiple_files() {
        let bin_file = "src/bin.rs";
        let bin_original = vec!["fn main() {", "println!(\"Hello, world!\");", "}"];
        let bin_formatted = vec!["fn main() {", "    println!(\"Hello, world!\");", "}"];
        let lib_file = "src/lib.rs";
        let lib_original = vec!["fn greet() {", "println!(\"Greetings!\");", "}"];
        let lib_formatted = vec!["fn greet() {", "    println!(\"Greetings!\");", "}"];
        let mut writer = Vec::new();
        let mut emitter = JsonEmitter::default();
        let _ = emitter.emit_header(&mut writer);
        let _ = emitter
            .emit_formatted_file(
                &mut writer,
                FormattedFile {
                    filename: &FileName::Real(PathBuf::from(bin_file)),
                    original_text: &bin_original.join("\n"),
                    formatted_text: &bin_formatted.join("\n"),
                },
            )
            .unwrap();
        let _ = emitter
            .emit_formatted_file(
                &mut writer,
                FormattedFile {
                    filename: &FileName::Real(PathBuf::from(lib_file)),
                    original_text: &lib_original.join("\n"),
                    formatted_text: &lib_formatted.join("\n"),
                },
            )
            .unwrap();
        let _ = emitter.emit_footer(&mut writer);
        let exp_bin_json = to_json_string(&MismatchedFile {
            name: String::from(bin_file),
            mismatches: vec![MismatchedBlock {
                original_begin_line: 2,
                original_end_line: 2,
                expected_begin_line: 2,
                expected_end_line: 2,
                original: String::from("println!(\"Hello, world!\");"),
                expected: String::from("    println!(\"Hello, world!\");"),
            }],
        })
        .unwrap();
        let exp_lib_json = to_json_string(&MismatchedFile {
            name: String::from(lib_file),
            mismatches: vec![MismatchedBlock {
                original_begin_line: 2,
                original_end_line: 2,
                expected_begin_line: 2,
                expected_end_line: 2,
                original: String::from("println!(\"Greetings!\");"),
                expected: String::from("    println!(\"Greetings!\");"),
            }],
        })
        .unwrap();
        assert_eq!(
            &writer[..],
            format!("[{},{}]", exp_bin_json, exp_lib_json).as_bytes()
        );
    }
}