Fix failing type conversation

CHANGELOG.md

@@ -13,6 +13,9 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ### Removed
 
 ### Fixed
+- Fix int/uint to float type conversation. #68
+- Fix primitive type unpacking for variables expanded from environment variables
+  or strings read/created by config file parsers. #67
 
 ## [0.3.6]
 

reify.go

@@ -521,6 +521,13 @@ func doReifyPrimitive(
 		}
 		return v, nil
 
+	case isFloat(kind):
+		v, err := reifyFloat(opts, val, baseType)
+		if err != nil {
+			return v, err
+		}
+		return v, nil
+
 	case kind == reflect.Bool:
 		v, err := reifyBool(opts, val, baseType)
 		if err != nil {
@@ -624,6 +631,23 @@ func reifyUint(
 	return reflect.ValueOf(u).Convert(t), nil
 }
 
+func reifyFloat(
+	opts fieldOptions,
+	val value,
+	t reflect.Type,
+) (reflect.Value, Error) {
+	f, err := val.toFloat(opts.opts)
+	if err != nil {
+		return reflect.Value{}, raiseConversion(opts.opts, val, err, "float")
+	}
+
+	tmp := reflect.Zero(t)
+	if tmp.OverflowFloat(f) {
+		return reflect.Value{}, raiseConversion(opts.opts, val, ErrOverflow, "float")
+	}
+	return reflect.ValueOf(f).Convert(t), nil
+}
+
 func reifyBool(
 	opts fieldOptions,
 	val value,

reify_test.go

@@ -144,6 +144,98 @@ func TestUnpackPrimitiveValues(t *testing.T) {
 	}
 }
 
+func TestUnpackPrimitivesValuesResolve(t *testing.T) {
+	tests := []interface{}{
+		New(),
+		&map[string]interface{}{},
+		map[string]interface{}{},
+		node{},
+		&node{},
+		&struct {
+			B bool
+			I int
+			U uint
+			F float64
+			S string
+		}{},
+		&struct {
+			B interface{}
+			I interface{}
+			U interface{}
+			F interface{}
+			S interface{}
+		}{},
+		&struct {
+			B *bool
+			I *int
+			U *uint
+			F *float64
+			S *string
+		}{},
+	}
+
+	cfgOpts := []Option{
+		VarExp,
+		Resolve(func(name string) (string, error) {
+			return map[string]string{
+				"v_b": "true",
+				"v_i": "42",
+				"v_u": "23",
+				"v_f": "3.14",
+				"v_s": "string",
+			}[name], nil
+		}),
+	}
+
+	c, _ := NewFrom(node{
+		"b": "${v_b}",
+		"i": "${v_i}",
+		"u": "${v_u}",
+		"f": "${v_f}",
+		"s": "${v_s}",
+	}, cfgOpts...)
+
+	for i, out := range tests {
+		t.Logf("test unpack primitives(%v) into: %v", i, out)
+		err := c.Unpack(out, cfgOpts...)
+		if err != nil {
+			t.Fatalf("failed to unpack: %v", err)
+		}
+	}
+
+	// validate content by merging struct
+	for i, in := range tests {
+		t.Logf("test unpack primitives(%v) check: %v", i, in)
+
+		c, err := NewFrom(in, cfgOpts...)
+		if err != nil {
+			t.Errorf("failed")
+			continue
+		}
+
+		b, err := c.Bool("b", -1, cfgOpts...)
+		assert.NoError(t, err)
+
+		i, err := c.Int("i", -1, cfgOpts...)
+		assert.NoError(t, err)
+
+		u, err := c.Uint("u", -1, cfgOpts...)
+		assert.NoError(t, err)
+
+		f, err := c.Float("f", -1, cfgOpts...)
+		assert.NoError(t, err)
+
+		s, err := c.String("s", -1, cfgOpts...)
+		assert.NoError(t, err)
+
+		assert.Equal(t, true, b)
+		assert.Equal(t, 42, int(i))
+		assert.Equal(t, 23, int(u))
+		assert.Equal(t, 3.14, f)
+		assert.Equal(t, "string", s)
+	}
+}
+
 func TestUnpackNested(t *testing.T) {
 	var genSub = func(name string) *Config {
 		s := New()

types.go

@@ -195,6 +195,7 @@ func (c *cfgBool) typ(*options) (typeInfo, error)          { return typeInfo{"bo
 
 func (c *cfgInt) cpy(ctx context) value                   { return newInt(ctx, c.meta(), c.i) }
 func (c *cfgInt) toInt(*options) (int64, error)           { return c.i, nil }
+func (c *cfgInt) toFloat(*options) (float64, error)       { return float64(c.i), nil }
 func (c *cfgInt) reflect(*options) (reflect.Value, error) { return reflect.ValueOf(c.i), nil }
 func (c *cfgInt) reify(*options) (interface{}, error)     { return c.i, nil }
 func (c *cfgInt) toString(*options) (string, error)       { return fmt.Sprintf("%d", c.i), nil }
@@ -212,6 +213,7 @@ func (c *cfgUint) reify(*options) (interface{}, error)     { return c.u, nil }
 func (c *cfgUint) toString(*options) (string, error)       { return fmt.Sprintf("%d", c.u), nil }
 func (c *cfgUint) typ(*options) (typeInfo, error)          { return typeInfo{"uint", tUint64}, nil }
 func (c *cfgUint) toUint(*options) (uint64, error)         { return c.u, nil }
+func (c *cfgUint) toFloat(*options) (float64, error)       { return float64(c.u), nil }
 func (c *cfgUint) toInt(*options) (int64, error) {
 	if c.u > math.MaxInt64 {
 		return 0, ErrOverflow
@@ -243,13 +245,17 @@ func (c *cfgFloat) toInt(*options) (int64, error) {
 	return int64(c.f), nil
 }
 
-func (c *cfgString) cpy(ctx context) value             { return newString(ctx, c.meta(), c.s) }
-func (c *cfgString) toString(*options) (string, error) { return c.s, nil }
+func (c *cfgString) cpy(ctx context) value { return newString(ctx, c.meta(), c.s) }
 func (c *cfgString) reflect(*options) (reflect.Value, error) {
 	return reflect.ValueOf(c.s), nil
 }
 func (c *cfgString) reify(*options) (interface{}, error) { return c.s, nil }
 func (c *cfgString) typ(*options) (typeInfo, error)      { return typeInfo{"string", tString}, nil }
+func (c *cfgString) toBool(*options) (bool, error)       { return strconv.ParseBool(c.s) }
+func (c *cfgString) toString(*options) (string, error)   { return c.s, nil }
+func (c *cfgString) toInt(*options) (int64, error)       { return strconv.ParseInt(c.s, 0, 64) }
+func (c *cfgString) toUint(*options) (uint64, error)     { return strconv.ParseUint(c.s, 0, 64) }
+func (c *cfgString) toFloat(*options) (float64, error)   { return strconv.ParseFloat(c.s, 64) }
 
 func (c cfgSub) Context() context                   { return c.c.ctx }
 func (cfgSub) toBool(*options) (bool, error)        { return false, ErrTypeMismatch }

util.go

@@ -123,6 +123,15 @@ func isUint(k reflect.Kind) bool {
 	}
 }
 
+func isFloat(k reflect.Kind) bool {
+	switch k {
+	case reflect.Float32, reflect.Float64:
+		return true
+	default:
+		return false
+	}
+}
+
 func implementsUnpacker(v reflect.Value) (reflect.Value, bool) {
 	for {
 		if v.Type().Implements(tUnpacker) {