Update FromInterface & Result As method

jsonq.go

@@ -150,6 +150,18 @@ func (j *JSONQ) From(node string) *JSONQ {
 	return j
 }
 
+// FromInterface reads the content from valid map[string]interface{}
+func (j *JSONQ) FromInterface(v interface{}) *JSONQ {
+	switch data := v.(type) {
+	case []interface{}, map[string]interface{}, map[string][]interface{}:
+		j.rootJSONContent = data
+		j.jsonContent = j.rootJSONContent
+	default:
+		j.addError(fmt.Errorf("invalid type [%T]", v))
+	}
+	return j
+}
+
 // Select use for selection of the properties from query result
 func (j *JSONQ) Select(properties ...string) *JSONQ {
 	j.attributes = append(j.attributes, properties...)

jsonq_test.go

@@ -326,6 +326,24 @@ func TestJSONQ_From(t *testing.T) {
 	assertJSON(t, out, expJSON, "accessing group by data")
 }
 
+func TestJSONQ_FromInterface(t *testing.T) {
+	var v map[string]interface{}
+	err := json.Unmarshal([]byte(jsonStr), &v)
+	if err != nil {
+		t.Error(err)
+	}
+	jq := New().FromInterface(v)
+	if jq.rootJSONContent == nil || jq.jsonContent == nil {
+		t.Errorf("failed to assign value using FromInterface method")
+	}
+
+	var customType float64
+	jq = New().FromInterface(customType)
+	if jq.Error() == nil {
+		t.Errorf("failed to set error properly for FromInterface method")
+	}
+}
+
 func TestJSONQ_Where_single_where(t *testing.T) {
 	jq := New().FromString(jsonStr).
 		From("vendor.items").

result.go

@@ -57,6 +57,10 @@ func (r *Result) As(v interface{}) error {
 			"*[]float32": "Float32Slice", "*[]float64": "Float64Slice",
 		}
 
+		if methodMap[method] == "" {
+			return fmt.Errorf("gojsonq: type [%T] is not available", v)
+		}
+
 		vv := reflect.ValueOf(r).MethodByName(methodMap[method]).Call(nil)
 		if vv != nil {
 			if vv[1].Interface() != nil {

result_test.go

@@ -21,6 +21,7 @@ func TestNil(t *testing.T) {
 }
 
 func TestAs(t *testing.T) {
+	type flt float64
 	testCases := []struct {
 		tag              string
 		value            interface{}
@@ -96,6 +97,23 @@ func TestAs(t *testing.T) {
 			},
 			errExpect: true,
 		},
+		{
+			tag:   "custom type error check",
+			value: string("*nop"),
+			newExpectedValue: func() interface{} {
+				var a flt
+				return &a
+			},
+			expect: func(value, i interface{}) bool {
+				val, ok := i.(string)
+				if !ok {
+					return false
+				}
+
+				return val == (value.(string))
+			},
+			errExpect: true,
+		},
 	}
 
 	for _, tc := range testCases {