Enabled formatting with rustfmt via -f flag

Also added a way to see result of `cargo check` if it fails with `-v`
flag

Author: Emilgardis

ci/svd2rust-regress/src/errors.rs

@@ -1 +1,9 @@
-error_chain!{}
+use std::path;
+error_chain!{
+    errors {
+        ProcessFailed(command: String, stderr: Option<path::PathBuf>, stdout: Option<path::PathBuf>) {
+            description("Process Failed")
+            display("Process Failed - {}", command)
+        }
+    }
+}

ci/svd2rust-regress/src/main.rs

@@ -6,16 +6,18 @@ extern crate reqwest;
 #[macro_use]
 extern crate structopt;
 
-mod tests;
 mod errors;
 mod svd_test;
+mod tests;
 
-use std::path::PathBuf;
-use structopt::StructOpt;
 use rayon::prelude::*;
+use std::path::PathBuf;
+use std::process::{exit, Command};
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::process::exit;
 use std::time::Instant;
+use std::fs::File;
+use std::io::Read;
+use structopt::StructOpt;
 
 #[derive(StructOpt, Debug)]
 #[structopt(name = "svd2rust-regress")]
@@ -47,6 +49,18 @@ struct Opt {
     #[structopt(short = "b", long = "bad-tests")]
     bad_tests: bool,
 
+    /// Enable formatting with `rustfmt`
+    #[structopt(short = "f", long = "format")]
+    format: bool,
+
+    /// Path to an `rustfmt` binary, relative or absolute.
+    /// Defaults to `$(rustup which rustfmt)`
+    #[structopt(long = "rustfmt_bin_path", parse(from_os_str))]
+    rustfmt_bin_path: Option<PathBuf>,
+
+    /// Use verbose output
+    #[structopt(long = "verbose", short = "v", parse(from_occurrences))]
+    verbose: u8,
     // TODO: Specify smaller subset of tests? Maybe with tags?
     // TODO: Early fail
     // TODO: Compile svd2rust?
@@ -93,6 +107,27 @@ fn main() {
         None => &default_svd2rust,
     };
 
+    let default_rustfmt: Option<PathBuf> = if let Some(v) = Command::new("rustup")
+        .args(&["which", "rustfmt"])
+        .output()
+        .ok()
+        .map(|v| v.stdout)
+    {
+        Some(String::from_utf8_lossy(&v).into_owned().trim().into())
+    } else {
+        None
+    }; // FIXME: capture error and assure exit is 0
+
+    let rustfmt_bin_path = match (&opt.rustfmt_bin_path, opt.format) {
+        (_, false) => None,
+        (&Some(ref path), true) => Some(path),
+        (&None, true) => {
+            if default_rustfmt.is_none() {
+                eprintln!("Warning: No rustfmt found, formatting will be skipped")
+            }
+            default_rustfmt.as_ref()
+        }
+    };
     // collect enabled tests
     let tests = tests::TESTS
         .iter()
@@ -133,8 +168,9 @@ fn main() {
     tests.par_iter().for_each(|t| {
         let start = Instant::now();
 
-        match svd_test::test(t, &bin_path) {
+        match svd_test::test(t, &bin_path, rustfmt_bin_path) {
             Ok(()) => {
+                // TODO: If verbosity is > 1, print every logged stderr
                 eprintln!(
                     "Passed: {} - {} seconds",
                     t.name(),
@@ -143,11 +179,25 @@ fn main() {
             }
             Err(e) => {
                 any_fails.store(true, Ordering::Release);
+                let additional_info = if opt.verbose > 0 {
+                    match e.kind() {
+                        &errors::ErrorKind::ProcessFailed(ref command, _, ref stderr) if command == "cargo check" => {
+                            let mut buf = String::new();
+                            // Unwrap is safe
+                            File::open(stderr.as_ref().unwrap()).expect("Couldn't open file").read_to_string(&mut buf).expect("Couldn't read file to string");
+                            buf
+                        }
+                        _ => "".into()
+                    }
+                } else {
+                    "".into()
+                };
                 eprintln!(
-                    "Failed: {} - {} seconds - {:?}",
+                    "Failed: {} - {} seconds - {}{}",
                     t.name(),
                     start.elapsed().as_secs(),
-                    e
+                    e,
+                    additional_info,
                 );
             }
         }

ci/svd2rust-regress/src/svd_test.rs

@@ -1,10 +1,10 @@
 use errors::*;
-use std::io::prelude::*;
+use reqwest;
 use std::fs::{remove_dir_all, File, OpenOptions};
+use std::io::prelude::*;
+use std::path::PathBuf;
 use std::process::{Command, Output};
 use tests::TestCase;
-use reqwest;
-use std::path::PathBuf;
 
 static CRATES_ALL: &[&str] = &["bare-metal = \"0.1.0\"", "vcell = \"0.1.0\""];
 static CRATES_MSP430: &[&str] = &["msp430 = \"0.1.0\""];
@@ -50,25 +50,25 @@ impl CommandHelper for Output {
         stdout: Option<&PathBuf>,
         stderr: Option<&PathBuf>,
     ) -> Result<()> {
-        if cant_fail && !self.status.success() {
-            bail!(format!("Process Failed! - {}", name))
-        }
-
         if let Some(out) = stdout {
             let out_payload = String::from_utf8_lossy(&self.stdout);
             file_helper(&out_payload, out)?;
-        }
+        };
 
         if let Some(err) = stderr {
             let err_payload = String::from_utf8_lossy(&self.stderr);
             file_helper(&err_payload, err)?;
+        };
+
+        if cant_fail && !self.status.success() {
+            return Err(ErrorKind::ProcessFailed(name.into(), stdout.cloned(), stderr.cloned()).into())
         }
 
         Ok(())
     }
 }
 
-pub fn test(t: &TestCase, bin_path: &PathBuf) -> Result<()> {
+pub fn test(t: &TestCase, bin_path: &PathBuf, rustfmt_bin_path: Option<&PathBuf>) -> Result<()> {
     let user = match ::std::env::var("USER") {
         Ok(val) => val,
         Err(_) => "rusttester".into(),
@@ -135,10 +135,8 @@ pub fn test(t: &TestCase, bin_path: &PathBuf) -> Result<()> {
         &RiscV => "riscv",
     };
     Command::new(bin_path)
-        .arg("-i")
-        .arg(&chip_svd)
-        .arg("--target")
-        .arg(target)
+        .args(&["-i", &chip_svd])
+        .args(&["--target", &target])
         .current_dir(&chip_dir)
         .output()
         .chain_err(|| "failed to execute process")?
@@ -149,16 +147,15 @@ pub fn test(t: &TestCase, bin_path: &PathBuf) -> Result<()> {
             Some(&svd2rust_err_file),
         )?;
 
-    // TODO: rustfmt < 0.4.0 seems to mangle some doc comments. Omit until this is fixed
-    // Run `cargo fmt`, capturing stderr to a log file
-    // let cargo_fmt_err_file = path_helper_base(&chip_dir, &["cargo-fmt.err.log"]);
-    // Command::new("cargo")
-    //     .arg("fmt")
-    //     .current_dir(&chip_dir)
-    //     .output()
-    //     .chain_err(|| "failed to format")?
-    //     .capture_outputs(false, "cargo fmt", None, Some(&cargo_fmt_err_file))?;
-
+    if let Some(rustfmt_bin_path) = rustfmt_bin_path {
+        // Run `cargo fmt`, capturing stderr to a log file
+        let fmt_err_file = path_helper_base(&chip_dir, &["rustfmt.err.log"]);
+        Command::new(rustfmt_bin_path)
+            .arg(lib_rs_file)
+            .output()
+            .chain_err(|| "failed to format")?
+            .capture_outputs(false, "rustfmt", None, Some(&fmt_err_file))?;
+    }
     // Run `cargo check`, capturing stderr to a log file
     let cargo_check_err_file = path_helper_base(&chip_dir, &["cargo-check.err.log"]);
     Command::new("cargo")