Remove format_and_emit_report from the API

Also changes the header/footer stuff

Author: nrc

src/bin/main.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![cfg(not(test))]
+#![feature(extern_prelude)]
 
 extern crate env_logger;
 #[macro_use]
@@ -27,8 +28,8 @@ use failure::err_msg;
 use getopts::{Matches, Options};
 
 use rustfmt::{
-    emit_post_matter, emit_pre_matter, format_and_emit_report, load_config, CliOptions, Color,
-    Config, EmitMode, ErrorKind, FileLines, FileName, Input, Summary, Verbosity,
+    checkstyle_footer, checkstyle_header, format_input, load_config, use_colored_tty, CliOptions,
+    Color, Config, EmitMode, ErrorKind, FileLines, FileName, Input, Summary, Verbosity,
 };
 
 fn main() {
@@ -221,12 +222,12 @@ fn execute(opts: &Options) -> Result<(ExitCodeMode, Summary), failure::Error> {
             }
 
             let mut error_summary = Summary::default();
-            emit_pre_matter(&config)?;
+            emit_pre_matter(&config);
             match format_and_emit_report(Input::Text(input), &config) {
                 Ok(summary) => error_summary.add(summary),
                 Err(_) => error_summary.add_operational_error(),
             }
-            emit_post_matter(&config)?;
+            emit_post_matter(&config);
 
             Ok((ExitCodeMode::Normal, error_summary))
         }
@@ -251,7 +252,7 @@ fn format(
         }
     }
 
-    emit_pre_matter(&config)?;
+    emit_pre_matter(&config);
     let mut error_summary = Summary::default();
 
     for file in files {
@@ -289,7 +290,7 @@ fn format(
             }
         }
     }
-    emit_post_matter(&config)?;
+    emit_post_matter(&config);
 
     // If we were given a path via dump-minimal-config, output any options
     // that were used during formatting as TOML.
@@ -307,6 +308,49 @@ fn format(
     Ok((exit_mode, error_summary))
 }
 
