Adds expect function mirroring expect! macro.

resolves #15

Author: jeremyBanks

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 1.4.0
+
+* Add non-macro versions of `expect` and `expect_file` ([#32])
+
 # 1.3.0
 
 * Add `data()` getter to Expect ([#31])
@@ -13,6 +17,7 @@
 
 * No changelog until this point :-(
 
+[#32]: https://github.com/rust-analyzer/expect-test/pull/32
 [#31]: https://github.com/rust-analyzer/expect-test/pull/31
 [#27]: https://github.com/rust-analyzer/expect-test/pull/27
 [#26]: https://github.com/rust-analyzer/expect-test/pull/26

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "expect-test"
-version = "1.3.0"
+version = "1.4.0"
 description = "Minimalistic snapshot testing library"
 keywords = ["snapshot", "testing", "expect"]
 categories = ["development-tools::testing"]

src/lib.rs

@@ -163,7 +163,7 @@ fn update_expect() -> bool {
     env::var("UPDATE_EXPECT").is_ok()
 }
 
-/// Creates an instance of `Expect` from string literal:
+/// Creates an instance of `Expect` from a string literal:
 ///
 /// ```
 /// # use expect_test::expect;
@@ -190,6 +190,61 @@ macro_rules! expect {
     [[]] => { $crate::expect![[""]] };
 }
 
+/// Creates an instance of `Expect` from a string literal:
+///
+/// ```
+/// # use expect_test::expect;
+/// expect!("
+///     Foo { value: 92 }
+/// ");
+/// expect!(r#"{"Foo": 92}"#);
+/// ```
+///
+/// Leading indentation is stripped.
+///
+/// This uses the `#[track_caller]` attribute to resolve relative file paths.
+/// This [may not work as expected][1] if this is called from a function which als uses `#[track_caller]`,
+/// or if the toolchain is [configured to strip caller information][2].
+/// In these cases you may use the macro form, [`expect!`].
+///
+/// [1]: https://github.com/rust-analyzer/expect-test/issues/15#issuecomment-939308821
+/// [2]: https://doc.rust-lang.org/beta/unstable-book/compiler-flags/location-detail.html
+#[track_caller]
+pub fn expect(data: impl ExpectedData) -> Expect {
+    let location = std::panic::Location::caller();
+    Expect {
+        position: Position {
+            file: location.file(),
+            line: location.line(),
+            column: location.column(),
+        },
+        data: data.str(),
+        indent: true,
+    }
+}
+
+pub trait ExpectedData {
+    fn str(&self) -> &'static str;
+}
+
+impl ExpectedData for &'static str {
+    fn str(&self) -> &'static str {
+        self
+    }
+}
+
+impl ExpectedData for [&'static str; 1] {
+    fn str(&self) -> &'static str {
+        self[0]
+    }
+}
+
+impl ExpectedData for [&'static str; 0] {
+    fn str(&self) -> &'static str {
+        ""
+    }
+}
+
 /// Creates an instance of `ExpectFile` from relative or absolute path:
 ///
 /// ```
@@ -212,9 +267,9 @@ macro_rules! expect_file {
 /// ```
 ///
 /// This uses the `#[track_caller]` attribute to resolve relative file paths.
-/// They [won't work correctly][1] if this is called from a function which also uses `#[track_caller]`,
+/// This [may not work as expected][1] if this is called from a function which als uses `#[track_caller]`,
 /// or if the toolchain is [configured to strip caller information][2].
-/// In these cases you must use the macro form, [`expect_file!`].
+/// In these cases you may use the macro form, [`expect_file!`].
 ///
 /// [1]: https://github.com/rust-analyzer/expect-test/issues/15#issuecomment-939308821
 /// [2]: https://doc.rust-lang.org/beta/unstable-book/compiler-flags/location-detail.html
@@ -330,22 +385,19 @@ impl Expect {
         let mut line_start = 0;
         for (i, line) in lines_with_ends(file).enumerate() {
             if i == self.position.line as usize - 1 {
-                // `column` points to the first character of the macro invocation:
+                // `column` points to the first character of the macro invocation/function call:
                 //
-                //    expect![[r#""#]]        expect![""]
-                //    ^       ^               ^       ^
-                //  column   offset                 offset
+                //    expect![[r#""#]]    expect![""]    expect("")   expect([""])
+                //    ^       ^           ^       ^      ^      ^     ^       ^
+                //  column   offset
                 //
-                // Seek past the exclam, then skip any whitespace and
-                // the macro delimiter to get to our argument.
+                // we seek until we find the first character of the string literal, if present.
                 let byte_offset = line
                     .char_indices()
                     .skip((self.position.column - 1).try_into().unwrap())
-                    .skip_while(|&(_, c)| c != '!')
-                    .skip(1) // !
-                    .skip_while(|&(_, c)| c.is_whitespace())
-                    .skip(1) // [({
-                    .skip_while(|&(_, c)| c.is_whitespace())
+                    .skip_while(|&(_, c)| !matches!(c, '[' | '(' | '{'))
+                    // .skip_while(|&(_, c)| matches!(c, '[' | '(' | '{') || c.is_whitespace())
+                    .skip(1)
                     .next()
                     .expect("Failed to parse macro invocation")
                     .0;
@@ -365,29 +417,35 @@ impl Expect {
         let literal_start = literal_start + (lit_to_eof.len() - lit_to_eof_trimmed.len());
 
         let literal_len =
-            locate_end(lit_to_eof_trimmed).expect("Couldn't find closing delimiter for `expect!`.");
+            locate_end(lit_to_eof_trimmed).expect("Couldn't find closing delimiter for `expect`.");
         let literal_range = literal_start..literal_start + literal_len;
         Location { line_indent, literal_range }
     }
 }
 
 fn locate_end(arg_start_to_eof: &str) -> Option<usize> {
-    match arg_start_to_eof.chars().next()? {
-        c if c.is_whitespace() => panic!("skip whitespace before calling `locate_end`"),
-
-        // expect![[]]
-        '[' => {
+    let c = arg_start_to_eof.chars().next()?;
+    if c.is_whitespace() {
+        panic!("skip whitespace before calling `locate_end`")
+    }
+    match c {
+        // expect![["..."]] | expect!(["..."])
+        '[' | '(' => {
+            let end = if c == '[' { ']' } else { ')' };
             let str_start_to_eof = arg_start_to_eof[1..].trim_start();
+            if str_start_to_eof.chars().next() == Some(end) {
+                return Some(2);
+            }
             let str_len = find_str_lit_len(str_start_to_eof)?;
             let str_end_to_eof = &str_start_to_eof[str_len..];
-            let closing_brace_offset = str_end_to_eof.find(']')?;
+            let closing_brace_offset = str_end_to_eof.find(end)?;
             Some((arg_start_to_eof.len() - str_end_to_eof.len()) + closing_brace_offset + 1)
         }
 
         // expect![] | expect!{} | expect!()
         ']' | '}' | ')' => Some(0),
 
-        // expect!["..."] | expect![r#"..."#]
+        // expect!["..."] | expect![r#"..."#] | expect("...")
         _ => find_str_lit_len(arg_start_to_eof),
     }
 }
@@ -746,7 +804,14 @@ mod tests {
 
     #[test]
     fn test_trivial_assert() {
-        expect!["5"].assert_eq("5");
+        expect!["1"].assert_eq("1");
+        expect!["2"].assert_eq("2");
+    }
+
+    #[test]
+    fn test_trivial_assert_fn() {
+        expect("3").assert_eq("3");
+        expect("4").assert_eq("4");
     }
 
     #[test]
@@ -766,15 +831,15 @@ mod tests {
         expect![[r##"[r#"{"foo": 42}"#]"##]].assert_eq(&patch);
 
         let patch = format_patch(Some(0), "hello\nworld\n");
-        expect![[r##"
+        expect([r##"
             [r#"
                 hello
                 world
-            "#]"##]]
+            "#]"##])
         .assert_eq(&patch);
 
         let patch = format_patch(Some(4), "single line");
-        expect![[r#""single line""#]].assert_eq(&patch);
+        expect([r#""single line""#]).assert_eq(&patch);
     }
 
     #[test]