Rename Comparable to Obj

Author: pellared

CHANGELOG.md

@@ -77,6 +77,7 @@ The main additions are the new assertions for
 
 - The `f` package is renamed to `verify`.
 - Rename `Obj` and `FluentObj` to `Any` and `FluentAny`.
+- Rename `Comparable` and `FluentComparable` to `Obj` and `FluentObj`.
 - Change the `Check` assertion for `any` object so that the
   provided function has to return `FailureMessage`
   instead of a `string`.

comparable.go

@@ -2,34 +2,34 @@ package verify
 
 import "fmt"
 
-// FluentComparable encapsulates assertions for comparable object.
-type FluentComparable[T comparable] struct {
+// FluentObj encapsulates assertions for comparable object.
+type FluentObj[T comparable] struct {
 	FluentAny[T]
 }
 
-// Comparable is used for testing a comparable object.
-func Comparable[T comparable](got T) FluentComparable[T] {
-	return FluentComparable[T]{FluentAny[T]{got}}
+// Obj is used for testing a comparable object.
+func Obj[T comparable](got T) FluentObj[T] {
+	return FluentObj[T]{FluentAny[T]{got}}
 }
 
 // Equal tests the objects using == operator.
-func (x FluentComparable[T]) Equal(want T) FailureMessage {
+func (x FluentObj[T]) Equal(want T) FailureMessage {
 	if x.Got == want {
 		return ""
 	}
 	return FailureMessage(fmt.Sprintf("the objects are not equal\ngot: %+v\nwant: %+v", x.Got, want))
 }
 
 // NotEqual tests the objects using != operator.
-func (x FluentComparable[T]) NotEqual(obj T) FailureMessage {
+func (x FluentObj[T]) NotEqual(obj T) FailureMessage {
 	if x.Got != obj {
 		return ""
 	}
 	return "the objects are equal"
 }
 
 // Zero tests if the object is a zero value.
-func (x FluentComparable[T]) Zero() FailureMessage {
+func (x FluentObj[T]) Zero() FailureMessage {
 	var want T
 	if want == x.Got {
 		return ""
@@ -38,7 +38,7 @@ func (x FluentComparable[T]) Zero() FailureMessage {
 }
 
 // NonZero tests if the object is a non-zero value.
-func (x FluentComparable[T]) NonZero() FailureMessage {
+func (x FluentObj[T]) NonZero() FailureMessage {
 	var want T
 	if want != x.Got {
 		return ""

comparable_test.go

@@ -6,7 +6,7 @@ import (
 	"github.com/fluentassert/verify"
 )
 
-func TestComparable(t *testing.T) {
+func TestObj(t *testing.T) {
 	type A struct {
 		Str  string
 		Bool bool
@@ -16,18 +16,18 @@ func TestComparable(t *testing.T) {
 		t.Run("Passed", func(t *testing.T) {
 			want := A{Str: "string", Bool: true}
 			got := A{Str: "string", Bool: true}
-			msg := verify.Comparable(got).Equal(want)
+			msg := verify.Obj(got).Equal(want)
 			assertPassed(t, msg)
 		})
 		t.Run("Failed", func(t *testing.T) {
 			want := A{Str: "string", Bool: true}
 			got := A{Str: "wrong", Bool: true}
-			msg := verify.Comparable(got).Equal(want)
+			msg := verify.Obj(got).Equal(want)
 			assertFailed(t, msg, "the objects are not equal")
 		})
 		t.Run("nil", func(t *testing.T) {
 			var got *A
-			msg := verify.Comparable(got).Equal(nil)
+			msg := verify.Obj(got).Equal(nil)
 			assertPassed(t, msg)
 		})
 	})
@@ -36,61 +36,61 @@ func TestComparable(t *testing.T) {
 		t.Run("Passed", func(t *testing.T) {
 			want := A{Str: "string", Bool: true}
 			got := A{Str: "wrong", Bool: true}
-			msg := verify.Comparable(got).NotEqual(want)
+			msg := verify.Obj(got).NotEqual(want)
 			assertPassed(t, msg)
 		})
 		t.Run("Failed", func(t *testing.T) {
 			want := A{Str: "string", Bool: true}
 			got := A{Str: "string", Bool: true}
-			msg := verify.Comparable(got).NotEqual(want)
+			msg := verify.Obj(got).NotEqual(want)
 			assertFailed(t, msg, "the objects are equal")
 		})
 		t.Run("nil", func(t *testing.T) {
 			var got *A
-			msg := verify.Comparable(got).NotEqual(nil)
+			msg := verify.Obj(got).NotEqual(nil)
 			assertFailed(t, msg, "the objects are equal")
 		})
 	})
 
 	t.Run("Zero", func(t *testing.T) {
 		t.Run("Passed", func(t *testing.T) {
 			got := A{}
-			msg := verify.Comparable(got).Zero()
+			msg := verify.Obj(got).Zero()
 			assertPassed(t, msg)
 		})
 		t.Run("Failed", func(t *testing.T) {
 			got := A{Str: "wrong"}
-			msg := verify.Comparable(got).Zero()
+			msg := verify.Obj(got).Zero()
 			assertFailed(t, msg, "not a zero value\n")
 		})
 		t.Run("nil", func(t *testing.T) {
 			var got *A
-			msg := verify.Comparable(got).Zero()
+			msg := verify.Obj(got).Zero()
 			assertPassed(t, msg)
 		})
 	})
 
 	t.Run("NonZero", func(t *testing.T) {
 		t.Run("Passed", func(t *testing.T) {
 			got := A{Str: "string"}
-			msg := verify.Comparable(got).NonZero()
+			msg := verify.Obj(got).NonZero()
 			assertPassed(t, msg)
 		})
 		t.Run("Failed", func(t *testing.T) {
 			got := A{}
-			msg := verify.Comparable(got).NonZero()
+			msg := verify.Obj(got).NonZero()
 			assertFailed(t, msg, "a zero value")
 		})
 		t.Run("nil", func(t *testing.T) {
 			var got *A
-			msg := verify.Comparable(got).NonZero()
+			msg := verify.Obj(got).NonZero()
 			assertFailed(t, msg, "a zero value")
 		})
 	})
 
 	t.Run("has assertions from Any", func(t *testing.T) {
 		want := A{}
-		got := verify.Comparable(want).FluentAny.Got // type embedding done properly
+		got := verify.Obj(want).FluentAny.Got // type embedding done properly
 		assertEqual(t, got, want)
 	})
 }

error_test.go

@@ -90,7 +90,7 @@ func TestError(t *testing.T) {
 		got := verify.Error(want).FluentAny.Got // type embedding done properly
 		assertEqual(t, got, want, cmpopts.EquateErrors())
 	})
-	t.Run("has assertions from String, Ordered, Comparable for string", func(t *testing.T) {
+	t.Run("has assertions from String, Ordered, Obj for string", func(t *testing.T) {
 		want := "an error"
 		got := verify.Error(errors.New(want)).FluentString.Got // type embedding done properly
 		assertEqual(t, got, want)

number.go

@@ -14,7 +14,7 @@ type NumberFloat[T constraints.Number] struct {
 
 // Number is used for testing numbers.
 func Number[T constraints.Number](got T) NumberFloat[T] {
-	return NumberFloat[T]{FluentOrdered[T]{FluentComparable[T]{FluentAny[T]{got}}}}
+	return NumberFloat[T]{FluentOrdered[T]{FluentObj[T]{FluentAny[T]{got}}}}
 }
 
 // InDelta tests that the numbers have an absolute error (distance) less or equal than delta.

ordered.go

@@ -9,13 +9,13 @@ import (
 // FluentOrdered encapsulates assertions for ordered object
 // // that supports the operators < <= >= >.
 type FluentOrdered[T constraints.Ordered] struct {
-	FluentComparable[T]
+	FluentObj[T]
 }
 
 // Ordered is used for testing a ordered object
 // that supports the operators < <= >= >.
 func Ordered[T constraints.Ordered](got T) FluentOrdered[T] {
-	return FluentOrdered[T]{FluentComparable[T]{FluentAny[T]{got}}}
+	return FluentOrdered[T]{FluentObj[T]{FluentAny[T]{got}}}
 }
 
 // Lesser tests the objects using < operator.

ordered_test.go

@@ -67,9 +67,9 @@ func TestOrdered(t *testing.T) {
 		})
 	})
 
-	t.Run("has assertions from Comparable and Obj", func(t *testing.T) {
+	t.Run("has assertions from Obj and Any", func(t *testing.T) {
 		want := 123
-		got := verify.Ordered(want).FluentComparable.FluentAny.Got // type embedding done properly
+		got := verify.Ordered(want).FluentObj.FluentAny.Got // type embedding done properly
 		assertEqual(t, got, want)
 	})
 }

string.go

@@ -13,7 +13,7 @@ type FluentString[T ~string] struct {
 
 // String is used for testing a string object.
 func String[T ~string](got T) FluentString[T] {
-	return FluentString[T]{FluentOrdered[T]{FluentComparable[T]{FluentAny[T]{got}}}}
+	return FluentString[T]{FluentOrdered[T]{FluentObj[T]{FluentAny[T]{got}}}}
 }
 
 // Empty tests if the string is not empty.

string_test.go

@@ -140,9 +140,9 @@ func TestString(t *testing.T) {
 		})
 	})
 
-	t.Run("has assertions from Ordered, Comparable, Obj", func(t *testing.T) {
+	t.Run("has assertions from Ordered, Obj, Any", func(t *testing.T) {
 		want := "text"
-		got := verify.String(want).FluentOrdered.FluentComparable.FluentAny.Got // type embedding done properly
+		got := verify.String(want).FluentOrdered.FluentObj.FluentAny.Got // type embedding done properly
 		assertEqual(t, got, want)
 	})
 }