Add StringMatching assertion for regular expressions

Closes #6

Author: rliebz

README.md

@@ -109,6 +109,7 @@ g.Should(be.DeepEqual([]string{"a", "b"}, []string{"a", "b"}))
 
 g.Should(be.SliceContaining([]int{1, 2, 3}, 2))
 g.Should(be.StringContaining("foobar", "foo"))
+g.Should(be.StringMatching("foobar", `^foo`))
 
 var err error
 g.NoError(err)

be/assertions.go

@@ -3,6 +3,7 @@ package be
 import (
 	"fmt"
 	"reflect"
+	"regexp"
 	"strconv"
 	"strings"
 
@@ -442,6 +443,51 @@ substr: %s
 	}
 }
 
+// StringMatching asserts that a given string matches a regular expression.
+func StringMatching(str string, expr string) ghost.Result {
+	args := ghostlib.ArgsFromAST(str, expr)
+	argStr, argExpr := args[0], args[1]
+
+	re, err := regexp.Compile(expr)
+	if err != nil {
+		return ghost.Result{
+			Ok: false,
+			Message: fmt.Sprintf(`%v is not a valid regular expression
+%v
+`,
+				argExpr,
+				err,
+			),
+		}
+	}
+
+	if re.MatchString(str) {
+		return ghost.Result{
+			Ok: true,
+			Message: fmt.Sprintf(`%v matches regular expression %v
+str:  %s
+expr: %s
+`,
+				argStr, argExpr,
+				quoteString(str),
+				re.String(),
+			),
+		}
+	}
+
+	return ghost.Result{
+		Ok: false,
+		Message: fmt.Sprintf(`%v does not match regular expression %v
+str:  %s
+expr: %s
+`,
+			argStr, argExpr,
+			quoteString(str),
+			re.String(),
+		),
+	}
+}
+
 // True asserts that a value is true.
 func True(b bool) ghost.Result {
 	args := ghostlib.ArgsFromAST(b)

be/assertions_test.go

@@ -919,6 +919,67 @@ substr: "two"
 	})
 }
 
+func TestStringMatching(t *testing.T) {
+	t.Run("matches", func(t *testing.T) {
+		g := ghost.New(t)
+
+		str := "foobar"
+		expr := "^foo"
+
+		result := be.StringMatching(str, expr)
+		g.Should(be.True(result.Ok))
+		g.Should(be.Equal(result.Message, `str matches regular expression expr
+str:  "foobar"
+expr: ^foo
+`))
+
+		result = be.StringMatching("foobar", "^foo")
+		g.Should(be.True(result.Ok))
+		g.Should(be.Equal(result.Message, `"foobar" matches regular expression "^foo"
+str:  "foobar"
+expr: ^foo
+`))
+	})
+
+	t.Run("does not match", func(t *testing.T) {
+		g := ghost.New(t)
+
+		str := "foobar"
+		expr := "^foo$"
+
+		result := be.StringMatching(str, expr)
+		g.Should(be.False(result.Ok))
+		g.Should(be.Equal(result.Message, `str does not match regular expression expr
+str:  "foobar"
+expr: ^foo$
+`))
+
+		result = be.StringMatching("foobar", "^foo$")
+		g.Should(be.False(result.Ok))
+		g.Should(be.Equal(result.Message, `"foobar" does not match regular expression "^foo$"
+str:  "foobar"
+expr: ^foo$
+`))
+	})
+
+	t.Run("invalid", func(t *testing.T) {
+		g := ghost.New(t)
+
+		str := "foobar"
+		expr := "^foo\\j"
+
+		result := be.StringMatching(str, expr)
+		g.Should(be.False(result.Ok))
+		g.Should(be.Equal(result.Message, `expr is not a valid regular expression
+error parsing regexp: invalid escape sequence: `+"`\\j`\n"))
+
+		result = be.StringMatching("foobar", "^foo\\j")
+		g.Should(be.False(result.Ok))
+		g.Should(be.Equal(result.Message, `"^foo\\j" is not a valid regular expression
+error parsing regexp: invalid escape sequence: `+"`\\j`\n"))
+	})
+}
+
 func TestTrue(t *testing.T) {
 	t.Run("true", func(t *testing.T) {
 		g := ghost.New(t)

example_test.go

@@ -26,6 +26,7 @@ func TestExample(t *testing.T) {
 	g.Should(be.SliceLen([]string{"a", "b", "c"}, 3))
 
 	g.Should(be.StringContaining("foobar", "foo"))
+	g.Should(be.StringMatching("foobar", `^foo`))
 
 	var err error
 	g.NoError(err)