Add json.Number test.

Author: q-uint

attrexp_test.go

@@ -72,6 +72,29 @@ func TestParseNumber(t *testing.T) {
 					t.Error(test.nStr, i)
 				}
 
+				// Check if equal to json.Decode.
+				if i != number {
+					t.Error(number, i)
+				}
+			}
+			{ // Config with useNumber = true.
+				d := json.NewDecoder(strings.NewReader(test.nStr))
+				d.UseNumber()
+				var number json.Number
+				if err := d.Decode(&number); err != nil {
+					t.Error(err)
+				}
+
+				i, err := config{
+					useNumber: true,
+				}.parseNumber(n)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if i != json.Number(test.nStr) {
+					t.Error(test.nStr, i)
+				}
+
 				// Check if equal to json.Decode.
 				if i != number {
 					t.Error(number, i)

filter.go

@@ -32,86 +32,86 @@ func parseFilter(raw []byte, c config) (Expression, error) {
 	return c.parseFilterOr(node)
 }
 
-func (p config) parseFilterOr(node *ast.Node) (Expression, error) {
-	if node.Type != typ.FilterOr {
-		return nil, invalidTypeError(typ.FilterOr, node.Type)
+func (p config) parseFilterAnd(node *ast.Node) (Expression, error) {
+	if node.Type != typ.FilterAnd {
+		return nil, invalidTypeError(typ.FilterAnd, node.Type)
 	}
 
 	children := node.Children()
 	if len(children) == 0 {
-		return nil, invalidLengthError(typ.FilterOr, 1, 0)
+		return nil, invalidLengthError(typ.FilterAnd, 1, 0)
 	}
 
 	if len(children) == 1 {
-		return p.parseFilterAnd(children[0])
+		return p.parseFilterValue(children[0])
 	}
 
-	var or LogicalExpression
+	var and LogicalExpression
 	for _, node := range children {
-		exp, err := p.parseFilterAnd(node)
+		exp, err := p.parseFilterValue(node)
 		if err != nil {
 			return nil, err
 		}
 		switch {
-		case or.Left == nil:
-			or.Left = exp
-		case or.Right == nil:
-			or.Right = exp
-			or.Operator = OR
+		case and.Left == nil:
+			and.Left = exp
+		case and.Right == nil:
+			and.Right = exp
+			and.Operator = AND
 		default:
-			or = LogicalExpression{
+			and = LogicalExpression{
 				Left: &LogicalExpression{
-					Left:     or.Left,
-					Right:    or.Right,
-					Operator: OR,
+					Left:     and.Left,
+					Right:    and.Right,
+					Operator: AND,
 				},
 				Right:    exp,
-				Operator: OR,
+				Operator: AND,
 			}
 		}
 	}
-	return &or, nil
+	return &and, nil
 }
 
-func (p config) parseFilterAnd(node *ast.Node) (Expression, error) {
-	if node.Type != typ.FilterAnd {
-		return nil, invalidTypeError(typ.FilterAnd, node.Type)
+func (p config) parseFilterOr(node *ast.Node) (Expression, error) {
+	if node.Type != typ.FilterOr {
+		return nil, invalidTypeError(typ.FilterOr, node.Type)
 	}
 
 	children := node.Children()
 	if len(children) == 0 {
-		return nil, invalidLengthError(typ.FilterAnd, 1, 0)
+		return nil, invalidLengthError(typ.FilterOr, 1, 0)
 	}
 
 	if len(children) == 1 {
-		return p.parseFilterValue(children[0])
+		return p.parseFilterAnd(children[0])
 	}
 
-	var and LogicalExpression
+	var or LogicalExpression
 	for _, node := range children {
-		exp, err := p.parseFilterValue(node)
+		exp, err := p.parseFilterAnd(node)
 		if err != nil {
 			return nil, err
 		}
 		switch {
-		case and.Left == nil:
-			and.Left = exp
-		case and.Right == nil:
-			and.Right = exp
-			and.Operator = AND
+		case or.Left == nil:
+			or.Left = exp
+		case or.Right == nil:
+			or.Right = exp
+			or.Operator = OR
 		default:
-			and = LogicalExpression{
+			or = LogicalExpression{
 				Left: &LogicalExpression{
-					Left:     and.Left,
-					Right:    and.Right,
-					Operator: AND,
+					Left:     or.Left,
+					Right:    or.Right,
+					Operator: OR,
 				},
 				Right:    exp,
-				Operator: AND,
+				Operator: OR,
 			}
 		}
 	}
-	return &and, nil
+	return &or, nil
 }
 
 func (p config) parseFilterValue(node *ast.Node) (Expression, error) {

valuepath.go

@@ -32,32 +32,6 @@ func parseValuePath(raw []byte, c config) (ValuePath, error) {
 	return c.parseValuePath(node)
 }
 
-func (p config) parseValuePath(node *ast.Node) (ValuePath, error) {
-	if node.Type != typ.ValuePath {
-		return ValuePath{}, invalidTypeError(typ.ValuePath, node.Type)
-	}
-
-	children := node.Children()
-	if l := len(children); l != 2 {
-		return ValuePath{}, invalidLengthError(typ.ValuePath, 2, l)
-	}
-
-	attrPath, err := parseAttrPath(children[0])
-	if err != nil {
-		return ValuePath{}, err
-	}
-
-	valueFilter, err := p.parseValueFilter(children[1])
-	if err != nil {
-		return ValuePath{}, err
-	}
-
-	return ValuePath{
-		AttributePath: attrPath,
-		ValueFilter:   valueFilter,
-	}, nil
-}
-
 func (p config) parseValueFilter(node *ast.Node) (Expression, error) {
 	switch t := node.Type; t {
 	case typ.ValueLogExpOr, typ.ValueLogExpAnd:
@@ -110,3 +84,29 @@ func (p config) parseValueFilter(node *ast.Node) (Expression, error) {
 		return nil, invalidChildTypeError(typ.ValuePath, t)
 	}
 }
+
+func (p config) parseValuePath(node *ast.Node) (ValuePath, error) {
+	if node.Type != typ.ValuePath {
+		return ValuePath{}, invalidTypeError(typ.ValuePath, node.Type)
+	}
+
+	children := node.Children()
+	if l := len(children); l != 2 {
+		return ValuePath{}, invalidLengthError(typ.ValuePath, 2, l)
+	}
+
+	attrPath, err := parseAttrPath(children[0])
+	if err != nil {
+		return ValuePath{}, err
+	}
+
+	valueFilter, err := p.parseValueFilter(children[1])
+	if err != nil {
+		return ValuePath{}, err
+	}
+
+	return ValuePath{
+		AttributePath: attrPath,
+		ValueFilter:   valueFilter,
+	}, nil
+}