Continuous output and syntax highlighting

Cargo.lock

@@ -1,6 +1,6 @@
 [root]
 name = "cargo-expand"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "isatty 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]

README.md

@@ -14,9 +14,11 @@ Install with `cargo install cargo-expand`.
 This command optionally uses
 [`rustfmt`](https://github.com/rust-lang-nursery/rustfmt)
 to format the expanded output. If `rustfmt` is not available, the expanded code
-is not formatted. Install `rustfmt` with `cargo install rustfmt`. (Note:
+is not formatted. Install `rustfmt` with `cargo install rustfmt`.
-`rustfmt` is temporarily disabled due to
+
-[rust-lang/rust#38016](https://github.com/rust-lang/rust/issues/38016).)
+This command optionally uses [`Pygments`](http://pygments.org/) to colorize the
+expanded output. If `Pygments` is not available, the expanded code is not
+colorized. Install with `pip install Pygments`.
 
 ## Example
 
@@ -63,6 +65,14 @@ To expand without `rustfmt` even though it is available in `$PATH`:
 
 `$ RUSTFMT= cargo expand`
 
+To color with `pygmentize` different from the one in `$PATH`:
+
+`$ PYGMENTIZE=/path/to/pygmentize cargo expand`
+
+To not color even though `pygmentize` is available in `$PATH`:
+
+`$ PYGMENTIZE= cargo expand`
+
 ## License
 
 Licensed under either of

src/main.rs

@@ -1,58 +1,129 @@
 use std::env;
 use std::io::{self, Write};
-use std::process::{self, Command, Stdio};
+use std::process::{self, Command};
+
+#[cfg(unix)]
+use std::process::{Child, Stdio};
 
 extern crate isatty;
 use isatty::{stdout_isatty, stderr_isatty};
 
 fn main() {
+    let result = cargo_expand();
+    process::exit(match result {
+        Ok(code) => code,
+        Err(err) => {
+            let _ = writeln!(&mut io::stderr(), "{}", err);
+            1
+        }
+    });
+}
+
+#[cfg(windows)]
+fn cargo_expand() -> io::Result<i32> {
     // Build cargo command
-    let mut cargo = Command::new("cargo");
+    let mut cmd = Command::new("cargo");
-    cargo.args(&wrap_args(env::args()));
+    cmd.args(&wrap_args(env::args()));
+    run(cmd)
+}
 
-    // Run cargo command, print errors, exit if failed
+#[cfg(unix)]
-    let expanded = cargo.output().unwrap();
+fn cargo_expand() -> io::Result<i32> {
-    for line in String::from_utf8_lossy(&expanded.stderr).lines() {
+    if env::args().last().unwrap() == "--filter-rustfmt" {
-        writeln!(io::stderr(), "{}", line).unwrap();
+        filter_rustfmt();
-    }
-    if !expanded.status.success() {
-        process::exit(expanded.status.code().unwrap_or(1));
     }
 
-    let rustfmt = env::var("RUSTFMT").unwrap_or("rustfmt".to_string());
+    // Build cargo command
+    let mut cmd = Command::new("cargo");
+    cmd.args(&wrap_args(env::args()));
 
-    // Just print the expanded output if rustfmt is not available
+    // Pipe to rustfmt
-    if rustfmt == "" || !have_rustfmt() {
+    let _wait = match which_rustfmt() {
-        io::stdout().write_all(&expanded.stdout).unwrap();
+        Some(ref fmt) => {
-        return;
+            let args: Vec<_> = env::args().collect();
+            let mut filter_args = Vec::new();
+            for i in 0..args.len() {
+                filter_args.push(args[i].as_str());
+            }
+            filter_args.push("--filter-rustfmt");
+
+            Some((
+                // Work around $crate issue https://github.com/rust-lang/rust/issues/38016
+                try!(cmd.pipe_to(&["sed", "s/$crate/XCRATE/g"], None)),
+                try!(cmd.pipe_to(&[fmt], None)),
+                try!(cmd.pipe_to(&["sed", "s/XCRATE/$crate/g"], Some(&filter_args))),
+            ))
+        }
+        None => None,
+    };
+
+    // Pipe to pygmentize
+    let _wait = match which_pygmentize() {
+        Some(pyg) => Some(try!(cmd.pipe_to(&[&pyg, "-l", "rust"], None))),
+        None => None,
+    };
+
+    run(cmd)
+}
+
+fn run(mut cmd: Command) -> io::Result<i32> {
+    cmd.status().map(|status| status.code().unwrap_or(1))
+}
+
+#[cfg(unix)]
+struct Wait(Vec<Child>);
+
+#[cfg(unix)]
+impl Drop for Wait {
+    fn drop(&mut self) {
+        for child in &mut self.0 {
+            if let Err(err) = child.wait() {
+                let _ = writeln!(&mut io::stderr(), "{}", err);
+            }
+        }
+    }
+}
+
+#[cfg(unix)]
+trait PipeTo {
+    fn pipe_to(&mut self, out: &[&str], err: Option<&[&str]>) -> io::Result<Wait>;
+}
+
+#[cfg(unix)]
+impl PipeTo for Command {
+    fn pipe_to(&mut self, out: &[&str], err: Option<&[&str]>) -> io::Result<Wait> {
+        use std::os::unix::io::{AsRawFd, FromRawFd};
+
+        self.stdout(Stdio::piped());
+        if err.is_some() {
+            self.stderr(Stdio::piped());
         }
 
-    // Build rustfmt command and give it the expanded code
+        let child = try!(self.spawn());
-    let mut rustfmt = Command::new(rustfmt)
-        .stdin(Stdio::piped())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .spawn()
-        .unwrap();
-    rustfmt.stdin.as_mut().unwrap().write_all(&expanded.stdout).unwrap();
 
-    // Print rustfmt errors and exit if failed
+        *self = Command::new(out[0]);
-    let formatted = rustfmt.wait_with_output().unwrap();
+        self.args(&out[1..]);
-    for line in String::from_utf8_lossy(&formatted.stderr).lines() {
+        self.stdin(unsafe {
-        if !ignore_rustfmt_err(line) {
+            Stdio::from_raw_fd(child.stdout.as_ref().map(AsRawFd::as_raw_fd).unwrap())
-            writeln!(io::stderr(), "{}", line).unwrap();
+        });
-        }
-    }
-    if !formatted.status.success() {
-        let code = formatted.status.code().unwrap_or(1);
-        // Ignore code 3 which is formatting errors
-        if code != 3 {
-            process::exit(code);
-        }
-    }
 
-    // Print formatted output
+        match err {
-    io::stdout().write_all(&formatted.stdout).unwrap();
+            None => {
+                Ok(Wait(vec![child]))
+            }
+            Some(err) => {
+                let mut errcmd = Command::new(err[0]);
+                errcmd.args(&err[1..]);
+                errcmd.stdin(unsafe {
+                    Stdio::from_raw_fd(child.stderr.as_ref().map(AsRawFd::as_raw_fd).unwrap())
+                });
+                errcmd.stdout(Stdio::null());
+                errcmd.stderr(Stdio::inherit());
+                let spawn = try!(errcmd.spawn());
+                Ok(Wait(vec![spawn, child]))
+            }
+        }
+    }
 }
 
 // Based on https://github.com/rsolomo/cargo-check
@@ -87,19 +158,78 @@ fn wrap_args<T, I>(it: I) -> Vec<String>
     args
 }
 
-fn have_rustfmt() -> bool {
+#[cfg(unix)]
-    // FIXME https://github.com/rust-lang/rust/issues/38016
+fn which_rustfmt() -> Option<String> {
-    false
+    match env::var("RUSTFMT") {
-    /*Command::new("rustfmt")
+        Ok(which) => {
+            if which.is_empty() {
+                None
+            } else {
+                Some(which)
+            }
+        }
+        Err(_) => {
+            let have_rustfmt = Command::new("rustfmt")
                 .stdin(Stdio::null())
                 .stdout(Stdio::null())
                 .stderr(Stdio::null())
                 .spawn()
-        .is_ok()*/
+                .is_ok();
+            if have_rustfmt {
+                Some("rustfmt".to_string())
+            } else {
+                None
+            }
+        }
+    }
 }
 
-fn ignore_rustfmt_err(line: &str) -> bool {
+#[cfg(unix)]
-    line.is_empty()
+fn which_pygmentize() -> Option<String> {
-        || line.ends_with("line exceeded maximum length (sorry)")
+    match env::var("PYGMENTIZE") {
-        || line.ends_with("left behind trailing whitespace (sorry)")
+        Ok(which) => {
+            if which.is_empty() {
+                None
+            } else {
+                Some(which)
+            }
+        }
+        Err(_) => {
+            let have_pygmentize = Command::new("pygmentize")
+                .arg("-l")
+                .arg("rust")
+                .stdin(Stdio::null())
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .spawn()
+                .is_ok();
+            if have_pygmentize {
+                Some("pygmentize".to_string())
+            } else {
+                None
+            }
+        }
+    }
+}
+
+#[cfg(unix)]
+fn filter_rustfmt() -> ! {
+    let mut line = String::new();
+    while let Ok(n) = io::stdin().read_line(&mut line) {
+        if n == 0 {
+            break;
+        }
+        if !ignore_rustfmt_err(&line) {
+            let _ = write!(&mut io::stderr(), "{}", line);
+        }
+        line.clear();
+    }
+    process::exit(0);
+}
+
+#[cfg(unix)]
+fn ignore_rustfmt_err(line: &str) -> bool {
+    line.trim().is_empty()
+        || line.trim_right().ends_with("line exceeded maximum length (sorry)")
+        || line.trim_right().ends_with("left behind trailing whitespace (sorry)")
 }