+fn format_and_emit_report(input: Input, config: &Config) -> Result<Summary, failure::Error> {
+    let out = &mut stdout();
+
+    match format_input(input, config, Some(out)) {
+        Ok((summary, report)) => {
+            if report.has_warnings() {
+                match term::stderr() {
+                    Some(ref t)
+                        if use_colored_tty(config.color())
+                            && t.supports_color()
+                            && t.supports_attr(term::Attr::Bold) =>
+                    {
+                        match report.fancy_print(term::stderr().unwrap()) {
+                            Ok(..) => (),
+                            Err(..) => panic!("Unable to write to stderr: {}", report),
+                        }
+                    }
+                    _ => eprintln!("{}", report),
+                }
+            }
+
+            Ok(summary)
+        }
+        Err((msg, mut summary)) => {
+            eprintln!("Error writing files: {}", msg);
+            summary.add_operational_error();
+            Ok(summary)
+        }
+    }
+}
+
+fn emit_pre_matter(config: &Config) {
+    if config.emit_mode() == EmitMode::Checkstyle {
+        println!("{}", checkstyle_header());
+    }
+}
+
+fn emit_post_matter(config: &Config) {
+    if config.emit_mode() == EmitMode::Checkstyle {
+        println!("{}", checkstyle_footer());
+    }
+}
+
 fn print_usage_to_stdout(opts: &Options, reason: &str) {
     let sep = if reason.is_empty() {
         String::new()

src/checkstyle.rs

@@ -13,24 +13,16 @@ use std::path::Path;
 
 use rustfmt_diff::{DiffLine, Mismatch};
 
-pub fn output_header<T>(out: &mut T) -> Result<(), io::Error>
-where
-    T: Write,
-{
+pub fn header() -> String {
     let mut xml_heading = String::new();
     xml_heading.push_str("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
     xml_heading.push_str("\n");
     xml_heading.push_str("<checkstyle version=\"4.3\">");
-    write!(out, "{}", xml_heading)
+    xml_heading
 }
 
-pub fn output_footer<T>(out: &mut T) -> Result<(), io::Error>
-where
-    T: Write,
-{
-    let mut xml_tail = String::new();
-    xml_tail.push_str("</checkstyle>\n");
-    write!(out, "{}", xml_tail)
+pub fn footer() -> String {
+    "</checkstyle>\n".to_owned()
 }
 
 pub fn output_checkstyle_file<T>(

src/filemap.rs

@@ -36,13 +36,13 @@ where
     T: Write,
 {
     if config.emit_mode() == EmitMode::Checkstyle {
-        ::checkstyle::output_header(out)?;
+        write!(out, "{}", ::checkstyle::header())?;
     }
     for &(ref filename, ref text) in file_map {
         write_file(text, filename, out, config)?;
     }
     if config.emit_mode() == EmitMode::Checkstyle {
-        ::checkstyle::output_footer(out)?;
+        write!(out, "{}", ::checkstyle::footer())?;
     }
 
     Ok(())

src/git-rustfmt/main.rs

@@ -15,13 +15,14 @@ extern crate log;
 extern crate rustfmt_nightly as rustfmt;
 
 use std::env;
+use std::io::stdout;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::str::FromStr;
 
 use getopts::{Matches, Options};
 
-use rustfmt::{format_and_emit_report, load_config, CliOptions, Input};
+use rustfmt::{format_input, load_config, CliOptions, Input};
 
 fn prune_files(files: Vec<&str>) -> Vec<&str> {
     let prefixes: Vec<_> = files
@@ -73,7 +74,14 @@ fn fmt_files(files: &[&str]) -> i32 {
 
     let mut exit_code = 0;
     for file in files {
-        let summary = format_and_emit_report(Input::File(PathBuf::from(file)), &config).unwrap();
+        let (summary, report) = format_input(
+            Input::File(PathBuf::from(file)),
+            &config,
+            Some(&mut stdout()),
+        ).unwrap();
+        if report.has_warnings() {
+            eprintln!("{}", report);
+        }
         if !summary.has_no_errors() {
             exit_code = 1;
         }

src/lib.rs

@@ -13,11 +13,11 @@
 #![allow(unused_attributes)]
 #![feature(type_ascription)]
 #![feature(unicode_internals)]
+#![feature(extern_prelude)]
 
 #[macro_use]
 extern crate derive_new;
 extern crate diff;
-#[macro_use]
 extern crate failure;
 extern crate itertools;
 #[cfg(test)]
@@ -32,14 +32,13 @@ extern crate serde;
 extern crate serde_derive;
 extern crate serde_json;
 extern crate syntax;
-extern crate term;
 extern crate toml;
 extern crate unicode_segmentation;
 
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt;
-use std::io::{self, stdout, Write};
+use std::io::{self, Write};
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::path::PathBuf;
 use std::rc::Rc;
@@ -55,13 +54,14 @@ use comment::{CharClasses, FullCodeCharKind, LineClasses};
 use failure::Fail;
 use issues::{BadIssueSeeker, Issue};
 use shape::Indent;
-use utils::use_colored_tty;
 use visitor::{FmtVisitor, SnippetProvider};
 
+pub use checkstyle::{footer as checkstyle_footer, header as checkstyle_header};
 pub use config::summary::Summary;
 pub use config::{
     load_config, CliOptions, Color, Config, EmitMode, FileLines, FileName, Verbosity,
 };
+pub use utils::use_colored_tty;
 
 #[macro_use]
 mod utils;
@@ -129,6 +129,8 @@ pub enum ErrorKind {
     BadAttr,
     #[fail(display = "io error: {}", _0)]
     IoError(io::Error),
+    #[fail(display = "Version mismatch")]
+    VersionMismatch,
 }
 
 impl From<io::Error> for ErrorKind {
@@ -168,7 +170,7 @@ impl FormattingError {
             ErrorKind::LineOverflow(..) | ErrorKind::TrailingWhitespace | ErrorKind::IoError(_) => {
                 "internal error:"
             }
-            ErrorKind::LicenseCheck | ErrorKind::BadAttr => "error:",
+            ErrorKind::LicenseCheck | ErrorKind::BadAttr | ErrorKind::VersionMismatch => "error:",
             ErrorKind::BadIssue(_) | ErrorKind::DeprecatedAttr => "warning:",
         }
     }
@@ -203,7 +205,7 @@ impl FormattingError {
 }
 
 #[derive(Clone)]
-struct FormatReport {
+pub struct FormatReport {
     // Maps stringified file paths to their associated formatting errors.
     internal: Rc<RefCell<(FormatErrorMap, ReportedErrors)>>,
 }
@@ -246,7 +248,8 @@ impl FormatReport {
                 ErrorKind::BadIssue(_)
                 | ErrorKind::LicenseCheck
                 | ErrorKind::DeprecatedAttr
-                | ErrorKind::BadAttr => {
+                | ErrorKind::BadAttr
+                | ErrorKind::VersionMismatch => {
                     errs.has_check_errors = true;
                 }
                 _ => {}
@@ -263,11 +266,11 @@ impl FormatReport {
             .sum()
     }
 
-    fn has_warnings(&self) -> bool {
+    pub fn has_warnings(&self) -> bool {
         self.warning_count() > 0
     }
 
-    fn print_warnings_fancy(
+    pub fn fancy_print(
         &self,
         mut t: Box<term::Terminal<Output = io::Stderr>>,
     ) -> Result<(), term::Error> {
@@ -749,12 +752,22 @@ fn format_code_block(code_snippet: &str, config: &Config) -> Option<String> {
     Some(result)
 }
 
+#[derive(Debug)]
+pub enum Input {
+    File(PathBuf),
+    Text(String),
+}
+
 pub fn format_input<T: Write>(
     input: Input,
     config: &Config,
     out: Option<&mut T>,
-) -> Result<Summary, (ErrorKind, Summary)> {
-    syntax::with_globals(|| format_input_inner(input, config, out)).map(|tup| tup.0)
+) -> Result<(Summary, FormatReport), (ErrorKind, Summary)> {
+    if !config.version_meets_requirement() {
+        return Err((ErrorKind::VersionMismatch, Summary::default()));
+    }
+
+    syntax::with_globals(|| format_input_inner(input, config, out)).map(|tup| (tup.0, tup.2))
 }
 
 fn format_input_inner<T: Write>(
@@ -950,61 +963,6 @@ fn get_modified_lines(
     Ok(ModifiedLines { chunks })
 }
 
-#[derive(Debug)]
-pub enum Input {
-    File(PathBuf),
-    Text(String),
-}
-
-pub fn format_and_emit_report(input: Input, config: &Config) -> Result<Summary, failure::Error> {
-    if !config.version_meets_requirement() {
-        return Err(format_err!("Version mismatch"));
-    }
-    let out = &mut stdout();
-    match syntax::with_globals(|| format_input_inner(input, config, Some(out))) {
-        Ok((summary, _, report)) => {
-            if report.has_warnings() {
-                match term::stderr() {
-                    Some(ref t)
-                        if use_colored_tty(config.color())
-                            && t.supports_color()
-                            && t.supports_attr(term::Attr::Bold) =>
-                    {
-                        match report.print_warnings_fancy(term::stderr().unwrap()) {
-                            Ok(..) => (),
-                            Err(..) => panic!("Unable to write to stderr: {}", report),
-                        }
-                    }
-                    _ => eprintln!("{}", report),
-                }
-            }
-
-            Ok(summary)
-        }
-        Err((msg, mut summary)) => {
-            eprintln!("Error writing files: {}", msg);
-            summary.add_operational_error();
-            Ok(summary)
-        }
-    }
-}
-
-pub fn emit_pre_matter(config: &Config) -> Result<(), ErrorKind> {
-    if config.emit_mode() == EmitMode::Checkstyle {
-        let mut out = &mut stdout();
-        checkstyle::output_header(&mut out)?;
-    }
-    Ok(())
-}
-
-pub fn emit_post_matter(config: &Config) -> Result<(), ErrorKind> {
-    if config.emit_mode() == EmitMode::Checkstyle {
-        let mut out = &mut stdout();
-        checkstyle::output_footer(&mut out)?;
-    }
-    Ok(())
-}
-
 #[cfg(test)]
 mod unit_tests {
     use super::{format_code_block, format_snippet, Config};

src/rustfmt_diff.rs

@@ -13,7 +13,6 @@ use diff;
 use std::collections::VecDeque;
 use std::io;
 use std::io::Write;
-use term;
 use utils::use_colored_tty;
 
 #[derive(Debug, PartialEq)]