feature: string equal by line transformers

Author: halimath

README.md

@@ -114,6 +114,18 @@ chain. In addition, `is.Error` also supports the target error to be `nil`. In th
 behaves identical to `is.Error(v)`. This allows an easy and convenient way of writing table based tests that
 expect both error and non-error conditions.
 
+### `EqualToStringByLines`
+
+The `EqualToStringByLines` expectation effectively works like `EqualTo` on strings. The difference arises when
+the two strings are _not_ equal. If both strings are longer, multiline strings, catching a small difference
+can be hard to do. In those situations `EqualToStringByLines` helps by reporting differences on a per-line
+basis. This makes locating the differences and fixing code/adjusting the tests much easier. In addition,
+`EqualToStringByLines` supports _transformers_ - simple functions that preprocess each line - before the
+transformation results are compared. This makes it much easisier to place expected string values in code as
+multiline raw string literals. Those string literal's lines usually follow the current indentation depth
+which makes them unequal to a (flat) given value. Using the `Dedent` transformer can easily compensate for
+this keeping the expectation indented "correcly" (which regards to code formatting) but the test won't fail.
+
 ### Deep equality
 
 The `is.DeepEqualTo` expectation is special as compared to the other ones. It uses a recursive algorithm to 

is/string.go

@@ -2,6 +2,7 @@ package is
 
 import (
 	"strings"
+	"unicode"
 
 	"github.com/halimath/expect"
 )
@@ -51,10 +52,22 @@ func StringWithSuffix(got, want string) expect.Expectation {
 	})
 }
 
+// Dedent is intended to be used as a transformer passed to [EqualToStringByLines].
+// It removes any prefix whitespace from s thus dedenting each line. This is
+// especially usefull if the expected value for a test is written in code as an
+// indented multiline raw string literal but the actual lines are not indented.
+func DedentLines(s string) string {
+	return strings.TrimLeftFunc(s, unicode.IsSpace)
+}
+
 // EqualToStringByLines compares got and want line by line and reports different
 // lines one at a time. This makes it easiert to understand failed expectations
 // when comparing large strings.
-func EqualToStringByLines(got, want string) expect.Expectation {
+//
+// transformers are applied to all lines, both those obtained from got and want.
+// transformers are applied in order (iteratively) and the final transformation
+// result is used for comparison.
+func EqualToStringByLines(got, want string, transformers ...func(string) string) expect.Expectation {
 	return expect.ExpectFunc(func(t expect.TB) {
 		t.Helper()
 
@@ -70,7 +83,15 @@ func EqualToStringByLines(got, want string) expect.Expectation {
 		limit := min(len(gotLines), len(wantLines))
 
 		for i := 0; i < limit; i++ {
-			if wantLines[i] != gotLines[i] {
+			gotLine := gotLines[i]
+			wantLine := wantLines[i]
+
+			for _, transformer := range transformers {
+				gotLine = transformer(gotLine)
+				wantLine = transformer(wantLine)
+			}
+
+			if gotLine != wantLine {
 				t.Errorf("at line %d: wanted\n%q\nbut got\n%q", i, wantLines[i], gotLines[i])
 				if lenghtsDiffer {
 					return

is/string_test.go

@@ -79,6 +79,7 @@ func TestEqualToStringByLines(t *testing.T) {
 	EqualToStringByLines("foo\nbar", "foo").Expect(&tb)
 	EqualToStringByLines("foo", "foo\nbar").Expect(&tb)
 	EqualToStringByLines("foo\nbar", "foo\nspam").Expect(&tb)
+	EqualToStringByLines("foo\n  bar", "foo\n\tbar", DedentLines).Expect(&tb)
 
 	if !reflect.DeepEqual(tb, testhelper.TB{
 		ErrFlag: true,