Merge pull request #12 from sidhant92/develop

Support for default Field

Author: sidhant92

internal/parser/antlr/antlr_parser.go

@@ -10,26 +10,26 @@ import (
 )
 
 type ANTLRParser struct {
-	UseCache bool
-	cache    *lru.Cache[string, domain.Node]
+	UseCache     bool
+	cache        *lru.Cache[string, domain.Node]
 }
 
 func Default() *ANTLRParser {
 	return &ANTLRParser{
-		UseCache: false,
-		cache:    nil,
+		UseCache:     false,
+		cache:        nil,
 	}
 }
 
 func Cached(size int) *ANTLRParser {
 	cache, _ := lru.New[string, domain.Node](size)
 	return &ANTLRParser{
-		UseCache: true,
-		cache:    cache,
+		UseCache:     true,
+		cache:        cache,
 	}
 }
 
-func (p *ANTLRParser) Parse(input string) (res domain.Node, err error) {
+func (p *ANTLRParser) Parse(input string, defaultField ...string) (res domain.Node, err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			log.Println("panic occurred:", r)
@@ -56,7 +56,11 @@ func (p *ANTLRParser) Parse(input string) (res domain.Node, err error) {
 	lexer := lib.NewBooleanExpressionLexer(inputStream)
 	stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
 	antlrParser := lib.NewBooleanExpressionParser(stream)
-	listener := New()
+	var df = ""
+	if len(defaultField) > 0 {
+		df = defaultField[0]
+	}
+	listener := New(df)
 	antlr.ParseTreeWalkerDefault.Walk(listener, antlrParser.Parse())
 	if p.UseCache {
 		p.cache.Add(input, listener.GetResult())

internal/parser/antlr/listener.go

@@ -18,14 +18,17 @@ type myListener struct {
 	Result domain.Node
 
 	OperatorService *service.OperatorService
+
+	DefaultField string
 }
 
-func New() *myListener {
+func New(defaultField string) *myListener {
 	l := myListener{
 		Nodes:           []domain.Node{},
 		LastToken:       nil,
 		Result:          nil,
 		OperatorService: service.NewOperatorService(),
+		DefaultField:    defaultField,
 	}
 	return &l
 }
@@ -132,7 +135,8 @@ func (l *myListener) ExitTypesExpression(c *lib.TypesExpressionContext) {
 }
 
 func (l *myListener) ExitInExpression(c *lib.InExpressionContext) {
-	field := c.GetField().GetText()
+	l.ValidateField(c.GetField(), c.GetText())
+	field := l.GetField(c.GetField().GetText())
 
 	typesContextFilter := func(tree antlr.Tree) bool { return reflect.TypeOf(tree) == reflect.TypeOf(&lib.TypesContext{}) }
 	var typesContextChildren = util.Filter(c.GetData().GetChildren(), typesContextFilter)
@@ -154,7 +158,8 @@ func (l *myListener) ExitInExpression(c *lib.InExpressionContext) {
 }
 
 func (l *myListener) ExitToExpression(c *lib.ToExpressionContext) {
-	field := c.GetField().GetText()
+	l.ValidateField(c.GetField(), c.GetText())
+	field := l.GetField(c.GetField().GetText())
 	lowerDataType := GetDataType(c.GetLower().GetStart())
 	lowerValue, _ := util.ConvertValue(c.GetLower().GetStart().GetText(), lowerDataType)
 	upperDataType := GetDataType(c.GetUpper().GetStart())
@@ -189,7 +194,7 @@ func (l *myListener) ExitNotExpression(c *lib.NotExpressionContext) {
 }
 
 func (l *myListener) ExitComparatorExpression(c *lib.ComparatorExpressionContext) {
-	field := c.GetLeft().GetText()
+	field := l.GetField(c.GetLeft().GetText())
 	dataType := GetDataType(c.GetRight().GetStart())
 	value, _ := util.ConvertValue(c.GetRight().GetText(), dataType)
 	operator := l.OperatorService.GetOperatorFromSymbol(c.GetOp().GetText())
@@ -249,3 +254,16 @@ func GetDataType(token antlr.Token) constant.DataType {
 		return constant.STRING
 	}
 }
+
+func (l myListener) ValidateField(token antlr.Token, text string)  {
+	if token == nil || (len(token.GetText()) == 0 && len(text) == 0) {
+		panic("Invalid Expression, field and default value both are empty")
+	}
+}
+
+func (l myListener) GetField(field string) string {
+	if len(field) == 0 {
+		return l.DefaultField
+	}
+	return field
+}

pkg/application/boolean_expression_evaluator.go

@@ -15,8 +15,8 @@ type BooleanExpressionEvaluator struct {
 	OperatorService *service.OperatorService
 }
 
-func (b *BooleanExpressionEvaluator) Evaluate(expression string, data map[string]interface{}) (bool, error) {
-	node, err := b.Parser.Parse(expression)
+func (b *BooleanExpressionEvaluator) Evaluate(expression string, data map[string]interface{}, defaultField ...string) (bool, error) {
+	node, err := b.Parser.Parse(expression, defaultField...)
 	if err != nil {
 		return false, err
 	}

pkg/application/boolean_expression_evaluator_test.go

@@ -409,3 +409,21 @@ func TestStringEqualityWithQuotes(t *testing.T) {
 	assert.Nil(t, err)
 	assert.True(t, res)
 }
+
+func TestDefaultFieldTrue(t *testing.T) {
+	data := map[string]interface{}{
+		"age": 19,
+	}
+	res, err := evaluator.Evaluate(">= 18 AND < 20", data, "age")
+	assert.Nil(t, err)
+	assert.True(t, res)
+}
+
+func TestDefaultFieldFalse(t *testing.T) {
+	data := map[string]interface{}{
+		"age": 17,
+	}
+	res, err := evaluator.Evaluate(">= 18 AND < 20", data, "age")
+	assert.Nil(t, err)
+	assert.False(t, res)
+}

pkg/error/errors.go

@@ -6,4 +6,6 @@ var INVALID_DATA_TYPE = errors.New("invalid data type")
 
 var INVALID_UNARY_OPERAND = errors.New("invalid unary operand")
 
-var KEY_DATA_NOT_PRESENT = errors.New("key data not present")
+var KEY_DATA_NOT_PRESENT = errors.New("key data not present")
+
+var INVALID_EXPRESSION = errors.New("invalid expression")

pkg/parser/parser.go

@@ -6,7 +6,7 @@ import (
 )
 
 type Parser interface {
-	Parse(input string) (domain.Node, error)
+	Parse(input string, defaultField ...string) (domain.Node, error)
 }
 
 func New() Parser {