Implemented rough draft of check write mode.

Cargo.toml

@@ -50,6 +50,7 @@ rustc-ap-syntax = "67.0.0"
 
 [dev-dependencies]
 lazy_static = "1.0.0"
+assert_cli = "0.5"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.11"

README.md

@@ -98,14 +98,16 @@ read data from stdin. Alternatively, you can use `cargo fmt` to format all
 binary and library targets of your crate.
 
 You'll probably want to specify the write mode. Currently, there are modes for
-`diff`, `replace`, `overwrite`, `display`, `coverage`, `checkstyle`, and `plain`.
+`check`, `diff`, `replace`, `overwrite`, `display`, `coverage`, `checkstyle`, and `plain`.
 
 * `overwrite` Is the default and overwrites the original files _without_ creating backups.
 * `replace` Overwrites the original files after creating backups of the files.
 * `display` Will print the formatted files to stdout.
 * `plain` Also writes to stdout, but with no metadata.
 * `diff` Will print a diff between the original files and formatted files to stdout.
          Will also exit with an error code if there are any differences.
+* `check` Similar to `diff`, but is intended to be run in during CI and returns error code 1
+          on failure instead of 4 as `diff` does.  
 * `checkstyle` Will output the lines that need to be corrected as a checkstyle XML file,
   that can be used by tools like Jenkins.
 

src/bin/main.rs

@@ -198,7 +198,7 @@ fn make_opts() -> Options {
         "",
         "write-mode",
         "How to write output (not usable when piping from stdin)",
-        "[replace|overwrite|display|plain|diff|coverage|checkstyle]",
+        "[replace|overwrite|display|plain|diff|check|coverage|checkstyle]",
     );
 
     opts
@@ -287,6 +287,10 @@ fn execute(opts: &Options) -> FmtResult<Summary> {
             }
 
             let mut error_summary = Summary::default();
+            if let Some(mode) = options.write_mode {
+                error_summary.add_write_mode(mode)
+            }
+
             for file in files {
                 if !file.exists() {
                     eprintln!("Error: file `{}` does not exist", file.to_str().unwrap());
@@ -342,6 +346,8 @@ fn main() {
         Ok(summary) => {
             if summary.has_operational_errors() {
                 1
+            } else if summary.has_diff && summary.write_mode == Some(WriteMode::Check) {
+                1
             } else if summary.has_parsing_errors() {
                 2
             } else if summary.has_formatting_errors() {

src/config/options.rs

@@ -183,6 +183,9 @@ configuration_option_enum! { WriteMode:
     Checkstyle,
     // Output the changed lines (for internal value only)
     Modified,
+    // Displays how much of the input was processed, but if anything was modified, rustfmt quits
+    // with exit code 0. This option is intended to be run as part of a CI pipeline.
+    Check,
 }
 
 configuration_option_enum! { Color:

src/config/summary.rs

@@ -11,6 +11,8 @@
 use std::time::{Duration, Instant};
 use std::default::Default;
 
+use config::options::WriteMode;
+
 #[must_use]
 #[derive(Debug, Default, Clone, Copy)]
 pub struct Summary {
@@ -26,6 +28,9 @@ pub struct Summary {
     // Formatted code differs from existing code (write-mode diff only).
     pub has_diff: bool,
 
+    // What write mode rustfmt was invoked with, if any.
+    pub write_mode: Option<WriteMode>,
+
     // Keeps track of time spent in parsing and formatting steps.
     timer: Timer,
 }
@@ -89,6 +94,10 @@ impl Summary {
         self.has_diff = true;
     }
 
+    pub fn add_write_mode(&mut self, mode: WriteMode) {
+        self.write_mode = Some(mode)
+    }
+
     pub fn has_no_errors(&self) -> bool {
         !(self.has_operational_errors || self.has_parsing_errors || self.has_formatting_errors
             || self.has_diff)

src/filemap.rs

@@ -178,6 +178,19 @@ where
             let diff = create_diff(filename, text, config)?;
             output_checkstyle_file(out, filename, diff)?;
         }
+        WriteMode::Check => {
+            let filename = filename_to_path();
+            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.display(), line_num),
+                    config.color(),
+                );
+                return Ok(has_diff);
+            }
+        }
     }
 
     // when we are not in diff mode, don't indicate differing files

tests/lib.rs

@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+extern crate assert_cli;
 #[macro_use]
 extern crate lazy_static;
 #[macro_use]
@@ -861,3 +862,16 @@ fn configuration_snippet_tests() {
     println!("Ran {} configurations tests.", blocks.len());
     assert_eq!(failures, 0, "{} configurations tests failed", failures);
 }
+
+#[test]
+fn verify_check_works() {
+    assert_cli::Assert::command(&[
+        "cargo",
+        "run",
+        "--bin=rustfmt",
+        "--",
+        "--write-mode=check",
+        "src/bin/main.rs",
+    ]).succeeds()
+        .unwrap();
+}