Support for Arrays and Not IN Operator

.github/workflows/test.yaml

@@ -17,7 +17,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v2
         with:
-          go-version: '1.20'
+          go-version: '1.21'
 
       - name: Build
         run: make build

go.mod

@@ -1,17 +1,18 @@
 module github.com/sidhant92/bool-parser-go
 
-go 1.20
+go 1.21
 
 require (
-	github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20221202181307-76fa05c21b12
+	github.com/antlr4-go/antlr v0.0.0-20230518091524-98b52378c522
+	github.com/antlr4-go/antlr/v4 v4.13.0
 	github.com/hashicorp/go-version v1.6.0
+	github.com/hashicorp/golang-lru/v2 v2.0.1
 	github.com/stretchr/testify v1.8.1
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/hashicorp/golang-lru/v2 v2.0.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e // indirect
+	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,5 +1,7 @@
-github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20221202181307-76fa05c21b12 h1:npHgfD4Tl2WJS3AJaMUi5ynGDPUBfkg3U3fCzDyXZ+4=
-github.com/antlr/antlr4/runtime/Go/antlr/v4 v4.0.0-20221202181307-76fa05c21b12/go.mod h1:pSwJ0fSY5KhvocuWSx4fz3BA8OrA1bQn+K1Eli3BRwM=
+github.com/antlr4-go/antlr v0.0.0-20230518091524-98b52378c522 h1:o+W7GDFUwWtVkN28CW/nhh/aCmHn6OJddUs3+8vMMjs=
+github.com/antlr4-go/antlr v0.0.0-20230518091524-98b52378c522/go.mod h1:srLVvW4JLxy+tCG9Nn2l8al77mUIMCwAOLQocfLDU2w=
+github.com/antlr4-go/antlr/v4 v4.13.0 h1:lxCg3LAv+EUK6t1i0y1V6/SLeUi0eKEKdhQAlS8TVTI=
+github.com/antlr4-go/antlr/v4 v4.13.0/go.mod h1:pfChB/xh/Unjila75QW7+VU4TSnWnnk9UTnmpPaOR2g=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -16,8 +18,10 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e h1:+WEEuIdZHnUeJJmEUjyYC2gfUMj69yZXw17EnHg/otA=
-golang.org/x/exp v0.0.0-20220722155223-a9213eeb770e/go.mod h1:Kr81I6Kryrl9sr8s2FK3vxD90NdsKWRuOIl2O4CvYbA=
+golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc h1:mCRnTeVUjcrhlRmO0VK8a6k6Rrf6TF9htwo2pJVSjIU=
+golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/containerdatatype/container_data_type.go

@@ -0,0 +1,11 @@
+package containerdatatype
+
+import (
+	"github.com/sidhant92/bool-parser-go/pkg/constant"
+)
+
+type ContainerDataType interface {
+	IsValid(dataType constant.DataType, value interface{}) bool
+
+	GetContainerDataType() constant.ContainerDataType
+}

internal/containerdatatype/container_data_type_factory.go

@@ -0,0 +1,19 @@
+package containerdatatype
+
+import (
+	"github.com/sidhant92/bool-parser-go/pkg/constant"
+	"golang.org/x/exp/maps"
+)
+
+var containerDataTypeMap = map[constant.ContainerDataType]ContainerDataType{
+	constant.PRIMITIVE: NewPrimitiveContainerDataType(),
+	constant.LIST:      NewListContainerDataType(),
+}
+
+func GetContainerDataType(containerDataType constant.ContainerDataType) ContainerDataType {
+	return containerDataTypeMap[containerDataType]
+}
+
+func GetAllDataTypes() []ContainerDataType {
+	return maps.Values(containerDataTypeMap)
+}

internal/containerdatatype/list_container_data_type.go

@@ -0,0 +1,31 @@
+package containerdatatype
+
+import (
+	"github.com/sidhant92/bool-parser-go/internal/datatype"
+	"github.com/sidhant92/bool-parser-go/internal/util"
+	"github.com/sidhant92/bool-parser-go/pkg/constant"
+)
+
+type ListContainerDataType struct {
+}
+
+func (s *ListContainerDataType) GetContainerDataType() constant.ContainerDataType {
+	return constant.LIST
+}
+
+func (s *ListContainerDataType) IsValid(dataType constant.DataType, value interface{}) bool {
+	if !util.IsSlice(value) {
+		return false
+	}
+	var slice = util.GetSliceFromInterface(value)
+	for _, value := range slice {
+		if !datatype.GetDataType(dataType).IsValid(value) {
+			return false
+		}
+	}
+	return true
+}
+
+func NewListContainerDataType() ContainerDataType {
+	return &ListContainerDataType{}
+}

internal/containerdatatype/primitive_container_data_type.go

@@ -0,0 +1,25 @@
+package containerdatatype
+
+import (
+	"github.com/sidhant92/bool-parser-go/internal/datatype"
+	"github.com/sidhant92/bool-parser-go/internal/util"
+	"github.com/sidhant92/bool-parser-go/pkg/constant"
+)
+
+type PrimitiveContainerDataType struct {
+}
+
+func (s *PrimitiveContainerDataType) GetContainerDataType() constant.ContainerDataType {
+	return constant.PRIMITIVE
+}
+
+func (s *PrimitiveContainerDataType) IsValid(dataType constant.DataType, value interface{}) bool {
+	if util.IsSlice(value) {
+		return false
+	}
+	return datatype.GetDataType(dataType).IsValid(value)
+}
+
+func NewPrimitiveContainerDataType() ContainerDataType {
+	return &PrimitiveContainerDataType{}
+}

internal/datatype/boolean_data_type.go

@@ -39,11 +39,13 @@ func (s *BooleanDataType) GetValue(value interface{}) interface{} {
 	return res
 }
 
-func (s *BooleanDataType) Compare(left interface{}, right interface{}) (int, error) {
-	leftValid := s.IsValid(left)
-	rightValid := s.IsValid(right)
-	if !leftValid || !rightValid {
-		return 0, errors.INVALID_DATA_TYPE
+func (s *BooleanDataType) Compare(left interface{}, right interface{}, validated bool) (int, error) {
+	if !validated {
+		leftValid := s.IsValid(left)
+		rightValid := s.IsValid(right)
+		if !leftValid || !rightValid {
+			return 0, errors.INVALID_DATA_TYPE
+		}
 	}
 	leftValue := s.GetValue(left).(bool)
 	rightValue := s.GetValue(right).(bool)

internal/datatype/data_type.go

@@ -9,5 +9,5 @@ type DataType interface {
 
 	GetValue(value interface{}) any
 
-	Compare(left interface{}, right interface{}) (int, error)
+	Compare(left interface{}, right interface{}, validated bool) (int, error)
 }

internal/datatype/data_type_factory.go

@@ -2,6 +2,7 @@ package datatype
 
 import (
 	"github.com/sidhant92/bool-parser-go/pkg/constant"
+	"golang.org/x/exp/maps"
 )
 
 var dataTypeMap = map[constant.DataType]DataType{
@@ -16,3 +17,7 @@ var dataTypeMap = map[constant.DataType]DataType{
 func GetDataType(dataType constant.DataType) DataType {
 	return dataTypeMap[dataType]
 }
+
+func GetAllDataTypes() []DataType {
+	return maps.Values(dataTypeMap)
+}

internal/datatype/decimal_data_type.go

@@ -39,11 +39,13 @@ func (s *DecimalDataType) GetValue(value interface{}) interface{} {
 	return res
 }
 
-func (s *DecimalDataType) Compare(left interface{}, right interface{}) (int, error) {
-	leftValid := s.IsValid(left)
-	rightValid := s.IsValid(right)
-	if !leftValid || !rightValid {
-		return 0, errors.INVALID_DATA_TYPE
+func (s *DecimalDataType) Compare(left interface{}, right interface{}, validated bool) (int, error) {
+	if !validated {
+		leftValid := s.IsValid(left)
+		rightValid := s.IsValid(right)
+		if !leftValid || !rightValid {
+			return 0, errors.INVALID_DATA_TYPE
+		}
 	}
 	leftValue := s.GetValue(left).(float64)
 	rightValue := s.GetValue(right).(float64)

internal/datatype/int_data_type.go

@@ -39,11 +39,13 @@ func (s *IntDataType) GetValue(value interface{}) interface{} {
 	return res
 }
 
-func (s *IntDataType) Compare(left interface{}, right interface{}) (int, error) {
-	leftValid := s.IsValid(left)
-	rightValid := s.IsValid(right)
-	if !leftValid || !rightValid {
-		return 0, errors.INVALID_DATA_TYPE
+func (s *IntDataType) Compare(left interface{}, right interface{}, validated bool) (int, error) {
+	if !validated {
+		leftValid := s.IsValid(left)
+		rightValid := s.IsValid(right)
+		if !leftValid || !rightValid {
+			return 0, errors.INVALID_DATA_TYPE
+		}
 	}
 	leftValue := s.GetValue(left).(int)
 	rightValue := s.GetValue(right).(int)

internal/datatype/long_data_type.go

@@ -39,11 +39,13 @@ func (s *LongDataType) GetValue(value interface{}) interface{} {
 	return res
 }
 
-func (s *LongDataType) Compare(left interface{}, right interface{}) (int, error) {
-	leftValid := s.IsValid(left)
-	rightValid := s.IsValid(right)
-	if !leftValid || !rightValid {
-		return 0, errors.INVALID_DATA_TYPE
+func (s *LongDataType) Compare(left interface{}, right interface{}, validated bool) (int, error) {
+	if !validated {
+		leftValid := s.IsValid(left)
+		rightValid := s.IsValid(right)
+		if !leftValid || !rightValid {
+			return 0, errors.INVALID_DATA_TYPE
+		}
 	}
 	leftValue := s.GetValue(left).(int64)
 	rightValue := s.GetValue(right).(int64)

internal/datatype/string_data_type.go

@@ -26,11 +26,13 @@ func (s *StringDataType) GetValue(value interface{}) interface{} {
 	return fmt.Sprintf("%v",value)
 }
 
-func (s *StringDataType) Compare(left interface{}, right interface{}) (int, error) {
-	leftValid := s.IsValid(left)
-	rightValid := s.IsValid(right)
-	if !leftValid || !rightValid {
-		return 0, errors.INVALID_DATA_TYPE
+func (s *StringDataType) Compare(left interface{}, right interface{}, validated bool) (int, error) {
+	if !validated {
+		leftValid := s.IsValid(left)
+		rightValid := s.IsValid(right)
+		if !leftValid || !rightValid {
+			return 0, errors.INVALID_DATA_TYPE
+		}
 	}
 	leftValue := s.GetValue(left).(string)
 	rightValue := s.GetValue(right).(string)

internal/datatype/version_data_type.go

@@ -36,11 +36,13 @@ func (s *VersionDataType) GetValue(value interface{}) interface{} {
 	return res
 }
 
-func (s *VersionDataType) Compare(left interface{}, right interface{}) (int, error) {
-	leftValid := s.IsValid(left)
-	rightValid := s.IsValid(right)
-	if !leftValid || !rightValid {
-		return 0, errors.INVALID_DATA_TYPE
+func (s *VersionDataType) Compare(left interface{}, right interface{}, validated bool) (int, error) {
+	if !validated {
+		leftValid := s.IsValid(left)
+		rightValid := s.IsValid(right)
+		if !leftValid || !rightValid {
+			return 0, errors.INVALID_DATA_TYPE
+		}
 	}
 	leftValue := s.GetValue(left).(*version.Version)
 	rightValue := s.GetValue(right).(*version.Version)

internal/operator/abstract_operator.go

@@ -3,9 +3,13 @@ package operator
 import "github.com/sidhant92/bool-parser-go/pkg/constant"
 
 type AbstractOperator interface {
-	Evaluate(dataType constant.DataType, left interface{}, right ...interface{}) (bool, error)
+	Evaluate(containerDataType constant.ContainerDataType, dataType constant.DataType, validated bool, left interface{}, right ...interface{}) (bool, error)
 
 	GetSymbol() string
 
 	GetOperator() constant.Operator
+
+	GetAllowedContainerTypes() []constant.ContainerDataType
+
+	GetAllowedDataTypes() []constant.DataType
 }

internal/operator/contains_all_operator.go

@@ -0,0 +1,49 @@
+package operator
+
+import (
+	"github.com/sidhant92/bool-parser-go/pkg/constant"
+	"reflect"
+)
+
+type ContainsAllOperator struct {
+}
+
+func (e *ContainsAllOperator) Evaluate(containerDataType constant.ContainerDataType, dataType constant.DataType, validated bool, left interface{}, right ...interface{}) (bool, error) {
+	var leftArray []interface{}
+	rv := reflect.ValueOf(left)
+	if rv.Kind() == reflect.Slice {
+		for i := 0; i < rv.Len(); i++ {
+			leftArray = append(leftArray, rv.Index(i).Interface())
+		}
+	}
+	for _, value := range right {
+		res, err := GetOperator(constant.IN).Evaluate(constant.PRIMITIVE, dataType, validated, value, leftArray...)
+		if err != nil {
+			return false, err
+		}
+		if !res {
+			return false, nil
+		}
+	}
+	return true, nil
+}
+
+func (e *ContainsAllOperator) GetSymbol() string {
+	return "CONTAINS_ALL"
+}
+
+func (e *ContainsAllOperator) GetOperator() constant.Operator {
+	return constant.CONTAINS_ALL
+}
+
+func (e *ContainsAllOperator) GetAllowedContainerTypes() []constant.ContainerDataType {
+	return []constant.ContainerDataType{constant.LIST}
+}
+
+func (e *ContainsAllOperator) GetAllowedDataTypes() []constant.DataType {
+	return []constant.DataType{constant.STRING, constant.INTEGER, constant.LONG, constant.DECIMAL, constant.BOOLEAN, constant.VERSION}
+}
+
+func NewContainsAllOperator() AbstractOperator {
+	return &ContainsAllOperator{}
+}

internal/operator/contains_any_operator.go

@@ -0,0 +1,49 @@
+package operator
+
+import (
+	"github.com/sidhant92/bool-parser-go/pkg/constant"
+	"reflect"
+)
+
+type ContainsAnyOperator struct {
+}
+
+func (e *ContainsAnyOperator) Evaluate(containerDataType constant.ContainerDataType, dataType constant.DataType, validated bool, left interface{}, right ...interface{}) (bool, error) {
+	var leftArray []interface{}
+	rv := reflect.ValueOf(left)
+	if rv.Kind() == reflect.Slice {
+		for i := 0; i < rv.Len(); i++ {
+			leftArray = append(leftArray, rv.Index(i).Interface())
+		}
+	}
+	for _, value := range right {
+		res, err := GetOperator(constant.IN).Evaluate(constant.PRIMITIVE, dataType, validated, value, leftArray...)
+		if err != nil {
+			return false, err
+		}
+		if res {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+func (e *ContainsAnyOperator) GetSymbol() string {
+	return "CONTAINS_ANY"
+}
+
+func (e *ContainsAnyOperator) GetOperator() constant.Operator {
+	return constant.CONTAINS_ANY
+}
+
+func (e *ContainsAnyOperator) GetAllowedContainerTypes() []constant.ContainerDataType {
+	return []constant.ContainerDataType{constant.LIST}
+}
+
+func (e *ContainsAnyOperator) GetAllowedDataTypes() []constant.DataType {
+	return []constant.DataType{constant.STRING, constant.INTEGER, constant.LONG, constant.DECIMAL, constant.BOOLEAN, constant.VERSION}
+}
+
+func NewContainsAnyOperator() AbstractOperator {
+	return &ContainsAnyOperator{}
+}