From 7bf1abfc55d8a6898f04f0da309a03213cb49806 Mon Sep 17 00:00:00 2001
From: Joe Mooring <joe.mooring@veriphor.com>
Date: Thu, 4 Apr 2024 08:22:33 -0700
Subject: tpl/strings: Improve type checking

---
 tpl/strings/strings.go      | 26 +++++++++++++++--------
 tpl/strings/strings_test.go | 50 +++++++++++++++++++++++++++++++++------------
 2 files changed, 54 insertions(+), 22 deletions(-)

diff --git a/tpl/strings/strings.go b/tpl/strings/strings.go
index e6f7aed80..02f9a2b1e 100644
--- a/tpl/strings/strings.go
+++ b/tpl/strings/strings.go
@@ -162,24 +162,32 @@ func (ns *Namespace) ContainsAny(s, chars any) (bool, error) {
 // ContainsNonSpace reports whether s contains any non-space characters as defined
 // by Unicode's White Space property,
 // <docsmeta>{"newIn": "0.111.0" }</docsmeta>
-func (ns *Namespace) ContainsNonSpace(s any) bool {
-	ss := cast.ToString(s)
+func (ns *Namespace) ContainsNonSpace(s any) (bool, error) {
+	ss, err := cast.ToStringE(s)
+	if err != nil {
+		return false, err
+	}
 
 	for _, r := range ss {
 		if !unicode.IsSpace(r) {
-			return true
+			return true, nil
 		}
 	}
-	return false
+	return false, nil
 }
 
 // Diff returns an anchored diff of the two texts old and new in the “unified
 // diff” format. If old and new are identical, Diff returns an empty string.
-func (ns *Namespace) Diff(oldname string, old any, newname string, new any) string {
-	oldb := []byte(cast.ToString(old))
-	newb := []byte(cast.ToString(new))
-
-	return string(diff.Diff(oldname, oldb, newname, newb))
+func (ns *Namespace) Diff(oldname string, old any, newname string, new any) (string, error) {
+	olds, err := cast.ToStringE(old)
+	if err != nil {
+		return "", err
+	}
+	news, err := cast.ToStringE(new)
+	if err != nil {
+		return "", err
+	}
+	return string(diff.Diff(oldname, []byte(olds), newname, []byte(news))), nil
 }
 
 // HasPrefix tests whether the input s begins with prefix.
diff --git a/tpl/strings/strings_test.go b/tpl/strings/strings_test.go
index 92767925a..4fcd3b59a 100644
--- a/tpl/strings/strings_test.go
+++ b/tpl/strings/strings_test.go
@@ -153,17 +153,30 @@ func TestContainsNonSpace(t *testing.T) {
 	for _, test := range []struct {
 		s      any
 		expect bool
+		isErr  bool
 	}{
-		{"", false},
-		{" ", false},
-		{"        ", false},
-		{"\t", false},
-		{"\r", false},
-		{"a", true},
-		{"    a", true},
-		{"a\n", true},
+		{"", false, false},
+		{" ", false, false},
+		{"        ", false, false},
+		{"\t", false, false},
+		{"\r", false, false},
+		{"a", true, false},
+		{"    a", true, false},
+		{"a\n", true, false},
+		// error
+		{tstNoStringer{}, false, true},
 	} {
-		c.Assert(ns.ContainsNonSpace(test.s), qt.Equals, test.expect)
+
+		result, err := ns.ContainsNonSpace(test.s)
+
+		if test.isErr {
+			c.Assert(err, qt.IsNotNil)
+			continue
+		}
+
+		c.Assert(err, qt.IsNil)
+		c.Assert(result, qt.Equals, test.expect)
+
 	}
 }
 
@@ -812,21 +825,32 @@ func TestDiff(t *testing.T) {
 	t.Parallel()
 	c := qt.New(t)
 
-	for _, tt := range []struct {
+	for _, test := range []struct {
 		oldname string
 		old     any
 		newname string
 		new     any
-		expect  string
+		expect  any
 	}{
 		{"old", "foo\n", "new", "bar\n", "diff old new\n--- old\n+++ new\n@@ -1,1 +1,1 @@\n-foo\n+bar\n"},
 		{"old", "foo\n", "new", "foo\n", ""},
 		{"old", "foo\n", "new", "", "diff old new\n--- old\n+++ new\n@@ -1,1 +0,0 @@\n-foo\n"},
 		{"old", "foo\n", "new", nil, "diff old new\n--- old\n+++ new\n@@ -1,1 +0,0 @@\n-foo\n"},
 		{"old", "", "new", "", ""},
+		// errors
+		{"old", tstNoStringer{}, "new", "foo", false},
+		{"old", "foo", "new", tstNoStringer{}, false},
 	} {
 
-		result := ns.Diff(tt.oldname, tt.old, tt.newname, tt.new)
-		c.Assert(result, qt.Equals, tt.expect)
+		result, err := ns.Diff(test.oldname, test.old, test.newname, test.new)
+
+		if b, ok := test.expect.(bool); ok && !b {
+			c.Assert(err, qt.Not(qt.IsNil))
+			continue
+		}
+
+		c.Assert(err, qt.IsNil)
+		c.Assert(result, qt.Equals, test.expect)
+
 	}
 }
-- 
cgit v1.2.3