feat(error-code): migrate the error code to interface based

README.md

@@ -1,32 +1,39 @@
 # Goval
 
-Goval is a powerful and easy-to-use library that provides a set of functions for validating
-various types of data in Go programming language.
-This library is designed to simplify the process of data validation and reduce the likelihood of errors and vulnerabilities in applications.
+**Goval** or **Go Validator** is a package for value validation in Go. 
 
-## Design
+The objective of this package is to provide a simple and easy-to-use validation library for Go that is easy to integrate into existing projects, and easy for developers to use.
+The package should be easy to extend and should provide a simple way to add custom validators, with no magic happening
+behind the scenes to make it easy to understand and debug as well.
 
-The Engineering Design behind this package can be accessed in `DESIGN.md`.
+This package is designed to enhance the capabilities of the Go function as a first-class citizen. That means everything
+in this package is built using function composition. Each validation rule is a simple function that can be chained (
+composed) together to create complex validation logic. This package is also designed to avoid using reflection as much
+as possible and is safe for concurrent use.
 
-## Features
+> The package is still under development and requires more validation rules to be implemented. If you would like to
+> contribute to this project, your contributions would be greatly appreciated. To contribute, simply fork the project and
+> send us a pull request. Although there is no formal format for contributing at the moment, we would appreciate it if you
+> could provide a good explanation with your pull request.
 
----
+## Features
 
-- Validate strings, numbers, dates, structs, and more
-- Customizable error messages and validation rules
+- Composable Validation Rule
 - Lightweight and easy to integrate with any Go application
-- Built-in support for validating structs
+- Support Generics
+- No Reflection
+- Concurrent Safe
 
 ## Install
 
----
-
 Use go get
+
 ```shell
 go get github.com/pkg-id/goval
 ```
 
 Then, import to your own code
+
 ```go
 import "github.com/pkg-id/goval"
 ```
@@ -89,11 +96,6 @@ func main() {
 }
 ```
 
-## Contributing
-
----
-
 ## License
 
----
 Distributed under MIT License, please see license file within the code for more details.

codes.go

@@ -1,53 +1,56 @@
 package goval
 
-type RuleCode int
+type ruleCode int
+
+func (r ruleCode) Equal(other RuleCoder) bool {
+	v, ok := other.(ruleCode)
+	return ok && r == v
+}
+
+type RuleCoder interface {
+	Equal(other RuleCoder) bool
+}
 
 const (
-	ruleCodeNilBase RuleCode = (1 + iota) * 1_000
-	ruleCodeBaseString
-	ruleCodeBaseNumber
-	ruleCodeBaseSlice
-	ruleCodeBaseMap
-	ruleCodeBaseTime
+	rcPointer ruleCode = (1 + iota) * 1_000
+	rcString
+	rcNumber
+	rcSlice
+	rcMap
+	rcTime
 )
 
 const (
-	NilRequired = ruleCodeNilBase + iota
+	PtrRequired = rcPointer + iota
 )
 
 const (
-	StringRequired = ruleCodeBaseString + iota
+	StringRequired = rcString + iota
 	StringMin
 	StringMax
 	StringMatch
 )
 
 const (
-	NumberRequired = ruleCodeBaseNumber + iota
+	NumberRequired = rcNumber + iota
 	NumberMin
 	NumberMax
 )
 
 const (
-	SliceRequired = ruleCodeBaseSlice + iota
+	SliceRequired = rcSlice + iota
 	SliceMin
 	SliceMax
-	SliceEach
 )
 
 const (
-	MapRequired = ruleCodeBaseMap + iota
+	MapRequired = rcMap + iota
 	MapMin
 	MapMax
-	MapEach
 )
 
 const (
-	TimeRequired = ruleCodeBaseTime + iota
+	TimeRequired = rcTime + iota
 	TimeMin
 	TimeMax
 )
-
-func IsCodeEqual(a, b RuleCode) bool {
-	return a == b
-}

codes_test.go

@@ -0,0 +1,59 @@
+package goval
+
+import (
+	"testing"
+)
+
+type customTypeButSameBase ruleCode
+
+func (c customTypeButSameBase) Equal(other RuleCoder) bool {
+	v, ok := other.(customTypeButSameBase)
+	return ok && v == c
+}
+
+type customTypeButSameRootBase int
+
+func (c customTypeButSameRootBase) Equal(other RuleCoder) bool {
+	v, ok := other.(customTypeButSameRootBase)
+	return ok && v == c
+}
+
+func TestRuleCode_Equal(t *testing.T) {
+	tests := []struct {
+		desc string
+		got  bool
+		exp  bool
+	}{
+		{
+			desc: "type and value is same",
+			got:  NumberRequired.Equal(NumberRequired),
+			exp:  true,
+		},
+		{
+			desc: "type same but value is different",
+			got:  NumberRequired.Equal(NumberRequired),
+			exp:  true,
+		},
+		{
+			desc: "type and value is same. But, it used value literal",
+			got:  NumberRequired.Equal(ruleCode(3000)),
+			exp:  true,
+		},
+		{
+			desc: "type is different and literal value is same, but the source type is same",
+			got:  NumberRequired.Equal(customTypeButSameBase(3000)),
+			exp:  false,
+		},
+		{
+			desc: "type is different and literal value is same, but the root source type is same",
+			got:  NumberRequired.Equal(customTypeButSameRootBase(3000)),
+			exp:  false,
+		},
+	}
+
+	for _, tc := range tests {
+		if tc.got != tc.exp {
+			t.Fatalf("got: %-6v. exp: %-6v. %s", tc.got, tc.exp, tc.desc)
+		}
+	}
+}