decode: can decode into interfaces

Author: mitchellh

decode.go

@@ -67,6 +67,9 @@ func (d *decoder) decode(name string, v *MrbValue, result reflect.Value) error {
 		return d.decodeFloat(name, v, result)
 	case reflect.Int:
 		return d.decodeInt(name, v, result)
+	case reflect.Interface:
+		// When we see an interface, we make our own thing
+		return d.decodeInterface(name, v, result)
 	case reflect.Map:
 		return d.decodeMap(name, v, result)
 	case reflect.Ptr:
@@ -127,6 +130,60 @@ func (d *decoder) decodeInt(name string, v *MrbValue, result reflect.Value) erro
 	return nil
 }
 
+func (d *decoder) decodeInterface(name string, v *MrbValue, result reflect.Value) error {
+	var set reflect.Value
+	redecode := true
+
+	switch t := v.Type(); t {
+	case TypeHash:
+		var temp map[string]interface{}
+		tempVal := reflect.ValueOf(temp)
+		result := reflect.MakeMap(
+			reflect.MapOf(
+				reflect.TypeOf(""),
+				tempVal.Type().Elem()))
+
+		set = result
+	case TypeArray:
+		var temp []interface{}
+		tempVal := reflect.ValueOf(temp)
+		result := reflect.MakeSlice(
+			reflect.SliceOf(tempVal.Type().Elem()), 0, 0)
+		set = result
+	case TypeFalse:
+		fallthrough
+	case TypeTrue:
+		var result bool
+		set = reflect.Indirect(reflect.New(reflect.TypeOf(result)))
+	case TypeFixnum:
+		var result int
+		set = reflect.Indirect(reflect.New(reflect.TypeOf(result)))
+	case TypeFloat:
+		var result float64
+		set = reflect.Indirect(reflect.New(reflect.TypeOf(result)))
+	case TypeString:
+		set = reflect.Indirect(reflect.New(reflect.TypeOf("")))
+	default:
+		return fmt.Errorf(
+			"%s: cannot decode into interface: %s",
+			name, t)
+	}
+
+	// Set the result to what its supposed to be, then reset
+	// result so we don't reflect into this method anymore.
+	result.Set(set)
+
+	if redecode {
+		// Revisit the node so that we can use the newly instantiated
+		// thing and populate it.
+		if err := d.decode(name, v, result); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func (d *decoder) decodeMap(name string, v *MrbValue, result reflect.Value) error {
 	if v.Type() != TypeHash {
 		return fmt.Errorf("%s: not a hash type for map (%v)", name, v.Type())

decode_test.go

@@ -137,6 +137,79 @@ func TestDecode(t *testing.T) {
 	}
 }
 
+func TestDecodeInterface(t *testing.T) {
+	cases := []struct {
+		Input    string
+		Expected interface{}
+	}{
+		// Booleans
+		{
+			"true",
+			true,
+		},
+
+		{
+			"false",
+			false,
+		},
+
+		// Float
+		{
+			"1.2",
+			float64(1.2000000476837158),
+		},
+
+		// Int
+		{
+			"32",
+			int(32),
+		},
+
+		// Map
+		{
+			`{"foo" => "bar"}`,
+			map[string]interface{}{"foo": "bar"},
+		},
+
+		{
+			`{32 => "bar"}`,
+			map[string]interface{}{"32": "bar"},
+		},
+
+		// Slice
+		{
+			`["foo", "bar"]`,
+			[]interface{}{"foo", "bar"},
+		},
+
+		// String
+		{
+			`"32"`,
+			"32",
+		},
+	}
+
+	for _, tc := range cases {
+		mrb := NewMrb()
+		value, err := mrb.LoadString(tc.Input)
+		if err != nil {
+			mrb.Close()
+			t.Fatalf("err: %s\n\n%s", err, tc.Input)
+		}
+
+		var result interface{}
+		err = Decode(&result, value)
+		mrb.Close()
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		if !reflect.DeepEqual(result, tc.Expected) {
+			t.Fatalf("bad: \n\n%s\n\n%#v\n\n%#v", tc.Input, result, tc.Expected)
+		}
+	}
+}
+
 const testDecodeObjectMethods = `
 class Foo
 	def foo