Update As method

Author: thedevsaddam

README.md

@@ -1,7 +1,7 @@
 ![gojsonq-logo](gojsonq.png)
 
 [![Build Status](https://travis-ci.org/thedevsaddam/gojsonq.svg?branch=master)](https://travis-ci.org/thedevsaddam/gojsonq)
-[![Project status](https://img.shields.io/badge/version-v2.3-green.svg)](https://github.com/thedevsaddam/gojsonq/releases)
+[![Project status](https://img.shields.io/badge/version-v2.4-green.svg)](https://github.com/thedevsaddam/gojsonq/releases)
 [![Go Report Card](https://goreportcard.com/badge/github.com/thedevsaddam/gojsonq)](https://goreportcard.com/report/github.com/thedevsaddam/gojsonq)
 [![Coverage Status](https://coveralls.io/repos/github/thedevsaddam/gojsonq/badge.svg?branch=master)](https://coveralls.io/github/thedevsaddam/gojsonq?branch=master)
 [![GoDoc](https://godoc.org/github.com/thedevsaddam/gojsonq?status.svg)](https://godoc.org/github.com/thedevsaddam/gojsonq)

option_test.go

@@ -4,29 +4,58 @@ import (
 	"testing"
 )
 
-func TestSetDecoder(t *testing.T) {
+func TestWithDecoder(t *testing.T) {
 	jq := New(WithDecoder(&cDecoder{}))
 	if jq.option.decoder == nil {
 		t.Error("failed to set decoder as option")
 	}
 }
 
-func TestSetDecoder_with_nil_expecting_an_error(t *testing.T) {
+func TestWithDecoder_with_nil_expecting_an_error(t *testing.T) {
 	jq := New(WithDecoder(nil))
+	if jq.Error() == nil {
+		t.Error("failed to catch nil in WithDecoder")
+	}
+}
+
+func TestWithSeparator(t *testing.T) {
+	jq := New(WithSeparator("->"))
+	if jq.option.separator != "->" {
+		t.Error("failed to set separator as option")
+	}
+}
+
+func TestWithSeparator_with_nil_expecting_an_error(t *testing.T) {
+	jq := New(WithSeparator(""))
+	if jq.Error() == nil {
+		t.Error("failed to catch nil in WithSeparator")
+	}
+}
+
+// to increase the code coverage; will remove in major release
+func TestSetDecoder(t *testing.T) {
+	jq := New(SetDecoder(&cDecoder{}))
+	if jq.option.decoder == nil {
+		t.Error("failed to set decoder as option")
+	}
+}
+
+func TestSetDecoder_with_nil_expecting_an_error(t *testing.T) {
+	jq := New(SetDecoder(nil))
 	if jq.Error() == nil {
 		t.Error("failed to catch nil in SetDecoder")
 	}
 }
 
 func TestSetSeparator(t *testing.T) {
-	jq := New(WithSeparator("->"))
+	jq := New(SetSeparator("->"))
 	if jq.option.separator != "->" {
 		t.Error("failed to set separator as option")
 	}
 }
 
 func TestSetSeparator_with_nil_expecting_an_error(t *testing.T) {
-	jq := New(WithSeparator(""))
+	jq := New(SetSeparator(""))
 	if jq.Error() == nil {
 		t.Error("failed to catch nil in SetSeparator")
 	}

result.go

@@ -9,6 +9,7 @@ import (
 
 const errMessage = "gojsonq: wrong method call for %v"
 
+// Available named error values
 var (
 	ErrExpectsPointer = fmt.Errorf("gojsonq: failed to unmarshal, expects pointer")
 	ErrImmutable      = fmt.Errorf("gojsonq: failed to unmarshal, target is not mutable")
@@ -30,7 +31,7 @@ func (r *Result) Nil() bool {
 	return r.value == nil
 }
 
-// As sets the value of Result to v
+// As sets the value of Result to v; It does not support methods with argument available in Result
 func (r *Result) As(v interface{}) error {
 	if r.value != nil {
 		rv := reflect.ValueOf(v)
@@ -43,11 +44,26 @@ func (r *Result) As(v interface{}) error {
 			return ErrImmutable
 		}
 
-		value := reflect.ValueOf(r.value)
-		if !reflect.TypeOf(r.value).AssignableTo(reflect.TypeOf(v).Elem()) {
-			return ErrTypeMismatch
+		method := rv.Type().String()
+		methodMap := map[string]string{
+			"*string": "String", "*bool": "Bool", "*time.Duration": "Duration",
+			"*int": "Int", "*int8": "Int8", "*int16": "Int16", "*int32": "Int32",
+			"*uint": "Uint", "*uint8": "Uint8", "*uint16": "Uint16", "*uint32": "Uint32",
+			"*float32": "Float32", "*float64": "Float64",
+
+			"*[]string": "StringSlice", "*[]bool": "BoolSlice", "*[]time.Duration": "DurationSlice",
+			"*[]int": "IntSlice", "*[]int8": "Int8Slice", "*[]int16": "Int16Slice", "*[]int32": "Int32Slice",
+			"*[]uint": "UintSlice", "*[]uint8": "Uint8Slice", "*[]uint16": "Uint16Slice", "*[]uint32": "Uint32Slice",
+			"*[]float32": "Float32Slice", "*[]float64": "Float64Slice",
+		}
+
+		vv := reflect.ValueOf(r).MethodByName(methodMap[method]).Call(nil)
+		if vv != nil {
+			if vv[1].Interface() != nil {
+				return ErrTypeMismatch
+			}
+			rv.Elem().Set(vv[0])
 		}
-		rv.Elem().Set(value)
 	}
 	return nil
 }

result_test.go

@@ -29,65 +29,70 @@ func TestAs(t *testing.T) {
 		errExpect        bool
 	}{
 		{
-			tag:   "as int32",
-			value: int32(1),
+			tag:   "float64 as int", // golang unmarshal number to float64
+			value: float64(1),
 			newExpectedValue: func() interface{} {
-				var a int32
+				var a int
 				return &a
 			},
 			expect: func(value, i interface{}) bool {
-				val, ok := i.(int32)
+				val, ok := i.(int)
 				if !ok {
 					return false
 				}
 
-				return val == (value.(int32))
+				return val == (value.(int))
 			},
 			errExpect: false,
 		},
 		{
-			tag:   "int32 as string",
-			value: int32(1),
+			tag:   "float64 as uint",
+			value: float64(1),
 			newExpectedValue: func() interface{} {
-				var a string
+				var a uint
 				return &a
 			},
 			expect: func(value, i interface{}) bool {
-				return false
+				val, ok := i.(uint)
+				if !ok {
+					return false
+				}
+
+				return val == (value.(uint))
 			},
-			errExpect: true,
+			errExpect: false,
 		},
 		{
-			tag:   "int32 as int64",
-			value: int32(1),
+			tag:   "float64 assign to non ptr",
+			value: float64(1),
 			newExpectedValue: func() interface{} {
-				var a int64
-				return &a
+				var a float64
+				return a
 			},
 			expect: func(value, i interface{}) bool {
-				val, ok := i.(int64)
+				val, ok := i.(float64)
 				if !ok {
 					return false
 				}
 
-				return val == (value.(int64))
+				return val == (value.(float64))
 			},
 			errExpect: true,
 		},
 		{
-			tag:   "int32 as int16",
-			value: int32(1),
+			tag:   "string assign to int",
+			value: string("*nop"),
 			newExpectedValue: func() interface{} {
-				var a int16
+				var a float64
 				return &a
 			},
 			expect: func(value, i interface{}) bool {
-				val, ok := i.(int16)
+				val, ok := i.(string)
 				if !ok {
 					return false
 				}
 
-				return val == (value.(int16))
+				return val == (value.(string))
 			},
 			errExpect: true,
 		},