Replace WriteMode with EmitMode and backup bool

Author: nrc

Configurations.md

@@ -1885,13 +1885,6 @@ fn main() {
 
 See also: [`match_block_trailing_comma`](#match_block_trailing_comma).
 
-## `write_mode`
-
-What Write Mode to use when none is supplied: Replace, Overwrite, Display, Diff, Coverage
-
-- **Default value**: `"Overwrite"`
-- **Possible values**: `"Checkstyle"`, `"Coverage"`, `"Diff"`, `"Display"`, `"Overwrite"`, `"Plain"`, `"Replace"`
-- **Stable**: No
 
 ## `blank_lines_upper_bound`
 
@@ -2071,3 +2064,11 @@ ignore [
     "examples",
 ]
 ```
+
+## `emit_mode`
+
+Internal option
+
+## `make_backup`
+
+Internal option, use `--backup`

src/bin/main.rs

@@ -28,18 +28,18 @@ use getopts::{Matches, Options};
 
 use rustfmt::{
     emit_post_matter, emit_pre_matter, format_and_emit_report, load_config, CliOptions, Color,
-    Config, ErrorKind, FileLines, FileName, Input, Summary, Verbosity, WriteMode,
+    Config, EmitMode, ErrorKind, FileLines, FileName, Input, Summary, Verbosity,
 };
 
 fn main() {
     env_logger::init();
     let opts = make_opts();
 
     let exit_code = match execute(&opts) {
-        Ok((write_mode, summary)) => {
+        Ok((exit_mode, summary)) => {
             if summary.has_operational_errors() || summary.has_parsing_errors()
                 || ((summary.has_diff || summary.has_check_errors())
-                    && write_mode == WriteMode::Check)
+                    && exit_mode == ExitCodeMode::Check)
             {
                 1
             } else {
@@ -172,26 +172,26 @@ fn is_nightly() -> bool {
         .unwrap_or(false)
 }
 
-fn execute(opts: &Options) -> Result<(WriteMode, Summary), failure::Error> {
+fn execute(opts: &Options) -> Result<(ExitCodeMode, Summary), failure::Error> {
     let matches = opts.parse(env::args().skip(1))?;
     let options = GetOptsOptions::from_matches(&matches)?;
 
     match determine_operation(&matches)? {
         Operation::Help(HelpOp::None) => {
             print_usage_to_stdout(opts, "");
-            Ok((WriteMode::None, Summary::default()))
+            Ok((ExitCodeMode::Normal, Summary::default()))
         }
         Operation::Help(HelpOp::Config) => {
             Config::print_docs(&mut stdout(), options.unstable_features);
-            Ok((WriteMode::None, Summary::default()))
+            Ok((ExitCodeMode::Normal, Summary::default()))
         }
         Operation::Help(HelpOp::FileLines) => {
             print_help_file_lines();
-            Ok((WriteMode::None, Summary::default()))
+            Ok((ExitCodeMode::Normal, Summary::default()))
         }
         Operation::Version => {
             print_version();
-            Ok((WriteMode::None, Summary::default()))
+            Ok((ExitCodeMode::Normal, Summary::default()))
         }
         Operation::ConfigOutputDefault { path } => {
             let toml = Config::default().all_options().to_toml().map_err(err_msg)?;
@@ -201,14 +201,14 @@ fn execute(opts: &Options) -> Result<(WriteMode, Summary), failure::Error> {
             } else {
                 io::stdout().write_all(toml.as_bytes())?;
             }
-            Ok((WriteMode::None, Summary::default()))
+            Ok((ExitCodeMode::Normal, Summary::default()))
         }
         Operation::Stdin { input } => {
             // try to read config from local directory
             let (mut config, _) = load_config(Some(Path::new(".")), Some(options.clone()))?;
 
-            // write_mode is always Display for Stdin.
-            config.set().write_mode(WriteMode::Display);
+            // emit mode is always Stdout for Stdin.
+            config.set().emit_mode(EmitMode::Stdout);
             config.set().verbose(Verbosity::Quiet);
 
             // parse file_lines
@@ -228,7 +228,7 @@ fn execute(opts: &Options) -> Result<(WriteMode, Summary), failure::Error> {
             }
             emit_post_matter(&config)?;
 
-            Ok((WriteMode::Display, error_summary))
+            Ok((ExitCodeMode::Normal, error_summary))
         }
         Operation::Format {
             files,
@@ -241,7 +241,7 @@ fn format(
     files: Vec<PathBuf>,
     minimal_config_path: Option<String>,
     options: GetOptsOptions,
-) -> Result<(WriteMode, Summary), failure::Error> {
+) -> Result<(ExitCodeMode, Summary), failure::Error> {
     options.verify_file_lines(&files);
     let (config, config_path) = load_config(None, Some(options.clone()))?;
 
@@ -299,7 +299,12 @@ fn format(
         file.write_all(toml.as_bytes())?;
     }
 
-    Ok((config.write_mode(), error_summary))
+    let exit_mode = if options.check {
+        ExitCodeMode::Check
+    } else {
+        ExitCodeMode::Normal
+    };
+    Ok((exit_mode, error_summary))
 }
 
 fn print_usage_to_stdout(opts: &Options, reason: &str) {
@@ -406,12 +411,13 @@ fn determine_operation(matches: &Matches) -> Result<Operation, ErrorKind> {
     })
 }
 
-const STABLE_WRITE_MODES: [WriteMode; 4] = [
-    WriteMode::Replace,
-    WriteMode::Overwrite,
-    WriteMode::Display,
-    WriteMode::Check,
-];
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+enum ExitCodeMode {
+    Normal,
+    Check,
+}
+
+const STABLE_EMIT_MODES: [EmitMode; 3] = [EmitMode::Files, EmitMode::Stdout, EmitMode::Diff];
 
 /// Parsed command line options.
 #[derive(Clone, Debug, Default)]
@@ -420,7 +426,8 @@ struct GetOptsOptions {
     quiet: bool,
     verbose: bool,
     config_path: Option<PathBuf>,
-    write_mode: WriteMode,
+    emit_mode: EmitMode,
+    backup: bool,
     check: bool,
     color: Option<Color>,
     file_lines: FileLines, // Default is all lines in all files.
@@ -463,19 +470,19 @@ impl GetOptsOptions {
             if options.check {
                 return Err(format_err!("Invalid to use `--emit` and `--check`"));
             }
-            if let Ok(write_mode) = write_mode_from_emit_str(emit_str) {
-                options.write_mode = write_mode;
+            if let Ok(emit_mode) = emit_mode_from_emit_str(emit_str) {
+                options.emit_mode = emit_mode;
             } else {
                 return Err(format_err!("Invalid value for `--emit`"));
             }
         }
 
-        if options.write_mode == WriteMode::Overwrite && matches.opt_present("backup") {
-            options.write_mode = WriteMode::Replace;
+        if matches.opt_present("backup") {
+            options.backup = true;
         }
 
         if !rust_nightly {
-            if !STABLE_WRITE_MODES.contains(&options.write_mode) {
+            if !STABLE_EMIT_MODES.contains(&options.emit_mode) {
                 return Err(format_err!(
                     "Invalid value for `--emit` - using an unstable \
                      value without `--unstable-features`",
@@ -524,9 +531,12 @@ impl CliOptions for GetOptsOptions {
             config.set().error_on_unformatted(error_on_unformatted);
         }
         if self.check {
-            config.set().write_mode(WriteMode::Check);
+            config.set().emit_mode(EmitMode::Diff);
         } else {
-            config.set().write_mode(self.write_mode);
+            config.set().emit_mode(self.emit_mode);
+        }
+        if self.backup {
+            config.set().make_backup(true);
         }
         if let Some(color) = self.color {
             config.set().color(color);
@@ -538,12 +548,12 @@ impl CliOptions for GetOptsOptions {
     }
 }
 
-fn write_mode_from_emit_str(emit_str: &str) -> Result<WriteMode, failure::Error> {
+fn emit_mode_from_emit_str(emit_str: &str) -> Result<EmitMode, failure::Error> {
     match emit_str {
-        "files" => Ok(WriteMode::Overwrite),
-        "stdout" => Ok(WriteMode::Display),
-        "coverage" => Ok(WriteMode::Coverage),
-        "checkstyle" => Ok(WriteMode::Checkstyle),
+        "files" => Ok(EmitMode::Files),
+        "stdout" => Ok(EmitMode::Stdout),
+        "coverage" => Ok(EmitMode::Coverage),
+        "checkstyle" => Ok(EmitMode::Checkstyle),
         _ => Err(format_err!("Invalid value for `--emit`")),
     }
 }

src/config/mod.rs

@@ -114,9 +114,6 @@ create_config! {
                                               in tuple patterns";
 
     // Control options (changes the operation of rustfmt, rather than the formatting)
-    write_mode: WriteMode, WriteMode::Overwrite, false,
-        "What Write Mode to use when none is supplied: \
-         Replace, Overwrite, Display, Plain, Diff, Coverage, Check";
     color: Color, Color::Auto, false,
         "What Color option to use when none is supplied: Always, Never, Auto";
     required_version: String, env!("CARGO_PKG_VERSION").to_owned(), false,
@@ -144,6 +141,9 @@ create_config! {
          via the --file-lines option";
     width_heuristics: WidthHeuristics, WidthHeuristics::scaled(100), false,
         "'small' heuristic values";
+    emit_mode: EmitMode, EmitMode::Files, false,
+        "What emit Mode to use when none is supplied";
+    make_backup: bool, false, false, "Backup changed files";
 }
 
 pub fn load_config<O: CliOptions>(

src/config/options.rs

@@ -165,25 +165,21 @@ configuration_option_enum! { ReportTactic:
     Never,
 }
 
-configuration_option_enum! { WriteMode:
-    // Overwrites original file without backup.
-    Overwrite,
-    // Backs the original file up and overwrites the original.
-    Replace,
+configuration_option_enum! { EmitMode:
+    // Emits to files.
+    Files,
     // Writes the output to stdout.
-    Display,
+    Stdout,
     // Displays how much of the input file was processed
     Coverage,
     // Unfancy stdout
     Checkstyle,
     // Output the changed lines (for internal value only)
-    Modified,
+    ModifiedLines,
     // Checks if a diff can be generated. If so, rustfmt outputs a diff and quits with exit code 1.
     // This option is designed to be run in CI where a non-zero exit signifies non-standard code
     // formatting.
-    Check,
-    // Rustfmt shouldn't output anything formatting-like (e.g., emit a help message).
-    None,
+    Diff,
 }
 
 configuration_option_enum! { Color:
@@ -266,9 +262,9 @@ impl ::std::str::FromStr for WidthHeuristics {
     }
 }
 
-impl Default for WriteMode {
-    fn default() -> WriteMode {
-        WriteMode::Overwrite
+impl Default for EmitMode {
+    fn default() -> EmitMode {
+        EmitMode::Files
     }
 }
 

src/filemap.rs

@@ -15,7 +15,7 @@ use std::io::{self, BufWriter, Read, Write};
 use std::path::Path;
 
 use checkstyle::output_checkstyle_file;
-use config::{Config, FileName, NewlineStyle, Verbosity, WriteMode};
+use config::{Config, EmitMode, FileName, NewlineStyle, Verbosity};
 use rustfmt_diff::{make_diff, output_modified, print_diff, Mismatch};
 
 #[cfg(test)]
@@ -35,13 +35,13 @@ pub(crate) fn write_all_files<T>(
 where
     T: Write,
 {
-    if config.write_mode() == WriteMode::Checkstyle {
+    if config.emit_mode() == EmitMode::Checkstyle {
         ::checkstyle::output_header(out)?;
     }
     for &(ref filename, ref text) in file_map {
         write_file(text, filename, out, config)?;
     }
-    if config.write_mode() == WriteMode::Checkstyle {
+    if config.emit_mode() == EmitMode::Checkstyle {
         ::checkstyle::output_footer(out)?;
     }
 
@@ -116,11 +116,11 @@ where
 
     let filename_to_path = || match *filename {
         FileName::Real(ref path) => path,
-        _ => panic!("cannot format `{}` with WriteMode::Replace", filename),
+        _ => panic!("cannot format `{}` and emit to files", filename),
     };
 
-    match config.write_mode() {
-        WriteMode::Replace => {
+    match config.emit_mode() {
+        EmitMode::Files if config.make_backup() => {
             let filename = filename_to_path();
             if let Ok((ori, fmt)) = source_and_formatted_text(text, filename, config) {
                 if fmt != ori {
@@ -140,7 +140,7 @@ where
                 }
             }
         }
-        WriteMode::Overwrite => {
+        EmitMode::Files => {
             // Write text directly over original file if there is a diff.
             let filename = filename_to_path();
             let (source, formatted) = source_and_formatted_text(text, filename, config)?;
@@ -149,13 +149,13 @@ where
                 write_system_newlines(file, text, config)?;
             }
         }
-        WriteMode::Display | WriteMode::Coverage => {
+        EmitMode::Stdout | EmitMode::Coverage => {
             if config.verbose() != Verbosity::Quiet {
                 println!("{}:\n", filename);
             }
             write_system_newlines(out, text, config)?;
         }
-        WriteMode::Modified => {
+        EmitMode::ModifiedLines => {
             let filename = filename_to_path();
             if let Ok((ori, fmt)) = source_and_formatted_text(text, filename, config) {
                 let mismatch = make_diff(&ori, &fmt, 0);
@@ -164,12 +164,12 @@ where
                 return Ok(has_diff);
             }
         }
-        WriteMode::Checkstyle => {
+        EmitMode::Checkstyle => {
             let filename = filename_to_path();
             let diff = create_diff(filename, text, config)?;
             output_checkstyle_file(out, filename, diff)?;
         }
-        WriteMode::Check => {
+        EmitMode::Diff => {
             let filename = filename_to_path();
             if let Ok((ori, fmt)) = source_and_formatted_text(text, filename, config) {
                 let mismatch = make_diff(&ori, &fmt, 3);
@@ -182,7 +182,6 @@ where
                 return Ok(has_diff);
             }
         }
-        WriteMode::None => {}
     }
 
     // when we are not in diff mode, don't indicate differing files