Support floats

mapstructure.go

diff --git a/mapstructure.go b/mapstructure.go
index e7c4155..a84a489 100644
--- a/mapstructure.go
+++ b/mapstructure.go
@@ -124,17 +124,10 @@
 		return nil
 	}
 
-	k := val.Kind()
-
-	// Some shortcuts because we treat all ints and uints the same way
-	if k >= reflect.Int && k <= reflect.Int64 {
-		k = reflect.Int
-	} else if k >= reflect.Uint && k <= reflect.Uint64 {
-		k = reflect.Uint
-	}
-
 	var err error
-	switch k {
+	dataKind := d.getKind(val)
+
+	switch dataKind {
 	case reflect.Bool:
 		fallthrough
 	case reflect.Interface:
@@ -142,9 +135,11 @@
 	case reflect.String:
 		err = d.decodeBasic(name, data, val)
 	case reflect.Int:
-		fallthrough
-	case reflect.Uint:
 		err = d.decodeInt(name, data, val)
+	case reflect.Uint:
+		err = d.decodeUint(name, data, val)
+	case reflect.Float32:
+		err = d.decodeFloat(name, data, val)
 	case reflect.Struct:
 		err = d.decodeStruct(name, data, val)
 	case reflect.Map:
@@ -153,7 +148,7 @@
 		err = d.decodeSlice(name, data, val)
 	default:
 		// If we reached this point then we weren't able to decode it
-		return fmt.Errorf("%s: unsupported type: %s", name, k)
+		return fmt.Errorf("%s: unsupported type: %s", name, dataKind)
 	}
 
 	// If we reached here, then we successfully decoded SOMETHING, so
@@ -165,6 +160,21 @@
 	return err
 }
 
+func (d *Decoder) getKind(val reflect.Value) reflect.Kind {
+	kind := val.Kind()
+
+	switch {
+	case kind >= reflect.Int && kind <= reflect.Int64:
+		return reflect.Int
+	case kind >= reflect.Uint && kind <= reflect.Uint64:
+		return reflect.Uint
+	case kind >= reflect.Float32 && kind <= reflect.Float64:
+		return reflect.Float32
+	default:
+		return kind
+	}
+}
+
 // This decodes a basic type (bool, int, string, etc.) and sets the
 // value to "data" of that type.
 func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value) error {
@@ -182,47 +192,59 @@
 
 func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) error {
 	dataVal := reflect.ValueOf(data)
-	dataKind := dataVal.Kind()
-	if dataKind >= reflect.Int && dataKind <= reflect.Int64 {
-		dataKind = reflect.Int
-	} else if dataKind >= reflect.Uint && dataKind <= reflect.Uint64 {
-		dataKind = reflect.Uint
-	} else if dataKind >= reflect.Float32 && dataKind <= reflect.Float64 {
-		dataKind = reflect.Float32
-	} else {
+	dataKind := d.getKind(dataVal)
+
+	switch dataKind {
+	case reflect.Int:
+		val.SetInt(dataVal.Int())
+	case reflect.Uint:
+		val.SetInt(int64(dataVal.Uint()))
+	case reflect.Float32:
+		val.SetInt(int64(dataVal.Float()))
+	default:
 		return fmt.Errorf(
 			"'%s' expected type '%s', got unconvertible type '%s'",
 			name, val.Type(), dataVal.Type())
 	}
 
-	valKind := val.Kind()
-	if valKind >= reflect.Int && valKind <= reflect.Int64 {
-		valKind = reflect.Int
-	} else if valKind >= reflect.Uint && valKind <= reflect.Uint64 {
-		valKind = reflect.Uint
-	}
+	return nil
+}
+
+func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.ValueOf(data)
+	dataKind := d.getKind(dataVal)
 
 	switch dataKind {
 	case reflect.Int:
-		if valKind == reflect.Int {
-			val.SetInt(dataVal.Int())
-		} else {
-			val.SetUint(uint64(dataVal.Int()))
-		}
+		val.SetUint(uint64(dataVal.Int()))
 	case reflect.Uint:
-		if valKind == reflect.Int {
-			val.SetInt(int64(dataVal.Uint()))
-		} else {
-			val.SetUint(dataVal.Uint())
-		}
+		val.SetUint(dataVal.Uint())
 	case reflect.Float32:
-		if valKind == reflect.Int {
-			val.SetInt(int64(dataVal.Float()))
-		} else {
-			val.SetUint(uint64(dataVal.Float()))
-		}
+		val.SetUint(uint64(dataVal.Float()))
 	default:
-		panic("should never reach")
+		return fmt.Errorf(
+			"'%s' expected type '%s', got unconvertible type '%s'",
+			name, val.Type(), dataVal.Type())
+	}
+
+	return nil
+}
+
+func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.ValueOf(data)
+	dataKind := d.getKind(dataVal)
+
+	switch dataKind {
+	case reflect.Int:
+		val.SetFloat(float64(dataVal.Int()))
+	case reflect.Uint:
+		val.SetFloat(float64(dataVal.Uint()))
+	case reflect.Float32:
+		val.SetFloat(float64(dataVal.Float()))
+	default:
+		return fmt.Errorf(
+			"'%s' expected type '%s', got unconvertible type '%s'",
+			name, val.Type(), dataVal.Type())
 	}
 
 	return nil

mapstructure_test.go

diff --git a/mapstructure_test.go b/mapstructure_test.go
index 5f359c2..f459ca8 100644
--- a/mapstructure_test.go
+++ b/mapstructure_test.go
@@ -10,6 +10,7 @@
 	Vint    int
 	Vuint   uint
 	Vbool   bool
+	Vfloat  float64
 	Vextra  string
 	vsilent bool
 	Vdata   interface{}
@@ -61,6 +62,7 @@
 		"vint":    42,
 		"Vuint":   42,
 		"vbool":   true,
+		"Vfloat":  42.42,
 		"vsilent": true,
 		"vdata":   42,
 	}
@@ -88,6 +90,10 @@
 		t.Errorf("vbool value should be true: %#v", result.Vbool)
 	}
 
+	if result.Vfloat != 42.42 {
+		t.Errorf("vfloat value should be 42.42: %#v", result.Vfloat)
+	}
+
 	if result.Vextra != "" {
 		t.Errorf("vextra value should be empty: %#v", result.Vextra)
 	}