tests/lib.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 #[macro_use]
  12 extern crate lazy_static;
  13 #[macro_use]
  14 extern crate log;
  15 extern crate regex;
  16 extern crate rustfmt_nightly as rustfmt;
  17 extern crate term;
  18
  19 use std::collections::{HashMap, HashSet};
  20 use std::fs;
  21 use std::io::{self, BufRead, BufReader, Read};
  22 use std::iter::{Enumerate, Peekable};
  23 use std::path::{Path, PathBuf};
  24 use std::str::Chars;
  25
  26 use rustfmt::*;
  27 use rustfmt::config::{Color, Config, ReportTactic};
  28 use rustfmt::config::summary::Summary;
  29 use rustfmt::filemap::write_system_newlines;
  30 use rustfmt::rustfmt_diff::*;
  31
  32 const DIFF_CONTEXT_SIZE: usize = 3;
  33 const CONFIGURATIONS_FILE_NAME: &str = "Configurations.md";
  34
  35 // Returns a `Vec` containing `PathBuf`s of files with a rs extension in the
  36 // given path. The `recursive` argument controls if files from subdirectories
  37 // are also returned.
  38 fn get_test_files(path: &Path, recursive: bool) -> Vec<PathBuf> {
  39     let mut files = vec![];
  40     if path.is_dir() {
  41         for entry in fs::read_dir(path).expect(&format!(
  42             "Couldn't read directory {}",
  43             path.to_str().unwrap()
  44         )) {
  45             let entry = entry.expect("Couldn't get DirEntry");
  46             let path = entry.path();
  47             if path.is_dir() && recursive {
  48                 files.append(&mut get_test_files(&path, recursive));
  49             } else if path.extension().map_or(false, |f| f == "rs") {
  50                 files.push(path);
  51             }
  52         }
  53     }
  54     files
  55 }
  56
  57 fn verify_config_used(path: &Path, config_name: &str) {
  58     for entry in fs::read_dir(path).expect(&format!(
  59         "Couldn't read {} directory",
  60         path.to_str().unwrap()
  61     )) {
  62         let entry = entry.expect("Couldn't get directory entry");
  63         let path = entry.path();
  64         if path.extension().map_or(false, |f| f == "rs") {
  65             // check if "// rustfmt-<config_name>:" appears in the file.
  66             let filebuf = BufReader::new(
  67                 fs::File::open(&path).expect(&format!("Couldn't read file {}", path.display())),
  68             );
  69             assert!(
  70                 filebuf
  71                     .lines()
  72                     .map(|l| l.unwrap())
  73                     .take_while(|l| l.starts_with("//"))
  74                     .any(|l| l.starts_with(&format!("// rustfmt-{}", config_name))),
  75                 format!(
  76                     "config option file {} does not contain expected config name",
  77                     path.display()
  78                 )
  79             );
  80         }
  81     }
  82 }
  83
  84 #[test]
  85 fn verify_config_test_names() {
  86     for path in &[
  87         Path::new("tests/source/configs"),
  88         Path::new("tests/target/configs"),
  89     ] {
  90         for entry in fs::read_dir(path).expect("Couldn't read configs directory") {
  91             let entry = entry.expect("Couldn't get directory entry");
  92             let path = entry.path();
  93             if path.is_dir() {
  94                 let config_name = path.file_name().unwrap().to_str().unwrap();
  95
  96                 // Make sure that config name is used in the files in the directory.
  97                 verify_config_used(&path, config_name);
  98             }
  99         }
 100     }
 101 }
 102
 103 // This writes to the terminal using the same approach (via term::stdout or
 104 // println!) that is used by `rustfmt::rustfmt_diff::print_diff`. Writing
 105 // using only one or the other will cause the output order to differ when
 106 // `print_diff` selects the approach not used.
 107 fn write_message(msg: &str) {
 108     let mut writer = OutputWriter::new(Color::Auto);
 109     writer.writeln(&format!("{}", msg), None);
 110 }
 111
 112 // Integration tests. The files in the tests/source are formatted and compared
 113 // to their equivalent in tests/target. The target file and config can be
 114 // overridden by annotations in the source file. The input and output must match
 115 // exactly.
 116 #[test]
 117 fn system_tests() {
 118     // Get all files in the tests/source directory.
 119     let files = get_test_files(Path::new("tests/source"), true);
 120     let (_reports, count, fails) = check_files(files);
 121
 122     // Display results.
 123     println!("Ran {} system tests.", count);
 124     assert_eq!(fails, 0, "{} system tests failed", fails);
 125 }
 126
 127 // Do the same for tests/coverage-source directory
 128 // the only difference is the coverage mode
 129 #[test]
 130 fn coverage_tests() {
 131     let files = get_test_files(Path::new("tests/coverage/source"), true);
 132     let (_reports, count, fails) = check_files(files);
 133
 134     println!("Ran {} tests in coverage mode.", count);
 135     assert_eq!(fails, 0, "{} tests failed", fails);
 136 }
 137
 138 #[test]
 139 fn checkstyle_test() {
 140     let filename = "tests/writemode/source/fn-single-line.rs";
 141     let expected_filename = "tests/writemode/target/checkstyle.xml";
 142     assert_output(Path::new(filename), Path::new(expected_filename));
 143 }
 144
 145 #[test]
 146 fn modified_test() {
 147     // Test "modified" output
 148     let filename = "tests/writemode/source/modified.rs";
 149     let result = get_modified_lines(Input::File(filename.into()), &Config::default()).unwrap();
 150     assert_eq!(
 151         result.modified_lines,
 152         ModifiedLines {
 153             chunks: vec![
 154                 ModifiedChunk {
 155                     line_number_orig: 4,
 156                     lines_removed: 4,
 157                     lines: vec!["fn blah() {}".into()],
 158                 },
 159                 ModifiedChunk {
 160                     line_number_orig: 9,
 161                     lines_removed: 6,
 162                     lines: vec!["#[cfg(a, b)]".into(), "fn main() {}".into()],
 163                 },
 164             ],
 165         }
 166     );
 167 }
 168
 169 // Helper function for comparing the results of rustfmt
 170 // to a known output file generated by one of the write modes.
 171 fn assert_output(source: &Path, expected_filename: &Path) {
 172     let config = read_config(source);
 173     let (_error_summary, file_map, _report) = format_file(source, &config);
 174
 175     // Populate output by writing to a vec.
 176     let mut out = vec![];
 177     let _ = filemap::write_all_files(&file_map, &mut out, &config);
 178     let output = String::from_utf8(out).unwrap();
 179
 180     let mut expected_file = fs::File::open(&expected_filename).expect("Couldn't open target");
 181     let mut expected_text = String::new();
 182     expected_file
 183         .read_to_string(&mut expected_text)
 184         .expect("Failed reading target");
 185
 186     let compare = make_diff(&expected_text, &output, DIFF_CONTEXT_SIZE);
 187     if !compare.is_empty() {
 188         let mut failures = HashMap::new();
 189         failures.insert(source.to_owned(), compare);
 190         print_mismatches_default_message(failures);
 191         assert!(false, "Text does not match expected output");
 192     }
 193 }
 194
 195 // Idempotence tests. Files in tests/target are checked to be unaltered by
 196 // rustfmt.
 197 #[test]
 198 fn idempotence_tests() {
 199     // Get all files in the tests/target directory.
 200     let files = get_test_files(Path::new("tests/target"), true);
 201     let (_reports, count, fails) = check_files(files);
 202
 203     // Display results.
 204     println!("Ran {} idempotent tests.", count);
 205     assert_eq!(fails, 0, "{} idempotent tests failed", fails);
 206 }
 207
 208 // Run rustfmt on itself. This operation must be idempotent. We also check that
 209 // no warnings are emitted.
 210 #[test]
 211 fn self_tests() {
 212     let mut files = get_test_files(Path::new("tests"), false);
 213     let bin_directories = vec!["cargo-fmt", "git-rustfmt", "bin", "format-diff"];
 214     for dir in bin_directories {
 215         let mut path = PathBuf::from("src");
 216         path.push(dir);
 217         path.push("main.rs");
 218         files.push(path);
 219     }
 220     files.push(PathBuf::from("src/lib.rs"));
 221
 222     let (reports, count, fails) = check_files(files);
 223     let mut warnings = 0;
 224
 225     // Display results.
 226     println!("Ran {} self tests.", count);
 227     assert_eq!(fails, 0, "{} self tests failed", fails);
 228
 229     for format_report in reports {
 230         println!("{}", format_report);
 231         warnings += format_report.warning_count();
 232     }
 233
 234     assert_eq!(
 235         warnings, 0,
 236         "Rustfmt's code generated {} warnings",
 237         warnings
 238     );
 239 }
 240
 241 #[test]
 242 fn stdin_formatting_smoke_test() {
 243     let input = Input::Text("fn main () {}".to_owned());
 244     let config = Config::default();
 245     let (error_summary, file_map, _report) =
 246         format_input::<io::Stdout>(input, &config, None).unwrap();
 247     assert!(error_summary.has_no_errors());
 248     for &(ref file_name, ref text) in &file_map {
 249         if let FileName::Custom(ref file_name) = *file_name {
 250             if file_name == "stdin" {
 251                 assert_eq!(text.to_string(), "fn main() {}\n");
 252                 return;
 253             }
 254         }
 255     }
 256     panic!("no stdin");
 257 }
 258
 259 // FIXME(#1990) restore this test
 260 // #[test]
 261 // fn stdin_disable_all_formatting_test() {
 262 //     let input = String::from("fn main() { println!(\"This should not be formatted.\"); }");
 263 //     let mut child = Command::new("./target/debug/rustfmt")
 264 //         .stdin(Stdio::piped())
 265 //         .stdout(Stdio::piped())
 266 //         .arg("--config-path=./tests/config/disable_all_formatting.toml")
 267 //         .spawn()
 268 //         .expect("failed to execute child");
 269
 270 //     {
 271 //         let stdin = child.stdin.as_mut().expect("failed to get stdin");
 272 //         stdin
 273 //             .write_all(input.as_bytes())
 274 //             .expect("failed to write stdin");
 275 //     }
 276 //     let output = child.wait_with_output().expect("failed to wait on child");
 277 //     assert!(output.status.success());
 278 //     assert!(output.stderr.is_empty());
 279 //     assert_eq!(input, String::from_utf8(output.stdout).unwrap());
 280 // }
 281
 282 #[test]
 283 fn format_lines_errors_are_reported() {
 284     let long_identifier = String::from_utf8(vec![b'a'; 239]).unwrap();
 285     let input = Input::Text(format!("fn {}() {{}}", long_identifier));
 286     let config = Config::default();
 287     let (error_summary, _file_map, _report) =
 288         format_input::<io::Stdout>(input, &config, None).unwrap();
 289     assert!(error_summary.has_formatting_errors());
 290 }
 291
 292 #[test]
 293 fn format_lines_errors_are_reported_with_tabs() {
 294     let long_identifier = String::from_utf8(vec![b'a'; 97]).unwrap();
 295     let input = Input::Text(format!("fn a() {{\n\t{}\n}}", long_identifier));
 296     let config = Config::from_toml("hard_tabs = true").unwrap();
 297     let (error_summary, _file_map, _report) =
 298         format_input::<io::Stdout>(input, &config, None).unwrap();
 299     assert!(error_summary.has_formatting_errors());
 300 }
 301
 302 // For each file, run rustfmt and collect the output.
 303 // Returns the number of files checked and the number of failures.
 304 fn check_files(files: Vec<PathBuf>) -> (Vec<FormatReport>, u32, u32) {
 305     let mut count = 0;
 306     let mut fails = 0;
 307     let mut reports = vec![];
 308
 309     for file_name in files {
 310         debug!("Testing '{}'...", file_name.display());
 311
 312         match idempotent_check(&file_name) {
 313             Ok(ref report) if report.has_warnings() => {
 314                 print!("{}", report);
 315                 fails += 1;
 316             }
 317             Ok(report) => reports.push(report),
 318             Err(err) => {
 319                 if let IdempotentCheckError::Mismatch(msg) = err {
 320                     print_mismatches_default_message(msg);
 321                 }
 322                 fails += 1;
 323             }
 324         }
 325
 326         count += 1;
 327     }
 328
 329     (reports, count, fails)
 330 }
 331
 332 fn print_mismatches_default_message(result: HashMap<PathBuf, Vec<Mismatch>>) {
 333     let mut t = term::stdout().unwrap();
 334     for (file_name, diff) in result {
 335         let mismatch_msg_formatter =
 336             |line_num| format!("\nMismatch at {}:{}:", file_name.display(), line_num);
 337         print_diff(diff, &mismatch_msg_formatter, Color::Auto);
 338     }
 339
 340     t.reset().unwrap();
 341 }
 342
 343 fn print_mismatches<T: Fn(u32) -> String>(
 344     result: HashMap<PathBuf, Vec<Mismatch>>,
 345     mismatch_msg_formatter: T,
 346 ) {
 347     let mut t = term::stdout().unwrap();
 348     for (_file_name, diff) in result {
 349         print_diff(diff, &mismatch_msg_formatter, Color::Auto);
 350     }
 351
 352     t.reset().unwrap();
 353 }
 354
 355 fn read_config(filename: &Path) -> Config {
 356     let sig_comments = read_significant_comments(filename);
 357     // Look for a config file... If there is a 'config' property in the significant comments, use
 358     // that. Otherwise, if there are no significant comments at all, look for a config file with
 359     // the same name as the test file.
 360     let mut config = if !sig_comments.is_empty() {
 361         get_config(sig_comments.get("config").map(Path::new))
 362     } else {
 363         get_config(filename.with_extension("toml").file_name().map(Path::new))
 364     };
 365
 366     for (key, val) in &sig_comments {
 367         if key != "target" && key != "config" {
 368             config.override_value(key, val);
 369         }
 370     }
 371
 372     // Don't generate warnings for to-do items.
 373     config.set().report_todo(ReportTactic::Never);
 374
 375     config
 376 }
 377
 378 fn format_file<P: Into<PathBuf>>(filepath: P, config: &Config) -> (Summary, FileMap, FormatReport) {
 379     let filepath = filepath.into();
 380     let input = Input::File(filepath);
 381     format_input::<io::Stdout>(input, config, None).unwrap()
 382 }
 383
 384 pub enum IdempotentCheckError {
 385     Mismatch(HashMap<PathBuf, Vec<Mismatch>>),
 386     Parse,
 387 }
 388
 389 pub fn idempotent_check(filename: &PathBuf) -> Result<FormatReport, IdempotentCheckError> {
 390     let sig_comments = read_significant_comments(filename);
 391     let config = read_config(filename);
 392     let (error_summary, file_map, format_report) = format_file(filename, &config);
 393     if error_summary.has_parsing_errors() {
 394         return Err(IdempotentCheckError::Parse);
 395     }
 396
 397     let mut write_result = HashMap::new();
 398     for &(ref filename, ref text) in &file_map {
 399         let mut v = Vec::new();
 400         // Won't panic, as we're not doing any IO.
 401         write_system_newlines(&mut v, text, &config).unwrap();
 402         // Won't panic, we are writing correct utf8.
 403         let one_result = String::from_utf8(v).unwrap();
 404         if let FileName::Real(ref filename) = *filename {
 405             write_result.insert(filename.to_owned(), one_result);
 406         }
 407     }
 408
 409     let target = sig_comments.get("target").map(|x| &(*x)[..]);
 410
 411     handle_result(write_result, target).map(|_| format_report)
 412 }
 413
 414 // Reads test config file using the supplied (optional) file name. If there's no file name or the
 415 // file doesn't exist, just return the default config. Otherwise, the file must be read
 416 // successfully.
 417 fn get_config(config_file: Option<&Path>) -> Config {
 418     let config_file_name = match config_file {
 419         None => return Default::default(),
 420         Some(file_name) => {
 421             let mut full_path = PathBuf::from("tests/config/");
 422             full_path.push(file_name);
 423             if !full_path.exists() {
 424                 return Default::default();
 425             };
 426             full_path
 427         }
 428     };
 429
 430     let mut def_config_file = fs::File::open(config_file_name).expect("Couldn't open config");
 431     let mut def_config = String::new();
 432     def_config_file
 433         .read_to_string(&mut def_config)
 434         .expect("Couldn't read config");
 435
 436     Config::from_toml(&def_config).expect("Invalid toml")
 437 }
 438
 439 // Reads significant comments of the form: // rustfmt-key: value
 440 // into a hash map.
 441 fn read_significant_comments(file_name: &Path) -> HashMap<String, String> {
 442     let file =
 443         fs::File::open(file_name).expect(&format!("Couldn't read file {}", file_name.display()));
 444     let reader = BufReader::new(file);
 445     let pattern = r"^\s*//\s*rustfmt-([^:]+):\s*(\S+)";
 446     let regex = regex::Regex::new(pattern).expect("Failed creating pattern 1");
 447
 448     // Matches lines containing significant comments or whitespace.
 449     let line_regex = regex::Regex::new(r"(^\s*$)|(^\s*//\s*rustfmt-[^:]+:\s*\S+)")
 450         .expect("Failed creating pattern 2");
 451
 452     reader
 453         .lines()
 454         .map(|line| line.expect("Failed getting line"))
 455         .take_while(|line| line_regex.is_match(line))
 456         .filter_map(|line| {
 457             regex.captures_iter(&line).next().map(|capture| {
 458                 (
 459                     capture
 460                         .get(1)
 461                         .expect("Couldn't unwrap capture")
 462                         .as_str()
 463                         .to_owned(),
 464                     capture
 465                         .get(2)
 466                         .expect("Couldn't unwrap capture")
 467                         .as_str()
 468                         .to_owned(),
 469                 )
 470             })
 471         })
 472         .collect()
 473 }
 474
 475 // Compare output to input.
 476 // TODO: needs a better name, more explanation.
 477 fn handle_result(
 478     result: HashMap<PathBuf, String>,
 479     target: Option<&str>,
 480 ) -> Result<(), IdempotentCheckError> {
 481     let mut failures = HashMap::new();
 482
 483     for (file_name, fmt_text) in result {
 484         // If file is in tests/source, compare to file with same name in tests/target.
 485         let target = get_target(&file_name, target);
 486         let open_error = format!("Couldn't open target {:?}", &target);
 487         let mut f = fs::File::open(&target).expect(&open_error);
 488
 489         let mut text = String::new();
 490         let read_error = format!("Failed reading target {:?}", &target);
 491         f.read_to_string(&mut text).expect(&read_error);
 492
 493         // Ignore LF and CRLF difference for Windows.
 494         if !string_eq_ignore_newline_repr(&fmt_text, &text) {
 495             let diff = make_diff(&text, &fmt_text, DIFF_CONTEXT_SIZE);
 496             assert!(
 497                 !diff.is_empty(),
 498                 "Empty diff? Maybe due to a missing a newline at the end of a file?"
 499             );
 500             failures.insert(file_name, diff);
 501         }
 502     }
 503
 504     if failures.is_empty() {
 505         Ok(())
 506     } else {
 507         Err(IdempotentCheckError::Mismatch(failures))
 508     }
 509 }
 510
 511 // Map source file paths to their target paths.
 512 fn get_target(file_name: &Path, target: Option<&str>) -> PathBuf {
 513     if let Some(n) = file_name
 514         .components()
 515         .position(|c| c.as_os_str() == "source")
 516     {
 517         let mut target_file_name = PathBuf::new();
 518         for (i, c) in file_name.components().enumerate() {
 519             if i == n {
 520                 target_file_name.push("target");
 521             } else {
 522                 target_file_name.push(c.as_os_str());
 523             }
 524         }
 525         if let Some(replace_name) = target {
 526             target_file_name.with_file_name(replace_name)
 527         } else {
 528             target_file_name
 529         }
 530     } else {
 531         // This is either and idempotence check or a self check
 532         file_name.to_owned()
 533     }
 534 }
 535
 536 #[test]
 537 fn rustfmt_diff_make_diff_tests() {
 538     let diff = make_diff("a\nb\nc\nd", "a\ne\nc\nd", 3);
 539     assert_eq!(
 540         diff,
 541         vec![
 542             Mismatch {
 543                 line_number: 1,
 544                 line_number_orig: 1,
 545                 lines: vec![
 546                     DiffLine::Context("a".into()),
 547                     DiffLine::Resulting("b".into()),
 548                     DiffLine::Expected("e".into()),
 549                     DiffLine::Context("c".into()),
 550                     DiffLine::Context("d".into()),
 551                 ],
 552             },
 553         ]
 554     );
 555 }
 556
 557 #[test]
 558 fn rustfmt_diff_no_diff_test() {
 559     let diff = make_diff("a\nb\nc\nd", "a\nb\nc\nd", 3);
 560     assert_eq!(diff, vec![]);
 561 }
 562
 563 // Compare strings without distinguishing between CRLF and LF
 564 fn string_eq_ignore_newline_repr(left: &str, right: &str) -> bool {
 565     let left = CharsIgnoreNewlineRepr(left.chars().peekable());
 566     let right = CharsIgnoreNewlineRepr(right.chars().peekable());
 567     left.eq(right)
 568 }
 569
 570 struct CharsIgnoreNewlineRepr<'a>(Peekable<Chars<'a>>);
 571
 572 impl<'a> Iterator for CharsIgnoreNewlineRepr<'a> {
 573     type Item = char;
 574     fn next(&mut self) -> Option<char> {
 575         self.0.next().map(|c| {
 576             if c == '\r' {
 577                 if *self.0.peek().unwrap_or(&'\0') == '\n' {
 578                     self.0.next();
 579                     '\n'
 580                 } else {
 581                     '\r'
 582                 }
 583             } else {
 584                 c
 585             }
 586         })
 587     }
 588 }
 589
 590 #[test]
 591 fn string_eq_ignore_newline_repr_test() {
 592     assert!(string_eq_ignore_newline_repr("", ""));
 593     assert!(!string_eq_ignore_newline_repr("", "abc"));
 594     assert!(!string_eq_ignore_newline_repr("abc", ""));
 595     assert!(string_eq_ignore_newline_repr("a\nb\nc\rd", "a\nb\r\nc\rd"));
 596     assert!(string_eq_ignore_newline_repr("a\r\n\r\n\r\nb", "a\n\n\nb"));
 597     assert!(!string_eq_ignore_newline_repr("a\r\nbcd", "a\nbcdefghijk"));
 598 }
 599
 600 // This enum is used to represent one of three text features in Configurations.md: a block of code
 601 // with its starting line number, the name of a rustfmt configuration option, or the value of a
 602 // rustfmt configuration option.
 603 enum ConfigurationSection {
 604     CodeBlock((String, u32)), // (String: block of code, u32: line number of code block start)
 605     ConfigName(String),
 606     ConfigValue(String),
 607 }
 608
 609 impl ConfigurationSection {
 610     fn get_section<I: Iterator<Item = String>>(
 611         file: &mut Enumerate<I>,
 612     ) -> Option<ConfigurationSection> {
 613         lazy_static! {
 614             static ref CONFIG_NAME_REGEX: regex::Regex =
 615                 regex::Regex::new(r"^## `([^`]+)`").expect("Failed creating configuration pattern");
 616             static ref CONFIG_VALUE_REGEX: regex::Regex = regex::Regex::new(r#"^#### `"?([^`"]+)"?`"#)
 617                 .expect("Failed creating configuration value pattern");
 618         }
 619
 620         loop {
 621             match file.next() {
 622                 Some((i, line)) => {
 623                     if line.starts_with("```rust") {
 624                         // Get the lines of the code block.
 625                         let lines: Vec<String> = file.map(|(_i, l)| l)
 626                             .take_while(|l| !l.starts_with("```"))
 627                             .collect();
 628                         let block = format!("{}\n", lines.join("\n"));
 629
 630                         // +1 to translate to one-based indexing
 631                         // +1 to get to first line of code (line after "```")
 632                         let start_line = (i + 2) as u32;
 633
 634                         return Some(ConfigurationSection::CodeBlock((block, start_line)));
 635                     } else if let Some(c) = CONFIG_NAME_REGEX.captures(&line) {
 636                         return Some(ConfigurationSection::ConfigName(String::from(&c[1])));
 637                     } else if let Some(c) = CONFIG_VALUE_REGEX.captures(&line) {
 638                         return Some(ConfigurationSection::ConfigValue(String::from(&c[1])));
 639                     }
 640                 }
 641                 None => return None, // reached the end of the file
 642             }
 643         }
 644     }
 645 }
 646
 647 // This struct stores the information about code blocks in the configurations
 648 // file, formats the code blocks, and prints formatting errors.
 649 struct ConfigCodeBlock {
 650     config_name: Option<String>,
 651     config_value: Option<String>,
 652     code_block: Option<String>,
 653     code_block_start: Option<u32>,
 654 }
 655
 656 impl ConfigCodeBlock {
 657     fn new() -> ConfigCodeBlock {
 658         ConfigCodeBlock {
 659             config_name: None,
 660             config_value: None,
 661             code_block: None,
 662             code_block_start: None,
 663         }
 664     }
 665
 666     fn set_config_name(&mut self, name: Option<String>) {
 667         self.config_name = name;
 668         self.config_value = None;
 669     }
 670
 671     fn set_config_value(&mut self, value: Option<String>) {
 672         self.config_value = value;
 673     }
 674
 675     fn set_code_block(&mut self, code_block: String, code_block_start: u32) {
 676         self.code_block = Some(code_block);
 677         self.code_block_start = Some(code_block_start);
 678     }
 679
 680     fn get_block_config(&self) -> Config {
 681         let mut config = Config::default();
 682         if self.config_value.is_some() && self.config_value.is_some() {
 683             config.override_value(
 684                 self.config_name.as_ref().unwrap(),
 685                 self.config_value.as_ref().unwrap(),
 686             );
 687         }
 688         config
 689     }
 690
 691     fn code_block_valid(&self) -> bool {
 692         // We never expect to not have a code block.
 693         assert!(self.code_block.is_some() && self.code_block_start.is_some());
 694
 695         // See if code block begins with #![rustfmt_skip].
 696         let fmt_skip = self.code_block
 697             .as_ref()
 698             .unwrap()
 699             .split('\n')
 700             .nth(0)
 701             .unwrap_or("") == "#![rustfmt_skip]";
 702
 703         if self.config_name.is_none() && !fmt_skip {
 704             write_message(&format!(
 705                 "No configuration name for {}:{}",
 706                 CONFIGURATIONS_FILE_NAME,
 707                 self.code_block_start.unwrap()
 708             ));
 709             return false;
 710         }
 711         if self.config_value.is_none() && !fmt_skip {
 712             write_message(&format!(
 713                 "No configuration value for {}:{}",
 714                 CONFIGURATIONS_FILE_NAME,
 715                 self.code_block_start.unwrap()
 716             ));
 717             return false;
 718         }
 719         true
 720     }
 721
 722     fn has_parsing_errors(&self, error_summary: Summary) -> bool {
 723         if error_summary.has_parsing_errors() {
 724             write_message(&format!(
 725                 "\u{261d}\u{1f3fd} Cannot format {}:{}",
 726                 CONFIGURATIONS_FILE_NAME,
 727                 self.code_block_start.unwrap()
 728             ));
 729             return true;
 730         }
 731
 732         false
 733     }
 734
 735     fn print_diff(&self, compare: Vec<Mismatch>) {
 736         let mut mismatches = HashMap::new();
 737         mismatches.insert(PathBuf::from(CONFIGURATIONS_FILE_NAME), compare);
 738         print_mismatches(mismatches, |line_num| {
 739             format!(
 740                 "\nMismatch at {}:{}:",
 741                 CONFIGURATIONS_FILE_NAME,
 742                 line_num + self.code_block_start.unwrap() - 1
 743             )
 744         });
 745     }
 746
 747     fn formatted_has_diff(&self, file_map: &FileMap) -> bool {
 748         let &(ref _file_name, ref text) = file_map.first().unwrap();
 749         let compare = make_diff(self.code_block.as_ref().unwrap(), text, DIFF_CONTEXT_SIZE);
 750         if !compare.is_empty() {
 751             self.print_diff(compare);
 752             return true;
 753         }
 754
 755         false
 756     }
 757
 758     // Return a bool indicating if formatting this code block is an idempotent
 759     // operation. This function also triggers printing any formatting failure
 760     // messages.
 761     fn formatted_is_idempotent(&self) -> bool {
 762         // Verify that we have all of the expected information.
 763         if !self.code_block_valid() {
 764             return false;
 765         }
 766
 767         let input = Input::Text(self.code_block.as_ref().unwrap().to_owned());
 768         let config = self.get_block_config();
 769
 770         let (error_summary, file_map, _report) =
 771             format_input::<io::Stdout>(input, &config, None).unwrap();
 772
 773         !self.has_parsing_errors(error_summary) && !self.formatted_has_diff(&file_map)
 774     }
 775
 776     // Extract a code block from the iterator. Behavior:
 777     // - Rust code blocks are identifed by lines beginning with "```rust".
 778     // - One explicit configuration setting is supported per code block.
 779     // - Rust code blocks with no configuration setting are illegal and cause an
 780     //   assertion failure, unless the snippet begins with #![rustfmt_skip].
 781     // - Configuration names in Configurations.md must be in the form of
 782     //   "## `NAME`".
 783     // - Configuration values in Configurations.md must be in the form of
 784     //   "#### `VALUE`".
 785     fn extract<I: Iterator<Item = String>>(
 786         file: &mut Enumerate<I>,
 787         prev: Option<&ConfigCodeBlock>,
 788         hash_set: &mut HashSet<String>,
 789     ) -> Option<ConfigCodeBlock> {
 790         let mut code_block = ConfigCodeBlock::new();
 791         code_block.config_name = prev.and_then(|cb| cb.config_name.clone());
 792
 793         loop {
 794             match ConfigurationSection::get_section(file) {
 795                 Some(ConfigurationSection::CodeBlock((block, start_line))) => {
 796                     code_block.set_code_block(block, start_line);
 797                     break;
 798                 }
 799                 Some(ConfigurationSection::ConfigName(name)) => {
 800                     assert!(
 801                         Config::is_valid_name(&name),
 802                         "an unknown configuration option was found: {}",
 803                         name
 804                     );
 805                     assert!(
 806                         hash_set.remove(&name),
 807                         "multiple configuration guides found for option {}",
 808                         name
 809                     );
 810                     code_block.set_config_name(Some(name));
 811                 }
 812                 Some(ConfigurationSection::ConfigValue(value)) => {
 813                     code_block.set_config_value(Some(value));
 814                 }
 815                 None => return None, // end of file was reached
 816             }
 817         }
 818
 819         Some(code_block)
 820     }
 821 }
 822
 823 #[test]
 824 fn configuration_snippet_tests() {
 825     // Read Configurations.md and build a `Vec` of `ConfigCodeBlock` structs with one
 826     // entry for each Rust code block found.
 827     fn get_code_blocks() -> Vec<ConfigCodeBlock> {
 828         let mut file_iter = BufReader::new(
 829             fs::File::open(Path::new(CONFIGURATIONS_FILE_NAME))
 830                 .expect(&format!("Couldn't read file {}", CONFIGURATIONS_FILE_NAME)),
 831         ).lines()
 832             .map(|l| l.unwrap())
 833             .enumerate();
 834         let mut code_blocks: Vec<ConfigCodeBlock> = Vec::new();
 835         let mut hash_set = Config::hash_set();
 836
 837         while let Some(cb) =
 838             ConfigCodeBlock::extract(&mut file_iter, code_blocks.last(), &mut hash_set)
 839         {
 840             code_blocks.push(cb);
 841         }
 842
 843         for name in hash_set {
 844             if !Config::is_hidden_option(&name) {
 845                 panic!("{} does not have a configuration guide", name);
 846             }
 847         }
 848
 849         code_blocks
 850     }
 851
 852     let blocks = get_code_blocks();
 853     let failures = blocks
 854         .iter()
 855         .map(|b| b.formatted_is_idempotent())
 856         .fold(0, |acc, r| acc + (!r as u32));
 857
 858     // Display results.
 859     println!("Ran {} configurations tests.", blocks.len());
 860     assert_eq!(failures, 0, "{} configurations tests failed", failures);
 861 }