refactor assert_cmd! macro

- fix #22
- fix #15

Author: colin-kiegel

Cargo.toml

@@ -16,6 +16,7 @@ build = "build.rs"
 colored = "1.4"
 difference = "1.0"
 error-chain = "0.10.0"
+rustc-serialize = "0.3"
 
 [build-dependencies]
 skeptic = "0.5"

README.md

@@ -42,17 +42,17 @@ And here is one that will fail (which also shows `execute` which returns a
 #[macro_use] extern crate assert_cli;
 
 fn main() {
-    let test = assert_cmd!(grep amet Cargo.toml)
+    let test = assert_cmd!(grep amet "Cargo.toml")
         .fails_with(1)
         .execute();
-    assert!(test.is_err());
+    assert!(test.is_ok());
 }
 ```
 
 If you want to match the program's output _exactly_, you can use
 `prints_exactly`:
 
-```rust,should_panic="Assert CLI failure"
+```rust,should_panic
 #[macro_use] extern crate assert_cli;
 
 fn main() {

src/lib.rs

@@ -75,6 +75,7 @@
 
 extern crate difference;
 #[macro_use] extern crate error_chain;
+extern crate rustc_serialize;
 
 use std::process::{Command, Output};
 use std::fmt;
@@ -84,6 +85,9 @@ use difference::Changeset;
 mod errors;
 use errors::*;
 
+#[macro_use] mod macros;
+pub use macros::flatten_escaped_string;
+
 mod diff;
 
 /// Assertions for a specific command.
@@ -448,41 +452,3 @@ impl Assert {
         }
     }
 }
-
-/// Easily construct an `Assert` with a custom command.
-///
-/// Make sure to include the crate as `#[macro_use] extern crate assert_cli;` if
-/// you want to use this macro.
-///
-/// # Examples
-///
-/// To test that our very complex cli applications succeeds and prints some
-/// text to stdout that contains
-///
-/// ```plain
-/// No errors whatsoever
-/// ```
-///
-/// ...,  you would call it like this:
-///
-/// ```rust
-/// #[macro_use] extern crate assert_cli;
-/// # fn main() {
-/// assert_cmd!(echo "Launch sequence initiated.\nNo errors whatsoever!\n")
-///     .succeeds()
-///     .prints("No errors whatsoever")
-///     .unwrap();
-/// # }
-/// ```
-///
-/// The macro will try to convert its arguments as strings, but is limited by
-/// Rust's default tokenizer, e.g., you always need to quote CLI arguments
-/// like `"--verbose"`.
-#[macro_export]
-macro_rules! assert_cmd {
-    ($($x:tt)+) => {{
-        $crate::Assert::command(
-            &[$(stringify!($x)),*]
-        )
-    }}
-}

src/macros.rs

@@ -0,0 +1,99 @@
+use std::borrow::Cow;
+use rustc_serialize::json::Json;
+
+/// Easily construct an `Assert` with a custom command.
+///
+/// Make sure to include the crate as `#[macro_use] extern crate assert_cli;` if
+/// you want to use this macro.
+///
+/// # Examples
+///
+/// To test that our very complex cli applications succeeds and prints some
+/// text to stdout that contains
+///
+/// ```plain
+/// No errors whatsoever
+/// ```
+///
+/// ...,  you would call it like this:
+///
+/// ```rust
+/// #[macro_use] extern crate assert_cli;
+/// # fn main() {
+/// assert_cmd!(echo "Launch sequence initiated.\nNo errors whatsoever!\n")
+///     .succeeds()
+///     .prints("No errors whatsoever")
+///     .unwrap();
+/// # }
+/// ```
+///
+/// The macro will try to convert its arguments as strings, but is limited by
+/// Rust's default tokenizer, e.g., you always need to quote CLI arguments
+/// like `"--verbose"`.
+#[macro_export]
+macro_rules! assert_cmd {
+    ($($x:tt)+) => {{
+        $(__assert_single_token_expression!(@CHECK $x);)*
+
+        $crate::Assert::command(
+            &[$(
+                $crate::flatten_escaped_string(stringify!($x)).as_ref()
+            ),*]
+        )
+    }}
+}
+
+/// Deserialize a JSON-encoded `String`.
+///
+/// # Panics
+///
+/// If `x` can not be decoded as `String`.
+#[doc(hidden)]
+fn deserialize_json_string(x: &str) -> String {
+    match Json::from_str(x).expect(&format!("Unable to deserialize `{:?}` as string.", x)) {
+        Json::String(deserialized) => deserialized,
+        _ => panic!("Unable to deserialize `{:?}` as string.", x),
+    }
+}
+
+/// Deserialize a JSON-encoded `String`.
+///
+/// # Panics
+///
+/// If `x` can not be decoded as `String`.
+#[doc(hidden)]
+pub fn flatten_escaped_string(x: &str) -> Cow<str> {
+    if x.starts_with('"') && x.ends_with('"') {
+        Cow::Owned(deserialize_json_string(x))
+    } else {
+        Cow::Borrowed(x)
+    }
+}
+
+/// Inspect a single token and decide if it is safe to `stringify!`, without loosing
+/// information about whitespaces, to address https://github.com/killercup/assert_cli/issues/22.
+///
+/// Call like `__assert_single_token_expression!(@CHECK x)`, where `x` can be any token to check.
+///
+/// This macro will only accept single tokens, which parse as expressions, e.g.
+/// - strings "foo", r#"foo"
+/// - idents `foo`, `foo42`
+/// - numbers `42`
+/// - chars `'a'`
+///
+/// Delimited token trees `{...}` and the like are rejected. Everything thats not an expression
+/// will also be rejected.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __assert_single_token_expression {
+    // deny `{...}`
+    (@CHECK {$( $x:tt )*}) => { assert_cmd!(@DENY {$( $x )*}) };
+    // deny `(...)`
+    (@CHECK ($( $x:tt )*)) => { assert_cmd!(@DENY {$( $x )*}) };
+    // deny `[...]`
+    (@CHECK [$( $x:tt )*]) => { assert_cmd!(@DENY {$( $x )*}) };
+    // only allow tokens that parse as expression
+    (@CHECK $x:expr) => { };
+    // little helper
+    (@DENY) => { };
+}