(chore)Export more helper functions.

Author: huangjunwen

array_str.go

@@ -65,7 +65,7 @@ func opFilter(apply Applier, params []interface{}, data interface{}) (res interf
 		if err != nil {
 			return nil, err
 		}
-		if toBool(r) {
+		if ToBool(r) {
 			filteredArr = append(filteredArr, item)
 		}
 	}
@@ -138,7 +138,7 @@ func opAll(apply Applier, params []interface{}, data interface{}) (res interface
 		if err != nil {
 			return nil, err
 		}
-		if !toBool(r) {
+		if !ToBool(r) {
 			return false, nil
 		}
 	}
@@ -175,7 +175,7 @@ func opNone(apply Applier, params []interface{}, data interface{}) (res interfac
 		if err != nil {
 			return nil, err
 		}
-		if toBool(r) {
+		if ToBool(r) {
 			return false, nil
 		}
 	}
@@ -212,7 +212,7 @@ func opSome(apply Applier, params []interface{}, data interface{}) (res interfac
 		if err != nil {
 			return nil, err
 		}
-		if toBool(r) {
+		if ToBool(r) {
 			return true, nil
 		}
 	}
@@ -258,14 +258,14 @@ func opIn(apply Applier, params []interface{}, data interface{}) (res interface{
 	}
 
 	param0 := params[0]
-	if !isPrimitive(param0) {
+	if !IsPrimitive(param0) {
 		return nil, fmt.Errorf("in: expect json primitive as first param but got %T", param0)
 	}
 
 	switch param1 := params[1].(type) {
 	case []interface{}:
 		for _, item := range param1 {
-			if !isPrimitive(item) {
+			if !IsPrimitive(item) {
 				return nil, fmt.Errorf("in: expect json primitives in array but got %T", item)
 			}
 			if param0 == item {
@@ -274,7 +274,7 @@ func opIn(apply Applier, params []interface{}, data interface{}) (res interface{
 		}
 		return false, nil
 	case string:
-		s, err := toString(param0)
+		s, err := ToString(param0)
 		if err != nil {
 			return nil, err
 		}
@@ -298,7 +298,7 @@ func opCat(apply Applier, params []interface{}, data interface{}) (res interface
 	}
 	parts := []string{}
 	for _, param := range params {
-		s, err := toString(param)
+		s, err := ToString(param)
 		if err != nil {
 			return nil, err
 		}
@@ -322,15 +322,15 @@ func opSubstr(apply Applier, params []interface{}, data interface{}) (res interf
 		return
 	}
 
-	s, err := toString(params[0])
+	s, err := ToString(params[0])
 	if err != nil {
 		return nil, err
 	}
 	r := []rune(s)
 
 	var start int
 	{
-		param1, err := toNumeric(params[1])
+		param1, err := ToNumeric(params[1])
 		if err != nil {
 			return nil, err
 		}
@@ -348,7 +348,7 @@ func opSubstr(apply Applier, params []interface{}, data interface{}) (res interf
 		hasEnd bool
 	)
 	if len(params) > 2 {
-		param2, err := toNumeric(params[2])
+		param2, err := ToNumeric(params[2])
 		if err != nil {
 			return nil, err
 		}

helpers.go

@@ -38,8 +38,8 @@ func getLogic(obj interface{}) (op string, params []interface{}) {
 	panic(fmt.Errorf("no operator in logic"))
 }
 
-// isPrimitive returns true if obj is json primitive.
-func isPrimitive(obj interface{}) bool {
+// IsPrimitive returns true if obj is json primitive (null/bool/float64/string).
+func IsPrimitive(obj interface{}) bool {
 	switch obj.(type) {
 	case nil:
 		return true
@@ -54,15 +54,15 @@ func isPrimitive(obj interface{}) bool {
 	case map[string]interface{}:
 		return false
 	default:
-		panic(fmt.Errorf("isPrimitive not support type %T", obj))
+		panic(fmt.Errorf("IsPrimitive not support type %T", obj))
 	}
 }
 
-// toBool returns the truthy of a json object.
+// ToBool returns the truthy of a json object.
 // ref:
 //   - http://jsonlogic.com/truthy.html
 //   - json-logic-js/logic.js::truthy
-func toBool(obj interface{}) bool {
+func ToBool(obj interface{}) bool {
 	switch o := obj.(type) {
 	case nil:
 		return false
@@ -78,23 +78,23 @@ func toBool(obj interface{}) bool {
 		// Always true
 		return true
 	default:
-		panic(fmt.Errorf("toBool got non-json type %T", obj))
+		panic(fmt.Errorf("ToBool got non-json type %T", obj))
 	}
 }
 
-// toNumeric converts json primitive to numeric. It should be the same as JavaScript's Number(), except:
+// ToNumeric converts json primitive to numeric. It should be the same as JavaScript's Number(), except:
 //   - an error is returned if obj is not a json primitive.
 //   - an error is returned if obj is string but not well-formed.
 //   - the number is NaN or +Inf/-Inf.
-func toNumeric(obj interface{}) (f float64, err error) {
+func ToNumeric(obj interface{}) (f float64, err error) {
 	defer func() {
 		if err == nil {
 			if math.IsNaN(f) {
 				f = 0
-				err = fmt.Errorf("toNumeric got NaN")
+				err = fmt.Errorf("ToNumeric got NaN")
 			} else if math.IsInf(f, 0) {
 				f = 0
-				err = fmt.Errorf("toNumeric got +Inf/-Inf")
+				err = fmt.Errorf("ToNumeric got +Inf/-Inf")
 			}
 		}
 	}()
@@ -112,16 +112,16 @@ func toNumeric(obj interface{}) (f float64, err error) {
 	case string:
 		return strconv.ParseFloat(o, 64)
 	case []interface{}, map[string]interface{}:
-		return 0, fmt.Errorf("toNumeric not support type %T", obj)
+		return 0, fmt.Errorf("ToNumeric not support type %T", obj)
 	default:
-		panic(fmt.Errorf("toNumeric got non-json type %T", obj))
+		panic(fmt.Errorf("ToNumeric got non-json type %T", obj))
 	}
 }
 
-// toString converts json primitive to string. It should be the same as JavaScript's String(), except:
+// ToString converts json primitive to string. It should be the same as JavaScript's String(), except:
 //   - an error is returned if obj is not a json primitive.
 //   - obj is number NaN or +Inf/-Inf.
-func toString(obj interface{}) (string, error) {
+func ToString(obj interface{}) (string, error) {
 	switch o := obj.(type) {
 	case nil:
 		return "null", nil
@@ -132,34 +132,36 @@ func toString(obj interface{}) (string, error) {
 		return "false", nil
 	case float64:
 		if math.IsNaN(o) {
-			return "", fmt.Errorf("toString got NaN")
+			return "", fmt.Errorf("ToString got NaN")
 		}
 		if math.IsInf(o, 0) {
-			return "", fmt.Errorf("toString got +Inf/-Inf")
+			return "", fmt.Errorf("ToString got +Inf/-Inf")
 		}
 		return strconv.FormatFloat(o, 'f', -1, 64), nil
 	case string:
 		return o, nil
 	case []interface{}, map[string]interface{}:
-		return "", fmt.Errorf("toString not support type %T", obj)
+		return "", fmt.Errorf("ToString not support type %T", obj)
 	default:
-		panic(fmt.Errorf("toString got non-json type %T", obj))
+		panic(fmt.Errorf("ToString got non-json type %T", obj))
 	}
 }
 
-type compSymbol string
+// CompSymbol represents compare operator.
+type CompSymbol string
 
-// compare symbol can be "<"/"<="/">"/">="
 const (
-	lt compSymbol = "<"
-	le compSymbol = "<="
-	gt compSymbol = ">"
-	ge compSymbol = ">="
+	LT CompSymbol = "<"
+	LE CompSymbol = "<="
+	GT CompSymbol = ">"
+	GE CompSymbol = ">="
+	EQ CompSymbol = "==="
+	NE CompSymbol = "!=="
 )
 
-// compareValues compares json primitives. It should be the same as JavaScript's "<"/"<="/">"/">=", except:
+// CompareValues compares json primitives. It should be the same as JavaScript's "<"/"<="/">"/">="/"==="/"!==", except:
 //   - an error is returned if any value is not a json primitive.
-//   - any error retuend by toNumeric.
+//   - any error retuend by ToNumeric.
 //
 // ref:
 //   - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Less_than
@@ -172,44 +174,51 @@ const (
 //     >   Strings are converted based on the values they contain, and are converted as NaN if they do not contain numeric values.
 //     > If either value is NaN, the operator returns false.
 //     > Otherwise the values are compared as numeric values.
-func compareValues(symbol compSymbol, left, right interface{}) (bool, error) {
-	if !isPrimitive(left) || !isPrimitive(right) {
+func CompareValues(symbol CompSymbol, left, right interface{}) (bool, error) {
+	if !IsPrimitive(left) || !IsPrimitive(right) {
 		return false, fmt.Errorf("only primitive values can be compared")
 	}
+	switch symbol {
+	case EQ:
+		return left == right, nil
+	case NE:
+		return left != right, nil
+	}
+
 	leftStr, leftIsStr := left.(string)
 	rightStr, rightIsStr := right.(string)
 	if leftIsStr && rightIsStr {
 		switch symbol {
-		case lt:
+		case LT:
 			return leftStr < rightStr, nil
-		case le:
+		case LE:
 			return leftStr <= rightStr, nil
-		case gt:
+		case GT:
 			return leftStr > rightStr, nil
-		case ge:
+		case GE:
 			return leftStr >= rightStr, nil
 		default:
 			panic(fmt.Errorf("Impossible branch"))
 		}
 	}
 
-	leftNum, err := toNumeric(left)
+	leftNum, err := ToNumeric(left)
 	if err != nil {
 		return false, err
 	}
 
-	rightNum, err := toNumeric(right)
+	rightNum, err := ToNumeric(right)
 	if err != nil {
 		return false, err
 	}
 	switch symbol {
-	case lt:
+	case LT:
 		return leftNum < rightNum, nil
-	case le:
+	case LE:
 		return leftNum <= rightNum, nil
-	case gt:
+	case GT:
 		return leftNum > rightNum, nil
-	case ge:
+	case GE:
 		return leftNum >= rightNum, nil
 	default:
 		panic(fmt.Errorf("Impossible branch"))

helpers_test.go

@@ -65,7 +65,7 @@ func TestToBool(t *testing.T) {
 		{Obj: map[string]interface{}{}, IsTrue: true},
 		{Obj: map[string]interface{}{"var": "x"}, IsTrue: true},
 	} {
-		assert.Equal(testCase.IsTrue, toBool(testCase.Obj), "test case %d", i)
+		assert.Equal(testCase.IsTrue, ToBool(testCase.Obj), "test case %d", i)
 	}
 }
 
@@ -92,7 +92,7 @@ func TestToNumeric(t *testing.T) {
 		{Obj: "-inf", Err: true},
 		{Obj: "+inf", Err: true},
 	} {
-		n, err := toNumeric(testCase.Obj)
+		n, err := ToNumeric(testCase.Obj)
 		if testCase.Err {
 			assert.Error(err, "test case %d", i)
 		} else {
@@ -101,6 +101,7 @@ func TestToNumeric(t *testing.T) {
 		}
 	}
 }
+
 func TestToString(t *testing.T) {
 	assert := assert.New(t)
 
@@ -120,7 +121,7 @@ func TestToString(t *testing.T) {
 		{Obj: []interface{}{1}, Err: true},
 		{Obj: map[string]interface{}{}, Err: true},
 	} {
-		s, err := toString(testCase.Obj)
+		s, err := ToString(testCase.Obj)
 		if testCase.Err {
 			assert.Error(err, "test case %d", i)
 		} else {
@@ -134,19 +135,21 @@ func TestCompareValues(t *testing.T) {
 	assert := assert.New(t)
 
 	for i, testCase := range []struct {
-		Symbol compSymbol
+		Symbol CompSymbol
 		Left   interface{}
 		Right  interface{}
 		Result bool
 		Err    bool
 	}{
-		{Symbol: lt, Left: "1", Right: "a", Result: true},          // This is compared as strings.
-		{Symbol: lt, Left: "1", Right: float64(1.1), Result: true}, // This is compared as numerics.
-		{Symbol: lt, Left: float64(1), Right: "a", Err: true},
-		{Symbol: lt, Left: "a", Right: float64(1), Err: true},
-		{Symbol: lt, Left: []interface{}{}, Right: float64(1), Err: true},
+		{Symbol: LT, Left: "1", Right: "a", Result: true},          // This is compared as strings.
+		{Symbol: LT, Left: "1", Right: float64(1.1), Result: true}, // This is compared as numerics.
+		{Symbol: LT, Left: float64(1), Right: "a", Err: true},
+		{Symbol: LT, Left: "a", Right: float64(1), Err: true},
+		{Symbol: LT, Left: []interface{}{}, Right: float64(1), Err: true},
+		{Symbol: EQ, Left: float64(3), Right: float64(3), Result: true},
+		{Symbol: EQ, Left: float64(3), Right: "3", Result: false},
 	} {
-		result, err := compareValues(testCase.Symbol, testCase.Left, testCase.Right)
+		result, err := CompareValues(testCase.Symbol, testCase.Left, testCase.Right)
 		if testCase.Err {
 			assert.Error(err, "test case %d", i)
 		} else {