refactoring/ renaming condition Tree to a generic Tree.

Author: pawels-optimizely

optimizely/config/datafileProjectConfig/mappers/condition_trees.go

@@ -26,14 +26,14 @@ import (
 var ErrEmptyTree = errors.New("Empty Tree")
 
 // Takes the conditions array from the audience in the datafile and turns it into a condition tree
-func buildConditionTree(conditions interface{}) (conditionTree *entities.ConditionTreeNode, retErr error) {
+func buildConditionTree(conditions interface{}) (conditionTree *entities.TreeNode, retErr error) {
 
 	value := reflect.ValueOf(conditions)
 	visited := make(map[interface{}]bool)
 
-	conditionTree = &entities.ConditionTreeNode{}
-	var populateConditions func(v reflect.Value, root *entities.ConditionTreeNode)
-	populateConditions = func(v reflect.Value, root *entities.ConditionTreeNode) {
+	conditionTree = &entities.TreeNode{}
+	var populateConditions func(v reflect.Value, root *entities.TreeNode)
+	populateConditions = func(v reflect.Value, root *entities.TreeNode) {
 
 		for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
 			if v.Kind() == reflect.Ptr {
@@ -50,7 +50,7 @@ func buildConditionTree(conditions interface{}) (conditionTree *entities.Conditi
 
 		case reflect.Slice, reflect.Array:
 			for i := 0; i < v.Len(); i++ {
-				n := &entities.ConditionTreeNode{}
+				n := &entities.TreeNode{}
 				typedV := v.Index(i).Interface()
 				switch typedV.(type) {
 				case string:
@@ -69,7 +69,7 @@ func buildConditionTree(conditions interface{}) (conditionTree *entities.Conditi
 						retErr = err
 						return
 					}
-					n.Condition = condition
+					n.Item = condition
 				}
 
 				root.Nodes = append(root.Nodes, n)
@@ -88,15 +88,15 @@ func buildConditionTree(conditions interface{}) (conditionTree *entities.Conditi
 }
 
 // Takes the conditions array from the audience in the datafile and turns it into a condition tree
-func buildAudienceConditionTree(conditions interface{}) (conditionTree *entities.ConditionTreeNode, err error) {
+func buildAudienceConditionTree(conditions interface{}) (conditionTree *entities.TreeNode, err error) {
 
 	var operators = []string{"or", "and", "not"} // any other operators?
 	value := reflect.ValueOf(conditions)
 	visited := make(map[interface{}]bool)
 
-	conditionTree = &entities.ConditionTreeNode{}
-	var populateConditions func(v reflect.Value, root *entities.ConditionTreeNode)
-	populateConditions = func(v reflect.Value, root *entities.ConditionTreeNode) {
+	conditionTree = &entities.TreeNode{}
+	var populateConditions func(v reflect.Value, root *entities.TreeNode)
+	populateConditions = func(v reflect.Value, root *entities.TreeNode) {
 
 		for v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface {
 			if v.Kind() == reflect.Ptr {
@@ -113,7 +113,7 @@ func buildAudienceConditionTree(conditions interface{}) (conditionTree *entities
 
 		case reflect.Slice, reflect.Array:
 			for i := 0; i < v.Len(); i++ {
-				n := &entities.ConditionTreeNode{}
+				n := &entities.TreeNode{}
 				typedV := v.Index(i).Interface()
 				switch typedV.(type) {
 				case string:
@@ -123,9 +123,8 @@ func buildAudienceConditionTree(conditions interface{}) (conditionTree *entities
 						root.Operator = n.Operator
 						continue
 					} else {
-						n.Condition.Value = value
-						n.Condition.Type = "audience_condition"
-						n.Condition.Name = "optimizely_populated"
+						n.Item = value
+
 					}
 				}
 

optimizely/config/datafileProjectConfig/mappers/condition_trees_test.go

@@ -33,38 +33,23 @@ func TestBuildAudienceConditionTreeSimpleAudienceCondition(t *testing.T) {
 		assert.Fail(t, err.Error())
 	}
 
-	expectedConditionTree := &entities.ConditionTreeNode{
+	expectedConditionTree := &entities.TreeNode{
 		Operator: "and",
-		Nodes: []*entities.ConditionTreeNode{
+		Nodes: []*entities.TreeNode{
 			{
 				Operator: "or",
-				Nodes: []*entities.ConditionTreeNode{
+				Nodes: []*entities.TreeNode{
 					{
 						Operator: "or",
-						Nodes: []*entities.ConditionTreeNode{
+						Nodes: []*entities.TreeNode{
 							{
-								Condition: entities.Condition{
-									Name:  "optimizely_populated",
-									Match: "",
-									Type:  "audience_condition",
-									Value: "12",
-								},
+								Item: "12",
 							},
 							{
-								Condition: entities.Condition{
-									Name:  "optimizely_populated",
-									Match: "",
-									Type:  "audience_condition",
-									Value: "123",
-								},
+								Item: "123",
 							},
 							{
-								Condition: entities.Condition{
-									Name:  "optimizely_populated",
-									Match: "",
-									Type:  "audience_condition",
-									Value: "1234",
-								},
+								Item: "1234",
 							},
 						},
 					},
@@ -84,17 +69,17 @@ func TestBuildConditionTreeSimpleAudienceCondition(t *testing.T) {
 		assert.Fail(t, err.Error())
 	}
 
-	expectedConditionTree := &entities.ConditionTreeNode{
+	expectedConditionTree := &entities.TreeNode{
 		Operator: "and",
-		Nodes: []*entities.ConditionTreeNode{
+		Nodes: []*entities.TreeNode{
 			{
 				Operator: "or",
-				Nodes: []*entities.ConditionTreeNode{
+				Nodes: []*entities.TreeNode{
 					{
 						Operator: "or",
-						Nodes: []*entities.ConditionTreeNode{
+						Nodes: []*entities.TreeNode{
 							{
-								Condition: entities.Condition{
+								Item: entities.Condition{
 									Name:  "s_foo",
 									Match: "exact",
 									Type:  "custom_attribute",

optimizely/config/datafileProjectConfig/mappers/experiment_test.go

@@ -90,17 +90,12 @@ func TestMapExperiments(t *testing.T) {
 					EndOfRange: 10000,
 				},
 			},
-			AudienceConditionTree: &entities.ConditionTreeNode{
+			AudienceConditionTree: &entities.TreeNode{
 				Operator: "or",
-				Nodes: []*entities.ConditionTreeNode{
+				Nodes: []*entities.TreeNode{
 					{
 						Operator: "",
-						Condition: entities.Condition{
-							Name:  "optimizely_populated",
-							Match: "",
-							Type:  "audience_condition",
-							Value: "31111",
-						},
+						Item:     "31111",
 					},
 				},
 			},

optimizely/decision/evaluator/audience.go

@@ -22,23 +22,23 @@ import (
 
 // AudienceEvaluator evaluates an audience against the given user's attributes
 type AudienceEvaluator interface {
-	Evaluate(audience entities.Audience, condTreeParams *entities.ConditionTreeParameters) bool
+	Evaluate(audience entities.Audience, condTreeParams *entities.TreeParameters) bool
 }
 
 // TypedAudienceEvaluator evaluates typed audiences
 type TypedAudienceEvaluator struct {
-	conditionTreeEvaluator ConditionTreeEvaluator
+	conditionTreeEvaluator TreeEvaluator
 }
 
 // NewTypedAudienceEvaluator creates a new instance of the TypedAudienceEvaluator
 func NewTypedAudienceEvaluator() *TypedAudienceEvaluator {
-	conditionTreeEvaluator := NewConditionTreeEvaluator()
+	conditionTreeEvaluator := NewTreeEvaluator()
 	return &TypedAudienceEvaluator{
 		conditionTreeEvaluator: *conditionTreeEvaluator,
 	}
 }
 
 // Evaluate evaluates the typed audience against the given user's attributes
-func (a TypedAudienceEvaluator) Evaluate(audience entities.Audience, condTreeParams *entities.ConditionTreeParameters) bool {
+func (a TypedAudienceEvaluator) Evaluate(audience entities.Audience, condTreeParams *entities.TreeParameters) bool {
 	return a.conditionTreeEvaluator.Evaluate(audience.ConditionTree, condTreeParams)
 }

optimizely/decision/evaluator/condition.go

@@ -29,17 +29,19 @@ const (
 	gtMatchType     = "gt"
 )
 
-// ConditionEvaluator evaluates a condition against the given user's attributes
-type ConditionEvaluator interface {
-	Evaluate(entities.Condition, *entities.ConditionTreeParameters) (bool, error)
+// ItemEvaluator evaluates a condition against the given user's attributes
+type ItemEvaluator interface {
+	Evaluate(interface{}, *entities.TreeParameters) (bool, error)
 }
 
 // CustomAttributeConditionEvaluator evaluates conditions with custom attributes
 type CustomAttributeConditionEvaluator struct{}
 
 // Evaluate returns true if the given user's attributes match the condition
-func (c CustomAttributeConditionEvaluator) Evaluate(condition entities.Condition, condTreeParams *entities.ConditionTreeParameters) (bool, error) {
+func (c CustomAttributeConditionEvaluator) Evaluate(item interface{}, condTreeParams *entities.TreeParameters) (bool, error) {
 	// We should only be evaluating custom attributes
+
+	condition := item.(entities.Condition)
 	if condition.Type != customAttributeType {
 		return false, fmt.Errorf(`Unable to evaluator condition of type "%s"`, condition.Type)
 	}
@@ -76,18 +78,15 @@ func (c CustomAttributeConditionEvaluator) Evaluate(condition entities.Condition
 type AudienceConditionEvaluator struct{}
 
 // Evaluate returns true if the given user's attributes match the condition
-func (c AudienceConditionEvaluator) Evaluate(condition entities.Condition, condTreeParams *entities.ConditionTreeParameters) (bool, error) {
-	// We should only be evaluating custom attributes
-	if condition.Type != audienceCondition {
-		return false, fmt.Errorf(`Unable to evaluator condition of type "%s"`, condition.Type)
-	}
+func (c AudienceConditionEvaluator) Evaluate(item interface{}, condTreeParams *entities.TreeParameters) (bool, error) {
+
 	var ok bool
 	var audienceID string
 
-	if audienceID, ok = condition.Value.(string); ok {
+	if audienceID, ok = item.(string); ok {
 		if audience, good := condTreeParams.AudienceMap[audienceID]; good {
 			condTree := audience.ConditionTree
-			conditionTreeEvaluator := NewConditionTreeEvaluator()
+			conditionTreeEvaluator := NewTreeEvaluator()
 			retValue := conditionTreeEvaluator.Evaluate(condTree, condTreeParams)
 			return retValue, nil
 		}

optimizely/decision/evaluator/condition_test.go

@@ -41,7 +41,7 @@ func TestCustomAttributeConditionEvaluator(t *testing.T) {
 		},
 	}
 
-	condTreeParams := entities.NewConditionTreeParameters(&user, map[string]entities.Audience{})
+	condTreeParams := entities.NewTreeParameters(&user, map[string]entities.Audience{})
 	result, _ := conditionEvaluator.Evaluate(condition, condTreeParams)
 	assert.Equal(t, result, true)
 

optimizely/decision/evaluator/condition_tree.go

@@ -17,11 +17,11 @@
 package evaluator
 
 import (
+	"fmt"
 	"github.com/optimizely/go-sdk/optimizely/entities"
 )
 
 const customAttributeType = "custom_attribute"
-const audienceCondition = "audience_condition"
 
 const (
 	// "and" operator returns true if all conditions evaluate to true
@@ -32,33 +32,26 @@ const (
 	orOperator = "or"
 )
 
-// ConditionTreeEvaluator evaluates a condition tree
-type ConditionTreeEvaluator struct {
-	conditionEvaluatorMap map[string]ConditionEvaluator
+//TreeEvaluator evaluates a condition tree
+type TreeEvaluator struct {
 }
 
-// NewConditionTreeEvaluator creates a condition tree evaluator with the out-of-the-box condition evaluators
-func NewConditionTreeEvaluator() *ConditionTreeEvaluator {
-	// For now, only one evaluator per attribute type
-	conditionEvaluatorMap := make(map[string]ConditionEvaluator)
-	conditionEvaluatorMap[customAttributeType] = CustomAttributeConditionEvaluator{}
-	conditionEvaluatorMap[audienceCondition] = AudienceConditionEvaluator{}
-	return &ConditionTreeEvaluator{
-		conditionEvaluatorMap: conditionEvaluatorMap,
-	}
+// NewTreeEvaluator creates a condition tree evaluator with the out-of-the-box condition evaluators
+func NewTreeEvaluator() *TreeEvaluator {
+	return &TreeEvaluator{}
 }
 
 // entities.UserContext
 // Evaluate returns true if the userAttributes satisfy the given condition tree
-func (c ConditionTreeEvaluator) Evaluate(node *entities.ConditionTreeNode, condTreeParams *entities.ConditionTreeParameters) bool {
+func (c TreeEvaluator) Evaluate(node *entities.TreeNode, condTreeParams *entities.TreeParameters) bool {
 	// This wrapper method converts the conditionEvalResult to a boolean
 	result, _ := c.evaluate(node, condTreeParams)
 	return result == true
 }
 
 // Helper method to recursively evaluate a condition tree
 // Returns the result of the evaluation and whether the evaluation of the condition is valid or not (to handle null bubbling)
-func (c ConditionTreeEvaluator) evaluate(node *entities.ConditionTreeNode, condTreeParams *entities.ConditionTreeParameters) (evalResult bool, isValid bool) {
+func (c TreeEvaluator) evaluate(node *entities.TreeNode, condTreeParams *entities.TreeParameters) (evalResult bool, isValid bool) {
 	operator := node.Operator
 	if operator != "" {
 		switch operator {
@@ -73,21 +66,28 @@ func (c ConditionTreeEvaluator) evaluate(node *entities.ConditionTreeNode, condT
 		}
 	}
 
-	conditionEvaluator, ok := c.conditionEvaluatorMap[node.Condition.Type]
-	if !ok {
-		// TODO(mng): log error
-		// Result is invalid
+	var result bool
+	var err error
+	switch v := node.Item.(type) {
+	case entities.Condition:
+		evaluator := CustomAttributeConditionEvaluator{}
+		result, err = evaluator.Evaluate(node.Item, condTreeParams)
+	case string:
+		evaluator := AudienceConditionEvaluator{}
+		result, err = evaluator.Evaluate(node.Item, condTreeParams)
+	default:
+		fmt.Printf("I don't know about type %T!\n", v)
 		return false, false
 	}
-	result, err := conditionEvaluator.Evaluate(node.Condition, condTreeParams)
+
 	if err != nil {
 		// Result is invalid
 		return false, false
 	}
 	return result, true
 }
 
-func (c ConditionTreeEvaluator) evaluateAnd(nodes []*entities.ConditionTreeNode, condTreeParams *entities.ConditionTreeParameters) (evalResult bool, isValid bool) {
+func (c TreeEvaluator) evaluateAnd(nodes []*entities.TreeNode, condTreeParams *entities.TreeParameters) (evalResult bool, isValid bool) {
 	sawInvalid := false
 	for _, node := range nodes {
 		result, isValid := c.evaluate(node, condTreeParams)
@@ -106,7 +106,7 @@ func (c ConditionTreeEvaluator) evaluateAnd(nodes []*entities.ConditionTreeNode,
 	return true, true
 }
 
-func (c ConditionTreeEvaluator) evaluateNot(nodes []*entities.ConditionTreeNode, condTreeParams *entities.ConditionTreeParameters) (evalResult bool, isValid bool) {
+func (c TreeEvaluator) evaluateNot(nodes []*entities.TreeNode, condTreeParams *entities.TreeParameters) (evalResult bool, isValid bool) {
 	if len(nodes) > 0 {
 		result, isValid := c.evaluate(nodes[0], condTreeParams)
 		if !isValid {
@@ -117,7 +117,7 @@ func (c ConditionTreeEvaluator) evaluateNot(nodes []*entities.ConditionTreeNode,
 	return false, false
 }
 
-func (c ConditionTreeEvaluator) evaluateOr(nodes []*entities.ConditionTreeNode, condTreeParams *entities.ConditionTreeParameters) (evalResult bool, isValid bool) {
+func (c TreeEvaluator) evaluateOr(nodes []*entities.TreeNode, condTreeParams *entities.TreeParameters) (evalResult bool, isValid bool) {
 	sawInvalid := false
 	for _, node := range nodes {
 		result, isValid := c.evaluate(node, condTreeParams)