// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
// TODO: add tests
-use strings::string_buffer::StringBuffer;
-
-use std::collections::HashMap;
use std::fs::{self, File};
-use std::io::{self, Write, Read, stdout};
+use std::io::{self, BufWriter, Read, Write};
-use WriteMode;
-use config::{NewlineStyle, Config};
-use rustfmt_diff::{make_diff, print_diff};
+use checkstyle::{output_checkstyle_file, output_footer, output_header};
+use config::{Config, NewlineStyle, WriteMode};
+use rustfmt_diff::{make_diff, print_diff, Mismatch};
// 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, String);
// 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 String) {
+ s.push_str("\n");
}
-pub fn write_all_files(file_map: &FileMap,
- mode: WriteMode,
- config: &Config)
- -> Result<(HashMap<String, String>), io::Error> {
- let mut result = HashMap::new();
- for filename in file_map.keys() {
- let one_result = try!(write_file(&file_map[filename], filename, mode, config));
- if let Some(r) = one_result {
- result.insert(filename.clone(), r);
- }
+pub fn write_all_files<T>(
+ file_map: &[FileRecord],
+ 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 {
+ write_file(text, filename, out, config)?;
}
+ output_footer(out, config.write_mode()).ok();
- Ok(result)
+ Ok(())
}
-pub fn write_file(text: &StringBuffer,
- filename: &str,
- mode: WriteMode,
- config: &Config)
- -> Result<Option<String>, io::Error> {
-
- // prints all newlines either as `\n` or as `\r\n`
- fn write_system_newlines<T>(mut writer: T,
- text: &StringBuffer,
- config: &Config)
- -> Result<(), io::Error>
- where T: Write
- {
- let style = if config.newline_style == NewlineStyle::Native {
- if cfg!(windows) {
- NewlineStyle::Windows
- } else {
- NewlineStyle::Unix
- }
+// Prints all newlines either as `\n` or as `\r\n`.
+pub fn write_system_newlines<T>(writer: T, text: &str, config: &Config) -> Result<(), io::Error>
+where
+ T: Write,
+{
+ // Buffer output, since we're writing a since char at a time.
+ let mut writer = BufWriter::new(writer);
+
+ let style = if config.newline_style() == NewlineStyle::Native {
+ if cfg!(windows) {
+ NewlineStyle::Windows
} else {
- config.newline_style
- };
-
- match style {
- NewlineStyle::Unix => write!(writer, "{}", text),
- NewlineStyle::Windows => {
- for (c, _) in text.chars() {
- match c {
- '\n' => try!(write!(writer, "\r\n")),
- '\r' => continue,
- c => try!(write!(writer, "{}", c)),
- }
+ NewlineStyle::Unix
+ }
+ } else {
+ config.newline_style()
+ };
+
+ match style {
+ NewlineStyle::Unix => write!(writer, "{}", text),
+ NewlineStyle::Windows => {
+ for c in text.chars() {
+ match c {
+ '\n' => write!(writer, "\r\n")?,
+ '\r' => continue,
+ c => write!(writer, "{}", c)?,
}
- Ok(())
}
- NewlineStyle::Native => unreachable!(),
+ Ok(())
}
+ NewlineStyle::Native => unreachable!(),
+ }
+}
+
+pub fn write_file<T>(
+ text: &str,
+ filename: &str,
+ out: &mut T,
+ config: &Config,
+) -> Result<bool, io::Error>
+where
+ T: Write,
+{
+ fn source_and_formatted_text(
+ text: &str,
+ filename: &str,
+ config: &Config,
+ ) -> Result<(String, String), io::Error> {
+ let mut f = File::open(filename)?;
+ let mut ori_text = String::new();
+ f.read_to_string(&mut ori_text)?;
+ let mut v = Vec::new();
+ write_system_newlines(&mut v, text, config)?;
+ let fmt_text = String::from_utf8(v).unwrap();
+ Ok((ori_text, fmt_text))
+ }
+
+ fn create_diff(
+ filename: &str,
+ text: &str,
+ config: &Config,
+ ) -> Result<Vec<Mismatch>, io::Error> {
+ let (ori, fmt) = source_and_formatted_text(text, filename, config)?;
+ Ok(make_diff(&ori, &fmt, 3))
}
- match mode {
+ match config.write_mode() {
WriteMode::Replace => {
- // Do a little dance to make writing safer - write to a temp file
- // rename the original to a .bk, then rename the temp file to the
- // original.
- let tmp_name = filename.to_owned() + ".tmp";
- let bk_name = filename.to_owned() + ".bk";
- {
- // Write text to temp file
- let tmp_file = try!(File::create(&tmp_name));
- try!(write_system_newlines(tmp_file, text, config));
- }
+ if let Ok((ori, fmt)) = source_and_formatted_text(text, filename, config) {
+ if fmt != ori {
+ // Do a little dance to make writing safer - write to a temp file
+ // rename the original to a .bk, then rename the temp file to the
+ // original.
+ let tmp_name = filename.to_owned() + ".tmp";
+ let bk_name = filename.to_owned() + ".bk";
+ {
+ // Write text to temp file
+ let tmp_file = File::create(&tmp_name)?;
+ write_system_newlines(tmp_file, text, config)?;
+ }
- try!(fs::rename(filename, bk_name));
- try!(fs::rename(tmp_name, filename));
+ fs::rename(filename, bk_name)?;
+ fs::rename(tmp_name, filename)?;
+ }
+ }
}
WriteMode::Overwrite => {
- // Write text directly over original file.
- let file = try!(File::create(filename));
- try!(write_system_newlines(file, text, config));
- }
- WriteMode::NewFile(extn) => {
- let filename = filename.to_owned() + "." + extn;
- let file = try!(File::create(&filename));
- try!(write_system_newlines(file, text, config));
+ // Write text directly over original file if there is a diff.
+ let (source, formatted) = source_and_formatted_text(text, filename, config)?;
+ if source != formatted {
+ let file = File::create(filename)?;
+ write_system_newlines(file, text, config)?;
+ }
}
WriteMode::Plain => {
- let stdout = stdout();
- let stdout = stdout.lock();
- try!(write_system_newlines(stdout, text, config));
+ 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));
+ write_system_newlines(out, text, config)?;
}
WriteMode::Diff => {
- println!("Diff of {}:\n", filename);
- let mut f = try!(File::open(filename));
- let mut ori_text = String::new();
- try!(f.read_to_string(&mut ori_text));
- let mut v = Vec::new();
- try!(write_system_newlines(&mut v, text, config));
- let fmt_text = String::from_utf8(v).unwrap();
- let diff = make_diff(&ori_text, &fmt_text, 3);
- print_diff(diff, |line_num| format!("\nDiff at line {}:", line_num));
+ if let Ok((ori, fmt)) = source_and_formatted_text(text, filename, config) {
+ 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),
+ config.color(),
+ );
+ return Ok(has_diff);
+ }
}
- 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()));
+ WriteMode::Checkstyle => {
+ let diff = create_diff(filename, text, config)?;
+ output_checkstyle_file(out, filename, diff)?;
}
}
- Ok(None)
+ // when we are not in diff mode, don't indicate differing files
+ Ok(false)
}
projects / rust.git / blobdiff