Merge pull request #12 from rust-lang/unstable-api-new-features

Add new features to `unstable-api` tool.

Author: m-ou-se

tools/unstable-api/Cargo.toml

@@ -19,3 +19,6 @@ version = "0.3"
 
 [dependencies.anyhow]
 version = "1"
+
+[target.'cfg(unix)'.dependencies]
+nix = "0.20"

tools/unstable-api/README.md

@@ -7,7 +7,7 @@ This tool will dump the public API for an unstable feature.
 From this directory, run something like:
 
 ```shell
-cargo run --release -- --feature $feature --repo-root $path_to_rust | rustfmt
+cargo run --release -- --feature $feature --repo-root $path_to_rust
 ```
 
 where `$feature` is the name of the unstable feature and `$path_to_rust` is the path to a local clone of `rust-lang/rust`. You'll probably need to run `x.py` first to make sure submodules are cloned.
@@ -16,9 +16,16 @@ You can also install it as a Cargo tool and use it that way:
 
 ```shell
 cargo install --path .
-cargo unstable-api --feature $feature --repo-root $path_to_rust | rustfmt
+cd $path_to_rust
+cargo unstable-api --feature $feature
 ```
 
+You can leave out the `--repo-root` option when running it inside the `rust-lang/rust` repository.
+
+## Output formatting
+
+On Unix, the output is automatically formatted with `rustfmt` and highlighted with `bat`, if you have those tools installed.
+
 ## Limitations
 
 APIs that are generated by macros won't be picked up. This tool just parses the source code so it can be run without needing to build the standard library itself.

tools/unstable-api/src/main.rs

@@ -1,6 +1,6 @@
 use std::{env, path::PathBuf};
 
-use anyhow::Error;
+use anyhow::{Context, Error};
 use structopt::StructOpt;
 
 mod util;
@@ -14,33 +14,26 @@ mod visit;
 struct Opt {
     /// Repository root of `rust-lang/rust`.
     #[structopt(long, parse(from_os_str))]
-    repo_root: PathBuf,
+    repo_root: Option<PathBuf>,
     #[structopt(long)]
     feature: String,
 }
 
 fn main() -> Result<(), Error> {
     let opt = Opt::from_iter(env::args().filter(|arg| arg != "unstable-api"));
 
+    let repo_root = match opt.repo_root {
+        Some(p) => p,
+        None => find_repo_root()?,
+    };
+
+    #[cfg(unix)]
+    setup_output_formatting();
+
     let libs = vec![
-        {
-            let mut lib_core = opt.repo_root.clone();
-            lib_core.push("library");
-            lib_core.push("core");
-            lib_core
-        },
-        {
-            let mut lib_alloc = opt.repo_root.clone();
-            lib_alloc.push("library");
-            lib_alloc.push("alloc");
-            lib_alloc
-        },
-        {
-            let mut lib_std = opt.repo_root.clone();
-            lib_std.push("library");
-            lib_std.push("std");
-            lib_std
-        },
+        repo_root.clone().join("library/core"),
+        repo_root.clone().join("library/alloc"),
+        repo_root.clone().join("library/std"),
     ];
 
     for crate_root in libs {
@@ -49,3 +42,47 @@ fn main() -> Result<(), Error> {
 
     Ok(())
 }
+
+fn find_repo_root() -> Result<PathBuf, Error> {
+    let path = std::process::Command::new("cargo")
+        .arg("locate-project")
+        .arg("--workspace")
+        .arg("--message-format=plain")
+        .output()
+        .context("unable to find repository root")?
+        .stdout;
+    let mut path = PathBuf::from(String::from_utf8(path)?);
+    path.pop();
+    Ok(path)
+}
+
+#[cfg(unix)]
+fn setup_output_formatting() {
+    use nix::unistd::{isatty, dup2};
+    use std::os::unix::io::AsRawFd;
+    use std::process::{Command, Stdio};
+
+    if isatty(1) == Ok(true) {
+        // Pipe the output through `bat` for nice formatting and paging, if available.
+        if let Ok(mut bat) = Command::new("bat")
+            .arg("--language=rust")
+            .arg("--plain") // Disable line numbers for easy copy-pasting.
+            .stdin(Stdio::piped())
+            .stdout(Stdio::inherit())
+            .spawn()
+        {
+            // Replace our stdout by the pipe into `bat`.
+            dup2(bat.stdin.take().unwrap().as_raw_fd(), 1).unwrap();
+        }
+    }
+
+    // Pipe the output through `rustfmt`, if available.
+    if let Ok(mut rustfmt) = Command::new("rustfmt")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::inherit()) // This pipes into `bat` if it was executed above.
+        .spawn()
+    {
+        // Replace our stdout by the pipe into `rustfmt`.
+        dup2(rustfmt.stdin.take().unwrap().as_raw_fd(), 1).unwrap();
+    }
+}