Remove BlockIndentStyle::Inherit

[rust.git] / src / filemap.rs

diff --git a/src/filemap.rs b/src/filemap.rs
index b22ca7b9b806e71048ef6e585baeebac439107f2..6c15d659d549eda0f805937baf712f75ee3fce51 100644 (file)
--- a/src/filemap.rs
+++ b/src/filemap.rs
@@ -13,32 +13,32 @@
 
 use strings::string_buffer::StringBuffer;
 
-use std::collections::HashMap;
 use std::fs::{self, File};
-use std::io::{self, Write, Read, stdout, BufWriter};
+use std::io::{self, Write, Read, BufWriter};
 
 use config::{NewlineStyle, Config, WriteMode};
-use rustfmt_diff::{make_diff, print_diff};
+use rustfmt_diff::{make_diff, print_diff, Mismatch};
+use checkstyle::{output_header, output_footer, output_checkstyle_file};
 
 // A map of the files of a crate, with their new content
-pub type FileMap = HashMap<String, StringBuffer>;
+pub type FileMap = Vec<FileRecord>;
+
+pub type FileRecord = (String, StringBuffer);
 
 // Append a newline to the end of each file.
-pub fn append_newlines(file_map: &mut FileMap) {
-    for (_, s) in file_map.iter_mut() {
-        s.push_str("\n");
-    }
+pub fn append_newline(s: &mut StringBuffer) {
+    s.push_str("\n");
 }
 
-pub fn write_all_files(file_map: &FileMap,
-                       mode: WriteMode,
-                       config: &Config)
-                       -> Result<(), io::Error> {
-    for filename in file_map.keys() {
-        try!(write_file(&file_map[filename], filename, mode, config));
+pub fn write_all_files<T>(file_map: &FileMap, out: &mut T, config: &Config) -> Result<(), io::Error>
+    where T: Write
+{
+    output_header(out, config.write_mode).ok();
+    for &(ref filename, ref text) in file_map {
+        try!(write_file(text, filename, out, config));
     }
+    output_footer(out, config.write_mode).ok();
 
-    // Output trailers for write mode.
     Ok(())
 }
 
@@ -78,11 +78,13 @@ pub fn write_system_newlines<T>(writer: T,
     }
 }
 
-pub fn write_file(text: &StringBuffer,
-                  filename: &str,
-                  mode: WriteMode,
-                  config: &Config)
-                  -> Result<Option<String>, io::Error> {
+pub fn write_file<T>(text: &StringBuffer,
+                     filename: &str,
+                     out: &mut T,
+                     config: &Config)
+                     -> Result<bool, io::Error>
+    where T: Write
+{
 
     fn source_and_formatted_text(text: &StringBuffer,
                                  filename: &str,
@@ -97,7 +99,15 @@ fn source_and_formatted_text(text: &StringBuffer,
         Ok((ori_text, fmt_text))
     }
 
-    match mode {
+    fn create_diff(filename: &str,
+                   text: &StringBuffer,
+                   config: &Config)
+                   -> Result<Vec<Mismatch>, io::Error> {
+        let (ori, fmt) = try!(source_and_formatted_text(text, filename, config));
+        Ok(make_diff(&ori, &fmt, 3))
+    }
+
+    match config.write_mode {
         WriteMode::Replace => {
             if let Ok((ori, fmt)) = source_and_formatted_text(text, filename, config) {
                 if fmt != ori {
@@ -123,40 +133,27 @@ fn source_and_formatted_text(text: &StringBuffer,
             try!(write_system_newlines(file, text, config));
         }
         WriteMode::Plain => {
-            let stdout = stdout();
-            let stdout = stdout.lock();
-            try!(write_system_newlines(stdout, text, config));
+            try!(write_system_newlines(out, text, config));
         }
         WriteMode::Display | WriteMode::Coverage => {
             println!("{}:\n", filename);
-            let stdout = stdout();
-            let stdout = stdout.lock();
-            try!(write_system_newlines(stdout, text, config));
+            try!(write_system_newlines(out, text, config));
         }
         WriteMode::Diff => {
-            println!("Diff of {}:\n", filename);
             if let Ok((ori, fmt)) = source_and_formatted_text(text, filename, config) {
-                print_diff(make_diff(&ori, &fmt, 3),
-                           |line_num| format!("\nDiff at line {}:", line_num));
+                let mismatch = make_diff(&ori, &fmt, 3);
+                let has_diff = !mismatch.is_empty();
+                print_diff(mismatch,
+                           |line_num| format!("Diff in {} at line {}:", filename, line_num));
+                return Ok(has_diff);
             }
         }
-        WriteMode::Default => {
-            unreachable!("The WriteMode should NEVER Be default at this point!");
-        }
         WriteMode::Checkstyle => {
-            // Generate the diff for the current file.
-            // Output the XML tags for the lines that are different.
-            // Use the new text as 'should be X'.
-        }
-        WriteMode::Return => {
-            // io::Write is not implemented for String, working around with
-            // Vec<u8>
-            let mut v = Vec::new();
-            try!(write_system_newlines(&mut v, text, config));
-            // won't panic, we are writing correct utf8
-            return Ok(Some(String::from_utf8(v).unwrap()));
+            let diff = try!(create_diff(filename, text, config));
+            try!(output_checkstyle_file(out, filename, diff));
         }
     }
 
-    Ok(None)
+    // when we are not in diff mode, don't indicate differing files
+    Ok(false)
 }