Merge pull request #5 from huttotw/fix/float64

fix/float64

Author: huttotw

rule.go

@@ -2,6 +2,7 @@ package grules
 
 import (
 	"encoding/json"
+	"math"
 )
 
 const (
@@ -128,3 +129,38 @@ func (r Rule) evaluate(props map[string]interface{}, comps map[string]Comparator
 
 	return comp(val, r.Value)
 }
+
+// UnmarshalJSON will unmarshal a rule, converting any integers to int64 and
+// floats to float64s. This is important because of how we can pass data
+// as props
+func (r *Rule) UnmarshalJSON(data []byte) error {
+	var m map[string]interface{}
+	err := json.Unmarshal(data, &m)
+	if err != nil {
+		return err
+	}
+
+	var val interface{}
+	switch m["value"].(type) {
+	case float64:
+		if math.Floor(m["value"].(float64))-m["value"].(float64) == 0 {
+			val = int64(m["value"].(float64))
+		} else {
+			val = m["value"]
+		}
+	default:
+		val = m["value"]
+	}
+
+	if m["comparator"] != nil {
+		r.Comparator = m["comparator"].(string)
+	}
+
+	if m["path"] != nil {
+		r.Path = m["path"].(string)
+	}
+
+	r.Value = val
+
+	return nil
+}

rule_test.go

@@ -1,6 +1,8 @@
 package grules
 
 import (
+	"encoding/json"
+	"reflect"
 	"testing"
 )
 
@@ -217,14 +219,14 @@ func TestEngineEvaluate(t *testing.T) {
 		e.Composites = []Composite{
 			Composite{
 				Operator: OperatorAnd,
-			Rules: []Rule{
-				Rule{
-					Comparator: "contains",
-					Path: "address.bedroom.furniture",
-					Value: "tv",
+				Rules: []Rule{
+					Rule{
+						Comparator: "contains",
+						Path:       "address.bedroom.furniture",
+						Value:      "tv",
+					},
 				},
 			},
-			},	
 		}
 		res := e.Evaluate(props)
 		if res != true {
@@ -279,3 +281,44 @@ func TestEngineEvaluate(t *testing.T) {
 		}
 	})
 }
+
+func TestRuleUnmarshalJSON(t *testing.T) {
+	t.Run("string", func(t *testing.T) {
+		b := []byte(`{"path":"name","comparator":"eq","value":"trevor"}`)
+		var r Rule
+		err := json.Unmarshal(b, &r)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if reflect.TypeOf(r.Value).Kind() != reflect.String {
+			t.Fatal("expected value to be of type string")
+		}
+	})
+
+	t.Run("int64", func(t *testing.T) {
+		b := []byte(`{"path":"name","comparator":"eq","value":1}`)
+		var r Rule
+		err := json.Unmarshal(b, &r)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if reflect.TypeOf(r.Value).Kind() != reflect.Int64 {
+			t.Fatal("expected value to be of type int64")
+		}
+	})
+
+	t.Run("float64", func(t *testing.T) {
+		b := []byte(`{"path":"name","comparator":"eq","value":1.1}`)
+		var r Rule
+		err := json.Unmarshal(b, &r)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if reflect.TypeOf(r.Value).Kind() != reflect.Float64 {
+			t.Fatal("expected value to be of type float64")
+		}
+	})
+}