Use cargo's pretty printing for diagnostics

Also generally improves diagnostic messages and docs, and cleans
up (slightly) how we handle the --args option

Includes bump to 0.1.2

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cargo-instruments"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["Colin Rofls <[email protected]>"]
 license = "MIT"
 description = "Generate Xcode Instruments trace files for binary targets."
@@ -16,3 +16,4 @@ chrono = "0.4.6"
 cargo = "0.34.0"
 failure = "0.1.5"
 structopt = { version = "0.2", default-features = false }
+termcolor = "1.0"

src/app.rs

@@ -1,11 +1,13 @@
 //! The main application logic.
 
 use std::path::PathBuf;
+use std::process::Command;
 
 use cargo::core::Workspace;
 use cargo::ops::CompileOptions;
 use cargo::util::config::Config;
 use failure::{format_err, Error};
+use termcolor::Color;
 
 use crate::instruments;
 use crate::opt::{CargoOpts, Opts, Target};
@@ -26,9 +28,32 @@ pub(crate) fn run(args: Opts) -> Result<(), Error> {
  let workspace = Workspace::new(&manifest_path, &cfg)?;
  let workspace_root = manifest_path.parent().unwrap().to_owned();
 
- let exec_path = build_target(&args, &workspace)?;
+ let exec_path = match build_target(&args, &workspace) {
+ Ok(path) => path,
+ Err(e) => {
+ workspace.config().shell().status_with_color("Failed", &e, Color::Red)?;
+ return Ok(());
+ }
+ };
+
+ let relpath = exec_path.strip_prefix(&workspace_root).unwrap_or(exec_path.as_path());
+ workspace.config().shell().status("Profiling", relpath.to_string_lossy())?;
 
- instruments::run(&args, exec_path, workspace_root)
+ let trace_path = match instruments::run(&args, exec_path, &workspace_root) {
+ Ok(path) => path,
+ Err(e) => {
+ workspace.config().shell().status_with_color("Failed", &e, Color::Red)?;
+ return Ok(());
+ }
+ };
+
+ let reltrace = trace_path.strip_prefix(&workspace_root).unwrap_or(trace_path.as_path());
+ workspace.config().shell().status("Wrote Trace", reltrace.to_string_lossy())?;
+ if args.open {
+ workspace.config().shell().status("Opening", reltrace.to_string_lossy())?;
+ open_file(&trace_path)?;
+ }
+ Ok(())
 }
 
 /// Attempts to build the specified target. On success, returns the path to
@@ -102,3 +127,12 @@ fn validate_target(target: &Target, workspace: &Workspace) -> Result<(), Error>
  Ok(())
  }
 }
+
+fn open_file(file: &PathBuf) -> Result<(), Error> {
+ let status = Command::new("open").arg(file).status()?;
+
+ if !status.success() {
+ return Err(format_err!("open failed"));
+ }
+ Ok(())
+}

src/instruments.rs

@@ -63,7 +63,11 @@ pub(crate) fn list() -> Result<String, Error> {
  Ok(output)
 }
 
-pub(crate) fn run(args: &Opts, exec_path: PathBuf, workspace_root: PathBuf) -> Result<(), Error> {
+pub(crate) fn run(
+ args: &Opts,
+ exec_path: PathBuf,
+ workspace_root: &PathBuf,
+) -> Result<PathBuf, Error> {
  let outfile = get_out_file(args, &exec_path, &workspace_root)?;
  let template = resolve_template(&args);
 
@@ -80,17 +84,15 @@ pub(crate) fn run(args: &Opts, exec_path: PathBuf, workspace_root: PathBuf) -> R
  command.args(args.target_args.as_slice());
  }
 
- let status = command.status()?;
-
- if !status.success() {
- return Err(format_err!("instruments failed"));
- }
+ let output = command.output()?;
 
- if args.open {
- open_file(&outfile)?;
+ if !output.status.success() {
+ let stderr =
+ String::from_utf8(output.stderr).unwrap_or(String::from("failed to capture stderr"));
+ Err(format_err!("instruments errored: {}", stderr))
+ } else {
+ Ok(outfile)
  }
-
- Ok(())
 }
 
 fn get_out_file(
@@ -125,15 +127,6 @@ fn get_target_dir(workspace_root: &PathBuf) -> Result<PathBuf, Error> {
  Ok(target_dir)
 }
 
-fn open_file(file: &PathBuf) -> Result<(), Error> {
- let status = Command::new("open").arg(file).status()?;
-
- if !status.success() {
- return Err(format_err!("open failed"));
- }
- Ok(())
-}
-
 fn now_timestamp() -> impl std::fmt::Display {
  use chrono::prelude::*;
  let now = Local::now();

src/opt.rs

@@ -1,6 +1,5 @@
 //! CLI argument handling
 
-use std::ffi::OsString;
 use std::fmt;
 use std::path::PathBuf;
 use structopt::StructOpt;
@@ -49,9 +48,10 @@ pub(crate) struct Opts {
  #[structopt(long)]
  pub(crate) open: bool,
 
- /// Arguments passed to the target binary
- #[structopt(short = "a", long = "args", parse(from_os_str))]
- pub(crate) target_args: Vec<OsString>,
+ /// Arguments passed to the target binary. If you're having trouble,
+ /// try wrapping args in double and single quotes, like --args '"-h --fun plz"'.
+ #[structopt(short = "a", long = "args", value_name = "ARGS")]
+ pub(crate) target_args: Vec<String>,
 }
 
 /// The target, parsed from args.
@@ -128,4 +128,14 @@ mod tests {
  let opts = Opts::from_iter(&["instruments"]);
  assert_eq!(opts.limit, None);
  }
+
+
+ #[test]
+ fn var_args() {
+ // this isn't ideal, but works for now
+ let opts = Opts::from_iter(&["instruments", "alloc", "--limit", "808", "--args", "hi -h --bin"]);
+ assert_eq!(opts.template, "alloc");
+ assert_eq!(opts.limit, Some(808));
+ assert_eq!(opts.target_args, vec!["hi -h --bin"]);
+ }
 }