v0.3.1

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tester"
-version = "0.3.0"
+version = "0.3.1"
 authors = ["Nugine <nugine@foxmail.com>"]
 edition = "2018"
 

README.md

@@ -27,17 +27,20 @@
 
 ## Usage
 
-    tester 0.3.0
+    tester 0.3.1
     Nugine <nugine@foxmail.com>
 
     USAGE:
-        tester [FLAGS] <target> [-- <args>...]
+        tester [FLAGS] [OPTIONS] <target> [-- <args>...]
 
     FLAGS:
         -h, --help       Prints help information
-        -j, --json       json output (stderr)
+        -j, --json       Json output
         -V, --version    Prints version information
 
+    OPTIONS:
+        -o, --output <output>    output file path (default stderr)
+
     ARGS:
         <target>     command to run
         <args>...    arguments to be passed
@@ -63,6 +66,8 @@ declare type TesterOutput = ({
 
 ## Changelog
 
++ Add option `--output` on `0.3.1`
+
 + Break changes on `0.3.0`
 
     delete `--arg`

src/main.rs

@@ -11,21 +11,42 @@ use crate::tester::{Tester, TraitTester};
 
 use structopt::StructOpt;
 
+#[inline(always)]
+fn err_exit<E: std::fmt::Display>(e: E) -> ! {
+    eprintln!("tester: {}", e);
+    std::process::exit(1)
+}
+
 fn main() {
     let opt = Opt::from_args();
 
-    let tester = Tester::new(opt.target, opt.args);
+    let json = opt.json;
+
+    use std::io::Write;
+    let mut output_file: Box<dyn Write> = match opt.output {
+        None => Box::new(std::io::stderr()),
+        Some(ref path) => match std::fs::File::create(path) {
+            Err(e) => err_exit(e),
+            Ok(f) => Box::new(f),
+        },
+    };
 
+    let tester = Tester::new(opt.target, opt.args);
     match tester.run() {
         Err(err) => {
-            eprintln!("tester: {}", err.msg());
-            std::process::exit(1);
+            if let Err(e) = writeln!(output_file, "tester: {}", err.msg()) {
+                err_exit(e)
+            }
         }
         Ok(out) => {
-            if opt.json {
-                eprintln!("{}", serde_json::to_string(&out).unwrap());
+            let out_string = if json {
+                serde_json::to_string(&out).unwrap()
             } else {
-                eprintln!("{}", out);
+                format!("{}", out)
+            };
+
+            if let Err(e) = writeln!(output_file, "{}", out_string) {
+                err_exit(e)
             }
         }
     }

src/opt.rs

@@ -8,9 +8,17 @@ pub struct Opt {
     #[structopt(parse(from_os_str), help = "command to run")]
     pub target: OsString,
 
-    #[structopt(short = "j", long = "json", help = "json output (stderr)")]
+    #[structopt(short = "j", long = "json", help = "Json output")]
     pub json: bool,
 
+    #[structopt(
+        short = "o",
+        long = "output",
+        parse(from_os_str),
+        help = "output file path (default stderr)"
+    )]
+    pub output: Option<OsString>,
+
     #[structopt(last = true, parse(from_os_str), help = "arguments to be passed")]
     pub args: Vec<OsString>,
 }